#endif // DALI_ELDBUS_AVAILABLE
#include <dali/public-api/common/vector-wrapper.h>
+#include <dali/public-api/events/device.h>
#include <dali/public-api/events/touch-point.h>
#include <dali/public-api/events/key-event.h>
#include <dali/public-api/events/wheel-event.h>
#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/integration-api/events/hover-event-integ.h>
#include <dali/integration-api/events/wheel-event-integ.h>
-#include <dali/devel-api/events/device.h>
// INTERNAL INCLUDES
#include <events/gesture-manager.h>
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
+
+/**
+ * EcoreInputModifierToEcoreIMFLock function converts from Ecore_Event_Modifier to Ecore_IMF_Keyboard_Locks enums.
+ * @param[in] modifier the Ecore_Event_Modifier input.
+ * @return the Ecore_IMF_Keyboard_Locks output.
+ */
+Ecore_IMF_Keyboard_Locks EcoreInputModifierToEcoreIMFLock( unsigned int modifier )
+{
+ unsigned int lock( ECORE_IMF_KEYBOARD_LOCK_NONE ); // If no other matches, returns NONE.
+
+ if( modifier & ECORE_EVENT_LOCK_NUM )
+ {
+ lock |= ECORE_IMF_KEYBOARD_LOCK_NUM; // Num lock is active.
+ }
+
+ if( modifier & ECORE_EVENT_LOCK_CAPS )
+ {
+ lock |= ECORE_IMF_KEYBOARD_LOCK_CAPS; // Caps lock is active.
+ }
+
+ if( modifier & ECORE_EVENT_LOCK_SCROLL )
+ {
+ lock |= ECORE_IMF_KEYBOARD_LOCK_SCROLL; // Scroll lock is active.
+ }
+
+ return static_cast<Ecore_IMF_Keyboard_Locks>( lock );
+}
+
/**
* 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.
*/
Ecore_IMF_Keyboard_Modifiers EcoreInputModifierToEcoreIMFModifier(unsigned int ecoreModifier)
{
- int modifier( ECORE_IMF_KEYBOARD_MODIFIER_NONE ); // If no other matches returns NONE.
+ unsigned int modifier( ECORE_IMF_KEYBOARD_MODIFIER_NONE ); // If no other matches returns NONE.
if ( ecoreModifier & ECORE_EVENT_MODIFIER_SHIFT ) // enums from ecore_input/Ecore_Input.h
/**
* Get the device class from the provided ecore event
*/
-void GetDeviceClass( Ecore_Device_Class ecoreDeviceClass, DevelDevice::Class::Type& deviceClass )
+void GetDeviceClass( Ecore_Device_Class ecoreDeviceClass, Device::Class::Type& deviceClass )
{
switch( ecoreDeviceClass )
{
case ECORE_DEVICE_CLASS_SEAT:
{
- deviceClass = DevelDevice::Class::USER;
+ deviceClass = Device::Class::USER;
break;
}
case ECORE_DEVICE_CLASS_KEYBOARD:
{
- deviceClass = DevelDevice::Class::KEYBOARD;
+ deviceClass = Device::Class::KEYBOARD;
break;
}
case ECORE_DEVICE_CLASS_MOUSE:
{
- deviceClass = DevelDevice::Class::MOUSE;
+ deviceClass = Device::Class::MOUSE;
break;
}
case ECORE_DEVICE_CLASS_TOUCH:
{
- deviceClass = DevelDevice::Class::TOUCH;
+ deviceClass = Device::Class::TOUCH;
break;
}
case ECORE_DEVICE_CLASS_PEN:
{
- deviceClass = DevelDevice::Class::PEN;
+ deviceClass = Device::Class::PEN;
break;
}
case ECORE_DEVICE_CLASS_POINTER:
{
- deviceClass = DevelDevice::Class::POINTER;
+ deviceClass = Device::Class::POINTER;
break;
}
case ECORE_DEVICE_CLASS_GAMEPAD:
{
- deviceClass = DevelDevice::Class::GAMEPAD;
+ deviceClass = Device::Class::GAMEPAD;
break;
}
default:
{
- deviceClass = DevelDevice::Class::NONE;
+ deviceClass = Device::Class::NONE;
break;
}
}
}
-void GetDeviceSubclass( Ecore_Device_Subclass ecoreDeviceSubclass, DevelDevice::Subclass::Type& deviceSubclass )
+void GetDeviceSubclass( Ecore_Device_Subclass ecoreDeviceSubclass, Device::Subclass::Type& deviceSubclass )
{
switch( ecoreDeviceSubclass )
{
case ECORE_DEVICE_SUBCLASS_FINGER:
{
- deviceSubclass = DevelDevice::Subclass::FINGER;
+ deviceSubclass = Device::Subclass::FINGER;
break;
}
case ECORE_DEVICE_SUBCLASS_FINGERNAIL:
{
- deviceSubclass = DevelDevice::Subclass::FINGERNAIL;
+ deviceSubclass = Device::Subclass::FINGERNAIL;
break;
}
case ECORE_DEVICE_SUBCLASS_KNUCKLE:
{
- deviceSubclass = DevelDevice::Subclass::KNUCKLE;
+ deviceSubclass = Device::Subclass::KNUCKLE;
break;
}
case ECORE_DEVICE_SUBCLASS_PALM:
{
- deviceSubclass = DevelDevice::Subclass::PALM;
+ deviceSubclass = Device::Subclass::PALM;
break;
}
case ECORE_DEVICE_SUBCLASS_HAND_SIZE:
{
- deviceSubclass = DevelDevice::Subclass::HAND_SIDE;
+ deviceSubclass = Device::Subclass::HAND_SIDE;
break;
}
case ECORE_DEVICE_SUBCLASS_HAND_FLAT:
{
- deviceSubclass = DevelDevice::Subclass::HAND_FLAT;
+ deviceSubclass = Device::Subclass::HAND_FLAT;
break;
}
case ECORE_DEVICE_SUBCLASS_PEN_TIP:
{
- deviceSubclass = DevelDevice::Subclass::PEN_TIP;
+ deviceSubclass = Device::Subclass::PEN_TIP;
break;
}
case ECORE_DEVICE_SUBCLASS_TRACKPAD:
{
- deviceSubclass = DevelDevice::Subclass::TRACKPAD;
+ deviceSubclass = Device::Subclass::TRACKPAD;
break;
}
case ECORE_DEVICE_SUBCLASS_TRACKPOINT:
{
- deviceSubclass = DevelDevice::Subclass::TRACKPOINT;
+ deviceSubclass = Device::Subclass::TRACKPOINT;
break;
}
case ECORE_DEVICE_SUBCLASS_TRACKBALL:
{
- deviceSubclass = DevelDevice::Subclass::TRACKBALL;
+ deviceSubclass = Device::Subclass::TRACKBALL;
+ break;
+ }
+#ifdef OVER_TIZEN_VERSION_4
+ case ECORE_DEVICE_SUBCLASS_REMOCON:
+ {
+ deviceSubclass = Device::Subclass::REMOCON;
break;
}
+ case ECORE_DEVICE_SUBCLASS_VIRTUAL_KEYBOARD:
+ {
+ deviceSubclass = Device::Subclass::VIRTUAL_KEYBOARD;
+ break;
+ }
+#endif
default:
{
- deviceSubclass = DevelDevice::Subclass::NONE;
+ deviceSubclass = Device::Subclass::NONE;
break;
}
}
state = PointState::INTERRUPTED;
}
- DevelDevice::Class::Type deviceClass;
- DevelDevice::Subclass::Type deviceSubclass;
+ Device::Class::Type deviceClass;
+ Device::Subclass::Type deviceSubclass;
GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass );
GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass );
if ( touchEvent->window == (unsigned int)ecore_wl_window_id_get(handler->mImpl->mWindow) )
{
- DevelDevice::Class::Type deviceClass;
- DevelDevice::Subclass::Type deviceSubclass;
+ Device::Class::Type deviceClass;
+ Device::Subclass::Type deviceSubclass;
GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass );
GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass );
if ( touchEvent->window == (unsigned int)ecore_wl_window_id_get(handler->mImpl->mWindow) )
{
- DevelDevice::Class::Type deviceClass;
- DevelDevice::Subclass::Type deviceSubclass;
+ Device::Class::Type deviceClass;
+ Device::Subclass::Type deviceSubclass;
GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass );
GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass );
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 ) );
+ point.SetScreenPosition( Vector2( touchEvent->x, touchEvent->y ) );
handler->SendEvent( point, touchEvent->timestamp );
DALI_LOG_INFO( gImfLogging, Debug::General, "EVENT EcoreEventMouseButtonCancel\n" );
ecoreKeyDownEvent.compose = keyEvent->compose;
ecoreKeyDownEvent.timestamp = keyEvent->timestamp;
ecoreKeyDownEvent.modifiers = EcoreInputModifierToEcoreIMFModifier ( keyEvent->modifiers );
- ecoreKeyDownEvent.locks = (Ecore_IMF_Keyboard_Locks) ECORE_IMF_KEYBOARD_LOCK_NONE;
- ecoreKeyDownEvent.dev_name = "";
- ecoreKeyDownEvent.dev_class = ECORE_IMF_DEVICE_CLASS_KEYBOARD;
- ecoreKeyDownEvent.dev_subclass = ECORE_IMF_DEVICE_SUBCLASS_NONE;
+ ecoreKeyDownEvent.locks = EcoreInputModifierToEcoreIMFLock( keyEvent->modifiers );
+ ecoreKeyDownEvent.dev_name = ecore_device_name_get( keyEvent->dev );
+ ecoreKeyDownEvent.dev_class = static_cast<Ecore_IMF_Device_Class>( ecore_device_class_get( keyEvent->dev ) );
+ ecoreKeyDownEvent.dev_subclass = static_cast<Ecore_IMF_Device_Subclass>( ecore_device_subclass_get( keyEvent->dev ) );
std::string checkDevice;
GetDeviceName( keyEvent, checkDevice );
{
if ( !strcmp( keyEvent->keyname, "Escape" ) ||
!strcmp( keyEvent->keyname, "Return" ) ||
- !strcmp( keyEvent->keyname, "KP_Enter" ) )
+ !strcmp( keyEvent->keyname, "KP_Enter" ) ||
+ !strcmp( keyEvent->keyname, "XF86Exit" ) )
{
+ ecore_imf_context_input_panel_hide( imfContext );
ecore_imf_context_reset( imfContext );
}
}
}
std::string deviceName;
- DevelDevice::Class::Type deviceClass;
- DevelDevice::Subclass::Type deviceSubclass;
+ Device::Class::Type deviceClass;
+ Device::Subclass::Type deviceSubclass;
GetDeviceName( keyEvent, deviceName );
GetDeviceClass( ecore_device_class_get( keyEvent->dev ), deviceClass );
ecoreKeyUpEvent.compose = keyEvent->compose;
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;
+ ecoreKeyUpEvent.locks = EcoreInputModifierToEcoreIMFLock( keyEvent->modifiers );
+ ecoreKeyUpEvent.dev_name = ecore_device_name_get( keyEvent->dev );
+ ecoreKeyUpEvent.dev_class = static_cast<Ecore_IMF_Device_Class>( ecore_device_class_get( keyEvent->dev ) );
+ ecoreKeyUpEvent.dev_subclass = static_cast<Ecore_IMF_Device_Subclass>( ecore_device_subclass_get( keyEvent->dev ) );
eventHandled = ecore_imf_context_filter_event( imfContext,
ECORE_IMF_EVENT_KEY_UP,
}
std::string deviceName;
- DevelDevice::Class::Type deviceClass;
- DevelDevice::Subclass::Type deviceSubclass;
+ Device::Class::Type deviceClass;
+ Device::Subclass::Type deviceSubclass;
GetDeviceName( keyEvent, deviceName );
GetDeviceClass( ecore_device_class_get( keyEvent->dev ), deviceClass );