web-dev-qa-db-fra.com

Mappage des capuchons Verrouillage pour échapper et contrôler sur Windows 7

Je veux pouvoir cartographier la touche de verrouillage des capuchons pour vous échapper si elle n'est pas enfoncée avec aucune autre clé et contrôle si elle est. Comment puis-je faire cela sur Windows 7?

windowskeyboardremapping
25
Zameer Manji

Vous pouvez le remapper pour s'échapper avec Sharpkeys

Cependant, je ne connais pas d'un moyen réaliste d'effectuer un remodelage conditionnel, autrement que d'écrire un pilote de clavier.

8
wizzard0

Ce n'est pas exactement ce que vous voulez, mais très proche si vous pouvez vivre avec des défauts. Voici un script Autohotkey :

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

Il remappe les capuchons verrouillables à CTRL et envoie une évasion lorsque vous relâchez la clé. Il m'a fallu un certain temps pour s'habituer à la touche d'échappement étant pressée à chaque fois que je laisse aller la clé de verrouillage des capuchons. Cependant, il est à peu près inutile sur le site Web textase parce que vous appuyez sur Echap perd la mise au point sur le Texarea.

Je cherche une solution à cela. Je pourrais aller aussi loin que d'écrire une sorte de conducteur/crochet de clavier en C si nécessaire, haha.

Economies spécifiques à VIM: il rend les digraphes impossibles à taper à l'aide de la combinaison Ctrl-K et sont généralement gênantes avant de vous y habituer. Cela me convient bien parce que je ferais n'importe quoi pour éviter le plus possible les touches ESC et CTRL.

7
Henry Heikkinen

Cela peut être apparu sur la page précédemment mentionnée Vim Wikia après la solution de Rich au-dessus.

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

Ce n'est pas mon travail, mais j'ai commencé à l'utiliser et cela fonctionne exactement comme décrit, pas de véritables mises en garde et, car elles ne tentent pas de cartographier des exceptions (car elles sont inutiles), il se comporte assez bien en Chrome (je le voulais vraiment pour vimium).

6
dragon788

J'utilise le script suivant Autohotkey pour cela, adapté de ne que j'ai trouvée sur le wiki Tips Vim . La mise en œuvre est un peu hacky, mais ça "travaille pour moi". (Et contrairement aux autres réponses sur cette page à partir de 2016-09-19, elle résout complètement la question sans aucune mises en garde que je suis au courant.)

Le codeur d'origine a noté:

Le script essaie également de détecter et d'éviter les "faux positifs" où vous appuyez sur le contrôle et une autre clé et relâchez-les trop rapidement, c'est-à-dire avant la période de délai d'attente.

Assurez-vous de modifier la valeur de 250 ms en fonction de la qualité ou du mauvais votre clavier, ainsi que de votre propre temps de réaction. C'est probablement quelque chose à modifier expérimentalement à votre goût.

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
4
Rich

Voici une entrée de registre qui mappe la serrure Caps pour s'échapper sur 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

Enregistrez ce qui précède dans un fichier avec une extension .reg (comme MapCapLocks.reg) et importer/l'exécuter sur votre ordinateur. Cela peut être fait en cliquant sur ce fichier dans l'explorateur de fichiers, puis en vous déconnectant et à vous connecter.

4
Stryker

Je cherchais quelque chose aussi semblable à cela, mais malheureusement, les scripts AHK des réponses ici n'ont pas bien fonctionné pour moi.

Cependant, j'ai trouvé une solution qui résolue cela pour moi sur le Vim Wiki .

  • Tout d'abord, téléchargez l'application suivante appelée Dual-Key-Remap .
  • Extraire le zip dans un endroit de votre choix (je stocke des utilitaires comme ceux-ci dans C:\Users\%username%\util\)
  • Ouvrez le répertoire suivant: C:\Users\%username%\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\ et faites glisser le fichier Dual-Key-Remap.exe là-bas, tout en maintenant ALT pour créer un raccourci. (Ou clic droit et sélectionnez "Créer un raccourci" et déplacez le raccourci vers votre répertoire de démarrage).
  • Se connecter et sortir. Quelques secondes après que vous soyez connecté dans les clés seront rebondés.
2
curious-cat

En fait, je pense avoir construit la solution parfaite ici:

En tant qu'utilisateur VIM, c'est un must pour moi et je l'utilise avec succès sur Windows pendant une longue période. Je viens de créer une entrée sur HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run Avec Regedit doit indiquer à l'exécutable et cela fonctionne simplement.

Pour compiler et installer des dépendances Veuillez vérifier le référentiel README et le site Web principal pour l'interception.

J'ai également créé une version Linux du même ici:

2
pepper_chico

Si cela ne vous dérange pas de compiler vous-même un code source court, vous pouvez utiliser le code ci-dessous. Vous devez le compiler comme application de console Windows. E.g., dans l'invite de commande visual C++, vous pouvez le compiler avec

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

La touche Remapping fonctionne lorsque l'application est en cours d'exécution. Pas besoin de redémarrer, de vous déconnecter/dans, etc. Si vous avez besoin de remappage de travaux pour les applications exécutées avec les droits de l'administrateur, vous devez modifier l'application Remapper comme administrateur également. L'utilise depuis quelques jours déjà (sur Windows 10), jusqu'à présent si bon.

// 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): https://superuser.com/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;
}
0
Alex Che

Le programme RemapKey.exe inclus dans les ( Outils de ressources de ressources Windows Server 20 mentionné dans cet article fonctionne bien sous Windows 7.

0
justin

Je n'ai pas assez de réputation pour commenter la réponse qui a fonctionné pour moi. Je l'ai toujours évoqué cependant.

Pepper-Chico's Réponse a fonctionné pour moi.

La clé de verrouillage des capuchons se comporte comme une clé d'échappement si elle est enfoncée. Et se comporte comme la clé Ctrl si elle est combinée avec d'autres. J'ai aussi le même cas d'utilisation pour cela. Vigueur.

L'instruction dans le lien qu'il a fourni est assez simple à suivre.

0
mrkvn