Mapeamento de Caps Lock para escape e controle no Windows 7


23

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?



4
Bem, a reafectação condicional não está coberto lá
wizzard0

Eu fiz isso modificando o registro: commons.lbl.gov/display/~jwelcher@lbl.gov/… você precisa reiniciar o computador depois de fazer isso. Win7.
Static # 11/05

Respostas:


8

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.


11
Eu já tenho minha tecla Caps Lock mapeada para Escape com SharpKeys.
Zameer Manji

6

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.


Se você deseja apenas mapeá-lo para escapar, pode simplificar isso para: $CapsLock::Escapee então imediatamente return.
Kazark

Estou tentando entender - então a falha no script é que, quando Caps Lock é pressionado e liberado, são enviados um Ctrl e um Escape?
Rishi

5

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 tenho usado esse script e funciona para mim. Estou usando isso para religar o Caps Lock ao Control / Escape para vim.
Brandon

11
Trabalho! Só para esclarecer, é um script do AutoHotKey. Comece aqui: autohotkey.com
Michael Fox

Para o benefício de leitores que podem não ter clicado e visto os comentários na minha essência, parece que esta solução só funciona se você pressionar Caps Lockantes de pressionar Shift. Caps+Shift+Xfunciona mas Shift+Caps+Xnão funciona .
Rich

4

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

3

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.


Cite as partes essenciais da resposta nos links de referência, pois a resposta pode se tornar inválida se as páginas vinculadas forem alteradas. Atualmente 404, então esta resposta é inútil.
DavidPostill

Excelentes pontos. Vou atualizar a resposta
Stryker

Isso também mapeará a tecla ScrollLock para CapsLock. Se não é isso que você deseja, use o valor hex:00,00,00,00,00,00,00,00,02,00,00,00,01,00,3a,00,00,00,00,00. O editor útil para este mapa é ScancodeMapping from PlexData .
Appleshell 22/06

2

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

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:


2

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.


0

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.


0

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;
}
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.