Mappatura del blocco maiuscole su Escape and Control su Windows 7


23

Voglio essere in grado di mappare il tasto BLOC MAIUSC su Esc se non viene premuto con nessun altro tasto e Control se lo è. Come posso farlo su Windows 7?



4
Bene, la riassegnazione condizionale non è coperta qui
wizzard0

L'ho fatto modificando il registro: commons.lbl.gov/display/~jwelcher@lbl.gov/… è necessario riavviare il computer dopo averlo fatto. Win7.
statico o

Risposte:


8

Puoi rimappare su Escape con SharpKeys

Tuttavia, non conosco un modo realistico per eseguire il rimappatura condizionale, oltre a scrivere un driver della tastiera.


1
Ho già il mio tasto BLOC MAIUSC associato a Escape con SharpKeys.
Zameer Manji,

6

Questo non è esattamente quello che vuoi, ma molto vicino se riesci a vivere con alcuni difetti. Ecco uno script AutoHotKey :

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

Rimappa Caps Lock su Ctrl e invia Esc quando si rilascia il tasto. Mi ci è voluto un po 'di tempo per abituarmi alla pressione del tasto Esc ogni volta che rilasciavo il tasto BLOC MAIUSC. Tuttavia è praticamente inutile sulle textareas del sito Web perché premendo Esc si perde l'attenzione sulla textarea.

Sto cercando una soluzione a questo però. Potrei andare fino a scrivere una sorta di gancio per driver / tastiera in C se necessario, ahah.

Disturbi specifici di Vim: rende impossibile scrivere digraph usando la combinazione Ctrl-K ed è generalmente fastidioso prima di abituarti. Per me funziona bene perché farei qualsiasi cosa per evitare il più possibile i tasti Esc e Ctrl.


Se vuoi solo mapparlo per scappare, puoi semplificarlo a: $CapsLock::Escapee poi immediatamente return.
Kazark

Sto cercando di capire - quindi il difetto dello script è che quando viene premuto e rilasciato Caps Lock, vengono inviati sia un Ctrl che Escape?
Rishi,

5

Questo potrebbe essere apparso sulla pagina di vim wikia precedentemente menzionata dopo la soluzione di Rich sopra.

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

Questo non è il mio lavoro, ma ho iniziato ad usarlo e funziona esattamente come descritto, nessun vero avvertimento, e poiché non tenta di mappare alcuna eccezione (perché non sono necessarie) si comporta abbastanza bene in Chrome (io davvero lo volevo per Vimium).


Sto usando questo script e funziona per me. Sto usando questo per ricollegare Caps Lock a Control / Escape for vim.
Brandon,

1
Lavori! Giusto per chiarire, è uno script AutoHotKey. Inizia qui: autohotkey.com
Michael Fox,

A beneficio dei lettori che potrebbero non aver cliccato e visto i commenti sul mio contenuto, questa soluzione sembra funzionare solo se si preme Caps Lockprima di premere Shift. Caps+Shift+Xfunziona ma Shift+Caps+Xnon funziona.
Rich

4

Per questo uso il seguente script AutoHotkey , adattato da quello che ho trovato sul Wiki di Vim Tips . L'implementazione è un po 'confusa, ma "funziona per me". (E a differenza delle altre risposte su questa pagina a partire dal 19.09.2016, risolve completamente il problema senza alcun avvertimento di cui sono a conoscenza.)

Il programmatore originale ha osservato:

Lo script tenta inoltre di rilevare ed evitare "falsi positivi" quando si preme Control e un altro tasto e si rilasciano entrambi troppo rapidamente, ovvero prima del periodo di timeout.

Assicurati di modificare il valore di 250ms a seconda di quanto sia buona o cattiva la tua tastiera e del tuo tempo di reazione. Questo è probabilmente qualcosa da modificare sperimentalmente a proprio piacimento.

Informazioni su CapsLockCtrlEscape.ahk :

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

Ecco una voce di registro che mappa il blocco maiuscole per uscire su 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

Salva quanto sopra in un file con estensione .reg (come mapCapLocks.reg) e importalo / eseguilo sul tuo computer.


Si prega di citare le parti essenziali della risposta dai collegamenti di riferimento, in quanto la risposta può diventare non valida se le pagine collegate cambiano. Attualmente 404 quindi questa risposta è inutile.
DavidPostill

Punti eccellenti. Aggiornerò la risposta
Stryker,

Questo mapperà anche la chiave ScrollLock su CapsLock. Se non è quello che vuoi, usa il valore hex:00,00,00,00,00,00,00,00,02,00,00,00,01,00,3a,00,00,00,00,00. L'editor utile per questa mappa è ScancodeMapping di PlexData .
Appleshell,

2

In realtà penso di aver costruito la soluzione perfetta qui:

Come utente di Vim, questo è un must per me, e lo sto usando con successo su Windows da molto tempo. Ho appena creato una voce su HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Runcon regedit per puntare all'eseguibile e funziona semplicemente.

Per compilare e installare dipendenze, consultare il repository README e il sito Web principale di Interception.

Ho anche creato una versione Linux della stessa qui:


2

Stavo cercando qualcosa di simile a questo, ma sfortunatamente gli script AHK delle risposte qui non hanno funzionato bene per me.

Tuttavia, ho trovato una soluzione che mi ha risolto sul wiki di Vim .

  • Innanzitutto, scarica la seguente app chiamata dual-key-remap .
  • Estrai la zip in una posizione a tua scelta (conservo le utility come queste in C:\Users\%username%\util\)
  • Apri la seguente directory: C:\Users\%username%\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\e trascina lì il file dual-key-remap.exe, tenendo premuto ALT per creare un collegamento. (Oppure fai clic con il pulsante destro del mouse e seleziona "crea collegamento" e sposta il collegamento nella directory di avvio).
  • Accedi ed esci. Alcuni secondi dopo aver effettuato l'accesso, le chiavi verranno rimbalzate.


0

Non ho abbastanza reputazione per commentare la risposta che ha funzionato per me. L'ho comunque votato.

la risposta di pepper-chico ha funzionato per me.

Il tasto BLOC MAIUSC si comporta come tasto ESC se premuto da solo. E si comporta come il tasto Ctrl se combinato con altri. Ho anche lo stesso caso d'uso per questo. Vim.

Le istruzioni nel link fornito sono abbastanza semplici da seguire.


0

Se non ti dispiace compilare tu stesso il codice sorgente breve, puoi usare il codice qui sotto. Devi compilarlo come applicazione console di Windows. Ad esempio, nel prompt dei comandi di Visual C ++ è possibile compilarlo

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

La rimappatura dei tasti funziona mentre l'applicazione è in esecuzione. Non è necessario riavviare, disconnettersi / accedere, ecc. Se è necessario rimappare per funzionare con le applicazioni eseguite con diritti di amministratore, è necessario eseguire anche l'applicazione di remapper come amministratore. Lo uso già da un paio di giorni (su Windows 10), finora tutto bene.

// 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;
}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.