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?
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?
Risposte:
Puoi rimappare su Escape con SharpKeys
Tuttavia, non conosco un modo realistico per eseguire il rimappatura condizionale, oltre a scrivere un driver della tastiera.
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.
$CapsLock::Escape
e poi immediatamente return
.
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).
Caps Lock
prima di premere Shift
. Caps+Shift+X
funziona ma Shift+Caps+X
non funziona.
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
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.
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 .
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\Run
con 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:
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 .
C:\Users\%username%\util\
)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).Il programma remapkey.exe incluso negli strumenti del Resource Kit di Windows Server 2003 menzionato in questo articolo funziona perfettamente con Windows 7.
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.
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;
}