def main_func(ip, port): dispatcher = Dispatcher() dispatcher.map("/Chordata/r*", data_handler) dispatcher.set_default_handler(default_handler) server = BlockingOSCUDPServer((ip, port), dispatcher) server.serve_forever() # Blocks forever
class OSCConnector(Connector): def __init__(self, backend, host, port): super().__init__(backend) self.client = SimpleUDPClient(host, port) self._osc_server_lock = threading.Lock() dispatcher = Dispatcher() dispatcher.map("/track/*/volume/str", self.osc_volume_handler) dispatcher.map("/track/*/mute/toggle", self.osc_mute_handler) #dispatcher.set_default_handler(self.osc_default_handler) self._osc_server = BlockingOSCUDPServer(("127.0.0.1", 8001), dispatcher) self._osc_server_thread = threading.Thread( target=self._osc_server.serve_forever) self._osc_server_thread.start() def recv(self, msg): if not isinstance(msg, AudioMessage): return if isinstance(msg, VolumeMessage): self.set_volume(msg.track, msg.volume) if isinstance(msg, MuteMessage): self.set_muted(msg.track, msg.muted) def stop(self): self._osc_server.shutdown() def send_refresh_request(self): print("Sending refresh request to REAPER...") self.client.send_message("/action", 41743) def osc_default_handler(self, address, *args): print("OSC default handler:", address, args) def osc_volume_handler(self, address, *args): #print(address, args) with self._osc_server_lock: try: track_number = int(address.split("/")[2]) self.send_to_frontend( VolumeMessage(track_number, float(args[0][:-2]))) except: pass def osc_mute_handler(self, address, *args): with self._osc_server_lock: try: track_number = int(address.split("/")[2]) self.send_to_frontend(MuteMessage(track_number, bool(args[0]))) except: pass def set_volume(self, track_number, volume): self.client.send_message(f"/track/{track_number}/volume/db", volume) def set_muted(self, track_number, muted): self.client.send_message(f"/track/{track_number}/mute", int(muted))
def __init__(self, ip: str = "127.0.0.1", port_in: int = 8081, port_out: int = 8080, recv_address: str = "/pyosc", parse_parenthesis_as_list: bool = False, discard_duplicate_arguments: bool = True, send_format: SendFormat = SendFormat.FLATTEN, osc_log_level: Optional[int] = logging.INFO): """ :param ip: :param port_in: :param port_out: :param parse_parenthesis_as_list: :param send_format: :param osc_log_level: Forward log messages to Max. Will not forward if set to None. To forward only some messages, override _handle_max_osc_error, _handle_type_error or _handle_error """ super(MaxOsc, self).__init__(parse_parenthesis_as_list, discard_duplicate_arguments) self.logger = logging.getLogger(__name__) self.sender: Sender = Sender(ip, port_out, send_format) if osc_log_level: handler: OscLogHandler = OscLogHandler(self.sender, osc_log_level) self.logger.addHandler(handler) dispatcher = Dispatcher() dispatcher.map(recv_address, self.main_callback) dispatcher.set_default_handler(self._default_handler) self._server = BlockingOSCUDPServer((ip, port_in), dispatcher) self.logger.info( f"MaxOsc initialized on ip {ip} with incoming port {port_in} and outgoing port {port_out}." )
def __init__(self, ip, receive_from_port, quit_event, address_list=["/clock*"], address_handler_list=[None]): """ Constructor for OSC_SENDER CLASS :param ip: ip address of client ==> 127.0.0.1 (for local host/ inter app communication on same machine) :param receive_from_port: the port on which python listens for incoming data """ super(OscReceiver, self).__init__() self.setDaemon( True) # don't forget this line, otherwise, the thread never ends self.ip = ip self.receiving_from_port = receive_from_port self.listening_thread = None self.dispatcher = Dispatcher() for ix, address in enumerate(address_list): self.dispatcher.map(address, address_handler_list[ix]) self.dispatcher.set_default_handler(self.default_handler) self.server = BlockingOSCUDPServer((self.ip, self.receiving_from_port), self.dispatcher) #self.server.request_queue_size = 0 self.quit_event = quit_event
def start(self): """ start serving for UDP OSC packages """ print(f"starting tuio-client at port {self.server_address[1]}") BlockingOSCUDPServer.__init__(self, self.server_address, self) self.serve_forever()
class OscReceiver(threading.Thread): def __init__(self, ip, receive_from_port, quit_event, address_list=["/clock*"], address_handler_list=[None]): """ Constructor for OSC_SENDER CLASS :param ip: ip address of client ==> 127.0.0.1 (for local host/ inter app communication on same machine) :param receive_from_port: the port on which python listens for incoming data """ super(OscReceiver, self).__init__() self.setDaemon( True) # don't forget this line, otherwise, the thread never ends self.ip = ip self.receiving_from_port = receive_from_port self.listening_thread = None self.dispatcher = Dispatcher() for ix, address in enumerate(address_list): self.dispatcher.map(address, address_handler_list[ix]) self.dispatcher.set_default_handler(self.default_handler) self.server = BlockingOSCUDPServer((self.ip, self.receiving_from_port), self.dispatcher) #self.server.request_queue_size = 0 self.quit_event = quit_event def run(self): print("running --- waiting for data") count = 0 while not self.quit_event.is_set(): self.server.handle_request() #count = (count+1) #% 8 #print("count {}".format(count)) def default_handler(self, address, *args): # handler for osc messages with no specific defined decoder/handler print(f"DEFAULT {address}: {args}") def get_ip(self): return self.ip def get_receiving_from_port(self): return self.receiving_from_port def get_server(self): return self.server def change_ip_port(self, ip, port): self.ip = ip self.receiving_from_port = port self.server = BlockingOSCUDPServer(self.ip, self.receiving_from_port)
def __init__(self, address=("127.0.0.1", 9000), listen_port=9001): self.beat_callback = None self.startup_callback = None self.listen_port = listen_port #------------------------------------------------------------------------ # Handler callbacks for particular messages from Live. # Used so that other processes can register callbacks when states change. #------------------------------------------------------------------------ self.handlers = {} self.osc_address = address self.osc_client = SimpleUDPClient(address[0], address[1]) dispatcher = Dispatcher() dispatcher.set_default_handler(self.handler) self.osc_server = BlockingOSCUDPServer(("127.0.0.1", listen_port), dispatcher) self.osc_server_thread = None self.osc_read_event = None self.osc_timeout = 3.0 self.osc_server_events = {} self.query_address = None self.query_rv = [] self.listen()
def main(): dispatcher = i2c_osc_dispatcher.I2COscDispatcher(devices) port = 6449 logger.setLevel(logging.INFO) server = BlockingOSCUDPServer(("0.0.0.0", port), dispatcher) server.serve_forever() # Blocks forever
def __init__(self, port): print(f'Setting up Receiver with port: {port}') self.dispatcher = Dispatcher() self.server = BlockingOSCUDPServer(('127.0.0.1', port), self.dispatcher) self.dispatcher.set_default_handler(self.handleMessage) self.thread = Thread(target=self.run) self.thread.start()
def connecta_osc(self): self.disp = Dispatcher() self.disp.map(OSC_TIME_ROUTES[0], self.getTimeFromOscPlayer1) self.disp.map(OSC_TIME_ROUTES[1], self.getTimeFromOscPlayer2) self.disp.map(OSC_FILE_NAMES[0], self.getFileFromOscPlayer1) self.disp.map(OSC_FILE_NAMES[1], self.getFileFromOscPlayer2) self.disp.map(OSC_LAYER_PAUSED[0], self.getPauseFromOscPlayer1) self.disp.map(OSC_LAYER_PAUSED[1], self.getPauseFromOscPlayer2) self.srv = BlockingOSCUDPServer( (self.ip, self.port), self.disp)
def main_func(): ip = "localhost" port = 6565 dispatcher = Dispatcher() dispatcher.set_default_handler(default_handler) server = BlockingOSCUDPServer((ip, port), dispatcher) server.serve_forever()
class Osc_Interface(Thread): """ Class used to creat an OSC client to send message to an external synthesiser listening to OSC messages """ def __init__(self, client_host='127.0.0.1', client_port=57120, server_host='127.0.0.1', server_port=57130): """ Class constructor :param host: URL used to reach OSC listener :param port: port used to reach OSC listener """ # Initiate OSC client self._osc_client = udp_client.SimpleUDPClient(client_host, client_port) # Register a default dispatcher self._dispatcher = Dispatcher() self._dispatcher.set_default_handler(self._print_message) self._server_host = server_host self._server_port = server_port # Initiate OSC server self.start_server() def _print_message(address, *args): print(f"DEFAULT {address}: {args}") def start_server(self): self._running = True Thread.__init__(self) def run(self): self._server = BlockingOSCUDPServer( (self._server_host, self._server_port), self._dispatcher) self._server.serve_forever() def stop(self): self._running = False self._server.shutdown() def is_running(self): return self._running def add_handler(self, trigger, handler): self._dispatcher.map('/' + trigger, handler) def send(self, osc_handler, msg): """ Send an OSC message to a synthesiser listening to OSC messages :param url: used to trigger right instrument on synthesiser - most of the time this is instrument's name :param notes: an array containing notes to play in midi note format """ self._osc_client.send_message('/' + osc_handler, msg)
def osc_server(): dispatcher = Dispatcher() dispatcher.map("/lightstick/preset", preset_handler) dispatcher.set_default_handler(default_handler) ip = "0.0.0.0" port = 5000 server = BlockingOSCUDPServer((ip, port), dispatcher) server.serve_forever()
def main_func(): dispatcher = Dispatcher() dispatcher.map("/%/*", data_handler) dispatcher.set_default_handler(default_handler) ip = "localhost" port = 6565 server = BlockingOSCUDPServer((ip, port), dispatcher) server.serve_forever() # Blocks forever
def __init__(self, addresses=[], ip='127.0.0.1', port=5005): self._server = None self._data = {} self._lock = Lock() if not addresses or not isinstance(addresses, list): raise ValueError('You must provide a list of addresses.') dispatcher = Dispatcher() for address in addresses: self._data[self._address_to_port(address)] = {'timestamps': [], 'rows': []} dispatcher.map(address, self._handler) self._server = BlockingOSCUDPServer((ip, port), dispatcher) Thread(target=self._server.serve_forever).start()
def __init__(self, backend, host, port): super().__init__(backend) self.client = SimpleUDPClient(host, port) self._osc_server_lock = threading.Lock() dispatcher = Dispatcher() dispatcher.map("/track/*/volume/str", self.osc_volume_handler) dispatcher.map("/track/*/mute/toggle", self.osc_mute_handler) #dispatcher.set_default_handler(self.osc_default_handler) self._osc_server = BlockingOSCUDPServer(("127.0.0.1", 8001), dispatcher) self._osc_server_thread = threading.Thread( target=self._osc_server.serve_forever) self._osc_server_thread.start()
def main_func(): global client client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client.connect(('localhost', 30001)) dispatcher = Dispatcher() dispatcher.map("/%%/*", address_handler) dispatcher.map("/%/*", data_handler) dispatcher.set_default_handler(default_handler) ip = "localhost" port = 6565 server = BlockingOSCUDPServer((ip, port), dispatcher) server.serve_forever() # Blocks forever
class MessageReceiver: def __init__(self, port): print(f'Setting up Receiver with port: {port}') self.dispatcher = Dispatcher() self.server = BlockingOSCUDPServer(('127.0.0.1', port), self.dispatcher) self.dispatcher.set_default_handler(self.handleMessage) self.thread = Thread(target=self.run) self.thread.start() def run(self): self.server.serve_forever() print('done with receiver thread') def handleMessage(self, adress, *args): print(f'handler: {adress}: {args}')
class Oscin: def __init__(self, _ip, _port): self.ip, self.port = _ip, _port self.currentTimePlayer1, self.totalTimePlayer1 = 0.0, 0.0 self.currentTimePlayer2, self.totalTimePlayer2 = 0.0, 0.0 self.filePlayer1, self.filePlayer2 = 'no-media', 'no-media' self.pausedPlayer1, self.pausedPlayer2 = False, False def connecta_osc(self): self.disp = Dispatcher() self.disp.map(OSC_TIME_ROUTES[0], self.getTimeFromOscPlayer1) self.disp.map(OSC_TIME_ROUTES[1], self.getTimeFromOscPlayer2) self.disp.map(OSC_FILE_NAMES[0], self.getFileFromOscPlayer1) self.disp.map(OSC_FILE_NAMES[1], self.getFileFromOscPlayer2) self.disp.map(OSC_LAYER_PAUSED[0], self.getPauseFromOscPlayer1) self.disp.map(OSC_LAYER_PAUSED[1], self.getPauseFromOscPlayer2) self.srv = BlockingOSCUDPServer( (self.ip, self.port), self.disp) def inicia_osc(self): self.srv.serve_forever() def getTimeFromOscPlayer1(self, addr, currPlayer1, totalPlayer1): self.currentTimePlayer1 = currPlayer1 self.totalTimePlayer1 = totalPlayer1 #print('PLAYER 1 Completat: {0:.0%}'.format( self.currentTimePlayer1/self.totalTimePlayer1 )) def getTimeFromOscPlayer2(self, addr, currPlayer2, totalPlayer2): self.currentTimePlayer2 = currPlayer2 self.totalTimePlayer2 = totalPlayer2 #print('PLAYER 2 Completat: {0:.0%}'.format( self.currentTimePlayer2/self.totalTimePlayer2 )) def getFileFromOscPlayer1(self, addr, path): #print('getFileFromOscPlayer1 path: ' + path) self.filePlayer1 = path def getFileFromOscPlayer2(self, addr, path): #print('getFileFromOscPlayer2 path: ' + path) self.filePlayer2 = path def getPauseFromOscPlayer1(self, addr, paused): #print('Player 1 paused? ' + str(paused)) self.pausedPlayer1 = paused def getPauseFromOscPlayer2(self, addr, paused): #print('Player 2 paused? ' + str(paused)) self.pausedPlayer2 = paused
def run(self) -> None: """ raises: OSError is server already is in use """ osc_dispatcher: Dispatcher = Dispatcher() osc_dispatcher.map(self.SERVER_ADDRESS, self.__process_osc) osc_dispatcher.set_default_handler(self.__unmatched_osc) self._server: BlockingOSCUDPServer = BlockingOSCUDPServer( (Server.DEFAULT_IP, self._inport), osc_dispatcher) self._server.serve_forever()
def thread_osc(threadname, _queue): print("Start:" + threadname) from pythonosc.dispatcher import Dispatcher from pythonosc.osc_server import BlockingOSCUDPServer def handler(address, *args): if not _queue.empty(): _queue.get() _queue.put(args) #def default_handler(address, *args): # print(f"DEFAULT {address}: {args}") dispatcher = Dispatcher() #dispatcher.map("/faciallandmarks/eyebrows", eyebrown_handler) dispatcher.map("/landmarks", handler) #dispatcher.set_default_handler(default_handler) server = BlockingOSCUDPServer(("192.168.178.52", 9000), dispatcher) server.serve_forever() # Blocks forever
class Server(Node): """A simple OSC server.""" def __init__(self, addresses=[], ip="127.0.0.1", port=5005): self._server = None self._data = {} self._lock = Lock() if not addresses or not isinstance(addresses, list): raise ValueError("You must provide a list of addresses.") dispatcher = Dispatcher() for address in addresses: self._data[self._address_to_port(address)] = { "timestamps": [], "rows": [] } dispatcher.map(address, self._handler) self._server = BlockingOSCUDPServer((ip, port), dispatcher) Thread(target=self._server.serve_forever).start() def update(self): with self._lock: for port, data in self._data.items(): if data["rows"]: getattr(self, port).set(data["rows"], data["timestamps"]) self._data[port] = {"timestamps": [], "rows": []} def terminate(self): if self._server: self._server.shutdown() def _handler(self, address, *args): time = now() port = self._address_to_port(address) values = list(args) with self._lock: self._data[port]["rows"].append(values) self._data[port]["timestamps"].append(time) def _address_to_port(self, address): address = "/" + address if not address.startswith("/") else address return "o" + address.replace("/", "_")
class OscServer: def __init__(self, ip_adress="127.0.0.1", port=4321): self.ip_adress = ip_adress self.port = port self.dispatcher = Dispatcher() self.server = None def register_default_handler(self, handler_function: FunctionType): self.dispatcher.set_default_handler(handler_function) def register_handler(self, route: str, handler_function: FunctionType): self.dispatcher.map(route, handler_function) def terminate(self): self.server.shutdown() def serve(self): print(f"Listening for OSC messages on {self.ip_adress}:{self.port}") self.server = BlockingOSCUDPServer((self.ip_adress, self.port), self.dispatcher) self.server.serve_forever()
def __init__(self, ip, port): self.lines = [""]*Orac.MAX_LINES self.selectedLine = 0 self.params = [{"name": "", "value": "", "ctrl": 0.0} for _ in range(Orac.MAX_PARAMS)] self.oscDispatcher = Dispatcher() self.oscDispatcher.map("/text", self.textHandler) self.oscDispatcher.map("/selectText", self.selectTextHandler) self.oscDispatcher.map("/clearText", self.clearTextHandler) self.oscDispatcher.map("/P*Desc", self.paramDescHandler) self.oscDispatcher.map("/P*Ctrl", self.paramCtrlHandler) self.oscDispatcher.map("/P*Value", self.paramValueHandler) self.oscDispatcher.map("/module", self.moduleHandler) self.oscDispatcher.map("/*", self.allOtherHandler) self.server = BlockingOSCUDPServer(('', args.listen), self.oscDispatcher) self.client = udp_client.SimpleUDPClient(args.ip, args.port) self.client.send_message("/Connect", args.listen) self.linesClearedCallbacks = [] self.lineChangedCallbacks = [] self.paramNameChangedCallbacks = [] self.paramValueChangedCallbacks = [] self.paramCtrlChangedCallbacks = [] self.lineChangedNotificationsEnabled = True self.screenTimer = None self.linesSnapshot = None self.paramNotificationsEnabled = True self.paramTimer = None self.paramsSnapshot = None self.changingModule = False
import time from pythonosc.udp_client import SimpleUDPClient from pythonosc.dispatcher import Dispatcher from pythonosc.osc_server import BlockingOSCUDPServer client = SimpleUDPClient("127.0.0.1", 12000) def in_bang(address, *args): time.sleep(1) client.send_message("/output", "bang") dispatcher = Dispatcher() dispatcher.map("/input", in_bang) server = BlockingOSCUDPServer(("127.0.0.1", 6448), dispatcher) server.serve_forever()
def change_ip_port(self, ip, port): self.ip = ip self.receiving_from_port = port self.server = BlockingOSCUDPServer(self.ip, self.receiving_from_port)
for arg in args: newargs = newargs + str(arg) if arg != args[-1] and arg != None: newargs = '/' + newargs + '/' break elif arg == None: newargs = None new_message = prefix + str(message) + str(newargs) client.send_message(new_message, '0') print('Sent: ', new_message) # get osc config rxip = input("Enter the RX IP Address: ") rxport = input("Enter the RX Port: ") txip = input("Enter the TX IP Address: ") txport = input("Enter the TX Port: ") rxlisten = input( "Enter the message to listen for (* is wildcard, ex: /eos/out/get*): ") prefix = input("Enter the new message prefix (ex: /reRouter): ") # OSC Setup dispatcher = Dispatcher() dispatcher.map(rxlisten, remap) # create client client = SimpleUDPClient(txip, int(txport)) # create server server = BlockingOSCUDPServer((rxip, int(rxport)), dispatcher) server.serve_forever()
def set_filter(address: str, *args: List[Any]) -> None: # We expect two float arguments if not len(args) == 2 or type(args[0]) is not float or type(args[1]) is not float: return # Check that address starts with filter if not address[:-1] == "/filter": # Cut off the last character return value1 = args[0] value2 = args[1] filterno = address[-1] print(f"Setting filter {filterno} values: {value1}, {value2}") dispatcher.map("/filter*", set_filter) # Map wildcard address to set_filter function # Set up server and client for testing from pythonosc.osc_server import BlockingOSCUDPServer from pythonosc.udp_client import SimpleUDPClient server = BlockingOSCUDPServer(("127.0.0.1", 1337), dispatcher) client = SimpleUDPClient("127.0.0.1", 1337) # Send message and receive exactly one message (blocking) client.send_message("/filter1", [1., 2.]) server.handle_request() client.send_message("/filter8", [6., -2.]) server.handle_request()
if not len(args) == 2 or type(args[0]) is not float or type( args[1]) is not float: return # Check that address starts with filter if not address[:-1] == "/filter": # Cut off the last character return value1 = args[0] value2 = args[1] filterno = address[-1] print(f"Setting filter {filterno} values: {value1}, {value2}") dispatcher.map("/filter*", set_filter) # Map wildcard address to set_filter function # Set up server and client for testing from pythonosc.osc_server import BlockingOSCUDPServer from pythonosc.udp_client import SimpleUDPClient server = BlockingOSCUDPServer(("127.0.0.1", 1337), dispatcher) client = SimpleUDPClient("127.0.0.1", 1337) # Send message and receive exactly one message (blocking) client.send_message("/filter1", [1., 2.]) server.handle_request() client.send_message("/filter8", [6., -2.]) server.handle_request()
plugin = int( input( "Which plugin will receive OSC? \n 1) IEM SceneRotator \n 2) Envelop \nType number:" )) client = SimpleUDPClient(ip_out, port_out) # Create client if plugin == 1: plu = 'IEM SceneRotator' print(f"Sending to {ip_out}:{port_out} to {plu}, use CTRL+C to stop") def default_handler(address, *argv): client.send_message("/SceneRotator/ypr", [-argv[1], -argv[0], argv[2]]) elif plugin == 2: plu = 'Envelop' print(f"Sending to {ip_out}:{port_out} to {plu}, use CTRL+C to stop") def default_handler(address, *argv): client.send_message("/E4 HOA Transform/yaw", (-((argv[1] + 180) / 360)) + 1) client.send_message("/E4 HOA Transform/pitch", (-((argv[0] + 180) / 360)) + 1) client.send_message("/E4 HOA Transform/roll", (argv[2] + 180) / 360) dispatcher = Dispatcher() dispatcher.map("/nxosc/xyz", default_handler) server = BlockingOSCUDPServer((ip_in, port_in), dispatcher) server.serve_forever() # Blocks forever
class Orac: MAX_LINES = 5 MAX_PARAMS = 8 def __init__(self, ip, port): self.lines = [""]*Orac.MAX_LINES self.selectedLine = 0 self.params = [{"name": "", "value": "", "ctrl": 0.0} for _ in range(Orac.MAX_PARAMS)] self.oscDispatcher = Dispatcher() self.oscDispatcher.map("/text", self.textHandler) self.oscDispatcher.map("/selectText", self.selectTextHandler) self.oscDispatcher.map("/clearText", self.clearTextHandler) self.oscDispatcher.map("/P*Desc", self.paramDescHandler) self.oscDispatcher.map("/P*Ctrl", self.paramCtrlHandler) self.oscDispatcher.map("/P*Value", self.paramValueHandler) self.oscDispatcher.map("/module", self.moduleHandler) self.oscDispatcher.map("/*", self.allOtherHandler) self.server = BlockingOSCUDPServer(('', args.listen), self.oscDispatcher) self.client = udp_client.SimpleUDPClient(args.ip, args.port) self.client.send_message("/Connect", args.listen) self.linesClearedCallbacks = [] self.lineChangedCallbacks = [] self.paramNameChangedCallbacks = [] self.paramValueChangedCallbacks = [] self.paramCtrlChangedCallbacks = [] self.lineChangedNotificationsEnabled = True self.screenTimer = None self.linesSnapshot = None self.paramNotificationsEnabled = True self.paramTimer = None self.paramsSnapshot = None self.changingModule = False def navigationActivate(self): self.client.send_message("/NavActivate", 1.0) def navigationNext(self): self.client.send_message("/NavNext", 1.0) def navigationPrevious(self): self.client.send_message("/NavPrev", 1.0) # reallyClear is set to True when switching modules. # It is set to False when changing pages. We can't know how many pages there are, # therefore we try to change a page, if we don't receive any param info, we assume the # page didn't change, as it's either the first or the last one, so we keep the values # we had before. def clearParams(self, reallyClear): self.paramNotificationsEnabled = False if self.paramTimer != None: self.paramTimer.cancel() else: self.paramsSnapshot = self.params.copy() self.paramTimer = Timer(0.2, self.handleParamUpdate, args=(reallyClear,)) self.paramTimer.start() self.params = [{"name": "", "value": "", "ctrl": 0.0} for _ in range(Orac.MAX_PARAMS)] def handleParamUpdate(self, reallyClear): if self.params == [{"name": "", "value": "", "ctrl": 0.0} for _ in range(Orac.MAX_PARAMS)]: if not reallyClear: self.params = self.paramsSnapshot else: for i in range(Orac.MAX_PARAMS): self.notifyParamNameChanged(i, "") self.notifyParamValueChanged(i, "") self.notifyParamCtrlChanged(i, None) else: for i in range(Orac.MAX_PARAMS): if self.paramsSnapshot[i]["name"] != self.params[i]["name"]: self.notifyParamNameChanged(i, self.params[i]["name"]) if self.paramsSnapshot[i]["value"] != self.params[i]["value"]: self.notifyParamValueChanged(i, self.params[i]["value"]) self.notifyParamCtrlChanged(i, self.params[i]["ctrl"] if self.params[i]["name"] or self.params[i]["value"] else None) self.paramNotificationsEnabled = True self.paramTimer = None self.paramsSnapshot = None def moduleNext(self): self.changingModule = True self.client.send_message("/ModuleNext", 1.0) def modulePrevious(self): self.changingModule = True self.client.send_message("/ModulePrev", 1.0) def pageNext(self): self.clearParams(False) self.client.send_message("/PageNext", 1.0) def pagePrevious(self): self.clearParams(False) self.client.send_message("/PagePrev", 1.0) def paramSet(self, param, value): value = max(min(value, 1.0), 0.0) self.client.send_message("/P%dCtrl" % (param+1), value) if self.paramNotificationsEnabled: self.notifyParamCtrlChanged(param, value) def addLinesClearedCallback(self, cb): self.linesClearedCallbacks.append(cb) def addLineChangedCallback(self, cb): self.lineChangedCallbacks.append(cb) def addParamNameChangedCallback(self, cb): self.paramNameChangedCallbacks.append(cb) def addParamValueChangedCallback(self, cb): self.paramValueChangedCallbacks.append(cb) def addParamCtrlChangedCallback(self, cb): self.paramCtrlChangedCallbacks.append(cb) def notifyLinesCleared(self): for cb in self.linesClearedCallbacks: cb(self) def notifyLineChanged(self, line, text, selected): for cb in self.lineChangedCallbacks: cb(self, line, text, selected) def notifyParamNameChanged(self, i, name): for cb in self.paramNameChangedCallbacks: cb(self, i, name) def notifyParamValueChanged(self, i, value): for cb in self.paramValueChangedCallbacks: cb(self, i, value) def notifyParamCtrlChanged(self, i, ctrl): for cb in self.paramCtrlChangedCallbacks: cb(self, i, ctrl) def run(self): self.server.serve_forever(0.1) def textHandler(self, address, *osc_arguments): i = osc_arguments[0]-1 if self.lines[i] != osc_arguments[1]: self.lines[i] = osc_arguments[1] if self.lineChangedNotificationsEnabled: self.notifyLineChanged(i, self.lines[i], self.selectedLine == i) def selectTextHandler(self, address, *osc_arguments): i = osc_arguments[0]-1 if self.selectedLine != i: if self.lineChangedNotificationsEnabled: self.notifyLineChanged(self.selectedLine, self.lines[self.selectedLine], False) self.selectedLine = i if self.lineChangedNotificationsEnabled: self.notifyLineChanged(i, self.lines[i], True) def handleScreenUpdate(self): if self.lines == [""]*Orac.MAX_LINES: self.notifyLinesCleared() else: for i in range(Orac.MAX_LINES): if self.linesSnapshot[i] != self.lines[i]: self.notifyLineChanged(i, self.lines[i], i == self.selectedLine) self.lineChangedNotificationsEnabled = True self.screenTimer = None def clearTextHandler(self, address, *osc_arguments): if self.changingModule: self.clearParams(True) self.lineChangedNotificationsEnabled = False if self.screenTimer != None: self.screenTimer.cancel() else: self.linesSnapshot = self.lines.copy() self.screenTimer = Timer(0.2, self.handleScreenUpdate) self.screenTimer.start() self.lines = [""]*Orac.MAX_LINES @staticmethod def decodeParamId(oscAddress): return ord(oscAddress[2]) - ord('1') def paramDescHandler(self, address, *osc_arguments): i = Orac.decodeParamId(address) if self.params[i]["name"] != osc_arguments[0]: self.params[i]["name"] = osc_arguments[0] if self.paramNotificationsEnabled: self.notifyParamNameChanged(i, osc_arguments[0]) def paramValueHandler(self, address, *osc_arguments): i = Orac.decodeParamId(address) if self.params[i]["value"] != osc_arguments[0]: self.params[i]["value"] = osc_arguments[0] if self.paramNotificationsEnabled: self.notifyParamValueChanged(i, osc_arguments[0]) def moduleHandler(self, address, *osc_arguments): self.changingModule = False def paramCtrlHandler(self, address, *osc_arguments): i = Orac.decodeParamId(address) if self.params[i]["ctrl"] != osc_arguments[0]: self.params[i]["ctrl"] = osc_arguments[0] if self.paramNotificationsEnabled: self.notifyParamCtrlChanged(i, osc_arguments[0]) def allOtherHandler(self, address, *osc_arguments): print(address, osc_arguments)