Mappage du verrouillage des majuscules pour échapper et contrôler sous Windows 7

Je veux pouvoir mapper la touche de verrouillage des majuscules sur Échap si elle n'est enfoncée avec aucune autre touche et sur Contrôle si c'est le cas. Comment puis-je faire cela sur Windows 7?

Vous pouvez le remapper à Escape avec SharpKeys

Cependant, je ne connais pas de manière réaliste d'effectuer un remappage conditionnel, autre que l'écriture d'un pilote de clavier.

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

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

Il remappe Caps Lock à Ctrl et envoie Escape lorsque vous relâchez la touche. Il m'a fallu un certain temps pour m'habituer à ce que la touche Échap soit enfoncée à chaque fois que je relâche la touche de verrouillage des majuscules. Cependant, c'est à peu près inutile sur les zones de texte du site Web, car en appuyant sur Échap, vous perdez le focus sur la zone de texte.

Je cherche cependant une solution à cela. Je pourrais aller jusqu'à écrire une sorte de crochet pilote / clavier en C si nécessaire, haha.

Gênes spécifiques à Vim: Cela rend les digraphes impossibles à taper à l'aide de la combinaison Ctrl-K et est généralement ennuyeux avant de vous y habituer. Cela fonctionne bien pour moi car je ferais tout pour éviter autant que possible les touches Échap et Ctrl.

Cela peut être apparu sur la page vim wikia mentionnée précédemment après la solution de Rich ci-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 réelles mises en garde, et parce qu'il n'essaie pas de mapper des exceptions (car elles sont inutiles), il se comporte très bien dans Chrome (je vraiment je le voulais pour Vimium).

J'utilise pour cela le script AutoHotkey suivant , adapté de celui que j'ai trouvé sur le wiki Vim Tips . L'implémentation est un peu hacky, mais ça "marche pour moi". (Et contrairement aux autres réponses sur cette page en date du 2016-09-19, cela résout complètement le problème sans aucune mise en garde à ma connaissance.)

Le codeur d'origine a noté:

Le script essaie également de détecter et d'éviter les «faux positifs» lorsque vous appuyez sur Contrôle et sur une autre touche et relâchez les deux trop rapidement, c'est-à-dire avant la période de temporisation.

Assurez-vous de modifier la valeur de 250 ms en fonction de la qualité de votre clavier et de votre propre temps de réaction. C'est probablement quelque chose à modifier expérimentalement à votre guise.

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

Voici une entrée de registre qui mappe le verrouillage des majuscules 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 importez / exécutez-le sur votre machine.

En fait, je pense que j'ai construit la solution parfaite ici:

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

En tant qu'utilisateur Vim, c'est un must pour moi, et je l'utilise depuis longtemps avec succès sur Windows. Je viens de créer une entrée HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Runavec regedit pour pointer vers l'exécutable et cela fonctionne simplement.

Pour compiler et installer les dépendances, veuillez consulter le README du référentiel et le site Web principal pour l'interception.

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

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

Je cherchais quelque chose d'aussi similaire à cela, mais malheureusement, les scripts AHK des réponses ici ne fonctionnaient pas bien pour moi.

Cependant, j'ai trouvé une solution qui a résolu cela pour moi sur le wiki vim .

• Tout d'abord, téléchargez l'application suivante appelée remappage à double clé .
• Extraire le zip dans un emplacement 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-y glisser le fichier dual-key-remap.exe, tout en maintenant ALT enfoncé pour créer un raccourci. (Ou faites un clic droit et sélectionnez «créer un raccourci» et déplacez le raccourci vers votre répertoire de démarrage).
• Connectez-vous et déconnectez-vous. Quelques secondes après votre connexion, les clés rebondiront.

Le programme remapkey.exe inclus dans les outils du Kit de ressources Windows Server 2003 mentionné dans cet article fonctionne bien dans Windows 7.

Je n'ai pas assez de réputation pour commenter la réponse qui a fonctionné pour moi. Je l'ai quand même voté.

La réponse de pepper-chico a fonctionné pour moi.

La touche de verrouillage des majuscules se comporte comme la touche Échap si elle est enfoncée d'elle-même. Et se comporte comme la touche Ctrl si elle est combinée avec d'autres. J'ai également le même cas d'utilisation pour cela. Vigueur.

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

Si cela ne vous dérange pas de compiler vous-même le code source court, vous pouvez utiliser le code ci-dessous. Vous devez le compiler en tant qu'application de console Windows. Par exemple, dans l'invite de commande Visual C ++, vous pouvez le compiler avec

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

Le remappage des touches fonctionne lorsque l'application est en cours d'exécution. Pas besoin de redémarrer, de se déconnecter / se connecter, etc. Si vous avez besoin d'un remappage pour fonctionner pour des applications exécutées avec des droits d'administrateur, vous devez également exécuter l'application de remappage en tant qu'administrateur. Je l'utilise depuis quelques jours déjà (sur Windows 10), jusqu'à présent tout va bien.

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