How to implement "Adaptive Keys"?

[veyxov]

Is your feature request related to a problem? Please describe.
I want to implement Adaptive Keys from Hands Down Layout.
This feature allows a key to produce another key when pressed after a specific sequence of keys within a certain period of time.

Describe the solution you'd like
Something like fork which also has a delay.
fork-delay a b delay (list_of_keys) - produces b if a is pressed after list_of_keys in the delay period

Describe alternatives you've considered
frk (fork left right (right-trigger-keys))
Currently I'm using fork to achieve this, It works great when rolling. However, there is an issue when there is another key in between right and the triggering keys. In such cases, the default key (left) is produced instead of the expected adaptive key (right). For example, when rolling "f" and "m" (adjacent), it correctly produces "fl" as in the word "fly" (I type "fmy.") However, in words like "fall," where "f" and "l" are not adjacent, the adaptive behavior does not occur.

TLDR; I would like a modified version of the "fork" function that takes into account the delay period and produces an adaptive key only when the triggering key is pressed within that period after the specified sequence of keys.

Sorry if this is not clear I tried my best 😁. Also thanks to anyone involved on this project 🙏

[jtroo]

Interesting feature!

Reading through this reddit thread, it seems like it might potentially be replicable by putting (multi <key> (oneshot delay <adaptive layer>) on the predecessor keys, as opposed to having a new fork-delay action on the adaptive key. You could give that a try and see if that works well enough.

For the feature itself, do you know some deeper details of how adaptive keys work? I'm thinking about some implementation details. The first thought I had would be to use a circular buffer to track key actions.

• Do we need to track presses only? Or do key releases matter? This matters for buffer size.
• How many keys for lookback would be reasonable? E.g. 5 keys? 10 keys? This matters for buffer size.
• How long of a lookback time would be reasonable? E.g. 500ms? 1s? This matters for kanata time-to-idle to save on system resources.

[veyxov]

Tried solution

The "one-shot layer" solution still has the problem. When you press the <key>, <another key> then <adaptive key> it doesn't produce <adaptive key>, because one-shot is already utilized on <another key>.
For example famm should produce fall (m - default, l - adaptive after f)

(f) (multi f (one-shot 1000 (layer-toggle adaptive)))
Also when I use this solution, when I press f and nothing after it, it produces fffffffffff (repeats f for a second)

Possible solution

I think something like toggle-layer-delay which toggles the adaptive layer for a given delay, could be a possible solution.

If we use a solution which uses "keys for look back", I think 3 is enough. Because if there are more than 2-3 keys between the <key> and <adaptive key> it has no benefit to roll like this (using adaptive keys). You can reposition your fingers on the home row in between.

Thanks for the response.

[jtroo]

You could actually try out your possible solution today! Though it is definitely convoluted and hard to discover how to do it.

Here's a working sample that makes 0 adaptive where if it is pressed quickly enough after 9, it becomes an exclamation mark (with the US locale).

(defsrc 9 0)
(deflayer base
  (multi
    9
    (on-press-fakekey fk-adaptive1 press)
    (macro 200 (on-press-fakekey fk-adaptive1 release)))
  0
)
(deflayer adaptive1 9 S-1)
(deffakekeys
  fk-adaptive1 (layer-while-held adaptive1)
)

[veyxov]

I tested this and it works. This is exactly what I needed.

If I understood right, it presses a fake key which toggles a layer, then releases after the delay.

Thank you very much 🙏, this will drastically improve awkward "row jumps" on my layout.

[DarkKronicle]

I found another solution that allows to change the front character without needing to backspace.

(defcfg
	sequence-timeout 150
	sequence-input-mode hidden-delay-type
)

(defsrc k u)
(deflayer base (macro sldr k) u)
(defseq 
	ku-adaptive (k u)
)
(deffakekeys 
	ku-adaptive (macro q (on-press-fakekey sft release) u)
)	

The fakekey sft is just a lsft stand in so I can unshift in these macros.

This creates a sequence for k u and types q u if it is executed. The k key starts a sequence and starts it with k when pressed, so if u is pressed quickly enough it will activate. If it isn't or any other character is pressed, it will just output those characters.