const unsigned long timeStamp(132);
const Integration::KeyEvent::State keyState(Integration::KeyEvent::Up);
const std::string deviceName("hwKeyboard");
+ const DevelKeyEvent::DeviceClass::Type deviceClass = DevelKeyEvent::DeviceClass::KEYBOARD;
- Integration::KeyEvent keyEvent(keyName, keyString, keyCode, keyModifier, timeStamp, keyState, deviceName );
+ Integration::KeyEvent keyEvent(keyName, keyString, keyCode, keyModifier, timeStamp, keyState, deviceName, deviceClass );
DALI_TEST_EQUALS( keyEvent.type, Integration::Event::Key, TEST_LOCATION );
DALI_TEST_CHECK( keyEvent.keyName == keyName );
DALI_TEST_CHECK( keyEvent.keyString == keyString );
DALI_TEST_EQUALS( keyEvent.time, timeStamp, TEST_LOCATION );
DALI_TEST_EQUALS( keyEvent.state, keyState, TEST_LOCATION);
DALI_TEST_EQUALS( keyEvent.deviceName, deviceName, TEST_LOCATION);
+ DALI_TEST_EQUALS( keyEvent.deviceClass, deviceClass, TEST_LOCATION);
}
END_TEST;
}
DALI_TEST_EQUALS( keyEvent.time, 0lu, TEST_LOCATION );
DALI_TEST_EQUALS( keyEvent.state, Integration::KeyEvent::Down, TEST_LOCATION);
DALI_TEST_EQUALS( keyEvent.deviceName, "", TEST_LOCATION);
+ DALI_TEST_EQUALS( keyEvent.deviceClass, DevelKeyEvent::DeviceClass::NONE, TEST_LOCATION);
END_TEST;
}
END_TEST;
}
+
+int UtcDaliKeyEventSetDeviceClass(void)
+{
+ TestApplication application;
+
+ KeyEvent event(TEST_STRING_1,"i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down);
+
+ DALI_TEST_EQUALS( DevelKeyEvent::GetDeviceClass( event ), DevelKeyEvent::DeviceClass::NONE, TEST_LOCATION);
+
+ DevelKeyEvent::SetDeviceClass( event, DevelKeyEvent::DeviceClass::TOUCH );
+
+ DALI_TEST_EQUALS( DevelKeyEvent::GetDeviceClass( event ), DevelKeyEvent::DeviceClass::TOUCH, TEST_LOCATION);
+
+ KeyEvent event2;
+ DALI_TEST_EQUALS( DevelKeyEvent::GetDeviceClass( event2 ), DevelKeyEvent::DeviceClass::NONE, TEST_LOCATION);
+
+ END_TEST;
+}
{
const std::string DEFAULT_DEVICE_NAME("hwKeyboard");
+const DevelKeyEvent::DeviceClass::Type DEFAULT_DEVICE_CLASS( DevelKeyEvent::DeviceClass::TOUCH );
// Functor for EventProcessingFinished signal
struct EventProcessingFinishedFunctor
KeyEventGeneratedReceivedFunctor functor2( data2 );
GetImplementation( stage ).ConnectSignal( &application, "keyEventGenerated", functor2 );
- Integration::KeyEvent event( "a", "a", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME );
+ Integration::KeyEvent event( "a", "a", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME, DEFAULT_DEVICE_CLASS );
application.ProcessEvent( event );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
data.Reset();
- Integration::KeyEvent event2( "i", "i", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME );
+ Integration::KeyEvent event2( "i", "i", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME, DEFAULT_DEVICE_CLASS );
application.ProcessEvent( event2 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
data.Reset();
- Integration::KeyEvent event3( "a", "a", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME );
+ Integration::KeyEvent event3( "a", "a", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DEFAULT_DEVICE_CLASS );
application.ProcessEvent( event3 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
data.Reset();
- Integration::KeyEvent event4( "a", "a", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME );
+ Integration::KeyEvent event4( "a", "a", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME, DEFAULT_DEVICE_CLASS );
application.ProcessEvent( event4 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
KeyEventReceivedFunctor functor( data );
stage.KeyEventSignal().Connect( &application, functor );
- Integration::KeyEvent event( "i", "i", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME );
+ Integration::KeyEvent event( "i", "i", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DEFAULT_DEVICE_CLASS );
application.ProcessEvent( event );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
data.Reset();
- Integration::KeyEvent event2( "i", "i", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME );
+ Integration::KeyEvent event2( "i", "i", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME, DEFAULT_DEVICE_CLASS );
application.ProcessEvent( event2 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
data.Reset();
- Integration::KeyEvent event3( "a", "a", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME );
+ Integration::KeyEvent event3( "a", "a", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME, DEFAULT_DEVICE_CLASS );
application.ProcessEvent( event3 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
data.Reset();
- Integration::KeyEvent event4( "a", "a", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME );
+ Integration::KeyEvent event4( "a", "a", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME, DEFAULT_DEVICE_CLASS );
application.ProcessEvent( event4 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
namespace DevelKeyEvent
{
- /**
- * @brief Get the device name the key event originated from
- *
- * @param[in] keyEvent the KeyEvent to retrieve the device name from
- * @return the device name
- */
- std::string GetDeviceName( const KeyEvent& keyEvent );
-
- /**
- * @brief Set the device name to the KeyEvent
- *
- * @param[in] keyEvent the KeyEvent to set the device name on
- * @param[in] deviceName device name string to set
- */
- void SetDeviceName( KeyEvent& keyEvent, const std::string& deviceName );
-
-}
-
-}
+
+namespace DeviceClass
+{
+
+/**
+ * @brief An enum of Device Classe types.
+ */
+enum Type
+{
+ NONE, ///< Not a device
+ SEAT, ///< The user/seat (the user themselves)
+ KEYBOARD, ///< A regular keyboard, numberpad or attached buttons
+ MOUSE, ///< A mouse, trackball or touchpad relative motion device
+ TOUCH, ///< A touchscreen with fingers or stylus
+ PEN, ///< A special pen device
+ POINTER, ///< A laser pointer, wii-style or 7"minority report" pointing device
+ GAMEPAD ///< A gamepad controller or joystick
+};
+
+} // namespace DeviceClass
+
+/**
+ * @brief Get the device name the key event originated from
+ *
+ * @param[in] keyEvent The KeyEvent to retrieve the device name from
+ * @return The device name
+ */
+DALI_IMPORT_API std::string GetDeviceName( const KeyEvent& keyEvent );
+
+/**
+ * @brief Set the device name to the KeyEvent
+ *
+ * @param[in] keyEvent The KeyEvent to set the device name on
+ * @param[in] deviceName Device name string to set
+ */
+DALI_IMPORT_API void SetDeviceName( KeyEvent& keyEvent, const std::string& deviceName );
+
+/**
+ * @brief Get the device class the key event originated from
+ *
+ * @param[in] keyEvent The KeyEvent to retrieve the device class from
+ * @return The device class
+ */
+DALI_IMPORT_API DeviceClass::Type GetDeviceClass( const KeyEvent& keyEvent );
+
+/**
+ * @brief Set the device class to the KeyEvent
+ *
+ * @param[in] keyEvent The KeyEvent to set the device class on
+ * @param[in] deviceClass Device class to set
+ */
+DALI_IMPORT_API void SetDeviceClass( KeyEvent& keyEvent, const DeviceClass::Type& deviceClass );
+
+} // namespace DevelKeyEvent
+
+} // namespace Dali
#endif //DALI_KEY_EVENT_DEVEL_H
{
KeyEvent::KeyEvent()
-: Event(Key),
+: Event( Key ),
keyName(),
keyString(),
- keyCode(-1),
- keyModifier(0),
- time(0),
- state(KeyEvent::Down),
- deviceName("")
+ keyCode( -1 ),
+ keyModifier( 0 ),
+ time( 0 ),
+ state( KeyEvent::Down ),
+ deviceName( "" ),
+ deviceClass( DevelKeyEvent::DeviceClass::NONE )
{
}
KeyEvent::KeyEvent( const std::string& keyName, const std::string& keyString, int keyCode, int keyModifier,
- unsigned long timeStamp, const State& keyState, const std::string deviceName )
-: Event(Key),
- keyName(keyName),
- keyString(keyString),
- keyCode(keyCode),
- keyModifier(keyModifier),
- time(timeStamp),
- state(keyState),
- deviceName(deviceName)
+ unsigned long timeStamp, const State& keyState, const std::string deviceName, const DevelKeyEvent::DeviceClass::Type deviceClass )
+: Event( Key ),
+ keyName( keyName ),
+ keyString( keyString ),
+ keyCode( keyCode ),
+ keyModifier( keyModifier ),
+ time( timeStamp ),
+ state( keyState ),
+ deviceName( deviceName ),
+ deviceClass( deviceClass )
{
}
KeyEvent::KeyEvent( const Dali::KeyEvent& event )
-: Event(Key),
+: Event( Key ),
keyName( event.keyPressedName ),
keyString( event.keyPressed ),
keyCode( event.keyCode ),
keyModifier( event.keyModifier ),
time( event.time ),
state( static_cast< Integration::KeyEvent::State >( event.state ) ),
- deviceName("")
+ deviceName( "" ),
+ deviceClass( DevelKeyEvent::DeviceClass::NONE )
{
}
// INTERNAL INCLUDES
#include <dali/integration-api/events/event.h>
#include <dali/public-api/events/key-event.h>
+#include <dali/devel-api/events/key-event-devel.h>
namespace Dali DALI_IMPORT_API
{
* @param[in] timeStamp The time (in ms) that the key event occurred.
* @param[in] keyState The state of the key event.
* @param[in] deviceName Name of device KeyEvent originated from
+ * @param[in] deviceClass Class of device KeyEvent originated from
*/
KeyEvent(const std::string& keyName,
const std::string& keyString,
int keyModifier,
unsigned long timeStamp,
const State& keyState,
- const std::string deviceName );
+ const std::string deviceName,
+ const DevelKeyEvent::DeviceClass::Type deviceClass );
/*
* Constructor, creates a Integration::KeyEvent from a Dali::KeyEvent
*/
std::string deviceName;
+ /**
+ * Class of device KeyEvent originated from
+ */
+ DevelKeyEvent::DeviceClass::Type deviceClass;
};
} // namespace Integration
bool consumed = false;
KeyEvent keyEvent(event.keyName, event.keyString, event.keyCode, event.keyModifier, event.time, static_cast<KeyEvent::State>(event.state));
DevelKeyEvent::SetDeviceName( keyEvent, event.deviceName );
+ DevelKeyEvent::SetDeviceClass( keyEvent, event.deviceClass );
+
// Emit the key event signal from stage.
consumed = mStage.EmitKeyEventGeneratedSignal( keyEvent );
struct KeyEventImpl
{
KeyEventImpl()
- :deviceName("")
+ : deviceName( "" ),
+ deviceClass( DevelKeyEvent::DeviceClass::NONE )
{
- };
+ }
KeyEventImpl& operator=( const KeyEventImpl& rhs )
{
if( this != &rhs )
{
deviceName = rhs.deviceName;
+ deviceClass = rhs.deviceClass;
}
return *this;
KeyEventImpl( const KeyEventImpl& rhs )
{
deviceName = rhs.deviceName;
+ deviceClass = rhs.deviceClass;
}
std::string deviceName;
+ DevelKeyEvent::DeviceClass::Type deviceClass;
};
typedef std::map< const KeyEvent*, KeyEventImpl*> KeyEventMap;
}
}
+DevelKeyEvent::DeviceClass::Type DevelKeyEvent::GetDeviceClass( const KeyEvent& keyEvent )
+{
+ KeyEventMapIter search = keyEventImplMap.find( &keyEvent );
+
+ DevelKeyEvent::DeviceClass::Type result = DevelKeyEvent::DeviceClass::NONE;
+
+ if( search != keyEventImplMap.end() )
+ {
+ result = search->second->deviceClass;
+ }
+
+ return result;
+}
+
+void DevelKeyEvent::SetDeviceClass( KeyEvent& keyEvent, const DeviceClass::Type& deviceClass )
+{
+ KeyEventMapIter search = keyEventImplMap.find( &keyEvent );
+
+ if( search != keyEventImplMap.end() )
+ {
+ search->second->deviceClass = deviceClass;
+ }
+}
} // namespace Dali