mapping = {
"<n> [by] <n2> [<action>]":
R(Function(send_input, nexus=_NEXUS),
rdescript="Douglas Grid: Action"),
"exit | escape | cancel":
R(Function(kill, nexus=_NEXUS), rdescript="Exit Douglas Grid"),
}
extras = [
IntegerRefST("n", 0, 300),
IntegerRefST("n2", 0, 300),
Choice("action", {
"kick": 0,
"psychic": 1,
}),
]
defaults = {
"action": -1,
}
#---------------------------------------------------------------------------
context = AppContext(title="douglasgrid")
grammar = Grammar("douglasgrid", context=context)
if settings.SETTINGS["apps"]["douglas"]:
rule = GridControlRule(name="Douglas")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
"compare files":
R(Key('c-f3'), rdescript="Sync Dirs: compare right and left"),
"copy left":
R(Key('c-l'), rdescript="Sync Dirs: select for copying left"),
"copy right":
R(Key('c-r'), rdescript="Sync Dirs: select for copying right"),
"view right":
R(Key('s-f3'), rdescript="Sync Dirs: view right"),
"remove selection":
R(Key('c-m'), rdescript="Sync Dirs: remove selection"),
"synchronize":
R(Key('a-c'), rdescript="Total Commander: synchronize button"),
}
context = AppContext(executable="totalcmd") | AppContext(
executable="totalcmd64")
grammar = Grammar("Total Commander", context=context)
syncdir_context = AppContext(executable="totalcmd",
title='Synchronize directories')
syncdir_context |= AppContext(executable="totalcmd64",
title='Synchronize directories')
syncdir_grammar = Grammar("Total Commander Sync Dirs", context=syncdir_context)
if settings.SETTINGS["apps"]["totalcmd"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(SyncDirsRule())
control.nexus().merger.add_global_rule(TotalCommanderRule())
else:
syncdir_rule = SyncDirsRule(name="totalcmd sync dirs")
gfilter.run_on(syncdir_rule)
rdescript="GREP: Search Recursive Count"),
"search recursive filetype":
R(Text("find . -name \"*.java\" -exec grep -rinH \"PATTERN\" {} \\;"),
rdescript="GREP: Search Recursive Filetype"),
"to file":
R(Text(" > FILENAME"), rdescript="Bash: To File"),
}
extras = [
IntegerRefST("n", 1, 10000),
]
defaults = {"n": 0}
#---------------------------------------------------------------------------
context = AppContext(executable="\\sh.exe")
context2 = AppContext(executable="\\bash.exe")
context3 = AppContext(executable="\\cmd.exe")
context4 = AppContext(executable="\\mintty.exe")
grammar = Grammar("MINGW32", context=(context | context2 | context3 | context4))
if settings.SETTINGS["apps"]["gitbash"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(GitBashRule())
else:
rule = GitBashRule(name="git bash")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
"(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,
}
#---------------------------------------------------------------------------
context = AppContext(executable="lyx")
grammar = Grammar("lyx", context=context)
if settings.SETTINGS["apps"]["lyx"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(LyxRule())
else:
rule = LyxRule(name="lyx")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
def test_mcontext(self):
python = Python()
eclipse = EclipseCCR(mcontext=AppContext(executable='test'))
self.assertIsNone(python.get_context())
self.assertIsNotNone(eclipse.get_context())
}
extras = [
IntegerRefST("num", 1, 4),
Choice(
"fav", {
"advent": "adv",
"(docks | documents)": "docs",
"(downs | download)": "downs",
"git caster": "gcast",
"mike": "mike",
"user caster": "ucast",
"uni [work]": "uni",
}),
]
defaults = {
"num": 1,
}
context = AppContext(executable="fman", title="fman")
grammar = Grammar("fman", context=context)
if settings.SETTINGS["apps"]["fman"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(fmanRule())
else:
rule = fmanRule()
gfilter.run_on(rule)
grammar.add_rule(fmanRule(name="fman"))
grammar.load()
R(Function(send_input, nexus=_NEXUS), rdescript="Legion: Action"),
"refresh":
R(Function(navigation.mouse_alternates, mode="legion", nexus=_NEXUS),
rdescript="Legion: Refresh"),
"exit | escape | cancel":
R(Function(kill, nexus=_NEXUS), rdescript="Exit Legion"),
}
extras = [
Choice("action", {
"kick": 0,
"psychic": 1,
"light": 2,
}),
IntegerRefST("n", 0, 1000),
]
defaults = {
"action": -1,
}
#---------------------------------------------------------------------------
context = AppContext(title="legiongrid")
grammar = Grammar("legiongrid", context=context)
if settings.SETTINGS["apps"]["legion"]:
rule = GridControlRule(name="legion")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
from caster.lib.dfplus.state.short import R
class KDiff3Rule(MergeRule):
pronunciation = "K diff"
mapping = {
"refresh": R(Key("f5"), rdescript="Refresh"),
}
extras = [
Dictation("text"),
Dictation("mim"),
IntegerRefST("n", 1, 1000),
]
defaults = {"n": 1, "mim": ""}
#---------------------------------------------------------------------------
context = AppContext(executable="kdiff3")
grammar = Grammar("KDiff3", context=context)
if settings.SETTINGS["apps"]["kdiff3"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(KDiff3Rule())
else:
rule = KDiff3Rule(name="kdiff3")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
"numberth", {
"first": "1",
"second": "2",
"third": "3",
"fourth": "4",
"fifth": "5",
"sixth": "6",
"seventh": "7",
"eighth": "8",
"ninth": "9",
"next": "pgdown",
"previous": "pgup",
}),
]
defaults = {"n": 1, "dict": "nothing"}
#---------------------------------------------------------------------------
context = AppContext(executable="chrome")
grammar = Grammar("chrome", context=context)
if settings.SETTINGS["apps"]["chrome"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(ChromeRule())
else:
rule = ChromeRule(name="chrome")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
