Résumé des paramètres personnels de keyhac

Si je pouvais en apporter un seul sur une île inhabitée, j'apporterais keyhac.

configuration de base

Modifiez la fonction configure () dans config.py, qui se trouve dans le même répertoire que exe.

config.py


import sys
import os
import datetime
import re #ajouter à
import time #ajouter à
import urllib.parse #ajouter à

import pyauto
from keyhac import *

def configure(keymap):

    #Modifier avec vscode obtenu à partir du scoop (ou du bloc-notes sinon)
    EDITOR_PATH = r"C:\Users\{}\scoop\apps\vscode\current\Code.exe".format(os.environ.get("USERNAME"))
    if not os.path.exists(EDITOR_PATH):
        EDITOR_PATH = "notepad.exe"
    keymap.editor = EDITOR_PATH

    # theme
    keymap.setFont("HackGen Console", 16)
    keymap.setTheme("black")

    #Définir la clé de conversion / non-conversion comme modificateur utilisateur
    keymap.replaceKey("(29)", 235)      #Soit non converti (29) 235
    keymap.defineModifier(235, "User0") #N'utilisez aucune conversion comme clé qualifiée U0
    keymap.replaceKey("(28)", 236)      #Soit la conversion (28) 236
    keymap.defineModifier(236, "User1") #Utiliser la transformation comme clé qualifiée U1

    #Historique des clips activé
    keymap.clipboard_history.enableHook(True)

    #Taille maximale de l'historique
    keymap.clipboard_history.maxnum = 200
    keymap.clipboard_history.quota = 10*1024*1024

    #Ctrl depuis l'historique+Symbole lors du collage d'un devis avec Entrée
    keymap.quote_mark = "> "

J'aime la police HackGen.

Ci-dessous, tous les détails de personnalisation seront écrits dans configure (). Veuillez fermer les yeux: il n'y a pas de règles pour les noms de variables et les noms de fonctions.

Déplacer le curseur

config.py


    #Remappage de clé toujours valide
    keymap_global = keymap.defineWindowKeymap()
    
    for modifier in ("", "S-", "C-", "A-", "C-S-", "C-A-", "S-A-", "C-A-S-"):
        #Haut bas Gauche Droite
        keymap_global[modifier + "U0-H"] = modifier + "Left"
        keymap_global[modifier + "U0-J"] = modifier + "Down"
        keymap_global[modifier + "U0-K"] = modifier + "Up"
        keymap_global[modifier + "U0-L"] = modifier + "Right"
        # Home / End
        keymap_global[modifier + "U0-A"] = modifier + "Home"
        keymap_global[modifier + "U0-E"] = modifier + "End"
        # Enter
        keymap_global[modifier + "U0-Space"] = modifier + "Enter"

        #Ignorez complètement la clé "Katakana Hiragana Rome"
        keymap_global["D-" + modifier + "(240)"] = lambda: None
        keymap_global["U-" + modifier + "(240)"] = lambda: None
        keymap_global["D-" + modifier + "(241)"] = lambda: None
        keymap_global["U-" + modifier + "(241)"] = lambda: None
        keymap_global["D-" + modifier + "(242)"] = lambda: None
        keymap_global["U-" + modifier + "(242)"] = lambda: None


    # [B]ackSpace / [D]elete
    keymap_global["U0-D"] = "Delete"
    keymap_global["U0-B"] = "Back"
    keymap_global["C-U0-D"] = "C-Delete"
    keymap_global["C-U0-B"] = "C-Back"
    keymap_global["S-U0-B"] = "S-Home", "C-X" #Couper au début
    keymap_global["S-U0-D"] = "S-End", "C-X" #Couper jusqu'au bout
    keymap_global["C-S-U0-B"] = "Home", "Back", "End" #Concaténer avec la ligne précédente
    keymap_global["C-S-U0-D"] = "End", "Delete", "End" #Concaténer avec la ligne suivante

Reportez-vous à ce site pour savoir comment définir le mouvement du curseur par la touche de modification collectivement. Dans Autohotkey, vous pouvez rendre la touche de modification transparente en ajoutant {blind}.

Contrôle IME

IME on / off est contrôlé par conversion + J et aucune conversion + F. Quand j'ai pensé à Japonais et Foreign, c'était utile car il y avait une saillie pour la position d'origine sur la clé.

config.py


    # [J]apanese / [F]oreign
    keymap_global["U1-J"] = lambda: keymap.getWindow().setImeStatus(1)
    keymap_global["U0-F"] = lambda: keymap.getWindow().setImeStatus(0)

Autre remappage clé

config.py


    #1 sélection de ligne
    keymap_global["U1-A"] = "End", "S-Home"

    #Reconversion originale
    keymap_global["U0-R"] = "LWin-Slash"

    #Celui que j'ai vu sur emacs
    keymap_global["LC-H"] = "Back"

    #Focus sur la barre des tâches
    keymap_global["C-U0-W"] = "W-T"

    #Insérez une ligne de haut en bas
    keymap_global["U0-I"]   = "End", "Enter"
    keymap_global["S-U0-I"] = "Home", "Enter", "Up"

    # escape
    keymap_global["O-(235)"] = "Esc"
    keymap_global["U0-X"]    = "Esc"

    #Liste des fenêtres ouvertes
    keymap_global["U0-W"] = "LCtrl-LAlt-Tab", "U-LAlt" #Augmentez explicitement Alt pour éviter de maintenir

    #Confirmé par alphanumérique
    keymap_global["U1-N"]   = "F10", "(243)"
    keymap_global["S-U1-N"] = "F10", "Enter"

    #Menu contextuel
    keymap_global["U0-C"] = "S-F10"

    #Renommer
    keymap_global["U0-N"] = "F2", "Right"
    keymap_global["S-U0-N"] = "F2", "C-Home"
    keymap_global["C-U0-N"] = "F2"

Raccourci maison

Fonction générale

Créez les fonctions suivantes pour les fonctions fréquemment utilisées.

config.py


    def delay(sec = 0.05):
        time.sleep(sec)

    def get_clippedText():
        return (getClipboardText() or "")

    def paste_string(s):
        setClipboardText(s)
        delay()
        keymap.InputKeyCommand("C-V")()

    def copy_string(sec = 0.05):
        keymap.InputKeyCommand("C-C")()
        delay(sec)
        return get_clippedText()

    def send_input(ime_mode, keys, sleep = 0.01):
        if ime_mode is not None:
            if keymap.getWindow().getImeStatus() != ime_mode:
                keymap.InputKeyCommand("(243)")()
        for key in keys:
            delay(sleep)
            try:
                keymap.InputKeyCommand(key)()
            except:
                keymap.InputTextCommand(key)()

keyhac traite l'entrée clé ʻInputKeyCommand () et la chaîne d'entrée ʻInputTextCommand () séparément. J'ai créé la fonction finale send_input () pour implémenter des spécifications d'entrée telles que Send, ABC {Enter} dans Autohotkey. IME peut également être spécifié ((243) est une clé demi-largeur / pleine largeur).

Système de saisie de caractères

Utilisez la fonction send_input () ci-dessus pour réduire le plus possible l'effort de saisie de caractères.

Entrer des parenthèses

config.py


    #Entrez des parenthèses et déplacez le curseur entre
    def wrap_with_brackets(pair, after_ime_mode):
        keys = [pair, "Left"]
        if after_ime_mode == 1:
            keys.append("(243)")
        return lambda: send_input(0, keys, 0.05)
    brackets = [
        ("U0-2"            , '""'          , 0),
        ("U0-7"            , "''"          , 0),
        ("U0-8"            , "\u300E\u300F", 1), # WHITE CORNER BRACKET 『』
        ("U0-9"            , "\u3010\u3011", 1), # BLACK LENTICULAR BRACKET 【】
        ("U0-AtMark"       , "``"          , 0),
        ("U1-2"            , "\u201C\u201D", 1), # DOUBLE QUOTATION MARK “”
        ("U1-7"            , "\u3014\u3015", 1), # TORTOISE SHELL BRACKET 〔〕
        ("U1-8"            , "\uFF08\uFF09", 1), # FULLWIDTH PARENTHESIS ()
        ("U1-9"            , "()"          , 0),
        ("U0-OpenBracket"  , "\u300c\u300d", 1), # CORNER BRACKET 「」
        ("U1-OpenBracket"  , "\uFF3B\uFF3D", 1), # FULLWIDTH SQUARE BRACKET []
        ("U0-CloseBracket" , "[]"          , 0),
        ("U1-CloseBracket" , "{}"          , 0),
        ("C-U0-Comma"      , "<>"          , 0),
        ("C-U0-Period"     , "</>"         , 0),
        ("U0-Y"            , "\u3008\u3009", 1), # Angle Bracket 〈〉
        ("U1-Y"            , "\u300A\u300B", 1), # Double Angle Bracket 《》
    ]
    for brc in brackets:
        keymap_global[brc[0]] = wrap_with_brackets(brc[1], brc[2])

La spécification de parenthèses spéciales avec des points de code Unicode est une question d'apparence dans l'éditeur. Il n'y a pas de problème avec le send_input (0, [" U0-8 "," "" "," (243) "]) direct.

Entrée directe de symboles

Comme il est rare de saisir des signes de ponctuation, des points de lecture, des deux-points, etc. avec des clés, puis de les convertir davantage, nous permettons de les saisir directement.

Le mécanisme est simple, si vous regardez l'état de l'IME au moment de l'entrée et qu'il est activé, il vous suffit d'appuyer sur Ctrl + M (un raccourci pour confirmer avec la plupart des IME) en plus. IME peut être désactivé automatiquement après avoir tapé des caractères tels que «@» qui sont rarement saisis en japonais.

Il y a une raison pour laquelle Entrée n'est pas confirmée, et c'est un dispositif pour éviter d'appuyer accidentellement sur Entrée alors qu'il est déjà dans l'état d'entrée directe, comme un formulaire de saisie de mot de passe. Cependant, sachez que certains navigateurs ont une fonctionnalité attribuée à Ctrl + M (activer la fonction de désactivation du son dans Firefox). Pour la saisie japonaise de Google, appuyer à nouveau sur la touche demi-largeur / pleine largeur (243) confirme à nouveau le contenu d'entrée à ce moment-là, mais cette méthode est adoptée en tenant compte de la polyvalence.

config.py


    #Entrez directement, que IME soit activé ou désactivé
    def direct_input(key, turnoff_ime_later = False):
        key_list = [key]
        if keymap.getWindow().getImeStatus() == 1:
            key_list.append("C-M")
            if turnoff_ime_later:
                key_list.append("(243)")
        send_input(None, key_list)

    for key in [
        ("AtMark"      , True),
        ("Caret"       , False),
        ("CloseBracket", False),
        ("Colon"       , False),
        ("Comma"       , False),
        ("LS-AtMark"   , True),
        ("LS-Caret"    , False),
        ("LS-Colon"    , False),
        ("LS-Comma"    , False),
        ("LS-Minus"    , False),
        ("LS-Period"   , False),
        ("LS-SemiColon", False),
        ("LS-Slash"    , False),
        ("LS-Yen"      , True),
        ("OpenBracket" , False),
        ("Period"      , False),
        ("SemiColon"   , False),
        ("Slash"       , False),
        ("Yen"         , True),
    ]:
        def _wrapper(k, i):
            return lambda: direct_input(k, i)
        keymap_global[key[0]] = _wrapper(key[0], key[1])

    #Décalage à gauche+Symbole avec touches numériques
    for n in "123456789":
        def _wrapper(k, i):
            return lambda: direct_input(k, i)
        key = "LS-" + n
        if n in ("2", "3", "4"):
            keymap_global[key] = _wrapper(key, True)
        else:
            keymap_global[key] = _wrapper(key, False)

    #Désactivez les IME suivants si vous avez tapé un alphabet supérieur avec un décalage vers la gauche
    for alphabet in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
        def _wrapper(k):
            return lambda: direct_input(k, True)
        key = "LS-" + alphabet
        keymap_global[key] = _wrapper(key)

J'ai appris à créer _wrapper () lors de l'attribution d'une expression lambda dans une boucle sur ce site.

Nous allons permettre de saisir directement d'autres symboles (ce qui suit est un exemple). Puisque l'état IME peut être spécifié avec le premier argument de send_input () ci-dessus, la chaîne de caractères est entrée directement de manière pseudo en sélectionnant "IME off-> character input-> half-width / full-width key press". ..

config.py


    keymap_global["BackSlash"]      = lambda: direct_input("S-BackSlash", False)
    keymap_global["U0-Minus"]       = lambda: send_input(0, ["\u2015\u2015", "(243)"]) # HORIZONTAL BAR * 2
    keymap_global["U1-Minus"]       = lambda: send_input(0, ["Minus"])
    keymap_global["U0-U"]           = lambda: send_input(0, "_")
    keymap_global["U0-Colon"]       = lambda: send_input(0, ["Colon"])
    keymap_global["U0-Comma"]       = lambda: send_input(0, ["\uFF0C", "(243)"]) # FULLWIDTH COMMA ,
    keymap_global["U0-Period"]      = lambda: send_input(0, ["Period"])
    keymap_global["U0-Slash"]       = lambda: send_input(0, ["Slash"])

Entrée de la date

config.py


    def input_date(fmt):
        d = datetime.datetime.today()
        if fmt == "jp":
            date_str = "{}Année{}Mois{}journée".format(d.year, d.month, d.day)
            send_input(0, [date_str, "(243)"])
        else:
            date_str = d.strftime(fmt)
            send_input(0, date_str, 0)
    keymap_global["U1-D"] = keymap.defineMultiStrokeKeymap("date format: 1=>YYYYMMDD, 2=>YYYY/MM/DD, 3=>YYYY.MM.DD, 4=>YYYY-MM-DD, 5=>AAAA MM mois JJ jour")
    keymap_global["U1-D"]["1"] = lambda: input_date(r"%Y%m%d")
    keymap_global["U1-D"]["2"] = lambda: input_date(r"%Y/%m/%d")
    keymap_global["U1-D"]["3"] = lambda: input_date(r"%Y.%m.%d")
    keymap_global["U1-D"]["4"] = lambda: input_date(r"%Y-%m-%d")
    keymap_global["U1-D"]["5"] = lambda: input_date("jp")

Efficacité de divers travaux quotidiens

config.py


    #Coller en texte brut
    keymap_global["U0-V"] = lambda: paste_string(get_clippedText())

    #Supprimer l'espace blanc et coller en texte brut
    keymap_global["U1-V"] = lambda: paste_string(re.sub(r"\s", "", get_clippedText()))

    #IME désactivé maman Lorsque vous tapez, sélectionnez le dernier mot et IME activé
    keymap_global["U1-Space"] = lambda: send_input(1, ["C-S-Left"])

    #Ouvrez l'URL sélectionnée
    def open_url():
        url = (copy_string()).strip()
        if url.startswith("http"):
            run_url = url
        elif url.startswith("file:///"):
            local_path = url.replace("file:///", "")
            local_path = urllib.parse.unquote(local_path)
            if not os.path.exists(local_path):
                return None
            run_url = local_path
        else:
            return None
        keymap.ShellExecuteCommand("open", run_url, None, None)()
    keymap_global["D-U0-O"] = open_url

    #Entrez à nouveau la demi-largeur alphanumérique sélectionnée avec IME activé
    def re_input_as_kana():
        origin = get_clippedText()
        if origin:
            setClipboardText("")
        selection = copy_string(0.1)
        if selection:
            key_list = []
            noblank = re.sub(r"\s", "", selection)
            for k in noblank:
                if k == "-":
                    key_list.append("Minus")
                else:
                    key_list.append(k)
            send_input(1, key_list, 0)
        if origin:
            setClipboardText(origin)
    keymap_global["U1-I"] = re_input_as_kana

Système de recherche Web

Si vous appuyez sur la touche après aucune conversion + S dans l'état sélectionné, elle sera recherchée par différents moteurs (si elle n'est pas copiée correctement, elle sera recherchée par la chaîne de caractères qui était dans le clip juste avant).

Maintenez la touche Maj enfoncée tout en appuyant sur la deuxième touche pour rechercher des mots-clés en plaçant chaque mot entre guillemets, et maintenez la touche Ctrl enfoncée pour rechercher en effaçant hiragana.

À moins que vous ne recherchiez des mots-clés avec Shift, nous essayons de convertir des contrats tels que des virgules en espaces, donc ce n'est pas grave si la sélection de chaîne de caractères est un peu appropriée.

config.py


    def quote_each_word(s):
        ret = []
        for w in re.split(r"\s+", s):
            ret.append('"{}"'.format(w))
        return " ".join(ret)

    def punctuation_to_space(s):
        ret = re.sub(r"[\W_]+", " ", s)
        return ret.strip()

    def search_on_web(URLstr, mode = None):
        selection = copy_string(0.1)
        if len(selection) < 200:
            single_spaced = (re.sub(r"\s+", " ", selection)).strip()
            if mode == "strict":
                search_str = quote_each_word(single_spaced)
            else:
                search_str = punctuation_to_space(single_spaced)
                if mode == "without_hira":
                    search_str = re.sub(r"[Ah-Hmm]+", " ", search_str)
                    search_str = re.sub(r"\s+", " ", search_str)
                    search_str = search_str.strip()
            encoded = urllib.parse.quote(search_str)
            keymap.ShellExecuteCommand("open", URLstr + encoded, None, None)()

    engine_url = [
        ("A", r"https://www.amazon.co.jp/s?i=stripbooks&k="),
        ("C", r"https://ci.nii.ac.jp/books/search?q="),
        ("E", r"http://webcatplus.nii.ac.jp/pro/?q="),
        ("G", r"http://www.google.co.jp/search?q="),
        ("I", r"https://www.google.com/search?tbm=isch&q="),
        ("M", r"https://www.google.co.jp/maps/search/"),
        ("N", r"https://iss.ndl.go.jp/books?any="),
        ("O", r"https://map.goo.ne.jp/search/q/"),
        ("S", r"https://scholar.google.co.jp/scholar?q="),
        ("T", r"https://twitter.com/search?f=live&q="),
        ("Y", r"http://www.google.co.jp/search?tbs=li:1&q=site%3Ayuhikaku.co.jp%20intitle%3A"),
        ("W", r"https://www.worldcat.org/search?q="),
    ]
    mode_modifier = [
        (""  , None),
        ("S-", "strict"),
        ("C-", "without_hira"),
    ]

    keymap_global["U0-S"] = keymap.defineMultiStrokeKeymap('S-:quote-each, C-:without-hiragana')
    for e in engine_url:
        for m in mode_modifier:
            search_key = m[0] + e[0]
            engine_url = e[1]
            mode = m[1]
            def _wrapper(url, md):
                return lambda: search_on_web(url, md)
            keymap_global["U0-S"][search_key] = _wrapper(engine_url, mode)

Recherche Google de n'importe où

Sans conversion + Q, activez la fenêtre chrome si elle est ouverte et ouvrez un nouvel onglet, sinon lancez chrome.

```config.py`


    def find_window(arg_exe, arg_class):
        wnd = pyauto.Window.getDesktop().getFirstChild()
        last_found = None
        while wnd:
            if wnd.isVisible() and not wnd.getOwner():
                if wnd.getClassName() == arg_class and wnd.getProcessName() == arg_exe:
                    last_found = wnd
            wnd = wnd.getNext()
        return last_found

    def google_search():
        if keymap.getWindow().getProcessName() == "chrome.exe":
            send_input(1, ["C-T", "C-K"])
        else:
            wnd = find_window("chrome.exe", "Chrome_WidgetWin_1")
            if wnd:
                send_input(1, ["C-LWin-1", "C-T", "C-K"], 0.05)
            else:
                send_input(1, ["LWin-1"])
    keymap_global["U0-Q"] = google_search

Lorsque j'ai essayé d'activer la fenêtre avec le ʻActivateWindowCommand () `fourni, le phénomène selon lequel" la barre des tâches clignote uniquement et ne passe pas au premier plan "s'est produit à une fréquence qui ne peut être ignorée, alors appelez le chrome enregistré dans la barre des tâches avec le numéro Win +. Je le fais. (Si la fenêtre peut être amenée de force et sûrement au premier plan par le programme, elle peut être utilisée pour des virus malveillants, c'est donc inévitable pour la sécurité)

Il existe également une méthode appelée pyauto.Window.find () qui identifie la fenêtre, mais seul le nom de la classe peut être spécifié comme argument. Les applications Chrome telles que slack et vscode qui ont une classe de fenêtre de Chrome_WidgetWin_1 ne peuvent pas être identifiées à partir de chrome, j'ai donc essayé de parcourir la fenêtre ouverte et de rechercher.


Le simple fait d'ajouter un commentaire au contenu de la vie quotidienne l'a rendu assez long ...

En plus de cela, je personnalise diverses choses telles que le traitement et le collage de la chaîne de caractères du presse-papiers, l'activation d'une fenêtre spécifique, la manipulation de la taille de la fenêtre, etc. Je vais le résumer dans un autre article (si je suis motivé).

Recommended Posts

Résumé des paramètres personnels de keyhac
Résumé de la configuration personnelle d'Ubuntu et WSL2
[Linux] [Réglage initial] [Flutter] Résumé
Résumé des paramètres de connexion proxy
Résumé personnel de Jupyter Notebook Magic Command
Résumé personnel de l'outil de gestion de packages Python
Résumé des paramètres liés aux fichiers statiques (statiques) de Django