Si je pouvais en apporter un seul sur une île inhabitée, j'apporterais keyhac.
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.
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}.
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)
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"
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).
Utilisez la fonction send_input () ci-dessus pour réduire le plus possible l'effort de saisie de caractères.
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.
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"])
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")
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
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)
Sans conversion + Q, activez la fenêtre chrome si elle est ouverte et ouvrez un nouvel onglet, sinon lancez chrome.
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