midiRebind/mapping/midipagehandler.py

562 lines
21 KiB
Python

###########################
# IMPORTS
import mido
###########################
# FUNCTION DEFINES
_VERBOSE=4
nopeF=lambda x:None
def printl(label=""):
def _pl(*args):
print(label,*args)
return _pl
eprint=printl("[mPH:ERROR]")
dprint=nopeF
ddprint=nopeF
iprint=nopeF
wprint=nopeF
if _VERBOSE>=1:
wprint=printl("[mPH:WARNING]")
if _VERBOSE>=2:
iprint=printl("[mPH:INFO]")
if _VERBOSE>=3:
dprint=printl("[mPH:DEBUG]")
if _VERBOSE>=4:
ddprint=printl("[mPH:DDEBUG]")
###########################
# CLASS DEFINES
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 addActionIO(self,matchName,action):
"""Associate a function to a match to a message received
[externalP] -> Action -> [Handler]
"""
self._listActionsIO[matchName]=action
def addActionH(self,name,action):
"""Associate a function to match to a handler action
[Handler] -> Action -> [externalP]
"""
self._listActionsH[name]=action
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 noteReceived(self,note,val):
"""Acknoledge a control received and do the appropriate actions
[internalMidiAction] -> [Handler]
"""
self.handler.noteReceived(note,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)
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"
def __init__(self,table,pages=1):
"""The noteArray contains a list of virtual lines and the corresponding notes"""
self._posToNote=[]
self._noteToPos=[]
self._basevalues=[] # Store states given by the system or the machine
self._activebasevalues=[] # Store the values of the active page
self._changedbasevalues=[] # Store the active values, not yet updated
self._heightV=0
self._widthV=0
self._IOInterface=None
self.newListChanges()
self._listPossibleValues={None:0b0}
self.possibleStatus={}
self.__maxV=0b1
self._page=0
self._maxpages=pages
self._maxN=0
self._makeNotes(table)
###################
# 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):
"Make the note conversion tables and update everything"
self._heightV,self._widthV=len(table),len(table[0])
for i,j in self.allIndexes():
self._maxN=max(table[i][j],self._maxN)
self._noteToPos=[(None,None)]*(self._maxN+1)
self._posToNote=[[table[i][j] for j in range(self._widthV)] for i in range(self._heightV)]
for i,j in self.allIndexes():
self._noteToPos[table[i][j]]=(i,j)
def initValues(self):
"Init all tables with default values"
self._basevalues=[[[0 for i in range(self._widthV)] for j in range(self._heightV)] for k in range(self._maxpages)]
self._activebasevalues=self._basevalues[self._page]
self._changedbasevalues=[[0 for i in range(self._widthV)] for j in range(self._heightV)]
def _updateSize(self):
"Not the best way to add the table, but sometimes necessary"
self._heightV=len(self._activebasevalues)
if self._heightV:
self._widthV=len(self._activebasevalues[0])
else:
self._widthV=0
def addPossibleValues(self,values):
"Add a possible value in the dict"
if len(values)!=1:
for value in values:
self.addPossibleValues([value])
return
value=values[0]
if value in self._listPossibleValues:
wprint("Value {} is already in the dictionnaty of possible values")
return False
else:
self._listPossibleValues[value]=self.__maxV
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
def newChangedValues(self):
"Copy the values of the active values into the changeValues"
for i,j in self.allIndexes():
self._changedbasevalues[i][j]=self._activebasevalues[i][j]
####################
# Page Changes
def changePage(self,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
except KeyError as e:
eprint("Can't set active page to ({})".format(page))
print(e)
def _redrawPageChange(self,page1,page2):
"Add each different value between the two pages to the list of redraw"
if page1==page2: # Do nothing
return
for i,j in self.allIndexes():
if self._changedbasevalues[i][j]!=self._activebasevalues[i][j]:
self.addChange((i,j))
####################
# Manage attributes
def fullRedraw(self,redrawAll=False):
"Redraw every changed value"
if redrawAll: # Trigger a full redraw of everything
for i,j in self.allIndexes():
self.addChange((i,j))
return
for i,j in self.allIndexes():
if self._changedbasevalues[i][j]!=self._activebasevalues[i][j]:
self.addChange((i,j))
####################
# Modifiers methods
def statusId(self,namestatus):
"Return the id of a state"
if type(namestatus) in (list,tuple):
if len(namestatus)>=1:
return self.statusId(namestatus[0])|self.statusId(namestatus[1:])
return 0
return self._listPossibleValues[namestatus]
# 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 removeStatus(self,linecol,*liststatus):
"Remove a list of status, by name"
for status in liststatus:
self.removeStatusId(linecol,self.statusId(status))
def addStatusId(self,linecol,statusId):
"Add a status by name to a position"
self.addChange(linecol)
self._changedbasevalues[linecol[0]][linecol[1]]|=statusId
def removeStatusId(self,linecol,statusId):
"Remove a status by name to a position ONLY WORK WITH 1bit"
self.addChange(linecol)
if (self._changedbasevalues[linecol[0]][linecol[1]]&statusId):
self._changedbasevalues[linecol[0]][linecol[1]]-=statusId
def hasStatus(self,statusId):
"Check if a status is present"
if (self._changedbasevalues[linecol[0]][linecol[1]]&statusId):
return True
return False
####################
# Value Access methods
def addChange(self,linecol):
"Add a change to be acted"
self._changes.add(linecol)
def listChanges(self):
"Yield the list of position to be updated"
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.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
def getTableElt(self,table,linecol):
"Get an element from a table, either _line or _basevalues"
return table[linecol[0]][linecol[1]]
def getTableLine(self,table,line):
"Get a line from a table"
return table[line]
def getTableColumn(self,table,col):
"Get a column from a table"
return [table[i][col] for i in range(len(table))]
def setTableElt(self,table,linecol,val):
"Set an element in a table (No notifications)"
table[linecol[0]][linecol[1]]=val
def setTableLine(self,table,line,value):
"Change a line in a table (No notifications) (no copy())"
table[line]=value
def setTableColumn(self,table,col,values):
"Change a column to a specific list of values (No notifications)"
for i in range(len(values)):
table[i][col]=values[i]
####################
# Operator definitions
####################
# I/O Utilities
def allIndexes(self):
"Yield all (x,y) tuples of positions for the active table"
for i in range(self._heightV):
for j in range(self._widthV):
yield (i,j)
def __repr__(self):
"Give a small representation of the handler"
return 'midiPageHandler@{} ({})({}x{})'.format(id(self),self._page,self._heightV,self._widthV)
def prettyPrint(self,table=None):
"Give a nice print"
lineM='[{:3}] '*self._widthV
sep = "*"+'------'*(self._widthV)+"*"
if table==None:
table=self._activebasevalues
print(sep)
print(' '+self.__repr__())
print(sep)
for line in table:
if type(line[0])==int:
print(" "+lineM.format(*line))
else:
print(sep)
for elt in line:
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"
def __init__(self):
super(AkaiAPCMini,self).__init__([[i+(7-j)*8 for i in range(8)] for j in range(8)])
# Add the two control lines
self.initValues()
self._updateSize()
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("Live"),self.statusId("Selected")
self.possibleStatus={
0: self.colors["black"],
_INACTIVE: self.colors["yellow"],
_ACTIVE: self.colors["green"],
_LIVE: self.colors["red"],
_SELECTED: self.colors["black"], # Selecting empty does nothing
_INACTIVE|_SELECTED: self.colors["blinking_yellow"],
_ACTIVE|_SELECTED: self.colors["blinking_green"],
_LIVE|_SELECTED: self.colors["blinking_red"],
_ACTIVE|_LIVE: self.colors["red"],
_INACTIVE|_LIVE: self.colors["red"], # Debatable
_ACTIVE|_INACTIVE: self.colors["green"],#Just active
_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
_ACTIVE|_LIVE|_INACTIVE|_SELECTED:self.colors["blinking_red"] #Just live active selected
}
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)
for i,v in ak._listPossibleValues.items():
print("{}:{:b}".format(i,v))
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"))
ak.prettyPrint(ak._changedbasevalues)
ak.prettyPrint(ak._activebasevalues)
ak.applyChanges()
ak.prettyPrint(ak._activebasevalues)
ak.removeStatusId((2,1),ak.statusId("Active"))
ak.prettyPrint(ak._changedbasevalues)
ak.removeStatusId((2,1),ak.statusId("Selected"))
ak.prettyPrint(ak._changedbasevalues)
ak.removeStatusId((2,1),ak.statusId("Live"))
ak.prettyPrint(ak._changedbasevalues)
ak.removeStatus((5,5),"Active","Selected")
ak.prettyPrint(ak._changedbasevalues)
print(ak.statusId(("Active","Selected","Live")))
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)))