[Tizen] Adding deviceClass to KeyEvent Integ

Change-Id: I47ada0bfae0a8788d70886003084e4b416490e58

diff --git a/automated-tests/src/dali/utc-Dali-KeyEvent.cpp b/automated-tests/src/dali/utc-Dali-KeyEvent.cpp
index fc7aeae..bcb299d 100644 (file)
--- a/automated-tests/src/dali/utc-Dali-KeyEvent.cpp
+++ b/automated-tests/src/dali/utc-Dali-KeyEvent.cpp
@@ -311,8 +311,9 @@ int UtcDaliIntegrationKeyEvent(void)
     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 );
@@ -321,6 +322,7 @@ int UtcDaliIntegrationKeyEvent(void)
     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;
 }
@@ -341,6 +343,7 @@ int UtcDaliIntegrationKeyEventConvertor(void)
   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;
 }
@@ -362,3 +365,21 @@ int UtcDaliKeyEventSetDeviceName(void)
 
   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;
+}

diff --git a/automated-tests/src/dali/utc-Dali-Stage.cpp b/automated-tests/src/dali/utc-Dali-Stage.cpp
index b8c3504..9401ecf 100644 (file)
--- a/automated-tests/src/dali/utc-Dali-Stage.cpp
+++ b/automated-tests/src/dali/utc-Dali-Stage.cpp
@@ -45,6 +45,7 @@ namespace
 {
 
 const std::string DEFAULT_DEVICE_NAME("hwKeyboard");
+const DevelKeyEvent::DeviceClass::Type DEFAULT_DEVICE_CLASS( DevelKeyEvent::DeviceClass::TOUCH );
 
 // Functor for EventProcessingFinished signal
 struct EventProcessingFinishedFunctor
@@ -883,7 +884,7 @@ int UtcDaliStageKeyEventGeneratedSignalP(void)
   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 );
@@ -894,7 +895,7 @@ int UtcDaliStageKeyEventGeneratedSignalP(void)
 
   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 );
@@ -905,7 +906,7 @@ int UtcDaliStageKeyEventGeneratedSignalP(void)
 
   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 );
@@ -916,7 +917,7 @@ int UtcDaliStageKeyEventGeneratedSignalP(void)
 
   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 );
@@ -936,7 +937,7 @@ int UtcDaliStageSignalKeyEventP(void)
   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 );
@@ -947,7 +948,7 @@ int UtcDaliStageSignalKeyEventP(void)
 
   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 );
@@ -958,7 +959,7 @@ int UtcDaliStageSignalKeyEventP(void)
 
   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 );
@@ -969,7 +970,7 @@ int UtcDaliStageSignalKeyEventP(void)
 
   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 );

diff --git a/dali/devel-api/events/key-event-devel.h b/dali/devel-api/events/key-event-devel.h
index 13ffd20..908ce90 100644 (file)
--- a/dali/devel-api/events/key-event-devel.h
+++ b/dali/devel-api/events/key-event-devel.h
@@ -26,24 +26,61 @@ namespace Dali
 
 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

diff --git a/dali/integration-api/events/key-event-integ.cpp b/dali/integration-api/events/key-event-integ.cpp
index ed46ccf..b3bcdee 100644 (file)
--- a/dali/integration-api/events/key-event-integ.cpp
+++ b/dali/integration-api/events/key-event-integ.cpp
@@ -25,39 +25,42 @@ namespace Integration
 {
 
 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 )
 {
 }
 

diff --git a/dali/integration-api/events/key-event-integ.h b/dali/integration-api/events/key-event-integ.h
index e448a30..d98970d 100644 (file)
--- a/dali/integration-api/events/key-event-integ.h
+++ b/dali/integration-api/events/key-event-integ.h
@@ -24,6 +24,7 @@
 // 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
 {
@@ -62,6 +63,7 @@ struct KeyEvent : public Event
    * @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,
@@ -69,7 +71,8 @@ struct KeyEvent : public Event
            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
@@ -120,6 +123,10 @@ struct KeyEvent : public Event
    */
   std::string deviceName;
 
+  /**
+   * Class of device KeyEvent originated from
+   */
+  DevelKeyEvent::DeviceClass::Type deviceClass;
 };
 
 } // namespace Integration

diff --git a/dali/internal/event/events/key-event-processor.cpp b/dali/internal/event/events/key-event-processor.cpp
index 9d5b6de..9d083fa 100644 (file)
--- a/dali/internal/event/events/key-event-processor.cpp
+++ b/dali/internal/event/events/key-event-processor.cpp
@@ -45,6 +45,8 @@ void KeyEventProcessor::ProcessKeyEvent(const Integration::KeyEvent& event)
   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 );
 

diff --git a/dali/public-api/events/key-event.cpp b/dali/public-api/events/key-event.cpp
index 27e3ed4..960174a 100644 (file)
--- a/dali/public-api/events/key-event.cpp
+++ b/dali/public-api/events/key-event.cpp
@@ -35,15 +35,17 @@ const int KEY_INVALID_CODE = -1;
 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;
@@ -52,9 +54,11 @@ struct KeyEventImpl
   KeyEventImpl( const KeyEventImpl& rhs )
   {
     deviceName =  rhs.deviceName;
+    deviceClass = rhs.deviceClass;
   }
 
   std::string deviceName;
+  DevelKeyEvent::DeviceClass::Type deviceClass;
 };
 
 typedef std::map< const KeyEvent*, KeyEventImpl*> KeyEventMap;
@@ -174,5 +178,28 @@ void DevelKeyEvent::SetDeviceName( KeyEvent& keyEvent, const std::string& device
   }
 }
 
+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