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)
