# jsc modified with some voice-code compatibility
"righty (click | chirff)": right_click,
"righty press": Key("shift-f10"),
"(click | chiff)": click,
"(dubclick | duke)": dubclick,
"(tripclick | triplick)": tripclick,
"drag": mouse_drag,
"drag release": mouse_release,
"control click": control_click,
"shift click": shift_click,
# "(command click | chom lick)": command_click,
"(control shift click | troll shift click)": control_shift_click,
"(control shift double click | troll shift double click)": lambda m: control_shift_click(
m, 0, 2
),
"do park": [dubclick, Key("ctrl-v")],
"do koosh": [dubclick, Key("ctrl-c")],
# "wheel down": mouse_smooth_scroll(250),
# "wheel up": mouse_smooth_scroll(-250),
# "wheel down here": [mouse_center, mouse_smooth_scroll(250)],
# "wheel up here": [mouse_center, mouse_smooth_scroll(-250)],
"mouse center": mouse_center,
"mouse {mouse.regions} half": mouse_place("half"),
"mouse {mouse.regions} [full]": mouse_place("full"),
"move {mouse.regions} (one | 1)": mouse_move_pixels("one"),
"move {mouse.regions} ten": mouse_move_pixels("ten"),
"move {mouse.regions} hundred": mouse_move_pixels("hundred"),
}
ctx.set_list("regions", regions.keys())
ctx.keymap(keymap)
<tr><td class="pick">🔊 yeller [number]</td><td>make a selection and uppercase it</td></tr>
<tr><td class="pick">🔊 lower [number]</td><td>make a selection and lowercase it</td></tr>
<tr><td colspan="2" class="pick cancel">🔊 cancel</td></tr>
</table>
</div>
""")
def homophones_help(m):
webview.render(help_template)
webview.show()
keymap = {"(cancel | exit)": lambda x: close_homophones()}
pick_context.keymap(keymap)
pick_context.load()
context.keymap({
"phones help":
homophones_help,
"phones {basic_keys.digits}* {homophones.canonical}":
raise_homophones,
"phones {basic_keys.digits}*":
lambda m: raise_homophones(m, is_selection=True),
"force phones {homophones.canonical}":
lambda m: raise_homophones(m, force_raise=True),
"force phones":
lambda m: raise_homophones(m, force_raise=True, is_selection=True),
})
context.set_list("canonical", canonical)
'tilde': '~',
'(bang | exclamation point)': '!',
'dollar [sign]': '$',
'downscore': '_',
'colon': ':',
'(paren | left paren)': '(',
'(rparen | are paren | right paren)': ')',
'(brace | left brace)': '{',
'(rbrace | are brace | right brace)': '}',
'(angle | left angle | less than)': '<',
'(rangle | are angle | right angle | greater than)': '>',
'(star | asterisk)': '*',
'hash [sign]': '#',
'percent [sign]': '%',
'caret': '^',
'at sign': '@',
'(and sign | ampersand | amper)': '&',
'pipe': '|',
'power to sign': '^',
'(dubquote | double quote)': '"',
'triple quote': "'''",
'back tick': '`',
'elipsis': ['...'],
})
ctx.set_list('alphabet', alphabet.keys())
ctx.set_list('arrows', arrows.keys())
ctx.set_list('digits', digits.keys())
ctx.set_list('keys', keys.keys())
ctx.set_list('modifiers', modifiers.keys())
ctx.set_list('keymap', keymap.keys())
from talon.voice import Context, Key
import string
from ..utils import insert
# upper_alphabet_words = "append backer change delete ender finder gutter high insert join keyword lower middle next open paste command replace sneaker teeter undo visual wordy exit yanker zoink"
upper_alphabet_words = "ash baker chain dog egg fox gig horse ice jake king lash mule net oak page quail raft scout tide use vessel winch xray yacht zoo"
alphabet_upper = dict(zip(upper_alphabet_words.split(),
string.ascii_uppercase))
print(alphabet_upper)
def upper(m):
s = m['uppercase.alphabet_upper']
c = str(alphabet_upper[s[0]])
insert(c)
# ctx = Context("uppercase", bundle="org.vim.MacVim")
ctx = Context("uppercase")
ctx.keymap({
"{uppercase.alphabet_upper}": upper,
})
ctx.set_list('alphabet_upper', alphabet_upper)
print(keys)
return keys
except Exception as e:
# print(e)
return []
def dump(self):
resource.write(warps_file, json.dumps(self.data, indent=2))
mj = MouseWarp()
ctx = Context("warp")
ctx.keymap({
"mark <dgndictation> [over]": [
lambda m: mj.mark(utils.join_words(utils.parse_words(m))),
lambda _: ctx.set_list("warps", mj.warps()),
],
"warp {warp.warps}": [lambda m: mj.warp(m["warp.warps"][0])],
"clear warp {warp.warps} [over]":
[lambda m: mj.delete(m["warp.warps"][0])],
"list warps": [
lambda _: app.notify("Warps:", ", ".join(mj.warps())),
lambda _: ctx.set_list("warps", mj.warps()),
],
"click {warp.warps}": [
lambda m: mj.warp(m["warp.warps"][0]),
lambda _: ctrl.mouse_click(button=0),
],
})
"copy word right":
extendable("shift-alt-right cmd-c"),
"copy way left":
extendable("cmd-shift-left cmd-c"),
"copy way right":
extendable("cmd-shift-right cmd-c"),
"copy way up":
extendable("cmd-shift-up cmd-c"),
"copy way down":
extendable("cmd-shift-down cmd-c"),
# Cutting
"cut phrase": [utils.select_last_insert,
Key("cmd-x")],
"cut all": [Key("cmd-a cmd-x")],
"cut line":
extendable("cmd-left cmd-left cmd-shift-right cmd-x cmd-right"),
"cut word left":
extendable("shift-alt-left cmd-x"),
"cut word right":
extendable("shift-alt-right cmd-x"),
"cut way left":
extendable("cmd-shift-left cmd-x"),
"cut way right":
extendable("cmd-shift-right cmd-x"),
"cut way up":
extendable("cmd-shift-up cmd-x"),
"cut way down":
extendable("cmd-shift-down cmd-x"),
})
ctx.set_list("alphabet", alphabet.keys())
websites = {
'calendar': 'https://calendar.google.com',
'facebook': 'https://facebook.com',
'twitter': 'https://twitter.com',
'trello': 'https://trello.com',
'gmail': 'https://gmail.com',
'get hub': 'https://github.com',
'reddit': 'https://reddit.com',
'talon docs': 'https://github.com/dwighthouse/unofficial-talonvoice-docs',
'talon official docs': 'https://talonvoice.com/docs/index.html',
}
context = Context('GoogleChrome', bundle='com.google.Chrome')
context.set_list('websites', websites.keys())
def open_website(m):
name = str(m._words[1])
w = websites.get(name)
code = r'''
tell application "Google Chrome"
if title of active tab of window 1 is "New Tab" then
set t to active tab of window 1
else
set t to make new tab at end of tabs of window 1
end if
set URL of t to "%s"
end tell
''' % w
}
for action in ("get", "delete", "describe"):
for object in ("nodes", "jobs", "pods", "namespaces", "services", ""):
if object:
object = object + " "
command = f"{KUBERNETES_PREFIX} {action} {object}"
typed = f"kubectl {action} {object}"
keymap.update({command: typed})
keymap.update(
{"(pain | bang) " + str(i): Key("alt-" + str(i))
for i in range(10)})
ctx.keymap(keymap)
ctx.set_list("directory_shortcuts", directory_shortcuts.keys())
def shell_rerun(m):
# switch_app(name='iTerm2')
app = ui.apps(bundle="com.googlecode.iterm2")[0]
ctrl.key_press("c", ctrl=True, app=app)
time.sleep(0.05)
ctrl.key_press("up", app=app)
ctrl.key_press("enter", app=app)
global_ctx = Context("global_terminal")
global_ctx.keymap({"shell rerun": shell_rerun})
# module.exports = {
# permissions: "chmod "
"shell make": "make\n",
"shell jobs": "jobs\n",
}
for action in ("get", "delete", "describe"):
for object in ("nodes", "jobs", "pods", "namespaces", "services", "events", ""):
if object:
object = object + " "
command = f"{KUBERNETES_PREFIX} {action} {object}"
typed = f"kubectl {action} {object}"
keymap.update({command: typed})
keymap.update({"(pain | bang) " + str(i): Key("alt-" + str(i)) for i in range(10)})
ctx.keymap(keymap)
ctx.set_list("directory_shortcuts", directory_shortcuts.keys())
# ctx.set_list("servers", servers.keys())
def shell_rerun(m):
# switch_app(name='iTerm2')
app = ui.apps(bundle="com.googlecode.iterm2")[0]
ctrl.key_press("c", ctrl=True, app=app)
time.sleep(0.05)
ctrl.key_press("up", app=app)
ctrl.key_press("enter", app=app)
global_ctx = Context("global_terminal")
global_ctx.keymap(
{"shell rerun": shell_rerun, "shell server {global_terminal.servers}": name_servers}
def shell_rerun(m):
# switch_app(name='iTerm2')
app = ui.apps(bundle="com.googlecode.iterm2")[0]
ctrl.key_press("c", ctrl=True, app=app)
time.sleep(0.05)
ctrl.key_press("up", app=app)
ctrl.key_press("enter", app=app)
global_ctx = Context("global_terminal")
global_ctx.keymap({
"SHE rerun": shell_rerun,
"SHE server {global_terminal.servers}": name_servers
})
global_ctx.set_list("servers", servers.keys())
# module.exports = {
# permissions: "chmod "
# access: "chmod "
# ownership: "chown "
# "change own": "chown "
# "change group": "chgrp "
# cat: "cat "
# chat: "cat " # dragon doesn't like the word 'cat'
# copy: "cp "
# "copy recursive": "cp -r "
# move: "mv "
# remove: "rm "
# "remove recursive": "rm -rf "
# "remove directory": "rmdir "
# "make directory": "mkdir "
"lint (next | neck)": command("linter ui default: next in current file"),
"lint (preev | previous)": command("linter ui default: previous in current file"),
# atom-isort
"sort imports": command("atom isort sort imports"),
# atom-blacken
"(atom | adam) black": command("atom blacken"),
# platformio-ide-terminal
"(platform | terminal | termy | termie) new": command("platformio new"),
"(platform | terminal | termy | termie) (toggle | switch)": command(
"platformio toggle"
),
"(platform | terminal | termy | termie) (previous | preev)": command(
"platformio prev"
),
"(platform | terminal | termy | termie) next": command("platformio next"),
"(platform | terminal | termy | termie) (cell | sell)": command(
"platformio insert selected"
),
"(platform | terminal | termy | termie) close": command("platformio close"),
"(platform | terminal | termy | termie) close all": command("platformio close all"),
# atom-script
"(code | script) (run | sprint | go)": command("script run"),
"script close": command("script close view"),
"(code | script) kill": Key("ctrl-q"),
"(rep | rap | wrap) (toggle | switch)": command("toggle soft wrap"),
# bookmark
"(bookmark | mark) toggle": command("bookmark toggle"),
}
ctx.set_list("snippets", snippets.keys())
ctx.keymap(keymap)
'play': 'play',
'pause': 'play',
'stop': 'stop',
'quieter': 'volumeDown\n' * 2,
'louder': 'volumeUp\n' * 2,
'way quieter': 'volumeDown\n' * 6,
'way louder': 'volumeUp\n' * 6,
'focus': lambda: app().focus(),
}
def cmd(self, cmd):
ret = applescript.run(f'tell application "VLC"\n{cmd}\nend tell')
if ret:
return ffi.string(ret).decode('utf8')
def __call__(self, m):
cmd = str(m['vlc.commands'][0])
action = self.commands[cmd]
if isinstance(action, str):
self.cmd(action)
else:
action()
vlc = VLC()
ctx = Context('vlc') # , bundle=BUNDLE)
ctx.keymap({
'video {vlc.commands}': vlc,
})
ctx.set_list('commands', vlc.commands.keys())
from talon.voice import Context, Key
from .. import utils
def pick(m):
try:
index = utils.ordinal_indexes[m["picker.ordinal"][0]]
Key("down " * index + "enter")(m)
except:
pass
ctx = Context("picker")
ctx.keymap({"pick {picker.ordinal}": pick})
ctx.set_list("ordinal", utils.ordinal_indexes.keys())
"paste": Key("ctrl-v"),
# "menu help": Key("cmd-shift-?"),
"spotlight": Key(
"win-s"
), # spotlight search bar in mac corresponding to windows search bar
"(undo | under | skunks)": Key("ctrl-z"),
"redo": Key("ctrl-shift-z"),
"(crap | clear | scratch )": Key("ctrl-backspace"),
"(select | sell | cell) all": Key("ctrl-a"),
# "more bright": Key("brightness_up"),
# "less bright": Key("brightness_down"),
# "volume up": Key("volume_up"),
# "volume down": Key("volume_down"),
# "mute": Key("mute"),
# "play next": Key("next"),
# "play previous": Key("previous"),
# "(play | pause)": Key("space"), # spotify
"(wipe | vipe)": Key("backspace"),
"(pad | padding ) ": [" ", Key("left")],
"funny": "haha",
"arch hive": Key(key_pressify_string("arxiv")),
# "menubar": Key("ctrl-f2"),
# "status menu": Key("ctrl-f8"),
# "my doc": Key("ctrl-f3"),
"{standard.vocab}": inputs_vocab,
}
)
ctx.set_list("vocab", vocab)
ctx.keymap(keymap)
keymap = {
"{mouseSnapNine.digits}+":
narrow,
"(oops | back)":
mg.go_back,
"(reset | clear | escape)":
mg.reset,
"done": [
mg.stop, lambda _: ctx.unload(), lambda _: speech.set_enabled(True),
lambda _: click()
],
"exit":
[mg.stop, lambda _: ctx.unload(), lambda _: speech.set_enabled(True)],
}
ctx.keymap(keymap)
ctx.set_list("digits", digits.keys())
group.load()
ctx.unload()
startCtx = Context("mouseSnapNineStarter")
startCtx.keymap({
"(grid | mouse grid | mousegrid)": [
mg.reset, mg.start, lambda _: ctx.load(),
lambda _: speech.set_enabled(False)
],
# "snap done": [mg.stop, lambda _: ctx.unload()],
})
# mg.start()
# Hot reload while grid is active is very confusing without this.
speech.set_enabled(True)
def global_go_to_webpage(m):
switcher.switch_app(name="Google Chrome")
new_tab_go_to_webpage(m)
def global_chrome_close_tab(m):
current_app = ui.active_window().app
switcher.switch_app(name="Google Chrome")
press("cmd-w")
current_app.focus()
# app = ui.apps(bundle="com.google.Chrome")[0]
# ctrl.key_press("w", cmd=True, app=app)
global_ctx = Context("global_browser")
global_ctx.set_list("webpages", webpages.keys())
global_ctx.set_list("searches", searches.keys())
global_ctx.keymap({
"chrome new tab":
global_chrome_new_tab,
"chrome new [tab] {global_browser.webpages}":
global_go_to_webpage,
"chrome close tab":
global_chrome_close_tab,
"chrome search [<dgndictation>]": [global_chrome_new_tab, utils.text, " "],
"chrome lucky [<dgndictation>]": [
global_chrome_new_tab,
"lucky ",
utils.text,
" ",
],
def ordinal(n):
"""
Convert an integer into its ordinal representation::
ordinal(0) => '0th'
ordinal(3) => '3rd'
ordinal(122) => '122nd'
ordinal(213) => '213th'
"""
n = int(n)
suffix = ["th", "st", "nd", "rd", "th"][min(n % 10, 4)]
if 11 <= (n % 100) <= 13:
suffix = "th"
return str(n) + suffix
for n in range(2, 11):
ordinals[ordinal(n)] = n - 1
ctx.set_list("ordinals", ordinals.keys())
def repeat(m):
o = m["repeater.ordinals"][0]
repeater = Rep(int(ordinals[o]))
repeater.ctx = talon
return repeater(None)
ctx.keymap({"{repeater.ordinals}": repeat})
new = {}
for base in "/Applications", "/Applications/Utilities":
for name in os.listdir(base):
path = os.path.join(base, name)
name = name.rsplit(".", 1)[0]
new[name] = path
words = name.split(" ")
for word in words:
if word and word not in new:
if len(name) > 6 and len(word) < 3:
continue
new[word] = path
launch = new
ctx.set_list("launch", launch.keys())
def ui_event(event, arg):
if event in ("app_activate", "app_launch", "app_close", "win_open",
"win_close"):
# print(event, arg)
if event in ("win_open", "win_closed"):
if arg.app.name == "Amethyst":
return
update_lists()
# ui.register("", ui_event)
# update_lists()
ctx.set_list("running", hardcoded_application_names)
push_loc,
idea_psi("select"),
utils.delay(0.2),
idea("action Refactorings.QuickListPopupAction"),
],
"rename [{jetbrains.ordinal}] {jetbrains.path}": [
push_loc,
idea_psi("select"),
utils.delay(0.2),
idea("action RenameElement"),
],
"select [{jetbrains.ordinal}] {jetbrains.path}": [
push_loc, idea_psi("select")
],
"clear [{jetbrains.ordinal}] {jetbrains.path}": [
push_loc,
idea_psi("select"),
idea("action EditorDelete"),
],
"add {jetbrains.path} [<dgndictation>] [over]": [
push_loc, idea_psi_and_snippet()
],
}
ctx.keymap(keymap)
ctx.set_list("alphabet", alphabet.keys())
ctx.set_list("ordinal", utils.ordinal_indexes.keys())
ctx.set_list("path", PSI_PATHS.keys())
# group.load()
"switch [header] source":
command("switch header source"),
# treeview
"(tree [view] rename | rename file)":
command("tree view rename"),
# linter
"lint (next | neck)":
command("linter ui default: next in current file"),
"lint (prev | previous)":
command("linter ui default: previous in current file"),
# atom-isort
"sort imports":
command("atom isort sort imports"),
# editor
"move line up":
command("editor: move line up"),
"move line down":
command("editor: move line down"),
"move [current line] [to] line" + numerals:
move_to_line,
}
ctx.set_list("snippets", set(snippets.keys()) - set(snippet_formatters.keys()))
ctx.set_list("snippets_with_formatter", snippet_formatters.keys())
ctx.keymap(keymap)
"""
ideal AST navigation and manipulation
syntax_node_type := (function | method | class | if | statement | call | for | loop | with | number | ...)
(go (start | end) | select | copy | cut | delete) [(inside | all)] [(next | prev)] {syntax_node_type}
"""
press(k)
ctx = Context("basic_keys")
ctx.keymap({
"sky {basic_keys.alphabet}+ [(lowercase | sunk)]":
uppercase_letters,
"{basic_keys.modifiers}* {basic_keys.alphabet}+":
press_keys,
"{basic_keys.modifiers}* {basic_keys.digits}+":
press_keys,
"{basic_keys.modifiers}* {basic_keys.keys}+":
press_keys,
"(go | {basic_keys.modifiers}+) {basic_keys.arrows}+":
press_keys,
"number {basic_keys.digits}+ [over]":
press_keys,
"day " + optional_numerals:
repeat_function(1, "backspace"),
"(scrap | delete) " + optional_numerals:
repeat_function(1, "delete"),
"tabback":
Key("shift-tab"),
})
ctx.set_list("alphabet", alphabet.keys())
ctx.set_list("digits", digits.keys())
ctx.set_list("keys", keys.keys())
ctx.set_list("arrows", arrows.keys())
ctx.set_list("modifiers", modifiers.keys())
ctx.set_list("keymap", keymap.keys())
"painter text blue": ["\\textcolor{blue}{}", Key('left')],
"painter text green": ["\\textcolor{green}{}", Key('left')],
# new environments
"new {latex.environments}": new_environment,
"new <word> environment": new_custom_environment,
# greek letters
"(greek | greco) {basic_keys.alphabet}": greek,
"upper (greek | greco) {basic_keys.alphabet}": upper_greek,
"{basic_keys.digits} pie": number_pi,
# TODO: define a function that references the names of the Greek letters directly
# label and reference commands
"label {latex.label_reference_commands}": label_command,
"reference {latex.label_reference_commands}": reference_command,
"label equation": ["\\label{eq:}", Key('left')],
"reference equation": ["\\eqref{eq:}", Key('left')],
"clever reference on": lambda m: clever_reference_on(),
"clever reference off": lambda m: clever_reference_off(),
"citation": ["\\cite{}", Key("left")],
}
)
ctx.set_list('greek_alphabet', greek_letter_mappings.values())
ctx.set_list('environments', environments)
ctx.set_list('delimiters', delimiters)
ctx.set_list('zero_parameter_commands', zero_parameter_commands)
ctx.set_list('single_parameter_commands', single_parameter_commands)
ctx.set_list('label_reference_commands', label_reference_commands)
def move_win_left_space(m):
with drag_window():
press("ctrl-cmd-alt-left")
def move_win_right_space(m):
with drag_window():
press("ctrl-cmd-alt-right")
def window_move_space(m):
desktop_number = NAMED_DESKTOPS[m["spaces.named_desktops"][0]]
with drag_window():
press(f"ctrl-{desktop_number}")
def desk(m):
desktop_number = NAMED_DESKTOPS[m["spaces.named_desktops"][0]]
press(f"ctrl-{desktop_number}")
# cron.after('300ms', last_phrase.history.refresh)
keymap = {
"window move (space | desk) {spaces.named_desktops}": window_move_space,
"desk {spaces.named_desktops}": desk,
}
ctx = Context("spaces")
ctx.keymap(keymap)
ctx.set_list("named_desktops", NAMED_DESKTOPS.keys())
ctx.keymap({
"dot pie": ".py",
"dot pipe": ".py",
"star (arguments | args)": "*args",
"star star K wargs": "**kwargs",
"raise value error": ["raise ValueError()",
Key("left")],
"raise not implemented error": "raise NotImplementedError()",
"raise {global_python.exception}": raise_exception,
# for when using jupyter, not in a .py file
"toggle jupey": toggle_enabled(),
"toggle jupey on": toggle_enabled("on"),
"toggle jupey off": toggle_enabled("off"),
})
ctx.set_list("exception", exceptions.keys())
def enable_python(appl, window):
return is_filetype(FILETYPES)(appl, window) or config.enabled
# TODO: fix these so they're still useful but don't conflict with vim so much
ctx2 = Context("python", func=enable_python)
ctx2.keymap({
# Statements
"state (def | deaf | deft)":
"def ",
"state if":
"if ",
"state elif":
}
)
keymap.update(
{
"lower %s" % (i + 1): lambda m: make_selection(m, is_selection, lowercase)
for i in valid_indices
}
)
pick_context.keymap(keymap)
pick_context.load()
# keymap = {
# # Usage:
# # 'homophones word' to look up those homophones.
# # when the list pops up, say appropriate number or zero
# # (leave and do nothing).
# # can also call 'homophones' without any arguments.
# # it will look at the selected text and look that up.
# # 'phones [<dgndictation>]': raise_homophones,
# # 'force phones [<dgndictation>]': lambda m: raise_homophones(m, True),
# }
context.keymap({
'phones {homophones.canonical}': raise_homophones,
'phones': lambda m: raise_homophones(m, is_selection=True),
'force phones {homophones.canonical}': lambda m: raise_homophones(m, force_raise=True),
'force phones': lambda m: raise_homophones(m, force_raise=True, is_selection=True),
})
context.set_list('canonical', canonical)
for n in range(10, 20, 1):
numeral_map[str(n)] = n
if INCLUDE_TENS_IN_NUMERALS:
for n in range(20, 101, 10):
numeral_map[str(n)] = n
for n in range(100, 1001, 100):
numeral_map[str(n)] = n
for n in range(1000, 10001, 1000):
numeral_map[str(n)] = n
numeral_map["oh"] = 0 # synonym for zero
numeral_map["and"] = None # drop me
numeral_list = sorted(numeral_map.keys())
ctx = Context("n")
ctx.set_list("all", numeral_list)
numerals = " {n.all}+"
optional_numerals = " {n.all}*"
def text_to_number(words):
tmp = [str(s).lower() for s in words]
words = [parse_word(word) for word in tmp]
result = 0
factor = 1
for word in reversed(words):
if word not in numeral_list:
raise Exception("not a number: {}".format(words))
number = numeral_map[word]
# https://github.com/JonathanNickerson/talon_voice_user_scripts
import time
import talon.clip as clip
from talon.voice import Key, press, Str, Context
from ..utils import (
parse_words,
join_words,
is_not_vim,
numeral_list,
extract_num_from_m,
)
ctx = Context("generic_editor", func=is_not_vim)
ctx.set_list("n", numeral_list)
def find_next(m):
press("cmd-f")
Str(str(m.dgndictation[0]._words[0]))(None)
press("escape")
def find_previous(m):
press("left")
press("cmd-f")
Str(str(m.dgndictation[0]._words[0]))(None)
press("cmd-shift-g")
press("escape")
# create the commands to navigate through pages
for idx, items in enumerate(pages):
keymap.update({
"page " + str(idx + 1):
create_render_page(
templates["commands"],
context_name=context.name,
mapping=items,
current_page=idx + 1,
total_pages=len(pages),
)
})
render_webview(
templates["commands"],
keymap,
context_name=context.name,
mapping=(pages[target_page - 1] if pages else []),
current_page=target_page,
total_pages=len(pages),
)
keymap = {
"help alphabet": render_alphabet_help,
"help [commands] {help.contexts}": render_commands_help,
"help context": render_contexts_help,
}
ctx.set_list("contexts", contexts().keys())
ctx.keymap(keymap)
def uppercase_letters(m):
insert("".join(get_keys(m)).upper())
def press_keys(m):
mods = get_modifiers(m)
keys = get_keys(m)
if mods:
press("-".join(mods + [keys[0]]))
keys = keys[1:]
for k in keys:
press(k)
ctx = Context("basic")
ctx.keymap(
{
"(uppercase | ship) {basic.alphabet}+ [(lowercase | sunk)]": uppercase_letters,
"{basic.modifiers}* {basic.alphabet}+": press_keys,
"{basic.modifiers}* {basic.digits}+": press_keys,
"{basic.modifiers}* {basic.keys}+": press_keys,
"(go | {basic.modifiers}+) {basic.arrows}+": press_keys,
}
)
ctx.set_list("alphabet", alphabet.keys())
ctx.set_list("arrows", arrows.keys())
ctx.set_list("digits", digits.keys())
ctx.set_list("keys", keys.keys())
ctx.set_list("modifiers", modifiers.keys())
context = Context("registers")
regs = {str(i): i for i in range(10)}
global regs_list
regs_list = [str(i) for i in range(10)]
def send_clip_to_register(m):
press("ctrl-c")
cur_reg = int(m._words[-1])
regs_list[cur_reg] = clip.get()
# print(regs_list)
def paste_from_register(m):
cur_reg = int(m._words[-1])
reg_contents = regs_list[cur_reg]
print(reg_contents)
Str(reg_contents)(None)
keymap = {
"(copy | send) (register | reggie) {registers.regs}": send_clip_to_register,
"(paste | stick) (register | reggie) {registers.regs}": paste_from_register,
}
context.set_list("regs", regs.keys())
context.keymap(keymap)