def _process_recognition(self, value, extras): getPassword = Key("w-b/10, s-tab/10, right:8/10, enter, c-f/10") + value + Key('enter/10, escape/10, c-c/10, a-tab/10') getPassword.execute() clipboard = Clipboard() clipboard.copy_from_system(clear = True) password = clipboard.get_text() action = Text(password) action.execute()
def getFile(text=None): open_get_file_dialog = Key("cas-n") if text: open_get_file_dialog.execute() file_name = str(text).lower() Text(file_name).execute() else: open_get_file_dialog.execute()
class GitterRule(MergeRule): pronunciation = "Gitter" mapping = { "bold": R(Text("****") + Key("left:2"), rdescript="Gitter: Bold"), "emphasize": R(Text("**") + Key("left"), rdescript="Gitter: Italicize"), # "header": R(Text( "" ), rdescript="Gitter: Header"), # H1 ## H2 ### H3 "insert item": R(Text("* "), rdescript="Gitter: Insert Item"), "block quote": R(Text("> "), rdescript="Gitter: Block Quote"), "mention": R(Text("@"), rdescript="Gitter: Mention"), "insert link": R(Text("[]()") + Key("left:3"), rdescript="Gitter: Insert Link"), "insert image": R(Text("![]()") + Key("left:3"), rdescript="Gitter: Insert Image"), "insert code": R(Text("``") + Key("left"), rdescript="Gitter: Insert Code"), "formatted code": R(Text("```") + Key("s-enter"), rdescript="Gitter: Formatted Code"), } extras = [ Dictation("text"), ] Defaults = {}
class CodeMappings(MappingRule): mapping = { 'tab <number>': Function(calculateSlotNumber), 'Activity': Key('c-1'), 'chat': Key('c-2'), 'Teams': Key('c-3'), 'Calendar': Key('c-4'), 'snurch': Key('c-e'), 'goat': Key('c-g'), 'Filter': Key('cs-f'), 'make call': Key('cs-c') + Key('csa-slash'), '<text>': Text("%(text)s "), } extras = [ Integer('tab', 1, 10), Integer('number', 1, 9999), Dictation("text") ]
class MSWordRule(MergeRule): pronunciation = "Microsoft Word" mapping = { "insert image": R(Key("alt, n, p"), rdescript="Word: Insert Image"), } extras = [ Dictation("dict"), IntegerRefST("n",1, 100), ] defaults ={"n": 1, "dict":"nothing"}
class KeysOnlyRule(MappingRule): exported = False mapping = {k: Key(v) for k, v in lib.mappings.keys.items()} mapping.update({"<formatType> <text>": Function(format_text)}) # mapping.update({"sh":Mouse("<0,0>,left")}) extras = [ Dictation("text"), Choice("formatType", formatMap), IntegerRef("n", 1, 100), # Times to repeat the sequence. ] defaults = { "n": 1, }
class GlobalRule(MappingRule): mapping = { '[<text>] go to sleep': Function(go_to_sleep), 'mouse': Key('f3,f4/350,f4'), "touch": Mouse("left"), "touch two": Mouse("left:2"), 'touch are': Mouse('right'), "touch mid": Mouse("middle"), "[<n>] scroll down": (Mouse("wheeldown") + Pause('5')) * Repeat(extra='n') * 2, "[<n>] scroll up": (Mouse("wheelup") + Pause('5')) * Repeat(extra='n') * 2, "[<n>] scroll right": (Mouse("wheelright") + Pause('5')) * Repeat(extra='n') * 2, "[<n>] scroll left": (Mouse("wheelleft") + Pause('5')) * Repeat(extra='n') * 2, "drag": Mouse("left:down"), "drop": Mouse("left:up"), "[<n>] alt tab": Key("alt:down,tab/50:%(n)d/50,alt:up"), "alt tab show": Key("alt:down,tab/10,s-tab"), 'reload natlink': Function(reload_natlink), } extras = [ IntegerRef('n', 1, 101, default=1), Dictation('text'), ]
def selection_to_bib(ref_type, bib_path): Key("c-c/20").execute() cb = Clipboard.get_system_text() if ref_type == "book": ref = book_citation_generator.citation_from_name(cb) elif ref_type == "paper": ref = bibtexer.bib_from_title(cb) elif ref_type == "link": ref = bibtexer.bibtex_from_link(cb) with codecs.open(bib_path, encoding="utf-8", mode="a") as f: f.write(ref) print("Reference added:\n" + ref) Clipboard.set_system_text(bibtexer.get_tag(ref))
class TaskBar(MappingRule): mapping = { "Dora": Key("w-1"), "outlook": Key("w-2"), "chromie": Key("w-3"), "slacker": Key("w-4"), "teamer": Key("w-5"), "viz. code": Key("w-6"), "termie": Key("w-7"), }
def defineMethod(text, _node): commands = _node.words() method_index = commands.index("method") modifiers_string = getModifiers(commands[:method_index]) formatted_class_name = "" if text: format_me = str(text) if len(commands) > method_index + 1: format_command = commands[method_index + 1] if (format_command != "pascal") and (format_command !="snake"): format_command = "camel" # default formatted_class_name = utils.text_to_case(format_command, format_me) (Text(modifiers_string + formatted_class_name + "() {") + Key("enter, up, end, left:3")).execute()
def defineClass(text, _node): commands = _node.words() class_index = commands.index("class") modifiers_string = getModifiers(commands[:class_index]) formatted_class_name = "" if text: format_me = str(text) if len(commands) > class_index + 1: format_command = commands[class_index + 1] if (format_command != "camel") and (format_command !="snake"): format_command = "pascal" # default formatted_class_name = utils.text_to_case(format_command, format_me) (Text(modifiers_string + "class " + formatted_class_name + " {") + Key("enter")).execute()
class FlashDevelopCCR(MergeRule): pronunciation = "flash develop test" mwith = [Navigation().get_name()] 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}
class CommandRule(MappingRule): mapping = { "dragonfly add buffer": Exec("dragonfly-add-buffer"), "dragonfly add word": Exec("dragonfly-add-word"), "dragonfly blacklist word": Exec("dragonfly-blacklist-word"), "Foreclosure next": Exec("4clojure-next-question"), "Foreclosure previous": Exec("4clojure-previous-question"), "Foreclosure check": Exec("4clojure-check-answers"), "confirm": Text("yes") + Key("enter"), "deny": Text("no") + Key("enter"), "relative line numbers": Exec("linum-relative-toggle"), "revert buffer": Exec("revert-buffer"), "exit out of Emacs": Key("c-x, c-c"), } extras = [ IntegerRef("n", 1, 20), IntegerRef("line", 1, 10000), Dictation("text"), ] defaults = { "n": 1, }
class ObjectRule(MappingRule): exported = False mapping = { "[<n>] <modifier> <object>": Key("%(n)d, %(modifier)s, %(object)s") } extras = [ IntegerRef("n", 1, 10), modifier.modifierChoice("modifier"), object.objectChoice("object"), ] defaults = { "n": 1, }
def __init__(self, slack_n, outlook_n): self.slack = Key("w-" + slack_n + "/100") self.my_team = Key("c-2/30") self.myself = Key("cs-t/100") + Text("you") + Key("enter/50") self.msg_field = Mouse("[400, 1000]") # sometimes needs to be selected self.copy_msg = Key("up/30, c-a/30, c-c/30") self.outlook = Key("w-" + outlook_n + "/50") self.copy_from_slack = self.slack + self.my_team + self.myself + self.msg_field + self.copy_msg
class NERDTreeRule(MappingRule): exported = True mapping = { "nerd open": Key('o'), "nerd open split": Key('i'), "nerd open vertical": Key('s'), "nerd open tab": Key('t'), "nerd change directory": Key('c, d'), "nerd set directory": Key('C'), "nerd toggle": Key('colon') + Text('NERDTreeToggle') + Key('enter'), # use insert start commandto go into change node mode # nerd change node } extras = [] default = {}
class GlobalMovementRule(MappingRule): mapping = { 'up [<n>]': Key('up:%(n)d'), 'down [<n>]': Key('down:%(n)d'), 'left [<n>]': Key('left:%(n)d'), 'right [<n>]': Key('right:%(n)d'), 'home': Key('home'), 'end': Key('end'), 'enter [<n>]': Key('enter:%(n)d'), } extras = [IntegerRef('n', 1, 9999)] defaults = {'n': 1}
class WindowRule(MappingRule): name = "gvim_window" mapping = { # window navigation commands "window left": Key("c-w,h"), "window right": Key("c-w,l"), "window up": Key("c-w,k"), "window down": Key("c-w,j"), "increase window vertical": Key("colon") + Text('res +10') + Key('enter'), # window creation commands "window split": Key("c-w,s"), "window vertical split": Key("c-w,v"), } extras = []
class SlackMapping(MappingRule): mapping = { # "new (thing | tab)": Key("c-t"), # "new window": Key("c-n"), # "reopen tab": Key("cs-t"), # "(next | nex) (tab | ab) [<n>]": Key("c-pgdown:%(n)d"), # "(previous | preev) tab [<n>]": Key("c-pgup:%(n)d"), # "show tab <tab>": Key("c-%(tab)d"), "switch <text>": Key("c-k/25") + Text("%(text)s") + Key("enter"), "show switch": Key("c-k"), "left (pain | pane)": Key("f6/10:3"), # "open <w> [<x>] [<y>] [<z>]": Key("cs-space/" + click_by_voice_delay) + Function(printNumber) + Key("enter"), # click by voice # "open focus <w> [<x>] [<y>] [<z>]": Key("cs-space/" + click_by_voice_delay) + Function(printNumberFocus) + Key("enter"), # click by voice } extras = [ Integer("n", 1, 50), Integer("number", 1, 9999), Dictation("text"), ] defaults = { "n": 1, }
def drop_keep_clipboard(nnavi500, nexus): if nnavi500 == 1: Key("c-v").execute() else: max_tries = 20 key = str(nnavi500) cb = Clipboard(from_system=True) for i in range(0, max_tries): failure = False try: if key in nexus.clip: Clipboard.set_system_text(nexus.clip[key]) Key("c-v").execute() time.sleep( settings.SETTINGS["miscellaneous"]["keypress_wait"] / 1000.) else: dragonfly.get_engine().speak("slot empty") except Exception: failure = True if not failure: break cb.copy_to_system()
def text_nav(modifier, direction, n50, extreme): k = "" if extreme: if direction in ["left", "up"]: k = k + "home" else: k = k + "end" if direction in ["up", "down"]: k = "c-" + k else: k = str(direction) + ":" + str(n50) if modifier: k = str(modifier) + k.replace("c-", "") Key(k).execute()
def launch(hmc_type, callback, data=None): from dragonfly import (WaitWindow, FocusWindow, Key) instructions = _get_instructions(hmc_type) if data != None: instructions.append(data) Popen(instructions) hmc_title = _get_title(hmc_type) WaitWindow(title=hmc_title, timeout=5).execute() FocusWindow(title=hmc_title).execute() Key("tab").execute() from caster.asynch.hmc import squeue squeue.add_query(callback)
def get_selected_files(folders=False): ''' Copy selected (text or file is subsequently of interest) to a fresh clipboard ''' if WIN32 or LINUX: cb = Clipboard(from_system=True) cb.clear_clipboard() Key("c-c").execute() time.sleep(0.1) files = get_clipboard_files(folders) cb.copy_to_system() return files else: printer.out("get_selected_files: Not implemented for OS")
class PythonControlStructures(MappingRule): mapping = { "if": Text("if cond:") + Key("enter"), "for loop": Text("for i in iter:") + Key("enter"), "function": Text("def function():") + Key("enter"), "class": Text("class cls(object):") + Key("enter"), "init": Text("def __init__(self):") + Key("enter"), "main": Text("if __name__ == '__main__':") + Key("enter"), }
class MobaXtermMapping(MappingRule): mapping = { "next tab [<t>]": Key("c-tab:%(t)d"), "(preev | previous) tab [<t>]": Key("cs-tab:%(t)d"), "close tab [<t>]": Key("ca-q:%(t)d"), "Denny triage": Text("cd /usr/share/indeni-knowledge/stable/automation") + Key("enter"), "Ansible logs": Text("cd /usr/share/indeni-services/logs/ansible") + Key("enter"), "Denny knowledge": Text("cd /usr/share/indeni-knowledge") + Key("enter"), "Denny server": Text("cd /usr/share/indeni") + Key("enter"), "Denny collector": Text("cd /usr/share/indeni") + Key("enter"), "restart server": Text("sudo res") + Key("enter"), "stop server": Text("sudo res stop") + Key("enter"), } extras = [ Integer("t", 1, 50), Dictation("text"), Dictation("text2"), IntegerRef("n", 1, 50000), Integer("w", 0, 10), Integer("x", 0, 10), Integer("y", 0, 10), Integer("z", 0, 10) ] defaults = {"t": 1, "text": "", "text2": ""}
def find(self, back, go, text=None, punctuation=None, a=None, b=None, c=None): '''set direction''' key = "b" if back else "o" Key("a-" + key).execute() '''figure out what to search for''' if text is not None: text = str(text) '''simple vowel-removal regex''' if self.regex: text = re.sub("[aeiouAEIOU]+", r".*", text) if text.endswith(r".*"): text = text[:-2] elif punctuation is not None: text = str(punctuation) self.regex_off() elif a is not None: a = str(a) b = str(b) if b is not None else "" c = str(c) if c is not None else "" text = a + b + c self.regex_off() Text(text).execute() '''"go" indicates that we should keep looking''' if go: u = UntilCancelled(Key("enter"), 2) u.show = False u.execute() else: Key("enter, escape").execute()
class EmacsGroupingSymbols(MappingRule): mapping = { 'angle': Key('langle, rangle, left'), 'arc': Key('lparen, rparen, left'), 'curly': Key('lbrace, rbrace, left'), 'double': Key('dquote, dquote, left'), 'single': Key('squote, squote, left'), 'square': Key('lbracket, rbracket, left'), }
class NetrwRule(MappingRule): exported = True mapping = { "explore here": Text(":Explore") + Key("enter"), "explore fault": Text(":Vexplore") + Key("enter"), "explore split": Text(":Sexplore") + Key("enter"), "explore tab": Text(":Texplore") + Key("enter"), "explore back": Text(":Rexplore") + Key("enter"), "create net file": Key('%%'), "create net directory": Key('d') } extras = [] defaults = {}
class InsertModeStartRule(MappingRule): exported = True mapping = { "change <motion> [<text>]": Key("c") + execute_rule('motion') + Text('%(text)s'), "change <object> [<text>]": Key("c") + execute_rule('object') + Text('%(text)s'), "change line [<text>]": Key("c,c") + Text('%(text)s'), "insert [<text>]": Key("i") + Text('%(text)s'), "prepend [<text>]": Key("I") + Text('%(text)s'), "after [<text>]": Key("a") + Text('%(text)s'), "append [<text>]": Key("A") + Text('%(text)s'), "oh [<text>]": Key("o") + Text('%(text)s'), "bo [<text>]": Key("O") + Text('%(text)s'), "insert last [<text>]": Key("g, i") + Text('%(text)s'), } extras = [ RuleRef(rule = motion.MotionRule(name = "insert_motion"), name = "motion"), RuleRef(rule = object.ObjectRule(name = "insert_object"), name = "object"), Dictation("text"), ] defaults = { "text": "", }
def do_scratch_n_times(self, n): for _ in range(n): try: # Get the number of characters to delete from the current # window's stack. Discard the state flags. scratch_number, _ = self._get_window_stack().pop() Key("backspace:%d" % scratch_number).execute() except IndexError: handle = self._current_window_handle window = Window.get_window(handle) exe = os.path.basename(window.executable) title = window.title print("Nothing in scratch memory for %r window " "(title=%r, id=%d)" % (exe, title, handle)) break
class GlobalClionMappings(MappingRule): mapping = { #ide shortcuts "helper": Key("a-enter"), "reformat": Key("ctrl:down, a-l, ctrl:up"), "project": Key("ctrl:down, tab:down/10,1/10,tab:up,ctrl:up"), "rename": Key("shift:down,f6/10, shift:up"), "run": Key("s-f10"), "debug": Key("s-f9"), "build": Key("c-f9"), "stop": Key("c-f2"), } extras = [ Dictation("text"), Integer("n", 0, 50), Integer("line", 1, 10000) ]
def find(letter, n): f = Key('f') for i in range(n): f.execute() letter.execute()