def __init__(self, name, cmdWords,
allowNoChoice=True,
ruleType=RuleType.TERMINAL):
if type(cmdWords) in (unicode, str):
self.cmdWords = [cmdWords]
else:
self.cmdWords = cmdWords
self.name = name
self.ruleType = ruleType
self.allowNoChoice = allowNoChoice
getLoop().subscribeEvent(ConnectedEvent, self._sendWords)
self.actionRule = None
self.wordRule = None
self.rule = None
# self.words is a list of lists of sets where:
# self.words[phraseLength][wordIndex] = set() of words
# So if "foo bar" is a valid phrase, then it contains:
# self.words[2][0] == "foo"
# self.words[2][1] == "bar"
self.words = []
# self.selectionMap is a list of tuples where the first element
# is a list of words in order that map to the second element in
# the tuple.
self.selectionMap = []
self.activated = False
self.context = Context(set([self]))
self._buildRule()
def __init__(self, name, cmdWords, eventType):
WordSelector.__init__(self,
name,
cmdWords,
allowNoChoice=False,
ruleType=RuleType.TERMINAL)
self.rule.context.addRequirement(IsEmacs)
getLoop().subscribeEvent(eventType, self._onEmacsWord)
def __init__(self, eventQ, filterFunc=lambda x: False):
self.filterFunc = filterFunc
self.pushQ = eventQ
self.previousWindowId = None
self.previousWindowName = None
self.nextWindowList = getWindowList()
self.previousWindowList = []
# this is still too much of a perf hog, need real poll
getLoop().subscribeTimer(REFRESH_TIME, self)
def activate(self):
self.subHandles = []
self.subHandles.append(getLoop().subscribeTimer(self.interval,
self.update,
priority=0))
self.subHandles.append(getLoop().subscribeEvent(FocusChangeEvent,
self.update,
priority=0))
self.subHandles.append(getLoop().subscribeEvent(EmacsConnectedEvent,
self.update,
priority=0))
def __init__(self, eventQ, filterFunc=lambda x: False):
self.filterFunc = filterFunc
self.pushQ = eventQ
self.previousWindowId = None
self.previousWindowName = None
self.nextWindowList = getWindowList()
self.previousWindowList = []
# this is still too much of a perf hog, need real poll
getLoop().subscribeTimer(REFRESH_TIME, self)
def onClientConnect(self):
if not self.other:
# we use a timeout so ctrl-c will work
self.server_socket.settimeout(BLOCK_TIME)
try:
#log.info('waiting for connection')
self.other, addr = self.server_socket.accept()
self.otherHandle = getLoop().subscribeFile(self.other.fileno(), getLoop().FILE_INPUT, self.onClientData)
log.info('connected')
self.onConnect()
except socket.timeout:
return
def onClientConnect(self):
if not self.other:
# we use a timeout so ctrl-c will work
self.server_socket.settimeout(BLOCK_TIME)
try:
#log.info('waiting for connection')
self.other, addr = self.server_socket.accept()
self.otherHandle = getLoop().subscribeFile(
self.other.fileno(),
getLoop().FILE_INPUT, self.onClientData)
log.info('connected')
self.onConnect()
except socket.timeout:
return
def tryConnect(self):
if not self.sock:
self.makeSocket()
self.sock.settimeout(0.05)
try:
self.sock.connect(("localhost", 23233))
log.info("Connected to emacs!")
getLoop().put(EmacsConnectedEvent())
return True
except socket.error as e:
log.error("Error connecting to emacs: %s" % e)
except socket.timeout as e:
log.error("Connection to emacs timed out.")
return False
def tryConnect(self):
if not self.sock:
self.makeSocket()
self.sock.settimeout(0.05)
try:
self.sock.connect((self.host, self.port))
log.info("Connected to emacs!")
getLoop().put(EmacsConnectedEvent())
return True
except socket.error as e:
log.error("Error connecting to emacs: %s" % e)
except socket.timeout as e:
log.error("Connection to emacs timed out.")
return False
def __init__(self, var, value, contexts=None, useTimer=True, useFocus=False):
self.var = var
self.value = value
Requirement.__init__(self, contexts)
getLoop().subscribeEvent(EmacsConnectedEvent, self._query, priority=0)
if useTimer:
getLoop().subscribeTimer(1, self._query, priority=0)
if useFocus:
getLoop().subscribeEvent(FocusChangeEvent, self._query, priority=0)
def __init__(self,
var,
value,
contexts=None,
useTimer=True,
useFocus=False):
self.var = var
self.value = value
Requirement.__init__(self, contexts)
getLoop().subscribeEvent(EmacsConnectedEvent, self._query, priority=0)
if useTimer:
getLoop().subscribeTimer(1, self._query, priority=0)
if useFocus:
getLoop().subscribeEvent(FocusChangeEvent, self._query, priority=0)
def __init__(self, name, cmdWord):
WordSelector.__init__(self, name, cmdWord, allowNoChoice=False)
self.rule.context.addRequirement(IsEmacs)
self.rule.context.addRequirement(ModeRequirement(modes="erc-mode"))
getLoop().subscribeEvent(NickEvent, self._onNickList)
# log.info("connected [%s] loading [%s] state [%s] recog [%s]" % (self.connected, self.loading, self.micState,
# self.recognitionState))
finalState = None
if not self.connected:
finalState = "disconnected"
else:
if self.micState == "on":
if self.loading:
finalState = "disconnected"
else:
finalState = self.recognitionState
else:
finalState = self.micState
self.tellEmacs(finalState)
def tellEmacs(self, state):
# log.info("telling emacs cursor state: %s" % state)
runEmacsCmd("(md-new-mic-state \"%s\")" % state)
_state = MicrophoneState()
getLoop().subscribeEvent(MicrophoneEvent, _state.onMicState)
getLoop().subscribeEvent(RecognitionStateEvent, _state.onRecognitionState)
getLoop().subscribeEvent(LoadingRulesEvent, _state.loadingRulesChange)
getLoop().subscribeEvent(ConnectedEvent, _state.onConnect)
getLoop().subscribeEvent(DisconnectedEvent, _state.onDisconnect)
getLoop().subscribeEvent(EmacsConnectedEvent, _state.sendState)
def __init__(self):
getLoop().subscribeEvent(WindowListEvent, self._onWindowList)
WordSelector.__init__(self, "WindowNames", "win", allowNoChoice=False)
self.rule.activate() # always on
from rules.emacs.Cmd import CharCmd, Cmd, runEmacsCmd
from rules.ContextualRule import makeContextualRule
from requirements.Emacs import IsEmacs
from rules.emacs.common import emacsExtras, emacsDefaults
from EventList import WordListEvent, MajorModeEvent
from EventLoop import getLoop, pushEvent
from protocol import ListRef
import grammar
_mapping = {
"warp <charrule>" : CharCmd('(md-sn-find-slot %s)'),
"blank" : Cmd('(md-sn-next-slot)'),
"make blank" : Cmd('(md-sn-drop-slot)'),
"funk call [<i>]" : Cmd("(md-insert-call-snippet %(i)d)"),
"make <snippetList>" : Cmd("(md-insert-snippet \"%(snippetList)s\")"),
}
_extras = [
ListRef("SnippetList", "snippetList", [])
]
SnippetRule = makeContextualRule("Snippet", _mapping, emacsExtras + _extras, emacsDefaults)
SnippetRule.context.addRequirement(IsEmacs)
def _onModeChange(self):
snippetList = grammar.getStringList(runEmacsCmd("(md-get-snippet-names)"))
log.info("Snippet names: [%s]" % snippetList)
pushEvent(WordListEvent("SnippetList", snippetList))
getLoop().subscribeEvent(MajorModeEvent, _onModeChange)
if not ev.window.emacsMandimusHost or not ev.window.emacsMandimusPort:
return
key = (ev.window.emacsMandimusHost, ev.window.emacsMandimusPort)
if key not in allCommandClients:
allCommandClients[key] = CommandClient(key[0], key[1])
if clientInst is not allCommandClients[key]:
log.info("Switching to emacs: {}".format(key))
clientInst = allCommandClients[key]
# getLoop().put(EmacsConnectedEvent())
# priority=-1 in order to make sure it runs before the code that
# queries the current major mode, otherwise you might get the major
# mode of the last focused emacs not the newly focused emacs.
getLoop().subscribeEvent(FocusChangeEvent, _choose_command_client, priority=-1)
def runEmacsCmd(command, inFrame=True, dolog=False, allowError=False, queryOnly=True):
global clientInst
if clientInst is None:
log.info("Can't run command because not attached to any emacs: {}".format(command))
return ""
return clientInst.runCmd(command, inFrame, dolog, allowError, queryOnly)
class Minibuf(Action):
def __call__(self, extras={}):
# Key("a-x")()
Key("c-c,m,x")() # guaranteed to not use helm
Text(self.data % extras)()
Key("enter")()
def __init__(self, name, cmdWord):
WordSelector.__init__(self, name, cmdWord)
self.rule.context.addRequirement(IsEmacs)
getLoop().subscribeEvent(ProjectListEvent, self._onProjectList)
def __init__(self, modes, contexts=None):
self.modes = modes
if type(modes) == str or type(modes) == unicode:
self.modes = [self.modes]
Requirement.__init__(self, contexts)
getLoop().subscribeEvent(MajorModeEvent, self.onModeChange)
log.info("Switching major mode: {}".format(_majorMode))
pushEvent(MajorModeEvent(_majorMode))
_oldMajorMode = _majorMode
def _getMajorMode():
global _majorMode
return _majorMode
def _clearMajorMode(ev):
global _oldMajorMode
_oldMajorMode = None
getLoop().subscribeEvent(EmacsConnectedEvent, _clearMajorMode, priority=0)
getLoop().subscribeEvent(FocusChangeEvent, _updateMajorMode, priority=0)
class ModeRequirement(Requirement):
def __init__(self, modes, contexts=None):
self.modes = modes
if type(modes) == str or type(modes) == unicode:
self.modes = [self.modes]
Requirement.__init__(self, contexts)
getLoop().subscribeEvent(MajorModeEvent, self.onModeChange)
def onModeChange(self, ev):
# if you have no mode requirement, you trivially match
if not self.modes:
self._met(True)
def __init__(self, address, pushQ):
self.address = address
self.pushQ = pushQ
DragonflyNode.__init__(self, pushQ)
self.history = []
# dictionary mapping rule hash -> HashedRule
self.hashedRules = {}
# contains HashedRule's
self.activatedRules = set()
# contains HashedRule's from last time we committed, so
# we can check if we actually need to send changes
self.activatedLastCommit = set()
self.lastWordList = {}
self.server_socket = self.makeSocket()
self.server_socket.bind(self.address)
self.server_socket.listen(1)
self.other = None
self.otherHandle = None
self.buf = ''
self.utterance = []
getLoop().subscribeTimer(HEARTBEAT_TIME, self.onTimer)
getLoop().subscribeFile(
self.server_socket.fileno(),
getLoop().FILE_INPUT | getLoop().FILE_HUP | getLoop().FILE_ERROR,
self.onClientConnect)
getLoop().subscribeEvent(RuleActivateEvent, self.onRuleActivate)
getLoop().subscribeEvent(RuleRegisterEvent, self.onRuleRegister)
getLoop().subscribeEvent(RuleDeactivateEvent, self.onRuleDeactivate)
getLoop().subscribeEvent(EventsDrainedEvent,
self.commitRuleEnabledness)
getLoop().subscribeEvent(WordListEvent, self.onWordList)
getLoop().subscribeEvent(RepeatRequestEvent, self.onRepeatRequest)
def __init__(self, modes, contexts=None):
self.modes = modes
if type(modes) == str or type(modes) == unicode:
self.modes = [self.modes]
Requirement.__init__(self, contexts)
getLoop().subscribeEvent(MajorModeEvent, self.onModeChange)
def __init__(self, address, pushQ):
self.address = address
self.pushQ = pushQ
DragonflyNode.__init__(self, pushQ)
self.history = []
# dictionary mapping rule hash -> HashedRule
self.hashedRules = {}
# contains HashedRule's
self.activatedRules = set()
# contains HashedRule's from last time we committed, so
# we can check if we actually need to send changes
self.activatedLastCommit = set()
self.lastWordList = {}
self.server_socket = self.makeSocket()
self.server_socket.bind(self.address)
self.server_socket.listen(1)
self.other = None
self.otherHandle = None
self.buf = ''
self.utterance = []
getLoop().subscribeTimer(HEARTBEAT_TIME, self.onTimer)
getLoop().subscribeFile(self.server_socket.fileno(), getLoop().FILE_INPUT | getLoop().FILE_HUP | getLoop().FILE_ERROR, self.onClientConnect)
getLoop().subscribeEvent(RuleActivateEvent, self.onRuleActivate)
getLoop().subscribeEvent(RuleRegisterEvent, self.onRuleRegister)
getLoop().subscribeEvent(RuleDeactivateEvent, self.onRuleDeactivate)
getLoop().subscribeEvent(EventsDrainedEvent, self.commitRuleEnabledness)
getLoop().subscribeEvent(WordListEvent, self.onWordList)
getLoop().subscribeEvent(RepeatRequestEvent, self.onRepeatRequest)
def __init__(self, contexts=None, wmclass=None, negate=False):
self.wmclass = wmclass
self.negate = negate
Requirement.__init__(self, contexts)
getLoop().subscribeEvent(FocusChangeEvent, self.onFocusChange)
if key is None:
return
if key not in allCommandClients:
allCommandClients[key] = CommandClient(key[0], key[1])
if clientInst is not allCommandClients[key]:
log.info("Switching to emacs: {}".format(key))
clientInst = allCommandClients[key]
# getLoop().put(EmacsConnectedEvent())
# priority=-1 in order to make sure it runs before the code that
# queries the current major mode, otherwise you might get the major
# mode of the last focused emacs not the newly focused emacs.
getLoop().subscribeEvent(FocusChangeEvent, _choose_command_client, priority=-1)
def runEmacsCmd(command, inFrame=True, dolog=False, allowError=False, queryOnly=True):
global clientInst
if clientInst is None:
log.info("Can't run command because not attached to any emacs: {}".format(command))
return ""
return clientInst.runCmd(command, inFrame, dolog, allowError, queryOnly)
class Minibuf(Action):
def __call__(self, extras={}):
# Key("a-x")()
Key("c-t,c-m")() # guaranteed to not use helm
Text(self.data % extras)()
Key("enter")()
from rules.ContextualRule import makeContextualRule
from requirements.Emacs import IsEmacs
from rules.emacs.common import emacsExtras, emacsDefaults
from EventList import WordListEvent, MajorModeEvent
from EventLoop import getLoop, pushEvent
from protocol import ListRef
import grammar
_mapping = {
"warp <charrule>": CharCmd('(md-sn-find-slot %s)'),
"blank": Cmd('(md-sn-next-slot)'),
"make blank": Cmd('(md-sn-drop-slot)'),
"funk call [<i>]": Cmd("(md-insert-call-snippet %(i)d)"),
"make <snippetList>": Cmd("(md-insert-snippet \"%(snippetList)s\")"),
}
_extras = [ListRef("SnippetList", "snippetList", [])]
SnippetRule = makeContextualRule("Snippet", _mapping, emacsExtras + _extras,
emacsDefaults)
SnippetRule.context.addRequirement(IsEmacs)
def _onModeChange(self):
snippetList = grammar.getStringList(runEmacsCmd("(md-get-snippet-names)"))
log.info("Snippet names: [%s]" % snippetList)
pushEvent(WordListEvent("SnippetList", snippetList))
getLoop().subscribeEvent(MajorModeEvent, _onModeChange)
def activate(self):
self.subHandles = []
self.subHandles.append(getLoop().subscribeTimer(self.interval, self.update, priority=0))
self.subHandles.append(getLoop().subscribeEvent(FocusChangeEvent, self.update, priority=0))
self.subHandles.append(getLoop().subscribeEvent(EmacsConnectedEvent, self.update, priority=0))
def __init__(self, name, cmdWord, query):
WordSelector.__init__(self, name, cmdWord)
self.rule.context.addRequirement(IsEmacs)
self.query = query
getLoop().subscribeEvent(BufferListEvent, self._onBufferList)
def __init__(self, name, cmdWord):
WordSelector.__init__(self, name, cmdWord, allowNoChoice=False)
self.rule.context.addRequirement(IsEmacs)
self.rule.context.addRequirement(ModeRequirement(modes="erc-mode"))
getLoop().subscribeEvent(NickEvent, self._onNickList)
def __init__(self, name, cmdWords, eventType):
WordSelector.__init__(self, name, cmdWords, allowNoChoice=False,
ruleType=RuleType.TERMINAL)
self.rule.context.addRequirement(IsEmacs)
getLoop().subscribeEvent(eventType, self._onEmacsWord)
def __init__(self):
getLoop().subscribeEvent(WindowListEvent, self._onWindowList)
WordSelector.__init__(self, "WindowNames", "win", allowNoChoice=False)
self.rule.activate() # always on
def activate(self):
getLoop().put(RuleActivateEvent(self.rule))
def __init__(self, name, cmdWord, query):
WordSelector.__init__(self, name, cmdWord)
self.rule.context.addRequirement(IsEmacs)
self.query = query
getLoop().subscribeEvent(BufferListEvent, self._onBufferList)
# We use eventfd to wakeup the main thread so it will
# see the pedal event
written = os.write(wakeupFd, c_longlong(1))
if written != 8:
log.error("Error writing to eventfd.")
return 0
def errorCb(deviceId, status):
log.error("Error in pedals: [%s] [%s]" % (deviceId, status))
return 0
def readOut():
num = os.read(wakeupFd, 8)
log.debug("Pedal EventFD Read: %d" % struct.unpack('@Q', num)[0])
getLoop().subscribeFile(wakeupFd, getLoop().FILE_INPUT, readOut)
_dataCb = PHIDDataEvent(dataCb)
_errorCb = PHIDErrorEvent(errorCb)
infoArrayType = TEnumHIDInfo * MAX_XKEY_DEVICES
TEnumHIDInfoPtr = POINTER(TEnumHIDInfo)
info = infoArrayType()
count = c_long(0)
result = EnumeratePIE(PI_VID, info, pointer(count))
dev = None
for i in range(count.value):
dev = pointer(info[i])
def __init__(self, contexts=None, wmclass=None, negate=False):
self.wmclass = wmclass
self.negate = negate
Requirement.__init__(self, contexts)
getLoop().subscribeEvent(FocusChangeEvent, self.onFocusChange)
from EventLoop import getLoop
from rules.emacs.Cmd import runEmacsCmd
from EventList import WordEvent
import sys
def onWordEvent(ev):
runEmacsCmd(u"(mandimus-word-event \"%s\")" % ev.words)
getLoop().subscribeEvent(WordEvent, onWordEvent)
from subprocess import call
from EventLoop import getLoop
refreshingEnabled = False
def toggleRefreshClientSources(extras):
global refreshingEnabled
refreshingEnabled = not refreshingEnabled
def refreshClientSources(ev=None):
if refreshingEnabled:
call("touch ~/dragonshare/NatLink/NatLink/MacroSystem/*.py", shell=True)
getLoop().subscribeTimer(1, refreshClientSources)
from subprocess import call
from EventLoop import getLoop
refreshingEnabled = False
def toggleRefreshClientSources(extras):
global refreshingEnabled
refreshingEnabled = not refreshingEnabled
def refreshClientSources(ev=None):
if refreshingEnabled:
call("touch ~/dragonshare/NatLink/NatLink/MacroSystem/*.py",
shell=True)
getLoop().subscribeTimer(1, refreshClientSources)
def deactivate(self):
getLoop().put(RuleDeactivateEvent(self.rule))
_majorMode = runEmacsCmd("(md-get-all-modes)")
_majorMode = _getEmacsList(_majorMode)
if _majorMode != _oldMajorMode:
log.info("Switching major mode: {}".format(_majorMode))
pushEvent(MajorModeEvent(_majorMode))
_oldMajorMode = _majorMode
def _getMajorMode():
global _majorMode
return _majorMode
def _clearMajorMode(ev):
global _oldMajorMode
_oldMajorMode = None
getLoop().subscribeEvent(EmacsConnectedEvent, _clearMajorMode, priority=0)
getLoop().subscribeEvent(FocusChangeEvent, _updateMajorMode, priority=0)
class ModeRequirement(Requirement):
def __init__(self, modes, contexts=None):
self.modes = modes
if type(modes) == str or type(modes) == unicode:
self.modes = [self.modes]
Requirement.__init__(self, contexts)
getLoop().subscribeEvent(MajorModeEvent, self.onModeChange)
def onModeChange(self, ev):
# if you have no mode requirement, you trivially match
if not self.modes:
self._met(True)
return
from EventLoop import getLoop
from rules.emacs.Cmd import runEmacsCmd
from EventList import WordEvent
import sys
def onWordEvent(ev):
runEmacsCmd(u"(mandimus-word-event \"%s\")" % ev.words)
getLoop().subscribeEvent(WordEvent, onWordEvent)
def activate(self):
getLoop().put(RuleActivateEvent(self.rule))
if written != 8:
log.error("Error writing to eventfd.")
return 0
def errorCb(deviceId, status):
log.error("Error in pedals: [%s] [%s]" % (deviceId, status))
return 0
def readOut():
num = os.read(wakeupFd, 8)
log.debug("Pedal EventFD Read: %d" % struct.unpack('@Q', num)[0])
getLoop().subscribeFile(wakeupFd, getLoop().FILE_INPUT, readOut)
_dataCb = PHIDDataEvent(dataCb)
_errorCb = PHIDErrorEvent(errorCb)
infoArrayType = TEnumHIDInfo * MAX_XKEY_DEVICES
TEnumHIDInfoPtr = POINTER(TEnumHIDInfo)
info = infoArrayType()
count = c_long(0)
result = EnumeratePIE(PI_VID, info, pointer(count))
dev = None
for i in range(count.value):
dev = pointer(info[i])
def deactivate(self):
getLoop().put(RuleDeactivateEvent(self.rule))
