{
functorCalled = false;
- receivedKeyEvent.Reset();
+ receivedKeyEvent.keyModifier = 0;
+ receivedKeyEvent.keyPressedName.clear();
+ receivedKeyEvent.keyPressed.clear();
keyedActor.Reset();
}
{
TestApplication application; // Reset all test adapter return codes
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event );
-
- DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("I", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("i", event.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(99, event.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::Down, event.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::NONE, event.GetDeviceClass(), TEST_LOCATION); // check device class
- DALI_TEST_EQUALS(Device::Subclass::NONE, event.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
+ KeyEvent event(TEST_STRING_1,"i", 99, SHIFT_MODIFIER, 0, KeyEvent::Down); // set name to test, key string to i and modifier to shift
+ DALI_TEST_EQUALS(TEST_STRING_1, event.keyPressedName, TEST_LOCATION); // check key name
+ DALI_TEST_EQUALS("i", event.keyPressed, TEST_LOCATION); // check key string
+ DALI_TEST_EQUALS(99, event.keyCode, TEST_LOCATION); // check keyCode
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, event.keyModifier, TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(KeyEvent::Down, event.state, TEST_LOCATION); // check state
END_TEST;
}
-int UtcDaliKeyEventCopyAssignment(void)
+int UtcDaliKeyEventAssignment(void)
{
// Test Assignment operator
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event );
-
- DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("I", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("i", event.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(99, event.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::Down, event.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::NONE, event.GetDeviceClass(), TEST_LOCATION); // check device class
- DALI_TEST_EQUALS(Device::Subclass::NONE, event.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
-
- Dali::KeyEvent event2 = DevelKeyEvent::New(TEST_STRING_1, "J", "j", 88, CTRL_MODIFIER, 0lu, KeyEvent::Up, "", "", Device::Class::USER, Device::Subclass::FINGER); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event2 );
-
- DALI_TEST_EQUALS(TEST_STRING_1, event2.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("J", event2.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("j", event2.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(88, event2.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(CTRL_MODIFIER, event2.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, event2.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::Up, event2.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", event2.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", event2.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::USER, event2.GetDeviceClass(), TEST_LOCATION); // check device class
- DALI_TEST_EQUALS(Device::Subclass::FINGER, event2.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
+ KeyEvent event(TEST_STRING_1,"i", 99, SHIFT_MODIFIER, 0, KeyEvent::Down); // set name to test, key string to i and modifier to shift
- event = event2;
- DALI_TEST_CHECK( event );
-
- DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("J", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("j", event.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(88, event.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(CTRL_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::Up, event.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::USER, event.GetDeviceClass(), TEST_LOCATION); // check device class
- DALI_TEST_EQUALS(Device::Subclass::FINGER, event.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
+ DALI_TEST_EQUALS(TEST_STRING_1, event.keyPressedName, TEST_LOCATION); // check key name
+ DALI_TEST_EQUALS("i", event.keyPressed, TEST_LOCATION); // check key string
+ DALI_TEST_EQUALS(99, event.keyCode, TEST_LOCATION); // check keyCode
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, event.keyModifier, TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(KeyEvent::Down, event.state, TEST_LOCATION); // check state
- END_TEST;
-}
+ KeyEvent event2(TEST_STRING_1,"j", 88, CTRL_MODIFIER, 0, KeyEvent::Up); // set name to test, key string to i and modifier to shift
-int UtcDaliKeyEventCopyConstructor(void)
-{
- // Test Assignment operator
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event );
-
- DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("I", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("i", event.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(99, event.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::Down, event.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::NONE, event.GetDeviceClass(), TEST_LOCATION); // check device class
- DALI_TEST_EQUALS(Device::Subclass::NONE, event.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
+ DALI_TEST_EQUALS(TEST_STRING_1, event2.keyPressedName, TEST_LOCATION); // check key name
+ DALI_TEST_EQUALS("j", event2.keyPressed, TEST_LOCATION); // check key string
+ DALI_TEST_EQUALS(88, event2.keyCode, TEST_LOCATION); // check keyCode
+ DALI_TEST_EQUALS(CTRL_MODIFIER, event2.keyModifier, TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(KeyEvent::Up, event2.state, TEST_LOCATION); // check state
- KeyEvent event2( event );
- DALI_TEST_CHECK( event2 );
-
- DALI_TEST_EQUALS(TEST_STRING_1, event2.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("I", event2.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("i", event2.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(99, event2.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event2.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, event2.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::Down, event2.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", event2.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", event2.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::NONE, event2.GetDeviceClass(), TEST_LOCATION); // check device class
- DALI_TEST_EQUALS(Device::Subclass::NONE, event2.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
+ event = event2;
+
+ DALI_TEST_EQUALS(TEST_STRING_1, event.keyPressedName, TEST_LOCATION); // check key name
+ DALI_TEST_EQUALS("j", event.keyPressed, TEST_LOCATION); // check key string
+ DALI_TEST_EQUALS(88, event.keyCode, TEST_LOCATION); // check keyCode
+ DALI_TEST_EQUALS(CTRL_MODIFIER, event.keyModifier, TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(KeyEvent::Up, event.state, TEST_LOCATION); // check state
END_TEST;
}
-int UtcDaliKeyEventMoveAssignment(void)
+int UtcDaliKeyEventCopy(void)
{
// Test Assignment operator
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event );
-
- DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("I", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("i", event.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(99, event.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::Down, event.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::NONE, event.GetDeviceClass(), TEST_LOCATION); // check device class
- DALI_TEST_EQUALS(Device::Subclass::NONE, event.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
-
- KeyEvent move;
- move = std::move( event );
- DALI_TEST_CHECK( move );
-
- DALI_TEST_EQUALS(TEST_STRING_1, move.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("I", move.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("i", move.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(99, move.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(SHIFT_MODIFIER, move.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, move.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::Down, move.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", move.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", move.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::NONE, move.GetDeviceClass(), TEST_LOCATION); // check device class
- DALI_TEST_EQUALS(Device::Subclass::NONE, move.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
-
- DALI_TEST_CHECK( !event );
+ KeyEvent event(TEST_STRING_1,"i", 99, SHIFT_MODIFIER, 0, KeyEvent::Down); // set name to test, key string to i and modifier to shift
- END_TEST;
-}
+ DALI_TEST_EQUALS(TEST_STRING_1, event.keyPressedName, TEST_LOCATION); // check key name
+ DALI_TEST_EQUALS("i", event.keyPressed, TEST_LOCATION); // check key string
+ DALI_TEST_EQUALS(99, event.keyCode, TEST_LOCATION); // check keyCode
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, event.keyModifier, TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(KeyEvent::Down, event.state, TEST_LOCATION); // check state
-int UtcDaliKeyEventMoveConstructor(void)
-{
- // Test Assignment operator
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event );
-
- DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("I", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("i", event.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(99, event.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::Down, event.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::NONE, event.GetDeviceClass(), TEST_LOCATION); // check device class
- DALI_TEST_EQUALS(Device::Subclass::NONE, event.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
-
- KeyEvent move = std::move( event );
- DALI_TEST_CHECK( move );
-
- DALI_TEST_EQUALS(TEST_STRING_1, move.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("I", move.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("i", move.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(99, move.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(SHIFT_MODIFIER, move.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, move.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::Down, move.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", move.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", move.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::NONE, move.GetDeviceClass(), TEST_LOCATION); // check device class
- DALI_TEST_EQUALS(Device::Subclass::NONE, move.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
-
- DALI_TEST_CHECK( !event );
+ KeyEvent event2( event );
+
+ DALI_TEST_EQUALS(TEST_STRING_1, event2.keyPressedName, TEST_LOCATION); // check key name
+ DALI_TEST_EQUALS("i", event2.keyPressed, TEST_LOCATION); // check key string
+ DALI_TEST_EQUALS(99, event2.keyCode, TEST_LOCATION); // check keyCode
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, event2.keyModifier, TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(KeyEvent::Down, event2.state, TEST_LOCATION); // check state
END_TEST;
}
{
TestApplication application; // Reset all test adapter return codes
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, CTRL_MODIFIER, 0lu, KeyEvent::Down, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event );
-
- DALI_TEST_EQUALS(CTRL_MODIFIER, event.GetKeyModifier(), TEST_LOCATION);
- DALI_TEST_EQUALS(false, event.IsShiftModifier(), TEST_LOCATION); // check IsShiftModifier
+ KeyEvent event;
+ DALI_TEST_EQUALS(0, event.keyModifier, TEST_LOCATION);
- DevelKeyEvent::SetKeyModifier( event, SHIFT_MODIFIER ); // Set to Shift Modifier
+ event.keyModifier = SHIFT_MODIFIER; // Set to Shift Modifier
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check able to set
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, event.keyModifier, TEST_LOCATION); // check able to set
DALI_TEST_EQUALS(true, event.IsShiftModifier(), TEST_LOCATION); // check IsShiftModifier
{
TestApplication application; // Reset all test adapter return codes
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event );
+ KeyEvent event;
+ DALI_TEST_EQUALS(0, event.keyModifier, TEST_LOCATION);
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION);
- DALI_TEST_EQUALS(false, event.IsCtrlModifier(), TEST_LOCATION); // check IsCtrlModifier
+ event.keyModifier = CTRL_MODIFIER; // Set to Ctrl Modifier
- DevelKeyEvent::SetKeyModifier( event, CTRL_MODIFIER ); // Set to Ctrl Modifier
-
- DALI_TEST_EQUALS(CTRL_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check able to set
+ DALI_TEST_EQUALS(CTRL_MODIFIER, event.keyModifier, TEST_LOCATION); // check able to set
DALI_TEST_EQUALS(true, event.IsCtrlModifier(), TEST_LOCATION); // check IsCtrlModifier
END_TEST;
{
TestApplication application; // Reset all test adapter return codes
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event );
-
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION);
- DALI_TEST_EQUALS(false, event.IsAltModifier(), TEST_LOCATION); // check IsAltModifier
+ KeyEvent event;
+ DALI_TEST_EQUALS(0, event.keyModifier, TEST_LOCATION);
- DevelKeyEvent::SetKeyModifier( event, ALT_MODIFIER ); // Set to Alt Modifier
+ event.keyModifier = ALT_MODIFIER; // Set to Alt Modifier
- DALI_TEST_EQUALS(ALT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check able to set
+ DALI_TEST_EQUALS(ALT_MODIFIER, event.keyModifier, TEST_LOCATION); // check able to set
DALI_TEST_EQUALS(true, event.IsAltModifier(), TEST_LOCATION); // IsAltModifier
END_TEST;
{
TestApplication application; // Reset all test adapter return codes
- Dali::KeyEvent event = DevelKeyEvent::New("i", "I", "i", 0, CTRL_MODIFIER, 0lu, KeyEvent::Down, "", "", Device::Class::NONE, Device::Subclass::NONE);
+ KeyEvent event("i","i", 0, CTRL_MODIFIER, 0, KeyEvent::Down);
- DALI_TEST_EQUALS(CTRL_MODIFIER, event.GetKeyModifier(), TEST_LOCATION);
+ DALI_TEST_EQUALS(CTRL_MODIFIER, event.keyModifier, TEST_LOCATION); // check different modifier used
DALI_TEST_EQUALS(false, event.IsShiftModifier(), TEST_LOCATION);
END_TEST;
{
TestApplication application; // Reset all test adapter return codes
- Dali::KeyEvent event = DevelKeyEvent::New("i", "I", "i", 0, ALT_MODIFIER, 0lu, KeyEvent::Up, "", "", Device::Class::NONE, Device::Subclass::NONE);
+ KeyEvent event("i","i", 0, ALT_MODIFIER, 0, KeyEvent::Up);
- DALI_TEST_EQUALS(ALT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ALT_MODIFIER, event.keyModifier, TEST_LOCATION); // check different modifier used
DALI_TEST_EQUALS(false, event.IsCtrlModifier(), TEST_LOCATION);
END_TEST;
{
TestApplication application; // Reset all test adapter return codes
- Dali::KeyEvent event = DevelKeyEvent::New("i", "I", "i", 0, SHIFT_MODIFIER, 0lu, KeyEvent::Up, "", "", Device::Class::NONE, Device::Subclass::NONE);
+ KeyEvent event("i","i", 0, SHIFT_MODIFIER, 0, KeyEvent::Up);
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION);
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, event.keyModifier, TEST_LOCATION); // check different modifier used
DALI_TEST_EQUALS(false, event.IsAltModifier(), TEST_LOCATION);
END_TEST;
{
TestApplication application; // Reset all test adapter return codes
- Dali::KeyEvent event = DevelKeyEvent::New("i", "I", "i", 0, SHIFT_AND_CTRL_MODIFIER, 0lu, KeyEvent::Down, "", "", Device::Class::NONE, Device::Subclass::NONE);
+ KeyEvent event("i","i", 0, SHIFT_AND_CTRL_MODIFIER, 0, KeyEvent::Down);
DALI_TEST_EQUALS(true, (bool)(event.IsCtrlModifier() & event.IsShiftModifier()), TEST_LOCATION);
- DevelKeyEvent::SetKeyModifier( event, SHIFT_MODIFIER ); // Set to Shift Modifier
+ event.keyModifier = SHIFT_MODIFIER;
DALI_TEST_EQUALS(false, (bool)(event.IsCtrlModifier() & event.IsShiftModifier()), TEST_LOCATION);
END_TEST;
{
TestApplication application; // Reset all test adapter return codes
- Dali::KeyEvent event = DevelKeyEvent::New("i", "I", "i", 0, SHIFT_AND_CTRL_MODIFIER, 0lu, KeyEvent::Down, "", "", Device::Class::NONE, Device::Subclass::NONE);
+ KeyEvent event("i","i", 0, SHIFT_AND_CTRL_MODIFIER, 0, KeyEvent::Down);
DALI_TEST_EQUALS(true, (bool)(event.IsCtrlModifier() | event.IsAltModifier()), TEST_LOCATION);
- DevelKeyEvent::SetKeyModifier( event, SHIFT_MODIFIER ); // Set to Shift Modifier
+ event.keyModifier = SHIFT_MODIFIER;
+
+ DALI_TEST_EQUALS(false, (bool)(event.IsCtrlModifier() & event.IsAltModifier()), TEST_LOCATION);
+ END_TEST;
+}
+
+// Positive test case for a method
+int UtcDaliKeyEventState(void)
+{
+ TestApplication application; // Reset all test adapter return codes
+
+ KeyEvent event("i","i", 0, SHIFT_AND_CTRL_MODIFIER, 0, KeyEvent::Down);
+ DALI_TEST_EQUALS(true, (bool)(event.IsCtrlModifier() | event.IsAltModifier()), TEST_LOCATION);
+
+ event.keyModifier = SHIFT_MODIFIER;
DALI_TEST_EQUALS(false, (bool)(event.IsCtrlModifier() & event.IsAltModifier()), TEST_LOCATION);
END_TEST;
DALI_TEST_EQUALS( keyEvent.keyModifier, 0, TEST_LOCATION );
DALI_TEST_EQUALS( keyEvent.time, 0lu, TEST_LOCATION );
DALI_TEST_EQUALS( keyEvent.state, Integration::KeyEvent::Down, TEST_LOCATION);
- DALI_TEST_EQUALS( keyEvent.compose, std::string(), TEST_LOCATION);
- DALI_TEST_EQUALS( keyEvent.deviceName, std::string(), TEST_LOCATION);
- DALI_TEST_EQUALS( keyEvent.deviceClass, Device::Class::NONE, TEST_LOCATION);
- DALI_TEST_EQUALS( keyEvent.deviceSubclass, Device::Subclass::NONE, TEST_LOCATION);
}
{
END_TEST;
}
-int UtcDaliKeyEventSetKeyName(void)
+int UtcDaliIntegrationKeyEventConvertor(void)
{
TestApplication application;
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down, "", "", Device::Class::NONE, Device::Subclass::NONE);
+ KeyEvent event(TEST_STRING_1,"i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down); // set name to test, key string to i and modifier to shift
- DALI_TEST_EQUALS( TEST_STRING_1, event.GetKeyName(), TEST_LOCATION );
+ Integration::KeyEvent keyEvent( event );
- DevelKeyEvent::SetKeyName( event, "keyName" );
- DALI_TEST_EQUALS( "keyName", event.GetKeyName(), TEST_LOCATION );
+ DALI_TEST_EQUALS( keyEvent.type, Integration::Event::Key, TEST_LOCATION );
+ DALI_TEST_CHECK( keyEvent.keyName == TEST_STRING_1 );
+ DALI_TEST_CHECK( keyEvent.logicalKey == "" );
+ DALI_TEST_CHECK( keyEvent.keyString == "i" );
+ DALI_TEST_EQUALS( keyEvent.keyCode, 99, TEST_LOCATION );
+ DALI_TEST_EQUALS( keyEvent.keyModifier, SHIFT_MODIFIER, TEST_LOCATION );
+ DALI_TEST_EQUALS( keyEvent.time, 0lu, TEST_LOCATION );
+ DALI_TEST_EQUALS( keyEvent.state, Integration::KeyEvent::Down, TEST_LOCATION);
+ DALI_TEST_EQUALS( keyEvent.compose, "", TEST_LOCATION);
+ DALI_TEST_EQUALS( keyEvent.deviceName, "", TEST_LOCATION);
+ DALI_TEST_EQUALS( keyEvent.deviceClass, Device::Class::NONE, TEST_LOCATION);
+ DALI_TEST_EQUALS( keyEvent.deviceSubclass, Device::Subclass::NONE, TEST_LOCATION);
END_TEST;
}
-int UtcDaliKeyEventSetKeyString(void)
+int UtcDaliKeyEventSetCompose(void)
{
TestApplication application;
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down, "", "", Device::Class::NONE, Device::Subclass::NONE);
-
- DALI_TEST_EQUALS( "i", event.GetKeyString(), TEST_LOCATION );
+ KeyEvent event(TEST_STRING_1,"i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down);
- DevelKeyEvent::SetKeyString( event, "keyString" );
- DALI_TEST_EQUALS( "keyString", event.GetKeyString(), TEST_LOCATION );
+ DALI_TEST_EQUALS( event.GetCompose(), "", TEST_LOCATION);
END_TEST;
}
-int UtcDaliKeyEventSetKeyCode(void)
+int UtcDaliKeyEventSetDeviceName(void)
{
TestApplication application;
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down, "", "", Device::Class::NONE, Device::Subclass::NONE);
+ KeyEvent event(TEST_STRING_1,"i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down);
- DALI_TEST_EQUALS( 99, event.GetKeyCode(), TEST_LOCATION );
-
- DevelKeyEvent::SetKeyCode( event, 88 );
- DALI_TEST_EQUALS( 88, event.GetKeyCode(), TEST_LOCATION );
+ DALI_TEST_EQUALS( event.GetDeviceName(), "", TEST_LOCATION);
END_TEST;
}
-int UtcDaliKeyEventSetKeyModifier(void)
+int UtcDaliKeyEventSetDeviceClass(void)
{
TestApplication application;
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down, "", "", Device::Class::NONE, Device::Subclass::NONE);
-
- DALI_TEST_EQUALS( SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION );
+ KeyEvent event(TEST_STRING_1,"i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down);
- DevelKeyEvent::SetKeyModifier( event, ALT_MODIFIER );
- DALI_TEST_EQUALS( ALT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION );
+ DALI_TEST_EQUALS( event.GetDeviceClass(), Device::Class::NONE, TEST_LOCATION);
END_TEST;
}
-int UtcDaliKeyEventSetTime(void)
+int UtcDaliKeyEventSetDeviceSubclass(void)
{
TestApplication application;
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down, "", "", Device::Class::NONE, Device::Subclass::NONE);
+ KeyEvent event(TEST_STRING_1,"i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down);
- DALI_TEST_EQUALS( 0lu, event.GetTime(), TEST_LOCATION );
-
- DevelKeyEvent::SetTime( event, 100lu );
- DALI_TEST_EQUALS( 100lu, event.GetTime(), TEST_LOCATION );
+ DALI_TEST_EQUALS( event.GetDeviceSubclass(), Device::Subclass::NONE, TEST_LOCATION);
END_TEST;
}
-int UtcDaliKeyEventSetState(void)
+int UtcDaliKeyEventSetLogicalKey(void)
{
TestApplication application;
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down, "", "", Device::Class::NONE, Device::Subclass::NONE);
-
- DALI_TEST_EQUALS( KeyEvent::Down, event.GetState(), TEST_LOCATION );
+ KeyEvent event(TEST_STRING_1,"i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::Down);
- DevelKeyEvent::SetState( event, KeyEvent::Up );
- DALI_TEST_EQUALS( KeyEvent::Up, event.GetState(), TEST_LOCATION );
+ DALI_TEST_EQUALS( DevelKeyEvent::GetLogicalKey( event ), "", TEST_LOCATION );
END_TEST;
}
{
functorCalled = false;
- receivedKeyEvent.Reset();
+ receivedKeyEvent.keyModifier = 0;
+ receivedKeyEvent.keyPressedName.clear();
+ receivedKeyEvent.keyPressed.clear();
}
bool functorCalled;
{
functorCalled = false;
- receivedKeyEvent.Reset();
+ receivedKeyEvent.keyModifier = 0;
+ receivedKeyEvent.keyPressedName.clear();
+ receivedKeyEvent.keyPressed.clear();
}
bool functorCalled;
application.ProcessEvent( event );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.keyModifier );
+ DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.keyPressedName );
+ DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.keyPressed );
+ DALI_TEST_CHECK( event.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
data.Reset();
application.ProcessEvent( event2 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event2.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.keyModifier );
+ DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.keyPressedName );
+ DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.keyPressed );
+ DALI_TEST_CHECK( event2.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
data.Reset();
application.ProcessEvent( event3 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event3.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.keyModifier );
+ DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.keyPressedName );
+ DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.keyPressed );
+ DALI_TEST_CHECK( event3.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
data.Reset();
application.ProcessEvent( event4 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event4.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.keyModifier );
+ DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.keyPressedName );
+ DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.keyPressed );
+ DALI_TEST_CHECK( event4.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
END_TEST;
}
application.ProcessEvent( event );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.keyModifier );
+ DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.keyPressedName );
+ DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.keyPressed );
+ DALI_TEST_CHECK( event.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
data.Reset();
application.ProcessEvent( event2 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event2.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.keyModifier );
+ DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.keyPressedName );
+ DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.keyPressed );
+ DALI_TEST_CHECK( event2.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
data.Reset();
application.ProcessEvent( event3 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event3.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.keyModifier );
+ DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.keyPressedName );
+ DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.keyPressed );
+ DALI_TEST_CHECK( event3.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
data.Reset();
application.ProcessEvent( event4 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event4.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.keyModifier );
+ DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.keyPressedName );
+ DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.keyPressed );
+ DALI_TEST_CHECK( event4.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
END_TEST;
}
{
functorCalled = false;
- receivedKeyEvent.Reset();
+ receivedKeyEvent.keyModifier = 0;
+ receivedKeyEvent.keyPressedName.clear();
+ receivedKeyEvent.keyPressed.clear();
}
bool functorCalled;
{
functorCalled = false;
- receivedKeyEvent.Reset();
+ receivedKeyEvent.keyModifier = 0;
+ receivedKeyEvent.keyPressedName.clear();
+ receivedKeyEvent.keyPressed.clear();
}
bool functorCalled;
application.ProcessEvent( event );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.keyModifier );
+ DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.keyPressedName );
+ DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.keyPressed );
+ DALI_TEST_CHECK( event.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
data.Reset();
application.ProcessEvent( event2 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event2.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.keyModifier );
+ DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.keyPressedName );
+ DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.keyPressed );
+ DALI_TEST_CHECK( event2.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
data.Reset();
application.ProcessEvent( event3 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event3.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.keyModifier );
+ DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.keyPressedName );
+ DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.keyPressed );
+ DALI_TEST_CHECK( event3.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
data.Reset();
application.ProcessEvent( event4 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event4.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.keyModifier );
+ DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.keyPressedName );
+ DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.keyPressed );
+ DALI_TEST_CHECK( event4.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
END_TEST;
}
application.ProcessEvent( event );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.keyModifier );
+ DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.keyPressedName );
+ DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.keyPressed );
+ DALI_TEST_CHECK( event.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
data.Reset();
application.ProcessEvent( event2 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event2.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.keyModifier );
+ DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.keyPressedName );
+ DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.keyPressed );
+ DALI_TEST_CHECK( event2.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
data.Reset();
application.ProcessEvent( event3 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event3.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.keyModifier );
+ DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.keyPressedName );
+ DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.keyPressed );
+ DALI_TEST_CHECK( event3.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
data.Reset();
application.ProcessEvent( event4 );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event4.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.keyModifier );
+ DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.keyPressedName );
+ DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.keyPressed );
+ DALI_TEST_CHECK( event4.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
END_TEST;
}
struct Vector2;
struct Vector3;
struct Vector4;
-class KeyEvent;
+struct KeyEvent;
/**
* @brief The Stage is a top-level object used for displaying a tree of Actors.
/*\r
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.\r
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd.\r
*\r
* Licensed under the Apache License, Version 2.0 (the "License");\r
* you may not use this file except in compliance with the License.\r
namespace DevelKeyEvent\r
{\r
\r
-KeyEvent New( const std::string& keyName,\r
- const std::string& logicalKey,\r
- const std::string& keyString,\r
- int keyCode,\r
- int keyModifier,\r
- unsigned long timeStamp,\r
- const Dali::KeyEvent::State& keyState,\r
- const std::string& compose,\r
- const std::string& deviceName,\r
- const Device::Class::Type deviceClass,\r
- const Device::Subclass::Type deviceSubclass )\r
+std::string GetLogicalKey( KeyEvent keyEvent )\r
{\r
- Internal::KeyEventPtr internal = Internal::KeyEvent::New( keyName, logicalKey, keyString, keyCode, keyModifier, timeStamp, keyState, compose, deviceName, deviceClass, deviceSubclass );\r
-\r
- return KeyEvent( internal.Get() );\r
-}\r
-\r
-void SetKeyName( KeyEvent keyEvent, const std::string& keyName )\r
-{\r
- GetImplementation( keyEvent ).SetKeyName( keyName );\r
-}\r
-\r
-void SetKeyString( KeyEvent keyEvent, const std::string& keyString )\r
-{\r
- GetImplementation( keyEvent ).SetKeyString( keyString );\r
-}\r
-\r
-void SetKeyCode( KeyEvent keyEvent, int32_t keyCode )\r
-{\r
- GetImplementation( keyEvent ).SetKeyCode( keyCode );\r
-}\r
-\r
-void SetKeyModifier( KeyEvent keyEvent, int32_t keyModifier )\r
-{\r
- GetImplementation( keyEvent ).SetKeyModifier( keyModifier );\r
-}\r
-\r
-void SetTime( KeyEvent keyEvent, unsigned long time )\r
-{\r
- GetImplementation( keyEvent ).SetTime( time );\r
-}\r
-\r
-void SetState( KeyEvent keyEvent, const KeyEvent::State& state )\r
-{\r
- GetImplementation( keyEvent ).SetState( state );\r
+ return GetImplementation( &keyEvent )->GetLogicalKey();\r
}\r
\r
} // namespace DevelKeyEvent\r
#define DALI_KEY_EVENT_DEVEL_H\r
\r
/*\r
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.\r
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd.\r
*\r
* Licensed under the Apache License, Version 2.0 (the "License");\r
* you may not use this file except in compliance with the License.\r
{\r
\r
/**\r
- * @brief Creates an initialized WheelEvent.\r
+ * @brief Gets the logical key string.\r
*\r
- * @SINCE_1_9.27\r
- * @param[in] keyName The name of the key pressed or command from the IMF, if later then the some following parameters will be needed.\r
- * @param[in] logicalKey The logical key symbol (eg. shift + 1 == "exclamation")\r
- * @param[in] keyString The string of input characters or key pressed\r
- * @param[in] keyCode The unique key code for the key pressed.\r
- * @param[in] keyModifier The key modifier for special keys like shift and alt\r
- * @param[in] timeStamp The time (in ms) that the key event occurred.\r
- * @param[in] keyState The state of the key event.\r
- * @param[in] compose The key compose\r
- * @param[in] deviceName The name of device the key event originated from\r
- * @param[in] deviceClass The class of device the key event originated from\r
- * @param[in] deviceSubclass The subclass of device the key event originated from\r
- * @return A handle to a newly allocated Dali resource\r
- */\r
-DALI_CORE_API KeyEvent New( const std::string& keyName,\r
- const std::string& logicalKey,\r
- const std::string& keyString,\r
- int keyCode,\r
- int keyModifier,\r
- unsigned long timeStamp,\r
- const Dali::KeyEvent::State& keyState,\r
- const std::string& compose,\r
- const std::string& deviceName,\r
- const Device::Class::Type deviceClass,\r
- const Device::Subclass::Type deviceSubclass );\r
-\r
-/**\r
- * @brief Set the name given to the key pressed\r
- *\r
- * @SINCE_1_9.27\r
- * @param[in] keyEvent The instance of KeyEvent.\r
- * @param[in] keyName The name given to the key pressed.\r
- */\r
-void SetKeyName( KeyEvent keyEvent, const std::string& keyName );\r
-\r
-/**\r
- * @brief Set the actual string of input characters that should be used for input editors.\r
- *\r
- * @SINCE_1_9.27\r
- * @param[in] keyEvent The instance of KeyEvent.\r
- * @param[in] keyString The actual string of input characters\r
- */\r
-void SetKeyString( KeyEvent keyEvent, const std::string& keyString );\r
-\r
-/**\r
- * @brief Set the unique key code for the key pressed.\r
- *\r
- * @SINCE_1_9.27\r
- * @param[in] keyEvent The instance of KeyEvent.\r
- * @param[in] keyCode The unique key code for the key pressed\r
- */\r
-void SetKeyCode( KeyEvent keyEvent, int32_t keyCode );\r
-\r
-/**\r
- * @brief Set the key modifier for special keys like Shift, Alt and Ctrl which modify the next key pressed.\r
- *\r
- * @SINCE_1_9.27\r
- * @param[in] keyEvent The instance of KeyEvent.\r
- * @param[in] keyModifier The key modifier\r
- */\r
-void SetKeyModifier( KeyEvent keyEvent, int32_t keyModifier );\r
-\r
-/**\r
- * @brief Set the time (in ms) that the key event occurred.\r
- *\r
- * @SINCE_1_9.27\r
- * @param[in] keyEvent The instance of KeyEvent.\r
- * @param[in] time The time (in ms)\r
- */\r
-void SetTime( KeyEvent keyEvent, unsigned long time );\r
-\r
-/**\r
- * @brief Set the state of the key event.\r
+ * For example, when the user presses 'shift' key and '1' key together, the logical key is "exclamation".\r
+ * Plus, the keyPressedName is "1", and the keyPressed is "!".\r
*\r
- * @SINCE_1_9.27\r
* @param[in] keyEvent The instance of KeyEvent.\r
- * @param[in] state The state of the key event\r
+ * @return The logical key symbol\r
*/\r
-void SetState( KeyEvent keyEvent, const KeyEvent::State& state );\r
+DALI_CORE_API std::string GetLogicalKey( KeyEvent keyEvent );\r
\r
} // namespace DevelKeyEvent\r
\r
/*
- * Copyright (c) 2020 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.
{
}
+KeyEvent::KeyEvent( const Dali::KeyEvent& event )
+: Event( Key ),
+ keyName( event.keyPressedName ),
+ logicalKey( "" ),
+ keyString( event.keyPressed ),
+ keyCode( event.keyCode ),
+ keyModifier( event.keyModifier ),
+ time( event.time ),
+ state( static_cast< Integration::KeyEvent::State >( event.state ) ),
+ compose( "" ),
+ deviceName( "" ),
+ deviceClass( Device::Class::NONE ),
+ deviceSubclass( Device::Subclass::NONE )
+{
+ const Internal::KeyEventImpl* keyEventImpl = GetImplementation( &event );
+ logicalKey = keyEventImpl->GetLogicalKey();
+ compose = keyEventImpl->GetCompose();
+ deviceName = keyEventImpl->GetDeviceName();
+ deviceClass = keyEventImpl->GetDeviceClass();
+ deviceSubclass = keyEventImpl->GetDeviceSubclass();
+}
+
KeyEvent::~KeyEvent()
{
}
#define DALI_INTEGRATION_KEY_EVENT_H
/*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
/**
* Constructor
- * @param[in] keyName The name of the key pressed or command from the IMF, if later then the some following parameters will be needed.
- * @param[in] logicalKey The logical key symbol (eg. shift + 1 == "exclamation")
- * @param[in] keyString The string of input characters or key pressed
- * @param[in] keyCode The unique key code for the key pressed.
- * @param[in] keyModifier The key modifier for special keys like shift and alt
- * @param[in] timeStamp The time (in ms) that the key event occurred.
- * @param[in] keyState The state of the key event.
- * @param[in] compose The key compose
- * @param[in] deviceName The name of device KeyEvent originated from
- * @param[in] deviceClass The class of device KeyEvent originated from
- * @param[in] deviceSubclass The subclass of device KeyEvent originated from
+ * @param[in] keyName The name of the key pressed or command from the IMF, if later then the some following parameters will be needed.
+ * @param[in] logicalKey The logical key symbol (eg. shift + 1 == "exclamation")
+ * @param[in] keyString A string of input characters or key pressed
+ * @param[in] keyCode The unique key code for the key pressed.
+ * @param[in] keyModifier The key modifier for special keys like shift and alt
+ * @param[in] timeStamp The time (in ms) that the key event occurred.
+ * @param[in] keyState The state of the key event.
+ * @param[in] compose The key compose
+ * @param[in] deviceName Name of device KeyEvent originated from
+ * @param[in] deviceClass Class of device KeyEvent originated from
+ * @param[in] deviceSubclass Subclass of device KeyEvent originated from
*/
KeyEvent(const std::string& keyName,
const std::string& logicalKey,
const Device::Subclass::Type deviceSubclass );
/**
+ * Constructor, creates a Integration::KeyEvent from a Dali::KeyEvent
+ * @param[in] event Dali::KeyEvent to convert from
+ */
+ explicit KeyEvent( const Dali::KeyEvent& event );
+
+ /**
* Virtual destructor
*/
virtual ~KeyEvent();
// Data
/**
- * The name of the key pressed or command from the IMF
+ *@copydoc Dali::KeyEvent::keyPressedName
*/
std::string keyName;
std::string logicalKey;
/**
- * The string of input characters or key pressed
+ *@copydoc Dali::KeyEvent::keyPressed
*/
std::string keyString;
/**
- * The unique key code for the key pressed.
+ * @copydoc Dali::KeyEvent::keyCode
*/
int keyCode;
/**
- * The key modifier for special keys like shift and alt
+ *@copydoc Dali::KeyEvent::keyModifier
*/
int keyModifier;
/**
- * The time (in ms) that the key event occurred.
+ *@copydoc Dali::KeyEvent::time
*/
unsigned long time;
State state;
/**
- * If this keystroke has modified a string in the middle of being composed - this string replaces the previous one.
+ * A string if this keystroke has modified a string in the middle of being composed - this string replaces the previous one.
*/
std::string compose;
/**
- * The name of device KeyEvent originated from
+ * Name of device KeyEvent originated from
*/
std::string deviceName;
/**
- * The class of device KeyEvent originated from
+ * Class of device KeyEvent originated from
*/
Device::Class::Type deviceClass;
/**
- * The subclass of device KeyEvent originated from
+ * Subclass of device KeyEvent originated from
*/
Device::Subclass::Type deviceSubclass;
};
{
class Actor;
-class KeyEvent;
+struct KeyEvent;
class Layer;
class RenderTaskList;
class TouchEvent;
namespace Dali
{
-class KeyEvent;
+struct KeyEvent;
class TouchData;
class TouchEvent;
class WheelEvent;
return mSceneObject;
}
-void Scene::EmitKeyEventSignal(const Dali::KeyEvent& event)
+void Scene::EmitKeyEventSignal(const KeyEvent& event)
{
if ( !mKeyEventSignal.Empty() )
{
}
}
-bool Scene::EmitKeyEventGeneratedSignal(const Dali::KeyEvent& event)
+bool Scene::EmitKeyEventGeneratedSignal(const KeyEvent& event)
{
// Emit the KeyEventGenerated signal when KeyEvent is generated
- Dali::Integration::Scene handle( this );
return mKeyEventGeneratedSignal.Emit( event );
}
* Used by the EventProcessor to emit key event signals.
* @param[in] event The key event.
*/
- void EmitKeyEventSignal(const Dali::KeyEvent& event);
+ void EmitKeyEventSignal(const KeyEvent& event);
/**
* Used by the KeyEventProcessor to emit KeyEventGenerated signals.
* @param[in] event The key event.
* @return The return is true if KeyEvent is consumed, otherwise false.
*/
- bool EmitKeyEventGeneratedSignal(const Dali::KeyEvent& event);
+ bool EmitKeyEventGeneratedSignal(const KeyEvent& event);
/**
* Emits the event processing finished signal.
/*
- * Copyright (c) 2020 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.
namespace
{
-const uint32_t MODIFIER_SHIFT = 0x1;
-const uint32_t MODIFIER_CTRL = 0x2;
-const uint32_t MODIFIER_ALT = 0x4;
-const int32_t KEY_INVALID_CODE = -1;
+/**
+ * This container stores a mapping between public key event and impl as we cannot add data members in public one.
+ * In practice this keeps the impl "alive" in between KeyEvent constructor and destructor calls so that getter
+ * methods can be called to access the new data members. There is a 1:1 mapping between KeyEvent and KeyEventImpl.
+ */
+struct KeyImplMapping
+{
+ KeyEvent* keyEvent;
+ Internal::KeyEventImpl* impl;
+};
+Vector< KeyImplMapping > gKeyEventToImplMapping;
+
}
namespace Internal
{
-KeyEvent::KeyEvent()
-: mKeyName( "" ),
- mLogicalKey( "" ),
- mKeyString( "" ),
- mKeyCode( KEY_INVALID_CODE ),
- mKeyModifier( 0 ),
- mTime( 0 ),
- mState( Dali::KeyEvent::Down ),
+KeyEventImpl::KeyEventImpl( KeyEvent* keyEvent )
+: mLogicalKey( "" ),
mCompose( "" ),
mDeviceName( "" ),
mDeviceClass( Device::Class::NONE ),
mDeviceSubclass( Device::Subclass::NONE )
{
+ gKeyEventToImplMapping.PushBack( { keyEvent, this } );
}
-KeyEvent::KeyEvent( const std::string& keyName,
- const std::string& logicalKey,
- const std::string& keyString,
- int keyCode,
- int keyModifier,
- unsigned long timeStamp,
- const Dali::KeyEvent::State& keyState,
- const std::string& compose,
- const std::string& deviceName,
- const Device::Class::Type deviceClass,
- const Device::Subclass::Type deviceSubclass )
-: mKeyName( keyName ),
- mLogicalKey( logicalKey ),
- mKeyString( keyString ),
- mKeyCode( keyCode ),
- mKeyModifier( keyModifier ),
- mTime( timeStamp ),
- mState( keyState ),
- mCompose( compose ),
- mDeviceName( deviceName ),
- mDeviceClass( deviceClass ),
- mDeviceSubclass( deviceSubclass )
+KeyEventImpl::~KeyEventImpl()
{
+ for( auto&& iter : gKeyEventToImplMapping )
+ {
+ if( this == iter.impl )
+ {
+ gKeyEventToImplMapping.Erase( &iter ); // iter is reference to KeyImplMapping, take address of it for Erase
+ return;
+ }
+ }
}
-KeyEvent::~KeyEvent()
+KeyEventImpl& KeyEventImpl::operator=( const KeyEventImpl& rhs )
{
-}
+ if( this != &rhs )
+ {
+ mLogicalKey = rhs.mLogicalKey;
+ mCompose = rhs.mCompose;
+ mDeviceName = rhs.mDeviceName;
+ mDeviceClass = rhs.mDeviceClass;
+ mDeviceSubclass = rhs.mDeviceSubclass;
+ }
-KeyEventPtr KeyEvent::New( const std::string& keyName,
- const std::string& logicalKey,
- const std::string& keyString,
- int keyCode,
- int keyModifier,
- unsigned long timeStamp,
- const Dali::KeyEvent::State& keyState,
- const std::string& compose,
- const std::string& deviceName,
- const Device::Class::Type deviceClass,
- const Device::Subclass::Type deviceSubclass )
-{
- KeyEventPtr keyEvent = new KeyEvent( keyName, logicalKey, keyString, keyCode, keyModifier, timeStamp, keyState, compose, deviceName, deviceClass, deviceSubclass );
- return keyEvent;
+ return *this;
}
-bool KeyEvent::IsShiftModifier() const
+std::string KeyEventImpl::GetLogicalKey() const
{
- return ( ( MODIFIER_SHIFT & mKeyModifier ) == MODIFIER_SHIFT );
-}
-
-bool KeyEvent::IsCtrlModifier() const
-{
- return ( ( MODIFIER_CTRL & mKeyModifier ) == MODIFIER_CTRL );
+ return mLogicalKey;
}
-bool KeyEvent::IsAltModifier() const
+void KeyEventImpl::SetLogicalKey( const std::string& logicalKey )
{
- return ( ( MODIFIER_ALT & mKeyModifier ) == MODIFIER_ALT );
+ mLogicalKey = logicalKey;
}
-const std::string& KeyEvent::GetCompose() const
+std::string KeyEventImpl::GetCompose() const
{
return mCompose;
}
-const std::string& KeyEvent::GetDeviceName() const
-{
- return mDeviceName;
-}
-
-
-Device::Class::Type KeyEvent::GetDeviceClass() const
-{
- return mDeviceClass;
-}
-
-
-Device::Subclass::Type KeyEvent::GetDeviceSubclass() const
-{
- return mDeviceSubclass;
-}
-
-
-const std::string& KeyEvent::GetKeyName() const
-{
- return mKeyName;
-}
-
-
-const std::string& KeyEvent::GetKeyString() const
-{
- return mKeyString;
-}
-
-
-const std::string& KeyEvent::GetLogicalKey() const
-{
- return mLogicalKey;
-}
-
-
-int32_t KeyEvent::GetKeyCode() const
-{
- return mKeyCode;
-}
-
-
-int32_t KeyEvent::GetKeyModifier() const
+void KeyEventImpl::SetCompose( const std::string& compose )
{
- return mKeyModifier;
+ mCompose = compose;
}
-
-unsigned long KeyEvent::GetTime() const
+std::string KeyEventImpl::GetDeviceName() const
{
- return mTime;
+ return mDeviceName;
}
-
-Dali::KeyEvent::State KeyEvent::GetState() const
+void KeyEventImpl::SetDeviceName( const std::string& deviceName )
{
- return mState;
+ mDeviceName = deviceName;
}
-
-void KeyEvent::SetKeyName( const std::string& keyName )
+Device::Class::Type KeyEventImpl::GetDeviceClass() const
{
- mKeyName = keyName;
+ return mDeviceClass;
}
-
-void KeyEvent::SetKeyString( const std::string& keyString )
+void KeyEventImpl::SetDeviceClass( Device::Class::Type deviceClass )
{
- mKeyString = keyString;
+ mDeviceClass = deviceClass;
}
-
-void KeyEvent::SetKeyCode( int32_t keyCode )
+Device::Subclass::Type KeyEventImpl::GetDeviceSubclass() const
{
- mKeyCode = keyCode;
+ return mDeviceSubclass;
}
-
-void KeyEvent::SetKeyModifier( int32_t keyModifier )
+void KeyEventImpl::SetDeviceSubclass( Device::Subclass::Type deviceSubclass )
{
- mKeyModifier = keyModifier;
+ mDeviceSubclass = deviceSubclass;
}
+} // namsespace Internal
-void KeyEvent::SetTime( unsigned long time )
+Internal::KeyEventImpl* GetImplementation( KeyEvent* keyEvent )
{
- mTime = time;
+ Internal::KeyEventImpl* impl( NULL );
+ for( auto&& iter : gKeyEventToImplMapping )
+ {
+ if( iter.keyEvent == keyEvent )
+ {
+ impl = iter.impl;
+ }
+ }
+ return impl;
}
-
-void KeyEvent::SetState( const Dali::KeyEvent::State& state )
+const Internal::KeyEventImpl* GetImplementation( const KeyEvent* keyEvent )
{
- mState = state;
+ Internal::KeyEventImpl* impl( NULL );
+ for( auto&& iter : gKeyEventToImplMapping )
+ {
+ if( iter.keyEvent == keyEvent )
+ {
+ impl = iter.impl;
+ }
+ }
+ return impl;
}
-} // namespace Internal
-
} // namespace Dali
#define DALI_INTERNAL_KEY_EVENT_H
/*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
// INTERNAL INCLUDES
#include <dali/public-api/events/key-event.h>
-#include <dali/public-api/object/base-object.h>
namespace Dali
{
namespace Internal
{
-class KeyEvent;
-typedef IntrusivePtr< KeyEvent > KeyEventPtr;
-
-/**
- * @copydoc Dali::KeyEvent
- */
-class KeyEvent : public BaseObject
+struct KeyEventImpl
{
public:
/**
- * @brief Default constructor.
- */
- KeyEvent();
-
- /**
* @brief Constructor.
- *
- * @param[in] keyName The name of the key pressed or command from the IMF, if later then the some following parameters will be needed.
- * @param[in] logicalKey The logical key symbol (eg. shift + 1 == "exclamation")
- * @param[in] keyString The string of input characters or key pressed
- * @param[in] keyCode The unique key code for the key pressed.
- * @param[in] keyModifier The key modifier for special keys like shift and alt
- * @param[in] timeStamp The time (in ms) that the key event occurred.
- * @param[in] keyState The state of the key event.
- * @param[in] compose The key compose
- * @param[in] deviceName The name of device the key event originated from
- * @param[in] deviceClass The class of device the key event originated from
- * @param[in] deviceSubclass The subclass of device the key event originated from
*/
- KeyEvent( const std::string& keyName,
- const std::string& logicalKey,
- const std::string& keyString,
- int keyCode,
- int keyModifier,
- unsigned long timeStamp,
- const Dali::KeyEvent::State& keyState,
- const std::string& compose,
- const std::string& deviceName,
- const Device::Class::Type deviceClass,
- const Device::Subclass::Type deviceSubclass );
+ KeyEventImpl( Dali::KeyEvent* keyEvent );
/**
* @brief Destructor.
*/
- ~KeyEvent();
-
- /**
- * Create a new KeyEvent.
- *
- * @param[in] keyName The name of the key pressed or command from the IMF, if later then the some following parameters will be needed.
- * @param[in] logicalKey The logical key symbol (eg. shift + 1 == "exclamation")
- * @param[in] keyString The string of input characters or key pressed
- * @param[in] keyCode The unique key code for the key pressed.
- * @param[in] keyModifier The key modifier for special keys like shift and alt
- * @param[in] timeStamp The time (in ms) that the key event occurred.
- * @param[in] keyState The state of the key event.
- * @param[in] compose The key compose
- * @param[in] deviceName The name of device the key event originated from
- * @param[in] deviceClass The class of device the key event originated from
- * @param[in] deviceSubclass The subclass of device the key event originated from
- * @return A smart-pointer to the newly allocated KeyEvent.
- */
- static KeyEventPtr New( const std::string& keyName,
- const std::string& logicalKey,
- const std::string& keyString,
- int keyCode,
- int keyModifier,
- unsigned long timeStamp,
- const Dali::KeyEvent::State& keyState,
- const std::string& compose,
- const std::string& deviceName,
- const Device::Class::Type deviceClass,
- const Device::Subclass::Type deviceSubclass );
-
- /**
- * @copydoc Dali::KeyEvent::IsShiftModifier()
- */
- bool IsShiftModifier() const;
+ ~KeyEventImpl();
/**
- * @copydoc Dali::KeyEvent::IsCtrlModifier()
+ * @brief Assignment operator.
+ * @param[in] rhs A reference to the copied handle
+ * @return A reference to this
*/
- bool IsCtrlModifier() const;
+ KeyEventImpl& operator=( const KeyEventImpl& rhs );
/**
- * @copydoc Dali::KeyEvent::IsAltModifier()
+ * @brief Get the key symbol string.
+ * @return The key symbol
*/
- bool IsAltModifier() const;
+ std::string GetLogicalKey() const;
/**
- * @copydoc Dali::KeyEvent::GetCompose()
+ * @brief Set the key symbol string to the KeyEvent.
+ * @param[in] key The key symbol to set
*/
- const std::string& GetCompose() const;
+ void SetLogicalKey( const std::string& logicalKey );
/**
- * @copydoc Dali::KeyEvent::GetDeviceName()
- */
- const std::string& GetDeviceName() const;
-
- /**
- * @copydoc Dali::KeyEvent::GetDeviceClass()
- */
- Device::Class::Type GetDeviceClass() const;
-
- /**
- * @copydoc Dali::KeyEvent::GetDeviceSubclass()
- */
- Device::Subclass::Type GetDeviceSubclass() const;
-
- /**
- * @copydoc Dali::KeyEvent::GetKeyName()
- */
- const std::string& GetKeyName() const;
-
- /**
- * @copydoc Dali::KeyEvent::GetKeyString()
- */
- const std::string& GetKeyString() const;
-
- /**
- * @copydoc Dali::KeyEvent::GetLogicalKey()
- */
- const std::string& GetLogicalKey() const;
-
- /**
- * @copydoc Dali::KeyEvent::GetKeyCode()
- */
- int32_t GetKeyCode() const;
-
- /**
- * @copydoc Dali::KeyEvent::GetKeyModifier()
- */
- int32_t GetKeyModifier() const;
-
- /**
- * @copydoc Dali::KeyEvent::GetTime()
+ * @brief Get the compose string.
+ *
+ * @return The compose string.
*/
- unsigned long GetTime() const;
+ std::string GetCompose() const;
/**
- * @copydoc Dali::KeyEvent::GetState()
+ * @brief Set the compose string to the KeyEvent
+ * A string if this keystroke has modified a string in the middle of being composed,
+ * this string replaces the previous one.
+ *
+ * @param[in] compose The compose string to set
*/
- Dali::KeyEvent::State GetState() const;
+ void SetCompose( const std::string& compose );
/**
- * @brief Set the name given to the key pressed
+ * @brief Get the device name the key event originated from
*
- * @param[in] keyName The name given to the key pressed.
+ * @return The device name
*/
- void SetKeyName( const std::string& keyName );
+ std::string GetDeviceName() const;
/**
- * @brief Set the actual string of input characters that should be used for input editors.
+ * @brief Set the device name to the KeyEvent
*
- * @param[in] The actual string of input characters
+ * @param[in] deviceName Device name string to set
*/
- void SetKeyString( const std::string& keyString );
+ void SetDeviceName( const std::string& deviceName );
/**
- * @brief Set the unique key code for the key pressed.
+ * @brief Get the device class the key event originated from
*
- * @param[in] keyCode The unique key code for the key pressed
+ * @return The device class
*/
- void SetKeyCode( int32_t keyCode );
+ Device::Class::Type GetDeviceClass() const;
/**
- * @brief Set the key modifier for special keys like Shift, Alt and Ctrl which modify the next key pressed.
+ * @brief Set the device class to the KeyEvent
*
- * @param[in] keyModifier The key modifier
+ * @param[in] deviceClass Device class to set
*/
- void SetKeyModifier( int32_t keyModifier );
+ void SetDeviceClass( Device::Class::Type deviceClass );
/**
- * @brief Set the time (in ms) that the key event occurred.
+ * @brief Get the device subclass the key event originated from
*
- * @param[in] time The time (in ms)
+ * @return The device subclass
*/
- void SetTime( unsigned long time );
+ Device::Subclass::Type GetDeviceSubclass() const;
/**
- * @brief Set the state of the key event.
+ * @brief Set the device subclass to the KeyEvent
*
- * @param[in] state The state of the key event
+ * @param[in] deviceClass Device subclass to set
*/
- void SetState( const Dali::KeyEvent::State& state );
+ void SetDeviceSubclass( Device::Subclass::Type deviceSubclass );
private:
- // Not copyable or movable
+ // Undefined
+ KeyEventImpl();
- KeyEvent( const KeyEvent& rhs ) = delete; ///< Deleted copy constructor
- KeyEvent( KeyEvent&& rhs ) = delete; ///< Deleted move constructor
- KeyEvent& operator=( const KeyEvent& rhs ) = delete; ///< Deleted copy assignment operator
- KeyEvent& operator=( KeyEvent&& rhs ) = delete; ///< Deleted move assignment operator
+ // Undefined
+ KeyEventImpl( const KeyEventImpl& rhs );
private:
- std::string mKeyName; ///< The name of the key pressed
- std::string mLogicalKey; ///< The logical key symbol
- std::string mKeyString; ///< The string of input characters
- int mKeyCode; ///< TThe unique key code
- int mKeyModifier; ///< The key modifier
- unsigned long mTime; ///< The time that the key event occurred.
- Dali::KeyEvent::State mState; ///< The state of the key event.
- std::string mCompose; ///< The key compose
- std::string mDeviceName; ///< The name of device the key event originated from
- Device::Class::Type mDeviceClass; ///< The class of device the key event originated from
- Device::Subclass::Type mDeviceSubclass; ///< The subclass of device the key event originated from
+ std::string mLogicalKey;
+ std::string mCompose;
+ std::string mDeviceName;
+ Device::Class::Type mDeviceClass;
+ Device::Subclass::Type mDeviceSubclass;
};
} // namespace Internal
// Helpers for public-api forwarding methods
-inline Internal::KeyEvent& GetImplementation( Dali::KeyEvent& keyEvent )
-{
- DALI_ASSERT_ALWAYS( keyEvent && "Key Event handle is empty" );
-
- BaseObject& object = keyEvent.GetBaseObject();
-
- return static_cast< Internal::KeyEvent& >( object );
-}
-
-inline const Internal::KeyEvent& GetImplementation( const Dali::KeyEvent& keyEvent )
-{
- DALI_ASSERT_ALWAYS( keyEvent && "Key Event handle is empty" );
-
- const BaseObject& object = keyEvent.GetBaseObject();
+Internal::KeyEventImpl* GetImplementation( KeyEvent* keyEvent );
- return static_cast< const Internal::KeyEvent& >( object );
-}
+const Internal::KeyEventImpl* GetImplementation( const KeyEvent* keyEvent );
} // namespace Dali
/*
- * Copyright (c) 2020 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.
// INTERNAL INCLUDES
#include <dali/public-api/events/key-event.h>
#include <dali/internal/event/events/key-event-impl.h>
+#include <dali/internal/event/actors/actor-impl.h>
#include <dali/internal/event/common/scene-impl.h>
#include <dali/integration-api/events/key-event-integ.h>
void KeyEventProcessor::ProcessKeyEvent( const Integration::KeyEvent& event )
{
- KeyEventPtr keyEvent( new KeyEvent( event.keyName, event.logicalKey, event.keyString, event.keyCode, event.keyModifier, event.time, static_cast<Dali::KeyEvent::State>( event.state ), event.compose, event.deviceName, event.deviceClass, event.deviceSubclass ) );
- Dali::KeyEvent keyEventHandle( keyEvent.Get() );
+ KeyEvent keyEvent(event.keyName, event.keyString, event.keyCode, event.keyModifier, event.time, static_cast<Dali::KeyEvent::State>(event.state));
+ GetImplementation( &keyEvent )->SetLogicalKey( event.logicalKey );
+ GetImplementation( &keyEvent )->SetCompose( event.compose );
+ GetImplementation( &keyEvent )->SetDeviceName( event.deviceName );
+ GetImplementation( &keyEvent )->SetDeviceClass( event.deviceClass );
+ GetImplementation( &keyEvent )->SetDeviceSubclass( event.deviceSubclass );
// Emit the key event signal from the scene.
- bool consumed = mScene.EmitKeyEventGeneratedSignal( keyEventHandle );
+ bool consumed = mScene.EmitKeyEventGeneratedSignal( keyEvent );
if( !consumed )
{
- mScene.EmitKeyEventSignal( keyEventHandle );
+ mScene.EmitKeyEventSignal(keyEvent);
}
}
class CustomActor;
class CustomActorImpl;
class RelayoutContainer;
-class KeyEvent;
+struct KeyEvent;
class HoverEvent;
class WheelEvent;
struct Vector2;
/*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 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.
namespace Dali
{
-KeyEvent::KeyEvent()
-: BaseHandle()
+namespace
{
+const uint32_t MODIFIER_SHIFT = 0x1;
+const uint32_t MODIFIER_CTRL = 0x2;
+const uint32_t MODIFIER_ALT = 0x4;
+const int32_t KEY_INVALID_CODE = -1;
}
-KeyEvent::KeyEvent( const KeyEvent& rhs ) = default;
-
-KeyEvent::KeyEvent( KeyEvent&& rhs ) = default;
-
-KeyEvent::~KeyEvent()
+KeyEvent::KeyEvent()
+: keyPressedName(""),
+ keyPressed(""),
+ keyCode(KEY_INVALID_CODE),
+ keyModifier(0),
+ time(0),
+ state(KeyEvent::Down)
{
+ new Internal::KeyEventImpl( this );
}
-KeyEvent& KeyEvent::operator=( const KeyEvent& rhs ) = default;
-
-KeyEvent& KeyEvent::operator=( KeyEvent&& rhs ) = default;
-
-bool KeyEvent::IsShiftModifier() const
+KeyEvent::KeyEvent(const std::string& keyName, const std::string& keyString, int32_t keyCode, int32_t keyModifier,unsigned long timeStamp, const State& keyState)
+: keyPressedName(keyName),
+ keyPressed(keyString),
+ keyCode(keyCode),
+ keyModifier(keyModifier),
+ time(timeStamp),
+ state(keyState)
{
- return GetImplementation( *this ).IsShiftModifier();
+ new Internal::KeyEventImpl( this );
}
-bool KeyEvent::IsCtrlModifier() const
+KeyEvent::KeyEvent( const KeyEvent& rhs )
+: keyPressedName( rhs.keyPressedName ),
+ keyPressed( rhs.keyPressed ),
+ keyCode( rhs.keyCode ),
+ keyModifier( rhs.keyModifier ),
+ time( rhs.time ),
+ state( rhs.state )
{
- return GetImplementation( *this ).IsCtrlModifier();
+ Internal::KeyEventImpl* impl = new Internal::KeyEventImpl( this );
+ *impl = *GetImplementation( &rhs );
}
-bool KeyEvent::IsAltModifier() const
+KeyEvent& KeyEvent::operator=( const KeyEvent& rhs )
{
- return GetImplementation( *this ).IsAltModifier();
-}
+ if( this != &rhs )
+ {
+ keyPressedName = rhs.keyPressedName;
+ keyPressed = rhs.keyPressed;
+ keyCode = rhs.keyCode;
+ keyModifier = rhs.keyModifier;
+ time = rhs.time;
+ state = rhs.state;
-const std::string& KeyEvent::GetCompose() const
-{
- return GetImplementation( *this ).GetCompose();
-}
+ *GetImplementation( this ) = *GetImplementation( &rhs );
+ }
-const std::string& KeyEvent::GetDeviceName() const
-{
- return GetImplementation( *this ).GetDeviceName();
+ return *this;
}
-Device::Class::Type KeyEvent::GetDeviceClass() const
+KeyEvent::~KeyEvent()
{
- return GetImplementation( *this ).GetDeviceClass();
+ delete GetImplementation( this );
}
-Device::Subclass::Type KeyEvent::GetDeviceSubclass() const
+bool KeyEvent::IsShiftModifier() const
{
- return GetImplementation( *this ).GetDeviceSubclass();
-}
+ if ((MODIFIER_SHIFT & keyModifier) == MODIFIER_SHIFT)
+ {
+ return true;
+ }
-const std::string& KeyEvent::GetKeyName() const
-{
- return GetImplementation( *this ).GetKeyName();
+ return false;
}
-const std::string& KeyEvent::GetKeyString() const
+bool KeyEvent::IsCtrlModifier() const
{
- return GetImplementation( *this ).GetKeyString();
-}
+ if ((MODIFIER_CTRL & keyModifier) == MODIFIER_CTRL)
+ {
+ return true;
+ }
-const std::string& KeyEvent::GetLogicalKey() const
-{
- return GetImplementation( *this ).GetLogicalKey();
+ return false;
}
-int32_t KeyEvent::GetKeyCode() const
+bool KeyEvent::IsAltModifier() const
{
- return GetImplementation( *this ).GetKeyCode();
+ if ((MODIFIER_ALT & keyModifier) == MODIFIER_ALT)
+ {
+ return true;
+ }
+
+ return false;
}
-int32_t KeyEvent::GetKeyModifier() const
+std::string KeyEvent::GetCompose() const
{
- return GetImplementation( *this ).GetKeyModifier();
+ return GetImplementation( this )->GetCompose();
}
-unsigned long KeyEvent::GetTime() const
+std::string KeyEvent::GetDeviceName() const
{
- return GetImplementation( *this ).GetTime();
+ return GetImplementation( this )->GetDeviceName();
}
-KeyEvent::State KeyEvent::GetState() const
+Device::Class::Type KeyEvent::GetDeviceClass() const
{
- return GetImplementation( *this ).GetState();
+ return GetImplementation( this )->GetDeviceClass();
}
-KeyEvent::KeyEvent( Internal::KeyEvent* internal )
-: BaseHandle( internal )
+Device::Subclass::Type KeyEvent::GetDeviceSubclass() const
{
+ return GetImplementation( this )->GetDeviceSubclass();
}
+
} // namespace Dali
#define DALI_KEY_EVENT_H
/*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/events/device.h>
namespace Dali
{
-
-namespace Internal DALI_INTERNAL
-{
-class KeyEvent;
-}
-
/**
* @addtogroup dali_core_events
* @{
*/
/**
- * @brief The key event class is used to store a key press.
+ * @brief The key event structure is used to store a key press.
*
* It facilitates processing of these key presses and passing to other
* libraries like Toolkit. The keyString is the actual character you
* module.
* @SINCE_1_0.0
*/
-class DALI_CORE_API KeyEvent : public BaseHandle
+struct DALI_CORE_API KeyEvent
{
-
-public:
-
// Enumerations
/**
};
/**
- * @brief An uninitialized KeyEvent instance.
- *
- * Calling member functions with an uninitialized KeyEvent handle is not allowed.
+ * @brief Default constructor.
* @SINCE_1_0.0
*/
KeyEvent();
/**
+ * @brief Constructor.
+ *
+ * @SINCE_1_0.0
+ * @param[in] keyName The name of the key pressed or command from the IMF, if later then the some following parameters will be needed
+ * @param[in] keyString A string of input characters or key pressed
+ * @param[in] keyCode The unique key code for the key pressed
+ * @param[in] keyModifier The key modifier for special keys like shift and alt
+ * @param[in] timeStamp The time (in ms) that the key event occurred
+ * @param[in] keyState The state of the key event
+ */
+ KeyEvent(const std::string& keyName, const std::string& keyString, int32_t keyCode, int32_t keyModifier, unsigned long timeStamp, const State& keyState);
+
+ /**
* @brief Copy constructor.
* @SINCE_1_2.36
* @param[in] rhs A reference to the copied handle
KeyEvent( const KeyEvent& rhs );
/**
- * @brief Move constructor.
- *
- * @SINCE_1_9.27
- * @param[in] rhs A reference to the moved handle
- */
- KeyEvent( KeyEvent&& rhs );
-
- /**
- * @brief Copy assignment operator.
+ * @brief Assignment operator.
* @SINCE_1_2.36
* @param[in] rhs A reference to the copied handle
* @return A reference to this
KeyEvent& operator=( const KeyEvent& rhs );
/**
- * @brief Move assignment operator.
- *
- * @SINCE_1_9.27
- * @param[in] rhs A reference to the moved handle
- * @return A reference to this
- */
- KeyEvent& operator=( KeyEvent&& rhs );
-
- /**
* @brief Destructor.
* @SINCE_1_0.0
*/
/**
* @brief Get the key compose string.
*
- * @SINCE_1_9.27
+ * @SINCE_1_3.22
* @return The compose string
*/
- const std::string& GetCompose() const;
+ std::string GetCompose() const;
/**
* @brief Get the device name the key event originated from.
*
- * @SINCE_1_9.27
+ * @SINCE_1_2.60
* @return The device name
*/
- const std::string& GetDeviceName() const;
+ std::string GetDeviceName() const;
/**
* @brief Get the device class the key event originated from.
*/
Device::Subclass::Type GetDeviceSubclass() const;
- /**
- * @brief Get the name given to the key pressed or command from the IMF
- *
- * @SINCE_1_9.27
- * @return The name given to the key pressed.
- */
- const std::string& GetKeyName() const;
+ // Data
/**
- * @brief Get the actual string of input characters that should be used for input editors.
- *
- * @SINCE_1_9.27
- * @return The actual string of input characters
+ * @brief Name given to the key pressed.
*/
- const std::string& GetKeyString() const;
+ std::string keyPressedName;
/**
- * @brief Gets the logical key string.
- *
- * For example, when the user presses 'shift' key and '1' key together, the logical key is "exclamation".
- * Plus, the key name is "1", and the key string is "!".
- *
- * @SINCE_1_9.27
- * @return The logical key symbol
+ * @brief The actual string returned that should be used for input editors.
*/
- const std::string& GetLogicalKey() const;
+ std::string keyPressed;
/**
- * @brief Get the unique key code for the key pressed.
+ * @brief Keycode for the key pressed.
*
- * @SINCE_1_9.27
- * @return The unique key code for the key pressed
- *
- * @remarks We recommend not to use this key code value directly because its meaning
- * might be changed in the future. Currently, it means a platform-specific key code.
- * You need to use IsKey() to know what a key event means instead of direct comparison
- * of key code value.
+ * @remarks We recommend not to use this key code value
+ * directly because its meaning might be changed in the future. Currently, it means a
+ * platform-specific key code. You need to use IsKey() to know what a key event means
+ * instead of direct comparison of key code value.
*/
- int32_t GetKeyCode() const;
+ int32_t keyCode;
/**
- * @brief Return the key modifier for special keys like Shift, Alt and Ctrl which modify the next key pressed.
- *
- * @SINCE_1_9.27
- * @return The key modifier
+ * @brief special keys like shift, alt and control which modify the next key pressed.
*/
- int32_t GetKeyModifier() const;
+ int32_t keyModifier;
/**
- * @brief Get the time (in ms) that the key event occurred.
- *
- * @SINCE_1_9.27
- * @return The time (in ms)
+ * @brief The time (in ms) that the key event occurred.
*/
- unsigned long GetTime() const;
+ unsigned long time;
/**
- * @brief Get the state of the key event.
+ * @brief State of the key event.
*
* @see State
- *
- * @SINCE_1_9.27
- * @return The state of the key event
*/
- State GetState() const;
+ State state;
-public: // Not intended for application developers
-
- /// @cond internal
- /**
- * @brief This constructor is used internally to Create an initialized KeyEvent handle.
- *
- * @SINCE_1_9.27
- * @param[in] keyEvent A pointer to a newly allocated Dali resource
- */
- explicit DALI_INTERNAL KeyEvent( Internal::KeyEvent* keyEvent );
- /// @endcond
};
/**
projects / platform / core / uifw / dali-core.git / commitdiff