Keyboard disable (#6874)

Added disable key/shortcut functionality

src/modules/keyboardmanager/test/AppSpecificShortcutRemappingTests.cpp

@@ -4,12 +4,14 @@
 #include <keyboardmanager/common/KeyboardManagerState.h>
 #include <keyboardmanager/dll/KeyboardEventHandlers.h>
 #include "TestHelpers.h"
+#include <common\shared_constants.h>
 
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 
 namespace RemappingLogicTests
 {
     TEST_CLASS (AppSpecificShortcutRemappingTests)
+    
     {
     private:
         MockedInput mockedInputHandler;
@@ -312,5 +314,33 @@ namespace RemappingLogicTests
             Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x41), false);
             Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x56), false);
         }
+
+        // Disable app specific shortcut
+        TEST_METHOD (AppSpecificShortcutToDisable_ShouldDisable_WhenAppIsOnForeground)
+        {
+            Shortcut src;
+            src.SetKey(VK_CONTROL);
+            WORD actionKey = 0x41;
+            src.SetKey(actionKey);
+            WORD disableKey = CommonSharedConstants::VK_DISABLED;
+            testState.AddAppSpecificShortcut(testApp1, src, disableKey);
+
+            // Set the testApp as the foreground process
+            mockedInputHandler.SetForegroundProcess(testApp1);
+
+            const int nInputs = 2;
+            INPUT input[nInputs] = {};
+            input[0].type = INPUT_KEYBOARD;
+            input[0].ki.wVk = VK_CONTROL;
+            input[1].type = INPUT_KEYBOARD;
+            input[1].ki.wVk = actionKey;
+
+            // Send Ctrl+A keydown
+            mockedInputHandler.SendVirtualInput(nInputs, input, sizeof(INPUT));
+
+            // Check if Ctrl+A is released and disable key was not send
+            Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(VK_CONTROL), false);
+            Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(actionKey), false);
+        }
     };
 }

src/modules/keyboardmanager/test/BufferValidationTests.cpp

@@ -1438,5 +1438,26 @@ namespace RemappingUITests
                 Assert::AreEqual(true, result.first == KeyboardManagerHelper::ErrorType::NoError);
             });
         }
+
+        // Return error on Disable as second modifier key or action key
+        TEST_METHOD (ValidateShortcutBufferElement_ShouldReturnDisableAsActionKeyError_OnSettingSecondDropdownAsDisable)
+        {
+            std::vector<DWORD> keyList = keyboardLayout.GetKeyCodeList(true);
+            keyList.insert(keyList.begin(), CommonSharedConstants::VK_DISABLED);
+            // Arrange
+            RemapBuffer remapBuffer;
+            remapBuffer.push_back(std::make_pair(RemapBufferItem{ std::vector<DWORD>{ VK_SHIFT, CommonSharedConstants::VK_DISABLED }, Shortcut() }, testApp1));
+            std::vector<int32_t> selectedIndices = { 
+                GetDropDownIndexFromDropDownList(VK_SHIFT, keyList),
+                GetDropDownIndexFromDropDownList(CommonSharedConstants::VK_DISABLED, keyList)
+            };
+
+            // Act
+            std::pair<KeyboardManagerHelper::ErrorType, BufferValidationHelpers::DropDownAction> result = BufferValidationHelpers::ValidateShortcutBufferElement(0, 1, 1, selectedIndices, testApp1, true, keyList, remapBuffer, true);
+
+            // Assert
+            Assert::AreEqual(true, result.first == KeyboardManagerHelper::ErrorType::ShortcutDisableAsActionKey);
+            Assert::AreEqual(true, result.second == BufferValidationHelpers::DropDownAction::NoAction);
+        }
     };
 }

src/modules/keyboardmanager/test/OSLevelShortcutRemappingTests.cpp

@@ -2004,5 +2004,88 @@ namespace RemappingLogicTests
             // Shortcut invoked state should be true
             Assert::AreEqual(true, testState.osLevelShortcutReMap[src].isShortcutInvoked);
         }
+
+        TEST_METHOD (ShortcutDisable_ShouldDisableShortcut_OnExactMatch)
+        {
+            Shortcut src;
+            src.SetKey(VK_CONTROL);
+            WORD actionKey = 0x41;
+            src.SetKey(actionKey);
+            WORD disableKey = CommonSharedConstants::VK_DISABLED;
+
+            testState.AddOSLevelShortcut(src, disableKey);
+
+            const int nInputs = 2;
+            INPUT input[nInputs] = {};
+            input[0].type = INPUT_KEYBOARD;
+            input[0].ki.wVk = VK_CONTROL;
+            input[1].type = INPUT_KEYBOARD;
+            input[1].ki.wVk = actionKey;
+
+            // send Ctrl+A
+            mockedInputHandler.SendVirtualInput(nInputs, input, sizeof(INPUT));
+
+            // Check that Ctrl+A was released and Disable key was not sent
+            Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(VK_CONTROL), false);
+            Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(actionKey), false);
+        }
+
+        TEST_METHOD (ShortcutDisable_ShouldNotDisableShortcut_OnSubsetMatch)
+        {
+            Shortcut src;
+            src.SetKey(VK_CONTROL);
+            WORD actionKey = 0x41;
+            src.SetKey(actionKey);
+            WORD disableKey = CommonSharedConstants::VK_DISABLED;
+
+            testState.AddOSLevelShortcut(src, disableKey);
+
+            const int nInputs = 3;
+            INPUT input[nInputs] = {};
+            input[0].type = INPUT_KEYBOARD;
+            input[0].ki.wVk = VK_CONTROL;
+            input[1].type = INPUT_KEYBOARD;
+            input[1].ki.wVk = VK_SHIFT;
+            input[2].type = INPUT_KEYBOARD;
+            input[2].ki.wVk = actionKey;
+
+            // send Ctrl+Shift+A
+            mockedInputHandler.SendVirtualInput(nInputs, input, sizeof(INPUT));
+
+            // Check that Ctrl+A was not released and Disable key was not sent
+            Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(VK_CONTROL), true);
+            Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(actionKey), true);
+        }
+
+        TEST_METHOD (ShortcutDisable_ShouldNotDisableShortcutSuperset_AfterShorcutWasDisabled)
+        {
+            Shortcut src;
+            src.SetKey(VK_CONTROL);
+            WORD actionKey = 0x41;
+            src.SetKey(actionKey);
+            WORD disableKey = CommonSharedConstants::VK_DISABLED;
+
+            testState.AddOSLevelShortcut(src, disableKey);
+
+            const int nInputs = 2;
+            INPUT input[nInputs] = {};
+            input[0].type = INPUT_KEYBOARD;
+            input[0].ki.wVk = VK_CONTROL;
+            input[1].type = INPUT_KEYBOARD;
+            input[1].ki.wVk = actionKey;
+
+            // send Ctrl+A
+            mockedInputHandler.SendVirtualInput(nInputs, input, sizeof(INPUT));
+
+            input[0].type = INPUT_KEYBOARD;
+            input[0].ki.wVk = 0x42;
+            // send B
+            mockedInputHandler.SendVirtualInput(1, input, sizeof(INPUT));
+
+            // Check that Ctrl+A+B was pressed
+            Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(VK_CONTROL), true);
+            Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(actionKey), true);
+            Assert::AreEqual(mockedInputHandler.GetVirtualKeyState(0x42), true);
+        }
     };
 }

src/modules/keyboardmanager/test/SingleKeyRemappingTests.cpp

@@ -58,8 +58,8 @@ namespace RemappingLogicTests
         // Test if key is suppressed if a key is disabled by single key remap
         TEST_METHOD (RemappedKeyDisabled_ShouldNotChangeKeyState_OnKeyEvent)
         {
-            // Remap A to 0x0 (disabled)
-            testState.AddSingleKeyRemap(0x41, 0x0);
+            // Remap A to VK_DISABLE (disabled)
+            testState.AddSingleKeyRemap(0x41, CommonSharedConstants::VK_DISABLED);
             const int nInputs = 1;
 
             INPUT input[nInputs] = {};