X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=adaptors%2Fecore%2Fwayland%2Fevent-handler-ecore-wl.cpp;h=35d3d0521a73f845c940b6a00d5eb41dd9f35745;hb=c8250e2ee705059fed16528ca49642da093d6648;hp=84a8aa203fa1fa2227eeb76e4df78d30dd6a5559;hpb=3b14a58da69ac261e90ca2e7a1f8903c35b34741;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git diff --git a/adaptors/ecore/wayland/event-handler-ecore-wl.cpp b/adaptors/ecore/wayland/event-handler-ecore-wl.cpp index 84a8aa2..35d3d05 100644 --- a/adaptors/ecore/wayland/event-handler-ecore-wl.cpp +++ b/adaptors/ecore/wayland/event-handler-ecore-wl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015 Samsung Electronics Co., Ltd. + * Copyright (c) 2017 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,6 +19,9 @@ #include // EXTERNAL INCLUDES +// Ecore is littered with C style cast +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wold-style-cast" #include #include #include @@ -31,6 +34,10 @@ #include #endif // DALI_PROFILE_UBUNTU +#ifdef DALI_ELDBUS_AVAILABLE +#include +#endif // DALI_ELDBUS_AVAILABLE + #include #include #include @@ -40,6 +47,7 @@ #include #include #include +#include // INTERNAL INCLUDES #include @@ -64,7 +72,6 @@ namespace Adaptor namespace { Integration::Log::Filter* gTouchEventLogFilter = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_TOUCH"); -Integration::Log::Filter* gClientMessageLogFilter = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_CLIENT_MESSAGE"); Integration::Log::Filter* gDragAndDropLogFilter = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_DND"); Integration::Log::Filter* gImfLogging = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_IMF"); Integration::Log::Filter* gSelectionEventLogFilter = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_SELECTION"); @@ -74,10 +81,93 @@ Integration::Log::Filter* gSelectionEventLogFilter = Integration::Log::Filter::N namespace { + +// DBUS accessibility +const char* BUS = "org.enlightenment.wm-screen-reader"; +const char* INTERFACE = "org.tizen.GestureNavigation"; +const char* PATH = "/org/tizen/GestureNavigation"; + const unsigned int PRIMARY_TOUCH_BUTTON_ID( 1 ); const unsigned int BYTES_PER_CHARACTER_FOR_ATTRIBUTES = 3; +#ifdef DALI_ELDBUS_AVAILABLE +// DBus gesture string matching lists. +// TODO: This needs moving to its own module. +const char * ElDBusAccessibilityFingerCountStrings[] = +{ + "OneFinger", + "TwoFingers", + "ThreeFingers" +}; +const unsigned int FingerCountStringsTotal = sizeof( ElDBusAccessibilityFingerCountStrings ) / sizeof( ElDBusAccessibilityFingerCountStrings[0] ); +enum GestureType +{ + GESTURE_TYPE_NONE, + GESTURE_TYPE_HOVER, + GESTURE_TYPE_SINGLE_TAP, + GESTURE_TYPE_DOUBLE_TAP, + GESTURE_TYPE_TRIPLE_TAP +}; +struct GestureTypeTable +{ + const char* name; + const GestureType type; +}; +GestureTypeTable ElDBusAccessibilityFullEventTypeStrings[] = +{ + { "Hover", GESTURE_TYPE_HOVER }, + { "SingleTap", GESTURE_TYPE_SINGLE_TAP }, + { "DoubleTap", GESTURE_TYPE_DOUBLE_TAP }, + { "TripleTap", GESTURE_TYPE_TRIPLE_TAP } +}; +const unsigned int FullEventTypeStringsTotal = sizeof( ElDBusAccessibilityFullEventTypeStrings ) / sizeof( ElDBusAccessibilityFullEventTypeStrings[0] ); +enum SubGestureType +{ + SUB_GESTURE_TYPE_NONE, + SUB_GESTURE_TYPE_FLICK +}; +struct SubGestureTypeTable +{ + const char* name; + const SubGestureType type; +}; +SubGestureTypeTable ElDBusAccessibilityDirectionalEventTypeStrings[] = +{ + { "Flick", SUB_GESTURE_TYPE_FLICK } +}; +const unsigned int DirectionalEventTypeStringsTotal = sizeof( ElDBusAccessibilityDirectionalEventTypeStrings ) / sizeof( ElDBusAccessibilityDirectionalEventTypeStrings[0] ); +enum GestureDirection +{ + GESTURE_DIRECTION_NONE, + GESTURE_DIRECTION_UP, + GESTURE_DIRECTION_DOWN, + GESTURE_DIRECTION_LEFT, + GESTURE_DIRECTION_RIGHT, + GESTURE_DIRECTION_UP_RETURN, + GESTURE_DIRECTION_DOWN_RETURN, + GESTURE_DIRECTION_LEFT_RETURN, + GESTURE_DIRECTION_RIGHT_RETURN +}; +struct GestureDirectionTable +{ + const char* name; + const GestureDirection direction; +}; +GestureDirectionTable ElDBusAccessibilityDirectionStrings[] = +{ + { "Up", GESTURE_DIRECTION_UP }, + { "Down", GESTURE_DIRECTION_DOWN }, + { "Left", GESTURE_DIRECTION_LEFT }, + { "Right", GESTURE_DIRECTION_RIGHT }, + { "UpReturn", GESTURE_DIRECTION_UP_RETURN }, + { "DownReturn", GESTURE_DIRECTION_DOWN_RETURN }, + { "LeftReturn", GESTURE_DIRECTION_LEFT_RETURN }, + { "RightReturn", GESTURE_DIRECTION_RIGHT_RETURN } +}; +const unsigned int DirectionStringsTotal = sizeof( ElDBusAccessibilityDirectionStrings ) / sizeof( ElDBusAccessibilityDirectionStrings[0] ); +#endif // DALI_ELDBUS_AVAILABLE + /** * Ecore_Event_Modifier enums in Ecore_Input.h do not match Ecore_IMF_Keyboard_Modifiers in Ecore_IMF.h. * This function converts from Ecore_Event_Modifier to Ecore_IMF_Keyboard_Modifiers enums. @@ -158,6 +248,71 @@ static unsigned int GetCurrentMilliSeconds(void) const char * DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE = "db/setting/accessibility/font_name"; // It will be update at vconf-key.h and replaced. #endif // DALI_PROFILE_UBUNTU +/** + * Get the device name from the provided ecore key event + */ +void GetDeviceName( Ecore_Event_Key* keyEvent, std::string& result ) +{ + const char* ecoreDeviceName = ecore_device_name_get( keyEvent->dev ); + + if ( ecoreDeviceName ) + { + result = ecoreDeviceName; + } +} + +/** + * Get the device class from the provided ecore key event + */ +void GetDeviceClass( Ecore_Event_Key* keyEvent, DevelKeyEvent::DeviceClass::Type& deviceClass ) +{ + Ecore_Device_Class ecoreDeviceClass = ecore_device_class_get( keyEvent->dev ); + + switch( ecoreDeviceClass ) + { + case ECORE_DEVICE_CLASS_SEAT: + { + deviceClass = DevelKeyEvent::DeviceClass::USER; + break; + } + case ECORE_DEVICE_CLASS_KEYBOARD: + { + deviceClass = DevelKeyEvent::DeviceClass::KEYBOARD; + break; + } + case ECORE_DEVICE_CLASS_MOUSE: + { + deviceClass = DevelKeyEvent::DeviceClass::MOUSE; + break; + } + case ECORE_DEVICE_CLASS_TOUCH: + { + deviceClass = DevelKeyEvent::DeviceClass::TOUCH; + break; + } + case ECORE_DEVICE_CLASS_PEN: + { + deviceClass = DevelKeyEvent::DeviceClass::PEN; + break; + } + case ECORE_DEVICE_CLASS_POINTER: + { + deviceClass = DevelKeyEvent::DeviceClass::POINTER; + break; + } + case ECORE_DEVICE_CLASS_GAMEPAD: + { + deviceClass = DevelKeyEvent::DeviceClass::GAMEPAD; + break; + } + default: + { + deviceClass = DevelKeyEvent::DeviceClass::NONE; + break; + } + } +} + } // unnamed namespace // Impl to hide EFL implementation. @@ -172,15 +327,19 @@ struct EventHandler::Impl : mHandler( handler ), mEcoreEventHandler(), mWindow( window ) +#ifdef DALI_ELDBUS_AVAILABLE + , mSystemConnection( NULL ) +#endif // DALI_ELDBUS_AVAILABLE { // Only register for touch and key events if we have a window if ( window != 0 ) { // Register Touch events - mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_DOWN, EcoreEventMouseButtonDown, handler ) ); - mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_UP, EcoreEventMouseButtonUp, handler ) ); - mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_MOVE, EcoreEventMouseButtonMove, handler ) ); - mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_OUT, EcoreEventMouseButtonUp, handler ) ); // process mouse out event like up event + mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_DOWN, EcoreEventMouseButtonDown, handler ) ); + mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_UP, EcoreEventMouseButtonUp, handler ) ); + mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_MOVE, EcoreEventMouseButtonMove, handler ) ); + mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_OUT, EcoreEventMouseButtonUp, handler ) ); // process mouse out event like up event + mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_BUTTON_CANCEL, EcoreEventMouseButtonCancel, handler ) ); // Register Mouse wheel events mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_MOUSE_WHEEL, EcoreEventMouseWheel, handler ) ); @@ -193,13 +352,31 @@ struct EventHandler::Impl mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_KEY_DOWN, EcoreEventKeyDown, handler ) ); mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_KEY_UP, EcoreEventKeyUp, handler ) ); + // Register Selection event - clipboard selection + mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_WL_EVENT_DATA_SOURCE_SEND, EcoreEventDataSend, handler ) ); + mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_WL_EVENT_SELECTION_DATA_READY, EcoreEventDataReceive, handler ) ); + + // Register Rotate event + mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_WL_EVENT_WINDOW_ROTATE, EcoreEventRotate, handler) ); + // Register Detent event mEcoreEventHandler.push_back( ecore_event_handler_add( ECORE_EVENT_DETENT_ROTATE, EcoreEventDetent, handler) ); + #ifndef DALI_PROFILE_UBUNTU // Register Vconf notify - font name and size vconf_notify_key_changed( DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontNameChanged, handler ); vconf_notify_key_changed( VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, VconfNotifyFontSizeChanged, handler ); #endif // DALI_PROFILE_UBUNTU + +#ifdef DALI_ELDBUS_AVAILABLE + // Initialize ElDBus. + DALI_LOG_INFO( gImfLogging, Debug::General, "Starting DBus Initialization\n" ); + + // Pass in handler. + EcoreElDBusInitialisation( handler ); + + DALI_LOG_INFO( gImfLogging, Debug::General, "Finished DBus Initialization\n" ); +#endif // DALI_ELDBUS_AVAILABLE } } @@ -217,6 +394,14 @@ struct EventHandler::Impl { ecore_event_handler_del( *iter ); } + +#ifdef DALI_ELDBUS_AVAILABLE + // Close down ElDBus connections. + if( mSystemConnection ) + { + eldbus_connection_unref( mSystemConnection ); + } +#endif // DALI_ELDBUS_AVAILABLE } // Static methods @@ -282,24 +467,6 @@ struct EventHandler::Impl } /** - * Called when a touch up is received. - */ - static Eina_Bool EcoreEventMouseWheel( void* data, int type, void* event ) - { - Ecore_Event_Mouse_Wheel *mouseWheelEvent( (Ecore_Event_Mouse_Wheel*)event ); - - 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); - - EventHandler* handler( (EventHandler*)data ); - if ( mouseWheelEvent->window == (unsigned int)ecore_wl_window_id_get(handler->mImpl->mWindow) ) - { - WheelEvent wheelEvent( WheelEvent::MOUSE_WHEEL, mouseWheelEvent->direction, mouseWheelEvent->modifiers, Vector2(mouseWheelEvent->x, mouseWheelEvent->y), mouseWheelEvent->z, mouseWheelEvent->timestamp ); - handler->SendWheelEvent( wheelEvent ); - } - return ECORE_CALLBACK_PASS_ON; - } - - /** * Called when a touch motion is received. */ static Eina_Bool EcoreEventMouseButtonMove( void* data, int type, void* event ) @@ -322,6 +489,46 @@ struct EventHandler::Impl return ECORE_CALLBACK_PASS_ON; } + /** + * Called when a touch is canceled. + */ + static Eina_Bool EcoreEventMouseButtonCancel( void* data, int type, void* event ) + { + Ecore_Event_Mouse_Button *touchEvent( (Ecore_Event_Mouse_Button*)event ); + EventHandler* handler( (EventHandler*)data ); + + if( touchEvent->window == (unsigned int)ecore_wl_window_id_get( handler->mImpl->mWindow ) ) + { + Integration::Point point; + point.SetDeviceId( touchEvent->multi.device ); + point.SetState( PointState::INTERRUPTED ); + point.SetScreenPosition( Vector2( 0.0f, 0.0f ) ); + handler->SendEvent( point, touchEvent->timestamp ); + + DALI_LOG_INFO( gImfLogging, Debug::General, "EVENT EcoreEventMouseButtonCancel\n" ); + } + + return ECORE_CALLBACK_PASS_ON; + } + + /** + * Called when a mouse wheel is received. + */ + static Eina_Bool EcoreEventMouseWheel( void* data, int type, void* event ) + { + Ecore_Event_Mouse_Wheel *mouseWheelEvent( (Ecore_Event_Mouse_Wheel*)event ); + + 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); + + EventHandler* handler( (EventHandler*)data ); + if ( mouseWheelEvent->window == (unsigned int)ecore_wl_window_id_get(handler->mImpl->mWindow) ) + { + WheelEvent wheelEvent( WheelEvent::MOUSE_WHEEL, mouseWheelEvent->direction, mouseWheelEvent->modifiers, Vector2(mouseWheelEvent->x, mouseWheelEvent->y), mouseWheelEvent->z, mouseWheelEvent->timestamp ); + handler->SendWheelEvent( wheelEvent ); + } + return ECORE_CALLBACK_PASS_ON; + } + ///////////////////////////////////////////////////////////////////////////////////////////////// // Key Callbacks ///////////////////////////////////////////////////////////////////////////////////////////////// @@ -358,10 +565,27 @@ struct EventHandler::Impl ecoreKeyDownEvent.timestamp = keyEvent->timestamp; ecoreKeyDownEvent.modifiers = EcoreInputModifierToEcoreIMFModifier ( keyEvent->modifiers ); ecoreKeyDownEvent.locks = (Ecore_IMF_Keyboard_Locks) ECORE_IMF_KEYBOARD_LOCK_NONE; - - eventHandled = ecore_imf_context_filter_event( imfContext, - ECORE_IMF_EVENT_KEY_DOWN, - (Ecore_IMF_Event *) &ecoreKeyDownEvent ); + ecoreKeyDownEvent.dev_name = ""; + ecoreKeyDownEvent.dev_class = ECORE_IMF_DEVICE_CLASS_KEYBOARD; + ecoreKeyDownEvent.dev_subclass = ECORE_IMF_DEVICE_SUBCLASS_NONE; + + std::string checkDevice; + GetDeviceName( keyEvent, checkDevice ); + + // If the device is IME and the focused key is the direction keys, then we should send a key event to move a key cursor. + if( ( checkDevice == "ime" ) && ( ( !strncmp( keyEvent->keyname, "Left", 4 ) ) || + ( !strncmp( keyEvent->keyname, "Right", 5 ) ) || + ( !strncmp( keyEvent->keyname, "Up", 2 ) ) || + ( !strncmp( keyEvent->keyname, "Down", 4 ) ) ) ) + { + eventHandled = 0; + } + else + { + eventHandled = ecore_imf_context_filter_event( imfContext, + ECORE_IMF_EVENT_KEY_DOWN, + (Ecore_IMF_Event *) &ecoreKeyDownEvent ); + } // If the event has not been handled by IMF then check if we should reset our IMF context if( !eventHandled ) @@ -396,7 +620,15 @@ struct EventHandler::Impl keyString = keyEvent->string; } - KeyEvent keyEvent(keyName, keyString, keyCode, modifier, time, KeyEvent::Down); + std::string deviceName; + DevelKeyEvent::DeviceClass::Type deviceClass; + + GetDeviceName( keyEvent, deviceName ); + GetDeviceClass( keyEvent, deviceClass ); + + DALI_LOG_INFO( gImfLogging, Debug::Verbose, "EVENT EcoreEventKeyDown - >>EcoreEventKeyDown deviceName(%s) deviceClass(%d)\n", deviceName.c_str(), deviceClass ); + + Integration::KeyEvent keyEvent(keyName, keyString, keyCode, modifier, time, Integration::KeyEvent::Down, deviceName, deviceClass ); handler->SendEvent( keyEvent ); } } @@ -436,6 +668,9 @@ struct EventHandler::Impl ecoreKeyUpEvent.timestamp = keyEvent->timestamp; ecoreKeyUpEvent.modifiers = EcoreInputModifierToEcoreIMFModifier ( keyEvent->modifiers ); ecoreKeyUpEvent.locks = (Ecore_IMF_Keyboard_Locks) ECORE_IMF_KEYBOARD_LOCK_NONE; + ecoreKeyUpEvent.dev_name = ""; + ecoreKeyUpEvent.dev_class = ECORE_IMF_DEVICE_CLASS_KEYBOARD; + ecoreKeyUpEvent.dev_subclass = ECORE_IMF_DEVICE_SUBCLASS_NONE; eventHandled = ecore_imf_context_filter_event( imfContext, ECORE_IMF_EVENT_KEY_UP, @@ -463,7 +698,13 @@ struct EventHandler::Impl keyString = keyEvent->string; } - KeyEvent keyEvent(keyName, keyString, keyCode, modifier, time, KeyEvent::Up); + std::string deviceName; + DevelKeyEvent::DeviceClass::Type deviceClass; + + GetDeviceName( keyEvent, deviceName ); + GetDeviceClass( keyEvent, deviceClass ); + + Integration::KeyEvent keyEvent(keyName, keyString, keyCode, modifier, time, Integration::KeyEvent::Up, deviceName, deviceClass ); handler->SendEvent( keyEvent ); } } @@ -502,7 +743,8 @@ struct EventHandler::Impl } } } - // No need to connect callbacks as KeyboardStatusChanged will be called. + Dali::Clipboard clipboard = Clipboard::Get(); + clipboard.HideClipboard(); } return ECORE_CALLBACK_PASS_ON; @@ -534,9 +776,13 @@ struct EventHandler::Impl } } - // Clipboard don't support that whether clipboard is shown or not. Hide clipboard. + // Hiding clipboard event will be ignored once because window focus out event is always received on showing clipboard Dali::Clipboard clipboard = Clipboard::Get(); - clipboard.HideClipboard(); + if ( clipboard ) + { + Clipboard& clipBoardImpl( GetImplementation( clipboard ) ); + clipBoardImpl.HideClipboard(true); + } } return ECORE_CALLBACK_PASS_ON; @@ -632,6 +878,311 @@ struct EventHandler::Impl return ECORE_CALLBACK_PASS_ON; } + + ///////////////////////////////////////////////////////////////////////////////////////////////// + // ElDBus Accessibility Callbacks + ///////////////////////////////////////////////////////////////////////////////////////////////// + +#ifdef DALI_ELDBUS_AVAILABLE + // Callback for Ecore ElDBus accessibility events. + static void OnEcoreElDBusAccessibilityNotification( void *context EINA_UNUSED, const Eldbus_Message *message ) + { + EventHandler* handler = static_cast< EventHandler* >( context ); + // Ignore any accessibility events when paused. + if( handler->mPaused ) + { + return; + } + + if( !handler->mAccessibilityAdaptor ) + { + DALI_LOG_ERROR( "Invalid accessibility adaptor\n" ); + return; + } + + AccessibilityAdaptor* accessibilityAdaptor( &AccessibilityAdaptor::GetImplementation( handler->mAccessibilityAdaptor ) ); + if( !accessibilityAdaptor ) + { + DALI_LOG_ERROR( "Cannot access accessibility adaptor\n" ); + return; + } + + int gestureValue; + int xS, yS, xE, yE; + int state; // 0 - begin, 1 - ongoing, 2 - ended, 3 - aborted + int eventTime; + + // The string defines the arg-list's respective types. + if( !eldbus_message_arguments_get( message, "iiiiiiu", &gestureValue, &xS, &yS, &xE, &yE, &state, &eventTime ) ) + { + DALI_LOG_ERROR( "OnEcoreElDBusAccessibilityNotification: Error getting arguments\n" ); + } + + DALI_LOG_INFO( gImfLogging, Debug::General, "Got gesture: Name: %d Args: %d,%d,%d,%d State: %d\n", gestureValue, xS, yS, xE, yE ); + + // Create a touch point object. + TouchPoint::State touchPointState( TouchPoint::Down ); + if( state == 0 ) + { + touchPointState = TouchPoint::Down; // Mouse down. + } + else if( state == 1 ) + { + touchPointState = TouchPoint::Motion; // Mouse move. + } + else if( state == 2 ) + { + touchPointState = TouchPoint::Up; // Mouse up. + } + else + { + touchPointState = TouchPoint::Interrupted; // Error. + } + + // Send touch event to accessibility adaptor. + TouchPoint point( 0, touchPointState, (float)xS, (float)yS ); + + // Perform actions based on received gestures. + // Note: This is seperated from the reading so we can have other input readers without changing the below code. + switch( gestureValue ) + { + case 0: // OneFingerHover + { + // Focus, read out. + accessibilityAdaptor->HandleActionReadEvent( (unsigned int)xS, (unsigned int)yS, true /* allow read again */ ); + break; + } + case 1: // TwoFingersHover + { + // In accessibility mode, scroll action should be handled when the currently focused actor is contained in scrollable control + accessibilityAdaptor->HandleActionScrollEvent( point, GetCurrentMilliSeconds() ); + break; + } + case 2: // ThreeFingersHover + { + // Read from top item on screen continuously. + accessibilityAdaptor->HandleActionReadFromTopEvent(); + break; + } + case 3: // OneFingerFlickLeft + { + // Move to previous item. + accessibilityAdaptor->HandleActionReadPreviousEvent(); + break; + } + case 4: // OneFingerFlickRight + { + // Move to next item. + accessibilityAdaptor->HandleActionReadNextEvent(); + break; + } + case 5: // OneFingerFlickUp + { + // Move to previous item. + accessibilityAdaptor->HandleActionPreviousEvent(); + break; + } + case 6: // OneFingerFlickDown + { + // Move to next item. + accessibilityAdaptor->HandleActionNextEvent(); + break; + } + case 7: // TwoFingersFlickUp + { + // Scroll up the list. + accessibilityAdaptor->HandleActionScrollUpEvent(); + break; + } + case 8: // TwoFingersFlickDown + { + // Scroll down the list. + accessibilityAdaptor->HandleActionScrollDownEvent(); + break; + } + case 9: // TwoFingersFlickLeft + { + // Scroll left to the previous page + accessibilityAdaptor->HandleActionPageLeftEvent(); + break; + } + case 10: // TwoFingersFlickRight + { + // Scroll right to the next page + accessibilityAdaptor->HandleActionPageRightEvent(); + break; + } + case 11: // ThreeFingersFlickLeft + { + // Not exist yet + break; + } + case 12: // ThreeFingersFlickRight + { + // Not exist yet + break; + } + case 13: // ThreeFingersFlickUp + { + // Not exist yet + break; + } + case 14: // ThreeFingersFlickDown + { + // Not exist yet + break; + } + case 15: // OneFingerSingleTap + { + // Focus, read out. + accessibilityAdaptor->HandleActionReadEvent( (unsigned int)xS, (unsigned int)yS, true /* allow read again */ ); + break; + } + case 16: // OneFingerDoubleTap + { + // Activate selected item / active edit mode. + accessibilityAdaptor->HandleActionActivateEvent(); + break; + } + case 17: // OneFingerTripleTap + { + // Zoom + accessibilityAdaptor->HandleActionZoomEvent(); + break; + } + case 18: // TwoFingersSingleTap + { + // Pause/Resume current speech + accessibilityAdaptor->HandleActionReadPauseResumeEvent(); + break; + } + case 19: // TwoFingersDoubleTap + { + // Start/Stop current action + accessibilityAdaptor->HandleActionStartStopEvent(); + break; + } + case 20: // TwoFingersTripleTap + { + // Read information from indicator + accessibilityAdaptor->HandleActionReadIndicatorInformationEvent(); + break; + } + case 21: // ThreeFingersSingleTap + { + // Read from top item on screen continuously. + accessibilityAdaptor->HandleActionReadFromTopEvent(); + break; + } + case 22: // ThreeFingersDoubleTap + { + // Read from next item continuously. + accessibilityAdaptor->HandleActionReadFromNextEvent(); + break; + } + case 23: // ThreeFingersTripleTap + { + // Not exist yet + break; + } + case 24: // OneFingerFlickLeftReturn + { + // Scroll up to the previous page + accessibilityAdaptor->HandleActionPageUpEvent(); + break; + } + case 25: // OneFingerFlickRightReturn + { + // Scroll down to the next page + accessibilityAdaptor->HandleActionPageDownEvent(); + break; + } + case 26: // OneFingerFlickUpReturn + { + // Move to the first item on screen + accessibilityAdaptor->HandleActionMoveToFirstEvent(); + break; + } + case 27: // OneFingerFlickDownReturn + { + // Move to the last item on screen + accessibilityAdaptor->HandleActionMoveToLastEvent(); + break; + } + case 28: // TwoFingersFlickLeftReturn + { + // Not exist yet + break; + } + case 29: // TwoFingersFlickRightReturn + { + // Not exist yet + break; + } + case 30: // TwoFingersFlickUpReturn + { + // Not exist yet + break; + } + case 31: // TwoFingersFlickDownReturn + { + // Not exist yet + break; + } + case 32: // ThreeFingersFlickLeftReturn + { + // Not exist yet + break; + } + case 33: // ThreeFingersFlickRightReturn + { + // Not exist yet + break; + } + case 34: // ThreeFingersFlickUpReturn + { + // Not exist yet + break; + } + case 35: // ThreeFingersFlickDownReturn + { + // Not exist yet + break; + } + } + } + + void EcoreElDBusInitialisation( void *handle ) + { + Eldbus_Object *object; + Eldbus_Proxy *manager; + + if( !( mSystemConnection = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM) ) ) + { + DALI_LOG_ERROR( "Unable to get system bus\n" ); + } + + object = eldbus_object_get( mSystemConnection, BUS, PATH ); + if( !object ) + { + DALI_LOG_ERROR( "Getting object failed\n" ); + return; + } + + manager = eldbus_proxy_get( object, INTERFACE ); + if( !manager ) + { + DALI_LOG_ERROR( "Getting proxy failed\n" ); + return; + } + + if( !eldbus_proxy_signal_handler_add( manager, "GestureDetected", OnEcoreElDBusAccessibilityNotification, handle ) ) + { + DALI_LOG_ERROR( "No signal handler returned\n" ); + } + } +#endif // DALI_ELDBUS_AVAILABLE + /** * Called when the source window notifies us the content in clipboard is selected. */ @@ -652,8 +1203,76 @@ struct EventHandler::Impl } /** - * Called when detent event is recevied - */ + * Called when the source window notifies us the content in clipboard is selected. + */ + static Eina_Bool EcoreEventDataSend( void* data, int type, void* event ) + { + DALI_LOG_INFO(gSelectionEventLogFilter, Debug::Concise, "EcoreEventDataSend\n" ); + + Dali::Clipboard clipboard = Clipboard::Get(); + if ( clipboard ) + { + Clipboard& clipBoardImpl( GetImplementation( clipboard ) ); + clipBoardImpl.ExcuteBuffered( true, event ); + } + return ECORE_CALLBACK_PASS_ON; + } + + /** + * Called when the source window sends us about the selected content. + * For example, when item is selected in the clipboard. + */ + static Eina_Bool EcoreEventDataReceive( void* data, int type, void* event ) + { + DALI_LOG_INFO(gSelectionEventLogFilter, Debug::Concise, "EcoreEventDataReceive\n" ); + + EventHandler* handler( (EventHandler*)data ); + Dali::Clipboard clipboard = Clipboard::Get(); + char *selectionData = NULL; + if ( clipboard ) + { + Clipboard& clipBoardImpl( GetImplementation( clipboard ) ); + selectionData = clipBoardImpl.ExcuteBuffered( false, event ); + } + if ( selectionData && handler->mClipboardEventNotifier ) + { + ClipboardEventNotifier& clipboardEventNotifier( ClipboardEventNotifier::GetImplementation( handler->mClipboardEventNotifier ) ); + std::string content( selectionData, strlen(selectionData) ); + + clipboardEventNotifier.SetContent( content ); + clipboardEventNotifier.EmitContentSelectedSignal(); + } + return ECORE_CALLBACK_PASS_ON; + } + + /* + * Called when rotate event is recevied + */ + static Eina_Bool EcoreEventRotate( void* data, int type, void* event ) + { + DALI_LOG_INFO( gSelectionEventLogFilter, Debug::Concise, "EcoreEventRotate\n" ); + + EventHandler* handler( (EventHandler*)data ); + Ecore_Wl_Event_Window_Rotate* ev( (Ecore_Wl_Event_Window_Rotate*)event ); + + if( ev->win != (unsigned int)ecore_wl_window_id_get( handler->mImpl->mWindow ) ) + { + return ECORE_CALLBACK_PASS_ON; + } + + RotationEvent rotationEvent; + rotationEvent.angle = ev->angle; + rotationEvent.winResize = 0; + rotationEvent.width = ev->w; + rotationEvent.height = ev->h; + handler->SendRotationPrepareEvent( rotationEvent ); + + return ECORE_CALLBACK_PASS_ON; + } + + /* + * Called when detent event is recevied + */ static Eina_Bool EcoreEventDetent( void* data, int type, void* event ) { DALI_LOG_INFO(gSelectionEventLogFilter, Debug::Concise, "EcoreEventDetent\n" ); @@ -692,10 +1311,13 @@ struct EventHandler::Impl EventHandler* mHandler; std::vector mEcoreEventHandler; Ecore_Wl_Window* mWindow; +#ifdef DALI_ELDBUS_AVAILABLE + Eldbus_Connection* mSystemConnection; +#endif // DALI_ELDBUS_AVAILABLE }; EventHandler::EventHandler( RenderSurface* surface, CoreEventInterface& coreEventInterface, GestureManager& gestureManager, DamageObserver& damageObserver, DragAndDropDetectorPtr dndDetector ) -: mCoreEventInterface(coreEventInterface), +: mCoreEventInterface( coreEventInterface ), mGestureManager( gestureManager ), mStyleMonitor( StyleMonitor::Get() ), mDamageObserver( damageObserver ), @@ -703,8 +1325,9 @@ EventHandler::EventHandler( RenderSurface* surface, CoreEventInterface& coreEven mDragAndDropDetector( dndDetector ), mAccessibilityAdaptor( AccessibilityAdaptor::Get() ), mClipboardEventNotifier( ClipboardEventNotifier::Get() ), - mClipboard(Clipboard::Get()), - mImpl( NULL ) + mClipboard( Clipboard::Get() ), + mImpl( NULL ), + mPaused( false ) { Ecore_Wl_Window* window = 0; @@ -740,7 +1363,7 @@ void EventHandler::SendEvent(Integration::Point& point, unsigned long timeStamp) Integration::TouchEventCombiner::EventDispatchType type = mCombiner.GetNextTouchEvent(point, timeStamp, touchEvent, hoverEvent); if(type != Integration::TouchEventCombiner::DispatchNone ) { - 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); + DALI_LOG_INFO(gTouchEventLogFilter, Debug::General, "%d: Device %d: Button state %d (%.2f, %.2f)\n", timeStamp, point.GetDeviceId(), point.GetState(), point.GetLocalPosition().x, point.GetLocalPosition().y); // First the touch and/or hover event & related gesture events are queued if(type == Integration::TouchEventCombiner::DispatchTouch || type == Integration::TouchEventCombiner::DispatchBoth) @@ -759,21 +1382,19 @@ void EventHandler::SendEvent(Integration::Point& point, unsigned long timeStamp) } } -void EventHandler::SendEvent(KeyEvent& keyEvent) +void EventHandler::SendEvent(Integration::KeyEvent& keyEvent) { Dali::PhysicalKeyboard physicalKeyboard = PhysicalKeyboard::Get(); if ( physicalKeyboard ) { - if ( ! KeyLookup::IsDeviceButton( keyEvent.keyPressedName.c_str() ) ) + if ( ! KeyLookup::IsDeviceButton( keyEvent.keyName.c_str() ) ) { GetImplementation( physicalKeyboard ).KeyReceived( keyEvent.time > 1 ); } } - // Create KeyEvent and send to Core. - Integration::KeyEvent event(keyEvent.keyPressedName, keyEvent.keyPressed, keyEvent.keyCode, - keyEvent.keyModifier, keyEvent.time, static_cast(keyEvent.state)); - mCoreEventInterface.QueueCoreEvent( event ); + // Create send KeyEvent to Core. + mCoreEventInterface.QueueCoreEvent( keyEvent ); mCoreEventInterface.ProcessCoreEvents(); } @@ -801,15 +1422,13 @@ void EventHandler::SendRotationPrepareEvent( const RotationEvent& event ) if( mRotationObserver != NULL ) { mRotationObserver->OnRotationPrepare( event ); + mRotationObserver->OnRotationRequest(); } } void EventHandler::SendRotationRequestEvent( ) { - if( mRotationObserver != NULL ) - { - mRotationObserver->OnRotationRequest( ); - } + // No need to separate event into prepare and request in wayland } void EventHandler::FeedTouchPoint( TouchPoint& point, int timeStamp) @@ -825,7 +1444,8 @@ void EventHandler::FeedWheelEvent( WheelEvent& wheelEvent ) void EventHandler::FeedKeyEvent( KeyEvent& event ) { - SendEvent( event ); + Integration::KeyEvent convertedEvent( event ); + SendEvent( convertedEvent ); } void EventHandler::FeedEvent( Integration::Event& event ) @@ -879,3 +1499,5 @@ void EventHandler::SetRotationObserver( RotationObserver* observer ) } // namespace Internal } // namespace Dali + +#pragma GCC diagnostic pop