@tobq/boardclip 2.1.113 → 2.1.114

package/lib/windows-hook-worker.js

@@ -22,12 +22,13 @@
 
 const { parentPort, workerData } = require('worker_threads');
 const koffi = require('koffi');
+// Which presses the hook claims, and the shared-state layout main agrees on.
+const { STATE, VK, createHookClaimer, modsFrom } = require('./windows-hook-policy');
 
-// --- Shared state (worker reads, main writes) ---
-// Layout: [popupVisible, slot1, slot2, ..., slot9, reserved, ...]
+// --- Shared state (worker reads, main writes; layout = STATE) ---
 const sharedState = workerData && workerData.sharedStateBuffer
   ? new Uint8Array(workerData.sharedStateBuffer)
-  : new Uint8Array(16);
+  : new Uint8Array(STATE.SIZE);
 
 // --- Win32 constants ---
 const WH_KEYBOARD_LL = 13;
@@ -35,12 +36,6 @@ const WM_KEYDOWN = 0x0100;
 const WM_KEYUP = 0x0101;
 const WM_SYSKEYDOWN = 0x0104;
 const WM_SYSKEYUP = 0x0105;
-const VK_LWIN = 0x5B;
-const VK_RWIN = 0x5C;
-const VK_CONTROL = 0x11;
-const VK_V = 0x56;
-const VK_NUMPAD1 = 0x61;
-const VK_NUMPAD9 = 0x69;
 const KEYEVENTF_KEYUP = 0x0002;
 
 // --- koffi types ---
@@ -107,29 +102,21 @@ const keybd_event = user32.func(
   'void __stdcall keybd_event(uint8 bVk, uint8 bScan, uint32 dwFlags, uintptr_t dwExtraInfo)'
 );
 
-let winVChordActive = false;
-let winVChordConsumed = false;
-
-// Auto-repeat suppression for numpad quick-paste. When a key is physically
-// held, Windows emits repeated WM_KEYDOWN with no intervening WM_KEYUP. Without
-// tracking this, one held (or lag-stretched) press fires the paste many times.
-// numpadHeld = keys currently down; numpadIntercepted = keys whose keydown we
-// swallowed, so we also swallow their paired keyup.
-const numpadHeld = new Set();
-const numpadIntercepted = new Set();
-
-function isWinHeld() {
-  return (GetAsyncKeyState(VK_LWIN) & 0x8000) !== 0 ||
-         (GetAsyncKeyState(VK_RWIN) & 0x8000) !== 0;
-}
+const isKeyDown = (vk) => (GetAsyncKeyState(vk) & 0x8000) !== 0;
+// Win+V, Win+N and Numpad1-9: each claimed only with exactly its modifiers,
+// one verdict per press (lib/windows-hook-policy.js).
+const claimer = createHookClaimer(sharedState, {
+  isKeyDown,
+  readMods: (flags) => modsFrom(isKeyDown, flags),
+});
 
 function markWinKeyUsed() {
-  // If V is swallowed, Windows can still react to the original Win release.
+  // If a key is swallowed while Win is held, Windows can still react to the original Win release.
   // A tiny Ctrl tap marks the Win key as used while allowing the real Win-up
   // through, so we avoid both Clipboard History and stuck modifier state.
   try {
-    keybd_event(VK_CONTROL, 0, 0, 0);
-    keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
+    keybd_event(VK.CONTROL, 0, 0, 0);
+    keybd_event(VK.CONTROL, 0, KEYEVENTF_KEYUP, 0);
   } catch {}
 }
 
@@ -149,56 +136,10 @@ const hookCallback = koffi.register((nCode, wParam, lParamExt) => {
         return CallNextHookEx(null, nCode, wParam, lParamExt);
       }
 
-      const isWinKey = vk === VK_LWIN || vk === VK_RWIN;
-
-      // Win+V → show popup. Checked before Windows Clipboard History can.
-      if (isWinKey && keyUp && winVChordConsumed) {
-        markWinKeyUsed();
-        winVChordConsumed = false;
-      }
-
-      if (vk === VK_V) {
-        if (keyDown) {
-          if (isWinHeld() || winVChordActive) {
-            if (!winVChordActive) {
-              winVChordActive = true;
-              winVChordConsumed = true;
-              parentPort.postMessage({ type: 'show' });
-            }
-            return 1;
-          }
-        } else if (winVChordActive) {
-          winVChordActive = false;
-          return 1;
-        }
-      }
-
-      // Plain Numpad1-9 -> quick-paste when a slot is assigned and the popup
-      // is closed. When the popup is visible, pass through so the search box
-      // can accept normal numpad typing. Auto-repeat (held key) fires the paste
-      // exactly once — repeats are swallowed but not re-dispatched.
-      if (vk >= VK_NUMPAD1 && vk <= VK_NUMPAD9) {
-        const slot = vk - VK_NUMPAD1 + 1;
-        if (keyDown) {
-          const popupVisible = sharedState[0] === 1;
-          const slotAssigned = sharedState[slot] === 1;
-          if (!popupVisible && slotAssigned) {
-            if (numpadHeld.has(vk)) return 1; // auto-repeat: swallow, don't re-fire
-            numpadHeld.add(vk);
-            numpadIntercepted.add(vk);
-            parentPort.postMessage({ type: 'numpad', slot });
-            return 1;
-          }
-          // Not intercepting this press (popup open or slot unassigned): let it
-          // type normally and don't track it.
-        } else if (keyUp) {
-          numpadHeld.delete(vk);
-          if (numpadIntercepted.has(vk)) {
-            numpadIntercepted.delete(vk);
-            return 1; // swallow the keyup paired with a swallowed keydown
-          }
-        }
-      }
+      const verdict = claimer.event(vk, keyDown, kb.flags);
+      if (verdict.markWinUsed) markWinKeyUsed();
+      if (verdict.post) parentPort.postMessage(verdict.post);
+      if (verdict.swallow) return 1;
     }
   } catch (err) {
     // Never let JS exceptions escape the hook — Windows will stall the

package/lib/windows-hook.js

@@ -4,34 +4,37 @@
 // On Windows we can't use Electron's `globalShortcut.register('Super+V')`
 // because Windows Clipboard History owns Win+V at the RegisterHotKey layer
 // and silently rejects our registration. This module installs a
-// WH_KEYBOARD_LL hook on a dedicated worker thread which intercepts Win+V
-// and numpad keys *before* Windows Clipboard History sees them.
+// WH_KEYBOARD_LL hook on a dedicated worker thread which intercepts Win+V,
+// Win+N (new note, while that is the shortcut) and numpad keys *before*
+// Windows Clipboard History / the notification panel see them.
 //
 // See lib/windows-hook-worker.js for the hook implementation and the
 // rationale for running it in a worker.
 //
-// Shared state (popup visible + which numpad slots are assigned) is passed
-// via a SharedArrayBuffer because the worker is synchronously blocked in
+// Shared state (popup visible, which numpad slots are assigned, Win+N on;
+// layout = STATE in lib/windows-hook-policy.js) is passed via a
+// SharedArrayBuffer because the worker is synchronously blocked in
 // GetMessageW and can't process postMessage events from its JS event loop.
 
 const { Worker } = require('worker_threads');
 const path = require('path');
+const { STATE } = require('./windows-hook-policy');
 
 let currentHook = null;
 
-function install({ onShowPopup, onNumpadPaste }) {
+function install({ onShowPopup, onNumpadPaste, onNewNote }) {
   if (process.platform !== 'win32') {
     // Non-Windows platforms use Electron's globalShortcut; no-op API here.
     return {
       setPopupVisible() {},
       setSlotAssignments() {},
+      setNewNoteHotkey() {},
       uninstall() {},
     };
   }
   if (currentHook) return currentHook;
 
-  // Layout: [popupVisible, slot1, slot2, ..., slot9, reserved...]
-  const sharedStateBuffer = new SharedArrayBuffer(16);
+  const sharedStateBuffer = new SharedArrayBuffer(STATE.SIZE);
   const sharedState = new Uint8Array(sharedStateBuffer);
 
   const worker = new Worker(path.join(__dirname, 'windows-hook-worker.js'), {
@@ -46,6 +49,9 @@ function install({ onShowPopup, onNumpadPaste }) {
       case 'numpad':
         try { onNumpadPaste(msg.slot); } catch (e) { console.error('[windows-hook] onNumpadPaste:', e); }
         break;
+      case 'new-note':
+        try { if (onNewNote) onNewNote(); } catch (e) { console.error('[windows-hook] onNewNote:', e); }
+        break;
       case 'ready':
         // Hook installed successfully — no action needed.
         break;
@@ -67,14 +73,19 @@ function install({ onShowPopup, onNumpadPaste }) {
 
   currentHook = {
     setPopupVisible(visible) {
-      sharedState[0] = visible ? 1 : 0;
+      sharedState[STATE.POPUP_VISIBLE] = visible ? 1 : 0;
     },
     setSlotAssignments(assignedSet) {
       // assignedSet: Set<number> of assigned numpad slot numbers (1-9)
       for (let n = 1; n <= 9; n++) {
-        sharedState[n] = assignedSet && assignedSet.has(n) ? 1 : 0;
+        sharedState[STATE.SLOT_FIRST + n - 1] = assignedSet && assignedSet.has(n) ? 1 : 0;
       }
     },
+    // Win+N opens a new note only while it is the new-note shortcut (not
+    // while it is off or another chord is recorded, nor during a recording).
+    setNewNoteHotkey(enabled) {
+      sharedState[STATE.NEW_NOTE_HOTKEY] = enabled ? 1 : 0;
+    },
     uninstall() {
       if (!currentHook) return;
       currentHook = null;