X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=adaptors%2Fecore%2Fwayland%2Fevent-handler-ecore-wl.cpp;h=4634859500cd333b2b0a22c73cd2a1861e5b301f;hb=3e6f1441cbb782e8924b808081e4a263b1326f8d;hp=3033ba3f10e899c9d5ceb9a4e217b1d735581c50;hpb=c06d972e65c4816bded223d339ae3eec1a2b57c7;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 old mode 100644 new mode 100755 index 3033ba3..4634859 --- a/adaptors/ecore/wayland/event-handler-ecore-wl.cpp +++ b/adaptors/ecore/wayland/event-handler-ecore-wl.cpp @@ -39,6 +39,7 @@ #endif // DALI_ELDBUS_AVAILABLE #include +#include #include #include #include @@ -47,7 +48,6 @@ #include #include #include -#include // INTERNAL INCLUDES #include @@ -169,6 +169,33 @@ const unsigned int DirectionStringsTotal = sizeof( ElDBusAccessibilityDirectionS #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( 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. * @param[in] ecoreModifier the Ecore_Event_Modifier input. @@ -176,7 +203,7 @@ const unsigned int DirectionStringsTotal = sizeof( ElDBusAccessibilityDirectionS */ 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 @@ -251,7 +278,7 @@ const char * DALI_VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE = "db/setting/accessi /** * Get the device name from the provided ecore key event */ -void GetDeviceName( Ecore_Event_Key* keyEvent, std::string& result ) +void GetDeviceName( Ecore_Event_Key* keyEvent, std::string& result ) { const char* ecoreDeviceName = ecore_device_name_get( keyEvent->dev ); @@ -262,52 +289,124 @@ void GetDeviceName( Ecore_Event_Key* keyEvent, std::string& result ) } /** - * Get the device class from the provided ecore key event + * Get the device class from the provided ecore event */ -void GetDeviceClass( Ecore_Event_Key* keyEvent, DevelKeyEvent::DeviceClass::Type& deviceClass ) +void GetDeviceClass( Ecore_Device_Class ecoreDeviceClass, Device::Class::Type& deviceClass ) { - Ecore_Device_Class ecoreDeviceClass = ecore_device_class_get( keyEvent->dev ); - switch( ecoreDeviceClass ) { case ECORE_DEVICE_CLASS_SEAT: { - deviceClass = DevelKeyEvent::DeviceClass::USER; + deviceClass = Device::Class::USER; break; } case ECORE_DEVICE_CLASS_KEYBOARD: { - deviceClass = DevelKeyEvent::DeviceClass::KEYBOARD; + deviceClass = Device::Class::KEYBOARD; break; } case ECORE_DEVICE_CLASS_MOUSE: { - deviceClass = DevelKeyEvent::DeviceClass::MOUSE; + deviceClass = Device::Class::MOUSE; break; } case ECORE_DEVICE_CLASS_TOUCH: { - deviceClass = DevelKeyEvent::DeviceClass::TOUCH; + deviceClass = Device::Class::TOUCH; break; } case ECORE_DEVICE_CLASS_PEN: { - deviceClass = DevelKeyEvent::DeviceClass::PEN; + deviceClass = Device::Class::PEN; break; } case ECORE_DEVICE_CLASS_POINTER: { - deviceClass = DevelKeyEvent::DeviceClass::POINTER; + deviceClass = Device::Class::POINTER; break; } case ECORE_DEVICE_CLASS_GAMEPAD: { - deviceClass = DevelKeyEvent::DeviceClass::GAMEPAD; + deviceClass = Device::Class::GAMEPAD; break; } default: { - deviceClass = DevelKeyEvent::DeviceClass::NONE; + deviceClass = Device::Class::NONE; + break; + } + } +} + +void GetDeviceSubclass( Ecore_Device_Subclass ecoreDeviceSubclass, Device::Subclass::Type& deviceSubclass ) +{ + switch( ecoreDeviceSubclass ) + { + case ECORE_DEVICE_SUBCLASS_FINGER: + { + deviceSubclass = Device::Subclass::FINGER; + break; + } + case ECORE_DEVICE_SUBCLASS_FINGERNAIL: + { + deviceSubclass = Device::Subclass::FINGERNAIL; + break; + } + case ECORE_DEVICE_SUBCLASS_KNUCKLE: + { + deviceSubclass = Device::Subclass::KNUCKLE; + break; + } + case ECORE_DEVICE_SUBCLASS_PALM: + { + deviceSubclass = Device::Subclass::PALM; + break; + } + case ECORE_DEVICE_SUBCLASS_HAND_SIZE: + { + deviceSubclass = Device::Subclass::HAND_SIDE; + break; + } + case ECORE_DEVICE_SUBCLASS_HAND_FLAT: + { + deviceSubclass = Device::Subclass::HAND_FLAT; + break; + } + case ECORE_DEVICE_SUBCLASS_PEN_TIP: + { + deviceSubclass = Device::Subclass::PEN_TIP; + break; + } + case ECORE_DEVICE_SUBCLASS_TRACKPAD: + { + deviceSubclass = Device::Subclass::TRACKPAD; + break; + } + case ECORE_DEVICE_SUBCLASS_TRACKPOINT: + { + deviceSubclass = Device::Subclass::TRACKPOINT; + break; + } + case ECORE_DEVICE_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 = Device::Subclass::NONE; break; } } @@ -341,7 +440,6 @@ struct EventHandler::Impl 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 @@ -433,6 +531,12 @@ struct EventHandler::Impl state = PointState::INTERRUPTED; } + Device::Class::Type deviceClass; + Device::Subclass::Type deviceSubclass; + + GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass ); + GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass ); + Integration::Point point; point.SetDeviceId( touchEvent->multi.device ); point.SetState( state ); @@ -440,6 +544,9 @@ struct EventHandler::Impl point.SetRadius( touchEvent->multi.radius, Vector2( touchEvent->multi.radius_x, touchEvent->multi.radius_y ) ); point.SetPressure( touchEvent->multi.pressure ); point.SetAngle( Degree( touchEvent->multi.angle ) ); + point.SetDeviceClass( deviceClass ); + point.SetDeviceSubclass( deviceSubclass ); + handler->SendEvent( point, touchEvent->timestamp ); } @@ -456,6 +563,12 @@ struct EventHandler::Impl if ( touchEvent->window == (unsigned int)ecore_wl_window_id_get(handler->mImpl->mWindow) ) { + Device::Class::Type deviceClass; + Device::Subclass::Type deviceSubclass; + + GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass ); + GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass ); + Integration::Point point; point.SetDeviceId( touchEvent->multi.device ); point.SetState( PointState::UP ); @@ -463,6 +576,9 @@ struct EventHandler::Impl point.SetRadius( touchEvent->multi.radius, Vector2( touchEvent->multi.radius_x, touchEvent->multi.radius_y ) ); point.SetPressure( touchEvent->multi.pressure ); point.SetAngle( Degree( touchEvent->multi.angle ) ); + point.SetDeviceClass( deviceClass ); + point.SetDeviceSubclass( deviceSubclass ); + handler->SendEvent( point, touchEvent->timestamp ); } @@ -479,6 +595,12 @@ struct EventHandler::Impl if ( touchEvent->window == (unsigned int)ecore_wl_window_id_get(handler->mImpl->mWindow) ) { + Device::Class::Type deviceClass; + Device::Subclass::Type deviceSubclass; + + GetDeviceClass( ecore_device_class_get( touchEvent->dev ), deviceClass ); + GetDeviceSubclass( ecore_device_subclass_get( touchEvent->dev ), deviceSubclass ); + Integration::Point point; point.SetDeviceId( touchEvent->multi.device ); point.SetState( PointState::MOTION ); @@ -486,6 +608,9 @@ struct EventHandler::Impl point.SetRadius( touchEvent->multi.radius, Vector2( touchEvent->multi.radius_x, touchEvent->multi.radius_y ) ); point.SetPressure( touchEvent->multi.pressure ); point.SetAngle( Degree( touchEvent->multi.angle ) ); + point.SetDeviceClass( deviceClass ); + point.SetDeviceSubclass( deviceSubclass ); + handler->SendEvent( point, touchEvent->timestamp ); } @@ -503,9 +628,8 @@ struct EventHandler::Impl 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" ); @@ -567,10 +691,10 @@ struct EventHandler::Impl 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_device_class_get( keyEvent->dev ) ); + ecoreKeyDownEvent.dev_subclass = static_cast( ecore_device_subclass_get( keyEvent->dev ) ); std::string checkDevice; GetDeviceName( keyEvent, checkDevice ); @@ -595,8 +719,10 @@ struct EventHandler::Impl { 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 ); } } @@ -624,14 +750,16 @@ struct EventHandler::Impl } std::string deviceName; - DevelKeyEvent::DeviceClass::Type deviceClass; + Device::Class::Type deviceClass; + Device::Subclass::Type deviceSubclass; GetDeviceName( keyEvent, deviceName ); - GetDeviceClass( keyEvent, deviceClass ); + GetDeviceClass( ecore_device_class_get( keyEvent->dev ), deviceClass ); + GetDeviceSubclass( ecore_device_subclass_get( keyEvent->dev ), deviceSubclass ); 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 ); + Integration::KeyEvent keyEvent(keyName, keyString, keyCode, modifier, time, Integration::KeyEvent::Down, deviceName, deviceClass, deviceSubclass ); handler->SendEvent( keyEvent ); } } @@ -670,10 +798,10 @@ struct EventHandler::Impl 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_device_class_get( keyEvent->dev ) ); + ecoreKeyUpEvent.dev_subclass = static_cast( ecore_device_subclass_get( keyEvent->dev ) ); eventHandled = ecore_imf_context_filter_event( imfContext, ECORE_IMF_EVENT_KEY_UP, @@ -702,12 +830,14 @@ struct EventHandler::Impl } std::string deviceName; - DevelKeyEvent::DeviceClass::Type deviceClass; + Device::Class::Type deviceClass; + Device::Subclass::Type deviceSubclass; GetDeviceName( keyEvent, deviceName ); - GetDeviceClass( keyEvent, deviceClass ); + GetDeviceClass( ecore_device_class_get( keyEvent->dev ), deviceClass ); + GetDeviceSubclass( ecore_device_subclass_get( keyEvent->dev ), deviceSubclass ); - Integration::KeyEvent keyEvent(keyName, keyString, keyCode, modifier, time, Integration::KeyEvent::Up, deviceName, deviceClass ); + Integration::KeyEvent keyEvent(keyName, keyString, keyCode, modifier, time, Integration::KeyEvent::Up, deviceName, deviceClass, deviceSubclass ); handler->SendEvent( keyEvent ); } }