def __init__(self,
name=None,
mapping=None,
extras=None,
defaults=None,
exported=None,
ID=None,
composite=None,
compatible=None,
mcontext=None,
mwith=None):
self.ID = ID if ID is not None else MergeRule._get_next_id()
self.compatible = {} if compatible is None else compatible
'''composite is the IDs of the rules which this MergeRule is composed of: '''
self.composite = composite if composite is not None else set([self.ID])
self._mcontext = self.__class__.mcontext
if self._mcontext is None: self._mcontext = mcontext
self._mwith = self.__class__.mwith
if self._mwith is None: self._mwith = mwith
if mapping is not None:
mapping["display available commands"] = Function(
lambda: self._display_available_commands())
MappingRule.__init__(self, name, mapping, extras, defaults, exported)
def __init__(self, node, grammar, stat_msg=None, is_reset=False):
# for self modification
self.node = node
first = False
if self.master_node == None:
self.master_node = self.node
first = True
self.post = ContextSeeker(forward=[L(S(["cancel"], self.reset_node, consume=False))], rspec=self.master_node.spec)
if self.stat_msg == None:
self.stat_msg = stat_msg
mapping = {}
extras = []
defaults = {}
# each child node gets turned into a mapping key/value
for child in self.node.children:
child.fill_out_rule(mapping, extras, defaults, self)
if len(mapping)==0:
if self.stat_msg!=None and not first:
self.stat_msg.text("Node Reset")# status window messaging
self.reset_node()
for child in self.node.children:
child.fill_out_rule(mapping, extras, defaults, self)
else:
if self.stat_msg!=None and not first and not is_reset:# status window messaging
self.stat_msg.hint("\n".join([x.get_spec_and_base_and_node()[0] for x in self.node.children]))
MappingRule.__init__(self, "node_" + str(self.master_node.spec), mapping, extras, defaults)
self.grammar = grammar
def __init__(self, node, grammar, stat_msg=None, is_reset=False):
# for self modification
self.node = node
first = False
if self.master_node == None:
self.master_node = self.node
first = True
self.post = ContextSeeker(forward=[L(S(["cancel"], self.reset_node, consume=False),
S([self.master_node.spec], lambda: None, consume=False))],
rspec=self.master_node.spec)
if self.stat_msg == None:
self.stat_msg = stat_msg
mapping = {}
extras = []
defaults = {}
# each child node gets turned into a mapping key/value
for child in self.node.children:
child.fill_out_rule(mapping, extras, defaults, self)
if len(mapping)==0:
if self.stat_msg!=None and not first:
self.stat_msg.text("Node Reset")# status window messaging
self.reset_node()
for child in self.node.children:
child.fill_out_rule(mapping, extras, defaults, self)
else:
if self.stat_msg!=None and not first and not is_reset:# status window messaging
self.stat_msg.hint("\n".join([x.get_spec_and_base_and_node()[0] for x in self.node.children]))
MappingRule.__init__(self, "node_" + str(self.master_node.spec), mapping, extras, defaults)
self.grammar = grammar
def __init__(self, name = None, repeatables = None, finishers = None, max = 10, exported = True): if repeatables is None: repeatables = self.repeatables if finishers is None: finishers = self.finishers repeatablesRule = Repetition(Alternative(repeatables), min=1, max=max, name='repeatables') finishersRule = Alternative(finishers, name='finishers') extras = [repeatablesRule, finishersRule] MappingRule.__init__(self, name = name, extras = extras, exported = exported)
def refresh():
''' 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()
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"),
}
grammar.add_rule(MappingRule(name="sik", mapping=mapping))
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 generate_rule(path):
configuration = ConfigDev("dev")
configuration.load(path)
return MappingRule(exported=True,
mapping=configuration.cmd.map,
extras=configuration.cmd.extras,
defaults=configuration.cmd.defaults)
def __init__(
self,
name,
options,
alias=None,
base_options=[],
):
alias = alias or name
self.base_options = base_options
super(GitCommandRule, self).__init__(
name=name,
spec='[help] ({}) <options>'.format(alias),
exported=False,
extras=[
Repetition(
name='options',
min=0,
max=10,
child=RuleRef(
MappingRule(
name=name + '_options',
mapping=options,
exported=False,
)),
)
],
)
def buildFinalMergedRule(self):
#log.info("Building final merged rule.")
if not self.seriesRules and not self.terminatorRule:
return
extras = []
seriesRefNames = []
for i, r in enumerate(self.seriesRules):
name = "s" + str(i)
seriesRefNames.append(name)
ref = dfly.RuleRef(self.concreteRules[r], name)
extras.append(ref)
seriesPart = "[" + " | ".join([("<" + r + ">") for r in seriesRefNames]) + "]"
terminatorPart = ""
if self.terminatorRule:
extras.append(dfly.RuleRef(self.concreteRules[self.terminatorRule], "terminator"))
terminatorPart = " [<terminator>]"
masterPhrase = seriesPart + terminatorPart
mapping = {
masterPhrase : ReportingAction(masterPhrase, self.client, self.hash)
}
log.info("Building master grammar rule with name [%s] mapping [%s] extras [%s] defaults [%s]"
% (self.fullName, mapping, extras, {}))
masterTimeStart = time.time()
self.finalDflyRule = MappingRule(name=self.hash, mapping=mapping, extras=extras,
defaults={}, exported=True)
masterTimeEnd = time.time()
log.info("Master rule construction time: %ss" % (masterTimeEnd - masterTimeStart))
def create_rule(name, action_map, element_map, exported=False, context=None):
"""Creates a rule with the given name, binding the given element map to the
action map.
"""
return MappingRule(name,
action_map,
element_map_to_extras(element_map),
element_map_to_defaults(element_map),
exported,
context=context)
def __init__(self, mapping, extras=None, defaults=None):
mapping_rule = MappingRule(mapping=mapping, extras=extras,
defaults=defaults, exported=False)
single = RuleRef(rule=mapping_rule)
series = Repetition(single, min=1, max=16, name="series")
compound_spec = "<series>"
compound_extras = [series]
CompoundRule.__init__(self, spec=compound_spec,
extras=compound_extras, exported=True)
class ExclusiveManager:
"""
Loads and switches exclusivity for caster modes
:param mode: str
:param modetype: 'mic_mode' or 'engine_mode' str
"""
# TODO: Implement set_engine_mode exclusivity with mode rules.
# TODO: Implement timer for sleep mode.
# TODO: Implement hotkey for microphone on-off
sleep_grammar = None
sleeping = False
sleep_rule = MappingRule(
name="sleep_rule",
mapping={
"caster <mic_mode>":
Function(lambda mic_mode: EngineModesManager.set_mic_mode(
mode=mic_mode)),
"<text>":
Function(lambda text: False)
},
extras=[
Choice("mic_mode", {
"off": "off",
"on": "on",
"sleep": "sleeping",
}),
Dictation("text")
],
context=FuncContext(lambda: ExclusiveManager.sleeping),
)
def __init__(self, mode, modetype):
if modetype == "mic_mode":
if not isinstance(ExclusiveManager.sleep_grammar, Grammar):
grammar = ExclusiveManager.sleep_grammar = Grammar("sleeping")
grammar.add_rule(self.sleep_rule)
grammar.load()
if mode == "sleeping":
self.set_exclusive(state=True)
printer.out("Caster: Microphone is sleeping")
if mode == "on":
self.set_exclusive(state=False)
printer.out("Caster: Microphone is on")
if mode == "off":
printer.out("Caster: Microphone is off")
else:
printer.out("{}, {} not implemented".format(mode, modetype))
def set_exclusive(self, state):
grammar = ExclusiveManager.sleep_grammar
ExclusiveManager.sleeping = state
grammar.set_exclusive(state)
get_engine().process_grammars_context()
def value(self, node):
value = MappingRule.value(self, node)
if value == 'tcomment':
# ugly hack to get around tComment's not allowing ranges with gcc.
value = node.children[0].children[0].children[0].children[1].value()
if value in (1, '1', None):
return Text('gcc')
else:
return Text('gc%dj' % (int(value) - 1))
else:
return value
def value(self, node):
value = MappingRule.value(self, node)
if value == 'tcomment':
# ugly hack to get around tComment's not allowing ranges with gcc.
value = node.children[0].children[0].children[0].children[1].value()
if value in (1, '1', None):
return Text('gcc')
else:
return Text('gc%dj' % (int(value) - 1))
else:
return value
def _combine_mapping_rules(self, name, base_rule, extension_rule, context):
mapping = base_rule._mapping.copy()
mapping.update(extension_rule._mapping)
extras_dict = base_rule._extras.copy()
extras_dict.update(extension_rule._extras)
extras = extras_dict.values()
defaults = base_rule._defaults.copy()
defaults.update(extension_rule._defaults)
exported = base_rule._exported
return MappingRule(name, mapping, extras, defaults, exported, context)
def generate_commands(list_of_functions):
global server_proxy
global grammar
mapping = {}
for fname in list_of_functions:
spec = " ".join(fname.split("_"))
mapping[spec] = Function(execute, fname=fname)
grammar.unload()
grammar = Grammar("sikuli")
grammar.add_rule(MappingRule(mapping=mapping, name="sikuli server"))
grammar.load()
def value(self, node):
value = MappingRule.value(self, node)
if value == "tcomment":
try:
# ugly hack to get around tComment's not allowing ranges with gcc.
value = node.children[0].children[0].children[0].children[1].value()
if value in (1, "1", None):
return Text("gcc")
else:
return Text("gc%dj" % (int(value) - 1))
except Exception, ex:
print ex
def create_grammar():
grammar = Grammar("global state")
grammar.add_rule(
MappingRule(
mapping={
"mark": Function(__toggle_marking),
"cursor": Function(__toggle_cursor),
"done": Function(remove_nesting_level),
"done all": Function(remove_nesting_levels),
"dictate": Function(__start_dictating),
"finish": Function(__stop_dictating)
}))
return grammar, True
def load_sleep_wake_grammar(initial_awake):
sleep_grammar = Grammar("sleep")
def sleep(force=False):
global sleeping
if not sleeping or force:
sleeping = True
sleep_grammar.set_exclusiveness(True)
notify('Sleeping...')
def wake(force=False):
global sleeping
if sleeping or force:
sleeping = False
sleep_grammar.set_exclusiveness(False)
notify('Awake...')
def halt(force=False):
exit(0)
class SleepRule(MappingRule):
mapping = {
'dragonfly exit':
Function(halt),
"start listening":
Function(wake) +
Function(lambda: get_engine().start_saving_adaptation_state()),
"stop listening":
Function(lambda: get_engine().stop_saving_adaptation_state()) +
Function(sleep),
"halt listening":
Function(lambda: get_engine().stop_saving_adaptation_state()) +
Function(sleep),
}
sleep_grammar.add_rule(SleepRule())
sleep_noise_rule = MappingRule(
name="sleep_noise_rule",
mapping={"<text>": Function(lambda text: False and print(text))},
extras=[Dictation("text")],
context=FuncContext(lambda: sleeping),
)
sleep_grammar.add_rule(sleep_noise_rule)
sleep_grammar.load()
if initial_awake:
wake(force=True)
else:
sleep(force=True)
def __init__(self):
commands = git_commands.all_commands(GitCommandRuleBuilder)
spec = '[<cancel>] git [<command_with_options>] [<enter>] [<cancel>]'
super(GitRule, self).__init__(
spec=spec,
extras=[
RuleRef(name='cancel',
rule=MappingRule(
name='cancel',
mapping={'cancel [last]': Key('c-c')},
)),
Alternative(
name='command_with_options',
children=commands,
),
RuleRef(name='enter',
rule=MappingRule(
name='enter',
mapping={'enter': Key('enter')},
)),
],
)
def test_list_grammars(self):
""" Verify that the 'list_grammars' RPC method works correctly. """
# Load a Grammar with three rules and check that the RPC returns the
# correct data for them.
g = Grammar("list_grammars_test")
g.add_rule(CompoundRule(name="compound", spec="testing",
exported=True))
g.add_rule(
MappingRule(name="mapping",
mapping={
"command a": ActionBase(),
"command b": ActionBase()
}))
g.add_rule(
Rule(name="base", element=Literal("hello world"), exported=False))
g.load()
response = self.send_request("list_grammars", [])
expected_grammar_data = {
"name":
g.name,
"enabled":
True,
"active":
True,
"rules": [{
"name": "compound",
"specs": ["testing"],
"exported": True,
"active": True
}, {
"name": "mapping",
"specs": ["command a", "command b"],
"exported": True,
"active": True
}, {
"name": "base",
"specs": ["hello world"],
"exported": False,
"active": True
}]
}
# Check that the loaded grammar appears in the result. It might not
# be the only grammar and that is acceptable because dragonfly's
# tests can be run while user grammars are loaded.
try:
self.assertIn("result", response)
self.assertIn(expected_grammar_data, response["result"])
finally:
g.unload()
def create_grammar(self, g, t):
rule = MappingRule(
mapping={
t("scroll"):
Function(lambda: self.toggle_scroll()),
t("right_click"):
Mouse("right"),
"\"" + t("left_click") + "|" + t("click") + "|" + t("focus") + "\"":
Mouse("left"),
"\"" + t("double_click") + "|" + t("double") + "|" + t("open") + "|" + t("select") + "\"":
Mouse("left/3, left/3"),
})
g.add_rule(rule)
return True
def load_noise_grammar():
noise_grammar = Grammar("noise")
noise_grammar.add_rule(
MappingRule(
name='noise',
mapping={
"<text> {weight=10}":
Function(lambda text: print('Noise: ', text))
},
extras=[Dictation("text")],
))
noise_grammar.load()
def __init__(self,
name=None,
mapping=None,
extras=None,
defaults=None,
exported=None,
ID=None,
composite=None,
compatible=None,
mcontext=None,
mwith=None):
self.ID = ID if ID is not None else MergeRule._get_next_id()
self.compatible = {} if compatible is None else compatible
'''composite is the IDs of the rules which this MergeRule is composed of: '''
self.composite = composite if composite is not None else set([self.ID])
self._mcontext = self.__class__.mcontext
if self._mcontext is None: self._mcontext = mcontext
self._mwith = self.__class__.mwith
if self._mwith is None: self._mwith = mwith
self.extras.extend(self.default_extras)
MappingRule.__init__(self, name, mapping, extras, defaults, exported)
def load_sleep_wake_grammar(initial_awake):
sleep_grammar = Grammar("sleep")
def sleep(force=False):
global sleeping
if not sleeping or force:
sleeping = True
sleep_grammar.set_exclusiveness(True)
notify('sleep')
def wake(force=False):
global sleeping
if sleeping or force:
sleeping = False
sleep_grammar.set_exclusiveness(False)
notify('wake')
class SleepRule(MappingRule):
mapping = {
"listen to me":
Function(wake) +
Function(lambda: get_engine().start_saving_adaptation_state()),
"(go to sleep)|(stop listening)":
Function(lambda: get_engine().stop_saving_adaptation_state()) +
Function(sleep),
# "halt listening": Function(lambda: get_engine().stop_saving_adaptation_state()) + Function(sleep),
}
sleep_grammar.add_rule(SleepRule())
sleep_noise_rule = MappingRule(
name="sleep_noise_rule",
mapping={
"<text>":
Function(lambda text: False and print("(asleep) " + text))
},
extras=[Dictation("text")],
context=FuncContext(lambda: sleeping),
)
sleep_grammar.add_rule(sleep_noise_rule)
sleep_grammar.load()
if initial_awake:
wake(force=True)
else:
sleep(force=True)
def load_sleep_wake_grammar(initial_awake):
sleep_grammar = Grammar("sleep")
def sleep(force=False):
global sleeping
if not sleeping or force:
sleeping = True
sleep_grammar.set_exclusiveness(True)
get_engine().process_grammars_context()
notify('sleep')
def wake(force=False):
global sleeping
if sleeping or force:
sleeping = False
sleep_grammar.set_exclusiveness(False)
get_engine().process_grammars_context()
notify('wake')
class SleepRule(MappingRule):
mapping = {
"start listening": Function(wake),
"stop listening": Function(sleep),
"halt listening": Function(sleep),
}
sleep_grammar.add_rule(SleepRule())
sleep_noise_rule = MappingRule(
name="sleep_noise_rule",
mapping={"<text>": Function(lambda text: False and print(text))},
extras=[Dictation("text")],
context=FuncContext(lambda: sleeping),
)
sleep_grammar.add_rule(sleep_noise_rule)
sleep_grammar.load()
if initial_awake:
wake(force=True)
else:
sleep(force=True)
grammar_context = AppContext(executable="outlook")
grammar = Grammar("outlook_example", context=grammar_context)
#---------------------------------------------------------------------------
# Create a rule for static keyboard shortcuts.
static_rule = MappingRule(
name="static",
mapping={
"new folder": Key("cs-e"),
"new email": Key("cs-m"),
"new appointment": Key("cs-a"),
"new meeting request": Key("cs-q"),
"new contact": Key("cs-c"),
"new distribution list": Key("cs-l"),
"new note": Key("cs-n"),
"new task": Key("cs-k"),
"accept and edit": Key("a-a, c, e, enter"),
"accept and send": Key("a-a, c, s, enter"),
"accept without response": Key("a-a, c, d, enter"),
"tentative and edit": Key("a-a, a, e, enter"),
"tentative and send": Key("a-a, a, s, enter"),
"tentative without response": Key("a-a, a, d, enter"),
"folder": Key("c-y"),
},
)
# Add the action rule to the grammar instance.
grammar.add_rule(static_rule)
#---------------------------------------------------------------------------
# Create a rule for our list of folders.
def value(self, node):
return Text(MappingRule.value(self, node))
DictListRef(
'dynamic vim.insertions',
aenea.vocabulary.register_dynamic_vocabulary('vim.insertions')),
ruleArithmeticInsertion,
ruleSpellingInsertion,
]
static_code_insertions = aenea.vocabulary.get_static_vocabulary(
'vim.insertions.code')
static_insertions = aenea.vocabulary.get_static_vocabulary('vim.insertions')
if static_code_insertions:
primitive_insertions.append(
RuleRef(
MappingRule('static vim.insertions,code mapping',
mapping=aenea.vocabulary.get_static_vocabulary(
'vim.insertions.code')),
'static vim.insertions.code'))
if static_insertions:
primitive_insertions.append(
RuleRef(
MappingRule('static vim.insertions mapping',
mapping=aenea.vocabulary.get_static_vocabulary(
'vim.insertions')), 'static vim.insertions'))
class PrimitiveInsertion(CompoundRule):
spec = '<insertion>'
extras = [Alternative(primitive_insertions, name='insertion')]
rules = MappingRule(
mapping={
# Commands and keywords:
"and": Text(" and "),
"as": Text("as "),
"assign": Text(" = "),
"assert": Text("assert "),
"break": Text("break"),
"comment": Text("# "),
"class": Text("class "),
"class <text>": Function(define_class),
"continue": Text("continue"),
"del": Text("del "),
"divided by": Text(" / "),
"(dict|dictionary) key value": Text("\"\": \"\",") + Key("left:6"),
"enumerate": Text("enumerate()") + Key("left"),
"(def|define|definition) [function]": Text("def "),
"(def|define|definition) [function] <text>": Function(define_function),
"(def|define|definition) method <text>": Function(define_method),
"(def|define|definition) init": Text("def __init__("),
"doc string": Text('"""Doc string."""') + Key("left:14, s-right:11"),
"else": Text("else:") + Key("enter"),
"except": Text("except "),
"exec": Text("exec "),
"(el if|else if)": Text("elif "),
"(el if|else if) <text>": SCText("elif %(text)s"),
"equals": Text(" == "),
"false": Text("False"),
"finally": Text("finally:") + Key("enter"),
"for": Text("for "),
"for <text>": SCText("for %(text)s"),
"from": Text("from "),
"from <text>": SCText("from %(text)s"),
"global ": Text("global "),
"greater than": Text(" > "),
"greater [than] equals": Text(" >= "),
"if": Text("if "),
"if <text>": SCText("if %(text)s"),
"in": Text(" in "),
"in <text>": SCText("in %(text)s"),
"(int|I N T)": Text("int"),
"(int|I N T)": Text("int()") + Key("left"),
"init": Text("init"),
"import": Text("import "),
"import <text>": SCText("import %(text)s"),
"(len|L E N)": Text("len("),
"lambda": Text("lambda "),
"less than": Text(" < "),
"less [than] equals": Text(" <= "),
"(minus|subtract|subtraction)": Text(" - "),
"(minus|subtract|subtraction) equals": Text(" -= "),
"modulo": Key("space") + Key("percent") + Key("space"),
"not": Text(" not "),
"not equals": Text(" != "),
"none": Text("None"),
"or": Text(" or "),
"pass": Text("pass"),
"(plus|add|addition)": Text(" + "),
"(plus|add|addition) equals": Text(" += "),
"print": Text("print()") + Key("left"),
"raise": Text("raise"),
"raise exception": Text("raise Exception()") + Key("left"),
"return": Text("return"),
"return <text>": SCText("return %(text)s"),
"self": Text("self"),
"(str|S T R)": Text("str"),
"(str|S T R) paren": Text("str()") + Key("left"),
"true": Text("True"),
"try": Text("try:") + Key("enter"),
"times": Text(" * "),
"with": Text("with "),
"while": Text("while "),
"yield": Text("yield "),
# Some common modules.
"datetime": Text("datetime"),
"(io|I O)": Text("io"),
"logging": Text("logging"),
"(os|O S)": Text("os"),
"(pdb|P D B)": Text("pdb"),
"(re|R E)": Text("re"),
"(sys|S Y S)": Text("sys"),
"S Q lite 3": Text("sqlite3"),
"subprocess": Text("subprocess"),
},
extras=[
IntegerRef("n", 1, 100),
Dictation("text"),
],
defaults={
"n": 1
}
)
putty_rule = MappingRule(
name="putty",
mapping={
# characters
"(tab|tabby|Debbie)" : Key("tab"),
"Shift (tab|tabby|Debbie)" : Key("s-tab"),
"(slap|newline|enter)" : Key("enter"),
"(splat|star|asterisk)" : Key("asterisk"),
"(hash|hashtag)" : Key("hash"),
"(minus|dash|tack|hyphen)" : Key("hyphen"),
"(dashdash|tacktack)" : Key("hyphen,hyphen"),
"interupt" : Key("c-c"), # ctrl-c sends SIGINT
"end of file" : Key("c-d"), # ctrl-d send EOF
# shell commands
"(cd|change directory)" : Text("cd "),
"(l s|ellis|ls|list files)" : Text("ls "),
"(pwd|print working directory)" : Text("pwd ") + Key("enter"),
"(vi|v i|vim)" : Text("vim "),
"configure" : Text("./configure"),
"make" : Text("make "),
"make install" : Text("make install "),
"get init" : Text("git init "),
"get clone" : Text("git clone "),
"get add" : Text("git add "),
"get commit" : Text('git commit -m ""') + Key("left"),
"get status" : Text("git status ") + Key("enter"),
"get push" : Text("git push "),
"get push origin master" : Text("git push origin master "),
"get pull" : Text("git pull "),
"get check out" : Text("git checkout ") + Key("tab"),
"get fetch" : Text("git fetch ") + Key("tab"),
"get merge" : Text("git merge ") + Key("tab"),
"get log" : Text("git log ") + Key("enter"),
"get log pretty" : Text("git log --pretty=oneline") + Key("enter"),
"get log author" : Text('git log --author=""') + Key("left"),
"get stash save" : Text("git stash save") + Key("enter"),
"get stash pop" : Text("git stash pop") + Key("enter"),
"htop" : Text("htop") + Key("enter"),
},
extras=[
Dictation("text"),
],
)
def value(self, node): return Text(MappingRule.value(self, node))
rules = MappingRule(
mapping={
# Overall navigation.
"workspace <direction1> [<direction2>]":
Function(workspace_direction), # @IgnorePep8
"go to launcher":
Key("a-f1"),
"go to hud":
Key("win"),
"go to run":
Key("a-f2"),
"go to spread view":
Key("w-w"),
"go to expo view":
Key("w-s"),
"show panel menu":
Key("a-f10"),
"show window menu":
Key("a-space"),
# Window control
"close window":
Key("a-f4"),
"minimize window":
Key("ca-KP_Insert"),
"maximize window":
Key("cw-up"),
"restore window":
Key("cw-down"),
"move window":
Key("a-f7"),
"resize window":
Key("a-f8"),
"place window <winDirection>":
Function(window_direction),
"switch to <text>":
Function(switch_to_window),
"toggle desktop":
Key("cw-d"),
# Mouse commands.
"mouse [left] click":
Mouse("left"),
"mouse shift [left] click":
Key("shift:down/3") + Mouse("left") +
Key("shift:up/3"), # @IgnorePep8
"mouse control [left] click":
Key("ctrl:down/3") + Mouse("left") +
Key("ctrl:up/3"), # @IgnorePep8
"mouse right click":
Mouse("right"),
"mouse shift right click":
Key("shift:down/3") + Mouse("right") +
Key("shift:up/3"), # @IgnorePep8
"mouse control right click":
Key("ctrl:down/3") + Mouse("right") +
Key("ctrl:up/3"), # @IgnorePep8
"mouse <direction1> <n1> [<direction2> <n2>]":
Function(mouse_direction), # @IgnorePep8
"mouse <direction1> <direction2> <n1>":
Function(mouse_double_direction), # @IgnorePep8
# Starting applications.
"start terminal":
Key("ca-t"),
# Development option only.
"toggle host server":
Function(toggle_host_server),
},
extras=[
IntegerRef("n1", 1, 5000),
IntegerRef("n2", 1, 5000),
Dictation("text"),
Choice("direction1", basicDirections),
Choice("direction2", basicDirections),
Choice("winDirection", windowDirections),
],
defaults={"n": 1})
def load_sleep_wake_grammar(initial_awake):
sleep_grammar = Grammar("sleep")
def sleep(force=False):
get_engine().stop_saving_adaptation_state()
global sleeping
if not sleeping or force:
sleeping = True
sleep_grammar.set_exclusiveness(True)
notify('sleep')
def wake(force=False):
get_engine().start_saving_adaptation_state()
global sleeping
if sleeping or force:
sleeping = False
sleep_grammar.set_exclusiveness(False)
notify('wake')
class SleepRule(MappingRule):
mapping = {
"go to sleep":Function(sleep),
"bake up": Function(noop),
"rake up":Function(noop),
"shake up":Function(noop),
"lake up":Function(noop),
"nake up":Function(noop),
"wake tup":Function(noop),
"wake sup":Function(noop),
"whey grub":Function(noop),
"wake":Function(noop),
"wake up":Function(wake),
}
sleep_grammar.add_rule(SleepRule())
sleep_noise_rule = MappingRule(
name = "sleep_noise_rule",
mapping = { "<text>": Function(lambda text: False and print("(asleep) " + text)) },
extras = [ Dictation("text") ],
context = FuncContext(lambda: sleeping),
)
sleep_grammar.add_rule(sleep_noise_rule)
sleep_grammar.load()
# def checkIniFile():
# global sleeping
# global sleepOverride
# voice = readIni('voice')
# new_value = (voice=="off")
# if new_value:
# sleep()
# else:
# wake()
# set_interval(checkIniFile,3)
# watchingIniFile = True
if initial_awake:
wake(force=True)
else:
sleep(force=True)
from dragonfly import (Grammar, AppContext, MappingRule, Dictation, Key, Text)
firefox_context = AppContext(executable="firefox")
grammar = Grammar("firefox", context=firefox_context)
firefox_rules = MappingRule(name="firefox",
mapping={
"jump": Key("f12"),
"edit": Key("cs-f4"),
},
extras=[Dictation("text")])
grammar.add_rule(firefox_rules)
grammar.load()
def unload():
global grammar
if grammar: grammar.unload()
grammar = None