Mapeamento de Caps Lock para escape e controle no Windows 7

Quero poder mapear a tecla Caps Lock para Escape se não for pressionada com nenhuma outra tecla e Control, se estiver. Como posso fazer isso no Windows 7?

Você pode remapear para Escape com SharpKeys

No entanto, não conheço uma maneira realista de executar o remapeamento condicional, além de escrever um driver de teclado.

Isso não é exatamente o que você deseja, mas é muito próximo se você pode viver com algumas falhas. Aqui está um script AutoHotKey :

$CapsLock::LControl
$CapsLock Up::Send {Escape}
return

Ele remapeia Caps Lock para Ctrl e envia Escape quando você solta a tecla. Levei um tempo para me acostumar com a tecla Escape sendo pressionada toda vez que soltei a tecla Caps Lock. No entanto, é praticamente inútil nas áreas de texto do site, porque pressionar Escape perde o foco na área de texto.

Estou procurando uma solução para isso. Eu poderia ir tão longe quanto escrever algum tipo de driver / teclado em C, se necessário, haha.

Aborrecimentos específicos do Vim: Torna os digrafos impossíveis de digitar usando a combinação Ctrl-K e geralmente é irritante antes de você se acostumar. Funciona bem para mim, porque eu faria qualquer coisa para evitar as teclas Esc e Ctrl, tanto quanto possível.

Isso pode ter aparecido na página vim wikia mencionada anteriormente , após a solução de Rich acima.

; Author: fwompner gmail com
#InstallKeybdHook
SetCapsLockState, alwaysoff
Capslock::
Send {LControl Down}
KeyWait, CapsLock
Send {LControl Up}
if ( A_PriorKey = "CapsLock" )
{
    Send {Esc}
}
return

Este não é o meu trabalho, mas comecei a usá-lo e funciona exatamente como descrito, sem ressalvas reais e, porque não tenta mapear nenhuma exceção (porque são desnecessárias), ele se comporta muito bem no Chrome (eu realmente queria para o Vimium).

Eu uso o seguinte script AutoHotkey para isso, adaptado de um que encontrei no Wiki de dicas do Vim . A implementação é um pouco invasiva, mas "funciona para mim". (E, ao contrário das outras respostas desta página a partir de 19/09/2016, ele resolve completamente o problema sem nenhuma advertência de que eu saiba.)

O codificador original observou:

O script também tenta detectar e evitar "falsos positivos" onde você pressiona Control e outra tecla e libera os dois com muita rapidez, ou seja, antes do período de tempo limite.

Certifique-se de ajustar o valor de 250ms, dependendo de quão bom ou ruim é o seu teclado, e do seu próprio tempo de reação. Provavelmente, isso é algo para ajustar experimentalmente ao seu gosto.

CapsLockCtrlEscape.ahk gist :

g_LastCtrlKeyDownTime := 0
g_AbortSendEsc := false
g_ControlRepeatDetected := false

*CapsLock::
    if (g_ControlRepeatDetected)
    {
        return
    }

    send,{Ctrl down}
    g_LastCtrlKeyDownTime := A_TickCount
    g_AbortSendEsc := false
    g_ControlRepeatDetected := true

    return

*CapsLock Up::
    send,{Ctrl up}
    g_ControlRepeatDetected := false
    if (g_AbortSendEsc)
    {
        return
    }
    current_time := A_TickCount
    time_elapsed := current_time - g_LastCtrlKeyDownTime
    if (time_elapsed <= 250)
    {
        SendInput {Esc}
    }
    return

~*^a::
~*^b::
~*^c::
~*^d::
~*^e::
~*^f::
~*^g::
~*^h::
~*^i::
~*^j::
~*^k::
~*^l::
~*^m::
~*^n::
~*^o::
~*^p::
~*^q::
~*^r::
~*^s::
~*^t::
~*^u::
~*^v::
~*^w::
~*^x::
~*^y::
~*^z::
~*^1::
~*^2::
~*^3::
~*^4::
~*^5::
~*^6::
~*^7::
~*^8::
~*^9::
~*^0::
~*^Space::
~*^Backspace::
~*^Delete::
~*^Insert::
~*^Home::
~*^End::
~*^PgUp::
~*^PgDn::
~*^Tab::
~*^Return::
~*^,::
~*^.::
~*^/::
~*^;::
~*^'::
~*^[::
~*^]::
~*^\::
~*^-::
~*^=::
~*^`::
~*^F1::
~*^F2::
~*^F3::
~*^F4::
~*^F5::
~*^F6::
~*^F7::
~*^F8::
~*^F9::
~*^F10::
~*^F11::
~*^F12::
    g_AbortSendEsc := true
    return

Aqui está uma entrada do registro que mapeia o caps lock para escapar no Windows 7.

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout]
"Scancode Map"=hex:00,00,00,00,00,00,00,00,03,00,00,00,3a,00,46,00,01,00,3a,00,00,00,00,00

Salve o acima em um arquivo com uma extensão .reg (como mapCapLocks.reg) e importe / execute-o em sua máquina.

Na verdade, acho que construí a solução perfeita aqui:

• https://github.com/oblitum/Interception/blob/master/samples/caps2esc/caps2esc.cpp

Como usuário do Vim, isso é essencial para mim, e eu o uso com êxito no Windows há muito tempo. Acabei de criar uma entrada no HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Runregedit para apontar para o executável e simplesmente funciona.

Para compilar e instalar dependências, consulte o arquivo README do repositório e o site principal em busca de Interceptação.

Eu também criei uma versão Linux do mesmo aqui:

• https://github.com/oblitum/caps2esc

Eu estava procurando algo parecido com isso, mas infelizmente os scripts AHK das respostas aqui não funcionaram bem para mim.

No entanto, encontrei uma solução que resolveu isso para mim no wiki do vim .

• Primeiro, baixe o aplicativo a seguir chamado remapeamento de chave dupla .
• Extraia o zip em um local de sua escolha (guardo utilitários como esses em C:\Users\%username%\util\)
• Abra o seguinte diretório: C:\Users\%username%\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\e arraste o arquivo dual-key-remap.exe para lá, mantendo pressionada a tecla ALT para criar um atalho. (Ou clique com o botão direito do mouse e selecione 'criar atalho' e mova o atalho para o diretório de inicialização).
• Entrar e sair. Alguns segundos após o login, as chaves serão recuperadas.

O programa remapkey.exe incluído nas Ferramentas do Windows Server 2003 Resource Kit mencionadas neste artigo funciona bem no Windows 7.

Não tenho reputação suficiente para comentar a resposta que funcionou para mim. Eu ainda voto isso no entanto.

a resposta de pepper-chico funcionou para mim.

A tecla Caps Lock se comporta como tecla Escape se pressionada sozinha. E se comporta como a tecla Ctrl se combinada com outras. Eu também tenho o mesmo caso de uso para isso. Vim.

As instruções no link que ele forneceu são simples o suficiente para seguir.

Se você não se importa em compilar código-fonte curto, use o código abaixo. Você precisa compilá-lo como aplicativo de console do Windows. Por exemplo, no prompt de comando do Visual C ++, você pode compilá-lo com

cl /D_WIN32_WINNT=0x0401 remap_capslock.cpp /EHsc /link user32.lib

O remapeamento de chave funciona enquanto o aplicativo está em execução. Não há necessidade de reinicialização, logoff / entrada, etc. Se você precisar remapear para trabalhar com aplicativos executados com direitos de administrador, também será necessário executar o aplicativo remapeador como administrador. Já o usam há alguns dias (no Windows 10), até agora tudo bem.

// The app allows to remap CapsLock key to Esc (if pressed separately) or to Ctrl (if pressed with other keys).
// This may be useful for Vim.
// To compile from Visual C++ command prompt: 
//    cl /D_WIN32_WINNT=0x0401 remap_capslock.cpp /EHsc /link user32.lib
// Original source (which supported only Caps-Ctrl remapping): /superuser//a/1490007/22750

#include <windows.h>
#include <iostream>
#include <set>

HHOOK hook;
std::set<WORD> keys_down;
bool caps_down = false;
bool caps_was_down_with_another_key = false;

LRESULT CALLBACK keyboardHook(int nCode, WPARAM wParam, LPARAM lParam) {
    KBDLLHOOKSTRUCT *p = (KBDLLHOOKSTRUCT *) lParam;
    INPUT input[3] = {{ INPUT_KEYBOARD }, { INPUT_KEYBOARD }, { INPUT_KEYBOARD }};

    if ((p->flags & LLKHF_INJECTED) == 0) {
        std::cout << "nCode=" << nCode << "\twParam=" << wParam << "\tvkCode=" << p->vkCode << "\tscanCode=" << p->scanCode << std::endl;
        bool keyup = wParam == WM_KEYUP || wParam == WM_SYSKEYUP;
        if (p->vkCode == VK_CAPITAL) {
            if (keyup) {
                if (caps_was_down_with_another_key) {
                    std::cout << "Remapping CAPSLOCK UP to CTRL UP" << std::endl;
                    input[0].ki.dwFlags = KEYEVENTF_KEYUP;
                    input[0].ki.wVk = VK_LCONTROL;
                    SendInput(1, input, sizeof (INPUT));
                } else {
                    std::cout << "Remapping CAPSLOCK UP to ESCAPE DOWN&UP" << std::endl;
                    input[0].ki.dwFlags = KEYEVENTF_KEYUP;
                    input[0].ki.wVk = VK_LCONTROL;
                    input[1].ki.dwFlags = 0;
                    input[1].ki.wVk = VK_ESCAPE;
                    input[2].ki.dwFlags = KEYEVENTF_KEYUP;
                    input[2].ki.wVk = VK_ESCAPE;
                    SendInput(3, input, sizeof (INPUT));
                }
                caps_down = false;
                caps_was_down_with_another_key = false;
            } else {
                std::cout << "Remapping CAPSLOCK DOWN to CTRL DOWN" << std::endl;
                caps_down = true;
                input[0].ki.dwFlags = 0;
                input[0].ki.wVk = VK_LCONTROL;
                SendInput(1, input, sizeof (INPUT));
            }
            return 1;
        } else {
            if (keyup) {
                keys_down.erase(p->vkCode);
            } else {
                keys_down.insert(p->vkCode);
            }
            std::cout << keys_down.size() << " keys down" << std::endl;
        }
        if (caps_down && !keys_down.empty()) {
            caps_was_down_with_another_key = true;
        }
    }
    return CallNextHookEx(hook, nCode, wParam, lParam);
}

int main(int argc, char **argv){
    MSG messages;
    hook = SetWindowsHookEx(WH_KEYBOARD_LL, keyboardHook, NULL, 0);
    if (hook == NULL) {
        std::cout << "Error " << GetLastError() << std::endl;
        return 1;
    }
    std::cout << "Mapping ??? CAPSLOCK=>LCTRL and LCTRL=>CAPSLOCK..." << std::endl;
    while (GetMessage (&messages, NULL, 0, 0)) {
        TranslateMessage(&messages);
        DispatchMessage(&messages);
    }
    return 0;
}