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 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, 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, 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 __init__(self, name, cmdWord, query): WordSelector.__init__(self, name, cmdWord) self.rule.context.addRequirement(IsEmacs) self.query = query getLoop().subscribeEvent(BufferListEvent, self._onBufferList)
def activate(self): getLoop().put(RuleActivateEvent(self.rule))
# 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])
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)
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
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])