Implementing combos/chords for thumbs + home-row-mods?

[bogorad]

The idea described here is to only activate home-row-mods when a corresponding thumb key is chorded together with them. E.g., to get left meta you need to chord the letter A together with the thumb key. This is easily done via defchords:

(defsrc
  a       s       d       f       del
)

(defchords hr-left 500
  ;; left half
  (1        ) a
  (  2      ) s
  (    3    ) d
  (      4  ) f
  (        5) del
  ;; single hrm
  (1       5) lmet
  (  2     5) lalt
  (    3   5) lctl
  (      4 5) lsft
  ;; dual hrm
  (1 2     5) (multi lmet lalt)
  (1   3   5) (multi lmet lctl)
  (1     4 5) (multi lmet lsft)
  (  2 3   5) (multi lalt lctl)
  (  2   4 5) (multi lalt lsft)
  (    3 4 5) (multi lctl lsft)
  ;; triple hrm
  (1 2 3   5) (multi lmet lalt lctl)
  (1 2   4 5) (multi lmet lalt lsft)
  (1   3 4 5) (multi lmet lctl lsft)
  (  2 3 4 5) (multi lalt ltcl lsft )
  ;; quadruple hrm - HYPER
  (1 2 3 4 5) (multi lmet lalt ltcl lsft )
)

(defalias
  ;; for home-row-chording
  ;; left half
  met-a (chord hr-left 1)
  alt-s (chord hr-left 2)
  ctl-d (chord hr-left 3)
  sft-f (chord hr-left 4)
  del_  (chord hr-left 5)
)

(deflayer U_BASE
  @met-a  @alt-s  @ctl-d  @sft-f @del_
)

However, I cannot achieve the described behavior (at least how I understand it):

One nifty thing about this method is that you 
don’t need to keep holding down all the combo 
keys. You can press all the keys that compose 
the combo to trigger it and then only keep a 
single combo key down to maintain the modifier 
active, thus freeing your other fingers.

When I tap f+del I do get lsft - but only as long as I keep holding f. If I release f, while still holding del, lsft is relreased.

Any thoughts why, and how do I fix it?

[jtroo]

Today's release behaviour of chords is described in the docs. It is complicated, mainly due to backing implementation details.

https://github.com/jtroo/kanata/blob/main/docs/config.adoc#input-chords

There could be code added here to apply the same behaviour to the same simple actions within multi, making sure to only go one level deep:

kanata/keyberon/src/layout.rs

Line 945 in ffd5b82

// The current intent of this block is to ensure that simple actions like

[bogorad]

Yeah, that's beyond my understaning of Rust :) I'll settle for the "layered" solution for now. Thanks for your efforts!

[bogorad]

Wow! That was fast. Thank you so much!

Now with the above config, I chord f + del, then tap a letter, then release some of the chorded keys => lsft state is preserved, regardless of how many originally chorded keys are still depressed. Solves my problem!

I noticed the following inconsistent (IMO) behavior:

• I chord f + del, then release del => lsft state is preserved
• I chord f + del, then release f => lsft state is not preserved

is this by design?

[jtroo]

If you're using the interception variant, I have no clue why that might be - I'm not able to reproduce that result. Could you provide some --debug output?

If you were using non-interception though, I've just added some behaviour changes in the code that works around involving some weird Windows behaviours, specifically involving shift keys (lsft, rsft). Perhaps the latest main might fix it.

Well either way some --debug output would help. And also if the chord behaviour is the same for all keys and not just lsft too.

[bogorad]

Not using intercept. Pulled the latest version, and compiled with cargo build --release --features cmd,win_sendinput_send_scancodes.

(avoiding lsft for now)

1. Here's the debug for chord(d + del) then tap j, then tap k (both chord keys still depressed), then releasing chorded keys:

2024-02-21T11:35:45.4529103+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_DELETE, value: Press }
2024-02-21T11:35:45.4544269+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_DELETE, value: Press }
2024-02-21T11:35:45.4847559+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_D, value: Press }
2024-02-21T11:35:45.4859809+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_D, value: Press }
2024-02-21T11:35:45.8288812+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_J, value: Press }
2024-02-21T11:35:45.8299687+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_J, value: Press }
2024-02-21T11:35:45.8301845+01:00 [DEBUG] (2) kanata::kanata: key press     LCtrl
2024-02-21T11:35:45.8364572+01:00 [DEBUG] (2) kanata::kanata: key press     J
2024-02-21T11:35:45.9167305+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_J, value: Release }
2024-02-21T11:35:45.9180596+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_J, value: Release }
2024-02-21T11:35:45.9181516+01:00 [DEBUG] (2) kanata::kanata: key release   J
2024-02-21T11:35:46.0767081+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_K, value: Press }
2024-02-21T11:35:46.0778014+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_K, value: Press }
2024-02-21T11:35:46.078149+01:00 [DEBUG] (2) kanata::kanata: key press     K
2024-02-21T11:35:46.1247077+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_K, value: Release }
2024-02-21T11:35:46.1269946+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_K, value: Release }
2024-02-21T11:35:46.1271466+01:00 [DEBUG] (2) kanata::kanata: key release   K
2024-02-21T11:35:46.4207227+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_D, value: Release }
2024-02-21T11:35:46.4212859+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_D, value: Release }
2024-02-21T11:35:46.4527238+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_DELETE, value: Release }
2024-02-21T11:35:46.4530401+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_DELETE, value: Release }
2024-02-21T11:35:46.4531432+01:00 [DEBUG] (2) kanata::kanata: key release   LCtrl

2. Here's the debug for chord(d + del) then release del, then tap j. Works as expected:

2024-02-21T11:38:27.5967813+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_DELETE, value: Press }
2024-02-21T11:38:27.5986531+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_DELETE, value: Press }
2024-02-21T11:38:27.6288522+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_D, value: Press }
2024-02-21T11:38:27.6314008+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_D, value: Press }
2024-02-21T11:38:27.9407696+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_DELETE, value: Release }
2024-02-21T11:38:27.9431824+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_DELETE, value: Release }
2024-02-21T11:38:27.9434786+01:00 [DEBUG] (2) kanata::kanata: key press     LCtrl
2024-02-21T11:38:28.220807+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_J, value: Press }
2024-02-21T11:38:28.221808+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_J, value: Press }
2024-02-21T11:38:28.2221217+01:00 [DEBUG] (2) kanata::kanata: key press     J
2024-02-21T11:38:28.2928675+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_J, value: Release }
2024-02-21T11:38:28.2949658+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_J, value: Release }
2024-02-21T11:38:28.2951367+01:00 [DEBUG] (2) kanata::kanata: key release   J
2024-02-21T11:38:28.7247511+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_D, value: Release }
2024-02-21T11:38:28.7254257+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_D, value: Release }
2024-02-21T11:38:28.7257529+01:00 [DEBUG] (2) kanata::kanata: key release   LCtrl

3. Here's the debug for chord(d + del) then release d, then tap j. lctl is released prematurely (IMO):

2024-02-21T11:40:50.564756+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_DELETE, value: Press }
2024-02-21T11:40:50.5654043+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_DELETE, value: Press }
2024-02-21T11:40:50.5888081+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_D, value: Press }
2024-02-21T11:40:50.5921905+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_D, value: Press }
2024-02-21T11:40:50.9728044+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_D, value: Release }
2024-02-21T11:40:50.9743956+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_D, value: Release }
2024-02-21T11:40:50.9745614+01:00 [DEBUG] (2) kanata::kanata: key press     LCtrl
2024-02-21T11:40:50.9809923+01:00 [DEBUG] (2) kanata::kanata: key release   LCtrl
2024-02-21T11:40:50.9816474+01:00 [DEBUG] (2) kanata::kanata: key release   LCtrl
2024-02-21T11:40:51.372703+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_J, value: Press }
2024-02-21T11:40:51.3735437+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_J, value: Press }
2024-02-21T11:40:51.3738777+01:00 [DEBUG] (2) kanata::kanata: key press     J
2024-02-21T11:40:51.4607361+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_J, value: Release }
2024-02-21T11:40:51.4617137+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_J, value: Release }
2024-02-21T11:40:51.4618365+01:00 [DEBUG] (2) kanata::kanata: key release   J
2024-02-21T11:40:51.8207433+01:00 [DEBUG] (1) kanata::kanata::windows::llhook: event loop: KeyEvent { code: KEY_DELETE, value: Release }
2024-02-21T11:40:51.8229026+01:00 [DEBUG] (2) kanata::kanata: process recv ev KeyEvent { code: KEY_DELETE, value: Release }

[jtroo]

I believe the latest main should have fixed this issue. The exact buggy scenario was an early release of the chord (before timeout) while only holding the first pressed key.

[bogorad]

A complete success, thanks!