Zuordnen der Feststelltaste zu Escape and Control unter Windows 7

Ich möchte in der Lage sein, die Feststelltaste Escape zuzuordnen, wenn sie nicht mit einer anderen Taste gedrückt wird, und Control, wenn dies der Fall ist. Wie kann ich das unter Windows 7 machen?

Sie können es mit SharpKeys Escape neu zuordnen

Ich kenne jedoch keine realistische Möglichkeit, eine bedingte Neuzuordnung durchzuführen, außer einen Tastaturtreiber zu schreiben.

Dies ist nicht genau das, was Sie wollen, aber sehr nahe, wenn Sie mit einigen Fehlern leben können. Hier ist ein AutoHotKey- Skript:

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

Es ordnet die Feststelltaste erneut Strg zu und sendet Escape, wenn Sie die Taste loslassen. Es dauerte eine Weile, bis ich mich daran gewöhnt hatte, dass bei jedem Loslassen der Feststelltaste die Escape-Taste gedrückt wurde. In Website-Textbereichen ist dies jedoch so gut wie nutzlos, da durch Drücken von "Escape" der Fokus auf den Textbereich verliert.

Ich suche jedoch nach einer Lösung dafür. Ich könnte sogar so weit gehen, eine Art Treiber- / Tastatur-Hook in C zu schreiben, haha.

Vim-spezifische Belästigungen: Es macht es unmöglich, Digraphen mit der Strg-K-Kombination zu tippen, und ist im Allgemeinen unangenehm, bevor Sie sich daran gewöhnen. Es funktioniert jedoch gut für mich, weil ich alles tun würde, um Esc und Strg-Tasten so weit wie möglich zu vermeiden.

Dies ist möglicherweise auf der zuvor erwähnten Vim-Wikia-Seite nach Richs Lösung oben aufgetaucht .

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

Dies ist nicht meine Arbeit, aber ich habe damit begonnen, und es funktioniert genau wie beschrieben, keine wirklichen Einschränkungen, und weil es nicht versucht, Ausnahmen zuzuordnen (weil sie unnötig sind), verhält es sich in Chrome recht gut (ich wirklich) wollte es für Vimium).

Ich verwende dazu das folgende AutoHotkey- Skript, das ich aus dem Vim Tips Wiki übernommen habe . Die Implementierung ist ein bisschen hacky, aber es "funktioniert bei mir". (Und im Gegensatz zu den anderen Antworten auf dieser Seite vom 19.09.2016 wird das Problem vollständig gelöst, ohne dass mir irgendwelche Einschränkungen bewusst sind.)

Der ursprüngliche Codierer stellte fest:

Das Skript versucht auch, "False Positives" zu erkennen und zu vermeiden, wenn Sie die Strg-Taste und eine andere Taste drücken und beide zu schnell, dh vor dem Timeout, loslassen.

Stellen Sie sicher, dass Sie den 250-ms-Wert anpassen, je nachdem, wie gut oder schlecht Ihre Tastatur ist und welche Reaktionszeit Sie haben. Dies ist wahrscheinlich etwas, das Sie experimentell nach Ihren Wünschen anpassen können.

CapsLockCtrlEscape.ahk Inhalt :

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

Hier ist ein Registrierungseintrag, der die Feststelltaste für Windows 7 zuordnet.

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

Speichern Sie das Obige in einer Datei mit der Erweiterung .reg (wie mapCapLocks.reg) und importieren Sie es / führen Sie es auf Ihrem Computer aus.

Eigentlich denke ich, dass ich hier die perfekte Lösung gefunden habe:

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

Als Vim-Benutzer ist dies ein Muss für mich und ich benutze es seit langer Zeit mit Erfolg unter Windows. Ich erstelle gerade einen Eintrag HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Runmit regedit, um auf die ausführbare Datei zu verweisen, und es funktioniert einfach.

Informationen zum Kompilieren und Installieren von Abhängigkeiten finden Sie in der README-Datei des Repository und auf der Hauptwebsite von Interception.

Ich habe hier auch eine Linux-Version davon erstellt:

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

Ich suchte nach etwas ähnlichem, aber leider funktionierten die AHK-Skripte aus den Antworten hier nicht gut für mich.

Im Vim-Wiki habe ich jedoch eine Lösung gefunden, die das Problem für mich löst .

• Laden Sie zunächst die folgende App namens Dual-Key-Remap herunter .
• Extrahieren Sie die Postleitzahl an einem Ort Ihrer Wahl (ich speichere Dienstprogramme wie diese in C:\Users\%username%\util\)
• Öffnen Sie das folgende Verzeichnis: C:\Users\%username%\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\und ziehen Sie die Datei "dual-key-remap.exe" dorthin, während Sie die ALT -Taste gedrückt halten , um eine Verknüpfung zu erstellen. (Oder klicken Sie mit der rechten Maustaste und wählen Sie "Verknüpfung erstellen" und verschieben Sie die Verknüpfung in Ihr Startverzeichnis.)
• Einloggen und ausloggen. Ein paar Sekunden nachdem Sie eingeloggt sind, werden die Schlüssel neu gebunden.

Das in den in diesem Artikel erwähnten Windows Server 2003 Resource Kit-Tools enthaltene Programm remapkey.exe funktioniert in Windows 7 einwandfrei .

Ich habe nicht genug Ruf, um die Antwort zu kommentieren, die für mich funktioniert hat. Ich habe es trotzdem hochgestuft.

Die Antwort von pepper-chico hat bei mir funktioniert.

Die Feststelltaste verhält sich als Escape-Taste, wenn sie alleine gedrückt wird. Und verhält sich wie Strg-Taste, wenn mit anderen kombiniert. Ich habe auch den gleichen Anwendungsfall dafür. Vim.

Die Anweisungen in dem von ihm bereitgestellten Link sind einfach genug, um sie zu befolgen.

Wenn es Ihnen nichts ausmacht, kurzen Quellcode selbst zu kompilieren, können Sie den folgenden Code verwenden. Sie müssen es als Windows-Konsolenanwendung kompilieren. Beispielsweise können Sie es in der Visual C ++ - Eingabeaufforderung mit kompilieren

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

Die Tasten-Neuzuordnung funktioniert, während die Anwendung ausgeführt wird. Neustart, Abmelden / Anmelden usw. sind nicht erforderlich. Wenn Sie eine Neuzuordnung für Anwendungen benötigen, die mit Administratorrechten ausgeführt werden, müssen Sie die Remapperanwendung auch als Administrator ausführen. Habe es schon seit ein paar Tagen benutzt (unter Windows 10), soweit so gut.

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