def __init__(self, *args, **kwargs): self.spec = _("[<user> at] <server>") self.extras = [ Choice('user', {_("me"): "nihlaeth"}), Choice( 'server', { _("cerridwen"): "cerridwen", _("yemanja"): "yemanja", _("iris"): "iris", _("aine"): "aine", _("dayea"): "dayea", _("brighid"): "brighid", _("freya"): "freya", _("arthemis"): "arthemis", _("morrighan"): "morrighan", _("epona"): "epona", _("athena"): "athena", _("echo"): "echo", _("hera"): "hera", _("hera boot"): "heraboot", _("pele"): "pele", _("eileen"): "eileen", _("inanna"): "inanna.humanity4all.nl", _("anubis"): "anubis.humanity4all.nl", }) ] CompoundRule.__init__(self, *args, **kwargs)
class Basics(dragonfly.MappingRule): mapping = basics_mapping extras = [ Dictation('text'), IntegerRef('n', 1, 999), IntegerRef('n2', 1, 999), Choice("pressKey", pressKeyMap), Choice("surroundChar", surroundCharsMap), ]
class ExtraSymbolsFullGridRule(CompoundRule): spec = "<symbol1> [<mouseAction>]" extras = [ Choice("symbol1", charsDict1D_X), Choice("mouseAction", mouseActions), ] def _process_recognition(self, node, extras): doRecognitionLevel(node, extras, "Full")
class ExtraSymbolsMiniGridRule(CompoundRule): spec = "<symbol1> [<symbol2>] [<mouseAction>]" extras = [ Choice("symbol1", charsDict2D_X), Choice("symbol2", charsDict2D_Y), Choice("mouseAction", mouseActions), ] def _process_recognition(self, node, extras): print u"node", node print u"extras", extras doRecognitionLevel(node, extras, "Mini")
def __init__(self, *args, **kwargs): self.mapping = { _('open terminal'): Key('w-t'), _('workspace <n>'): Function(go_to_workspace), _('move [to] workspace <n>'): Function(move_to_workspace), _('window <direction>'): Key('w-%(direction)s'), _('move window [to the] <direction>'): Key('sw-%(direction)s'), _("fullscreen"): Key("w-f"), _("tabbed layout"): Key("w-w"), _("tiling layout"): Key("w-e"), _("stacking layout"): Key("w-s"), _("kill focused window"): Key("ws-q"), _("horizontal split"): Key("w-h"), _("vertical split"): Key("w-v"), _("toggle floating"): Key("ws-space"), _("focus floating"): Key("w-space"), _("reload i3 config file"): Key("ws-c"), _("restart i3 in place"): Key("ws-r"), _("I'm really sure I want to exit i3"): Key("ws-e"), _("resize mode"): Key("w-r"), _("invert screen rotation"): Key("ws-a"), _("reset screen rotation"): Key("ws-n"), _("(display|show) window info"): Key("ws-t"), } self.extras = [ IntegerRef('n', 1, 13), Choice( 'direction', { _('left'): 'left', _('right'): 'right', _('up'): 'up', _('down'): 'down' }), ] MappingRule.__init__(self, *args, **kwargs)
class MouseActionGridRule(CompoundRule): spec = "<mouseAction>" extras = [ Choice("mouseAction", mouseActions), ] def _process_recognition(self, node, extras): doRecognitionLevel(node, extras, "Action")
class KeystrokeRule(MappingRule): mapping = mapping extras = [ Integer("n", 1, 100), Dictation("text"), Dictation("text2"), Choice("char", specialCharMap), Choice("letters", letterMap), # Choice("modifier1", modifierMap), # Choice("modifier2", modifierMap), # Choice("modifierSingle", singleModifierMap), # Choice("pressKey", pressKeyMap), Choice("abbreviation", abbreviationMap), ] defaults = { "n": 1, "text": "", }
class MouseButtonRule(CompoundRule): spec = "<mouseAction> [<repetitions>]" extras = [ Choice("mouseAction", mouseActions), Choice("repetitions", smallNumbers), ] defaults = {"repetitions": 1} def value(self, node): # This file is imported by "_all.py" and needs to return something that has an "execute()" function. # But remote mouse actions don't have an "execute()" function, and if we directly perform mouse actions here, # they will get executed before the rest of the actions. # To support our mouse grid modes, we want the mouse action to happen at the end of the sequence, so the # user can move the mouse cursor first then click the mouse after the move. # So we'll do nothing in "value()", but we'll get "_all.py" to call "possibleMouseAction()" at the end of # the sequence. #print "MouseButtonRule is saving the words", node.words(), "to check for mouse button actions later." #self.words = node.words() return Text()
class KeystrokeRule(MappingRule): exported = False mapping = grammarCfg.cmd.map extras = [ IntegerRef("n", 1, 101), IntegerRef("num", 0, 101), IntegerRef("digit", 0, 10), IntegerRef("digit2", 0, 10), Dictation("text"), #Dictation("text2"), Choice("char", specialCharMap), Choice("letters", letterMapBothCases), #Choice("modifier1", modifierMap), #Choice("modifier2", modifierMap), #Choice("modifierSingle", singleModifierMap), #Choice("windowChars", windowCharMap), ] defaults = { "n": 1, }
def __init__(self, *args, **kwargs): self.spec = _("<operator> " "(<line>|[to] " "(<motion>|<operatormotion>) " "[<numbers>] " "[<mode> mode])") self.extras = [ Choice(name='operator', choices={ _('change'): Key('c'), _('delete'): Key('d'), _('yank'): Key('y'), _('swap case'): Key('g,tilde'), _('make lowercase'): Key('g,u'), _('make uppercase'): Key('g,s-u'), _('filter'): Key('exclamation'), _('C filter'): Key('equal'), _('text formatting'): Key('g,q'), _('rotation 13 encoding'): Key('g,question'), _('shift right'): Key('rangle'), _('shift left'): Key('langle'), _('define fold'): Key('z,f'), _('call function'): 'g,at' }), Literal(name='line', text=_('line')), Repetition(name='numbers', child=RuleRef(rule=Number()), min=0, max=3), RuleRef(name='motion', rule=MotionRule()), RuleRef(name='operatormotion', rule=VisualMotionRule()), Choice(name='mode', choices={ _("character"): Key("v"), _("line"): Key("s-v"), _("block"): Key("c-v"), }) ] CompoundRule.__init__(self, *args, **kwargs)
class KeystrokeRule(MappingRule): exported = False mapping = grammarCfg.cmd.map extras = [ IntegerRef("n", 1, 100), Dictation("text"), Dictation("text2"), Choice("char", specialCharMap), Choice("letters", letterMap), Choice("modifier1", modifierMap), Choice("modifier2", modifierMap), Choice("modifierSingle", singleModifierMap), Choice("pressKey", pressKeyMap), Choice("formatType", formatMap), Choice("abbreviation", abbreviationMap), Choice("reservedWord", reservedWord), ] defaults = { "n": 1, }
def __init__(self, *args, **kwargs): # technically we should not accept uppercase chars here self.spec = _('press [<modifiers>] <character>') self.extras = [ Repetition(name='modifiers', child=Choice(name='modifier', choices={ _('control'): 'c', _('shift'): 's', _('alt'): 'a', _('(command|super)'): 'w', }), min=0, max=4), RuleRef(name='character', rule=AnyCharacter()) ] CompoundRule.__init__(self, *args, **kwargs)
class KeystrokeRule(MappingRule): exported = False mapping = grammarCfg.cmd.map extras = [ IntegerRef("n", 1, 100), IntegerRef("num", 0, 1000000), Dictation("text"), Dictation("text2"), Choice("char", specialCharMap), Choice("letters", letterMap), Choice("modifier1", modifierMap), Choice("modifier2", modifierMap), Choice("modifierSingle", singleModifierMap), Choice("pressKey", pressKeyMap), ] defaults = { "n": 1, }
def __init__(self, name=None, spec=None, extras=None, defaults=None, exported=False, context=None, default_formatting='snake'): if exported is not None: self.exported = exported if self.exported: self.spec = "<formatting> <dictation>" else: self.default_formatting = default_formatting self.spec = "[<formatting>] <dictation>" self.extras = [ Choice( name='formatting', choices={ _("snake [case]"): "snake", # snake_case _("camel [case]"): "camel", # CamelCase _("mixed [case]"): "mixed", # mixedCase _("upper[case]"): "upper", # UPPERCASE_STUFF _("no case"): "nocase", # lowercase text _("sentence"): "sentence", # Cap first letter _("dictate"): "raw", # raw dictation }), Dictation(name='dictation'), ] CompoundRule.__init__(self, name=name, spec=spec, extras=extras, defaults=defaults, exported=exported, context=context)
class CenterMouseRule(CompoundRule): spec = "center [<mouseAction>]" extras = [ Choice("mouseAction", mouseActions), ] defaults = { # Set the default to -1 if you want "center" to just move the cursor, # or set it to 1 if you want "center" to perform a left mouse click by default. "mouseAction": 1, } def _process_recognition(self, node, extras): mouseAction = extras["mouseAction"] print "Centering the mouse." try: mouseServer.moveToCenter() except: print "Couldn't access the mouse grid server, is it running?" return # Possibly press a mouse button action action = int(mouseAction) if action >= 0: repetitions = 1 # For the special case of moving the mouse wheel, # set the repetition to be a large number, so the user doesn't have to keep repeating it so many times. # Asking for a repetition of 0 gets mapped to a scroll of 1. if action == 4 or action == 5: # Mouse wheel up & down button codes are 4 and 5. repetitions = repetitions * 3 + 1 # Set the amount to scroll print "Calling clickMouseGrid(%d) on the server" % (action) # Run our aenea plugin script that moves and clicks the mouse in Linux. for i in range(repetitions): pid = aenea.communications.server.clickMouseGrid(action) time.sleep(0.01)
_arrow_fnc_one_line() _esc() Key('s-4, a, lbrace, enter, rbrace').execute() _esc() Key('k, s-f, lparen, a').execute() ### extras = [ Integer("n", 0, 9999), Integer("n2", 0, 9999), Dictation('text'), Dictation('text2'), Choice("pressKey", pressKeyMap), ] defaults = { "n": 1, "n2": 1, } class JavascriptRuleAppend(EscapeInsertRule): mapping = { 'con <text>': Function(_const_assign), 'let <text>': Function(_let_assign), 'air lie': Function(_arrow_fnc_one_line), 'air': Function(_arrow_fnc), 'funk [<text>]': Function(_func), }
class Basics(MappingRule): mapping = basics_mapping extras = [Choice("language", language_map)]
class SQL(dragonfly.MappingRule): mapping = sql_mapping extras = [Choice( 'sqlKeyword', sql_map, )]
class NudgeMouseRule(CompoundRule): spec = "nudge <direction> [<distance>] [<mouseAction>]" extras = [ Choice("mouseAction", mouseActions), Choice("direction", { # Allow to say either up or North "North": 1, "East": 2, "South": 3, "West": 4, "North East": 5, "South East": 6, "South West": 7, "North West": 8, "up": 1, "right": 2, "down": 3, "left": 4, "up right": 5, "down right": 6, "down left": 7, "up left": 8, }), Choice("distance", mostNumbers), ] defaults = { "mouseAction": -1, # Don't click unless they ask for it } def _process_recognition(self, node, extras): direction = extras["direction"] mouseAction = extras["mouseAction"] # Figure out how much to move by distance = 7 # Default distance to nudge by try: distance = extras["distance"] except: pass print "Nudging the mouse in direction", direction, "by", distance try: if direction == 1: mouseServer.move_mouse_relative(0, -distance) elif direction == 2: mouseServer.move_mouse_relative(distance, 0) elif direction == 3: mouseServer.move_mouse_relative(0, distance) elif direction == 4: mouseServer.move_mouse_relative(-distance, 0) elif direction == 5: mouseServer.move_mouse_relative(distance, -distance) elif direction == 6: mouseServer.move_mouse_relative(distance, distance) elif direction == 7: mouseServer.move_mouse_relative(-distance, distance) elif direction == 8: mouseServer.move_mouse_relative(-distance, -distance) except: print "Couldn't access the mouse grid server, is it running?" return # Possibly press a mouse button action button_int = int(mouseAction) if button_int >= 0: print "Calling clickMouseGrid(%d) on the server" % (button_int) # Run our aenea plugin script that moves and clicks the mouse in Linux. pid = aenea.communications.server.clickMouseGrid(button_int)