Merge pull request #9353 from keymanapp/feat/windows/5822/notify-core-on-kbd-activation

feat(windows): Use Keyboard Activated event API call to turn off caps lock (if required) 🚏

Author: rc-swag

core/src/km_kbp_processevent_api.cpp

@@ -28,7 +28,7 @@ km_kbp_event(
   switch(event) {
     case KM_KBP_EVENT_KEYBOARD_ACTIVATED:
       assert(data == nullptr);
-      if(data == nullptr) {
+      if(data != nullptr) {
         return KM_KBP_STATUS_INVALID_ARGUMENT;
       }
       break;

core/src/kmx/kmx_processevent.h

@@ -86,7 +86,6 @@ class KMX_ProcessEvent {
   /* Caps Lock and modifier management */
 
   KMX_BOOL IsCapsLockOn(KMX_DWORD modifiers);
-  void SetCapsLock(KMX_DWORD &modifiers, KMX_BOOL capsLockOn, KMX_BOOL force = FALSE);
   void ResetCapsLock(KMX_DWORD &modifiers, KMX_BOOL isKeyDown);
   KMX_BOOL KeyCapsLockPress(KMX_DWORD &modifiers, KMX_BOOL isKeyDown);
   void KeyShiftPress(KMX_DWORD &modifiers, KMX_BOOL isKeyDown);
@@ -107,6 +106,7 @@ class KMX_ProcessEvent {
   KMX_Environment *GetEnvironment();
   KMX_Environment const *GetEnvironment() const;
   INTKEYBOARDINFO const *GetKeyboard() const;
+  void SetCapsLock(KMX_DWORD &modifiers, KMX_BOOL capsLockOn, KMX_BOOL force = FALSE);
 
   // Utility function
 public:

core/src/kmx/kmx_processor.cpp

@@ -103,6 +103,30 @@ kmx_processor::update_option(
   return option(scope, key, value);
 }
 
+km_kbp_status
+kmx_processor::external_event(
+  km_kbp_state* state,
+  uint32_t event,
+  void* _kmn_unused(data)
+) {
+
+  switch (event) {
+    case KM_KBP_EVENT_KEYBOARD_ACTIVATED:
+      // reset any current actions in the queue as a new keyboard
+      // has been activated
+      _kmx.GetActions()->ResetQueue();
+      state->actions().clear();
+      if (_kmx.GetKeyboard()->Keyboard->dwFlags & KF_CAPSALWAYSOFF) {
+        KMX_DWORD dummy_modifiers = 0;
+        _kmx.SetCapsLock(dummy_modifiers, FALSE, TRUE);
+      }
+      break;
+    default:
+      return KM_KBP_STATUS_INVALID_ARGUMENT;
+  }
+  return internal_process_queued_actions(state);
+}
+
 bool
 kmx_processor::queue_action(
   km_kbp_state * state,

core/src/kmx/kmx_processor.hpp

@@ -59,7 +59,14 @@ namespace kbp
     km_kbp_status
     process_queued_actions(
       km_kbp_state *state
-      ) override;
+    ) override;
+
+    km_kbp_status
+    external_event(
+      km_kbp_state* state,
+      uint32_t event,
+      void* data
+    ) override;
 
     bool
     queue_action(

core/tests/unit/kmnkbd/action_items.hpp

@@ -23,6 +23,7 @@ const char *action_item_types[] = {
   "KM_KBP_IT_PERSIST_OPT", // = 5,  // The indicated option needs to be stored.
   "KM_KBP_IT_EMIT_KEYSTROKE", // = 6,  // Emit the current keystroke to the application
   "KM_KBP_IT_INVALIDATE_CONTEXT", // = 7,
+  "KM_KBP_IT_CAPSLOCK",//     = 8, Enable or disable capsLock
 };
 
 void print_action_item(const char *title, km_kbp_action_item const & item) {
@@ -50,6 +51,13 @@ void print_action_item(const char *title, km_kbp_action_item const & item) {
       << "           value: " << item.option->value << std::endl
       << "           scope: " << item.option->scope << std::endl;
     break;
+  case KM_KBP_IT_CAPSLOCK:
+    std::cout << "  caps lock:  " <<
+      (item.capsLock == 0 ? "off" :
+      item.capsLock == 1 ? "on" :
+      "invalid value") << " (" <<
+      item.capsLock << ")" << std::endl;
+    break;
   }
 }
 
@@ -68,6 +76,7 @@ bool operator==(
                                                   lhs.backspace.expected_value == rhs.backspace.expected_value; break;
       case KM_KBP_IT_PERSIST_OPT:        result = *lhs.option == *rhs.option; break;
       case KM_KBP_IT_EMIT_KEYSTROKE:     break;
+      case KM_KBP_IT_CAPSLOCK:           result = lhs.capsLock == rhs.capsLock; break;
       case KM_KBP_IT_INVALIDATE_CONTEXT: break;
       default: std::cout << "unexpected type" << std::endl; return false; //
     }

core/tests/unit/kmx/kmx_external_event.cpp

@@ -0,0 +1,91 @@
+/*
+  Copyright:    © 2023 SIL International.
+  Description:  Tests for external event processing for the kmx processor
+  Create Date:  28 Jul 2023
+  Authors:      Ross Cruickshank (RC)
+
+*/
+
+#include <kmx/kmx_processevent.h>
+
+#include "path.hpp"
+#include "state.hpp"
+#include "../kmnkbd/action_items.hpp"
+#include <test_assert.h>
+#include <test_color.h>
+#include "../emscripten_filesystem.h"
+
+#include <map>
+#include <iostream>
+#include <sstream>
+
+/** 
+ * This test will test the infrastructure around the external event processing
+ * The functions tested are:
+ * - km_kbp_event with the event KM_KBP_EVENT_KEYBOARD_ACTIVATED
+ */
+
+using namespace km::kbp::kmx;
+
+km_kbp_option_item test_env_opts[] =
+{
+  KM_KBP_OPTIONS_END
+};
+
+int error_args() {
+  std::cerr << "kmx: Not enough arguments." << std::endl;
+  return 1;
+}
+
+void test_external_event(const km::kbp::path &source_file){
+
+  km_kbp_keyboard * test_kb = nullptr;
+  km_kbp_state * test_state = nullptr;
+
+  km::kbp::path full_path = source_file;
+
+  try_status(km_kbp_keyboard_load(full_path.native().c_str(), &test_kb));
+
+  // Setup state, environment
+  try_status(km_kbp_state_create(test_kb, test_env_opts, &test_state));
+
+  // Set up external events to test the processing.
+  uint32_t event = KM_KBP_EVENT_KEYBOARD_ACTIVATED;
+  // For this particular test we want to have the capslock state as on.
+  // then after the km_kbp_event the caps lock should be off as the load
+  // keyboard is a caps always off keyboard
+
+  try_status(km_kbp_event(test_state, event, nullptr));
+  // The action to turn capslock off must be in the actions list.
+  assert(action_items(test_state, {{KM_KBP_IT_CAPSLOCK, {0,}, {0}}, {KM_KBP_IT_END}}));
+
+  km_kbp_state_dispose(test_state);
+  km_kbp_keyboard_dispose(test_kb);
+
+}
+
+int main(int argc, char *argv []) {
+  int first_arg = 1;
+
+  if (argc < 2) {
+    return error_args();
+  }
+
+  auto arg_color = std::string(argv[1]) == "--color";
+  if(arg_color) {
+    first_arg++;
+    if(argc < 3) {
+      return error_args();
+    }
+  }
+  console_color::enabled = console_color::isaterminal() || arg_color;
+  km::kbp::kmx::g_debug_ToConsole = TRUE;
+
+#ifdef __EMSCRIPTEN__
+  test_external_event(get_wasm_file_path(argv[first_arg]));
+#else
+  test_external_event(argv[first_arg]);
+#endif
+
+  return 0;
+}

core/tests/unit/kmx/meson.build

@@ -208,3 +208,21 @@ kbd_log = custom_target(test_kbd + '.kmx'.underscorify(),
   command: kmc_cmd + ['build', '--debug', '--no-compiler-version', '@INPUT@', '--out-file', kbd_obj]
 )
   test('imx_list', imx_e,  depends: kbd_log, args: [kbd_obj] )
+
+external_e = executable('ext_event', ['kmx_external_event.cpp', '../emscripten_filesystem.cpp'],
+                cpp_args: defns + warns,
+                include_directories: [inc, libsrc],
+                link_args: links + tests_flags,
+                objects: lib.extract_all_objects(recursive: false))
+
+test_kbd = 'k_033___caps_always_off'
+
+
+kbd_src = common_test_keyboards_baseline + '/' + test_kbd + '.kmn'
+kbd_obj = join_paths(meson.current_build_dir(), test_kbd) + '.kmx'
+kbd_log = custom_target(test_kbd + '.kmx'.underscorify(),
+  output: test_kbd + '.log',
+  input: kbd_src,
+  command: kmc_cmd + ['build', '--debug', '--no-compiler-version', '@INPUT@', '--out-file', kbd_obj]
+)
+  test('ext_event', external_e,  depends: kbd_log, args: [kbd_obj] )

windows/src/engine/keyman32/kmprocessactions.cpp

@@ -87,7 +87,7 @@ static BOOL processInvalidateContext(
 }
 
 static BOOL
-processCapsLock(const km_kbp_action_item* actionItem, BOOL isUp, BOOL Updateable) {
+processCapsLock(const km_kbp_action_item* actionItem, BOOL isUp, BOOL Updateable, BOOL externalEvent) {
 
   // We only want to process the Caps Lock key event once --
   // in the first pass (!Updateable).
@@ -114,7 +114,8 @@ processCapsLock(const km_kbp_action_item* actionItem, BOOL isUp, BOOL Updateable
   }
   else {
     // This case would occur for the keyboard system store setting `store(&ShiftFreesCaps) '1'`
-    if (!isUp && IsCapsLockOn()) {
+    // OR selecting a keyboard with CAPs always off rule
+    if ((!isUp && IsCapsLockOn()) || (externalEvent && IsCapsLockOn())) {
       SendDebugMessageFormat(0, sdmGlobal, 0, "processCapsLock: TURN CAPS OFF: FIsUp=%d CapsState=%d", isUp, IsCapsLockOn());
       keybd_event(VK_CAPITAL, SCAN_FLAG_KEYMAN_KEY_EVENT, 0, 0);
       keybd_event(VK_CAPITAL, SCAN_FLAG_KEYMAN_KEY_EVENT, KEYEVENTF_KEYUP, 0);
@@ -160,7 +161,7 @@ BOOL ProcessActions(BOOL* emitKeyStroke)
       continueProcessingActions = processInvalidateContext(_td->app, _td->lpActiveKeyboard->lpCoreKeyboardState);
       break;
     case KM_KBP_IT_CAPSLOCK:
-      continueProcessingActions = processCapsLock(act, !_td->state.isDown, _td->TIPFUpdateable);
+      continueProcessingActions = processCapsLock(act, !_td->state.isDown, _td->TIPFUpdateable, FALSE);
       break;
     case KM_KBP_IT_END:
       // fallthrough
@@ -198,7 +199,33 @@ ProcessActionsNonUpdatableParse(BOOL* emitKeyStroke) {
       _td->CoreProcessEventRun = FALSE; // If we emit the key stroke on this parse we don't need the second parse
       break;
     case KM_KBP_IT_CAPSLOCK:
-      continueProcessingActions = processCapsLock(act, !_td->state.isDown, _td->TIPFUpdateable);
+      continueProcessingActions = processCapsLock(act, !_td->state.isDown, _td->TIPFUpdateable, FALSE);
+      break;
+    case KM_KBP_IT_INVALIDATE_CONTEXT:
+      continueProcessingActions = processInvalidateContext(_td->app, _td->lpActiveKeyboard->lpCoreKeyboardState);
+      break;
+    }
+    if (!continueProcessingActions) {
+      return FALSE;
+    }
+  }
+  return TRUE;
+}
+
+BOOL
+ProcessActionsExternalEvent() {
+  PKEYMAN64THREADDATA _td = ThreadGlobals();
+  if (!_td) {
+    return FALSE;
+  }
+  // Currently only a subset of actions are handled.
+  // Other actions will be added when needed.
+  BOOL continueProcessingActions = TRUE;
+  for (auto act = km_kbp_state_action_items(_td->lpActiveKeyboard->lpCoreKeyboardState, nullptr); act->type != KM_KBP_IT_END;
+       act++) {
+    switch (act->type) {
+    case KM_KBP_IT_CAPSLOCK:
+      continueProcessingActions = processCapsLock(act, !_td->state.isDown, FALSE, TRUE);
       break;
     case KM_KBP_IT_INVALIDATE_CONTEXT:
       continueProcessingActions = processInvalidateContext(_td->app, _td->lpActiveKeyboard->lpCoreKeyboardState);

windows/src/engine/keyman32/kmprocessactions.h

@@ -26,4 +26,15 @@ BOOL ProcessActions(BOOL* emitKeyStroke);
  */
 BOOL ProcessActionsNonUpdatableParse(BOOL* emitKeyStroke);
 
+/**
+ * This function processes the actions queued in the core processor in
+ * the external event case. That is actions not caused by a keystroke but from selecting a
+ * different keyboard for example.
+ * Currently only KM_KBP_IT_CAPSLOCK and KM_KBP_IT_INVALIDATE_CONTEXT are processed.
+ *
+ * @return BOOL  TRUE if actions were successfully processed
+ */
+BOOL ProcessActionsExternalEvent();
+
+
 #endif

windows/src/engine/keyman32/selectkeyboard.cpp

@@ -61,8 +61,8 @@ BOOL SelectKeyboard(DWORD KeymanID)
   PKEYMAN64THREADDATA _td = ThreadGlobals();
   if (!_td) return FALSE;
 
-  SendDebugMessageFormat(hwnd, sdmGlobal, 0, "ENTER SelectKeyboardCore-------------------------------------------");
-  SendDebugMessageFormat(hwnd, sdmGlobal, 0, "ENTER SelectKeyboardCore: Current:(HKL=%x KeymanID=%x %s) New:(ID=%x)", //lpActiveKeyboard=%s ActiveKeymanID: %x sk: %x KeymanID: %d",
+  SendDebugMessageFormat(hwnd, sdmGlobal, 0, "ENTER SelectKeyboard-------------------------------------------");
+  SendDebugMessageFormat(hwnd, sdmGlobal, 0, "ENTER SelectKeyboard: Current:(HKL=%x KeymanID=%x %s) New:(ID=%x)", //lpActiveKeyboard=%s ActiveKeymanID: %x sk: %x KeymanID: %d",
     GetKeyboardLayout(0),
     _td->ActiveKeymanID,
     _td->lpActiveKeyboard == NULL ? "NULL" : _td->lpActiveKeyboard->Name,
@@ -86,42 +86,45 @@ BOOL SelectKeyboard(DWORD KeymanID)
       {
         if (!_td->lpKeyboards[i].lpCoreKeyboard && !LoadlpKeyboard(i))
         {
-          SendDebugMessageFormat(hwnd, sdmGlobal, 0, "SelectKeyboardCore: Unable to load");
+          SendDebugMessageFormat(hwnd, sdmGlobal, 0, "SelectKeyboard: Unable to load");
           return TRUE;
         }
 
         _td->lpActiveKeyboard = &_td->lpKeyboards[i];
         _td->ActiveKeymanID = _td->lpActiveKeyboard->KeymanID;
 
-        SendDebugMessageFormat(hwnd, sdmGlobal, 0, "SelectKeyboardCore: NewKeymanID: %x", _td->ActiveKeymanID);
+        SendDebugMessageFormat(hwnd, sdmGlobal, 0, "SelectKeyboard: NewKeymanID: %x", _td->ActiveKeymanID);
 
         if (_td->app) _td->app->ResetContext();
-
-        // TODO: #5822 tell the core with km_kbp_event so it can reset the capslock state
-
         SelectApplicationIntegration();   // I4287
         if (_td->app && !_td->app->IsWindowHandled(hwnd)) _td->app->HandleWindow(hwnd);
         _td->state.windowunicode = !_td->app || _td->app->IsUnicode();
 
         ActivateDLLs(_td->lpActiveKeyboard);
 
+        if (KM_KBP_STATUS_OK !=
+            km_kbp_event(_td->lpActiveKeyboard->lpCoreKeyboardState, KM_KBP_EVENT_KEYBOARD_ACTIVATED, nullptr)) {
+          SendDebugMessageFormat(0, sdmGlobal, 0, "km_kbp_event Failed Result: %d ", FALSE);
+        } else {
+          ProcessActionsExternalEvent();
+        }
         return TRUE;
       }
       if (IsFocusedThread())
       {
-        SendDebugMessageFormat(hwnd, sdmGlobal, 0, "SelectKeyboardCore: Keyboard Not Found");
+        SendDebugMessageFormat(hwnd, sdmGlobal, 0, "SelectKeyboard: Keyboard Not Found");
       }
     }
   }
 
     __finally
     {
-      SendDebugMessageFormat(hwnd, sdmGlobal, 0, "EXIT SelectKeyboardCore: Current:(HKL=%x KeymanID=%x %s) New:(ID=%x)", //lpActiveKeyboard=%s ActiveKeymanID: %x sk: %x KeymanID: %d",
+      SendDebugMessageFormat(hwnd, sdmGlobal, 0, "EXIT SelectKeyboard: Current:(HKL=%x KeymanID=%x %s) New:(ID=%x)", //lpActiveKeyboard=%s ActiveKeymanID: %x sk: %x KeymanID: %d",
         GetKeyboardLayout(0),
         _td->ActiveKeymanID,
         _td->lpActiveKeyboard == NULL ? "NULL" : _td->lpActiveKeyboard->Name,
         KeymanID);
-      SendDebugMessageFormat(hwnd, sdmGlobal, 0, "EXIT SelectKeyboardCore-------------------------------------------");
+      SendDebugMessageFormat(hwnd, sdmGlobal, 0, "EXIT SelectKeyboard-------------------------------------------");
     }
     return TRUE;
 }