AHK Alternative key on long press

Question

I have a keyboard with these arrow (less/greater than) characters as alternate keys on Y and X.

Let's focus on the key X for this example.

By default the alternate character > is triggered with AltGr + X of course.

But I would like to trigger it by simply long pressing X, to speed things up and having no need for a second hand or finger.

So far I have the following, which I got from other posts:

$x::
    KeyWait, x, T0.2

    if (ErrorLevel)
        Send > ;long

    else {
        KeyWait, x, D T0.2

        if (ErrorLevel)
            Send x ;single
    }

    KeyWait, x
return

This basically works, but has one major flaw: A normal single key press takes now too much time to write the normal X character.

For instance, if you write fast a word like "exchange", you end up with something like "echxange", because the X takes too much time to be sent.

So how can this script be modified to fix that problem? My idea would be to send a normal X and to abord this whole script, once a {X Up} is registered. So after {X Up} he will no longer wait.

Or any other idea?

Thanks.

Answer 1

Here is a solution that calculates the duration of the keypress, the downside is you always have to release the key in order to get the required input. This means you can't hold down x to type xxxxxxxx.

$x::
    startTime := A_TickCount ;record the time the key was pressed
    KeyWait, x, U ;wait for the key to be released
    keypressDuration := A_TickCount-startTime ;calculate the duration the key was pressed down
    if (keypressDuration > 200) ;if the key was pressed down for more than 200ms send >
    {
        Send > 
    }
    else ;if the key was pressed down for less than 200ms send x
    {
         Send x 
    }

return

Answer 2

I took the answer provided by Yane, and improved it slightly.

The difference: Yane's answer will send the key when you release the key. My example will send the long-hold key after a set amount of time. This way you know when you've hold the key long enough.

$x::
    timeHasElapsed := 0
    SetTimer, SendAngleBracketRight, -200 ;if the key was pressed down for more than 200ms send > (negative value to make the timer run only once)
    KeyWait, x, U ;wait for the key to be released
    if (timeHasElapsed == 0) ;if the timer didn't go off disable the timer and send x
    {
        SetTimer, SendAngleBracketRight, OFF
        SendInput, x
    }
return

SendAngleBracketRight:
    SendInput, >
    timeHasElapsed := 1
return

Answer 3

The code below seems to work well for me, but note that there is the possibility (with some unfortunate timing) that it could erroneously replace an "x" if you're typing many x's in a row, resulting in something like this, "xxxx>xxx". I increased the sleep time to 350ms to make that scenario less likely, but it's something to be aware of and should be changed to suit whatever you need.

~x::
Sleep , 350
BlockInput , On
Send , % GetKeyState( "x" , P ) ? "{backspace}>" : ""
KeyWait , x , U
BlockInput , Off
Return

Note that since it sends a backspace, you may get unintended results if using it in a non-typing environment, such as in a browser where it may go back to the previous page if you can't type text. This can be mitigated if needed by filtering out those specific scenarios with WinActive or something similar.

Answer 4

Quite simple, but it'll need 2 separate scripts.
First run this script to block the repetition (I am almost sure it is what you want).

SendMode Input 

$x::
    send {x}
    keywait, x
    send {x up}
return

Then run this second script, which does the logic :

SendMode Input 

dt := 30            ;  milliseconds time resolution
timeout := 1500 ;  timeout

loop 
{
    sleep %dt%                      ; sleep to reduce CPU usage
    p := getkeystate("x", "P")          ; getkeystate
    if (p = 1) {
        timer += dt
    }
    if (p = 0) {
        timer := 0
    }
    ; tooltip pressed:  %p%  timer: %timer%
    if (timer > timeout) {
        send {backspace}
        send {>}
        timer := 0              ; reset timer
    }
}

It will input x normally, and > after 1.5 second, see timeout variable. The trick is that in the latter case it removes last x so you get only >.