def __init__(self, name):
Config.__init__(self, name)
self.cmd = Section("Language section")
self.cmd.map = Item({
"mimic <text>": Mimic(extra="text"),
},
namespace={
"Key": Key,
"Text": Text,
})
self.cmd.extras = Item([Dictation("text")])
self.cmd.defaults = Item({})
grammarCfg.cmd.map = Item(
{
### Navigation ###
"up [<n>]":
Key("up:%(n)d"),
"down [<n>]":
Key("down:%(n)d"),
"left [<n>]":
Key("left:%(n)d"),
"right [<n>]":
Key("right:%(n)d"),
"pinch [<n>]":
Key("pgup:%(n)d"),
"page [<n>]":
Key("pgdown:%(n)d"),
"left [<n>] (word|words)":
Key("c-left/3:%(n)d/10"),
"right [<n>] (word|words)":
Key("c-right/3:%(n)d/10"),
"home":
Key("home"),
"lend":
Key("end"),
"lendit":
Key("end, comma"),
"doc home":
Key("c-home/3"),
"doc end":
Key("c-end/3"),
### Selections ###
"grab <n>":
release + Key("shift:down, right:%(n)d, shift:up"),
"take <n>":
release + Key("shift:down, left:%(n)d, shift:up"),
"take <n> (line|lines)":
release + Key("end, shift:down, home, up:%(n)d, home, shift:up"),
"grab <n> (line|lines)":
release + Key("home, shift:down, down:%(n)d, end, shift:up"),
"grab <n> (word|words)":
release + Key("shift:down, c-right:%(n)d, shift:up"),
"take <n> (word|words)":
release + Key("shift:down, c-left:%(n)d, shift:up"),
"(take|grab) word":
Key("c-left, sc-right"),
"(take|grab) home":
release + Key("shift:down, home, shift:up"),
"(take|grab) end":
release + Key("shift:down, end, shift:up"),
"(take|grab) line":
release + Key("home, s-end"),
"(take|grab) all":
release + Key("c-a/3"),
### Functional keys ###
"act":
Key("escape"),
"space":
release + Key("space"),
"space [<n>]":
release + Key("space:%(n)d"),
"drop [<n>]":
release + Key("enter:%(n)d"),
"slide [<n>]":
release + Key("end, enter:%(n)d"),
"tab [<n>]":
Key("tab:%(n)d"),
### Deletions ###
"scratch [<n>]":
release + Key("backspace:%(n)d"),
"chuck [<n>]":
Key("del/3:%(n)d"),
"whack [<n>]":
Key("shift:down, c-left/3:%(n)d/10, del, shift:up"),
"bump [<n>]":
Key("shift:down, c-right/3:%(n)d/10, del, shift:up"),
"scratch [this] line":
Key("home, s-end, del"), # @IgnorePep8
"chuck [this] line":
Key("home:2, s-end, backspace:2"),
### Common functions ###
"dump [that]":
Function(paste_command),
"nab [that]":
Function(copy_command),
"cut [that]":
release + Key("c-x/3"),
"undo":
release + Key("c-z/3"),
"undo <n> [times]":
release + Key("c-z/3:%(n)d"),
"redo":
release + Key("c-y/3"),
"redo <n> [times]":
release + Key("c-y/3:%(n)d"),
"save":
release + Key("c-s"),
### Modifiers ###
"app key":
release + Key("apps/3"),
"mod key":
release + Key("win/3"),
"[(hold|press)] alt":
Key("alt:down/3"),
"release alt":
Key("alt:up"),
"[(hold|press)] shift":
Key("shift:down/3"),
"release shift":
Key("shift:up"),
"[(hold|press)] control":
Key("ctrl:down/3"),
"release control":
Key("ctrl:up"),
"release [all]":
release,
### Closures ###
"angles":
Key("langle, rangle, left/3"),
"squares":
Key("lbracket, rbracket, left/3"),
"braces":
Key("lbrace, rbrace, left/3"),
"parens":
Key("lparen, rparen, left/3"),
"quotes":
Key("dquote/3, dquote/3, left/3"),
"single quotes":
Key("squote, squote, left/3"),
### Multiple characters ###
"double <char>":
Text("%(char)s%(char)s"),
"triple <char>":
Text("%(char)s%(char)s%(char)s"),
"double escape":
Key("escape, escape"), # Exiting menus.
### Punctuation and separation
"colon [<n>]":
Key("colon/2:%(n)d"),
"(semi-colon|semicolon) [<n>]":
Key("semicolon/2:%(n)d"),
"dit [<n>]":
Key("comma/2:%(n)d"),
"drip":
Key("comma, space"),
"drip drop":
Key("comma, enter"),
"(dot|period) [<n>]":
Key("dot/2:%(n)d"),
"(dash|hyphen|minus) [<n>]":
Key("hyphen/2:%(n)d"),
"underscore [<n>]":
Key("underscore/2:%(n)d"),
# To release keyboard capture by VirtualBox.
# "press right control": Key("Control_R"),
### Formatting ###
# Formatting <n> words to the left of the cursor.
"camel <n> [words]":
Function(camel_case_count),
"pascal <n> [words]":
Function(pascal_case_count),
"snake <n> [words]":
Function(snake_case_count),
"squash <n> [words]":
Function(squash_count),
"expand <n> [words]":
Function(expand_count),
"uppercase <n> [words]":
Function(uppercase_count),
"lowercase <n> [words]":
Function(lowercase_count),
# Format dictated words. See the formatMap for all available types.
# Ex: "camel case my new variable" -> "myNewVariable"
# Ex: "snake case my new variable" -> "my_new_variable"
# Ex: "uppercase squash my new hyphen variable" -> "MYNEW-VARIABLE"
"<formatType> <text>":
Function(format_text),
# For writing words that would otherwise be characters or commands.
# Ex: "period", tab", "left", "right", "home".
"say <reservedWord>":
Text("%(reservedWord)s"),
# Abbreviate words commonly used in programming.
# Ex: arguments -> args, parameters -> params.
"short <abbreviation>":
Text("%(abbreviation)s"),
### Corrections ###
"(add|fix) missing space":
Key("c-left/3, space, c-right/3"),
"(delete|remove) (double|extra) (space|whitespace)":
Key("c-left/3, backspace, c-right/3"), # @IgnorePep8
"(delete|remove) (double|extra) (type|char|character)":
Key("c-left/3, del, c-right/3"), # @IgnorePep8
### Miscellaneous ###
# Microphone sleep/cancel started dictation.
"[<text>] (go to sleep|cancel and sleep) [<text2>]":
Function(cancel_and_sleep), # @IgnorePep8
# Reload Natlink.
# "reload Natlink": Function(reload_natlink),
"<number>":
Text("%(number)s"),
"<letter>":
Text("%(letter)s"),
"<specialChar>":
Text("%(specialChar)s"),
},
namespace={
"Key": Key,
"Text": Text,
})
grammarCfg.cmd.map = Item(
{
# Navigation keys.
"up [<n>]": Key("up:%(n)d"),
"down [<n>]": Key("down:%(n)d"),
"left [<n>]": Key("left:%(n)d"),
"right [<n>]": Key("right:%(n)d"),
"page up [<n>]": Key("pgup:%(n)d"),
"page down [<n>]": Key("pgdown:%(n)d"),
#"up <n> (page|pages)": Key("pgup:%(n)d"),
#"down <n> (page|pages)": Key("pgdown:%(n)d"),
#"left <n> (word|words)": Key("c-left/3:%(n)d/10"),
#"right <n> (word|words)": Key("c-right/3:%(n)d/10"),
# Android emulator, couldn't get own file working
"emulator back": Key("c-backspace"),
"emulator home": Key("c-h"),
"emulator overview": Key("c-o"),
"emulator left": Key("c-left"),
"emulator right": Key("c-right"),
"browser address": Key("a-d"),
"home": Key("home"),
"(end|bend|lend|dole)": Key("end"),
"doc home": Key("c-home/3"),
"doc end": Key("c-end/3"),
# Functional keys.
"space": release + Key("space"),
"space [<n>]": release + Key("space:%(n)d"),
"(enter|slap|slop) [<n>]": release + Key("enter:%(n)d"),
"tab [<n>]": Key("tab:%(n)d"),
"delete [<n>]": Key("delete:%(n)d"),
"delete line": Key("s-delete"),
#"delete [this] line": Key("home, s-end, del"), # @IgnorePep8
"backspace [<n>]": release + Key("backspace:%(n)d"),
"application key": release + Key("apps/3"),
"win key": release + Key("win/3"),
#"paste [that]": Function(paste_command),
#"copy [that]": Function(copy_command),
"cut [that]": release + Key("c-x/3"),
"select all": release + Key("c-a/3"),
"[(hold|press)] alt": Key("alt:down/3"),
"release alt": Key("alt:up"),
"[(hold|press)] shift": Key("shift:down/3"),
"release shift": Key("shift:up"),
"[(hold|press)] control": Key("ctrl:down/3"),
"release control": Key("ctrl:up"),
"release [all]": release,
"press key <pressKey>": Key("%(pressKey)s"),
# Closures.
"angle brackets": Key("langle, rangle, left/3"),
"[square] brackets": Key("lbracket, rbracket, left/3"),
"[curly] braces": Key("lbrace, rbrace, left/3"),
"(parens|parentheses)": Key("lparen, rparen, left/3"),
"quotes": Key("dquote/3, dquote/3, left/3"),
"backticks": Key("backtick:2, left"),
"single quotes": Key("squote, squote, left/3"),
# Shorthand multiple characters.
"double <char>": Text("%(char)s%(char)s"),
"triple <char>": Text("%(char)s%(char)s%(char)s"),
#ESCAPE
"escape": Key("escape"),
"double escape": Key("escape, escape"), # Exiting menus.
# Punctuation and separation characters, for quick editing.
"colon [<n>]": Key("colon/2:%(n)d"),
"semi-colon [<n>]": Key("semicolon/2:%(n)d"),
"comma [<n>]": Key("comma/2:%(n)d"),
"(dot|period|dit|point)": Key("dot"), # cannot be followed by a repeat count
"(dash|hyphen|minus) [<n>]": Key("hyphen/2:%(n)d"),
"underscore [<n>]": Key("underscore/2:%(n)d"),
"<letters>": Text("%(letters)s"),
"<char>": Text("%(char)s"),
'langle [<n>]': Key('langle:%(n)d'),
'lace [<n>]': Key('lbrace:%(n)d'),
'(lack|lair) [<n>]': Key('lbracket:%(n)d'),
#'(laip|len) [<n>]': Key('lparen:%(n)d'),
'len [<n>]': Key('lparen:%(n)d'),
'rangle [<n>]': Key('rangle:%(n)d'),
'race [<n>]': Key('rbrace:%(n)d'),
'(rack|rare) [<n>]': Key('rbracket:%(n)d'),
#'(raip|ren|wren) [<n>]': Key('rparen:%(n)d'),
'(ren|wren) [<n>]': Key('rparen:%(n)d'),
"act [<n>]": Key("escape:%(n)d"),
"calm [<n>]": Key("comma:%(n)d"),
#'into': Key('space,bar,space'),
'care': Key('home'),
'(dole|doll)': Key('end'), #doll|
'chuck [<n>]': Key('del:%(n)d'),
'scratch [<n>]': Key('backspace:%(n)d'),
"visual": Key("v"),
"visual line": Key("s-v"),
"visual block": Key("c-v"),
"doc save": Key("c-s"),
'gope [<n>]': Key('pgup:%(n)d'),
#'drop [<n>]': Key('pgdown:%(n)d'),
'lope [<n>]': Key('c-left:%(n)d'),
'(yope|rope) [<n>]': Key('c-right:%(n)d'),
'(hill scratch|hatch) [<n>]': Key('c-backspace:%(n)d'),
'hexadecimal': Text("0x"),
'suspend': Key('c-z'),
'word <text>': Function(handle_word),
'number <num>': Text("%(num)d"),
'change <text> to <text2>': Key("home, slash") + Text("%(text)s") + Key("enter, c, e") + Text("%(text2)s") + Key("escape"),
# Text corrections.
"(add|fix) missing space": Key("c-left/3, space, c-right/3"),
"(delete|remove) (double|extra) (space|whitespace)": Key("c-left/3, backspace, c-right/3"), # @IgnorePep8
"(delete|remove) (double|extra) (type|char|character)": Key("c-left/3, del, c-right/3"), # @IgnorePep8
# Microphone sleep/cancel started dictation.
# "[<text>] (go to sleep|cancel and sleep) [<text2>]": Function(cancel_and_sleep), # @IgnorePep8
},
namespace={
"Key": Key,
"Text": Text,
}
)
# pkg_resources.require("dragonfly >= 0.6.5beta1.dev-r76")
import time
from dragonfly import (Grammar, Alternative, RuleRef, DictListRef,
Dictation, Compound, Integer, Rule, CompoundRule,
DictList, Window, Rectangle, monitors,
Config, Section, Item, FocusWindow, ActionError)
# ---------------------------------------------------------------------------
# Set up this module's configuration.
config = Config("Window control")
config.lang = Section("Language section")
config.lang.name_win = Item(
"name (window | win) <name>",
doc="Command to give the foreground window a name; must contain the <name> extra.")
config.lang.focus_win = Item(
"focus <win_selector> | bring <win_selector> to [the] (top | foreground)",
doc="Command to bring a named window to the foreground.")
config.lang.focus_title = Item(
"focus title <text>",
doc="Command to bring a window with the given title to the foreground.")
config.lang.translate_win = Item(
"place <win_selector> <position> [on <mon_selector>]",
doc="Command to translate a window.")
config.lang.resize_win = Item(
"place <win_selector> [from] <position> [to] <position> [on <mon_selector>]",
doc="Command to move and resize a window.")
config.lang.stretch_win = Item(
"stretch <win_selector> [to] <position>",
"""
from dragonfly import Config, Section, Item, AppContext, Grammar, MappingRule, IntegerRef, Dictation, Choice
from lib.dynamic_aenea import (
DynamicContext,
Key,
Text,
)
from proxy_nicknames import AppContext as NixAppContext
hipchat_config = Config("HipChat")
hipchat_config.usernames = Section("Username Mappings")
hipchat_config.usernames.map = Item({"All": "all", "Here": "here"})
hipchat_config.load()
class NavigationRule(MappingRule):
mapping = {
"move up [<n>]":
Key("cs-tab:%(n)d"),
"move down [<n>]":
Key("c-tab:%(n)d"),
"close tab":
Key("c-w"),
"(join room | private message) <room>":
Key("c-j/25") + Text("%(room)s") + Key("enter"),
"search [room] history":
grammarCfg.cmd.map = Item(
{
# Navigation keys.
"up [<n>]":
Key("up:%(n)d"),
"down [<n>]":
Key("down:%(n)d"),
"left [<n>]":
Key("left:%(n)d"),
"right [<n>]":
Key("right:%(n)d"),
"page up [<n>]":
Key("pgup:%(n)d"),
"page down [<n>]":
Key("pgdown:%(n)d"),
"up <n> (page | pages)":
Key("pgup:%(n)d"),
"down <n> (page | pages)":
Key("pgdown:%(n)d"),
"left <n> (word | words)":
Key("c-left:%(n)d"),
"right <n> (word | words)":
Key("c-right:%(n)d"),
"home":
Key("home"),
"end":
Key("end"),
"doc home":
Key("c-home/3"),
"doc end":
Key("c-end/3"),
# Functional keys.
"space":
release + Key("space"),
"space [<n>]":
release + Key("space:%(n)d"),
"enter [<n>]":
release + Key("enter:%(n)d"),
"tab [<n>]":
Key("tab:%(n)d"),
"delete [<n>]":
release + Key("del:%(n)d/5"),
"delete [<n> | this] (line|lines)":
release + Key("home, s-down:%(n)d, del"), # @IgnorePep8
"backspace [<n>]":
release + Key("backspace:%(n)d"),
"application key":
release + Key("apps/3"),
"win key":
release + Key("win/3"),
"paste [that]":
release + Key("c-v/3"),
"copy [that]":
release + Key("c-c/3"),
"cut [that]":
release + Key("c-x/3"),
"select all":
release + Key("c-a/3"),
"undo":
release + Key("c-z/3"),
"undo <n> [times]":
release + Key("c-z/3:%(n)d"),
"redo":
release + Key("c-y/3"),
"redo <n> [times]":
release + Key("c-y/3:%(n)d"),
"[(hold|press)] alt":
Key("alt:down/3"),
"release alt":
Key("alt:up"),
"[(hold|press)] shift":
Key("shift:down/3"),
"release shift":
Key("shift:up"),
"[(hold|press)] control":
Key("ctrl:down/3"),
"release control":
Key("ctrl:up"),
"release [all]":
release,
# Type written form of "that which would otherwise not be written".
"say <text>":
release + Text("%(text)s"),
# "mimic <text>": release + Mimic(extra="text"),
# Shorthand multiple characters.
"double <char>":
Text("%(char)s%(char)s"),
"triple <char>":
Text("%(char)s%(char)s%(char)s"),
"double escape":
Key("escape, escape"), # Exiting menus.
# To release keyboard capture by VirtualBox.
"press right control":
Key("Control_R"),
# Formatting.
"camel case <text>":
Function(lib.format.camel_case_text),
"camel case <n> [words]":
Function(lib.format.camel_case_count),
"pascal case <text>":
Function(lib.format.pascal_case_text),
"pascal case <n> [words]":
Function(lib.format.pascal_case_count),
"snake case <text>":
Function(lib.format.snake_case_text),
"snake case <n> [words]":
Function(lib.format.snake_case_count),
"squash <text>":
Function(lib.format.squash_text),
"squash <n> [words]":
Function(lib.format.squash_count),
"expand <n> [words]":
Function(lib.format.expand_count),
"uppercase <text>":
Function(lib.format.uppercase_text),
"uppercase <n> [words]":
Function(lib.format.uppercase_count),
"lowercase <text>":
Function(lib.format.lowercase_text),
"lowercase <n> [words]":
Function(lib.format.lowercase_count),
# Text corrections.
"(add|fix) missing space":
Key("c-left/3, space, c-right/3"),
"(delete|remove) (double|extra) (space|whitespace)":
Key("c-left/3, backspace, c-right/3"), # @IgnorePep8
"(delete|remove) (double|extra) (type|char|character)":
Key("c-left/3, del, c-right/3"), # @IgnorePep8
# Canceling of started sentence.
# Useful for canceling what inconsiderate loud mouths have started.
"<text> cancel dictation":
Function(cancel_dictation),
"<text> cancel dictation <text2>":
Function(cancel_dictation),
"[<text>] cancel and sleep":
Function(cancel_and_sleep),
"[<text>] cancel and sleep [<text2>]":
Function(cancel_and_sleep),
# Reload Natlink.
"reload Natlink":
Function(reload_natlink),
},
namespace={
"Key": Key,
"Text": Text,
})
# * http://msdn.microsoft.com/en-us/library/ff184607.aspx
# * http://dragonfly-modules.googlecode.com/svn-history/r50/trunk/command-modules/documentation/mod-_outlook.html
#
from dragonfly import(Config, Section, Item,
Grammar, ConnectionGrammar, AppContext,
MappingRule, CompoundRule,
Key, Integer, IntegerRef,
DictList, DictListRef)
import tempfile
import os
import os.path
config = Config('Microsoft Outlook control')
config.lang = Section('Language section')
config.lang.go_to_folder = Item('folder <folder>')
config.lang.move_to_folder = Item('move to <folder>')
config.lang.sync_folders = Item('refresh folders')
config.load()
def collection_iter(collection):
for index in xrange(1, collection.Count + 1):
yield collection.Item(index)
class OutlookControlGrammar(ConnectionGrammar):
def __init__(self):
self.folders = DictList("folders")
super(OutlookControlGrammar,self).__init__(
name="Microsoft Outlook control",
context=AppContext(executable="outlook"),
app_name="Outlook.Application"
config.cmd.map = Item({
"cap deploy [with] migrations to <text>":
Text("SKIP_ASSETS=true RUBBER_ENV=") +
Function(lib.format.lowercase_text) + Text(" cap deploy:migrations"),
"cap deploy [with] migrations to <text> with filter":
Text("SKIP_ASSETS=true RUBBER_ENV=") +
Function(lib.format.lowercase_text) +
Text(" cap deploy:migrations FILTER="),
"cap deploy [with] migrations to <text> with filter roles":
Text("SKIP_ASSETS=true RUBBER_ENV=") +
Function(lib.format.lowercase_text) +
Text(" cap deploy:migrations FILTER_ROLES="),
"cap deploy [with] migrations to <text> with assets":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap deploy:migrations"),
"cap deploy [with] migrations to <text> with assets with filter":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap deploy:migrations FILTER="),
"cap deploy [with] migrations to <text> with assets with filter roles":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap deploy:migrations FILTER_ROLES="),
"cap deploy to <text>":
Text("SKIP_ASSETS=true RUBBER_ENV=") +
Function(lib.format.lowercase_text) + Text(" cap deploy"),
"cap deploy to <text> with filter":
Text("SKIP_ASSETS=true RUBBER_ENV=") +
Function(lib.format.lowercase_text) + Text(" cap deploy FILTER="),
"cap deploy to <text> with filter roles":
Text("SKIP_ASSETS=true RUBBER_ENV=") +
Function(lib.format.lowercase_text) + Text(" cap deploy FILTER_ROLES="),
"cap deploy to <text> with assets":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap deploy"),
"cap deploy to <text> with assets with filter":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap deploy FILTER="),
"cap deploy to <text> with assets with filter roles":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap deploy FILTER_ROLES="),
"cap invoke to <text>":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap invoke COMMAND=\"\"") + Key("left:1"),
"cap invoke to <text> with filter":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap invoke COMMAND=\"\" FILTER="),
"cap invoke to <text> with filter roles":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap invoke COMMAND=\"\" FILTER_ROLES="),
"cap rubber reboot <text>":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap rubber:reboot ALIAS=") + Function(lib.format.lowercase_text),
"cap rubber bootstrap <text>":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap rubber:bootstrap FILTER=") +
Function(lib.format.lowercase_text),
"cap rubber set up security groups <text>":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap rubber:setup_security_groups FILTER=") +
Function(lib.format.lowercase_text),
"cap rubber set up local aliases <text>":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap rubber:setup_local_aliases"),
"cap rubber set up remote aliases <text>":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap rubber:setup_remote_aliases"),
"cap rubber set up D N S aliases <text>":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap rubber:setup_dns_aliases"),
"cap rubber add role to <text>":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap rubber:roles:add ROLES= ALIAS=") +
Function(lib.format.lowercase_text),
"cap rubber create staging <text>":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap rubber:create_staging"),
"cap rubber destroy staging <text>":
Text("RUBBER_ENV=") + Function(lib.format.lowercase_text) +
Text(" cap rubber:destroy_staging"),
"cap rubber monit start":
Text("cap rubber:monit:start RUBBER_ENV="),
"cap rubber monit stop":
Text("cap rubber:monit:stop RUBBER_ENV="),
"cap rubber (postgres|PostgreSQL) start":
Text("cap rubber:postgresql:start RUBBER_ENV="),
"cap rubber (postgres|PostgreSQL) stop":
Text("cap rubber:postgresql:stop RUBBER_ENV="),
})
grammarCfg.cmd.map = Item(
{
# navigation
# next/prev brace
# next/prev matching selection
"down [<n>]": Key("down:%(n)d"),
"down block": Key("c-rbracket"),
"down method [<n>]": Key("a-down:%(n)d"),
"down page [<n>]": Key("pgdown:%(n)d"),
"doc end": Key("c-end"),
"doc start": Key("c-home"),
"go to column <n>": Key("c-g/25") + Text(":%(n)d") + Key("enter"),
"go to declaration": Key("c-b"),
"go to implemetation": Key("sc-b"),
"go to line <n>": Key("c-g/25") + Text("%(n)d") + Key("enter"),
"go to line <n> column <m>": Key("c-g/25") + Text("%(n)d:%(m)d") + Key("enter"),
"left [<n>]": Key("left:%(n)d"),
"left <n> (word|words)": Key("c-left:%(n)d"),
"line end": Key("end"),
"line start": Key("home"),
"matching brace": Key("cs-m"),
"next error": Key("f2"),
"next position": Key("ca-right"),
"previous error": Key("s-f2"),
"previous position": Key("ca-left"),
"right [<n>]": Key("right:%(n)d"),
"right word [<n>]": Key("c-right:%(n)d"),
"up [<n>]": Key("up:%(n)d"),
"up block": Key("c-lbracket"),
"up method [<n>]": Key("a-up:%(n)d"),
"up page [<n>]": Key("pgup:%(n)d"),
"up word [<n>]": Key("c-left:%(n)d"),
# Searching
"find in file": Key("c-f"),
"find in path": Key("cs-f"),
"find usage": Key("a-f7"),
"find next": Key("f3"),
"find previous": Key("s-f3"),
"find word": Key("c-f3"),
"replace in file": Key("c-r"),
"replace in pat": Key("sc-r"),
"select word <n>": Key("c-w:%(n)d"),
# function keys
"F one": Key("f1"),
"F two": Key("f2"),
"F three": Key("f3"),
"F four": Key("f4"),
"F five": Key("f5"),
"F six": Key("f6"),
"F Seven": Key("f7"),
"F eight": Key("f8"),
"F nine": Key("f9"),
"F ten": Key("f10"),
"F eleven": Key("f11"),
"F 12": Key("f12"),
# letters
"(A|alpha)": Text("a"),
"(B|bravo) ": Text("b"),
"(C|charlie) ": Text("c"),
"(D|delta) ": Text("d"),
"(E|echo) ": Text("e"),
"(F|foxtrot) ": Text("f"),
"(G|golf) ": Text("g"),
"(H|hotel) ": Text("h"),
"(I|india|indigo) ": Text("i"),
"(J|juliet) ": Text("j"),
"(K|kilo) ": Text("k"),
"(L|lima) ": Text("l"),
"(M|mike) ": Text("m"),
"(N|november) ": Text("n"),
"(O|oscar) ": Text("o"),
"(P|papa|poppa) ": Text("p"),
"(Q|quebec|quiche) ": Text("q"),
"(R|romeo) ": Text("r"),
"(S|sierra) ": Text("s"),
"(T|tango) ": Text("t"),
"(U|uniform) ": Text("u"),
"(V|victor) ": Text("v"),
"(W|whiskey) ": Text("w"),
"(X|x-ray) ": Text("x"),
"(Y|yankee) ": Text("y"),
"(Z|zulu) ": Text("z"),
# Typescript keywords, defined as commands so case etc is correct
"abstract": Text("abstract "),
"as": Text("as "),
"async": Text("async "),
"await": Text("await "),
"break": Text("break") + Key("enter"),
"case": Text("case :") + Key("left"),
"catch": Text("catch(err) {") + Key("enter"),
"class <text>": Text("class ") + Function(lib.format.pascal_case_text) + Text(" {") + Key("enter"),
"const <text>": Text("const ") + Function(lib.format.camel_case_text),
"constructor": Text("constructor () {") + Key("left:3"),
"continue": Text("continue") + Key("enter"),
"declare": Text("declare "),
"default": Text("default "),
"delete <text>": Text("delete ") + Function(lib.format.camel_case_text),
"do": Text("do "),
"else": Text(" else {") + Key("enter"),
"enum <text>": Text("enum ") + Function(lib.format.pascal_case_text) + Text(" {") + Key("enter"),
"export": Text("export "),
"extends <text>": Text("extends ") + Function(lib.format.pascal_case_text),
"false": Text("false"),
"finally": Text("finally {") + Key("enter"),
"for of <text>": Text("for (const elem of ") + Function(lib.format.pascal_case_text) + Text("){"),
"for in <text>": Text("for (const key of ") + Function(lib.format.pascal_case_text) + Text("){"),
"function <text>": Text("function ") + Function(lib.format.pascal_case_text) + Text("() {") + Key("enter") + Key("cs-m") + Key("left:2"),
"from": Text("from ''") + Key("left"),
"get <text>": Text("get ") + Function(lib.format.camel_case_text) + Text("() {") + Key("enter") + Text("return "),
"if": Text("if () {") + Key("enter") + Key("cs-m") + Key("left"),
"implements <text>": Text("implements ") + Function(lib.format.pascal_case_text),
"import": Text("import "),
"in": Text("in "),
"interface <text>": Text("interface ") + Function(lib.format.pascal_case_text) + Text(" {") + Key("enter"),
"instance of": Text("instanceof "),
"let <text>": Text("let ") + Function(lib.format.camel_case_text),
"new": Text("new "),
"null": Text("null "),
"package": Text("package "),
"private <text>": Text("private ") + Function(lib.format.camel_case_text),
"protected": Text("protected "),
"public": Text("public "),
"read only": Text("readonly "),
"return": Text("return "),
"set <text>": Text("set ") + Function(lib.format.camel_case_text) + Text("() {") + Key("enter") + Key("cs-m") + Key("left:2"),
"static": Text("static "),
"super": Text("super("),
"switch": Text("switch () {") + Key("enter") + Text("case :") + Key("enter") + Text("break") + Key("cs-m") + Key("left:2"),
"this": Text("this"),
"true": Text("true"),
"try": Text("try {") + Key("enter") + Key("down:2") + Text("catch (err) {") + Key("enter") + Key("cs-m") + Key("up"),
"type": Text("type "),
"type of": Text("typeof"),
"undefined": Text("undefined"),
"void": Text("void"),
"while": Text("while () {") + Key("enter") + Key("cs-m") + Key("left:2"),
# common methods
"log": Text("console.log(\""),
# common types
"any": Text("any"),
"boolean": Text("boolean"),
"map": Text("Map"),
"number": Text("number"),
"new map": Text("Map<>(") + Key("left:2"),
"string": Text("string"),
# symbols, puncuation etc
"bar": Text(" | "),
"equal to": Text(" === "),
"equals": Text(" = "),
"greater than": Text(" > "),
"greater than or equal 2": Text(" >= "),
"less than": Text(" < "),
"less than or equal 2": Text(" <= "),
"not equal to": Text(" !== "),
"angle bracket": Key("langle"),
"close angle bracket": Key("rangle"),
"square bracket": Text("["),
"close square bracket": Text("]"),
"brace": Key("lbrace"),
"close brace": Key("rbrace"),
"paren": Key("lparen"),
"close paren": Key("rparen"),
"quote": Key("dquote"),
"single quote": Key("squote"),
"colon [<n>]": Key("colon:%(n)d"),
"semi-colon [<n>]": Key("semicolon:%(n)d"),
"comma [<n>]": Key("comma:%(n)d"),
"dot [<n>]": Key("dot:%(n)d"),
"(dash|hyphen|minus) [<n>]": Key("hyphen:%(n)d"),
"underscore [<n>]": Key("underscore:%(n)d"),
"plus": Text(" + "),
"bang": Text("!"),
"at": Text("@"),
# Formatting <n> words to the left of the cursor.
"camel case <n>": Function(lib.format.camel_case_count),
"camel case <text>": Function(lib.format.camel_case_text),
"pascal case <n>": Function(lib.format.pascal_case_count),
"pascal case <text>": Function(lib.format.pascal_case_text),
"snake case <n>": Function(lib.format.snake_case_count),
"snake case <text>": Function(lib.format.snake_case_text),
"squash <n>": Function(lib.format.squash_count),
"expand <n>": Function(lib.format.expand_count),
"uppercase <n>": Function(lib.format.uppercase_count),
"uppercase <text>": Function(lib.format.uppercase_text),
"lowercase <n>": Function(lib.format.lowercase_count),
"lowercase <text>": Function(lib.format.lowercase_text),
# Format dictated words. See the formatMap for all available types.
# Ex: "camel case my new variable" -> "myNewVariable"
# Ex: "snake case my new variable" -> "my_new_variable"
# Ex: "uppercase squash my new hyphen variable" -> "MYNEW-VARIABLE"
# "<formatType> <text>": Function(lib.format.format_text),
# editing
# For writing words that would otherwise be characters or commands.
# Ex: "period", tab", "left", "right", "home", select word
"cut": Key("c-x"),
"dictate <text>": Text("%(text)s"),
"duplicate line": Key("c-d"),
"escape": Key("escape"),
"format": Key("csa-p"),
"paste": Key("c-v"),
"save": Key("c-s"),
"undo": Key("c-z"),
},
namespace={
"Key": Key,
"Text": Text,
}
)
"""
import pkg_resources
pkg_resources.require("dragonfly >= 0.6.5beta1.dev-r76")
from dragonfly import (Grammar, AppContext, MappingRule, Key,
Config, Section, Item)
#---------------------------------------------------------------------------
# Initialize this module's configuration.
config = Config("Audacity control")
config.lang = Section("Language section")
config.lang.new_project = Item("[start] new project", doc="Spec starts a new project.")
config.lang.open_project = Item("open project", doc="Spec opens an existing project.")
config.lang.close_project = Item("close [this] project", doc="Spec closes currently open project.")
config.lang.save_project = Item("save [this] project", doc="Spec saves currently open project.")
config.lang.selection_tool = Item("[open] selection tool", doc="Spec opens the selection tool.")
config.lang.envelope_tool = Item("[open] envelope tool", doc="Spec opens the envelope tool.")
config.lang.edit_tool = Item("[open] edit tool", doc="Spec opens the edit tool.")
config.lang.zoom_tool = Item("[open] zoom tool", doc="Spec opens the zoom tool.")
config.lang.timeshift_tool = Item("[open] timeshift tool", doc="Spec opens the timeshift tool.")
config.lang.multi_tool = Item("[open] multi tool", doc="Spec opens the multitool.")
config.lang.next_toolbar_tool = Item("[move to | go to] next tool", doc="Spec move to the next tool in toolbar.")
config.lang.previous_toolbar_tool = Item("[move to | go to] previous tool", doc="Spec move to the previous tool in toolbar.")
config.lang.silence = Item("[insert | create] silence", doc="Spec insert silence at current position.")
config.lang.duplicate = Item("[make] duplicate", doc="Spec makes duplicate.")
config.lang.find_zero_crossings= Item("[find | search] zero crossings", doc="Spec finds zero crossings.")
config.lang.play_stop = Item("[start | stop] playing", doc="Spec starts or stops playback.")
from dragonfly import Function, MappingRule, Text, Dictation, Config, Section, Item, Key
config = Config("format functions")
config.cmd = Section("Command section")
config.cmd.map = Item(
{},
namespace={
"Key": Key,
"Text": Text,
}
)
namespace = config.load()
#---------------------------------------------------------------------------
# Here we prepare the list of formatting functions from the config file.
# Retrieve text-formatting functions from this module's config file. Each of these functions must have a name that starts with "format_".
format_functions = {}
if namespace:
for name, function in namespace.items():
if name.startswith("format_") and callable(function):
spoken_form = function.__doc__.strip()
# We wrap generation of the Function action in a function so that its *function* variable will be local. Otherwise it
# would change during the next iteration of the namespace loop.
def wrap_function(function):
def _function(dictation):
formatted_text = function(dictation)
Text(formatted_text).execute()
#---------------------------------------------------------------------------
# Set up this module's configuration.
config = Config("bring me")
config.targets = Section("Targets section")
config.targets.mapping = Item(
default={
"less compiler": open("C:\svn\guesscommerceredesignclean\Websites\GuessInc.Web.Frontend\Content\Guess\LessCompiler.bat"),
"Google": website("http://www.google.com"),
"dev": website("https://dev.plus3.ws"),
"development": ssh("development"),
"Trello": website("http://www.trello.com"),
"Gmail": website("http://mail.google.com"),
"hacker news": website("http://news.ycombinator.com"),
"Reddit": website("http://www.reddit.com"),
},
doc="Mapping of spoken targets to bringable targets.",
namespace={
"website": website,
"open": open,
"folder": folder,
"ssh": ssh,
},
)
config.lang = Section("Language section")
config.lang.bring_me = Item("bring me <target>",
doc="Command to bring a target;"
" must contain the <target> extra.")
config.lang.paste_me = Item("paste me <target>",
doc="Command to paste the location of a target;"
import os.path
import subprocess
import os
import win32gui
import urllib
#from subprocess import Popen
from dragonfly import (Grammar, ConnectionGrammar, AppContext, CompoundRule,
Choice, Window, Config, Section, Item)
#---------------------------------------------------------------------------
# Set up this module's configuration.
config = Config("TortoiseSVN")
config.tortoisesvn = Section("TortoiseSVN configuration")
config.tortoisesvn.path = Item(
r'C:\Program Files\TortoiseSVN\bin\TortoiseProc.exe')
config.tortoisesvn.command = Item("(tortoise | subversion) <command>")
config.tortoisesvn.global_command = Item(
"(tortoise | subversion) <command> <predef>")
config.tortoisesvn.actions = Item(
{
"add": "add",
"checkout": "checkout",
"commit": "commit",
"revert": "revert",
"merge": "merge",
"delete": "delete",
"diff": "diff",
"log": "log",
"import": "import",
"update": "update",
pkg_resources.require("dragonfly >= 0.6.5beta1.dev-r76")
import os.path
from win32com.client import Dispatch
from pywintypes import com_error
from dragonfly import (ConnectionGrammar, AppContext, DictListRef,
CompoundRule, DictList, Config, Section, Item)
#---------------------------------------------------------------------------
# Set up this module's configuration.
config = Config("Microsoft Word styles control")
config.lang = Section("Language section")
config.lang.set_style = Item("set style <style>", doc="Spec for setting a style; must contain the <style> extra.")
config.lang.update_styles = Item("(update | synchronize) styles", doc="Spec for updating style list.")
#config.generate_config_file()
config.load()
#---------------------------------------------------------------------------
# StyleRule which keeps track of and can set available styles.
class StyleRule(CompoundRule):
spec = config.lang.set_style
styles = DictList("styles")
extras = [DictListRef("style", styles)]
def _process_recognition(self, node, extras):
try:
import pkg_resources
pkg_resources.require("dragonfly >= 0.6.5beta1.dev-r76")
except ImportError:
pass
from dragonfly import (Grammar, AppContext, MappingRule, Dictation,
Key, Text, Config, Section, Item, IntegerRef)
#---------------------------------------------------------------------------
# Set up this module's configuration.
config = Config("Foxit reader control")
config.lang = Section("Language section")
config.lang.new_win = Item("new (window | win)")
#config.generate_config_file()
config.load()
#---------------------------------------------------------------------------
# Create the main command rule.
class CommandRule(MappingRule):
mapping = {
"zoom in [<n>]": Key("c-equals:%(n)d"),
"zoom out [<n>]": Key("c-hyphen:%(n)d"),
"zoom [one] hundred": Key("c-1"),
"zoom [whole | full] page": Key("c-2"),
"zoom [page] width": Key("c-3"),
import pkg_resources
pkg_resources.require("dragonfly >= 0.6.5beta1.dev-r76")
import ctypes
import natlink
from dragonfly import (Grammar, CompoundRule, Config, Section, Item)
#---------------------------------------------------------------------------
# Set up this module's configuration.
config = Config("lock screen")
config.lang = Section("Language section")
config.lang.lock_screen = Item("lock screen now now",
doc="Command to lock the screen;"
" also puts the microphone to sleep.")
config.load()
#---------------------------------------------------------------------------
# Lock screen rule.
class LockRule(CompoundRule):
spec = config.lang.lock_screen
def _process_recognition(self, node, extras):
self._log.debug("%s: locking screen." % self)
# Put the microphone to sleep.
grammarCfg.cmd.map = Item(
{
# Navigation keys.
"up [<n>]":
Key("up:%(n)d"),
"up [<n>] slow":
Key("up/15:%(n)d"),
"down [<n>]":
Key("down:%(n)d"),
"down [<n>] slow":
Key("down/15:%(n)d"),
"left [<n>]":
Key("left:%(n)d"),
"left [<n>] slow":
Key("left/15:%(n)d"),
"right [<n>]":
Key("right:%(n)d"),
"right [<n>] slow":
Key("right/15:%(n)d"),
"page up [<n>]":
Key("pgup:%(n)d"),
"page down [<n>]":
Key("pgdown:%(n)d"),
"up <n> (page|pages)":
Key("pgup:%(n)d"),
"down <n> (page|pages)":
Key("pgdown:%(n)d"),
"left <n> (word|words)":
Key("c-left/3:%(n)d/10"),
"right <n> (word|words)":
Key("c-right/3:%(n)d/10"),
"home":
Key("home"),
"end":
Key("end"),
"doc home":
Key("c-home/3"),
"doc end":
Key("c-end/3"),
# Functional keys.
"space":
release + Key("space"),
"space [<n>]":
release + Key("space:%(n)d"),
"enter [<n>]":
release + Key("enter:%(n)d"),
"tab [<n>]":
Key("tab:%(n)d"),
"delete [<n>]":
Key("del/3:%(n)d"),
"delete [this] line":
Key("home, s-end, del"), # @IgnorePep8
"backspace [<n>]":
release + Key("backspace:%(n)d"),
"application key":
release + Key("apps/3"),
"win key":
release + Key("win/3"),
"paste [that]":
Function(paste_command),
"copy [that]":
Function(copy_command),
"cut [that]":
release + Key("c-x/3"),
"select all":
release + Key("c-a/3"),
"undo":
release + Key("c-z/3"),
"undo <n> [times]":
release + Key("c-z/3:%(n)d"),
"redo":
release + Key("c-y/3"),
"redo <n> [times]":
release + Key("c-y/3:%(n)d"),
"[(hold|press)] alt":
Key("alt:down/3"),
"release alt":
Key("alt:up"),
"[(hold|press)] shift":
Key("shift:down/3"),
"release shift":
Key("shift:up"),
"[(hold|press)] control":
Key("ctrl:down/3"),
"release control":
Key("ctrl:up"),
"release [all]":
release,
# Closures.
"angle brackets":
Key("langle, rangle, left/3"),
"brackets":
Key("lbracket, rbracket, left/3"),
"braces":
Key("lbrace, rbrace, left/3"),
"parens":
Key("lparen, rparen, left/3"),
"quotes":
Key("dquote/3, dquote/3, left/3"),
"single quotes":
Key("squote, squote, left/3"),
# Shorthand multiple characters.
"double <char>":
Text("%(char)s%(char)s"),
"triple <char>":
Text("%(char)s%(char)s%(char)s"),
"double escape":
Key("escape, escape"), # Exiting menus.
# Punctuation and separation characters, for quick editing.
"colon [<n>]":
Key("colon/2:%(n)d"),
"semi-colon [<n>]":
Key("semicolon/2:%(n)d"),
"comma [<n>]":
Key("comma/2:%(n)d"),
"(dot|period) [<n>]":
Key("dot/2:%(n)d"),
"(dash|hyphen|minus) [<n>]":
Key("hyphen/2:%(n)d"),
"underscore [<n>]":
Key("underscore/2:%(n)d"),
# To release keyboard capture by VirtualBox.
"press right control":
Key("Control_R"),
# Formatting <n> words to the left of the cursor.
"camel case <n> [words]":
Function(camel_case_count),
"pascal case <n> [words]":
Function(pascal_case_count),
"snake case <n> [words]":
Function(snake_case_count),
"squash <n> [words]":
Function(squash_count),
"expand <n> [words]":
Function(expand_count),
"uppercase <n> [words]":
Function(uppercase_count),
"lowercase <n> [words]":
Function(lowercase_count),
# Format dictated words. See the formatMap for all available types.
# Ex: "camel case my new variable" -> "myNewVariable"
# Ex: "snake case my new variable" -> "my_new_variable"
# Ex: "uppercase squash my new hyphen variable" -> "MYNEW-VARIABLE"
"<formatType> <text>":
Function(format_text),
# For writing words that would otherwise be characters or commands.
# Ex: "period", tab", "left", "right", "home".
"say <reservedWord>":
Text("%(reservedWord)s"),
# Abbreviate words commonly used in programming.
# Ex: arguments -> args, parameters -> params.
"abbreviate <abbreviation>":
Text("%(abbreviation)s"),
# Text corrections.
"(add|fix) missing space":
Key("c-left/3, space, c-right/3"),
"(delete|remove) (double|extra) (space|whitespace)":
Key("c-left/3, backspace, c-right/3"), # @IgnorePep8
"(delete|remove) (double|extra) (type|char|character)":
Key("c-left/3, del, c-right/3"), # @IgnorePep8
# Microphone sleep/cancel started dictation.
"[<text>] (go to sleep|cancel and sleep) [<text2>]":
Function(cancel_and_sleep), # @IgnorePep8
# Reload Natlink.
"reload Natlink":
Function(reload_natlink),
},
namespace={
"Key": Key,
"Text": Text,
})
from lib import sound
from natlink import setMicState
import natlinkstatus
import time
import subprocess
#---------------------------------------------------------------------------
# Set up this module's configuration.
config = Config("config manager")
#config = Config("dragonfly tools") # I like to keep those names consistent with the .py module file names
config.lang = Section("Language section")
config.lang.list_configs = Item("list configs", doc="Command to ...")
config.lang.edit_config = Item("edit <config> (config | configuration)",
doc="Command to ...")
config.lang.list_modules = Item("list modules", doc="Command to ...")
config.lang.edit_module = Item("edit <module> (module|mod)",
doc="Command to ...")
config.lang.show_dragonfly_version = Item("show dragonfly version",
doc="Command to ...")
config.lang.update_dragonfly = Item("update dragonfly version",
doc="Command to ...")
config.lang.reload_natlink = Item("reload natlink", doc="Command to ...")
config.lang.show_natlink_messages_window = Item(
"show (natlink|messages) [window]", doc="Command to ...")
from dragonfly import (Grammar, CompoundRule, Config, Section, Item)
import natlink
config = Config("snore")
config.lang = Section("Language section")
config.lang.snore = Item("snore", doc="Put the microphone to sleep")
class SnoreRule(CompoundRule):
spec = config.lang.snore
def _process_recognition(self, node, extras):
self._log.debug("sleepy mic")
natlink.setMicState("sleeping")
grammar = Grammar("snore")
grammar.add_rule(SnoreRule())
grammar.load()
def unload():
global grammar
if grammar: grammar.unload()
grammar = None
from dragonfly import MappingRule, Function, Config, Section, Item
def printTango():
print "tango"
def printUniform():
print "uniform"
config = Config("test map")
config.cmd = Section("Command section")
config.cmd.map = Item(
# Here we define the *default* command map. If you would like to modify it to your personal taste, please *do not* make changes
# here. Instead change the *config file* called "_multiedit.txt". If it exists, the map there will replace this one.
{
"print tango": Function(printTango),
"print uniform": Function(printUniform),
},
doc=
"Default window names. Maps spoken-forms to {executable name, title, executable path} dict."
)
config.load()
class TangoMap(MappingRule):
mapping = config.cmd.map
"""
# import logging
from dragonfly.windows.clipboard import Clipboard
from dragonfly import Config, Section, Item, Grammar, CompoundRule, Key
from supporting import utils
# rule_log = logging.getLogger("rule")
# ---------------------------------------------------------------------------
# Set up this module's configuration.
config = Config("Text Manipulation")
config.tweak = Section("Tweak section")
config.tweak.upper = Item("upper that", doc="Command to convert the selected text to uppercase.")
config.tweak.lower = Item("lower that", doc="Command to convert the selected text to lower case.")
# config.generate_config_file()
config.load()
# ===========================================================================
# Create this module's main grammar object.
text_manipulation_grammar = Grammar("text manipulation")
class UpperRule(CompoundRule):
spec = config.tweak.upper
def _process_recognition(self, node, extras):
copy_modify_paste(lambda s: s.upper())
config.cmd.map = Item({
"cd (mogo test|mogotest)":
Text("cd ~/dev/workspaces/mogotest") + Key("enter"),
"cd (mogo test|mogotest) remote":
Text("cd ~/dev/workspaces/mogotest-helix") + Key("enter"),
"cd ping4":
Text("cd ~/dev/workspaces/ping4app") + Key("enter"),
"cd ping4 remote":
Text("cd ~/ping4-helix") + Key("enter"),
"cd rubber":
Text("cd ~/dev/workspaces/rubber") + Key("enter"),
"cd rubber test":
Text("cd ~/dev/workspaces/rubbertest") + Key("enter"),
"cd workspaces":
Text("cd ~/dev/workspaces") + Key("enter"),
"cd home":
Text("cd ~") + Key("enter"),
"cd downloads":
Text("cd ~/Downloads") + Key("enter"),
"cd drop box":
Text("cd ~/Dropbox") + Key("enter"),
#"cd NatLink": Text("cd C:\NatLink\NatLink\MacroSystem") + Key("enter"),
"cd NatLink":
Text("cd /c/NatLink/NatLink/MacroSystem") + Key("enter"),
"cd rubber Ping4 production":
Text("cd ~/.rubber_ping4_production") + Key("enter"),
"cd rubber Ping4 (development|staging)":
Text("cd ~/.rubber_ping4_dev") + Key("enter"),
"cd rubber Mogotest":
Text("cd ~/.ec2_mogotest") + Key("enter"),
"(edit|vim) rubber secret":
Text("vim rubber-secret.yml"),
"(open|start) rails console":
Text("./script/rails c") + Key("enter"),
"fix line endings":
Text("find . -type f -exec dos2unix {} \; && chmod +x script/*") +
Key("enter"),
"fix (date|time)":
Text("ntpd -qg") + Key("enter"),
"stop torquebox":
Text("service monit stop && service torquebox stop") + Key("enter"),
"start torquebox":
Text("service torquebox start") + Key("enter"),
"grep torquebox":
Text("ps aux | grep torque") + Key("enter"),
"git get":
Text("git get") + Key("enter"),
"git put":
Text("git put") + Key("enter"),
"find URL group":
Text("g = UrlGroup.where(uid: '').first") + Key("left:8"),
"ssh mets":
Text("ssh mets.ping4central.com") + Key("enter"),
"ssh Q A gateway":
Text("ssh qa-gw.ping4inc.com") + Key("enter"),
"ssh Q A mets":
Text("ssh qa-mets.ping4inc.com") + Key("enter"),
"ssh load test gateway":
Text("ssh loadtest-gw.ping4inc.com") + Key("enter"),
"ssh load test mets":
Text("ssh loadtest-mets.ping4inc.com") + Key("enter"),
"ssh melchior":
Text("ssh nirvdrum@melchior") + Key("enter"),
"ssh ping4 (development|V M)":
Text("ssh development.ping4inc.com") + Key("enter"),
"ssh Kevin dot mogotest dot com":
Text("ssh kevin.mogotest.com") + Key("enter"),
"ssh app (oh|zero) 1":
Text("ssh app01.mogotest.com") + Key("enter"),
"ssh app (oh|zero) 2":
Text("ssh app02.mogotest.com") + Key("enter"),
"ssh tools":
Text("ssh tools.mogotest.com") + Key("enter"),
"ssh Cassandra 1":
Text("ssh cas1.ping4central.com") + Key("enter"),
"ssh Cassandra 2":
Text("ssh cas2.ping4central.com") + Key("enter"),
"ssh Cassandra 3":
Text("ssh cas3.ping4central.com") + Key("enter"),
"ssh Cassandra 4":
Text("ssh cas4.ping4central.com") + Key("enter"),
"ssh Cassandra 5":
Text("ssh cas5.ping4central.com") + Key("enter"),
"ssh Cassandra 6":
Text("ssh cas6.ping4central.com") + Key("enter"),
"ssh Cassandra 7":
Text("ssh cas7.ping4central.com") + Key("enter"),
"ssh Cassandra 8":
Text("ssh cas8.ping4central.com") + Key("enter"),
"tail app logs":
Text("cd ~") + Key("enter") + Text("current") + Key("enter") +
Text("tail -f log/*.log") + Key("enter"),
"tail (torquebox|torque box) log":
Text("tail -f /var/log/torquebox/torquebox.log") + Key("enter"),
"tail development logs":
Text("tail -f log/development.log") + Key("enter"),
"tail postgres (log|logs)":
Text("tail -f /var/log/postgresql/postgresql*.log") + Key("enter"),
"edit ssh config":
Text("vim ~/.ssh/config") + Key("enter"),
"(open|start) program":
DynamicAction(Key("a-space"), Key("f1")),
"(open|start) program <text>":
DynamicAction(Key("a-space"), Key("f1")) + Pause("30") +
Function(lib.format.lowercase_text),
# Custom vocabulary.
"nerve drum":
Text("nirvdrum"),
"chat laugh":
Text("Heh."),
"J ruby":
Text("jruby"),
"you tills":
Text("utils"),
"firefox you tills":
Text("FirefoxUtils"),
"IE 601":
Text("ie601"),
"IE 602":
Text("ie602"),
"IE 701":
Text("ie701"),
"IE 702":
Text("ie702"),
"IE 801":
Text("ie801"),
"IE 802":
Text("ie802"),
"IE 901":
Text("ie901"),
"IE 902":
Text("ie902"),
"IE 1001":
Text("ie1001"),
"IE 1002":
Text("ie1002"),
"ruby version":
Text("ruby --version") + Key("enter"),
"change ruby M R I":
Text("rbenv shell 2.1.1") + Key("enter"),
"change ruby (jay ruby|jruby)":
Text("rbenv shell jruby-1.7.10") + Key("enter"),
"(torque box|TorqueBox) run":
Text("torquebox run -b 0.0.0.0") + Key("enter"),
"(torque box|TorqueBox) deploy":
Text("torquebox deploy") + Key("enter"),
"vagrant destroy":
Text("vagrant destroy"),
"vagrant up":
Text("vagrant up"),
"vagrant up [with] virtual box":
Text("vagrant up --provider=virtualbox"),
"vagrant up [with] VMware":
Text("vagrant up --provider=vmware_workstation"),
"vagrant ssh":
Text("vagrant ssh"),
})
def bring_it(self):
subprocess.Popen([self.putty_path, "-load", self.target])
#---------------------------------------------------------------------------
# Set up this module's configuration.
config = Config("bring me")
config.targets = Section("Targets section")
config.targets.mapping = Item(
default={
"my site": website("http://www.google.com"),
},
doc="Mapping of spoken targets to bringable targets.",
namespace={
"website": website,
"open": open,
"folder": folder,
"ssh": ssh,
},
)
config.lang = Section("Language section")
config.lang.bring_me = Item("bring me <target>",
doc="Command to bring a target;"
" must contain the <target> extra.")
config.lang.paste_me = Item("paste me <target>",
doc="Command to paste the location of a target;"
" must contain the <target> extra.")
config.load()
#---------------------------------------------------------------------------
grammarCfg.cmd.map = Item(
{
# Navigation keys.
"(up|gup|gope) [<n>]":
Key("up:%(n)d"),
"(up|gup|gope) [<n>] slow":
Key("up/15:%(n)d"),
"(down|gun|gown) [<n>]":
Key("down:%(n)d"),
"(down|gun|gown) [<n>] slow":
Key("down/15:%(n)d"),
"(left|leaf) [<n>]":
Key("left:%(n)d"),
"(left|leaf) [<n>] slow":
Key("left/15:%(n)d"),
"(right|Ross) [<n>]":
Key("right:%(n)d"),
"(right|Ross) [<n>] slow":
Key("right/15:%(n)d"),
"(page up|pope|powp) [<n>]":
Key("pgup:%(n)d"),
"(page down|pown|pound) [<n>]":
Key("pgdown:%(n)d"), # pown is getting confused with home
"up <n> (page|pages)":
Key("pgup:%(n)d"),
"down <n> (page|pages)":
Key("pgdown:%(n)d"),
"left <n> (word|words)":
Key("c-left/3:%(n)d/10"),
"right <n> (word|words)":
Key("c-right/3:%(n)d/10"),
"home|West":
Key("home"),
"end|East":
Key("end"),
"doc home|North":
Key("c-home/3"),
"doc end|South":
Key("c-end/3"),
# Shorthand word jumps and deletes
"fomble [<n>]":
Key("c-right/5:%(n)d"),
"kimble [<n>]":
Key("c-del/5:%(n)d"),
"bamble [<n>]":
Key("c-left/5:%(n)d"),
"dumbbell [<n>]":
Key("c-backspace/5:%(n)d"),
# Functional keys.
"space|ace|spooce":
release + Key("space"),
"(space|ace|spooce) [<n>]":
release + Key("space:%(n)d"),
"(enter|slap|loon|shock) [<n>]":
release + Key("enter:%(n)d"),
"(tab|tabby|tub|tubby) [<n>]":
Key("tab:%(n)d"),
"(delete|chuck) [<n>]":
Key("del/3:%(n)d"),
"(delete|chuck) [this] line":
Key("home, s-end, del"), # @IgnorePep8
"(backspace|chook|crack) [<n>]":
release + Key("backspace:%(n)d"),
"(application key|context menu)":
release + Key("apps/3"),
"win key":
release + Key("win/3"),
"paste [that]":
Function(paste_command),
"copy [that]":
Function(copy_command),
"cut [that]":
release + Key("c-x/3"),
"select all":
release + Key("c-a/3"),
"undo":
release + Key("c-z/3"),
"undo <n> [times]":
release + Key("c-z/3:%(n)d"),
"redo":
release + Key("c-y/3"),
"redo <n> [times]":
release + Key("c-y/3:%(n)d"),
"[(hold|press)] alt":
Key("alt:down/3"),
"release alt":
Key("alt:up"),
"[(hold|press)] shift":
Key("shift:down/3"),
"release shift":
Key("shift:up"),
"[(hold|press)] control":
Key("ctrl:down/3"),
"release control":
Key("ctrl:up"),
"release [all]":
release,
# Closures.
"angle brackets":
Key("langle, rangle, left/3"),
"brackets":
Key("lbracket, rbracket, left/3"),
"braces":
Key("lbrace, rbrace, left/3"),
"parens":
Key("lparen, rparen, left/3"),
"quotes":
Key("dquote/3, dquote/3, left/3"),
"single quotes":
Key("squote, squote, left/3"),
# Shorthand multiple characters.
"double <char>":
Text("%(char)s%(char)s"),
"triple <char>":
Text("%(char)s%(char)s%(char)s"),
"double escape":
Key("escape, escape"), # Exiting menus.
# Punctuation and separation characters, for quick editing.
#"colon [<n>]": Key("colon/2:%(n)d"),
#"semi-colon [<n>]": Key("semicolon/2:%(n)d"),
#"comma [<n>]": Key("comma/2:%(n)d"),
#"(dot|period) [<n>]": Key("dot/2:%(n)d"),
#"(dash|hyphen|minus) [<n>]": Key("hyphen/2:%(n)d"),
#"underscore [<n>]": Key("underscore/2:%(n)d"),
# To release keyboard capture by VirtualBox.
"press right control":
Key("Control_R"),
# Formatting <n> words to the left of the cursor.
"camel case <n> [words]":
Function(camel_case_count),
"pascal case <n> [words]":
Function(pascal_case_count),
"snake case <n> [words]":
Function(snake_case_count),
"title case <n> [words]":
Function(title_case_count),
"squash <n> [words]":
Function(squash_count),
"expand <n> [words]":
Function(expand_count),
"uppercase <n> [words]":
Function(uppercase_count),
"lowercase <n> [words]":
Function(lowercase_count),
# Format dictated words. See the formatMap for all available types.
# Ex: "camel case my new variable" -> "myNewVariable"
# Ex: "snake case my new variable" -> "my_new_variable"
# Ex: "uppercase squash my new hyphen variable" -> "MYNEW-VARIABLE"
"<formatType> <text>":
Function(format_text),
# For writing words that would otherwise be characters or commands.
# Ex: "period", tab", "left", "right", "home".
"say <reservedWord>":
Text("%(reservedWord)s"),
# Abbreviate words commonly used in programming.
# Ex: arguments -> args, parameters -> params.
"abbreviate <abbreviation>":
Text("%(abbreviation)s"),
# Text corrections.
"(add|fix) missing space":
Key("c-left/3, space, c-right/3"),
"(delete|remove) (double|extra) (space|whitespace)":
Key("c-left/3, backspace, c-right/3"), # @IgnorePep8
"(delete|remove) (double|extra) (type|char|character)":
Key("c-left/3, del, c-right/3"), # @IgnorePep8
# Microphone sleep/cancel started dictation.
"[<text>] (snore|go to sleep|cancel and sleep) [<text2>]":
Function(cancel_and_sleep), # @IgnorePep8
# Reload Natlink.
# errors and fails on win7_64bit i think because pywin is 32bit
# Reloading Python subsystem...
# some error occurred
# Traceback (most recent call last):
# File "C:\NatLink\NatLink\MacroSystem\core\natlinkmain.py", line 146, in <module>
# import natlinkstatus # for extracting status info (QH)
# File "C:\NatLink\NatLink\MacroSystem\core\natlinkstatus.py", line 180, in <module>
# import RegistryDict, natlinkcorefunctions
# File "C:\NatLink\NatLink\MacroSystem\core\natlinkcorefunctions.py", line 31, in <module>
# from win32com.shell import shell, shellcon
# File "C:\Python27\lib\site-packages\win32com\__init__.py", line 82, in <module>
# SetupEnvironment()
# File "<string>", line 3, in __init__
# TypeError: 'NoneType' object is not callable
"reload Natlink":
Function(reload_natlink),
},
namespace={
"Key": Key,
"Text": Text,
})
from dragonfly import Config, Section, Item
config = Config("gvim")
# What words you wish to use to trigger vim's commands
config.cmd = Section("Language")
# What custom settings does your system have?
config.system = Section("System")
config.system.windowSwitchPrefix = Item(
'c-', # default: "c-w,",
doc=
"What prefix to use when switching windows? Relevant with vim-tmux-navigator (which can make vim windows and tmux panes inter-navigable.)."
)
def get_config():
return config
grammarCfg.cmd.map = Item(
{
# Navigation keys.
"up [<n>]": Key("up:%(n)d"),
"up [<n>] slow": Key("up/15:%(n)d"),
"down [<n>]": Key("down:%(n)d"),
"down [<n>] slow": Key("down/15:%(n)d"),
"left [<n>]": Key("left:%(n)d"),
"left [<n>] slow": Key("left/15:%(n)d"),
"right [<n>]": Key("right:%(n)d"),
"right [<n>] slow": Key("right/15:%(n)d"),
"jump up [<n>]": Key("pgup:%(n)d"),
"jump down [<n>]": Key("pgdown:%(n)d"),
"up <n> (page|pages)": Key("pgup:%(n)d"),
"down <n> (page|pages)": Key("pgdown:%(n)d"),
"left <n> (word|words)": Key("c-left/3:%(n)d/10"),
"right <n> (word|words)": Key("c-right/3:%(n)d/10"),
"house": Key("home"),
"street": Key("end"),
"doc house": Key("c-home/3"),
"doc street": Key("c-end/3"),
"Thomas": Key("a-space"),
"lamp": Key("c-left"),
"lamp <n>": Key("control:down/3") + Key("left:%(n)d") + Key("control:up"),
"ramp": Key("c-right"),
"ramp <n>": Key("control:down/3") + Key("right:%(n)d") + Key("control:up"),
"lace": Key("control:down/3") + Key("s-left") + Key("control:up"),
"lace <n>": Key("control:down/3") + Key("s-left:%(n)d") + Key("control:up"),
"race": Key("control:down/3") + Key("s-right") + Key("control:up"),
"race <n>": Key("control:down/3") + Key("s-right:%(n)d") + Key("control:up"),
"lava": Key("s-home"),
"raven": Key("s-end"),
# Functional keys.
"space": release + Key("space"),
"space [<n>]": release + Key("space:%(n)d"),
"slap [<n>]": release + Key("enter:%(n)d"),
"tab [<n>]": Key("tab:%(n)d"),
"delete [<n>]": Key("del/3:%(n)d"),
"daily": Key("home, s-end, del"), # @IgnorePep8
"backspace [<n>]": release + Key("backspace:%(n)d"),
"application key": release + Key("apps/3"),
"win key": release + Key("win/3"),
"paste [that]": Function(paste_command),
"copy [that]": Function(copy_command),
"cut [that]": release + Key("c-x/3"),
"select all": release + Key("c-a/3"),
"icey": release + Key("c-z/3"),
"icey <n> [times]": release + Key("c-z/3:%(n)d"),
"redo": release + Key("c-y/3"),
"redo <n> [times]": release + Key("c-y/3:%(n)d"),
"[(hold|press)] alt": Key("alt:down/3"),
"release alt": Key("alt:up"),
"[(hold|press)] shift": Key("shift:down/3"),
"release shift": Key("shift:up"),
"[(hold|press)] control": Key("ctrl:down/3"),
"release control": Key("ctrl:up"),
"release [all]": release,
# Closures.
"angle kets": Key("langle, rangle, left/3"),
"brackets": Key("lbracket, rbracket, left/3"),
"braces": Key("lbrace, rbrace, left/3"),
"parens": Key("lparen, rparen, left/3"),
"quotes": Key("dquote/3, dquote/3, left/3"),
"single quotes": Key("squote, squote, left/3"),
# Shorthand multiple characters.
"<char>": Text("%(char)s"),
"double <char>": Text("%(char)s%(char)s"),
"triple <char>": Text("%(char)s%(char)s%(char)s"),
"shark": Key("escape, escape"), # Exiting menus.
# Punctuation and separation characters, for quick editing.
"colon [<n>]": Key("colon/2:%(n)d"),
"semi-colon [<n>]": Key("semicolon/2:%(n)d"),
"comma [<n>]": Key("comma/2:%(n)d"),
"(dot|period) [<n>]": Key("dot/2:%(n)d"),
"underscore [<n>]": Key("underscore/2:%(n)d"),
# To release keyboard capture by VirtualBox.
"press right control": Key("Control_R"),
# Formatting <n> words to the left of the cursor.
"camel <n> [words]": Function(camel_case_count),
"pascal <n> [words]": Function(pascal_case_count),
"snake <n> [words]": Function(snake_case_count),
"squash <n> [words]": Function(squash_count),
"expand <n> [words]": Function(expand_count),
"uppercase <n> [words]": Function(uppercase_count),
"lowercase <n> [words]": Function(lowercase_count),
# Format dictated words. See the formatMap for all available types.
# Ex: "camel case my new variable" -> "myNewVariable"
# Ex: "snake case my new variable" -> "my_new_variable"
# Ex: "uppercase squash my new hyphen variable" -> "MYNEW-VARIABLE"
"<formatType> <text>": Function(format_text),
# For writing words that would otherwise be characters or commands.
# Ex: "period", tab", "left", "right", "home".
"say <reservedWord>": Text("%(reservedWord)s"),
# Abbreviate words commonly used in programming.
# Ex: arguments -> args, parameters -> params.
"squish <abbreviation>": Text("%(abbreviation)s"),
# Text corrections.
"(add|fix) missing space": Key("c-left/3, space, c-right/3"),
"(delete|remove) (double|extra) (space|whitespace)": Key("c-left/3, backspace, c-right/3"), # @IgnorePep8
"(delete|remove) (double|extra) (type|char|character)": Key("c-left/3, del, c-right/3"), # @IgnorePep8
# Microphone sleep/cancel started dictation.
"clinkz": Function(reload_rules), # @IgnorePep8
"code mode": Mimic("\\no-caps-on") + Mimic("\\no-space-on"),
# create rules
"dragon rule": Text('dragonrule') + Key("tab"),
"dragon text": Text('dragontext') + Key("tab"),
"dragon key": Text('dragonkey') + Key("tab"),
"dockmel <text>": Text('.') + Function(camel_case_text),
"libra": Text("() {}") + Key('left, enter'),
'pro one': Key('w-1'),
'pro two': Key('w-2'),
'pro three': Key('w-3'),
'pro four': Key('w-4'),
'pro five': Key('w-5'),
'pro six': Key('w-6'),
'pro seven': Key('w-7'),
'pro eight': Key('w-8'),
'pro nine': Key('w-9'),
},
namespace={
"Key": Key,
"Text": Text,
}
)
import pkg_resources
pkg_resources.require("dragonfly >= 0.6.5beta1.dev-r81")
except ImportError:
pass
import os, os.path
from dragonfly import (Grammar, CompoundRule, DictList, DictListRef,
MappingRule, Mimic, Key, FocusWindow, Window, Config,
Section, Item)
#---------------------------------------------------------------------------
# Set up this module's configuration.
config = Config("config manager")
config.lang = Section("Language section")
config.lang.list_configs = Item("list configs", doc="Command to ...")
config.lang.edit_config = Item("edit <config> (config | configuration)",
doc="Command to ...")
config.lang.show_dragonfly_version = Item("show dragonfly version",
doc="Command to ...")
config.lang.update_dragonfly = Item("update dragonfly version",
doc="Command to ...")
config.lang.reload_natlink = Item("reload natlink", doc="Command to ...")
config.load()
#---------------------------------------------------------------------------
config_map = DictList("config_map")
#---------------------------------------------------------------------------
grammarCfg.cmd.map = Item(
{
# Navigation keys.
"up [<n>]":
Key("up:%(n)d"),
"up [<n>] slow":
Key("up/15:%(n)d"),
"down [<n>]":
Key("down:%(n)d"),
"down [<n>] slow":
Key("down/15:%(n)d"),
"left [<n>]":
Key("left:%(n)d"),
"left [<n>] slow":
Key("left/15:%(n)d"),
"right [<n>]":
Key("right:%(n)d"),
"right [<n>] slow":
Key("right/15:%(n)d"),
"page up [<n>]":
Key("pgup:%(n)d"),
"page down [<n>]":
Key("pgdown:%(n)d"),
"up <n> (page|pages)":
Key("pgup:%(n)d"),
"down <n> (page|pages)":
Key("pgdown:%(n)d"),
"left <n> (word|words)":
Key("c-left/3:%(n)d/10"),
"right <n> (word|words)":
Key("c-right/3:%(n)d/10"),
"home|homer":
Key("home"),
"end":
Key("end"),
"doc home":
Key("c-home/3"),
"doc end":
Key("c-end/3"),
"doc save":
Key("c-s"),
"doc open":
Key("c-o"),
"doc save as":
Key("alt:down/3,f/3,a/3,alt:up/3"),
"doc close [<n>]":
Key("c-w:%(n)d"),
"doc close all":
Key("cs-w:%(n)d"),
"doc next [<n>]":
Key("c-tab:%(n)d"),
"doc create":
Key("c-n"),
"doc new tab":
Key("c-t"),
"doc (previous|back) [<n>]":
Key("cs-tab:%(n)d"),
"doc (search|find)":
Key("c-f"),
"doc print":
Key("c-p"),
"doc format":
Key("a-e, v, a"),
"doc this year":
Key("a-d/5, end/5") +
Text("&tbs=cdr%%3A1%%2Ccd_min%%3A1+Jan+2019%%2Ccd_max%%3A&tbm=",
pause=0.001) + Key("enter"),
"zoom in":
Key("c-plus, c-plus"),
"zoom out":
Key("c-minus, c-minus"),
"zoom reset":
Key("c-0"),
"select line [<n>]":
release + Key("home, home, s-down:%(n)d"),
"go block start [<n>]":
Key("sa-[:%(n)d"),
"show parameters":
Key("cs-space"),
"integer":
Text("int"),
"variable":
Text("var"),
"uno [<n>]":
Key("f1:%(n)d"),
"doss [<n>]":
Key("f2:%(n)d"),
"trez [<n>]":
Key("f3:%(n)d"),
"quatro [<n>]":
Key("f4:%(n)d"),
"sinko [<n>]":
Key("f5:%(n)d"),
"see ettay [<n>]":
Key("f7:%(n)d"),
"occo [<n>]":
Key("f8:%(n)d"),
"noo evvay [<n>]":
Key("f9:%(n)d"),
"dee ez [<n>]":
Key("f10:%(n)d"),
"onsay [<n>]":
Key("f11:%(n)d"),
"dossay [<n>]":
Key("f12:%(n)d"),
# Functional keys.
"space":
release + Key("space"),
"space [<n>]":
release + Key("space:%(n)d"),
"(slap|go) [<n>]":
release + Key("enter:%(n)d"),
"tab [<n>]":
Key("tab:%(n)d"),
"delete [<n>]":
Key("del/3:%(n)d"),
"delete [this] line":
Key("home, home, s-end, del, del"), # @IgnorePep8
"backspace [<n>]":
release + Key("backspace:%(n)d"),
"application key":
release + Key("apps/3"),
"win key":
release + Key("win/3"),
"paste [that]":
Function(paste_command),
"copy [that]":
Function(copy_command),
"cut [that]":
release + Key("c-x/3"),
"select all":
release + Key("c-a/3"),
"undo":
release + Key("c-z/3"),
"undo <n> [times]":
release + Key("c-z/3:%(n)d"),
"redo":
release + Key("c-y/3"),
"redo <n> [times]":
release + Key("c-y/3:%(n)d"),
"[(hold|press)] (alt|meta)":
Key("alt:down/3"),
"release (alt|meta)":
Key("alt:up"),
"[(hold|press)] shift":
Key("shift:down/3"),
"release shift":
Key("shift:up"),
"[(hold|press)] control":
Key("ctrl:down/3"),
"release control":
Key("ctrl:up"),
"(hold|press) (hyper|windows)":
Key("win:down/3"),
"release (hyper|windows)":
Key("win:up"),
"[press] (hyper|windows) first":
Key("win:down/3, 1/3, win:up/3"),
"[press] (hyper|windows) <m>":
Key("win:down/3, %(m)d/3, win:up/3"),
"release [all]":
release,
"git commit minus M":
Text("git commit -m "),
# Closures.
"angle brackets":
Key("langle, rangle, left/3"),
"brackets":
Key("lbracket, rbracket, left/3"),
"braces":
Key("lbrace, rbrace, left/3"),
"parens":
Key("lparen, rparen, left/3"),
"quotes":
Key("dquote/3, dquote/3, left/3"),
"single quotes":
Key("squote, squote, left/3"),
# To release keyboard capture by VirtualBox.
"press right control":
Key("Control_R"),
# Formatting <n> words to the left of the cursor.
"camel case <n> [words]":
Function(camel_case_count),
"pascal case <n> [words]":
Function(pascal_case_count),
"snake case <n> [words]":
Function(snake_case_count),
"squash <n> [words]":
Function(squash_count),
"expand <n> [words]":
Function(expand_count),
"uppercase <n> [words]":
Function(uppercase_count),
"lowercase <n> [words]":
Function(lowercase_count),
# Format dictated words. See the formatMap for all available types.
# Ex: "camel case my new variable" -> "myNewVariable"
# Ex: "snake case my new variable" -> "my_new_variable"
# Ex: "uppercase squash my new hyphen variable" -> "MYNEW-VARIABLE"
"<formatType> <text>":
Function(format_text),
# For writing words that would otherwise be characters or commands.
# Ex: "period", tab", "left", "right", "home".
"Simon says <reservedWord>":
Text("%(reservedWord)s"),
# Abbreviate words commonly used in programming.
# Ex: arguments -> args, parameterers -> params.
"abbreviate <abbreviation>":
Text("%(abbreviation)s"),
# Text corrections.
"(add|fix) missing space":
Key("c-left/3, space, c-right/3"),
"(delete|remove) (double|extra) (space|whitespace)":
Key("c-left/3, backspace, c-right/3"), # @IgnorePep8
"(delete|remove) (double|extra) (type|char|character)":
Key("c-left/3, del, c-right/3"), # @IgnorePep8
# Microphone sleep/cancel started dictation.
"[<text>] (go to sleep|cancel and sleep) [<text2>]":
Function(cancel_and_sleep), # @IgnorePep8
# Reload Natlink.
"reload Natlink":
Function(reload_natlink),
# Ego
"alpha":
Text("a"),
"bravo":
Text("b"),
"charlie":
Text("c"),
"delta":
Text("d"),
"echo":
Text("e"),
"foxtrot":
Text("f"),
"golf":
Text("g"),
"hotel":
Text("h"),
"(india|indigo)":
Text("i"),
"juliet":
Text("j"),
"kilo":
Text("k"),
"lima":
Text("l"),
"mike":
Text("m"),
"november":
Text("n"),
"oscar":
Text("o"),
"(Papa|pappa|pepper|popper)":
Text("p"),
"quebec":
Text("q"),
"romeo":
Text("r"),
"sierra":
Text("s"),
"tango":
Text("t"),
"uniform":
Text("u"),
"victor":
Text("v"),
"whiskey":
Text("w"),
"x-ray":
Text("x"),
"yankee":
Text("y"),
"zulu":
Text("z"),
"big alpha":
Text("A"),
"big bravo":
Text("B"),
"big charlie":
Text("C"),
"big delta":
Text("D"),
"big echo":
Text("E"),
"big foxtrot":
Text("F"),
"big golf":
Text("G"),
"big hotel":
Text("H"),
"big india":
Text("I"),
"big juliet":
Text("J"),
"big kilo":
Text("K"),
"big lima":
Text("L"),
"big mike":
Text("M"),
"big november":
Text("N"),
"big oscar":
Text("O"),
"big (Papa|pappa|pepper|popper)":
Text("P"),
"big quebec":
Text("Q"),
"big romeo":
Text("R"),
"big sierra":
Text("S"),
"big tango":
Text("T"),
"big uniform":
Text("U"),
"big victor":
Text("V"),
"big whiskey":
Text("W"),
"big x-ray":
Text("X"),
"big yankee":
Text("Y"),
"big zulu":
Text("Z"),
# Ego
"quote [<n>]":
release + Key("dquote:%(n)d"),
"dot":
Text("."),
"backslish":
Text("\\"),
"slish":
Text("/"),
"lape":
Text("("),
"rape":
Text(")"),
"lace":
Text("{"),
"race":
Text("}"),
"(lack|bra)":
Text("["),
"(rack|ket)":
Text("]"),
"lang":
Text("<"),
"rang":
Text(">"),
"pipe":
Text("|"),
"eke":
Text("="),
"bang":
Text("!"),
"plus":
Text("+"),
"minus":
Text("-"),
"mull":
Text("*"),
"(underscore|bar) [<n>]":
Key("underscore/2:%(n)d"),
"(sem|semi|rock|semicolon)":
Text(";"),
"(coal|colon)":
Text(":"),
"(comma|cam) [<n>]":
Key("comma/2:%(n)d"),
"(dot|period) [<n>]":
Key("dot/2:%(n)d"),
"(dash|hyphen) [<n>]":
Key("hyphen/2:%(n)d"),
"hash [<n>]":
Key("hash/2:%(n)d"),
#"": Text(""),
# Ego
"quit [<n>]":
release + Key("escape:%(n)d"),
"switch [<n>]":
release + Key("alt:down/10, tab:%(n)d/10, alt:up"),
"hut":
release + Key("alt:down/5, d, alt:up"),
"context menu":
release + Key("apps"),
# Ego
"hash include stud Io":
Text("#include <stdio.h>"),
"hash include stud lib":
Text("#include <stdlib.h>"),
"change directory":
Text("cd "),
"change directory drive":
Text("cd /D "),
"directory list":
Text("dir "),
"strike [<n>]":
release + Key("backspace:%(n)d"),
"kill [<n>]":
release + Key("delete:%(n)d"),
"pig [<n>]":
release + Key("pgdown:%(n)d"),
"pug [<n>]":
release + Key("pgup:%(n)d"),
"comment":
Text("// "),
# Ego
"dictation on":
Function(dictation_on),
"dictation off":
Function(dictation_off),
"say <text>":
Text("%(text)s"),
# Ego
"show dragon tip":
Text(""),
"move dragon tip":
Mouse("[15, 8]/200, left:down, [0.66, 0.98], left:up, <-50,0>"),
},
namespace={
"Key": Key,
"Text": Text,
})