def test_mcontext(self):
python = Python()
eclipse = EclipseCCR(mcontext=AppContext(executable='test'))
self.assertIsNone(python.get_context())
self.assertIsNotNone(eclipse.get_context())
"nrw", {
"first": 1,
"second": 2,
"third": 3,
"fourth": 4,
"fifth": 5,
"sixth": 6,
"seventh": 7,
"eighth": 8,
"(ninth | last)": 9,
}),
]
defaults = {
"n": 1,
"mim": "",
}
#---------------------------------------------------------------------------
context = AppContext(executable="atom", title="Atom")
grammar = Grammar("Atom", context=context)
if settings.SETTINGS["apps"]["atom"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(AtomRule())
else:
rule = AtomRule()
gfilter.run_on(rule)
grammar.add_rule(AtomRule(name="atom"))
grammar.load()
R(Mouse("right") + Key("down:6/5, right/5, down:5/5, enter"),
rdescript="Notepad++: Remove Style"),
"preview in browser":
R(Key("cas-r"), rdescript="Notepad++: Preview In Browser"),
# requires function list plug-in:
"function list":
R(Key("cas-l"), rdescript="Notepad++: Function List"),
}
extras = [
Dictation("text"),
IntegerRefST("n", 1, 100),
IntegerRefST("n2", 1, 10),
]
defaults = {"n": 1}
#---------------------------------------------------------------------------
context = AppContext(executable="notepad++")
grammar = Grammar("Notepad++", context=context)
if settings.SETTINGS["apps"]["notepadplusplus"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(NPPRule())
else:
rule = NPPRule(name="notepad plus plus")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
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}
#---------------------------------------------------------------------------
context = AppContext(executable="javaw", title="Eclipse") | AppContext(
executable="eclipse",
title="Eclipse") | AppContext(executable="AptanaStudio3")
grammar = Grammar("Eclipse", context=context)
if settings.SETTINGS["apps"]["eclipse"]:
# if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
# control.nexus().merger.add_global_rule(EclipseRule())
# control.nexus().merger.add_global_rule(EclipseCCR())
# else:
# control.nexus().merger.add_app_rule(EclipseCCR(), context)
rule = EclipseRule(name="eclipse")
gfilter.run_on(rule)
ccr = EclipseCCR()
gfilter.run_on(ccr)
R(Key("a-f, w, t"), rdescript="Explorer: New File"),
"(show | file | folder) properties":
R(Key("a-enter"), rdescript="Explorer: Properties Dialog"),
"get up":
R(Key("a-up"), rdescript="Explorer: Navigate up"),
"get back":
R(Key("a-left"), rdescript="Explorer: Navigate back"),
"get forward":
R(Key("a-right"), rdescript="Explorer: Navigate forward"),
}
extras = [
Dictation("text"),
IntegerRefST("n", 1, 1000),
]
defaults = {"n": 1}
#---------------------------------------------------------------------------
context = AppContext(executable="explorer")
grammar = Grammar("Windows Explorer", context=context)
if settings.SETTINGS["apps"]["explorer"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(IERule())
else:
rule = IERule(name="explorer")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
Choice("cols", {
"one": "1",
"two": "2",
"three": "3",
"grid": "5",
}),
Choice("panel", {
"one": "1",
"left": "1",
"two": "2",
"right": "2",
}),
]
defaults = {
"n12": "",
"n2": 1,
"n3": 1,
}
#---------------------------------------------------------------------------
context = AppContext(executable="sublime_text", title="Sublime Text")
grammar = Grammar("Sublime", context=context)
if settings.SETTINGS["apps"]["sublime"]:
rule = SublimeRule(name="sublime")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
R(Key("c-enter"), rdescript="RStudio: Run Line"),
"run document":
R(Key("ac-r"), rdescript="RStudio: Run Document"),
"comment (line | selected)":
R(Key("cs-c"), rdescript="RStudio: Comment Line"),
"knit (document | file)":
R(Key("cs-k")),
"next plot":
R(Key("ac-f12"), rdescript="RStudio: Next Plot"),
"previous plot":
R(Key("ac-f11"), rdescript="RStudio: Previous Plot"),
"help":
R(Key("c-c, c-2, question, c-v, enter, c-1")),
}
extras = [
IntegerRefST("n", 1, 10000),
]
defaults = {}
context = AppContext(executable="rstudio")
grammar = Grammar("RStudio", context=context)
if settings.SETTINGS["apps"]["rstudio"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(RStudioRule())
else:
rule = RStudioRule()
gfilter.run_on(rule)
grammar.add_rule(RStudioRule(name="rstudio"))
grammar.load()
"step over [<n>]":
R(Key("f10/50")*Repeat(extra="n"), rdescript="SSMS: Step Over"),
"step into":
R(Key("f11"), rdescript="SSMS: Step Into"),
"step out [of]":
R(Key("s-f11"), rdescript="SSMS: Step Out"),
"resume":
R(Key("f5"), rdescript="SSMS: Resume"),
}
extras = [
Dictation("text"),
Dictation("mim"),
IntegerRefST("n", 1, 1000),
]
defaults = {"n": 1, "mim": ""}
#---------------------------------------------------------------------------
context = AppContext(executable="ssms")
grammar = Grammar("SQL Server Management Studio", context=context)
if settings.SETTINGS["apps"]["ssms"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(SSMSRule())
else:
rule = SSMSRule(name="ssms")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
Choice(
"color", {
"red": 0,
"(orange | tan | brown)": 1,
"yellow": 2,
"green": 3,
"blue": 4,
"purple": 5
}),
Choice("action", {
"kick": 0,
"psychic": 1,
}),
IntegerRefST("n", 0, 100),
]
defaults = {
"pre": 0,
"action": -1,
}
#---------------------------------------------------------------------------
context = AppContext(title="rainbowgrid")
grammar = Grammar("rainbowgrid", context=context)
if settings.SETTINGS["apps"]["rainbow"]:
rule = GridControlRule(name="rainbow")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
"(show | hide) hidden": R(Key("c-dot")),
"sort [by] name": R(Key("c-f1")),
"sort [by] size": R(Key("c-f2")),
"sort [by] (modified | date)": R(Key("c-f3")),
"(stoosh | copy) path": R(Key("f11")),
"terminal": R(Key("f9")),
"command pallette": R(Key("cs-p")),
}
extras = [
IntegerRefST("num", 1, 4),
Choice("fav", {
"example favourite": "ef",
}),
]
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()
from caster.lib.dfplus.merge.mergerule import MergeRule
from caster.lib.dfplus.state.short import R
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"}
#---------------------------------------------------------------------------
context = AppContext(executable="winword")
grammar = Grammar("Microsoft Word", context=context)
if settings.SETTINGS["apps"]["winword"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(MSWordRule())
else:
rule = MSWordRule(name="microsoft word")
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)
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()
"(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()
"developer tools": R(Key("f12"), rdescript="Browser: Developer Tools"),
"view [page] source": R(Key("c-u"), rdescript="Browser: View Page Source"),
"resume": R(Key("f8"), rdescript="Browser: Resume"),
"step over": R(Key("f10"), rdescript="Browser: Step Over"),
"step into": R(Key("f11"), rdescript="Browser: Step Into"),
"step out": R(Key("s-f11"), rdescript="Browser: Step Out"),
"IRC identify": R(Text("/msg NickServ identify PASSWORD"), rdescript="IRC Chat Channel Identify"),
}
extras = [
Dictation("dict"),
IntegerRefST("n", 1, 10),
]
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()
"step over [<n>]":
R(Key("f10/50") * Repeat(extra="n"),
rdescript="Visual Studio Code:Step Over"),
"step into":
R(Key("f11"), rdescript="Visual Studio Code:Step Into"),
"step out [of]":
R(Key("s-f11"), rdescript="Visual Studio Code:Step Out"),
"resume":
R(Key("f5"), rdescript="Visual Studio Code:Resume"),
}
extras = [
Dictation("text"),
Dictation("mim"),
IntegerRefST("n", 1, 1000),
]
defaults = {"n": 1, "mim": "", "text": ""}
#---------------------------------------------------------------------------
context = AppContext(executable="code")
grammar = Grammar("Visual Studio Code", context=context)
if settings.SETTINGS["apps"]["visualstudiocode"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(VisualStudioCodeRule())
else:
rule = VisualStudioCodeRule(name="visualstudiocode")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
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 = {}
#---------------------------------------------------------------------------
context = AppContext(executable="gitter")
grammar = Grammar("gitter", context=context)
if settings.SETTINGS["apps"]["gitter"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(GitterRule())
print("added Gitter")
else:
rule = GitterRule(name="gitter")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
R(Key("f9"), rdescript="MSVC: Breakpoint"),
"format code":
R(Key("cs-f"), rdescript="MSVC: Format Code"),
"(do imports | import all)":
R(Key("cs-o"), rdescript="MSVC: Do Imports"),
"comment line":
R(Key("c-slash"), rdescript="MSVC: Comment Line"),
"go to line":
R(Key("c-g"), rdescript="MSVC: Go To Line"),
}
extras = [
Dictation("text"),
IntegerRefST("n", 1, 1000),
]
defaults = {"n": 1}
#---------------------------------------------------------------------------
context = AppContext(executable="WDExpress")
grammar = Grammar("WDExpress", context=context)
if settings.SETTINGS["apps"]["msvc"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(MSVCRule())
else:
rule = MSVCRule(name="M S V C")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
R(Key("a-percent"), rdescript="Emacs: Interactive Search"),
"go to line <n>":
R(Key("a-x, %(n)d"), rdescript="Emacs: Go To Line"),
"prior bracket":
R(Key("escape:down, c-b, escape:up"),
rdescript="Emacs: Prior Bracket"),
"next bracket":
R(Key("escape:down, c-f, escape:up"), rdescript="Emacs: Next Bracket"),
}
extras = [
Dictation("text"),
Dictation("mim"),
IntegerRefST("n", 1, 1000),
]
defaults = {"n": 1, "mim": ""}
#---------------------------------------------------------------------------
context = AppContext(executable="emacs", title="emacs")
grammar = Grammar("emacs", context=context)
if settings.SETTINGS["apps"]["emacs"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(EmacsRule())
else:
rule = EmacsRule(name="emacs")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
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}
#---------------------------------------------------------------------------
context = AppContext(executable="FlashDevelop", title="FlashDevelop")
grammar = Grammar("FlashDevelop", context=context)
if settings.SETTINGS["apps"]["flashdevelop"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(FlashDevelopRule())
control.nexus().merger.add_global_rule(FlashDevelopCCR())
else:
control.nexus().merger.add_app_rule(
FlashDevelopCCR(name="FlashDevelop"), context)
rule = FlashDevelopRule()
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
"two": "2",
"three": "3",
"grid": "5",
}),
Choice("panel", {
"one": "1",
"left": "1",
"two": "2",
"right": "2",
}),
]
defaults = {
"n2": 1,
"n3": 1,
}
#---------------------------------------------------------------------------
context = AppContext(executable="sublime_text")
grammar = Grammar("Sublime", context=context)
if settings.SETTINGS["apps"]["sublime"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(SublimeRule())
else:
rule = SublimeRule(name="sublime")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
"step over":
R(Key("f10"), rdescript="Browser: Step Over"),
"step into":
R(Key("f11"), rdescript="Browser: Step Into"),
"step out":
R(Key("s-f11"), rdescript="Browser: Step Out"),
"IRC identify":
R(Text("/msg NickServ identify PASSWORD"),
rdescript="IRC Chat Channel Identify"),
}
extras = [
Dictation("dict"),
IntegerRefST("n", 1, 100),
]
defaults = {"n": 1, "dict": "nothing"}
#---------------------------------------------------------------------------
context = AppContext(executable="firefox")
grammar = Grammar("firefox", context=context)
if settings.SETTINGS["apps"]["firefox"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(FirefoxRule())
else:
rule = FirefoxRule(name="firefox")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
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 = {}
#---------------------------------------------------------------------------
context = AppContext(executable="cmd")
grammar = Grammar("cmd", context=context)
if settings.SETTINGS["apps"]["cmd"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(CMDRule())
print("added CMD")
else:
rule = CMDRule(name="command prompt")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
R(Key("c-tab"), rdescript="Foxit Reader: Next Tab") *
Repeat(extra="n"),
"prior tab [<n>]":
R(Key("cs-tab"), rdescript="Foxit Reader: Previous Tab") *
Repeat(extra="n"),
"close tab [<n>]":
R(Key("c-f4/20"), rdescript="Foxit Reader: Close Tab") *
Repeat(extra="n"),
}
extras = [
Dictation("text"),
Dictation("mim"),
IntegerRefST("n", 1, 1000),
]
defaults = {"n": 1, "mim": ""}
#---------------------------------------------------------------------------
context = AppContext(executable="Foxit Reader")
grammar = Grammar("Foxit Reader", context=context)
if settings.SETTINGS["apps"]["foxitreader"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(FoxitRule())
else:
rule = FoxitRule(name="Foxit Reader")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
R(Key("s-f6"), rdescript="Jet Brains: Refactor rename"),
"go to declaration":
R(Key("c-b"), rdescript="Jet Brains: Go to declaration"),
"smart kraken": #kraken is Caster default for control space
R(Key("cs-space"), rdescript="Jet Brains: Smart completion"),
}
extras = [
Dictation("text"),
Dictation("mim"),
IntegerRefST("n", 1, 1000),
]
defaults = {"n": 1, "mim": ""}
#---------------------------------------------------------------------------
context = AppContext(executable="idea", title="IntelliJ") \
| AppContext(executable="idea64", title="IntelliJ") \
| AppContext(executable="studio64") \
| AppContext(executable="pycharm")
grammar = Grammar("IntelliJ + Android Studio + PyCharm", context=context)
if settings.SETTINGS["apps"]["jetbrains"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(JetbrainsRule())
else:
rule = JetbrainsRule(name="jet brains")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
"compare (files | versions)":
R(Key("a-f, r, h"), rdescript="Visual Studio: Compare..."),
"undo (checkout | pending changes)":
R(Key("a-f, r, u"), rdescript="Visual Studio: Undo Pending Changes"),
"[open] [go to] work item":
R(Key("a-m, g"), rdescript="Visual Studio: Open Work Item"),
"[add] [new] linked work item":
R(Key("sa-l"), rdescript="Visual Studio: New Linked Work Item"),
}
extras = [
Dictation("text"),
Dictation("mim"),
IntegerRefST("n", 1, 1000),
]
defaults = {"n": 1, "mim": ""}
#---------------------------------------------------------------------------
context = AppContext(executable="devenv")
grammar = Grammar("Visual Studio", context=context)
if settings.SETTINGS["apps"]["visualstudio"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(VisualStudioRule())
else:
rule = VisualStudioRule(name="visualstudio")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
"explorer": R(Key("cs-f")),
"edit": R(Key("cs-a")),
"new branch": R(Key("cs-n")),
"rename branch": R(Key("cs-r")),
"delete branch": R(Key("cs-d")),
"update from master": R(Key("cs-u")),
"compare to [branch]": R(Key("cs-b")),
"merge into current [branch]": R(Key("cs-m")),
"compare on github": R(Key("cs-c")),
"create pull request": R(Key("c-r")),
}
extras = [
IntegerRefST("n", 1, 10),
]
defaults = {"n": 1}
#---------------------------------------------------------------------------
context = AppContext(executable="GitHubDesktop")
grammar = Grammar("GitHubDesktop", context=context)
if settings.SETTINGS["apps"]["github"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(GitHubRule())
else:
rule = GitHubRule(name="GitHubDesktop")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
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}
#---------------------------------------------------------------------------
context = AppContext(executable="sqldeveloper64W", title="SQL Developer")
grammar = Grammar("Sql Developer", context=context)
if settings.SETTINGS["apps"]["sqldeveloper"]:
if settings.SETTINGS["miscellaneous"]["rdp_mode"]:
control.nexus().merger.add_global_rule(SQLDeveloperRule())
else:
rule = SQLDeveloperRule(name="sql developer")
gfilter.run_on(rule)
grammar.add_rule(rule)
grammar.load()
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()
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()