Add NoIntercept KeyEvent modifier

This modifier prevents the event from being intercepted. This, in turn, allows
the Accessibility module to intercept all events and then feed them back if not
consumed by the Screen Reader, without entering an infinite interception loop.

Change-Id: I667d5be40b1180c992852e2af025eb3b916742e8

diff --git a/automated-tests/src/dali/utc-Dali-KeyEvent.cpp b/automated-tests/src/dali/utc-Dali-KeyEvent.cpp
index 77e0f74..fcd6b34 100644 (file)
--- a/automated-tests/src/dali/utc-Dali-KeyEvent.cpp
+++ b/automated-tests/src/dali/utc-Dali-KeyEvent.cpp
@@ -361,6 +361,24 @@ int UtcDaliKeyEventIsAltModifier(void)
   END_TEST;
 }
 
+int UtcDaliKeyEventIsNoInterceptModifier(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); // set name to test, key string to i and modifier to shift
+  DALI_TEST_CHECK(event);
+
+  DALI_TEST_EQUALS(false, event.IsNoInterceptModifier(), TEST_LOCATION);
+
+  DevelKeyEvent::SetNoInterceptModifier(event, true);
+  DALI_TEST_EQUALS(true, event.IsNoInterceptModifier(), TEST_LOCATION);
+
+  DevelKeyEvent::SetNoInterceptModifier(event, false);
+  DALI_TEST_EQUALS(false, event.IsNoInterceptModifier(), TEST_LOCATION);
+
+  END_TEST;
+}
+
 // Positive fail test case for a method
 int UtcDaliKeyEventIsNotShiftModifier(void)
 {

diff --git a/dali/devel-api/events/key-event-devel.cpp b/dali/devel-api/events/key-event-devel.cpp
index a67a1db..30f1ca8 100644 (file)
--- a/dali/devel-api/events/key-event-devel.cpp
+++ b/dali/devel-api/events/key-event-devel.cpp
@@ -67,6 +67,11 @@ void SetKeyModifier(KeyEvent keyEvent, int32_t keyModifier)
   GetImplementation(keyEvent).SetKeyModifier(keyModifier);\r
 }\r
 \r
+void SetNoInterceptModifier(KeyEvent keyEvent, bool noIntercept)\r
+{\r
+  GetImplementation(keyEvent).SetNoInterceptModifier(noIntercept);\r
+}\r
+\r
 void SetTime(KeyEvent keyEvent, unsigned long time)\r
 {\r
   GetImplementation(keyEvent).SetTime(time);\r

diff --git a/dali/devel-api/events/key-event-devel.h b/dali/devel-api/events/key-event-devel.h
index 409c940..3ff576d 100644 (file)
--- a/dali/devel-api/events/key-event-devel.h
+++ b/dali/devel-api/events/key-event-devel.h
@@ -99,6 +99,15 @@ DALI_CORE_API void SetKeyCode(KeyEvent keyEvent, int32_t keyCode);
 DALI_CORE_API void SetKeyModifier(KeyEvent keyEvent, int32_t keyModifier);\r
 \r
 /**\r
+ * @brief Set the no-intercept key modifier.\r
+ *\r
+ * @SINCE_2_3.13\r
+ * @param[in] keyEvent The instance of KeyEvent\r
+ * @param[in] noIntercept The value of the modifier\r
+ */\r
+DALI_CORE_API void SetNoInterceptModifier(KeyEvent keyEvent, bool noIntercept);\r
+\r
+/**\r
  * @brief Set the time (in ms) that the key event occurred.\r
  *\r
  * @SINCE_1_9.27\r

diff --git a/dali/internal/event/events/key-event-impl.cpp b/dali/internal/event/events/key-event-impl.cpp
index 77d9238..1f1944a 100644 (file)
--- a/dali/internal/event/events/key-event-impl.cpp
+++ b/dali/internal/event/events/key-event-impl.cpp
@@ -25,10 +25,11 @@ namespace Dali
 {
 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;
+const uint32_t MODIFIER_SHIFT        = 0x1;
+const uint32_t MODIFIER_CTRL         = 0x2;
+const uint32_t MODIFIER_ALT          = 0x4;
+const uint32_t MODIFIER_NO_INTERCEPT = (1U << 31);
+const int32_t  KEY_INVALID_CODE      = -1;
 } // namespace
 
 namespace Internal
@@ -114,6 +115,11 @@ bool KeyEvent::IsAltModifier() const
   return ((MODIFIER_ALT & mKeyModifier) == MODIFIER_ALT);
 }
 
+bool KeyEvent::IsNoInterceptModifier() const
+{
+  return ((MODIFIER_NO_INTERCEPT & mKeyModifier) == MODIFIER_NO_INTERCEPT);
+}
+
 const std::string& KeyEvent::GetCompose() const
 {
   return mCompose;
@@ -199,6 +205,18 @@ void KeyEvent::SetKeyModifier(int32_t keyModifier)
   mKeyModifier = keyModifier;
 }
 
+void KeyEvent::SetNoInterceptModifier(bool noIntercept)
+{
+  if(noIntercept)
+  {
+    mKeyModifier |= MODIFIER_NO_INTERCEPT;
+  }
+  else
+  {
+    mKeyModifier &= ~MODIFIER_NO_INTERCEPT;
+  }
+}
+
 void KeyEvent::SetTime(unsigned long time)
 {
   mTime = time;

diff --git a/dali/internal/event/events/key-event-impl.h b/dali/internal/event/events/key-event-impl.h
index 0954d62..3b059bc 100644 (file)
--- a/dali/internal/event/events/key-event-impl.h
+++ b/dali/internal/event/events/key-event-impl.h
@@ -117,6 +117,11 @@ public:
   bool IsAltModifier() const;
 
   /**
+   * @copydoc Dali::KeyEvent::IsNoInterceptModifier()
+   */
+  bool IsNoInterceptModifier() const;
+
+  /**
    * @copydoc Dali::KeyEvent::GetCompose()
    */
   const std::string& GetCompose() const;
@@ -210,6 +215,13 @@ public:
   void SetKeyModifier(int32_t keyModifier);
 
   /**
+   * @brief Set the no-intercept key modifier.
+   *
+   * @param[in] noIntercept The value of the modifier
+   */
+  void SetNoInterceptModifier(bool noIntercept);
+
+  /**
    * @brief Set the time (in ms) that the key event occurred.
    *
    * @param[in] time The time (in ms)

diff --git a/dali/internal/event/events/key-event-processor.cpp b/dali/internal/event/events/key-event-processor.cpp
index f7f7a58..a0337bd 100644 (file)
--- a/dali/internal/event/events/key-event-processor.cpp
+++ b/dali/internal/event/events/key-event-processor.cpp
@@ -66,7 +66,11 @@ void KeyEventProcessor::ProcessKeyEvent(const Integration::KeyEvent& event)
   });
 
   // Emit the key event signal from the scene.
-  bool consumed = mScene.EmitInterceptKeyEventSignal(keyEventHandle);
+  bool consumed = false;
+  if(!keyEventHandle.IsNoInterceptModifier())
+  {
+    consumed = mScene.EmitInterceptKeyEventSignal(keyEventHandle);
+  }
   if(!consumed)
   {
     consumed = mScene.EmitKeyEventGeneratedSignal(keyEventHandle);

diff --git a/dali/public-api/events/key-event.cpp b/dali/public-api/events/key-event.cpp
index dda6e17..3edb0c9 100644 (file)
--- a/dali/public-api/events/key-event.cpp
+++ b/dali/public-api/events/key-event.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 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.
@@ -53,6 +53,11 @@ bool KeyEvent::IsAltModifier() const
   return GetImplementation(*this).IsAltModifier();
 }
 
+bool KeyEvent::IsNoInterceptModifier() const
+{
+  return GetImplementation(*this).IsNoInterceptModifier();
+}
+
 const std::string& KeyEvent::GetCompose() const
 {
   return GetImplementation(*this).GetCompose();

diff --git a/dali/public-api/events/key-event.h b/dali/public-api/events/key-event.h
index 1fa31e7..fdef981 100644 (file)
--- a/dali/public-api/events/key-event.h
+++ b/dali/public-api/events/key-event.h
@@ -2,7 +2,7 @@
 #define DALI_KEY_EVENT_H
 
 /*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 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.
@@ -140,6 +140,14 @@ public:
   bool IsAltModifier() const;
 
   /**
+   * @brief Checks if the no-intercept key modifier has been supplied.
+   *
+   * @SINCE_2_3.13
+   * @return True if no-intercept modifier is present
+   */
+  bool IsNoInterceptModifier() const;
+
+  /**
    * @brief Get the key compose string.
    *
    * @SINCE_1_9.27