def replay_save(choice: int):
"""Save the selected recording to a preconfigured directory"""
global rr
file_name = rr.save_recording_by_index(choice)
if not file_name:
return
if settings.get("user.replay_paste_name_on_save") != 0:
clip.set_text(file_name)
actions.user.insert_cursor_paste('"[|]":', "")
def code_public_function(text: str):
result = "def {}():".format(
actions.user.formatted_text(
text, settings.get("user.code_public_function_formatter")
)
)
actions.user.paste(result)
actions.edit.left()
actions.edit.left()
def __init__(self, count=30):
"""Specify the number of default recording to list in the picker"""
self.gui_open = False
self.recordings_list = []
self.count = count
self.recordings = pathlib.Path(TALON_HOME, "recordings/")
self.last_saved_recording = None
if settings.get("speech.record_all") != 1:
app.notify("Recording appears to be disabled")
def code_private_function(text: str):
"""Inserts private function declaration"""
result = "def _{}():".format(
actions.user.formatted_text(
text, settings.get("user.code_private_function_formatter")))
actions.user.paste(result)
actions.edit.left()
actions.edit.left()
def wait_mode_change(self, wanted):
timeout = settings.get("user.vim_mode_change_timeout")
if self.nvrpc.init_ok:
while wanted != self.nvrpc.get_active_mode()["mode"][0]:
print("%s vs %s" %
(wanted, self.nvrpc.get_active_mode()["mode"]))
time.sleep(0.01)
else:
time.sleep(timeout)
def code_default_function(text: str):
"""Inserts function definition"""
result = "function {} {{".format(
actions.user.formatted_text(
text, settings.get("user.code_public_function_formatter")))
actions.insert("\n\n}")
actions.key("up:2")
actions.user.code_insert_function(result, None)
def code_private_function_async(text: str):
"""Inserts async private function declaration"""
result = "async {}".format(
actions.user.formatted_text(
text, settings.get("user.code_private_function_formatter")
)
)
actions.user.code_insert_function(result, None)
def code_private_static_function(text: str):
"""Inserts private static function"""
result = "private static void {}".format(
actions.user.formatted_text(
text, settings.get("user.code_private_function_formatter")
)
)
actions.user.code_insert_function(result, None)
def get_file_map(current_path):
files = [
f.name
for f in islice(current_path.iterdir(),
settings.get("user.file_manager_file_limit", 1000))
if f.is_file()
]
spoken_forms = create_spoken_forms([p for p in files])
return dict(zip(spoken_forms, [f for f in files]))
def replay_save_last_played():
"""Insert some info from the last self.count recordings"""
global rr
file_name = rr.save_last_played()
if not file_name:
return
if settings.get("user.replay_paste_name_on_save") != 0:
clip.set_text(file_name)
actions.user.insert_cursor_paste('"[|]":', "")
def code_public_function(text: str):
result = "function {}".format(
actions.user.formatted_text(
text, settings.get("user.code_public_function_formatter")
)
)
actions.insert("\n\nend")
actions.key("up:2")
actions.user.code_insert_function(result, None)
def code_default_function(text: str):
"""Inserts function definition"""
result = "def {}".format(
actions.user.formatted_text(
text,
settings.get("user.code_public_function_formatter")
)
)
actions.user.paste(result)
def get_file_map(current_path):
files = [
f.name
for f in islice(current_path.iterdir(),
settings.get("user.file_manager_file_limit", 1000))
if is_file(f)
]
files.sort(key=str.casefold)
return actions.user.create_spoken_forms_from_list(
files, words_to_exclude=words_to_exclude)
def mouse_scroll_up_continuous():
"""Scrolls up continuously"""
global continuous_scoll_mode
continuous_scoll_mode = "scroll up continuous"
mouse_scroll(-80)()
if scroll_job is None:
start_scroll()
if settings.get("user.mouse_hide_mouse_gui") == 0:
gui_wheel.show()
def get_directory_map(current_path):
directories = [
f.name
for f in islice(current_path.iterdir(),
settings.get("user.file_manager_folder_limit", 1000))
if f.is_dir()
]
# print(len(directories))
spoken_forms = create_spoken_forms(directories)
return dict(zip(spoken_forms, directories))
def enable(self, persisted=False):
if not self.enabled:
self.enabled = True
self.display_state.register("broadcast_update",
self.broadcast_update)
# Only reset the talon HUD environment after a user action
# And only set the visible tag
self.current_talon_hud_environment = settings.get(
"user.talon_hud_environment", "")
if persisted:
self.set_current_flow("enabled")
self.current_flow = "enable"
ctx.tags = [
"user.talon_hud_available", "user.talon_hud_visible",
"user.talon_hud_choices_visible"
]
# Connect the events relating to non-content communication
self.event_dispatch.register("persist_preferences",
self.debounce_widget_preferences)
self.event_dispatch.register("hide_context_menu",
self.hide_context_menu)
self.event_dispatch.register("deactivate_poller",
self.deactivate_poller)
self.event_dispatch.register("show_context_menu",
self.move_context_menu)
self.event_dispatch.register("synchronize_poller",
self.synchronize_widget_poller)
# Reload the preferences just in case a screen change happened in between the hidden state
if persisted or self.current_flow in ["repair", "initialize"]:
reload_theme = self.widget_manager.reload_preferences(
True, self.current_talon_hud_environment)
if reload_theme != self.theme.name:
self.switch_theme(reload_theme, True)
for widget in self.widget_manager.widgets:
if widget.preferences.enabled and not widget.enabled:
widget.enable()
self.synchronize_pollers()
ui.register("screen_change", self.reload_preferences)
settings.register("user.talon_hud_environment",
self.hud_environment_change)
self.determine_active_setup_mouse()
if persisted:
self.preferences.persist_preferences({"enabled": True})
self.set_current_flow("manual")
# Make sure context isn't updated in this thread because of automatic reloads
cron.cancel(self.update_context_debouncer)
self.update_context_debouncer = cron.after("50ms",
self.update_context)
def code_insert_function(text: str, selection: str):
formatted_text = actions.user.formatted_text(
text, settings.get("user.code_private_function_formatter"))
if selection:
result = formatted_text + "({})".format(selection)
else:
result = formatted_text + "()"
actions.user.paste(result)
actions.edit.left()
def adjust_mode(self, valid_mode_ids, no_preserve=False, auto=True):
if auto is True and settings.get("user.vim_adjust_modes") == 0:
return
cur = self.current_mode_id()
print("Current mode is {}".format(cur))
if type(valid_mode_ids) != list:
valid_mode_ids = [valid_mode_ids]
if cur not in valid_mode_ids:
# Just favor the first mode
self.set_mode(valid_mode_ids[0], no_preserve=no_preserve)
def code_private_function(text: str):
"""Inserts private function declaration"""
result = "local function {}".format(
actions.user.formatted_text(
text, settings.get("user.code_private_function_formatter")
)
)
actions.insert("\n\nend")
actions.key("up:2")
actions.user.code_insert_function(result, None)
def code_private_function(text: str):
result = "{} <- function () {{\n\n}}".format(
actions.user.formatted_text(
text, settings.get("user.code_private_function_formatter")))
actions.user.paste(result)
actions.edit.up()
actions.edit.up()
actions.edit.line_end()
actions.edit.left()
actions.edit.left()
actions.edit.left()
def __init__(self, mod):
self.arch_index = 0
self.architectures = ["x86", "x64"]
for arch in self.architectures:
mod.tag(arch, desc="Tag for enabling {arch} architecture")
self.architecture = settings.get("user.debug_default_architecture")
if self.architecture:
ctx.tags = [f"user.{self.architecture}"]
else:
print("Just encountered bug!!!")
# it seems like sometimes the above isn't set yet...
ctx.tags = ["user.x64"]
def code_function(name: str, privacy=None):
formatted_name = actions.user.formatted_text(
name, settings.get("user.code_{}_function_formatter".format(privacy)))
if privacy:
result = "{} function {}".format(privacy, formatted_name)
else:
result = "function {}".format(formatted_name)
actions.user.paste("{}(): {{\n}}".format(result))
actions.edit.up()
actions.edit.line_end()
actions.edit.left()
actions.edit.left()
def smart_insert(txt: str):
"""context-aware insertion"""
# delete whatever is currently selected
actions.key(" ")
actions.key("backspace")
with ClipScanner() as clip:
# scan left side of the cursor
clip.clear()
actions.edit.extend_left()
before = clip.get_selection()
if before != "":
actions.edit.extend_right()
# scan right side of the cursor
clip.clear()
actions.edit.extend_right()
after = clip.get_selection()
if after != "":
actions.edit.extend_left()
squeeze_into_word = False
if before != "" and unicodedata.category(before)[0] == 'L' \
and after != "" and unicodedata.category(after)[0] == 'L':
squeeze_into_word = True
if before != "" \
and (unicodedata.category(before)[0] == 'L' or before in _space_after) \
and txt[0] not in _no_space_before \
and not squeeze_into_word:
actions.insert(' ')
if before in _capitalize_after or before == "":
txt = txt[0].upper() + txt[1:]
if settings.get("user.german_unicode") == 0:
ascii = txt
for c in _ascii_replace:
ascii = ascii.replace(c, _ascii_replace[c])
actions.insert(ascii)
else:
actions.insert(txt)
if (after != "" and (txt[-1] in _space_after
or unicodedata.category(txt[-1])[0] == 'L')
and after not in ' \n\t' and after not in _no_space_before
and not squeeze_into_word):
actions.insert(' ')
def handle_hexdump_count(cmd, number, register, clip=False, copy=False):
count = settings.get("user.debug_default_hexdump_count")
if number:
count = number
actions.auto_insert(f"{cmd} ")
if len(register):
actions.auto_insert(f"${register} {count}\n")
elif clip:
if copy:
actions.edit.copy()
actions.edit.paste()
actions.auto_insert(f" {count}\n")
else:
actions.user.insert_cursor(f"[|] {count}")
def __init__(self):
self.init_ok = False
self.nvim = None
if settings.get("user.vim_use_rpc") == 0:
return
self.rpc_path = self.get_active_rpc()
if self.rpc_path is not None:
try:
self.nvim = pynvim.attach("socket", path=self.rpc_path)
except RuntimeError:
return
self.init_ok = True
else:
return
def open_recordings(self, data):
if settings.get("speech.record_all", False) == False:
actions.user.hud_add_log("warning", "Recordings aren't currently enabled!\n" + \
"Enable them in the talon menu to create recordings")
if not os.path.exists(str(TALON_HOME) + "/recordings"):
actions.user.hud_add_log("error",
"No recordings have been made yet!")
else:
recordings_folder = str(TALON_HOME)
recordings_folder += "/recordings"
if platform.system() == "Windows":
os.startfile(recordings_folder)
elif platform.system() == "Darwin":
subprocess.Popen(["open", recordings_folder])
else:
subprocess.Popen(["xdg-open", recordings_folder])
def personal_info(record: str):
"""Insert some info from the personal info database"""
global pi
global personal_info_list
record_data = pi.db[record]
if type(record_data) == list:
if len(record_data) > 1:
auto_index = settings.get("user.personal_info_auto_select")
personal_info_list = record_data
if auto_index <= len(record_data):
record_data = record_data[auto_index]
else:
raise_personal_info()
else:
record_data = record_data[0]
actions.insert(f"{record_data}")
def code_function(name: str, is_public: bool):
formatter_privacy = "public" if is_public else "private"
formatted_name = actions.user.formatted_text(
name,
settings.get(
"user.code_{}_function_formatter".format(formatter_privacy)))
if is_public == "public":
result = "pub fn {}".format(formatted_name)
else:
result = "fn {}".format(formatted_name)
actions.user.paste("{}() {{\n}}".format(result))
actions.edit.up()
actions.edit.line_end()
actions.edit.left()
actions.edit.left()
actions.edit.left()
def __init__(self, mod):
self.datatypes = ["c_basic_datatypes", "c_stdint_datatypes"]
default = "c_basic_datatypes"
if settings.get("user.use_stdint_datatypes"):
default = "c_stdint_datatypes"
index = 0
for type in self.datatypes:
if default == type:
break
index += 1
self.datatype_index = index
for datatype in self.datatypes:
mod.tag(datatype, desc="Tag for enabling {datatype} datatype")
self.datatype = self.datatypes[self.datatype_index]
ctx.tags = [f"user.{self.datatype}"]
def start(self, current_flow="initialize"):
self.set_current_flow(current_flow)
self.current_talon_hud_environment = settings.get(
"user.talon_hud_environment", "")
if (self.preferences.prefs["enabled"]):
self.enable()
ctx.tags = [
"user.talon_hud_available", "user.talon_hud_visible",
"user.talon_hud_choices_visible"
]
if actions.sound.active_microphone() == "None":
actions.user.hud_add_log(
"warning",
"Microphone is set to \"None\"!\n\nNo voice commands will be registered."
)
self.set_current_flow("manual")
self.distribute_content()
