Substitua [com {e] por} usando o AutoHotkey

Question

Descobri que, na codificação, raramente uso as chaves quadradas [] , mas uso as chaves {} com frequência. Na maioria dos teclados, estes são introduzidos usando Shift + [ ou Shift + ] .

Agora tentei usar o AutoHotkey para remapear essas chaves usando:

[::{{}

Adicionar {} é basicamente o modo raw, mas não funcionou. Em seguida eu tentei

{[}::{{}

mas isso também não funcionou.

Alguma ajuda?

    

Answer 1

O uso de chaves para interpretação de chave bruta é apenas para os comandos Enviar . Então, para mapear [ para { e ] para } você pode usar:

[::Send, {{}
]::Send, {}}

Nota: Remapear uma chave com seu equivalente a Shift é problemático, já que a maioria, se não todos os teclados, envia o mesmo scancode toda vez, a única diferença é a introdução da tecla Shift (que possui seu próprio scancode).

Por exemplo, pressionar [ no teclado envia o scancode 01A e gera [ . Pressionando LShift + [ envia os scancodes 02A e 01A , gerando um { .

Atualização:

Eu tenho sucesso superado o problema do scancode com alguma lógica inteligente! Usando o seguinte formato, você deve poder mudar qualquer tecla com seu par Shift . A repetição de chaves também deve funcionar.

*$[::
    if (GetKeyState("Shift"))
        Send, {[}
    else
        Send, {{}  
    return

*$]::
    if (GetKeyState("Shift"))
        Send, {]}
    else
        Send, {}}
    return

Expandindo essa ideia, o @Bob escreveu uma versão mais robusta do script:

*$[::
    if (GetKeyState("Shift"))
        SendInput, {[ Down}
    else
        SendInput, {{ Down}
    return

*$]::
    if (GetKeyState("Shift"))
        SendInput, {] Down}
    else
        SendInput, {} Down}
    return

*$[ Up::
    if (GetKeyState("Shift"))
        SendInput, {[ Up}
    else
        SendInput, {{ Up}
    return

*$] Up::
    if (GetKeyState("Shift"))
        SendInput, {] Up}
    else
        SendInput, {} Up}
    return

    

Answer 2

Se eu tivesse o problema sem ver a resposta acima, adicionaria apenas alguns hotstrings conforme o exemplo abaixo.

:*?:[::
    SendInput, {Shift Down}'[{Shift up}
    return

:*?:]::
    SendInput, {Shift Down}']{Shift Up}
    return

:*?:{::
    SendInput, '[
    return

:*?:}::
    SendInput, ']
    return

    

Answer 3

A primeira resposta é má solução, se você usar qualquer atalho com chaves chaves, porque quebrou-los. Versão compatível com atalhos aqui:

$[::Send {{ Down}
$[ Up::Send {{ Up}

+$[::Send {[ Down}
+$[ Up::Send {[ Up}

$]::Send {} Down}
$] Up::Send {} Up}

+$]::Send {] Down}
+$] Up::Send {] Up}

Na verdade, nas linguagens de programação, os colchetes são usados duas vezes mais que os cacheados, por isso ofereço esta versão:

#NoEnv
#NoTrayIcon
#SingleInstance force
#MaxHotkeysPerInterval 200

; Swap [] with ()
  [::Send {( Down}
  [ Up::Send {( Up}

  ]::Send {) Down}
  ] Up::Send {) Up}

  +9::Send {[ Down}
  +9 Up::Send {[ Up}

  +0::Send {] Down}
  +0 Up::Send {] Up}

; Swap " with '
   $'::Send "
  +$'::Send '