def cross_platform_title_match(title):
"""
Match title on both windows and any proxy.
Parameters
----------
title: str
title to (partially) match
Raises
------
None
Returns
-------
dragonfly.LogicOrContext
Examples
--------
..doctest::
>>> TODO
"""
return AppContext(title=title) | \
ProxyAppContext(title=title)
def terminal():
"""
Matches terminal applications.
Matches PuTTY on windows or terminator on linux.
Raises
------
None
Returns
-------
dragonfly.LogicOrContext
Examples
--------
..doctest::
>>> terminal()
LogicOrContext(...)
"""
return AppContext('putty') | \
ProxyAppContext(cls='terminator')
from magneto.mergerule import MergeRule
from magneto import settings
from magneto.settings import ModuleDictionary
from magneto.modules.core.copypaste import CLIPBOARD
print('loading copypaste rules')
try:
import aenea.communications
except ImportError:
print 'Unable to import Aenea client-side modules.'
raise
bash_context = AeneaContext(
ProxyAppContext(cls_name='Terminal', cls='Terminal'),
AppContext(executable='Terminal')
)
bash_grammar = Grammar('bash', context=bash_context)
dictionary = ModuleDictionary("apps\\bash")
def paste(t,n):
if n != 0:
t=n
if t=="default":
Key("cs-v").execute()
else:
AeneaContext,
AppContext,
Dictation,
Grammar,
IntegerRef,
Key,
MappingRule,
ProxyAppContext,
Text,
Pause,
Function
)
nixContext = aenea.AeneaContext(
ProxyAppContext(match='regex', title='community edition'),
(AppContext(title="intell") | AppContext(title="pycharm"))
)
terminator_grammar = Grammar("jidea")
class jideaRule(MappingRule):
mapping = aenea.configuration.make_grammar_commands('jidea', {
"all actions": Key("cs-a"),
# Code execution.
"run app": Key("s-f10"),
"re-run app": Key("c-f5"),
"run test": Key("cs-f10"),
"stop running": Key("c-f2"),
from dragonfly import (
Choice,
Function,
Playback,
)
from aenea import (AeneaContext, AppContext, Grammar, IntegerRef, Key, Literal,
ProxyAppContext, MappingRule, NeverContext, Repetition,
Repeat, RuleRef, Sequence, Text)
from magneto.mergerule import MergeRule
from magneto.settings import ModuleDictionary
sublime_context = AeneaContext(
ProxyAppContext(cls_name='Sublime', cls='Sublime'),
AppContext(executable='Sublime'))
sublime_grammar = Grammar('sublime', context=sublime_context)
dictionary = ModuleDictionary("apps\\sublime")
def go_to_line(n1000):
Key("c-g").execute()
Text(str(n1000)).execute()
Key("enter").execute()
class Sublime(MergeRule):
mapping = {
# zoom
'zoom in [<n>]': Key('c-plus:%(n)d'),
'zoom out [<n>]': Key('c-minus:%(n)d'),
# scroll slow
'slide': Key('c-0'),
})
extras = [IntegerRef('n', 1, 100), Dictation('text')]
defaults = {
'n': 1,
'text': ''
}
chromium_context = aenea.AeneaContext(
ProxyAppContext(match='regex', title='(?i).*chrome.*'),
AppContext(title='chrome')
)
chromium_grammar = Grammar('chromium', context=chromium_context)
chromium_grammar.add_rule(ChromiumRule())
chromium_grammar.load()
def unload():
global chromium_grammar
if chromium_grammar:
chromium_grammar.unload()
chromium_grammar = None
#print "Calling showMouseGrid(cancel) on the server to hide the MouseGrid"
# Run our aenea plugin script that shows the mouse grid fullscreen in Linux.
#aenea.communications.server.showMouseGrid("cancel")
print "Sending Escape to cancel the mouse grid"
action = Key("escape")
action.execute()
class MouseCancelRule(MappingRule):
mapping = {
"cancel": Function(cancelMouseGrid),
}
contextMini = ProxyAppContext(title="InvisibleWindow - Mini")
grammarMini = Grammar('extra symbols mini grammar', context=contextMini)
grammarMini.add_rule(ExtraSymbolsMiniGridRule())
grammarMini.add_rule(MouseCancelRule())
grammarMini.add_rule(MouseActionGridRule())
grammarMini.load()
contextFull = ProxyAppContext(title="InvisibleWindow - Full")
grammarFull = Grammar('extra symbols full grammar', context=contextFull)
grammarFull.add_rule(ExtraSymbolsFullGridRule())
grammarFull.add_rule(MouseCancelRule())
grammarFull.add_rule(MouseActionGridRule())
grammarFull.load()
def unload():
mapping = {
'open terminal': Key('control:down, alt:down, t, control:up, alt:up'),
'cancel': Key('c-c'),
# fzf
'get command [<text>]': Key('c-r') + Pause('200') + Text('%(text)s'),
'get file': Key('c-t'),
'get folder': Key('a-c'),
# copy/paste terminal
'copy raw': Key('cs-c'),
'plop raw': Key('cs-v'),
}
extras = [IntegerRef('n', 1, 10), Dictation('text')]
defaults = {'n': 1, 'text': ''}
chromium_context = aenea.AeneaContext(
ProxyAppContext(match='regex', title='(?i).*terminal.*'),
AppContext(title='chrome'))
grammar = Grammar('terminal')
grammar.add_rule(MappingTerminal())
grammar.load()
def unload():
global grammar
if grammar:
grammar.unload()
grammar = None
"X D O tool": Text("xdotool "),
"X M L lint": Text("xmllint "),
"X M L lint <text>": Text("xmllint %(text)s"),
"X M L lint format": Text("xmllint -format "),
"X M L lint format <text>": Text("xmllint -format %(text)s"),
"X M L lint schema": Text("xmllint -schema "),
"X M L lint schema <text>": Text("xmllint -schema %(text)s"),
"X prop": Text("xprop "),
"X win info": Text("xwininfo "),
},
extras=[IntegerRef('n', 1, 10), Dictation('text')]
)
context = aenea.AeneaContext(
ProxyAppContext(match='regex', title='fish'),
(AppContext(executable='python'))
)
terminator_grammar = Grammar("Terminator general", context=context)
terminator_grammar.add_rule(rules)
terminator_grammar.load()
def unload():
global terminator_grammar
if terminator_grammar:
terminator_grammar.unload()
grammar = None
if local_disable_setting is not None:
if not isinstance(local_disable_setting, basestring):
print 'Local disable context may only be a string.'
else:
local_disable_context = AppContext(str(local_disable_setting))
proxy_disable_setting = conf.get('proxy_disable_context', None)
proxy_disable_context = NeverContext()
if proxy_disable_setting is not None:
if isinstance(proxy_disable_setting, dict):
d = {}
for k, v in proxy_disable_setting.iteritems():
d[str(k)] = str(v)
proxy_disable_context = ProxyAppContext(**d)
else:
proxy_disable_context = ProxyAppContext(
title=str(proxy_disable_setting),
match='substring'
)
context = AeneaContext(proxy_disable_context, local_disable_context)
grammar = Grammar('multiedit', context=~context)
grammar.add_rule(RepeatRule(extras=extras + [format_rule, Alternative(finishes, name='finish')], name='a'))
grammar.add_rule(LiteralRule())
grammar.load()