Asignación de bloqueo de mayúsculas a escape y control en Windows 7

Quiero poder asignar la tecla Bloq Mayús a Escape si no se presiona con ninguna otra tecla y controlar si es así. ¿Cómo puedo hacer eso en Windows 7?

Puede reasignarlo a Escape con SharpKeys

Sin embargo, no conozco una forma realista de realizar la reasignación condicional, aparte de escribir un controlador de teclado.

Esto no es exactamente lo que quieres, pero está muy cerca si puedes vivir con algunos defectos. Aquí hay un script de AutoHotKey :

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

Vuelve a asignar Bloq Mayús a Ctrl y envía Escape cuando sueltas la tecla. Me tomó un tiempo acostumbrarme a presionar la tecla Escape cada vez que soltaba la tecla Bloq Mayús. Sin embargo, es bastante inútil en las áreas de texto del sitio web porque presionar Escape pierde el foco en el área de texto.

Sin embargo, estoy buscando una solución para esto. Podría ir tan lejos como escribir algún tipo de gancho de controlador / teclado en C si es necesario, jaja.

Molestias específicas de Vim: hace que los dígrafos sean imposibles de escribir usando la combinación Ctrl-K y, por lo general, es bastante molesto antes de acostumbrarse. Sin embargo, me funciona bien porque haría cualquier cosa para evitar las teclas Esc y Ctrl tanto como sea posible.

Esto puede haber aparecido en la página vim wikia mencionada anteriormente después de la solución de Rich anterior.

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

Este no es mi trabajo, pero comencé a usarlo y funciona exactamente como se describe, sin advertencias reales, y debido a que no intenta mapear ninguna excepción (porque son innecesarias) se comporta bastante bien en Chrome (realmente lo quería para Vimium).

Para esto utilizo el siguiente script de AutoHotkey , adaptado del que encontré en el Wiki de Vim Tips . La implementación es un poco extraña, pero "funciona para mí". (Y a diferencia de las otras respuestas en esta página a partir de 2016-09-19, resuelve completamente el problema sin ninguna advertencia que yo sepa).

El codificador original señaló:

El script también intenta detectar y evitar "falsos positivos" cuando presiona Control y otra tecla y suelta ambos demasiado rápido, es decir, antes del tiempo de espera.

Asegúrese de ajustar el valor de 250 ms dependiendo de qué tan bueno o malo sea su teclado y su propio tiempo de reacción. Esto es probablemente algo para ajustar experimentalmente a tu gusto.

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

Aquí hay una entrada de registro que asigna el bloqueo de mayúsculas para escapar en 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

Guarde lo anterior en un archivo con una extensión .reg (como mapCapLocks.reg) e impórtelo / ejecútelo en su máquina.

En realidad creo que he construido la solución perfecta aquí:

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

Como usuario de Vim, esto es imprescindible para mí, y lo he estado usando con éxito en Windows durante mucho tiempo. Acabo de crear una entrada HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Runcon regedit para apuntar al ejecutable y simplemente funciona.

Para compilar e instalar dependencias, consulte el repositorio README y el sitio web principal de Interception.

También he creado una versión de Linux de lo mismo aquí:

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

Estaba buscando algo similar a esto, pero desafortunadamente los scripts AHK de las respuestas aquí no funcionaron bien para mí.

Sin embargo, encontré una solución que me resolvió esto en el wiki de vim .

• Primero, descargue la siguiente aplicación llamada dual-key-remap .
• Extraiga el zip en la ubicación que elija (guardo utilidades como estas en C:\Users\%username%\util\)
• Abra el siguiente directorio: C:\Users\%username%\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\y arrastre el archivo dual-key-remap.exe allí, mientras mantiene presionado ALT para crear un acceso directo. (O haga clic derecho y seleccione 'crear acceso directo', y mueva el acceso directo a su directorio de inicio).
• Iniciar y cerrar sesión Unos segundos después de haber iniciado sesión, las teclas se recuperarán.

El programa remapkey.exe incluido en las herramientas del Kit de recursos de Windows Server 2003 mencionadas en este artículo funciona bien en Windows 7.

No tengo suficiente reputación para comentar la respuesta que me funcionó. Sin embargo, todavía lo voté.

La respuesta de pepper-chico funcionó para mí.

La tecla Bloq Mayús se comporta como la tecla Escape si se presiona por sí sola. Y se comporta como la tecla Ctrl si se combina con otros. También tengo el mismo caso de uso para esto. Empuje.

La instrucción en el enlace que proporcionó es lo suficientemente simple como para seguirla.

Si no le importa compilar el código fuente corto usted mismo, puede usar el siguiente código. Necesita compilarlo como aplicación de consola de Windows. Por ejemplo, en el símbolo del sistema de Visual C ++ puede compilarlo con

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

La reasignación de claves funciona mientras se ejecuta la aplicación. No es necesario reiniciar, cerrar sesión / iniciar sesión, etc. Si necesita reasignar para trabajar para aplicaciones que se ejecutan con derechos de administrador, entonces también debe ejecutar la aplicación de reasignación como administrador. Lo he estado usando durante un par de días (en Windows 10), hasta ahora muy bien.

// 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;
}