Merge candidate for handler
This commit is contained in:
commit
930f658646
|
|
@ -50,5 +50,13 @@ To do so add a custom patch (or use a currently defined one, but chances are pat
|
|||
* TODO: Pagehandler: make a note handler
|
||||
* TODO: Color management, get colors associated to all statuses
|
||||
* TODO: General decorators @armtake
|
||||
<<<<<<< HEAD
|
||||
* TODO: Do a cleaner page printl
|
||||
* TODO: Do all page tests
|
||||
=======
|
||||
|
||||
* URGENT : Fix the connection issue
|
||||
* TODO: More explicit midi output/input connection error (and backup or exit)
|
||||
* TODO: CLEAN CONNECTION TO A RACK, ANYTHING BUT THIS CLUSTERF*CK
|
||||
* TODO: Connect the IOHandler with handler, binding and vice-versa, check some.
|
||||
>>>>>>> 24c2b19a5859b51b3f1036f08524b130635161c1
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#!/bin/python3
|
||||
###########################
|
||||
# IMPORTS
|
||||
|
||||
import mido
|
||||
###########################
|
||||
# FUNCTION DEFINES
|
||||
|
||||
|
|
@ -29,42 +29,70 @@ if _VERBOSE>=4:
|
|||
|
||||
###########################
|
||||
# CLASS DEFINES
|
||||
class lightHandler():
|
||||
def __init__(self,statusList,listAssociations):
|
||||
self.page=0
|
||||
self.output=None
|
||||
self.statusList={}
|
||||
self.statusAssociation={}
|
||||
self.lastpress=(None,None) #Does only account for the 8x8
|
||||
self.selected_pulse=(None,None)
|
||||
self.live_pulse=(None,None)
|
||||
self.addStatusList(statusList)
|
||||
self.initialiseColor()
|
||||
self.associateColor(listAssociations)
|
||||
class IOInterface():
|
||||
"Handle the IO actions between an external script and a midiPageHandler interface"
|
||||
def __init__(self,pagehandler,remoteController):
|
||||
self._pageHandler=pagehandler
|
||||
self._listActionsH={}
|
||||
self._listActionsIO={}
|
||||
self._pageHandler._IOInterface=self
|
||||
self._externalProgram=remoteController
|
||||
|
||||
def addStatusList(self,statusList):
|
||||
'Add a list of status'
|
||||
self.statusList=statusList
|
||||
self.maxStatus=max(self.statusList.values())
|
||||
def addActionIO(self,matchName,action):
|
||||
"""Associate a function to a match to a message received
|
||||
[externalP] -> Action -> [Handler]
|
||||
"""
|
||||
self._listActionsIO[matchName]=action
|
||||
|
||||
def initialiseColor(self,default=0):
|
||||
"Initialise the the colorstatus"
|
||||
for status in range(self.maxStatus*2-1):
|
||||
self.statusAssociation[status]=default
|
||||
def addActionH(self,name,action):
|
||||
"""Associate a function to match to a handler action
|
||||
[Handler] -> Action -> [externalP]
|
||||
"""
|
||||
self._listActionsH[name]=action
|
||||
|
||||
def associateColor(self,listAssociations):
|
||||
"Associate a status combination with a color"
|
||||
for status,color in listAssociations.items():
|
||||
self.statusAssociation[status]=color
|
||||
def messageReceived(self,typeM,messageMatch,*args):
|
||||
"""Acknoledge a message and do the appropriate actions
|
||||
[externalP] -> messageReceived -> Action -> [Handler]
|
||||
"""
|
||||
try:
|
||||
dprint("Received the command {} from the pulse ({})".format(typeM,messageMatch))
|
||||
self._listActionsIO[typeM](messageMatch,*args)
|
||||
except KeyError:
|
||||
wprint("The message type doesn't exits",typeM)
|
||||
|
||||
def lightcolor(self,col,row,color):
|
||||
self.light(col,row,val=_COLORS[color])
|
||||
def noteReceived(self,note,val):
|
||||
"""Acknoledge a control received and do the appropriate actions
|
||||
[internalMidiAction] -> [Handler]
|
||||
"""
|
||||
self.handler.noteReceived(note,val)
|
||||
|
||||
def light(self,col,row,val=1):
|
||||
self.lightnote(self.findit(col,row),val)
|
||||
def sendAction(self,name,*args):
|
||||
"""An action is to be sent to the external Program
|
||||
[Handler] -> [externalP]
|
||||
"""
|
||||
dprint("Sending command {} with args {} to the pulse".format(name,args))
|
||||
try:
|
||||
self._listActionsIO[name](*args)
|
||||
except KeyError:
|
||||
print(self._listActionsH)
|
||||
wprint("Can't send action request",name)
|
||||
|
||||
def lightnote(self,note,val=1):
|
||||
self.output.send(mido.Message("note_on",note=note,velocity=val))
|
||||
class IOInterfacePulse(IOInterface):
|
||||
"Specialised pulse interface"
|
||||
|
||||
def __init__(self,pagehandler,pulseModule,remoteController):
|
||||
super(IOInterfacePulse,self).__init__(pagehandler,remoteController)
|
||||
self._pulseModule=pulseModule
|
||||
# Commands that should be sent to the pulse
|
||||
self.addActionIO("LAYERINP",self._externalProgram.changeLayer)
|
||||
self.addActionIO("TAKEALL",self._externalProgram.takeAll)
|
||||
self.addActionIO("LOADMM",self._externalProgram.loadMM)
|
||||
self.addActionIO("QUICKF",self._externalProgram.quickFrame)
|
||||
self.addActionIO("FREEZE",self._externalProgram.freezeScreenAll)
|
||||
|
||||
# Command that are received from the pulse
|
||||
self.addActionH("LAYERINP",self._pulseModule.layerCommand)
|
||||
# self.addActionH("DETECTED",self._pulseModule.detected)
|
||||
|
||||
class midiPageHandler(object):
|
||||
"Page Handler, with some methods to manage a midi remote more easily"
|
||||
|
|
@ -78,8 +106,10 @@ class midiPageHandler(object):
|
|||
self._changedbasevalues=[] # Store the active values, not yet updated
|
||||
self._heightV=0
|
||||
self._widthV=0
|
||||
self._changes=set()
|
||||
self._IOInterface=None
|
||||
self.newListChanges()
|
||||
self._listPossibleValues={None:0b0}
|
||||
self.possibleStatus={}
|
||||
self.__maxV=0b1
|
||||
self._page=0
|
||||
self._maxpages=pages
|
||||
|
|
@ -87,6 +117,22 @@ class midiPageHandler(object):
|
|||
self._makeNotes(table)
|
||||
self.initValues()
|
||||
|
||||
###################
|
||||
# Important methods for Access
|
||||
def addStatusPos(self,statusName,linecol,page=None):
|
||||
"Apply a status to a position, applied when applyChanges is called"
|
||||
|
||||
def getColorPos(self,linecol):
|
||||
"Get the active color from a position"
|
||||
|
||||
def listNoteChanges(self):
|
||||
"Yield the list of (note,value) to update"
|
||||
for pos in self.listChanges():
|
||||
yield self.posToNote(pos),self.colorFrom(pos)
|
||||
|
||||
def noteReceived(self,note,val):
|
||||
"A note has been received, do the appropriate actions"
|
||||
pass
|
||||
####################
|
||||
# Manage attributes
|
||||
def _makeNotes(self,table):
|
||||
|
|
@ -128,6 +174,15 @@ class midiPageHandler(object):
|
|||
self.__maxV*=2
|
||||
return True
|
||||
|
||||
# def makeAssociationTable(self):
|
||||
# "Make a table to contain all associations"
|
||||
# self.statusList=statusList
|
||||
# self.maxStatus=max(self.statusList.values())
|
||||
# for status in range(self.maxStatus*2-1):
|
||||
# self.statusAssociation[status]=default
|
||||
# def addAssociation(self,status,color):
|
||||
# "Add an association of status and color, must be used after makeAssociationTable"
|
||||
|
||||
def listStatus(self):
|
||||
"Return the list of all values"
|
||||
return self._listPossibleValues
|
||||
|
|
@ -140,9 +195,10 @@ class midiPageHandler(object):
|
|||
####################
|
||||
# Page Changes
|
||||
def changePage(self,page):
|
||||
"Try to change page"
|
||||
"Try to change page, warning all pending changes will be lost"
|
||||
try:
|
||||
self._activebasevalues=self._basevalues[page]
|
||||
self.newListChanges()
|
||||
self.newChangedValues()
|
||||
self._redrawPageChange(self._page,page)
|
||||
self._page=page
|
||||
|
|
@ -170,7 +226,6 @@ class midiPageHandler(object):
|
|||
if self._changedbasevalues[i][j]!=self._activebasevalues[i][j]:
|
||||
self.addChange((i,j))
|
||||
|
||||
|
||||
####################
|
||||
# Modifiers methods
|
||||
|
||||
|
|
@ -182,12 +237,19 @@ class midiPageHandler(object):
|
|||
return 0
|
||||
return self._listPossibleValues[namestatus]
|
||||
|
||||
def addStatuses(self,linecol,status):
|
||||
"Add a status by name to a position"
|
||||
for status in status:
|
||||
# def addStatus(self,linecol,status):
|
||||
# "Add a status by name to a position"
|
||||
# self.addStatusId(linecol,self.statusId(status))
|
||||
|
||||
def addStatus(self,linecol,*statuses):
|
||||
"Add a list of statuses by name to a position"
|
||||
# if type(statuses)==str:
|
||||
# self.addStatusId(linecol,self.statusId(statuses))
|
||||
for status in statuses:
|
||||
self.addStatusId(linecol,self.statusId(status))
|
||||
|
||||
def removeStatuses(self,linecol,liststatus):
|
||||
|
||||
def removeStatus(self,linecol,*liststatus):
|
||||
"Remove a list of status, by name"
|
||||
for status in liststatus:
|
||||
self.removeStatusId(linecol,self.statusId(status))
|
||||
|
|
@ -219,12 +281,26 @@ class midiPageHandler(object):
|
|||
for change in self._changes:
|
||||
yield change
|
||||
|
||||
def newListChanges(self):
|
||||
"Add a new list of changes"
|
||||
self._changes=set()
|
||||
|
||||
def applyChanges(self):
|
||||
"Apply all changes and erase them, then reload another _changedbasevalues"
|
||||
for i,j in self.listChanges():
|
||||
self._activebasevalues[i][j]=self._changedbasevalues[i][j]
|
||||
self._changes=set()
|
||||
#self.newListChanges()
|
||||
|
||||
def colorFrom(self,linecol):
|
||||
"Obtain color from the linecol"
|
||||
return (self.possibleStatus[self.getTableElt(self._activebasevalues,linecol)])
|
||||
|
||||
def posToNote(self,linecol):
|
||||
return self.noteFrom(linecol)
|
||||
|
||||
def noteFrom(self,linecol):
|
||||
"Obtain note from the linecol"
|
||||
return self.getTableElt(self._posToNote,linecol)
|
||||
|
||||
######################
|
||||
# Table utilities
|
||||
|
|
@ -253,6 +329,7 @@ class midiPageHandler(object):
|
|||
for i in range(len(values)):
|
||||
table[i][col]=values[i]
|
||||
|
||||
|
||||
####################
|
||||
# Operator definitions
|
||||
|
||||
|
|
@ -286,6 +363,76 @@ class midiPageHandler(object):
|
|||
print(" "+lineM.format(*elt))
|
||||
print(sep)
|
||||
|
||||
|
||||
class pulseController(object):
|
||||
"Receive controls over a specific range and map them to commands to send"
|
||||
def __init__(self,returnInterface,ranges={j:j for j in range(3)}):
|
||||
self.ranges=ranges
|
||||
self.retunRanges={i:j for j,i in ranges.items()}
|
||||
_ALL_MESSAGE_TYPES=[
|
||||
"STATUS","LAYERINP","TAKE","TAKEALL","LOADMM","QUICKF"
|
||||
]
|
||||
self.returnInterface=returnInterface
|
||||
self.output=None
|
||||
self.poslastpressed=(0,0)
|
||||
self.idlastlayerpressed=0
|
||||
self.lastlayerpressed=[0,0]
|
||||
self.idlastmemorypressed=0
|
||||
self.offset=0 # Offset on the lines
|
||||
|
||||
def pressReceived(self,linecol,val):
|
||||
"Received an order from the controller, the order must be associated with an actual command and send it to the IOController"
|
||||
try:
|
||||
line,col=linecol
|
||||
trueline=self.ranges[line]
|
||||
if trueline==0: # It's a press on layer A
|
||||
self.layerPress((trueline,col),trueline,val,0)
|
||||
elif trueline==1: # It's a press on layer B
|
||||
self.layerPress((trueline,col),trueline,val,0)
|
||||
elif trueline==2: # It's a memory press
|
||||
self.memoryPress((trueline,col),val,0)
|
||||
else:
|
||||
pass # The pulse only takes 3 lines
|
||||
except KeyError as e:
|
||||
wprint("An error occured while the pulse was processing order",e)
|
||||
|
||||
def layerCommand(self,screen,liveprev,layer,col):
|
||||
"Received a layer command from the handler, will now translate it for the pulse TODO: CLEAN THIS HORRENDOUS THING"
|
||||
dprint("Received command to change layer:{} to {} on {}(live/prev)".format(layer,col,liveprev))
|
||||
# self.returnInterface._IOInterface._externalProgram.changeLayer(screen,liveprev,layer,col)
|
||||
# Do the actual color changing
|
||||
# .changeLayer()
|
||||
|
||||
def layerPress(self,linecol,layer,val,liveprev):
|
||||
"Adjust the color and info depending on the press" # Bound to dissapear
|
||||
self.idlastlayerpressed=layer
|
||||
line,col=linecol
|
||||
trueline=self.retunRanges[line]
|
||||
truelinecol=(trueline,col)
|
||||
self.returnInterface.removeStatus((trueline,self.lastlayerpressed[layer]),"Selected")
|
||||
self.lastlayerpressed[layer]=col
|
||||
self.returnInterface._IOInterface.sendAction("LAYERINP",0,liveprev,layer,col)
|
||||
if liveprev==0:
|
||||
self.returnInterface.addStatus(truelinecol,"Selected")
|
||||
else:
|
||||
self.returnInterface.addStatus(truelinecol,"Live")
|
||||
self.returnInterface.applyChanges()
|
||||
self.returnInterface.applyColors()
|
||||
|
||||
def memoryPress(self,linecol,val,liveprev):
|
||||
"""Adjust the color and info of a memory press (take or preview)
|
||||
Should be Green if defined and Yellow if not, selecting makes it prev"""
|
||||
line,col=linecol
|
||||
# self.removeStatus((line,self.idlastmemorypressed),"Selected")
|
||||
# self.idlastmemorypressed=col
|
||||
# self.addStatus(linecol,"Selected")
|
||||
self._IOInterface.sendAction("LOADMM",col,liveprev)
|
||||
# self.applyChanges()
|
||||
# self.applyColors()
|
||||
|
||||
def __repr__(self):
|
||||
return("PulseController{} ({self.idlastlayerpressed},{self.idlastmemorypressed})".format(list(self.ranges.keys()),self=self))
|
||||
|
||||
class AkaiAPCMini(midiPageHandler):
|
||||
"A specific implementation of the page handler"
|
||||
|
||||
|
|
@ -296,7 +443,7 @@ class AkaiAPCMini(midiPageHandler):
|
|||
|
||||
self.colors={"black":0,"green":1,"blinking_green":2,"red":3,"blinking_red":4,"yellow":5,"blinking_yellow":6}
|
||||
self.addPossibleValues(("Inactive","Active","Selected","Live"))
|
||||
_INACTIVE,_ACTIVE,_LIVE,_SELECTED=self.statusId("Inactive"),self.statusId("Active"),self.statusId("Selected"),self.statusId("Live")
|
||||
_INACTIVE,_ACTIVE,_LIVE,_SELECTED=self.statusId("Inactive"),self.statusId("Active"),self.statusId("Live"),self.statusId("Selected")
|
||||
|
||||
self.possibleStatus={
|
||||
0: self.colors["black"],
|
||||
|
|
@ -317,23 +464,68 @@ class AkaiAPCMini(midiPageHandler):
|
|||
_ACTIVE|_LIVE|_SELECTED: self.colors["blinking_red"],
|
||||
_ACTIVE|_INACTIVE|_LIVE: self.colors["blinking_red"], #Just live active
|
||||
_ACTIVE|_INACTIVE|_SELECTED:self.colors["blinking_green"], #Just selected active
|
||||
_INACTIVE|_LIVE|_SELECTED: self.colors["blinking_red"], # Very debatable
|
||||
_INACTIVE|_LIVE|_SELECTED: self.colors["blinking_red"], # Very debatable
|
||||
|
||||
_ACTIVE|_LIVE|_INACTIVE|_SELECTED:self.colors["blinking_red"] #Just live active selected
|
||||
}
|
||||
|
||||
self.colorHandler=lightHandler(self.listStatus(),self.possibleStatus)
|
||||
# self.changePage(0)
|
||||
self.listModules=[[None]*8] # Only one page and 8x8 for now
|
||||
# self.pulse1=pulseController(self,IOInterface)
|
||||
###########
|
||||
# For debug purposes
|
||||
for j in range(5):
|
||||
for i in range(8):
|
||||
self.addStatus((j,i),"Inactive")
|
||||
|
||||
for j in range(5,8):
|
||||
for i in range(8):
|
||||
self.addStatus((j,i),None)
|
||||
|
||||
def noteReceived(self,note,val):
|
||||
line,col=self._noteToPos[note]
|
||||
try:
|
||||
self.listModules[self._page][line].pressReceived((line,col),val)
|
||||
except AttributeError as e:
|
||||
wprint("No module loaded for Line {line}: {e}".format(line=line,e=e))
|
||||
wprint("List of modules available on page {page} is : {modules}".format(page=self._page,modules=self.listModules[self._page]))
|
||||
|
||||
def addModule(self,rackmodule,rangeActive):
|
||||
"Add a module to the controller, the range of control must be specified"
|
||||
module=rackmodule(self,{i:j for i,j in zip(rangeActive,range(len(rangeActive)))})
|
||||
for i in rangeActive:
|
||||
self.listModules[self._page][i]=module
|
||||
return module
|
||||
|
||||
def addInterfaceOut(self,interfaceOut):
|
||||
"Add one interface to send midi messages to, could be done another way"
|
||||
self.output=interfaceOut
|
||||
self.applyChanges()
|
||||
self.applyColors()
|
||||
|
||||
def applyColors(self):
|
||||
'Apply all the colorchanges'
|
||||
for note,val in self.listNoteChanges():
|
||||
self.lightnote(note,val)
|
||||
|
||||
def lightcolor(self,col,row,color):
|
||||
self.light(col,row,val=_COLORS[color])
|
||||
|
||||
def light(self,col,row,val=1):
|
||||
self.lightnote(self.findit(col,row),val)
|
||||
|
||||
def lightnote(self,note,val=1):
|
||||
self.output.send(mido.Message("note_on",note=note,velocity=val))
|
||||
|
||||
|
||||
|
||||
_TEST=True
|
||||
if __name__ == '__main__':
|
||||
ak=AkaiAPCMini()
|
||||
ak.prettyPrint(ak._posToNote)
|
||||
|
||||
# ak.addPossibleValues(("Inactive","Active","Selected","Live"))
|
||||
for i,v in ak._listPossibleValues.items():
|
||||
print("{}:{:b}".format(i,v))
|
||||
ak.addStatuses((2,1),("Active","Selected","Live"))
|
||||
ak.addStatus((2,1),"Active","Selected","Live")
|
||||
ak.addStatusId((5,5),ak.statusId("Active"))
|
||||
ak.addStatusId((5,5),ak.statusId("Selected"))
|
||||
ak.addStatusId((5,7),ak.statusId("Live"))
|
||||
|
|
@ -347,9 +539,30 @@ if __name__ == '__main__':
|
|||
ak.prettyPrint(ak._changedbasevalues)
|
||||
ak.removeStatusId((2,1),ak.statusId("Live"))
|
||||
ak.prettyPrint(ak._changedbasevalues)
|
||||
ak.removeStatuses((5,5),("Active","Selected"))
|
||||
ak.removeStatus((5,5),"Active","Selected")
|
||||
ak.prettyPrint(ak._changedbasevalues)
|
||||
|
||||
print(ak.statusId(("Active","Selected","Live")))
|
||||
<<<<<<< HEAD:mapping/midiPageHandler.py
|
||||
# ak.
|
||||
# light=lightHandler(ak.listStatus(),{})
|
||||
=======
|
||||
|
||||
ak.addStatus((3,3),"Active")
|
||||
ak.addStatus((3,3),"Active")
|
||||
ak.removeStatus((3,3),"Active")
|
||||
ak.removeStatus((3,3),"Active")
|
||||
ak.addStatus((3,3),"Active","Selected")
|
||||
ak.removeStatus((3,3),"Active")
|
||||
ak.addStatus((3,3),"Active","Live")
|
||||
ak.removeStatus((3,3),"Live")
|
||||
ak.prettyPrint(ak._changedbasevalues)
|
||||
ak.prettyPrint(ak._activebasevalues)
|
||||
ak.applyChanges()
|
||||
ak.prettyPrint(ak._activebasevalues)
|
||||
print(ak._changes)
|
||||
|
||||
for note,val in ak.listNoteChanges():
|
||||
print (note,val)
|
||||
print(ak.colorFrom((3,3)),ak.noteFrom((3,3)))
|
||||
>>>>>>> 24c2b19a5859b51b3f1036f08524b130635161c1:mapping/midipagehandler.py
|
||||
|
|
|
|||
|
|
@ -0,0 +1,18 @@
|
|||
#!/bin/python
|
||||
# Mini debugging tool, will get his own project at some point
|
||||
|
||||
|
||||
__DEBUG_LISTING={}
|
||||
######################
|
||||
# The listing is supposed to be composed of :
|
||||
# DEBUG[MODULE][SCOPE][FUNCTIONS]=(usage,cputimeused)
|
||||
|
||||
def debugListing(function,scope=None):
|
||||
"Add a function to the debug listing, on a custom category"
|
||||
_name,_usage=function.__name__,0
|
||||
__DEBUG_LISTING[_name]=[_usage,0]
|
||||
def returnFunction(*args,**kwargs):
|
||||
_usage+=1
|
||||
__DEBUG_LISTING[_name]=[_usage,0]
|
||||
function(*args,**kwargs)
|
||||
return returnFunction
|
||||
|
|
@ -5,6 +5,8 @@ from mapping.midi import MessageParse
|
|||
from mapping.midi import Actions
|
||||
import sys
|
||||
|
||||
from mapping.utils import doublepress
|
||||
from pythonAnalogWay import bindings
|
||||
###########################
|
||||
# FUNCTION DEFINES
|
||||
|
||||
|
|
@ -53,6 +55,7 @@ class pulseLink(object):
|
|||
def _onload(self):
|
||||
"Send a reset colors"
|
||||
import time,sys
|
||||
<<<<<<< HEAD
|
||||
# handler.prettyPrint(handler._activebasevalues)
|
||||
#vars.output=self.outputs[vars.interface_nb]
|
||||
|
||||
|
|
@ -63,11 +66,39 @@ def pagepress(trigger,val,note,*params):
|
|||
#,handler._posToNote[pos[0],pos[1]]
|
||||
dprint("Received {} (note:{})".format(pos,note))
|
||||
|
||||
=======
|
||||
HOSTS=[["127.0.0.1",3000]] # Test server
|
||||
# The socket remote controller
|
||||
controllerPulse=bindings.analogController(*HOSTS[0])
|
||||
|
||||
# Adding the midi interface to the controller
|
||||
handler.addInterfaceOut(self.interfaceOut(1))
|
||||
|
||||
# The pulse module, bound to 3 lines
|
||||
modulePulse=handler.addModule(midiPageHandler.pulseController,[4,1,2])
|
||||
|
||||
# The IO interface between the pulse and the controller, one IO is necessary per auxilliary application
|
||||
IOInterface=midiPageHandler.IOInterfacePulse(handler,modulePulse,controllerPulse)
|
||||
|
||||
# Finishing initialising the controller (Should be done in a thread to avoid locking)
|
||||
controllerPulse.addFeedbackInterface(IOInterface)
|
||||
controllerPulse.connectionSequence()
|
||||
#controllerPulse.keepPinging()
|
||||
|
||||
|
||||
def pagepress(trigger,val,note,*params):
|
||||
"A key was pressed on the pagebuttons area"
|
||||
try:
|
||||
# print(handler._noteToPos[note])
|
||||
handler.noteReceived(note,val)
|
||||
>>>>>>> 24c2b19a5859b51b3f1036f08524b130635161c1
|
||||
except TypeError as e:
|
||||
eprint("[Error] : Unassigned pagebutton {} - Note {:2} ({:3})".format(trigger,note,val))
|
||||
eprint(e)
|
||||
|
||||
@doublepress
|
||||
def quitpress(trigger,val,note,*params):
|
||||
# handler.
|
||||
print("Quitting...")
|
||||
sys.exit()
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,73 @@
|
|||
#!/bin/python
|
||||
|
||||
from threading import Timer
|
||||
|
||||
################
|
||||
# Print Functions
|
||||
|
||||
##############
|
||||
#Classes
|
||||
|
||||
class emptyClass(object):
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
def __call__(self,*args,**kwargs):
|
||||
return self
|
||||
|
||||
def __repr__(self,*args,**kwargs):
|
||||
return ''
|
||||
|
||||
def __getattr__(self,*args,**kwargs):
|
||||
return self
|
||||
|
||||
class emptyVars():
|
||||
def __init__(self):
|
||||
self.doublepressed_timer={}
|
||||
self.doublepressed_prot={}
|
||||
|
||||
def lightnote(self,note,val):
|
||||
"Note to light"
|
||||
print("Should light",note,val)
|
||||
################
|
||||
# Decorators
|
||||
|
||||
__DEFAULT_VARS=emptyVars()
|
||||
|
||||
def doublepress(funct,vars=__DEFAULT_VARS):#Note,color vars.lightnote(vars.BASE_NOTE_ARM_TAKE,1)
|
||||
"Offer a doublepress protection to a function"
|
||||
# print("Building doublepress protection for",funct.__name__)
|
||||
vars.doublepressed_prot[funct.__name__]=False
|
||||
vars.doublepressed_timer[funct.__name__]=_NOTIMER
|
||||
def _doubleProtected(*args,**kwargs):
|
||||
if vars.doublepressed_prot[funct.__name__]:
|
||||
# print("Launching function",funct.__name__,args,kwargs)
|
||||
vars.doublepressed_prot[funct.__name__]=False
|
||||
vars.doublepressed_timer[funct.__name__].cancel()
|
||||
funct(*args,**kwargs)
|
||||
else:
|
||||
# print("Launching the timer for",funct.__name__,args,kwargs)
|
||||
vars.doublepressed_timer[funct.__name__].cancel()
|
||||
vars.doublepressed_timer[funct.__name__]=Timer(_TIMERTAKE, deactivate(funct.__name__))
|
||||
vars.doublepressed_prot[funct.__name__]=True
|
||||
vars.doublepressed_timer[funct.__name__].start()
|
||||
return _doubleProtected
|
||||
|
||||
def deactivate(name,note=None,color=None,vars=__DEFAULT_VARS):
|
||||
"Reset the press count of a button"
|
||||
def _timedDesactivation():
|
||||
# print("Deactivating: ",name)
|
||||
vars.doublepressed_timer[name].cancel()
|
||||
vars.doublepressed_prot[name]=False
|
||||
vars.doublepressed_timer[name]=_NOTIMER
|
||||
if note!=None:
|
||||
#if color==None: color=BASECOLOR[Note]
|
||||
vars.lightnote(note,color)
|
||||
|
||||
return _timedDesactivation
|
||||
|
||||
##############
|
||||
# Definitions
|
||||
_NOTIMER=emptyClass()
|
||||
_EMPTYVARS=emptyVars()
|
||||
_TIMERTAKE=5
|
||||
Loading…
Reference in New Issue