Mapowanie Caps Lock na Escape i Control w Windows 7

Chcę mieć możliwość mapowania klawisza Caps Lock na Escape, jeśli nie zostanie naciśnięty z żadnym innym klawiszem, i kontrolowanie, jeśli tak jest. Jak mogę to zrobić w systemie Windows 7?

Możesz zmienić przypisanie do Escape za pomocą SharpKeys

Nie znam jednak realistycznego sposobu wykonywania mapowania warunkowego innego niż pisanie sterownika klawiatury.

Nie jest to dokładnie to, czego chcesz, ale bardzo blisko, jeśli możesz żyć z pewnymi wadami. Oto skrypt AutoHotKey :

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

Ponownie zamienia Caps Lock w Ctrl i wysyła Escape po zwolnieniu klawisza. Zajęło mi trochę czasu przyzwyczajenie się do naciskania klawisza Escape za każdym razem, gdy puszczam klawisz Caps Lock. Jest to jednak prawie bezużyteczne w obszarach tekstowych witryny, ponieważ naciśnięcie klawisza Escape traci skupienie na obszarach tekstowych.

Szukam rozwiązania tego. W razie potrzeby mógłbym napisać coś w rodzaju haka ze sterownikami / klawiaturami w C, haha.

Irytacje specyficzne dla Vima: uniemożliwia pisanie cyfr za pomocą kombinacji Ctrl-K i ogólnie jest denerwujące, zanim się przyzwyczaisz. Działa to jednak dla mnie dobrze, ponieważ zrobiłbym wszystko, aby w jak największym stopniu uniknąć klawiszy Esc i Ctrl.

Mogło to pojawić się na wcześniej wspomnianej stronie wiki vim po powyższym rozwiązaniu Richa.

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

To nie jest moja praca, ale zacząłem go używać i działa dokładnie tak, jak opisano, bez prawdziwych zastrzeżeń, a ponieważ nie próbuje mapować żadnych wyjątków (ponieważ są niepotrzebne), działa całkiem ładnie w Chrome (naprawdę chciałem dla Vimium).

Używam do tego następującego skryptu AutoHotkey , dostosowanego do tego, który znalazłem na Wiki Vim Tips . Implementacja jest nieco zaraźliwa, ale „działa dla mnie”. (I w przeciwieństwie do innych odpowiedzi na tej stronie z 19.09.2016, rozwiązuje on w pełni problem bez żadnych ostrzeżeń, o których wiem.)

Oryginalny programista zauważył:

Skrypt próbuje także wykryć i uniknąć „fałszywych alarmów”, gdy naciskasz Control i inny klawisz i zwalniasz oba zbyt szybko, tj. Przed upływem limitu czasu.

Koniecznie dostosuj wartość 250 ms w zależności od tego, jak dobra lub zła jest twoja klawiatura oraz od twojego czasu reakcji. Prawdopodobnie jest to coś, co można eksperymentalnie dostosować do własnych upodobań.

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

Oto wpis rejestru odwzorowujący klawisz Caps Escape na 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

Zapisz powyższe w pliku z rozszerzeniem .reg (np. MapCapLocks.reg) i zaimportuj / uruchom go na swoim komputerze.

Właściwie myślę, że zbudowałem tutaj idealne rozwiązanie:

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

Jako użytkownik Vima jest to dla mnie koniecznością i od dawna używam go z powodzeniem w systemie Windows. Po prostu tworzę wpis HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Runz regedit, aby wskazać plik wykonywalny i to po prostu działa.

Aby skompilować i zainstalować zależności, sprawdź repozytorium README i główną stronę internetową pod kątem przechwytywania.

Stworzyłem również tę samą wersję systemu Linux:

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

Szukałem czegoś podobnego do tego, ale niestety skrypty AHK z odpowiedzi tutaj nie działały dla mnie dobrze.

Znalazłem jednak rozwiązanie, które rozwiązało to dla mnie na wiki wiki .

• Najpierw pobierz następującą aplikację o nazwie remap podwójnego klucza .
• Rozpakuj zip w wybranej lokalizacji (przechowuję narzędzia takie jak te w C:\Users\%username%\util\)
• Otwórz następujący katalog: C:\Users\%username%\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\i przeciągnij tam plik dual-key-remap.exe, przytrzymując klawisz ALT, aby utworzyć skrót. (Lub kliknij prawym przyciskiem myszy i wybierz „utwórz skrót” i przenieś skrót do katalogu startowego).
• Zaloguj się i wyloguj. Kilka sekund po zalogowaniu klucze zostaną ponownie powiązane.

Program remapkey.exe zawarty w narzędziach Windows Server 2003 Resource Kit wymienionych w tym artykule działa dobrze w systemie Windows 7.

Nie mam wystarczającej reputacji, aby skomentować odpowiedź, która zadziałała dla mnie. Nadal jednak to głosowałem.

Odpowiedź pepper-chico zadziałała dla mnie.

Klawisz Caps Lock zachowuje się jak klawisz Escape, jeśli zostanie naciśnięty samodzielnie. I zachowuje się jak klawisz Ctrl w połączeniu z innymi. Mam też ten sam przypadek użycia. Wigor.

Instrukcja w linku, który podał, jest wystarczająco prosta do naśladowania.

Jeśli nie masz nic przeciwko samodzielnemu skompilowaniu krótkiego kodu źródłowego, możesz użyć kodu poniżej. Musisz go skompilować jako aplikację konsoli Windows. Np. W wierszu polecenia Visual C ++ można go skompilować

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

Ponowne mapowanie klucza działa podczas działania aplikacji. Nie trzeba ponownie uruchamiać komputera, wylogowywać się / logować itp. Jeśli konieczne jest ponowne mapowanie, aby aplikacje działały z prawami administratora, należy również uruchomić aplikację remapper jako administrator. Używam go już od kilku dni (w systemie Windows 10), na razie jak na razie.

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