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, deviceClass );
+ Integration::KeyEvent keyEvent(keyName, keyString, keyCode, keyModifier, timeStamp, keyState, deviceName );
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, DEFAULT_DEVICE_CLASS );
+ Integration::KeyEvent event( "a", "a", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME );
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, DEFAULT_DEVICE_CLASS );
+ Integration::KeyEvent event2( "i", "i", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME );
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, DEFAULT_DEVICE_CLASS );
+ Integration::KeyEvent event3( "a", "a", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME );
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, DEFAULT_DEVICE_CLASS );
+ Integration::KeyEvent event4( "a", "a", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME );
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, DEFAULT_DEVICE_CLASS );
+ Integration::KeyEvent event( "i", "i", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME );
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, DEFAULT_DEVICE_CLASS );
+ Integration::KeyEvent event2( "i", "i", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME );
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, DEFAULT_DEVICE_CLASS );
+ Integration::KeyEvent event3( "a", "a", 0, 0, 0, Integration::KeyEvent::Down, DEFAULT_DEVICE_NAME );
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, DEFAULT_DEVICE_CLASS );
+ Integration::KeyEvent event4( "a", "a", 0, 0, 0, Integration::KeyEvent::Up, DEFAULT_DEVICE_NAME );
application.ProcessEvent( event4 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
namespace DevelKeyEvent
{
-
-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
+ /**
+ * @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 );
+
+}
+
+}
#endif //DALI_KEY_EVENT_DEVEL_H
{
KeyEvent::KeyEvent()
-: Event( Key ),
+: Event(Key),
keyName(),
keyString(),
- keyCode( -1 ),
- keyModifier( 0 ),
- time( 0 ),
- state( KeyEvent::Down ),
- deviceName( "" ),
- deviceClass( DevelKeyEvent::DeviceClass::NONE )
+ keyCode(-1),
+ keyModifier(0),
+ time(0),
+ state(KeyEvent::Down),
+ deviceName("")
{
}
KeyEvent::KeyEvent( const std::string& keyName, const std::string& keyString, int keyCode, int keyModifier,
- 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 )
+ 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)
{
}
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( "" ),
- deviceClass( DevelKeyEvent::DeviceClass::NONE )
+ deviceName("")
{
}
// 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 DevelKeyEvent::DeviceClass::Type deviceClass );
+ const std::string deviceName );
/*
* 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( "" ),
- deviceClass( DevelKeyEvent::DeviceClass::NONE )
+ :deviceName("")
{
- }
+ };
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