adaptors/x11/event-handler-x.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_X.h>
  25
  26 #include <X11/Xlib.h>
  27 #include <X11/extensions/XInput2.h>
  28 #include <X11/extensions/XI2.h>
  29
  30 #include <cstring>
  31
  32 #include <sys/time.h>
  33
  34 #ifndef DALI_PROFILE_UBUNTU
  35 #include <vconf.h>
  36 #include <vconf-keys.h>
  37 #endif // DALI_PROFILE_UBUNTU
  38
  39 #ifdef DALI_ELDBUS_AVAILABLE
  40 #include <Eldbus.h>
  41 #endif // DALI_ELDBUS_AVAILABLE
  42
  43 #include <dali/public-api/common/vector-wrapper.h>
  44 #include <dali/public-api/events/touch-point.h>
  45 #include <dali/public-api/events/key-event.h>
  46 #include <dali/public-api/events/wheel-event.h>
  47 #include <dali/integration-api/debug.h>
  48 #include <dali/integration-api/events/key-event-integ.h>
  49 #include <dali/integration-api/events/touch-event-integ.h>
  50 #include <dali/integration-api/events/hover-event-integ.h>
  51 #include <dali/integration-api/events/wheel-event-integ.h>
  52
  53 // INTERNAL INCLUDES
  54 #include <events/gesture-manager.h>
  55 #include <window-render-surface.h>
  56 #include <clipboard-impl.h>
  57 #include <key-impl.h>
  58 #include <physical-keyboard-impl.h>
  59 #include <style-monitor-impl.h>
  60 #include <base/core-event-interface.h>
  61
  62 namespace Dali
  63 {
  64
  65 namespace Internal
  66 {
  67
  68 namespace Adaptor
  69 {
  70
  71 #if defined(DEBUG_ENABLED)
  72 namespace
  73 {
  74 Integration::Log::Filter* gTouchEventLogFilter  = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_TOUCH");
  75 Integration::Log::Filter* gClientMessageLogFilter  = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_CLIENT_MESSAGE");
  76 Integration::Log::Filter* gDragAndDropLogFilter = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_DND");
  77 Integration::Log::Filter* gImfLogging  = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_IMF");
  78 Integration::Log::Filter* gSelectionEventLogFilter = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_SELECTION");
  79 } // unnamed namespace
  80 #endif
  81
  82
  83 namespace
  84 {
  85
  86 const char * DETENT_DEVICE_NAME = "tizen_detent";
  87
  88 // DBUS accessibility
  89 #define A11Y_BUS "org.a11y.Bus"
  90 #define A11Y_INTERFACE "org.a11y.Bus"
  91 #define A11Y_PATH "/org/a11y/bus"
  92 #define A11Y_GET_ADDRESS "GetAddress"
  93 #define BUS "com.samsung.EModule"
  94 #define INTERFACE "com.samsung.GestureNavigation"
  95 #define PATH "/com/samsung/GestureNavigation"
  96 #define SIGNAL "GestureDetected"
  97
  98 #ifndef DALI_PROFILE_UBUNTU
  99 const char * DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME = "db/setting/accessibility/font_name"; // It will be update at vconf-key.h and replaced.
 100 #endif // DALI_PROFILE_UBUNTU
 101
 102 const unsigned int PRIMARY_TOUCH_BUTTON_ID( 1 );
 103
 104 #ifndef DALI_PROFILE_UBUNTU
 105 const char * CLIPBOARD_ATOM                = "CBHM_MSG";
 106 const char * CLIPBOARD_SET_OWNER_MESSAGE   = "SET_OWNER";
 107 #endif // DALI_PROFILE_UBUNTU
 108
 109 /// The atoms required by Ecore for Drag & Drop behaviour.
 110 Ecore_X_Atom DRAG_AND_DROP_ATOMS[] =
 111 {
 112   ECORE_X_ATOM_XDND_ACTION_COPY,
 113 };
 114
 115 /// The types that we support.
 116 const char * DRAG_AND_DROP_TYPES[] =
 117 {
 118   ECORE_X_SELECTION_TARGET_UTF8_STRING,
 119 };
 120
 121 const unsigned int DRAG_AND_DROP_ATOMS_NUMBER = sizeof( DRAG_AND_DROP_ATOMS ) / sizeof( Ecore_X_Atom );
 122 const unsigned int DRAG_AND_DROP_TYPES_NUMBER = sizeof( DRAG_AND_DROP_TYPES ) / sizeof( const char * );
 123
 124 const unsigned int BYTES_PER_CHARACTER_FOR_ATTRIBUTES = 3;
 125
 126 #ifdef DALI_ELDBUS_AVAILABLE
 127 // DBus gesture string matching lists.
 128 // TODO: This needs moving to its own module.
 129 const char * ElDBusAccessibilityFingerCountStrings[] =
 130 {
 131   "OneFinger",
 132   "TwoFingers",
 133   "ThreeFingers"
 134 };
 135 const unsigned int FingerCountStringsTotal = sizeof( ElDBusAccessibilityFingerCountStrings ) / sizeof( ElDBusAccessibilityFingerCountStrings[0] );
 136 enum GestureType
 137 {
 138   GESTURE_TYPE_NONE,
 139   GESTURE_TYPE_HOVER,
 140   GESTURE_TYPE_SINGLE_TAP,
 141   GESTURE_TYPE_DOUBLE_TAP,
 142   GESTURE_TYPE_TRIPLE_TAP
 143 };
 144 struct GestureTypeTable
 145 {
 146   const char* name;
 147   const GestureType type;
 148 };
 149 GestureTypeTable ElDBusAccessibilityFullEventTypeStrings[] =
 150 {
 151   { "Hover",     GESTURE_TYPE_HOVER      },
 152   { "SingleTap", GESTURE_TYPE_SINGLE_TAP },
 153   { "DoubleTap", GESTURE_TYPE_DOUBLE_TAP },
 154   { "TripleTap", GESTURE_TYPE_TRIPLE_TAP }
 155 };
 156 const unsigned int FullEventTypeStringsTotal = sizeof( ElDBusAccessibilityFullEventTypeStrings ) / sizeof( ElDBusAccessibilityFullEventTypeStrings[0] );
 157 enum SubGestureType
 158 {
 159   SUB_GESTURE_TYPE_NONE,
 160   SUB_GESTURE_TYPE_FLICK
 161 };
 162 struct SubGestureTypeTable
 163 {
 164   const char* name;
 165   const SubGestureType type;
 166 };
 167 SubGestureTypeTable ElDBusAccessibilityDirectionalEventTypeStrings[] =
 168 {
 169   { "Flick", SUB_GESTURE_TYPE_FLICK }
 170 };
 171 const unsigned int DirectionalEventTypeStringsTotal = sizeof( ElDBusAccessibilityDirectionalEventTypeStrings ) / sizeof( ElDBusAccessibilityDirectionalEventTypeStrings[0] );
 172 enum GestureDirection
 173 {
 174   GESTURE_DIRECTION_NONE,
 175   GESTURE_DIRECTION_UP,
 176   GESTURE_DIRECTION_DOWN,
 177   GESTURE_DIRECTION_LEFT,
 178   GESTURE_DIRECTION_RIGHT,
 179   GESTURE_DIRECTION_UP_RETURN,
 180   GESTURE_DIRECTION_DOWN_RETURN,
 181   GESTURE_DIRECTION_LEFT_RETURN,
 182   GESTURE_DIRECTION_RIGHT_RETURN
 183 };
 184 struct GestureDirectionTable
 185 {
 186         const char* name;
 187         const GestureDirection direction;
 188 };
 189 GestureDirectionTable ElDBusAccessibilityDirectionStrings[] =
 190 {
 191   { "Up",           GESTURE_DIRECTION_UP           },
 192   { "Down",         GESTURE_DIRECTION_DOWN         },
 193   { "Left",         GESTURE_DIRECTION_LEFT         },
 194   { "Right",        GESTURE_DIRECTION_RIGHT        },
 195   { "UpReturn",     GESTURE_DIRECTION_UP_RETURN    },
 196   { "DownReturn",   GESTURE_DIRECTION_DOWN_RETURN  },
 197   { "LeftReturn",   GESTURE_DIRECTION_LEFT_RETURN  },
 198   { "RightReturn",  GESTURE_DIRECTION_RIGHT_RETURN }
 199 };
 200 const unsigned int DirectionStringsTotal = sizeof( ElDBusAccessibilityDirectionStrings ) / sizeof( ElDBusAccessibilityDirectionStrings[0] );
 201 #endif // DALI_ELDBUS_AVAILABLE
 202
 203 /**
 204  * Ecore_Event_Modifier enums in Ecore_Input.h do not match Ecore_IMF_Keyboard_Modifiers in Ecore_IMF.h.
 205  * This function converts from Ecore_Event_Modifier to Ecore_IMF_Keyboard_Modifiers enums.
 206  * @param[in] ecoreModifier the Ecore_Event_Modifier input.
 207  * @return the Ecore_IMF_Keyboard_Modifiers output.
 208  */
 209 Ecore_IMF_Keyboard_Modifiers EcoreInputModifierToEcoreIMFModifier(unsigned int ecoreModifier)
 210 {
 211    int modifier( ECORE_IMF_KEYBOARD_MODIFIER_NONE );  // If no other matches returns NONE.
 212
 213
 214    if ( ecoreModifier & ECORE_EVENT_MODIFIER_SHIFT )  // enums from ecore_input/Ecore_Input.h
 215    {
 216      modifier |= ECORE_IMF_KEYBOARD_MODIFIER_SHIFT;  // enums from ecore_imf/ecore_imf.h
 217    }
 218
 219    if ( ecoreModifier & ECORE_EVENT_MODIFIER_ALT )
 220    {
 221      modifier |= ECORE_IMF_KEYBOARD_MODIFIER_ALT;
 222    }
 223
 224    if ( ecoreModifier & ECORE_EVENT_MODIFIER_CTRL )
 225    {
 226      modifier |= ECORE_IMF_KEYBOARD_MODIFIER_CTRL;
 227    }
 228
 229    if ( ecoreModifier & ECORE_EVENT_MODIFIER_WIN )
 230    {
 231      modifier |= ECORE_IMF_KEYBOARD_MODIFIER_WIN;
 232    }
 233
 234    if ( ecoreModifier & ECORE_EVENT_MODIFIER_ALTGR )
 235    {
 236      modifier |= ECORE_IMF_KEYBOARD_MODIFIER_ALTGR;
 237    }
 238
 239    return static_cast<Ecore_IMF_Keyboard_Modifiers>( modifier );
 240 }
 241
 242
 243 // Copied from x server
 244 static unsigned int GetCurrentMilliSeconds(void)
 245 {
 246   struct timeval tv;
 247
 248   struct timespec tp;
 249   static clockid_t clockid;
 250
 251   if (!clockid)
 252   {
 253 #ifdef CLOCK_MONOTONIC_COARSE
 254     if (clock_getres(CLOCK_MONOTONIC_COARSE, &tp) == 0 &&
 255       (tp.tv_nsec / 1000) <= 1000 && clock_gettime(CLOCK_MONOTONIC_COARSE, &tp) == 0)
 256     {
 257       clockid = CLOCK_MONOTONIC_COARSE;
 258     }
 259     else
 260 #endif
 261     if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0)
 262     {
 263       clockid = CLOCK_MONOTONIC;
 264     }
 265     else
 266     {
 267       clockid = ~0L;
 268     }
 269   }
 270   if (clockid != ~0L && clock_gettime(clockid, &tp) == 0)
 271   {
 272     return (tp.tv_sec * 1000) + (tp.tv_nsec / 1000000L);
 273   }
 274
 275   gettimeofday(&tv, NULL);
 276   return (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
 277 }
 278
 279 } // unnamed namespace
 280
 281 // Impl to hide EFL implementation.
 282 struct EventHandler::Impl
 283 {
 284   // Construction & Destruction
 285
 286   /**
 287    * Constructor
 288    */
 289   Impl( EventHandler* handler, Ecore_X_Window window )
 290   : mHandler( handler ),
 291     mEcoreEventHandler(),
 292     mWindow( window ),
 293     mXiDeviceId( 0 )
 294   {
 295     // Only register for touch and key events if we have a window
 296     if ( window != 0 )
 297     {
 298       // Register Touch events
 299       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_DOWN,  EcoreEventMouseButtonDown, handler ) );
 300       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_UP,    EcoreEventMouseButtonUp,   handler ) );
 301       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_MOVE,         EcoreEventMouseButtonMove, handler ) );
 302       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_OUT,          EcoreEventMouseButtonUp,   handler ) ); // process mouse out event like up event
 303
 304       // Register Mouse wheel events
 305       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_WHEEL,        EcoreEventMouseWheel,      handler ) );
 306
 307       // Register Key events
 308       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_KEY_DOWN,           EcoreEventKeyDown,         handler ) );
 309       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_KEY_UP,             EcoreEventKeyUp,           handler ) );
 310
 311       // Register Focus events
 312       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_X_EVENT_WINDOW_FOCUS_IN,  EcoreEventWindowFocusIn,   handler ) );
 313       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_X_EVENT_WINDOW_FOCUS_OUT, EcoreEventWindowFocusOut,  handler ) );
 314
 315       // Register Window damage events
 316       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_X_EVENT_WINDOW_DAMAGE,    EcoreEventWindowDamaged, handler ) );
 317
 318       // Enable Drag & Drop and register DnD events
 319       ecore_x_dnd_aware_set( window, EINA_TRUE );
 320       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_X_EVENT_XDND_ENTER,       EcoreEventDndEnter,            handler) );
 321       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_X_EVENT_XDND_POSITION,    EcoreEventDndPosition,         handler) );
 322       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_X_EVENT_XDND_LEAVE,       EcoreEventDndLeave,            handler) );
 323       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_X_EVENT_XDND_DROP,        EcoreEventDndDrop,             handler) );
 324       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_X_EVENT_XDND_FINISHED,    EcoreEventDndFinished,         handler) );
 325       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_X_EVENT_XDND_STATUS,      EcoreEventDndStatus,           handler) );
 326
 327       // Register Client message events - accessibility etc.
 328       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_X_EVENT_CLIENT_MESSAGE,  EcoreEventClientMessage, handler ) );
 329
 330       // Register Selection event - clipboard selection, Drag & Drop selection etc.
 331       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_X_EVENT_SELECTION_CLEAR, EcoreEventSelectionClear, handler ) );
 332       mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_X_EVENT_SELECTION_NOTIFY, EcoreEventSelectionNotify, handler ) );
 333
 334       // Initialize Xi2 system
 335       Display* display = static_cast< Display* >(ecore_x_display_get());
 336       Ecore_X_Window rootWindow = ecore_x_window_root_first_get();
 337       int opcode = 0, event = 0, error = 0;
 338       int major = XI_2_Major;
 339       int minor = XI_2_Minor;
 340       int deviceCount = 0;
 341       XIEventMask xiEventMask;
 342
 343       // Check if X input extension available
 344       if( XQueryExtension( display, "XInputExtension", &opcode, &event, &error ) )
 345       {
 346         // We support version 2.0
 347         if( XIQueryVersion( display, &major, &minor ) != BadRequest )
 348         {
 349           xiEventMask.deviceid = XIAllDevices;
 350
 351           // Check device id
 352           bool match = false;
 353           XIDeviceInfo* deviceInfo = NULL;
 354           deviceInfo = XIQueryDevice( display, XIAllDevices, &deviceCount );
 355
 356           for( int i = 0; i < deviceCount; i++ )
 357           {
 358             if( !strncmp( deviceInfo[i].name, DETENT_DEVICE_NAME, strlen( DETENT_DEVICE_NAME ) ) )
 359             {
 360               xiEventMask.deviceid = deviceInfo[i].deviceid;
 361               match = true;
 362               break;
 363             }
 364           }
 365
 366           if( match )
 367           {
 368             mXiDeviceId = xiEventMask.deviceid;
 369
 370             // SelectXi2Event
 371             xiEventMask.mask = (unsigned char*)(calloc( 1, XIMaskLen( XI_LASTEVENT ) ) );
 372             XISetMask( xiEventMask.mask, XI_RawMotion );
 373
 374             xiEventMask.mask_len = sizeof( xiEventMask.mask );
 375
 376             int ret = XISelectEvents( display, rootWindow, &xiEventMask, 1 );
 377             if( ret == 0 )
 378             {
 379               // Register custom wheel events
 380               mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_X_EVENT_GENERIC, EcoreEventCustomWheel, handler ) );
 381             }
 382             else
 383             {
 384               DALI_LOG_INFO( gImfLogging, Debug::General, "Failed to Select Events\n" );
 385             }
 386           }
 387         }
 388         else
 389         {
 390           DALI_LOG_INFO( gImfLogging, Debug::General, "Failed to query XI Version\n" );
 391         }
 392       }
 393       else
 394       {
 395         DALI_LOG_INFO( gImfLogging, Debug::General, "Failed to query XInputExtension\n" );
 396       }
 397
 398 #ifndef DALI_PROFILE_UBUNTU
 399       // Register Vconf notify - font name, font size and style
 400       vconf_notify_key_changed( DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged, handler );
 401       vconf_notify_key_changed( VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged, handler );
 402 #endif // DALI_PROFILE_UBUNTU
 403
 404 #ifdef DALI_ELDBUS_AVAILABLE
 405
 406       // Initialize ElDBus.
 407       DALI_LOG_INFO( gImfLogging, Debug::General, "Starting DBus Initialization" );
 408       eldbus_init();
 409
 410       Eldbus_Connection *sessionConnection;
 411       sessionConnection = eldbus_connection_get( ELDBUS_CONNECTION_TYPE_SESSION );
 412
 413       Eldbus_Object *a11yObject = eldbus_object_get( sessionConnection, A11Y_BUS, A11Y_PATH );
 414       Eldbus_Proxy *elDBusManager = eldbus_proxy_get( a11yObject, A11Y_INTERFACE );
 415
 416       // Pass in handler in the cb_data field so we can access the accessibility adaptor within the callback.
 417       eldbus_proxy_call( elDBusManager, A11Y_GET_ADDRESS, EcoreElDBusInitialisation, handler, -1, "" );
 418
 419       DALI_LOG_INFO( gImfLogging, Debug::General, "Finished DBus Initialization" );
 420
 421 #endif // DALI_ELDBUS_AVAILABLE
 422     }
 423   }
 424
 425   /**
 426    * Destructor
 427    */
 428   ~Impl()
 429   {
 430 #ifndef DALI_PROFILE_UBUNTU
 431     vconf_ignore_key_changed( VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged );
 432     vconf_ignore_key_changed( DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_NAME, VconfNotifyFontNameChanged );
 433 #endif // DALI_PROFILE_UBUNTU
 434
 435     for( std::vector<Ecore_Event_Handler*>::iterator iter = mEcoreEventHandler.begin(), endIter = mEcoreEventHandler.end(); iter != endIter; ++iter )
 436     {
 437       ecore_event_handler_del( *iter );
 438     }
 439
 440 #ifdef DALI_ELDBUS_AVAILABLE
 441     // Close down ElDBus
 442     eldbus_shutdown();
 443 #endif // DALI_ELDBUS_AVAILABLE
 444   }
 445
 446   // Static methods
 447
 448   /////////////////////////////////////////////////////////////////////////////////////////////////
 449   // Touch Callbacks
 450   /////////////////////////////////////////////////////////////////////////////////////////////////
 451
 452   /**
 453    * Called when a touch down is received.
 454    */
 455   static Eina_Bool EcoreEventMouseButtonDown( void* data, int type, void* event )
 456   {
 457     Ecore_Event_Mouse_Button *touchEvent( (Ecore_Event_Mouse_Button*)event );
 458     EventHandler* handler( (EventHandler*)data );
 459
 460     if ( touchEvent->window == handler->mImpl->mWindow )
 461     {
 462       TouchPoint::State state ( TouchPoint::Down );
 463
 464       // Check if the buttons field is set and ensure it's the primary touch button.
 465       // If this event was triggered by buttons other than the primary button (used for touch), then
 466       // just send an interrupted event to Core.
 467       if ( touchEvent->buttons && (touchEvent->buttons != PRIMARY_TOUCH_BUTTON_ID ) )
 468       {
 469         state = TouchPoint::Interrupted;
 470       }
 471
 472       TouchPoint point( touchEvent->multi.device, state, touchEvent->x, touchEvent->y );
 473       handler->SendEvent( point, touchEvent->timestamp );
 474     }
 475
 476     return ECORE_CALLBACK_PASS_ON;
 477   }
 478
 479   /**
 480    * Called when a touch up is received.
 481    */
 482   static Eina_Bool EcoreEventMouseButtonUp( void* data, int type, void* event )
 483   {
 484     Ecore_Event_Mouse_Button *touchEvent( (Ecore_Event_Mouse_Button*)event );
 485     EventHandler* handler( (EventHandler*)data );
 486
 487     if ( touchEvent->window == handler->mImpl->mWindow )
 488     {
 489       TouchPoint point( touchEvent->multi.device, TouchPoint::Up, touchEvent->x, touchEvent->y );
 490       handler->SendEvent( point, touchEvent->timestamp );
 491     }
 492
 493     return ECORE_CALLBACK_PASS_ON;
 494   }
 495
 496   /**
 497    * Called when a touch motion is received.
 498    */
 499   static Eina_Bool EcoreEventMouseButtonMove( void* data, int type, void* event )
 500   {
 501     Ecore_Event_Mouse_Move *touchEvent( (Ecore_Event_Mouse_Move*)event );
 502     EventHandler* handler( (EventHandler*)data );
 503
 504     if ( touchEvent->window == handler->mImpl->mWindow )
 505     {
 506       TouchPoint point( touchEvent->multi.device, TouchPoint::Motion, touchEvent->x, touchEvent->y );
 507       handler->SendEvent( point, touchEvent->timestamp );
 508     }
 509
 510     return ECORE_CALLBACK_PASS_ON;
 511   }
 512
 513   /////////////////////////////////////////////////////////////////////////////////////////////////
 514   // Wheel Callbacks
 515   /////////////////////////////////////////////////////////////////////////////////////////////////
 516
 517   /**
 518    * Called when a mouse wheel is received.
 519    */
 520   static Eina_Bool EcoreEventMouseWheel( void* data, int type, void* event )
 521   {
 522     Ecore_Event_Mouse_Wheel *mouseWheelEvent( (Ecore_Event_Mouse_Wheel*)event );
 523
 524     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 );
 525
 526     EventHandler* handler( (EventHandler*)data );
 527     if ( mouseWheelEvent->window == handler->mImpl->mWindow )
 528     {
 529       WheelEvent wheelEvent( WheelEvent::MOUSE_WHEEL, mouseWheelEvent->direction, mouseWheelEvent->modifiers, Vector2(mouseWheelEvent->x, mouseWheelEvent->y), mouseWheelEvent->z, mouseWheelEvent->timestamp );
 530       handler->SendWheelEvent( wheelEvent );
 531     }
 532     return ECORE_CALLBACK_PASS_ON;
 533   }
 534
 535   /**
 536    * Called when a custom wheel is received.
 537    */
 538   static Eina_Bool EcoreEventCustomWheel( void* data, int type, void* event )
 539   {
 540     Ecore_X_Event_Generic *genericEvent( (Ecore_X_Event_Generic*)event );
 541     EventHandler* handler( (EventHandler*)data );
 542
 543     switch( genericEvent->evtype )
 544     {
 545       case XI_RawMotion:
 546       {
 547         XIRawEvent* xiRawEvent = static_cast< XIRawEvent* >( genericEvent->data );
 548         unsigned int timeStamp = 0;
 549
 550         if( xiRawEvent->deviceid != handler->mImpl->mXiDeviceId )
 551         {
 552           return ECORE_CALLBACK_PASS_ON;
 553         }
 554
 555         // X(0): rotate: NOT USED
 556         // Y(1): timestamp
 557         // Z(2): direction
 558
 559         double* value = xiRawEvent->raw_values;
 560
 561         if( XIMaskIsSet( xiRawEvent->valuators.mask, 1) )
 562         {
 563           timeStamp = static_cast< unsigned int >( *(value + 1) );
 564         }
 565
 566         if( XIMaskIsSet( xiRawEvent->valuators.mask, 2) )
 567         {
 568           // if z == 1, clockwise
 569           // otherwise counter-clockwise
 570           int z = static_cast< int >( *(value + 2) );
 571
 572           // In DALi, positive value means clockwise, and negative value means counter-clockwise
 573           if( z == 0 )
 574           {
 575             z = -1;
 576           }
 577
 578           DALI_LOG_INFO( gImfLogging, Debug::General, "EVENT EcoreEventCustomWheel: z: %d\n", z );
 579
 580           WheelEvent wheelEvent( WheelEvent::CUSTOM_WHEEL, 0, 0, Vector2(0.0f, 0.0f), z, timeStamp );
 581           handler->SendWheelEvent( wheelEvent );
 582         }
 583         break;
 584       }
 585       default:
 586       {
 587         break;
 588       }
 589     }
 590
 591     return ECORE_CALLBACK_PASS_ON;
 592   }
 593
 594   /////////////////////////////////////////////////////////////////////////////////////////////////
 595   // Key Callbacks
 596   /////////////////////////////////////////////////////////////////////////////////////////////////
 597
 598   /**
 599    * Called when a key down is received.
 600    */
 601   static Eina_Bool EcoreEventKeyDown( void* data, int type, void* event )
 602   {
 603     DALI_LOG_INFO( gImfLogging, Debug::General, "EVENT >>EcoreEventKeyDown \n" );
 604
 605     EventHandler* handler( (EventHandler*)data );
 606     Ecore_Event_Key *keyEvent( (Ecore_Event_Key*)event );
 607     bool eventHandled( false );
 608
 609     // If a device key then skip ecore_imf_context_filter_event.
 610     if ( ! KeyLookup::IsDeviceButton( keyEvent->keyname ) )
 611     {
 612       Ecore_IMF_Context* imfContext = NULL;
 613       Dali::ImfManager imfManager( ImfManager::Get() );
 614       if ( imfManager )
 615       {
 616         imfContext = reinterpret_cast<Ecore_IMF_Context*>( imfManager.GetContext() );
 617       }
 618
 619       if ( imfContext )
 620       {
 621         // We're consuming key down event so we have to pass to IMF so that it can parse it as well.
 622         Ecore_IMF_Event_Key_Down ecoreKeyDownEvent;
 623         ecoreKeyDownEvent.keyname   = keyEvent->keyname;
 624         ecoreKeyDownEvent.key       = keyEvent->key;
 625         ecoreKeyDownEvent.string    = keyEvent->string;
 626         ecoreKeyDownEvent.compose   = keyEvent->compose;
 627         ecoreKeyDownEvent.timestamp = keyEvent->timestamp;
 628         ecoreKeyDownEvent.modifiers = EcoreInputModifierToEcoreIMFModifier ( keyEvent->modifiers );
 629         ecoreKeyDownEvent.locks     = (Ecore_IMF_Keyboard_Locks) ECORE_IMF_KEYBOARD_LOCK_NONE;
 630
 631         eventHandled = ecore_imf_context_filter_event( imfContext,
 632                                                        ECORE_IMF_EVENT_KEY_DOWN,
 633                                                        (Ecore_IMF_Event *) &ecoreKeyDownEvent );
 634
 635         // If the event has not been handled by IMF then check if we should reset our IMF context
 636         if( !eventHandled )
 637         {
 638           if ( !strcmp( keyEvent->keyname, "Escape"   ) ||
 639                !strcmp( keyEvent->keyname, "Return"   ) ||
 640                !strcmp( keyEvent->keyname, "KP_Enter" ) )
 641           {
 642             ecore_imf_context_reset( imfContext );
 643           }
 644         }
 645       }
 646     }
 647
 648     // If the event wasn't handled then we should send a key event.
 649     if ( !eventHandled )
 650     {
 651       if ( keyEvent->window == handler->mImpl->mWindow )
 652       {
 653         std::string keyName( keyEvent->keyname );
 654         std::string keyString( "" );
 655         int keyCode = ecore_x_keysym_keycode_get(keyEvent->keyname);
 656         int modifier( keyEvent->modifiers );
 657         unsigned long time = keyEvent->timestamp;
 658
 659         // Ensure key event string is not NULL as keys like SHIFT have a null string.
 660         if ( keyEvent->string )
 661         {
 662           keyString = keyEvent->string;
 663         }
 664
 665         KeyEvent keyEvent(keyName, keyString, keyCode, modifier, time, KeyEvent::Down);
 666         handler->SendEvent( keyEvent );
 667       }
 668     }
 669
 670     return ECORE_CALLBACK_PASS_ON;
 671   }
 672
 673   /**
 674    * Called when a key up is received.
 675    */
 676   static Eina_Bool EcoreEventKeyUp( void* data, int type, void* event )
 677   {
 678     DALI_LOG_INFO( gImfLogging, Debug::General, "EVENT >>EcoreEventKeyUp \n" );
 679
 680     EventHandler* handler( (EventHandler*)data );
 681     Ecore_Event_Key *keyEvent( (Ecore_Event_Key*)event );
 682     bool eventHandled( false );
 683
 684     // XF86Stop and XF86Send must skip ecore_imf_context_filter_event.
 685     if ( strcmp( keyEvent->keyname, "XF86Send"  ) &&
 686          strcmp( keyEvent->keyname, "XF86Phone" ) &&
 687          strcmp( keyEvent->keyname, "XF86Stop"  ) )
 688     {
 689       Ecore_IMF_Context* imfContext = NULL;
 690       Dali::ImfManager imfManager( ImfManager::Get() );
 691       if ( imfManager )
 692       {
 693         imfContext = reinterpret_cast<Ecore_IMF_Context*>( imfManager.GetContext() );
 694       }
 695
 696       if ( imfContext )
 697       {
 698         // We're consuming key up event so we have to pass to IMF so that it can parse it as well.
 699         Ecore_IMF_Event_Key_Up ecoreKeyUpEvent;
 700         ecoreKeyUpEvent.keyname   = keyEvent->keyname;
 701         ecoreKeyUpEvent.key       = keyEvent->key;
 702         ecoreKeyUpEvent.string    = keyEvent->string;
 703         ecoreKeyUpEvent.compose   = keyEvent->compose;
 704         ecoreKeyUpEvent.timestamp = keyEvent->timestamp;
 705         ecoreKeyUpEvent.modifiers = EcoreInputModifierToEcoreIMFModifier ( keyEvent->modifiers );
 706         ecoreKeyUpEvent.locks     = (Ecore_IMF_Keyboard_Locks) ECORE_IMF_KEYBOARD_LOCK_NONE;
 707
 708         eventHandled = ecore_imf_context_filter_event( imfContext,
 709                                                        ECORE_IMF_EVENT_KEY_UP,
 710                                                        (Ecore_IMF_Event *) &ecoreKeyUpEvent );
 711       }
 712     }
 713
 714     // If the event wasn't handled then we should send a key event.
 715     if ( !eventHandled )
 716     {
 717       if ( keyEvent->window == handler->mImpl->mWindow )
 718       {
 719         std::string keyName( keyEvent->keyname );
 720         std::string keyString( "" );
 721         int keyCode = ecore_x_keysym_keycode_get(keyEvent->keyname);
 722         int modifier( keyEvent->modifiers );
 723         unsigned long time( keyEvent->timestamp );
 724
 725         // Ensure key event string is not NULL as keys like SHIFT have a null string.
 726         if ( keyEvent->string )
 727         {
 728           keyString = keyEvent->string;
 729         }
 730
 731         KeyEvent keyEvent(keyName, keyString, keyCode, modifier, time, KeyEvent::Up);
 732         handler->SendEvent( keyEvent );
 733
 734       }
 735     }
 736
 737     return ECORE_CALLBACK_PASS_ON;
 738   }
 739
 740   /////////////////////////////////////////////////////////////////////////////////////////////////
 741   // Window Callbacks
 742   /////////////////////////////////////////////////////////////////////////////////////////////////
 743
 744   /**
 745    * Called when the window gains focus.
 746    */
 747   static Eina_Bool EcoreEventWindowFocusIn( void* data, int type, void* event )
 748   {
 749     Ecore_X_Event_Window_Focus_In* focusInEvent( (Ecore_X_Event_Window_Focus_In*)event );
 750     EventHandler* handler( (EventHandler*)data );
 751
 752     DALI_LOG_INFO( gImfLogging, Debug::General, "EVENT >>EcoreEventWindowFocusIn \n" );
 753
 754     // If the window gains focus and we hid the keyboard then show it again.
 755     if ( focusInEvent->win == handler->mImpl->mWindow )
 756     {
 757       DALI_LOG_INFO( gImfLogging, Debug::General, "EVENT EcoreEventWindowFocusIn - >>WindowFocusGained \n" );
 758
 759       if ( ImfManager::IsAvailable() /* Only get the ImfManager if it's available as we do not want to create it */ )
 760       {
 761         Dali::ImfManager imfManager( ImfManager::Get() );
 762         if ( imfManager )
 763         {
 764           ImfManager& imfManagerImpl( ImfManager::GetImplementation( imfManager ) );
 765           if( imfManagerImpl.RestoreAfterFocusLost() )
 766           {
 767             imfManagerImpl.Activate();
 768           }
 769         }
 770       }
 771       // No need to connect callbacks as KeyboardStatusChanged will be called.
 772     }
 773
 774     return ECORE_CALLBACK_PASS_ON;
 775   }
 776
 777   /**
 778    * Called when the window loses focus.
 779    */
 780   static Eina_Bool EcoreEventWindowFocusOut( void* data, int type, void* event )
 781   {
 782     Ecore_X_Event_Window_Focus_Out* focusOutEvent( (Ecore_X_Event_Window_Focus_Out*)event );
 783     EventHandler* handler( (EventHandler*)data );
 784
 785     DALI_LOG_INFO( gImfLogging, Debug::General, "EVENT >>EcoreEventWindowFocusOut \n" );
 786
 787     // If the window loses focus then hide the keyboard.
 788     if ( focusOutEvent->win == handler->mImpl->mWindow )
 789     {
 790       if ( ImfManager::IsAvailable() /* Only get the ImfManager if it's available as we do not want to create it */ )
 791       {
 792         Dali::ImfManager imfManager( ImfManager::Get() );
 793         if ( imfManager )
 794         {
 795           ImfManager& imfManagerImpl( ImfManager::GetImplementation( imfManager ) );
 796           if( imfManagerImpl.RestoreAfterFocusLost() )
 797           {
 798             imfManagerImpl.Deactivate();
 799           }
 800         }
 801       }
 802
 803       // Clipboard don't support that whether clipboard is shown or not. Hide clipboard.
 804       Dali::Clipboard clipboard = Clipboard::Get();
 805       clipboard.HideClipboard();
 806     }
 807
 808     return ECORE_CALLBACK_PASS_ON;
 809   }
 810
 811   /**
 812    * Called when the window is damaged.
 813    */
 814   static Eina_Bool EcoreEventWindowDamaged(void *data, int type, void *event)
 815   {
 816     Ecore_X_Event_Window_Damage* windowDamagedEvent( (Ecore_X_Event_Window_Damage*)event );
 817     EventHandler* handler( (EventHandler*)data );
 818
 819     if( windowDamagedEvent->win == handler->mImpl->mWindow )
 820     {
 821       DamageArea area;
 822       area.x = windowDamagedEvent->x;
 823       area.y = windowDamagedEvent->y;
 824       area.width = windowDamagedEvent->w;
 825       area.height = windowDamagedEvent->h;
 826
 827       handler->SendEvent( area );
 828     }
 829
 830     return ECORE_CALLBACK_PASS_ON;
 831   }
 832
 833   /**
 834    * Called when the window properties are changed.
 835    * We are only interested in the font change.
 836    */
 837
 838
 839   /////////////////////////////////////////////////////////////////////////////////////////////////
 840   // Drag & Drop Callbacks
 841   /////////////////////////////////////////////////////////////////////////////////////////////////
 842
 843   /**
 844    * Called when a dragged item enters our window's bounds.
 845    * This is when items are dragged INTO our window.
 846    */
 847   static Eina_Bool EcoreEventDndEnter( void* data, int type, void* event )
 848   {
 849     DALI_LOG_INFO( gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndEnter\n" );
 850
 851     Ecore_X_Event_Xdnd_Enter* enterEvent( (Ecore_X_Event_Xdnd_Enter*) event );
 852     EventHandler* handler( (EventHandler*)data );
 853     Ecore_X_Window window ( handler->mImpl->mWindow );
 854
 855     if ( enterEvent->win == window )
 856     {
 857       DragAndDropDetectorPtr dndDetector( handler->mDragAndDropDetector );
 858
 859       // Check whether the Drag & Drop detector has Drag & Drop behaviour enabled before we accept.
 860       if ( dndDetector && dndDetector->IsEnabled() )
 861       {
 862         // Tell Ecore that we want to enable drop in the entire window.
 863         Ecore_X_Rectangle rect;
 864         rect.x = rect.y = 0;
 865         ecore_x_window_geometry_get( window, NULL, NULL, (int*)&rect.width, (int*)&rect.height );
 866
 867         // Tell Ecore that we are able to process a drop.
 868         ecore_x_dnd_send_status( EINA_TRUE, EINA_FALSE, rect, ECORE_X_ATOM_XDND_DROP );
 869
 870         // Register the required atoms and types.
 871         ecore_x_dnd_actions_set( window, DRAG_AND_DROP_ATOMS, DRAG_AND_DROP_ATOMS_NUMBER );
 872         ecore_x_dnd_types_set(   window, DRAG_AND_DROP_TYPES, DRAG_AND_DROP_TYPES_NUMBER );
 873
 874         // Request to get the content from Ecore.
 875         ecore_x_selection_xdnd_request( window, ECORE_X_SELECTION_TARGET_UTF8_STRING );
 876
 877         DALI_LOG_INFO( gDragAndDropLogFilter, Debug::General, "EcoreEventDndEnter: Requesting Drag & Drop\n" );
 878
 879         // Clear the previous content
 880         dndDetector->ClearContent();
 881
 882         // Emit the entered signal
 883         dndDetector->EmitEnteredSignal();
 884       }
 885     }
 886
 887     return ECORE_CALLBACK_PASS_ON;
 888   }
 889
 890   /**
 891    * Called when a dragged item is moved within our window.
 892    * This is when items are dragged INTO our window.
 893    */
 894   static Eina_Bool EcoreEventDndPosition( void* data, int type, void* event )
 895   {
 896     DALI_LOG_INFO(gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndPosition\n" );
 897
 898     Ecore_X_Event_Xdnd_Position* positionEvent( (Ecore_X_Event_Xdnd_Position*) event );
 899     EventHandler* handler( (EventHandler*)data );
 900
 901     if ( positionEvent->win == handler->mImpl->mWindow )
 902     {
 903       DragAndDropDetectorPtr dndDetector( handler->mDragAndDropDetector );
 904
 905       // If we have a detector then update its latest position.
 906       if ( dndDetector )
 907       {
 908         DALI_LOG_INFO(gDragAndDropLogFilter, Debug::General, "EcoreEventDndPosition: position ( %d x %d )\n", positionEvent->position.x, positionEvent->position.y );
 909         dndDetector->SetPosition( Vector2( positionEvent->position.x, positionEvent->position.y ));
 910         dndDetector->EmitMovedSignal();
 911       }
 912     }
 913
 914     return ECORE_CALLBACK_PASS_ON;
 915   }
 916
 917   /**
 918    * Called when a dragged item leaves our window's bounds.
 919    * This is when items are dragged INTO our window.
 920    */
 921   static Eina_Bool EcoreEventDndLeave( void* data, int type, void* event )
 922   {
 923     DALI_LOG_INFO(gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndLeave\n" );
 924
 925     Ecore_X_Event_Xdnd_Leave* leaveEvent( (Ecore_X_Event_Xdnd_Leave*) event );
 926     EventHandler* handler( (EventHandler*)data );
 927
 928     if ( leaveEvent->win == handler->mImpl->mWindow )
 929     {
 930       DragAndDropDetectorPtr dndDetector( handler->mDragAndDropDetector );
 931
 932       // If we have a detector then clear its content and emit the exited-signal. Also tell Ecore that we have finished.
 933       if ( dndDetector )
 934       {
 935         dndDetector->ClearContent();
 936         dndDetector->EmitExitedSignal();
 937
 938         ecore_x_dnd_send_finished();
 939
 940         DALI_LOG_INFO( gDragAndDropLogFilter, Debug::General, "EcoreEventDndLeave: Finished\n" );
 941       }
 942     }
 943
 944     return ECORE_CALLBACK_PASS_ON;
 945   }
 946
 947   /**
 948    * Called when the dragged item is dropped within our window's bounds.
 949    * This is when items are dragged INTO our window.
 950    */
 951   static Eina_Bool EcoreEventDndDrop( void* data, int type, void* event )
 952   {
 953     DALI_LOG_INFO(gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndDrop\n" );
 954
 955     Ecore_X_Event_Xdnd_Drop* dropEvent ( (Ecore_X_Event_Xdnd_Drop*) event);
 956     EventHandler* handler( (EventHandler*)data );
 957
 958     if ( dropEvent->win == handler->mImpl->mWindow )
 959     {
 960       DragAndDropDetectorPtr dndDetector( handler->mDragAndDropDetector );
 961
 962       // Something has been dropped, inform the detector (if we have one) and tell Ecore that we have finished.
 963       if ( dndDetector )
 964       {
 965         DALI_LOG_INFO(gDragAndDropLogFilter, Debug::General, "EcoreEventDndDrop: position ( %d x %d )\n", dropEvent->position.x, dropEvent->position.y );
 966
 967         dndDetector->SetPosition( Vector2( dropEvent->position.x, dropEvent->position.y ) );
 968         dndDetector->EmitDroppedSignal();
 969         ecore_x_dnd_send_finished();
 970
 971         DALI_LOG_INFO( gDragAndDropLogFilter, Debug::General, "EcoreEventDndDrop: Finished\n" );
 972       }
 973     }
 974
 975     return ECORE_CALLBACK_PASS_ON;
 976   }
 977
 978   /**
 979    * Called when a dragged item is moved from our window and the target window has done processing it.
 980    * This is when items are dragged FROM our window.
 981    */
 982   static Eina_Bool EcoreEventDndFinished( void* data, int type, void* event )
 983   {
 984     DALI_LOG_INFO(gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndFinished\n" );
 985     return ECORE_CALLBACK_PASS_ON;
 986   }
 987
 988   /**
 989    * Called when a dragged item is moved from our window and the target window has sent us a status.
 990    * This is when items are dragged FROM our window.
 991    */
 992   static Eina_Bool EcoreEventDndStatus( void* data, int type, void* event )
 993   {
 994     DALI_LOG_INFO(gDragAndDropLogFilter, Debug::Concise, "EcoreEventDndStatus\n" );
 995     return ECORE_CALLBACK_PASS_ON;
 996   }
 997
 998   /**
 999    * Called when the client messages (i.e. the accessibility events) are received.
1000    */
1001   static Eina_Bool EcoreEventClientMessage( void* data, int type, void* event )
1002   {
1003 #ifndef DALI_PROFILE_UBUNTU
1004     Ecore_X_Event_Client_Message* clientMessageEvent( (Ecore_X_Event_Client_Message*)event );
1005     EventHandler* handler( (EventHandler*)data );
1006
1007     if (clientMessageEvent->message_type == ECORE_X_ATOM_E_ILLUME_ACCESS_CONTROL)
1008     {
1009       if ( ( (unsigned int)clientMessageEvent->data.l[0] == handler->mImpl->mWindow ) && handler->mAccessibilityAdaptor )
1010       {
1011         AccessibilityAdaptor* accessibilityAdaptor( &AccessibilityAdaptor::GetImplementation( handler->mAccessibilityAdaptor ) );
1012
1013         if((unsigned int)clientMessageEvent->data.l[1] == ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_SCROLL)
1014         {
1015           // 2 finger touch & move, 2 finger flick
1016
1017           // mouse state : e->data.l[2] (0: mouse down, 1: mouse move, 2: mouse up)
1018           // x : e->data.l[3]
1019           // y : e->data.l[4]
1020           TouchPoint::State state(TouchPoint::Down);
1021
1022           if ((unsigned int)clientMessageEvent->data.l[2] == 0)
1023           {
1024             state = TouchPoint::Down; // mouse down
1025           }
1026           else if ((unsigned int)clientMessageEvent->data.l[2] == 1)
1027           {
1028             state = TouchPoint::Motion; // mouse move
1029           }
1030           else if ((unsigned int)clientMessageEvent->data.l[2] == 2)
1031           {
1032             state = TouchPoint::Up; // mouse up
1033           }
1034           else
1035           {
1036             state = TouchPoint::Interrupted; // error
1037           }
1038
1039           DALI_LOG_INFO(gClientMessageLogFilter, Debug::General,
1040             "[%s:%d] [%d] %d, %d\n", __FUNCTION__, __LINE__,
1041             (unsigned int)clientMessageEvent->data.l[2],
1042             (unsigned int)clientMessageEvent->data.l[3], (unsigned int)clientMessageEvent->data.l[4]);
1043
1044           // Send touch event to accessibility adaptor.
1045           TouchPoint point( 0, state, (float)clientMessageEvent->data.l[3], (float)clientMessageEvent->data.l[4] );
1046
1047           // In accessibility mode, scroll action should be handled when the currently focused actor is contained in scrollable control
1048           accessibilityAdaptor->HandleActionScrollEvent( point, GetCurrentMilliSeconds() );
1049         }
1050         else if((unsigned int)clientMessageEvent->data.l[1] == ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_MOUSE)
1051         {
1052           // 1 finger double tap and hold
1053
1054           // mouse state : e->data.l[2] (0: mouse down, 1: mouse move, 2: mouse up)
1055           // x : e->data.l[3]
1056           // y : e->data.l[4]
1057           TouchPoint::State state(TouchPoint::Down);
1058
1059           if ((unsigned int)clientMessageEvent->data.l[2] == 0)
1060           {
1061             state = TouchPoint::Down; // mouse down
1062           }
1063           else if ((unsigned int)clientMessageEvent->data.l[2] == 1)
1064           {
1065             state = TouchPoint::Motion; // mouse move
1066           }
1067           else if ((unsigned int)clientMessageEvent->data.l[2] == 2)
1068           {
1069             state = TouchPoint::Up; // mouse up
1070           }
1071           else
1072           {
1073             state = TouchPoint::Interrupted; // error
1074           }
1075
1076           DALI_LOG_INFO(gClientMessageLogFilter, Debug::General,
1077             "[%s:%d] [%d] %d, %d\n", __FUNCTION__, __LINE__,
1078             (unsigned int)clientMessageEvent->data.l[2],
1079             (unsigned int)clientMessageEvent->data.l[3], (unsigned int)clientMessageEvent->data.l[4]);
1080
1081           // Send touch event to accessibility adaptor.
1082           TouchPoint point( 0, state, (float)clientMessageEvent->data.l[3], (float)clientMessageEvent->data.l[4] );
1083
1084           // In accessibility mode, scroll action should be handled when the currently focused actor is contained in scrollable control
1085           accessibilityAdaptor->HandleActionTouchEvent( point, GetCurrentMilliSeconds() );
1086         }
1087         else if((unsigned int)clientMessageEvent->data.l[1] == ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_BACK)
1088         {
1089           // 2 finger circle draw, do back
1090           accessibilityAdaptor->HandleActionBackEvent();
1091         }
1092         else if((unsigned int)clientMessageEvent->data.l[1] == ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_NEXT)
1093         {
1094           // one finger flick down
1095           // focus next object
1096           if(accessibilityAdaptor)
1097           {
1098             accessibilityAdaptor->HandleActionNextEvent();
1099           }
1100         }
1101         else if((unsigned int)clientMessageEvent->data.l[1] == ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_PREV)
1102         {
1103           // one finger flick up
1104           // focus previous object
1105           if(accessibilityAdaptor)
1106           {
1107             accessibilityAdaptor->HandleActionPreviousEvent();
1108           }
1109         }
1110         else if((unsigned int)clientMessageEvent->data.l[1] == ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_ACTIVATE)
1111         {
1112           // one finger double tap
1113           // same as one finger tap in normal mode (i.e. execute focused actor)
1114           if(accessibilityAdaptor)
1115           {
1116             accessibilityAdaptor->HandleActionActivateEvent();
1117           }
1118         }
1119         else if((unsigned int)clientMessageEvent->data.l[1] == ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_READ)
1120         {
1121           // one finger tap
1122           // focus & read an actor at ( e->data.l[2], e->data.l[3] ) position according to finger
1123           if(accessibilityAdaptor)
1124           {
1125             accessibilityAdaptor->HandleActionReadEvent((unsigned int)clientMessageEvent->data.l[2], (unsigned int)clientMessageEvent->data.l[3], true /* allow read again*/);
1126           }
1127         }
1128 #if defined(DALI_PROFILE_MOBILE)
1129         else if((unsigned int)clientMessageEvent->data.l[1] == ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_OVER)
1130         {
1131           // one finger tap & move
1132           // mouse state : e->data.l[2] (0: mouse down, 1: mouse move, 2: mouse up)
1133           // x : e->data.l[3]
1134           // y : e->data.l[4]
1135           // focus & read an actor at (x, y) position according to finger
1136           if(accessibilityAdaptor && (unsigned int)clientMessageEvent->data.l[2] == 1 /*only work for move event*/)
1137           {
1138             accessibilityAdaptor->HandleActionReadEvent((unsigned int)clientMessageEvent->data.l[3], (unsigned int)clientMessageEvent->data.l[4], false /* not allow read again*/);
1139           }
1140         }
1141 #endif
1142         else if((unsigned int)clientMessageEvent->data.l[1] == ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_READ_NEXT)
1143         {
1144           // one finger flick right
1145           // focus next object
1146            if(accessibilityAdaptor)
1147           {
1148             accessibilityAdaptor->HandleActionReadNextEvent();
1149           }
1150         }
1151         else if((unsigned int)clientMessageEvent->data.l[1] == ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_READ_PREV)
1152         {
1153           // one finger flick left
1154           // focus previous object
1155           if(accessibilityAdaptor)
1156           {
1157             accessibilityAdaptor->HandleActionReadPreviousEvent();
1158           }
1159         }
1160         else if((unsigned int)clientMessageEvent->data.l[1] == ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_UP)
1161         {
1162           // double down and move (right, up)
1163           // change slider value
1164           if(accessibilityAdaptor)
1165           {
1166             accessibilityAdaptor->HandleActionUpEvent();
1167           }
1168         }
1169         else if((unsigned int)clientMessageEvent->data.l[1] == ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_DOWN)
1170         {
1171           // double down and move (left, down)
1172           // change slider value
1173           if(accessibilityAdaptor)
1174           {
1175             accessibilityAdaptor->HandleActionDownEvent();
1176           }
1177         }
1178         else if((unsigned int)clientMessageEvent->data.l[1] == ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_ENABLE)
1179         {
1180            if(accessibilityAdaptor)
1181           {
1182             accessibilityAdaptor->HandleActionEnableEvent();
1183           }
1184         }
1185         else if((unsigned int)clientMessageEvent->data.l[1] == ECORE_X_ATOM_E_ILLUME_ACCESS_ACTION_DISABLE)
1186         {
1187           if(accessibilityAdaptor)
1188           {
1189             accessibilityAdaptor->HandleActionDisableEvent();
1190           }
1191         }
1192         // TODO: some more actions could be added later
1193       }
1194     }
1195     else if(clientMessageEvent->message_type == ecore_x_atom_get(CLIPBOARD_ATOM))
1196     {
1197       std::string message(clientMessageEvent->data.b);
1198       if( message == CLIPBOARD_SET_OWNER_MESSAGE)
1199       {
1200         // Claim the ownership of the SECONDARY selection.
1201         ecore_x_selection_secondary_set(handler->mImpl->mWindow, "", 1);
1202
1203         // Show the clipboard window
1204         Dali::Clipboard clipboard = Dali::Clipboard::Get();
1205         clipboard.ShowClipboard();
1206       }
1207     }
1208     else if( clientMessageEvent->message_type == ECORE_X_ATOM_E_WINDOW_ROTATION_CHANGE_PREPARE )
1209     {
1210       RotationEvent rotationEvent;
1211       rotationEvent.angle      = static_cast<int>(clientMessageEvent->data.l[1]);
1212       rotationEvent.winResize  = static_cast<int>(clientMessageEvent->data.l[2]);
1213       rotationEvent.width      = static_cast<int>(clientMessageEvent->data.l[3]);
1214       rotationEvent.height     = static_cast<int>(clientMessageEvent->data.l[4]);
1215       handler->SendRotationPrepareEvent( rotationEvent );
1216     }
1217     else if( clientMessageEvent->message_type == ECORE_X_ATOM_E_WINDOW_ROTATION_CHANGE_REQUEST )
1218     {
1219       handler->SendRotationRequestEvent();
1220     }
1221
1222 #endif // DALI_PROFILE_UBUNTU
1223     return ECORE_CALLBACK_PASS_ON;
1224   }
1225
1226
1227   /////////////////////////////////////////////////////////////////////////////////////////////////
1228   // ElDBus Accessibility Callbacks
1229   /////////////////////////////////////////////////////////////////////////////////////////////////
1230
1231 #ifdef DALI_ELDBUS_AVAILABLE
1232   // Callback for Ecore ElDBus accessibility events.
1233   static void OnEcoreElDBusAccessibilityNotification( void *context EINA_UNUSED, const Eldbus_Message *message )
1234   {
1235     EventHandler* handler( (EventHandler*)context );
1236
1237     if ( !handler->mAccessibilityAdaptor )
1238     {
1239       DALI_LOG_ERROR( "Invalid accessibility adaptor\n" );
1240       return;
1241     }
1242
1243     AccessibilityAdaptor* accessibilityAdaptor( &AccessibilityAdaptor::GetImplementation( handler->mAccessibilityAdaptor ) );
1244     if ( !accessibilityAdaptor )
1245     {
1246       DALI_LOG_ERROR( "Cannot access accessibility adaptor\n" );
1247       return;
1248     }
1249
1250     const char *gestureName;
1251     int xS, yS, xE, yE;
1252     unsigned int state;
1253
1254     // The string defines the arg-list's respective types.
1255     if( !eldbus_message_arguments_get( message, "siiiiu", &gestureName, &xS, &yS, &xE, &yE, &state ) )
1256     {
1257       DALI_LOG_ERROR( "OnEcoreElDBusAccessibilityNotification: Error getting arguments\n" );
1258     }
1259
1260     DALI_LOG_INFO( gImfLogging, Debug::General, "Got gesture: Name: %s  Args: %d,%d,%d,%d  State: %d\n", gestureName, xS, yS, xE, yE );
1261
1262     unsigned int fingers = 0;
1263     char* stringPosition = ( char* )gestureName;
1264
1265     // Check how many fingers the gesture uses.
1266     for( unsigned int i = 0; i < FingerCountStringsTotal; ++i )
1267     {
1268       unsigned int matchLength = strlen( ElDBusAccessibilityFingerCountStrings[ i ] );
1269       if( strncmp( gestureName, ElDBusAccessibilityFingerCountStrings[ i ], matchLength ) == 0 )
1270       {
1271         fingers = i + 1;
1272         stringPosition += matchLength;
1273         break;
1274       }
1275     }
1276
1277     if( fingers == 0 )
1278     {
1279       // Error: invalid gesture.
1280       return;
1281     }
1282
1283     GestureType gestureType = GESTURE_TYPE_NONE;
1284     SubGestureType subGestureType = SUB_GESTURE_TYPE_NONE;
1285     GestureDirection direction = GESTURE_DIRECTION_NONE;
1286
1287     // Check for full gesture type names first.
1288     for( unsigned int i = 0; i < FullEventTypeStringsTotal; ++i )
1289     {
1290       unsigned int matchLength = strlen( ElDBusAccessibilityFullEventTypeStrings[ i ].name );
1291       if( strncmp( stringPosition, ElDBusAccessibilityFullEventTypeStrings[ i ].name, matchLength ) == 0 )
1292       {
1293         gestureType = ElDBusAccessibilityFullEventTypeStrings[ i ].type;
1294         break;
1295       }
1296     }
1297
1298     // If we didn't find a full gesture, check for sub gesture type names.
1299     if( gestureType == GESTURE_TYPE_NONE )
1300     {
1301       // No full gesture name found, look for partial types.
1302       for( unsigned int i = 0; i < DirectionalEventTypeStringsTotal; ++i )
1303       {
1304         unsigned int matchLength = strlen( ElDBusAccessibilityDirectionalEventTypeStrings[ i ].name );
1305         if( strncmp( stringPosition, ElDBusAccessibilityDirectionalEventTypeStrings[ i ].name, matchLength ) == 0 )
1306         {
1307           subGestureType = ElDBusAccessibilityDirectionalEventTypeStrings[ i ].type;
1308           stringPosition += matchLength;
1309         break;
1310         }
1311       }
1312
1313       if( subGestureType == SUB_GESTURE_TYPE_NONE )
1314       {
1315         // ERROR: Gesture not recognised.
1316         return;
1317       }
1318
1319       // If the gesture was a sub type, get it's respective direction.
1320       for( unsigned int i = 0; i < DirectionStringsTotal; ++i )
1321       {
1322         unsigned int matchLength = strlen( ElDBusAccessibilityDirectionStrings[ i ].name );
1323         if( strncmp( stringPosition, ElDBusAccessibilityDirectionStrings[ i ].name, matchLength ) == 0 )
1324         {
1325           direction = ElDBusAccessibilityDirectionStrings[ i ].direction;
1326           stringPosition += matchLength;
1327           break;
1328         }
1329       }
1330
1331       if( direction == GESTURE_DIRECTION_NONE )
1332       {
1333         // ERROR: Gesture not recognised.
1334         return;
1335       }
1336     }
1337
1338     // Action the detected gesture here.
1339     if( gestureType != GESTURE_TYPE_NONE )
1340     {
1341       DALI_LOG_INFO( gImfLogging, Debug::General, "Got gesture: Fingers: %d  Gesture type: %d\n", fingers, gestureType );
1342     }
1343     else
1344     {
1345       DALI_LOG_INFO( gImfLogging, Debug::General, "Got gesture: Fingers: %d  Gesture sub type: %d Gesture direction: %d\n",
1346         fingers, subGestureType, direction );
1347     }
1348
1349     // Create a touch point object.
1350     TouchPoint::State touchPointState( TouchPoint::Down );
1351     if ( state == 0 )
1352     {
1353       touchPointState = TouchPoint::Down; // Mouse down.
1354     }
1355     else if ( state == 1 )
1356     {
1357       touchPointState = TouchPoint::Motion; // Mouse move.
1358     }
1359     else if ( state == 2 )
1360     {
1361       touchPointState = TouchPoint::Up; // Mouse up.
1362     }
1363     else
1364     {
1365       touchPointState = TouchPoint::Interrupted; // Error.
1366     }
1367
1368     // Send touch event to accessibility adaptor.
1369     TouchPoint point( 0, touchPointState, (float)xS, (float)yS );
1370
1371     // Perform actions based on received gestures.
1372     // Note: This is seperated from the reading so we can (in future)
1373     // have other input readers without changing the below code.
1374     switch( fingers )
1375     {
1376       case 1:
1377       {
1378         if( gestureType == GESTURE_TYPE_SINGLE_TAP || ( gestureType == GESTURE_TYPE_HOVER && touchPointState == TouchPoint::Motion ) )
1379         {
1380           // Focus, read out.
1381           accessibilityAdaptor->HandleActionReadEvent( (unsigned int)xS, (unsigned int)yS, true /* allow read again */ );
1382         }
1383         else if( gestureType == GESTURE_TYPE_DOUBLE_TAP )
1384         {
1385           if( false ) // TODO: how to detect double tap + hold?
1386           {
1387             // Move or drag icon / view more options for selected items.
1388             // accessibilityAdaptor->HandleActionTouchEvent( point, GetCurrentMilliSeconds() );
1389           }
1390           else
1391           {
1392             // Activate selected item / active edit mode.
1393             accessibilityAdaptor->HandleActionActivateEvent();
1394           }
1395         }
1396         else if( gestureType == GESTURE_TYPE_TRIPLE_TAP )
1397         {
1398           // Zoom
1399           accessibilityAdaptor->HandleActionZoomEvent();
1400         }
1401         else if( subGestureType == SUB_GESTURE_TYPE_FLICK )
1402         {
1403           if( direction == GESTURE_DIRECTION_LEFT )
1404           {
1405             // Move to previous item.
1406             accessibilityAdaptor->HandleActionReadPreviousEvent();
1407           }
1408           else if( direction == GESTURE_DIRECTION_RIGHT )
1409           {
1410             // Move to next item.
1411             accessibilityAdaptor->HandleActionReadNextEvent();
1412           }
1413           else if( direction == GESTURE_DIRECTION_UP )
1414           {
1415             // Move to next item.
1416             accessibilityAdaptor->HandleActionPreviousEvent();
1417           }
1418           else if( direction == GESTURE_DIRECTION_DOWN )
1419           {
1420             // Move to next item.
1421             accessibilityAdaptor->HandleActionNextEvent();
1422           }
1423           else if( direction == GESTURE_DIRECTION_LEFT_RETURN )
1424           {
1425             // Scroll up to the previous page
1426             accessibilityAdaptor->HandleActionPageUpEvent();
1427           }
1428           else if( direction == GESTURE_DIRECTION_RIGHT_RETURN )
1429           {
1430             // Scroll down to the next page
1431             accessibilityAdaptor->HandleActionPageDownEvent();
1432           }
1433           else if( direction == GESTURE_DIRECTION_UP_RETURN )
1434           {
1435             // Move to the first item on screen
1436             accessibilityAdaptor->HandleActionMoveToFirstEvent();
1437           }
1438           else if( direction == GESTURE_DIRECTION_DOWN_RETURN )
1439           {
1440             // Move to the last item on screen
1441             accessibilityAdaptor->HandleActionMoveToLastEvent();
1442           }
1443         }
1444         break;
1445       }
1446
1447       case 2:
1448       {
1449         if( gestureType == GESTURE_TYPE_HOVER )
1450         {
1451           // In accessibility mode, scroll action should be handled when the currently focused actor is contained in scrollable control
1452           accessibilityAdaptor->HandleActionScrollEvent( point, GetCurrentMilliSeconds() );
1453         }
1454         else if( gestureType == GESTURE_TYPE_SINGLE_TAP )
1455         {
1456           // Pause/Resume current speech
1457           accessibilityAdaptor->HandleActionReadPauseResumeEvent();
1458         }
1459         else if( gestureType == GESTURE_TYPE_DOUBLE_TAP )
1460         {
1461           // Start/Stop current action
1462           accessibilityAdaptor->HandleActionStartStopEvent();
1463         }
1464         else if( gestureType == GESTURE_TYPE_TRIPLE_TAP )
1465         {
1466           // Read information from indicator
1467           accessibilityAdaptor->HandleActionReadIndicatorInformationEvent();
1468         }
1469         else if( subGestureType == SUB_GESTURE_TYPE_FLICK )
1470         {
1471           if( direction == GESTURE_DIRECTION_LEFT )
1472           {
1473             // Scroll left to the previous page
1474             accessibilityAdaptor->HandleActionPageLeftEvent();
1475           }
1476           else if( direction == GESTURE_DIRECTION_RIGHT )
1477           {
1478             // Scroll right to the next page
1479             accessibilityAdaptor->HandleActionPageRightEvent();
1480           }
1481           else if( direction == GESTURE_DIRECTION_UP )
1482           {
1483             // Scroll up the list.
1484             accessibilityAdaptor->HandleActionScrollUpEvent();
1485           }
1486           else if( direction == GESTURE_DIRECTION_DOWN )
1487           {
1488             // Scroll down the list.
1489             accessibilityAdaptor->HandleActionScrollDownEvent();
1490           }
1491         }
1492         break;
1493       }
1494
1495       case 3:
1496       {
1497         if( gestureType == GESTURE_TYPE_SINGLE_TAP )
1498         {
1499           // Read from top item on screen continuously.
1500           accessibilityAdaptor->HandleActionReadFromTopEvent();
1501         }
1502         else if( gestureType == GESTURE_TYPE_DOUBLE_TAP )
1503         {
1504           // Read from next item continuously.
1505           accessibilityAdaptor->HandleActionReadFromNextEvent();
1506         }
1507         break;
1508       }
1509     }
1510   }
1511
1512   // Callback for to set up Ecore ElDBus for accessibility callbacks.
1513   static void EcoreElDBusInitialisation( void *handle, const Eldbus_Message *message, Eldbus_Pending *pending EINA_UNUSED )
1514   {
1515     Eldbus_Object *object;
1516     Eldbus_Proxy *manager;
1517     const char *a11yBusAddress = NULL;
1518
1519     // The string defines the arg-list's respective types.
1520     if( !eldbus_message_arguments_get( message, "s", &a11yBusAddress ) )
1521     {
1522       DALI_LOG_ERROR( "EcoreElDBusInitialisation: Error getting arguments\n" );
1523     }
1524
1525     DALI_LOG_INFO( gImfLogging, Debug::General, "Ecore ElDBus Accessibility address: %s\n", a11yBusAddress );
1526
1527     Eldbus_Connection *a11yConnection = eldbus_address_connection_get( a11yBusAddress );
1528
1529     object = eldbus_object_get( a11yConnection, BUS, PATH );
1530     manager = eldbus_proxy_get( object, INTERFACE );
1531
1532     // Pass the callback data through to the signal handler.
1533     eldbus_proxy_signal_handler_add( manager, SIGNAL, OnEcoreElDBusAccessibilityNotification, handle );
1534   }
1535 #endif // DALI_ELDBUS_AVAILABLE
1536
1537   /**
1538    * Called when the source window notifies us the content in clipboard is selected.
1539    */
1540   static Eina_Bool EcoreEventSelectionClear( void* data, int type, void* event )
1541   {
1542     DALI_LOG_INFO(gSelectionEventLogFilter, Debug::Concise, "EcoreEventSelectionClear\n" );
1543     Ecore_X_Event_Selection_Clear* selectionClearEvent( (Ecore_X_Event_Selection_Clear*) event );
1544     EventHandler* handler( (EventHandler*)data );
1545
1546     if ( selectionClearEvent->win == handler->mImpl->mWindow )
1547     {
1548       if ( selectionClearEvent->selection == ECORE_X_SELECTION_SECONDARY )
1549       {
1550         // Request to get the content from Ecore.
1551         ecore_x_selection_secondary_request(selectionClearEvent->win, ECORE_X_SELECTION_TARGET_TEXT);
1552       }
1553     }
1554     return ECORE_CALLBACK_PASS_ON;
1555   }
1556
1557   /**
1558    * Called when the source window sends us about the selected content.
1559    * For example, when dragged items are dragged INTO our window or when items are selected in the clipboard.
1560    */
1561   static Eina_Bool EcoreEventSelectionNotify( void* data, int type, void* event )
1562   {
1563     DALI_LOG_INFO(gSelectionEventLogFilter, Debug::Concise, "EcoreEventSelectionNotify\n" );
1564
1565     Ecore_X_Event_Selection_Notify* selectionNotifyEvent( (Ecore_X_Event_Selection_Notify*) event );
1566     EventHandler* handler( (EventHandler*)data );
1567
1568     if ( selectionNotifyEvent->win == handler->mImpl->mWindow )
1569     {
1570       Ecore_X_Selection_Data* selectionData( (Ecore_X_Selection_Data*) selectionNotifyEvent->data );
1571       if ( selectionData->data )
1572       {
1573         if ( selectionNotifyEvent->selection == ECORE_X_SELECTION_XDND )
1574         {
1575           DragAndDropDetectorPtr dndDetector( handler->mDragAndDropDetector );
1576
1577           // We have got the content that is to be dropped, inform the DndListener (if we have one).
1578           if ( dndDetector )
1579           {
1580             std::string content( (char*) selectionData->data, selectionData->length );
1581             dndDetector->SetContent( content );
1582
1583             DALI_LOG_INFO( gSelectionEventLogFilter, Debug::General, "EcoreEventSelectionNotify: Content(%d):\n" , selectionData->length );
1584             DALI_LOG_INFO( gSelectionEventLogFilter, Debug::General, "======================================\n" );
1585             DALI_LOG_INFO( gSelectionEventLogFilter, Debug::General, "%s\n", selectionData->data );
1586             DALI_LOG_INFO( gSelectionEventLogFilter, Debug::General, "======================================\n" );
1587           }
1588         }
1589         else if ( selectionNotifyEvent->selection == ECORE_X_SELECTION_SECONDARY )
1590         {
1591           // We have got the selected content, inform the clipboard event listener (if we have one).
1592           if ( handler->mClipboardEventNotifier )
1593           {
1594             ClipboardEventNotifier& clipboardEventNotifier( ClipboardEventNotifier::GetImplementation( handler->mClipboardEventNotifier ) );
1595             std::string content( (char*) selectionData->data, selectionData->length );
1596             clipboardEventNotifier.SetContent( content );
1597             clipboardEventNotifier.EmitContentSelectedSignal();
1598           }
1599
1600           // Claim the ownership of the SECONDARY selection.
1601           ecore_x_selection_secondary_set(handler->mImpl->mWindow, "", 1);
1602
1603           DALI_LOG_INFO( gSelectionEventLogFilter, Debug::General, "EcoreEventSelectionNotify: Content(%d):\n" , selectionData->length );
1604           DALI_LOG_INFO( gSelectionEventLogFilter, Debug::General, "======================================\n" );
1605           DALI_LOG_INFO( gSelectionEventLogFilter, Debug::General, "%s\n", selectionData->data );
1606           DALI_LOG_INFO( gSelectionEventLogFilter, Debug::General, "======================================\n" );
1607         }
1608       }
1609     }
1610     return ECORE_CALLBACK_PASS_ON;
1611   }
1612
1613
1614 #ifndef DALI_PROFILE_UBUNTU
1615   /////////////////////////////////////////////////////////////////////////////////////////////////
1616   // Font Callbacks
1617   /////////////////////////////////////////////////////////////////////////////////////////////////
1618   /**
1619    * Called when a font name is changed.
1620    */
1621   static void VconfNotifyFontNameChanged( keynode_t* node, void* data )
1622   {
1623     EventHandler* handler = static_cast<EventHandler*>( data );
1624     handler->SendEvent( StyleChange::DEFAULT_FONT_CHANGE );
1625   }
1626
1627   /**
1628    * Called when a font size is changed.
1629    */
1630   static void VconfNotifyFontSizeChanged( keynode_t* node, void* data )
1631   {
1632     EventHandler* handler = static_cast<EventHandler*>( data );
1633     handler->SendEvent( StyleChange::DEFAULT_FONT_SIZE_CHANGE );
1634   }
1635 #endif // DALI_PROFILE_UBUNTU
1636
1637   // Data
1638   EventHandler* mHandler;
1639   std::vector<Ecore_Event_Handler*> mEcoreEventHandler;
1640   Ecore_X_Window mWindow;
1641   int mXiDeviceId;
1642 };
1643
1644 EventHandler::EventHandler( RenderSurface* surface, CoreEventInterface& coreEventInterface, GestureManager& gestureManager, DamageObserver& damageObserver, DragAndDropDetectorPtr dndDetector )
1645 : mCoreEventInterface(coreEventInterface),
1646   mGestureManager( gestureManager ),
1647   mStyleMonitor( StyleMonitor::Get() ),
1648   mDamageObserver( damageObserver ),
1649   mRotationObserver( NULL ),
1650   mDragAndDropDetector( dndDetector ),
1651   mAccessibilityAdaptor( AccessibilityAdaptor::Get() ),
1652   mClipboardEventNotifier( ClipboardEventNotifier::Get() ),
1653   mClipboard(Clipboard::Get()),
1654   mImpl( NULL )
1655 {
1656   Ecore_X_Window window = 0;
1657
1658   // this code only works with the EcoreX11 RenderSurface so need to downcast
1659   ECore::WindowRenderSurface* ecoreSurface = dynamic_cast< ECore::WindowRenderSurface* >( surface );
1660   if( ecoreSurface )
1661   {
1662     // enable multi touch
1663     window = ecoreSurface->GetXWindow();
1664   }
1665
1666   mImpl = new Impl(this, window);
1667 }
1668
1669 EventHandler::~EventHandler()
1670 {
1671   if(mImpl)
1672   {
1673     delete mImpl;
1674   }
1675
1676   mGestureManager.Stop();
1677 }
1678
1679 void EventHandler::SendEvent(TouchPoint& point, unsigned long timeStamp)
1680 {
1681   if(timeStamp < 1)
1682   {
1683     timeStamp = GetCurrentMilliSeconds();
1684   }
1685
1686   Integration::TouchEvent touchEvent;
1687   Integration::HoverEvent hoverEvent;
1688   Integration::TouchEventCombiner::EventDispatchType type = mCombiner.GetNextTouchEvent(point, timeStamp, touchEvent, hoverEvent);
1689   if(type != Integration::TouchEventCombiner::DispatchNone )
1690   {
1691     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);
1692
1693     // First the touch and/or hover event & related gesture events are queued
1694     if(type == Integration::TouchEventCombiner::DispatchTouch || type == Integration::TouchEventCombiner::DispatchBoth)
1695     {
1696       mCoreEventInterface.QueueCoreEvent( touchEvent );
1697       mGestureManager.SendEvent(touchEvent);
1698     }
1699
1700     if(type == Integration::TouchEventCombiner::DispatchHover || type == Integration::TouchEventCombiner::DispatchBoth)
1701     {
1702       mCoreEventInterface.QueueCoreEvent( hoverEvent );
1703     }
1704
1705     // Next the events are processed with a single call into Core
1706     mCoreEventInterface.ProcessCoreEvents();
1707   }
1708 }
1709
1710 void EventHandler::SendEvent(KeyEvent& keyEvent)
1711 {
1712   Dali::PhysicalKeyboard physicalKeyboard = PhysicalKeyboard::Get();
1713   if ( physicalKeyboard )
1714   {
1715     if ( ! KeyLookup::IsDeviceButton( keyEvent.keyPressedName.c_str() ) )
1716     {
1717       GetImplementation( physicalKeyboard ).KeyReceived( keyEvent.time > 1 );
1718     }
1719   }
1720
1721   // Create KeyEvent and send to Core.
1722   Integration::KeyEvent event(keyEvent.keyPressedName, keyEvent.keyPressed, keyEvent.keyCode,
1723   keyEvent.keyModifier, keyEvent.time, static_cast<Integration::KeyEvent::State>(keyEvent.state));
1724   mCoreEventInterface.QueueCoreEvent( event );
1725   mCoreEventInterface.ProcessCoreEvents();
1726 }
1727
1728 void EventHandler::SendWheelEvent( WheelEvent& wheelEvent )
1729 {
1730   // Create WheelEvent and send to Core.
1731   Integration::WheelEvent event( static_cast< Integration::WheelEvent::Type >(wheelEvent.type), wheelEvent.direction, wheelEvent.modifiers, wheelEvent.point, wheelEvent.z, wheelEvent.timeStamp );
1732   mCoreEventInterface.QueueCoreEvent( event );
1733   mCoreEventInterface.ProcessCoreEvents();
1734 }
1735
1736 void EventHandler::SendEvent( StyleChange::Type styleChange )
1737 {
1738   DALI_ASSERT_DEBUG( mStyleMonitor && "StyleMonitor Not Available" );
1739   GetImplementation( mStyleMonitor ).StyleChanged(styleChange);
1740 }
1741
1742 void EventHandler::SendEvent( const DamageArea& area )
1743 {
1744   mDamageObserver.OnDamaged( area );
1745 }
1746
1747 void EventHandler::SendRotationPrepareEvent( const RotationEvent& event )
1748 {
1749   if( mRotationObserver != NULL )
1750   {
1751     mRotationObserver->OnRotationPrepare( event );
1752   }
1753 }
1754
1755 void EventHandler::SendRotationRequestEvent( )
1756 {
1757   if( mRotationObserver != NULL )
1758   {
1759     mRotationObserver->OnRotationRequest( );
1760   }
1761 }
1762
1763 void EventHandler::FeedTouchPoint( TouchPoint& point, int timeStamp)
1764 {
1765   SendEvent(point, timeStamp);
1766 }
1767
1768 void EventHandler::FeedWheelEvent( WheelEvent& wheelEvent )
1769 {
1770   SendWheelEvent( wheelEvent );
1771 }
1772
1773 void EventHandler::FeedKeyEvent( KeyEvent& event )
1774 {
1775   SendEvent( event );
1776 }
1777
1778 void EventHandler::FeedEvent( Integration::Event& event )
1779 {
1780   mCoreEventInterface.QueueCoreEvent( event );
1781   mCoreEventInterface.ProcessCoreEvents();
1782 }
1783
1784 void EventHandler::Reset()
1785 {
1786   mCombiner.Reset();
1787
1788   // Any touch listeners should be told of the interruption.
1789   Integration::TouchEvent event;
1790   TouchPoint point(0, TouchPoint::Interrupted, 0, 0);
1791   event.AddPoint( point );
1792
1793   // First the touch event & related gesture events are queued
1794   mCoreEventInterface.QueueCoreEvent( event );
1795   mGestureManager.SendEvent( event );
1796
1797   // Next the events are processed with a single call into Core
1798   mCoreEventInterface.ProcessCoreEvents();
1799 }
1800
1801 void EventHandler::SetDragAndDropDetector( DragAndDropDetectorPtr detector )
1802 {
1803   mDragAndDropDetector = detector;
1804 }
1805
1806 void EventHandler::SetRotationObserver( RotationObserver* observer )
1807 {
1808   mRotationObserver = observer;
1809 }
1810
1811 } // namespace Adaptor
1812
1813 } // namespace Internal
1814
1815 } // namespace Dali