def drop_keep_clipboard(nnavi500, nexus, capitalization, spacing): # Maintain standard spark functionality for non-strings if capitalization == 0 and spacing == 0 and nnavi500 == 1: Key("c-v").execute() return # Get clipboard text if nnavi500 > 1: key = str(nnavi500) if key in nexus.clip: text = nexus.clip[key] else: dragonfly.get_engine().speak("slot empty") text = None else: text = Clipboard.get_system_text() # Format if necessary, and paste if text is not None: cb = Clipboard(from_system=True) if capitalization != 0 or spacing != 0: text = textformat.TextFormat.formatted_text( capitalization, spacing, text) Clipboard.set_system_text(text) time.sleep(settings.SETTINGS["miscellaneous"]["keypress_wait"] / 1000.) Key("c-v").execute() time.sleep(settings.SETTINGS["miscellaneous"]["keypress_wait"] / 1000.) # Restore the clipboard contents. cb.copy_to_system()
def stoosh_keep_clipboard(nnavi500, nexus): if nnavi500 == 1: Key("c-c").execute() else: max_tries = 20 cb = Clipboard(from_system=True) Key("c-c").execute() key = str(nnavi500) for i in range(0, max_tries): failure = False try: # time for keypress to execute time.sleep( settings.SETTINGS["miscellaneous"]["keypress_wait"] / 1000.) nexus.clip[key] = Clipboard.get_system_text() utilities.save_toml_file( nexus.clip, settings.SETTINGS["paths"]["SAVED_CLIPBOARD_PATH"]) except Exception: failure = True utilities.simple_log() if not failure: break cb.copy_to_system()
def bring_add(launch, key): ''' Add current program or highlighted text to bring me ''' key = str(key) if launch == "program": path = utilities.get_active_window_path() if not path: # dragonfly.get_engine().speak("program not detected") print("Program path for bring me not found ") # elif launch == 'file': # no way to add file via pyperclip else: Key("a-d/5").execute() fail, path = context.read_selected_without_altering_clipboard() if fail == 2: #FIXME time.sleep(0.1) _, path = context.read_selected_without_altering_clipboard() if not path: # dragonfly.get_engine().speak("nothing selected") print("Selection for bring me not found ") Key("escape").execute() if not path: #logger.warn('Cannot add %s as %s to bringme: cannot get path', launch, key) return CONFIG[launch][key] = path utilities.save_toml_file(CONFIG, settings.SETTINGS["paths"]["BRINGME_PATH"]) refresh()
def ACP(command, label=None): """Utilize the Palette UI to execute commands.""" if not label: label = "Atom: Unlabeled Palette Command: " + command return R(Key("cs-p") + Pause(str(atom_palette_wait)) + Text(command) + Key("enter"), rdescript=label)
class PythonNon(MappingRule): mapping = { "try catch": R(Text("try:") + Key("enter:2/10, backspace") + Text("except Exception:") + Key("enter"), rdescript="Python: Try Catch"), }
def next_line(semi): semi = str(semi) Key("escape").execute() time.sleep(0.25) Key("end").execute() time.sleep(0.25) Text(semi).execute() Key("enter").execute()
class PrologNon(MappingRule): mapping = { "Rule": R(Text("() :-.") + Key("left/6"), rdescript="Prolog: rule"), SymbolSpecs.IF: R(Text("( ") + Key("enter") + Text(";") + Key("enter") + Text(")"), rdescript="Prolog: IF"), }
def duple_keep_clipboard(nnavi50): cb = Clipboard(from_system=True) Key("escape, home, s-end, c-c, end").execute() time.sleep(settings.SETTINGS["miscellaneous"]["keypress_wait"] / 1000.) for i in range(0, nnavi50): Key("enter, c-v").execute() time.sleep(settings.SETTINGS["miscellaneous"]["keypress_wait"] / 1000.) cb.copy_to_system()
def findNthToken(text, n, direction): Key("c-f").execute() Text("%(text)s").execute({"text": text}) if direction == "reverse": print("yeah? %(n)d") Key("s-enter:%(n)d").execute() else: Key("enter:%(n)d").execute() print("no? %(n)d") Key('escape').execute()
class EclipseCCR(MergeRule): pronunciation = "eclipse jump" mwith = [Navigation().get_pronunciation()] mapping = { #Line Ops "configure": R(Paste(ec_con.analysis_chars)+Key("left:2/5, c-f/20, backslash, rbracket, enter") + \ Function(ec_con.analyze_for_configure), rdescript="Eclipse: Configure"), "jump in [<n>]": R(Key("c-f, a-o")+Paste(r"[\(\[\{\<]")+Function(ec_con.regex_on)+ \ Key("enter:%(n)d/5, escape, right") , rdescript="Eclipse: Jump In"), "jump out [<n>]": R(Key("c-f, a-o")+Paste(r"[\)\] \}\>]")+Function(ec_con.regex_on)+ \ Key("enter:%(n)d/5, escape, right") , rdescript="Eclipse: Jump Out"), "jump back [<n>]": R(Key("c-f/5, a-b")+Paste(r"[\)\]\}\>]")+Function(ec_con.regex_on)+ \ Key("enter:%(n)d/5, escape, left") , rdescript="Eclipse: Jump Back"), "[go to] line <n>": R(Key("c-l") + Pause("50") + Text("%(n)d") + Key("enter")+ Pause("50"), rdescript="Eclipse: Go To Line"), "shackle <n> [<back>]": R(Key("c-l")+Key("right, cs-left")+ \ Function(ec_con.lines_relative), rdescript="Eclipse: Select Relative Lines"), } extras = [ Dictation("text"), IntegerRefST("n", 1, 1000), Boolean("back"), ] defaults = {"n": 1, "back": False}
class Alphabet(MergeRule): pronunciation = "alphabet" mapping = { "<letter>": R(Key("%(letter)s"), rdescript="Spell"), "big <letter>": R(Key("s-%(letter)s")), } extras = [ letter_choice("letter"), ] defaults = {}
def begin_end(environment): if type(environment) in [str, unicode]: back_curl("begin", environment).execute() Key("enter:2").execute() back_curl("end", environment).execute() Key("up").execute() elif type(environment) in [tuple, list]: back_curl("begin", environment[0]).execute() Text(environment[1]).execute() Key("enter:2").execute() back_curl("end", environment[0]).execute() Key("up").execute()
class SQLDeveloperRule(MergeRule): pronunciation = "sequel developer" mapping = { "run this query": R(Key("f9"), rdescript="SQL Dev: Run Query"), "format code": R(Key("c-f7"), rdescript="SQL Dev: Format Code"), "comment line": R(Key("c-slash"), rdescript="SQL Dev: Comment Line"), } extras = [ Dictation("text"), IntegerRefST("n", 1, 1000), ] defaults = {"n": 1}
class CMDRule(MergeRule): pronunciation = "command prompt" mapping = { "C drive": R(Text(r"cd C:/") + Key("enter"), rdescript="CMD: Go To C:"), "CD up": R(Text("cd ..") + Key("enter"), rdescript="CMD: Up Directory"), "CD": R(Text("cd "), rdescript="CMD: Navigate Directory"), "list": R(Text("dir") + Key("enter"), rdescript="CMD: List Files"), "make directory": R(Text("mkdir "), rdescript="CMD: Make directory"), "exit": R(Text("exit") + Key("enter"), rdescript="CMD: Exit"), } extras = [] defaults = {}
def letters(big, dict1, dict2, letter): '''used with alphabet.txt''' d1 = str(dict1) if d1 != "": Text(d1).execute() if big: Key("shift:down").execute() letter.execute() if big: Key("shift:up").execute() d2 = str(dict2) if d2 != "": Text(d2).execute()
class PythonNon(MappingRule): mapping = { "with": R(Text("with "), rdescript="Python: With"), "open file": R(Text("open('filename','r') as f:"), rdescript="Python: Open File"), "read lines": R(Text("content = f.readlines()"), rdescript="Python: Read Lines"), "try catch": R(Text("try:") + Key("enter:2/10, backspace") + Text("except Exception:") + Key("enter"), rdescript="Python: Try Catch"), }
class LyxRule(MergeRule): pronunciation = "lyx" mapping = { "new file": R(Key("c-n"), rdescript="LyX: new file"), "open file": R(Key("c-o"), rdescript="LyX: open file"), "save as": R(Key("cs-s"), rdescript="LyX: save as"), "math mode": R(Key("c-m"), rdescript="LyX: math mode"), "display mode": R(Key("cs-m"), rdescript="LyX: display mode"), "view PDF": R(Key("c-r"), rdescript="LyX: view PDF"), "update PDF": R(Key("cs-r"), rdescript="LyX: update PDF"), "move line up [<n>]": R(Key("a-up"), rdescript="LyX: move line up") * Repeat(extra="n"), "move line down [<n>]": R(Key("a-down"), rdescript="LyX: move line down") * Repeat(extra="n"), "insert <environment>": R(Key("a-i, h, %(environment)s"), rdescript="LyX: insert environment"), } extras = [ IntegerRefST("n", 1, 10), Choice( "environment", { "(in line formula | in line)": "i", "(display formula | display)": "d", "(equation array environment | equation array)": "e", "(AMS align environment | AMS align)": "a", "AMS align at [environment]": "t", "AMS flalign [environment]": "f", "(AMS gathered environment | AMS gather)": "g", "(AMS multline [environment]| multiline)": "m", "array [environment]": "y", "(cases [environment] | piecewise)": "c", "(aligned [environment] | align)": "l", "aligned at [environment]": "v", "gathered [environment]": "h", "split [environment]": "s", "delimiters": "r", "matrix": "x", "macro": "o", }), ] defaults = { "n": 1, }
def analyze_for_configure(self): '''solves the problem of the editor not being smart about toggles by using text to see which toggles are active''' '''regex toggle check''' Key("escape").execute() # get out of Find result = CONTEXT.read_nmax_tries(10) if result == self.analysis_chars: self.regex = False Key("backspace").execute() elif result == self.analysis_chars[1]: self.regex = True Key("delete, backspace").execute() else: print("Eclipse configuration failed (%s)" % result)
class FlashDevelopCCR(MergeRule): pronunciation = "flash develop test" mwith = [Navigation().get_pronunciation()] mapping = { "[go to] line <n>": R(Key("c-g") + Pause("50") + Text("%(n)d") + Key("enter"), rdescript="FlashDevelop: Go To Line"), } extras = [ Dictation("text"), IntegerRefST("n", 1, 1000), ] defaults = {"n": 1}
def quote(): e, text = context.read_selected_without_altering_clipboard(False) if text: Text("``" + text + "\'\'").execute() else: Text("``\'\'").execute() Key("left:2").execute()
def master_text_nav(mtn_mode, mtn_dir, nnavi500, extreme): ''' (<mtn_dir> | <mtn_mode> [<mtn_dir>]) [(<nnavi500> | <extreme>)] mtn_mode: "shin" s, "queue" cs, "fly" c, (default None) mtn_dir: 0-up, 1-down, 2-left, 3-right, (default right) nnavi500: number of keypresses (default 1) extreme: home/end (default None) ''' k = None if mtn_mode is None: if extreme is not None: if mtn_dir == "left": k = "home" elif mtn_dir == "right": k = "end" elif mtn_dir == "up": k = "c-home" elif mtn_dir == "down": k = "c-end" else: k = str(mtn_dir) + "/5:" + str(nnavi500) elif extreme is None: k = str(mtn_mode) + "-" + str(mtn_dir) + "/5:" + str(nnavi500) else: mtn_dir = str(mtn_dir) way = "end" if mtn_dir in ["right", "down"] else "home" k = str(mtn_mode) + "-" + str(way) Key(k).execute() time.sleep(settings.SETTINGS["miscellaneous"]["keypress_wait"]/1000.)
def refresh(_NEXUS): ''' should be able to add new scripts on the fly and then call this ''' unload() global grammar grammar = Grammar("si/kuli") def refresh_sick_command(): server_proxy.terminate() refresh(_NEXUS) mapping = { "launch sick IDE": Function(launch_IDE), "launch sick server": Function(launch_server), "refresh sick you Lee": Function(refresh_sick_command), "sick shot": Key("cs-2"), } rule = MergeRule(name="sik", mapping=mapping) gfilter.run_on(rule) grammar.add_rule(rule) grammar.load() # start server try: # if the server is already running, this should go off without a hitch start_server_proxy() except Exception: launch_server() seconds5 = 5 control.nexus().timer.add_callback(server_proxy_timer_fn, seconds5)
def read_selected_without_altering_clipboard(same_is_okay=False): '''Returns a tuple: (0, "text from system") - indicates success (1, None) - indicates no change (2, None) - indicates clipboard error ''' time.sleep(settings.SETTINGS["miscellaneous"]["keypress_wait"] / 1000.) # time for previous keypress to execute cb = Clipboard(from_system=True) temporary = None prior_content = None try: prior_content = Clipboard.get_system_text() Clipboard.set_system_text("") Key("c-c").execute() time.sleep(settings.SETTINGS["miscellaneous"]["keypress_wait"] / 1000.) # time for keypress to execute temporary = Clipboard.get_system_text() cb.copy_to_system() except Exception: utilities.simple_log(False) return 2, None if prior_content == temporary and not same_is_okay: return 1, None return 0, temporary
def lines_relative(self, back, n): if back: #backward try: num = CONTEXT.read_nmax_tries(10) txt = str(int(num) - int(n) + 1) # +1 to include current line Text(txt).execute() except ValueError: utilities.simple_log() return Key("enter").execute() else: #forward Key("escape, end, home, home").execute( ) # end-home-home to include all of current line # forward or backward Key("s-down:" + str(int(n)) + "/5, s-left").execute()
class StackTest(MappingRule): '''test battery for the ContextStack''' mapping = { "close last tag": ContextSeeker([ L(S(["cancel"], None), S(["html spoken"], close_last_spoken, use_spoken=True), S(["span", "div"], close_last_rspec, use_rspec=True)) ]), "html": R(Text("<html>"), rspec="html spoken"), "divider": R(Text("<div>"), rspec="div"), "span": R(Text("<span>"), rspec="span"), "backward seeker [<text>]": ContextSeeker([ L(S(["ashes"], Text("ashes1 [%(text)s] ")), S(["bravery"], Text("bravery1 [%(text)s] "))), L(S(["ashes"], Text("ashes2 [%(text)s] ")), S(["bravery"], Text("bravery2 [%(text)s] "))) ]), "forward seeker [<text>]": ContextSeeker(forward=[ L(S(["ashes"], Text("ashes1 [%(text)s] ")), S(["bravery"], Text("bravery1 [%(text)s] "))), L(S(["ashes"], Text("ashes2 [%(text)s] ")), S(["bravery"], Text("bravery2 [%(text)s] "))) ]), "asynchronous test": AsynchronousAction([ L(S(["ashes", "charcoal"], print_time, None), S(["bravery"], Text, "bravery1")) ], time_in_seconds=0.2, repetitions=20, finisher=Text(FINISHER_TEXT), blocking=False), "ashes": RegisteredAction(Text("ashes _ "), rspec="ashes"), "bravery": RegisteredAction(Text("bravery _ "), rspec="bravery"), "charcoal <text> [<n>]": R(Text("charcoal _ %(text)s"), rspec="charcoal"), "test confirm action": ConfirmAction(Key("a"), rdescript="Confirm Action Test", instructions="some words here"), "test box action": BoxAction(lambda data: _abc(data), rdescript="Test Box Action", box_type=settings.QTYPE_DEFAULT, log_failure=True), } extras = [Dictation("text"), Dictation("text2"), IntegerRefST("n", 1, 5)] defaults = {"text": "", "text2": ""}
def misc(misc_lyx_commands): if type(misc_lyx_commands) in [str, int]: Text(misc_lyx_commands).execute() elif type(misc_lyx_commands) in [list, tuple]: for i in range(len(misc_lyx_commands)): if i % 2 == 0: Text(misc_lyx_commands[i]).execute() else: Key(misc_lyx_commands[i]).execute()
def add_modkeys(rule): release = R(Key("shift:up, ctrl:up, alt:up"), rdescript="Mod Keys Up") if not hasattr(rule, "marked") and\ rule.get_pronunciation()[0:6] != "Merged": # don't augment merged rules-- they'd get it twice for spec in rule.mapping_actual().keys(): rule.mapping_actual( )[spec] = release + rule.mapping_actual()[spec] + release rule.marked = True
def insert(element): if type(element) in [str, int]: Text(element).execute() elif type(element) in [list, tuple]: for i in range(len(element)): if i % 2 == 0: Text(element[i]).execute() else: Key(element[i]).execute()
class MineNon(MappingRule): mapping = { # "switch <exec_path>": # R(Function(window_switcher.switch_window)), # "switch notepad": # R(Playback([(["switch", "to", "notepad"], 0.0)])), # "switch kindle": # R(Playback([(["switch", "to", "kindle"], 0.0)])), # "switch spot if I": # R(Playback([(["switch", "to", "spotify"], 0.0)])), # "switch file man": # R(Playback([(["switch", "to", "fman"], 0.0)])), # "open spot if I": # R(Playback([(["open", "spotify"], 0.0)])), # "open file man": # R(Playback([(["open", "fman"], 0.0)])), "show work [spaces]": R(Key("w-tab")), "(create | new) work [space]": R(Key("wc-d")), "close work [space]": R(Key("wc-f4")), "next work [space] [<n>]": R(Key("wc-right")) * Repeat(extra="n"), "(previous | prior) work [space] [<n>]": R(Key("wc-left")) * Repeat(extra="n"), # "normal mode": # R(Playback([(["switch", "to", "normal", "mode"], 0.0)])), # "command mode": # R(Playback([(["switch", "to", "command", "mode"], 0.0)])), # "dictation mode": # R(Playback([(["switch", "to", "dictation", "mode"], 0.0)])), } extras = [ window_switcher.get_choice(), IntegerRefST("n", 1, 5), ] defaults = { "n": 1, }
def insert(element): if type(element) is str: n_markers = 0 to_enter = element else: n_markers = element[1] to_enter = element[0] Text(to_enter).execute() for _ in range(n_markers): Key("s-f4").execute()