adding router program

Author: dctucker

router.py

@@ -1,11 +1,88 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+
 import sys
 import rtmidi
+import signal
+import locale
+locale.setlocale(locale.LC_ALL, '')
+import curses
+
+#from matrix import View
+
+class View:
+	def __init__(self, screen, model):
+		self.screen = screen
+		self.cursor = [0,0]
+		self.model = model
+
+	def input_left(self):
+		return 1 + len(self.model.inputs) * 2
+
+	def output_top(self):
+		return 1 + len(self.model.inputs)
+
+	def draw(self):
+		model = self.model
+		s = self.screen
+		y = 0
+		x = self.input_left() - 1
+		for i in model.inputs:
+			s.move(y, x)
+			s.addch(curses.ACS_HLINE)
+			s.addstr(y, x + 1, i)
+			y += 1
+		max_y = y
+		y += len(model.outputs)
+		#y = 1
+		x = 0
+		for o in model.outputs:
+			s.addstr(y, x, o)
+			y -= 1
+			x += 2
+		
+		y = self.output_top() - 1
+		for x in range(len(model.outputs)):
+			s.move(y, x * 2)
+			s.vline(curses.ACS_VLINE, len(model.outputs) - x)
+
+		for y in range(len(model.inputs)):
+			for x in range(len(model.outputs)):
+				s.move(y, x * 2)
+				s.addch(curses.ACS_PLUS)
+				s.addch(curses.ACS_HLINE)
+
+		for p1, p2 in model.connections:
+			y = model.get_index_in(p1)
+			x = model.get_index_out(p2) * 2
+			s.move(y,x)
+			s.addch(curses.ACS_DIAMOND)
+			s.addstr(y, x, "◊")
+		s.move( self.output_top() + len(model.outputs) + 2, 0)
+
+	def set_cursor(self, cursor):
+		s = self.screen
+		s.chgat( cursor[0], self.input_left(), len( self.model.inputs[cursor[0]] ), curses.A_REVERSE )
+		s.chgat( len( self.model.outputs ) - cursor[1] + self.output_top() - 1, 2*cursor[1], len( self.model.outputs[cursor[1]] ), curses.A_REVERSE )
+		self.cursor = cursor
+		self.screen.move( cursor[0], cursor[1] * 2 )
+
 
 class Devices:
+	_instance = None
 	def __init__(self):
-		self.inputs = {}
 		self.open_inputs = {}
 		self.open_outputs = {}
+		self.connections = []
+		self.load()
+
+	@classmethod
+	def instance(cls):
+		if cls._instance is None:
+			cls._instance = cls()
+		return cls._instance
+
+	def load(self):
 		self.ins()
 		self.outs()
 
@@ -48,28 +125,31 @@ def __del__(self):
 		for rt in self.open_inputs.values():
 			rt.closePort()
 
-class Device:
+class DeviceListener:
 	channels = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
-	def __init__(self):
-		self.input = devices.input(self.name)
+	def __init__(self, name):
+		self.name = name
+		self.input = Devices.instance().input(self.name)
 		self.input.setCallback( self )
-		self.output = devices.output(self.name)
+		self.output = Devices.instance().output(self.name)
 		self.subs = []
 
 	def __call__(self, message):
 		data = message.getRawData()
 		print '\033[2K', 
-		print ' '.join([hex(ord(d))[2:] for d in data]), "\r",
-		sys.stdout.flush()
+		print ' '.join([hex(ord(d))[2:] for d in data]),
 		self.forward(message)
+		print "\r",
+		sys.stdout.flush()
 
 	def forward(self, message):
-		ch = message.getChannel()
 		for sub in self.subs:
-			if ch in sub.channels:
-				sub.send(message)
+			if sub.filter(message):
+				sub.output.send(message)
 
 	def send(self, message):
+		data = message.getRawData()
+		print self.name,
 		self.output.sendMessage(message)
 
 	def send_unison(self, message, channel):
@@ -78,77 +158,80 @@ def send_unison(self, message, channel):
 		self.output.sendMessage(msg)
 
 	def subscribe(self, other):
-		self.subs.append(other)
-
-	def __rshift__(self, others):
-		for other in others:
-			self.subscribe(other)
-
-class Deluge(Device):
-	name = 'Deluge'
-
-class BCR(Device):
-	name = 'BCR2000'
-
-class JUNO(Device):
-	name = 'JUNO-DS'
-	channels = [4,5,6,7,9,11]
-
-class Circuit(Device):
-	name = 'Circuit'
-	channels = [0,1,2,10]
-
-class Phatty(Device):
-	name = 'Little Phatty SE II'
-	channels = [3]
-	#def send(self, message):
-	#	self.send_unison(message, 3)
-
-devices = Devices()
-deluge = Deluge()
-bcr = BCR()
-juno = JUNO()
-phatty = Phatty()
-circuit = Circuit()
-
-deluge >> juno, circuit, phatty
-bcr    >> phatty,
-juno   >> deluge, circuit, phatty
-
-
-"""
-matrix = (
-	(deluge, (juno, circuit, phatty)),
-	(bcr, (phatty,)),
-	(juno, (deluge, circuit, phatty)),
-)
-
-for device, others in matrix:
-	for other in others:
-		device.subscribe(other)
-"""
-
-"""
-deluge.subscribe(juno)
-deluge.subscribe(circuit)
-deluge.subscribe(phatty)
-
-bcr.subscribe(phatty)
-
-juno.subscribe(deluge)
-juno.subscribe(phatty)
-juno.subscribe(circuit)
-"""
-
-
-
-
-
-#while True:
-#	message = device.getMessage(100)
-#	call(message)
-
-
-print 'HIT ENTER TO EXIT'
-sys.stdin.read(1)
-
+		if other not in self.subs:
+			self.subs.append(other)
+
+class Connection:
+	def __init__(self, i, o):
+		self.input = i
+		self.output = o
+		self.filter = lambda x: True
+		
+	def connect(self):
+		devs = Devices.instance()
+		self.input.subscribe(self)
+
+	def __eq__(self, other):
+		return self.input.name == other.input.name and self.output.name == other.output.name
+
+class Router:
+	def __init__(self):
+		self.connections = []
+		self.listeners = {}
+
+	def connect(self, i, o, filt=lambda x: True):
+		if i not in self.listeners:
+			self.listeners[i] = DeviceListener(i)
+		if o not in self.listeners:
+			self.listeners[o] = DeviceListener(o)
+
+		i = self.listeners[i]
+		o = self.listeners[o]
+
+		new_connection = Connection(i,o)
+		new_connection.filter = filt
+		new_connection.connect()
+		for connection in self.connections:
+			if connection == new_connection:
+				self.connections.remove(connection)
+		self.connections.append(new_connection)
+
+def main(stdscr):
+	def channel_filter(channels):
+		return lambda x: x.getChannel() in channels
+
+	devices = Devices.instance()
+	devices.load()
+	router = Router()
+	router.connect("Deluge", "Little Phatty SE II", channel_filter((3,)))
+	router.connect("Deluge", "Circuit", channel_filter((0,1,2,10,)))
+	router.connect("Deluge", "JUNO-DS", channel_filter((4,5,6,7,9,11,)))
+	router.connect("JUNO-DS", "Circuit", channel_filter((1,2,10,)))
+	router.connect("JUNO-DS", "Deluge", channel_filter((8,)))
+	router.connect("JUNO-DS", "Little Phatty SE II", channel_filter((3,)))
+	router.connect("BCR2000", "Little Phatty SE II", channel_filter((3,)))
+
+	def hup(signum, frame):
+		devices.load()
+	signal.signal(signal.SIGHUP, hup)
+
+	#while True: #debug
+	#	message = device.getMessage(100)
+	#	call(message)
+
+	#ctrl = Controller(devices)
+	view = View(stdscr, devices)
+
+	while True:
+		view.draw()
+		#view.set_cursor(ctrl.cursor)
+		key = stdscr.getch()
+		if key == ord('q'):
+			break
+		elif key == ord('r'):
+			stdscr.clear()
+			
+		#ctrl.key_press(key)
+
+if __name__ == '__main__':
+	curses.wrapper(main)