#!/usr/bin/env python3 # -*- coding: utf-8 -*- # Carla Backend code # Copyright (C) 2011-2012 Filipe Coelho # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # For a full copy of the GNU General Public License see the COPYING file # Imports (Global) from PyQt4.QtGui import QApplication, QMainWindow from liblo import make_method, Address, ServerError, ServerThread from liblo import send as lo_send from liblo import TCP as LO_TCP # Imports (Custom) import ui_carla_control from carla_shared import * global lo_target, lo_targetName lo_target = None lo_targetName = "" Carla.isControl = True # Python Object dicts compatible to carla-backend struct ctypes MidiProgramData = { 'bank': 0, 'program': 0, 'label': None } ParameterData = { 'type': PARAMETER_NULL, 'index': 0, 'rindex': -1, 'hints': 0x0, 'midiChannel': 0, 'midiCC': -1 } ParameterRanges = { 'def': 0.0, 'min': 0.0, 'max': 1.0, 'step': 0.0, 'stepSmall': 0.0, 'stepLarge': 0.0 } CustomData = { 'type': CUSTOM_DATA_INVALID, 'key': None, 'value': None } PluginInfo = { 'type': PLUGIN_NONE, 'category': PLUGIN_CATEGORY_NONE, 'hints': 0x0, 'binary': None, 'name': None, 'label': None, 'maker': None, 'copyright': None, 'uniqueId': 0 } PortCountInfo = { 'ins': 0, 'outs': 0, 'total': 0 } ParameterInfo = { 'name': None, 'symbol': None, 'unit': None, 'scalePointCount': 0, } ScalePointInfo = { 'value': 0.0, 'label': None } class ControlPluginInfo(object): __slots__ = [ 'pluginInfo', 'pluginRealName', 'audioCountInfo', 'midiCountInfo', 'parameterCountInfo', 'parameterInfoS', 'parameterDataS', 'parameterRangeS', 'parameterValueS', 'programCount', 'programCurrent', 'programNameS', 'midiProgramCount', 'midiProgramCurrent', 'midiProgramDataS', 'inPeak', 'outPeak' ] # Python Object class compatible to 'Host' on the Carla Backend code class Host(object): def __init__(self): object.__init__(self) self.pluginInfo = [] for i in range(MAX_DEFAULT_PLUGINS): self.pluginInfo.append(ControlPluginInfo()) self._clear(i) def _clear(self, index): self.pluginInfo[index].pluginInfo = PluginInfo self.pluginInfo[index].pluginRealName = None self.pluginInfo[index].audioCountInfo = PortCountInfo self.pluginInfo[index].midiCountInfo = PortCountInfo self.pluginInfo[index].parameterCountInfo = PortCountInfo self.pluginInfo[index].parameterInfoS = [] self.pluginInfo[index].parameterDataS = [] self.pluginInfo[index].parameterRangeS = [] self.pluginInfo[index].parameterValueS = [] self.pluginInfo[index].programCount = 0 self.pluginInfo[index].programCurrent = -1 self.pluginInfo[index].programNameS = [] self.pluginInfo[index].midiProgramCount = 0 self.pluginInfo[index].midiProgramCurrent = -1 self.pluginInfo[index].midiProgramDataS = [] self.pluginInfo[index].inPeak = [0.0, 0.0] self.pluginInfo[index].outPeak = [0.0, 0.0] def _set_pluginInfo(self, index, info): self.pluginInfo[index].pluginInfo = info def _set_pluginRealName(self, index, realName): self.pluginInfo[index].pluginRealName = realName def _set_audioCountInfo(self, index, info): self.pluginInfo[index].audioCountInfo = info def _set_midiCountInfo(self, index, info): self.pluginInfo[index].midiCountInfo = info def _set_parameterCountInfo(self, index, info): self.pluginInfo[index].parameterCountInfo = info # clear self.pluginInfo[index].parameterInfoS = [] self.pluginInfo[index].parameterDataS = [] self.pluginInfo[index].parameterRangeS = [] self.pluginInfo[index].parameterValueS = [] # add placeholders for x in range(info['total']): self.pluginInfo[index].parameterInfoS.append(ParameterInfo) self.pluginInfo[index].parameterDataS.append(ParameterData) self.pluginInfo[index].parameterRangeS.append(ParameterRanges) self.pluginInfo[index].parameterValueS.append(0.0) def _set_programCount(self, index, count): self.pluginInfo[index].programCount = count # clear self.pluginInfo[index].programNameS = [] # add placeholders for x in range(count): self.pluginInfo[index].programNameS.append(None) def _set_midiProgramCount(self, index, count): self.pluginInfo[index].midiProgramCount = count # clear self.pluginInfo[index].midiProgramDataS = [] # add placeholders for x in range(count): self.pluginInfo[index].midiProgramDataS.append(MidiProgramData) def _set_parameterInfoS(self, index, paramIndex, data): if paramIndex < self.pluginInfo[index].parameterCountInfo['total']: self.pluginInfo[index].parameterInfoS[paramIndex] = data def _set_parameterDataS(self, index, paramIndex, data): if paramIndex < self.pluginInfo[index].parameterCountInfo['total']: self.pluginInfo[index].parameterDataS[paramIndex] = data def _set_parameterRangeS(self, index, paramIndex, data): if paramIndex < self.pluginInfo[index].parameterCountInfo['total']: self.pluginInfo[index].parameterRangeS[paramIndex] = data def _set_parameterValueS(self, index, paramIndex, value): if paramIndex < self.pluginInfo[index].parameterCountInfo['total']: self.pluginInfo[index].parameterValueS[paramIndex] = value def _set_parameterDefaultValue(self, index, paramIndex, value): if paramIndex < self.pluginInfo[index].parameterCountInfo['total']: self.pluginInfo[index].parameterRangeS[paramIndex]['def'] = value def _set_parameterMidiCC(self, index, paramIndex, cc): if paramIndex < self.pluginInfo[index].parameterCountInfo['total']: self.pluginInfo[index].parameterDataS[paramIndex]['midiCC'] = cc def _set_parameterMidiChannel(self, index, paramIndex, channel): if paramIndex < self.pluginInfo[index].parameterCountInfo['total']: self.pluginInfo[index].parameterDataS[paramIndex]['midiChannel'] = channel def _set_currentProgram(self, index, pIndex): self.pluginInfo[index].programCurrent = pIndex def _set_currentMidiProgram(self, index, mpIndex): self.pluginInfo[index].midiProgramCurrent = mpIndex def _set_programNameS(self, index, pIndex, data): if pIndex < self.pluginInfo[index].programCount: self.pluginInfo[index].programNameS[pIndex] = data def _set_midiProgramDataS(self, index, mpIndex, data): if mpIndex < self.pluginInfo[index].midiProgramCount: self.pluginInfo[index].midiProgramDataS[mpIndex] = data def _set_inPeak(self, index, port, value): self.pluginInfo[index].inPeak[port] = value def _set_outPeak(self, index, port, value): self.pluginInfo[index].outPeak[port] = value def get_plugin_info(self, plugin_id): return self.pluginInfo[plugin_id].pluginInfo def get_audio_port_count_info(self, plugin_id): return self.pluginInfo[plugin_id].audioCountInfo def get_midi_port_count_info(self, plugin_id): return self.pluginInfo[plugin_id].midiCountInfo def get_parameter_count_info(self, plugin_id): return self.pluginInfo[plugin_id].parameterCountInfo def get_parameter_info(self, plugin_id, parameter_id): return self.pluginInfo[plugin_id].parameterInfoS[parameter_id] def get_parameter_scalepoint_info(self, plugin_id, parameter_id, scalepoint_id): return ScalePointInfo def get_gui_info(self, plugin_id): return GuiInfo def get_parameter_data(self, plugin_id, parameter_id): return self.pluginInfo[plugin_id].parameterDataS[parameter_id] def get_parameter_ranges(self, plugin_id, parameter_id): return self.pluginInfo[plugin_id].parameterRangeS[parameter_id] def get_midi_program_data(self, plugin_id, midi_program_id): return self.pluginInfo[plugin_id].midiProgramDataS[midi_program_id] def get_custom_data(self, plugin_id, custom_data_id): return CustomData def get_chunk_data(self, plugin_id): return None def get_parameter_count(self, plugin_id): return self.pluginInfo[plugin_id].parameterCountInfo['total'] def get_program_count(self, plugin_id): return self.pluginInfo[plugin_id].programCount def get_midi_program_count(self, plugin_id): return self.pluginInfo[plugin_id].midiProgramCount def get_custom_data_count(self, plugin_id): return 0 def get_parameter_text(self, plugin_id, program_id): return None def get_program_name(self, plugin_id, program_id): return self.pluginInfo[plugin_id].programNameS[program_id] def get_midi_program_name(self, plugin_id, midi_program_id): return self.pluginInfo[plugin_id].midiProgramDataS[midi_program_id]['label'] def get_real_plugin_name(self, plugin_id): return self.pluginInfo[plugin_id].pluginRealName def get_current_program_index(self, plugin_id): return self.pluginInfo[plugin_id].programCurrent def get_current_midi_program_index(self, plugin_id): return self.pluginInfo[plugin_id].midiProgramCurrent def get_default_parameter_value(self, plugin_id, parameter_id): return self.pluginInfo[plugin_id].parameterRangeS[parameter_id]['def'] def get_current_parameter_value(self, plugin_id, parameter_id): return self.pluginInfo[plugin_id].parameterValueS[parameter_id] def get_input_peak_value(self, plugin_id, port_id): return self.pluginInfo[plugin_id].inPeak[port_id-1] def get_output_peak_value(self, plugin_id, port_id): return self.pluginInfo[plugin_id].outPeak[port_id-1] def set_active(self, plugin_id, onoff): global to_target, lo_targetName lo_path = "/%s/%i/set_active" % (lo_targetName, plugin_id) lo_send(lo_target, lo_path, 1 if onoff else 0) def set_drywet(self, plugin_id, value): global to_target, lo_targetName lo_path = "/%s/%i/set_drywet" % (lo_targetName, plugin_id) lo_send(lo_target, lo_path, value) def set_volume(self, plugin_id, value): global to_target, lo_targetName lo_path = "/%s/%i/set_volume" % (lo_targetName, plugin_id) lo_send(lo_target, lo_path, value) def set_balance_left(self, plugin_id, value): global to_target, lo_targetName lo_path = "/%s/%i/set_balance_left" % (lo_targetName, plugin_id) lo_send(lo_target, lo_path, value) def set_balance_right(self, plugin_id, value): global to_target, lo_targetName lo_path = "/%s/%i/set_balance_right" % (lo_targetName, plugin_id) lo_send(lo_target, lo_path, value) def set_parameter_value(self, plugin_id, parameter_id, value): global to_target, lo_targetName lo_path = "/%s/%i/set_parameter_value" % (lo_targetName, plugin_id) lo_send(lo_target, lo_path, parameter_id, value) def set_parameter_midi_channel(self, plugin_id, parameter_id, channel): global to_target, lo_targetName lo_path = "/%s/%i/set_parameter_midi_channel" % (lo_targetName, plugin_id) lo_send(lo_target, lo_path, parameter_id, channel) def set_parameter_midi_cc(self, plugin_id, parameter_id, midi_cc): global to_target, lo_targetName lo_path = "/%s/%i/set_parameter_midi_cc" % (lo_targetName, plugin_id) lo_send(lo_target, lo_path, parameter_id, midi_cc) def set_program(self, plugin_id, program_id): global to_target, lo_targetName lo_path = "/%s/%i/set_program" % (lo_targetName, plugin_id) lo_send(lo_target, lo_path, program_id) def set_midi_program(self, plugin_id, midi_program_id): global to_target, lo_targetName lo_path = "/%s/%i/set_midi_program" % (lo_targetName, plugin_id) lo_send(lo_target, lo_path, midi_program_id) def send_midi_note(self, plugin_id, channel, note, velocity): global to_target, lo_targetName if velocity: lo_path = "/%s/%i/note_on" % (lo_targetName, plugin_id) lo_send(lo_target, lo_path, channel, note, velocity) else: lo_path = "/%s/%i/note_off" % (lo_targetName, plugin_id) lo_send(lo_target, lo_path, channel, note) # OSC Control server class ControlServer(ServerThread): def __init__(self, parent): ServerThread.__init__(self, 8087, LO_TCP) self.parent = parent def getFullURL(self): return "%scarla-control" % self.get_url() @make_method('/carla-control/add_plugin_start', 'is') def add_plugin_start_callback(self, path, args): pluginId, pluginName = args self.parent.emit(SIGNAL("AddPluginStart(int, QString)"), pluginId, pluginName) @make_method('/carla-control/add_plugin_end', 'i') def add_plugin_end_callback(self, path, args): pluginId, = args self.parent.emit(SIGNAL("AddPluginEnd(int)"), pluginId) @make_method('/carla-control/remove_plugin', 'i') def remove_plugin_callback(self, path, args): pluginId, = args self.parent.emit(SIGNAL("RemovePlugin(int)"), pluginId) @make_method('/carla-control/set_plugin_data', 'iiiissssh') def set_plugin_data_callback(self, path, args): pluginId, ptype, category, hints, realName, label, maker, copyright_, uniqueId = args self.parent.emit(SIGNAL("SetPluginData(int, int, int, int, QString, QString, QString, QString, int)"), pluginId, ptype, category, hints, realName, label, maker, copyright_, uniqueId) @make_method('/carla-control/set_plugin_ports', 'iiiiiiii') def set_plugin_ports_callback(self, path, args): pluginId, audioIns, audioOuts, midiIns, midiOuts, cIns, cOuts, cTotals = args self.parent.emit(SIGNAL("SetPluginPorts(int, int, int, int, int, int, int, int)"), pluginId, audioIns, audioOuts, midiIns, midiOuts, cIns, cOuts, cTotals) @make_method('/carla-control/set_parameter_data', 'iiiissd') def set_parameter_data_callback(self, path, args): pluginId, index, type_, hints, name, label, current = args self.parent.emit(SIGNAL("SetParameterData(int, int, int, int, QString, QString, double)"), pluginId, index, type_, hints, name, label, current) @make_method('/carla-control/set_parameter_ranges', 'iidddddd') def set_parameter_ranges_callback(self, path, args): pluginId, index, min_, max_, def_, step, stepSmall, stepLarge = args self.parent.emit(SIGNAL("SetParameterRanges(int, int, double, double, double, double, double, double)"), pluginId, index, min_, max_, def_, step, stepSmall, stepLarge) @make_method('/carla-control/set_parameter_midi_cc', 'iii') def set_parameter_midi_cc_callback(self, path, args): pluginId, index, cc = args self.parent.emit(SIGNAL("SetParameterMidiCC(int, int, int)"), pluginId, index, cc) @make_method('/carla-control/set_parameter_midi_channel', 'iii') def set_parameter_midi_channel_callback(self, path, args): pluginId, index, channel = args self.parent.emit(SIGNAL("SetParameterMidiChannel(int, int, int)"), pluginId, index, channel) @make_method('/carla-control/set_parameter_value', 'iid') def set_parameter_value_callback(self, path, args): pluginId, index, value = args self.parent.emit(SIGNAL("SetParameterValue(int, int, double)"), pluginId, index, value) @make_method('/carla-control/set_default_value', 'iid') def set_default_value_callback(self, path, args): pluginId, index, value = args self.parent.emit(SIGNAL("SetDefaultValue(int, int, double)"), pluginId, index, value) @make_method('/carla-control/set_program', 'ii') def set_program_callback(self, path, args): pluginId, index = args self.parent.emit(SIGNAL("SetProgram(int, int)"), pluginId, index) @make_method('/carla-control/set_program_count', 'ii') def set_program_count_callback(self, path, args): pluginId, count = args self.parent.emit(SIGNAL("SetProgramCount(int, int)"), pluginId, count) @make_method('/carla-control/set_program_name', 'iis') def set_program_name_callback(self, path, args): pluginId, index, name = args self.parent.emit(SIGNAL("SetProgramName(int, int, QString)"), pluginId, index, name) @make_method('/carla-control/set_midi_program', 'ii') def set_midi_program_callback(self, path, args): pluginId, index = args self.parent.emit(SIGNAL("SetMidiProgram(int, int)"), pluginId, index) @make_method('/carla-control/set_midi_program_count', 'ii') def set_midi_program_count_callback(self, path, args): pluginId, count = args self.parent.emit(SIGNAL("SetMidiProgramCount(int, int)"), pluginId, count) @make_method('/carla-control/set_midi_program_data', 'iiiis') def set_midi_program_data_callback(self, path, args): pluginId, index, bank, program, name = args self.parent.emit(SIGNAL("SetMidiProgramData(int, int, int, int, QString)"), pluginId, index, bank, program, name) @make_method('/carla-control/set_input_peak_value', 'iid') def set_input_peak_value_callback(self, path, args): pluginId, portId, value = args self.parent.emit(SIGNAL("SetInputPeakValue(int, int, double)"), pluginId, portId, value) @make_method('/carla-control/set_output_peak_value', 'iid') def set_output_peak_value_callback(self, path, args): pluginId, portId, value = args self.parent.emit(SIGNAL("SetOutputPeakValue(int, int, double)"), pluginId, portId, value) @make_method('/carla-control/note_on', 'iiii') def note_on_callback(self, path, args): pluginId, channel, note, velo = args self.parent.emit(SIGNAL("NoteOn(int, int, int, int)"), pluginId, channel, note, velo) @make_method('/carla-control/note_off', 'iii') def note_off_callback(self, path, args): pluginId, channel, note = args self.parent.emit(SIGNAL("NoteOff(int, int, int)"), pluginId, channel, note) @make_method('/carla-control/exit', '') def exit_callback(self, path, args): self.parent.emit(SIGNAL("Exit()")) @make_method(None, None) def fallback(self, path, args): print("ControlServer::fallback(\"%s\") - unknown message, args =" % path, args) # Main Window class CarlaControlW(QMainWindow, ui_carla_control.Ui_CarlaControlW): def __init__(self, parent=None): QMainWindow.__init__(self, parent) self.setupUi(self) # ------------------------------------------------------------- # Load Settings self.settings = QSettings("Cadence", "Carla-Control") self.loadSettings() self.setStyleSheet(""" QWidget#centralwidget { background-color: qlineargradient(spread:pad, x1:0.0, y1:0.0, x2:0.2, y2:1.0, stop:0 rgb( 7, 7, 7), stop:1 rgb(28, 28, 28) ); } """) # ------------------------------------------------------------- # Internal stuff self.lo_address = "" self.lo_server = None self.m_lastPluginName = None self.m_plugin_list = [] for x in range(MAX_DEFAULT_PLUGINS): self.m_plugin_list.append(None) # ------------------------------------------------------------- # Set-up GUI stuff self.act_file_refresh.setEnabled(False) self.resize(self.width(), 0) # ------------------------------------------------------------- # Connect actions to functions self.connect(self.act_file_connect, SIGNAL("triggered()"), SLOT("slot_doConnect()")) self.connect(self.act_file_refresh, SIGNAL("triggered()"), SLOT("slot_doRefresh()")) self.connect(self.act_help_about, SIGNAL("triggered()"), SLOT("slot_aboutCarlaControl()")) self.connect(self.act_help_about_qt, SIGNAL("triggered()"), app, SLOT("aboutQt()")) self.connect(self, SIGNAL("AddPluginStart(int, QString)"), SLOT("slot_handleAddPluginStart(int, QString)")) self.connect(self, SIGNAL("AddPluginEnd(int)"), SLOT("slot_handleAddPluginEnd(int)")) self.connect(self, SIGNAL("RemovePlugin(int)"), SLOT("slot_handleRemovePlugin(int)")) self.connect(self, SIGNAL("SetPluginData(int, int, int, int, QString, QString, QString, QString, int)"), SLOT("slot_handleSetPluginData(int, int, int, int, QString, QString, QString, QString, int)")) self.connect(self, SIGNAL("SetPluginPorts(int, int, int, int, int, int, int, int)"), SLOT("slot_handleSetPluginPorts(int, int, int, int, int, int, int, int)")) self.connect(self, SIGNAL("SetParameterData(int, int, int, int, QString, QString, double)"), SLOT("slot_handleSetParameterData(int, int, int, int, QString, QString, double)")) self.connect(self, SIGNAL("SetParameterRanges(int, int, double, double, double, double, double, double)"), SLOT("slot_handleSetParameterRanges(int, int, double, double, double, double, double, double)")) self.connect(self, SIGNAL("SetParameterMidiCC(int, int, int)"), SLOT("slot_handleSetParameterMidiCC(int, int, int)")) self.connect(self, SIGNAL("SetParameterMidiChannel(int, int, int)"), SLOT("slot_handleSetParameterMidiChannel(int, int, int)")) self.connect(self, SIGNAL("SetParameterValue(int, int, double)"), SLOT("slot_handleSetParameterValue(int, int, double)")) self.connect(self, SIGNAL("SetDefaultValue(int, int, double)"), SLOT("slot_handleSetDefaultValue(int, int, double)")) self.connect(self, SIGNAL("SetProgram(int, int)"), SLOT("slot_handleSetProgram(int, int)")) self.connect(self, SIGNAL("SetProgramCount(int, int)"), SLOT("slot_handleSetProgramCount(int, int)")) self.connect(self, SIGNAL("SetProgramName(int, int, QString)"), SLOT("slot_handleSetProgramName(int, int, QString)")) self.connect(self, SIGNAL("SetMidiProgram(int, int)"), SLOT("slot_handleSetMidiProgram(int, int)")) self.connect(self, SIGNAL("SetMidiProgramCount(int, int)"), SLOT("slot_handleSetMidiProgramCount(int, int)")) self.connect(self, SIGNAL("SetMidiProgramData(int, int, int, int, QString)"), SLOT("slot_handleSetMidiProgramData(int, int, int, int, QString)")) self.connect(self, SIGNAL("SetInputPeakValue(int, int, double)"), SLOT("slot_handleSetInputPeakValue(int, int, double)")) self.connect(self, SIGNAL("SetOutputPeakValue(int, int, double)"), SLOT("slot_handleSetOutputPeakValue(int, int, double)")) self.connect(self, SIGNAL("NoteOn(int, int, int, int)"), SLOT("slot_handleNoteOn(int, int, int, int)")) self.connect(self, SIGNAL("NoteOff(int, int, int)"), SLOT("slot_handleNoteOff(int, int, int)")) self.connect(self, SIGNAL("Exit()"), SLOT("slot_handleExit()")) self.TIMER_GUI_STUFF = self.startTimer(50) # Peaks self.TIMER_GUI_STUFF2 = self.startTimer(50 * 2) # LEDs and edit dialog def remove_all(self): for i in range(MAX_DEFAULT_PLUGINS): if self.m_plugin_list[i]: self.slot_handleRemovePlugin(i) @pyqtSlot() def slot_doConnect(self): global lo_target, lo_targetName if lo_target and self.lo_server: urlText = self.lo_address else: urlText = "osc.tcp://127.0.0.1:19000/Carla" askValue = QInputDialog.getText(self, self.tr("Carla Control - Connect"), self.tr("Address"), text=urlText) if not askValue[1]: return self.slot_handleExit() self.lo_address = askValue[0] lo_target = Address(self.lo_address) lo_targetName = self.lo_address.rsplit("/", 1)[-1] print("Connecting to \"%s\" as '%s'..." % (self.lo_address, lo_targetName)) try: self.lo_server = ControlServer(self) except: # ServerError, err: print("Connecting error!") #print str(err) QMessageBox.critical(self, self.tr("Error"), self.tr("Failed to connect, operation failed.")) if self.lo_server: self.lo_server.start() self.act_file_refresh.setEnabled(True) lo_send(lo_target, "/register", self.lo_server.getFullURL()) @pyqtSlot() def slot_doRefresh(self): global lo_target if lo_target and self.lo_server: self.remove_all() lo_send(lo_target, "/unregister") lo_send(lo_target, "/register", self.lo_server.getFullURL()) @pyqtSlot() def slot_aboutCarlaControl(self): CarlaAboutW(self).exec_() @pyqtSlot(int, str) def slot_handleAddPluginStart(self, pluginId, pluginName): self.m_lastPluginName = pluginName @pyqtSlot(int) def slot_handleAddPluginEnd(self, pluginId): pwidget = PluginWidget(self, pluginId) self.w_plugins.layout().addWidget(pwidget) self.m_plugin_list[pluginId] = pwidget @pyqtSlot(int) def slot_handleRemovePlugin(self, pluginId): pwidget = self.m_plugin_list[pluginId] if pwidget: pwidget.edit_dialog.close() pwidget.close() pwidget.deleteLater() self.w_plugins.layout().removeWidget(pwidget) self.m_plugin_list[pluginId] = None @pyqtSlot(int, int, int, int, str, str, str, str, int) def slot_handleSetPluginData(self, pluginId, type_, category, hints, realName, label, maker, copyright, uniqueId): info = deepcopy(PluginInfo) info['type'] = type_ info['category'] = category info['hints'] = hints info['name'] = self.m_lastPluginName info['label'] = label info['maker'] = maker info['copyright'] = copyright info['uniqueId'] = uniqueId Carla.host._set_pluginInfo(pluginId, info) Carla.host._set_pluginRealName(pluginId, realName) @pyqtSlot(int, int, int, int, int, int, int, int) def slot_handleSetPluginPorts(self, pluginId, audioIns, audioOuts, midiIns, midiOuts, cIns, cOuts, cTotals): audioInfo = deepcopy(PortCountInfo) midiInfo = deepcopy(PortCountInfo) paramInfo = deepcopy(PortCountInfo) audioInfo['ins'] = audioIns audioInfo['outs'] = audioOuts audioInfo['total'] = audioIns + audioOuts midiInfo['ins'] = midiIns midiInfo['outs'] = midiOuts midiInfo['total'] = midiIns + midiOuts paramInfo['ins'] = cIns paramInfo['outs'] = cOuts paramInfo['total'] = cTotals Carla.host._set_audioCountInfo(pluginId, audioInfo) Carla.host._set_midiCountInfo(pluginId, midiInfo) Carla.host._set_parameterCountInfo(pluginId, paramInfo) @pyqtSlot(int, int, int, int, str, str, float) def slot_handleSetParameterData(self, pluginId, index, type_, hints, name, label, current): # remove hints not possible in bridge mode hints &= ~(PARAMETER_USES_SCALEPOINTS | PARAMETER_USES_CUSTOM_TEXT) data = deepcopy(ParameterData) data['type'] = type_ data['index'] = index data['rindex'] = index data['hints'] = hints info = deepcopy(ParameterInfo) info['name'] = name info['label'] = label Carla.host._set_parameterDataS(pluginId, index, data) Carla.host._set_parameterInfoS(pluginId, index, info) Carla.host._set_parameterValueS(pluginId, index, current) @pyqtSlot(int, int, float, float, float, float, float, float) def slot_handleSetParameterRanges(self, pluginId, index, min_, max_, def_, step, stepSmall, stepLarge): ranges = deepcopy(ParameterRanges) ranges['min'] = min_ ranges['max'] = max_ ranges['def'] = def_ ranges['step'] = step ranges['stepSmall'] = stepSmall ranges['stepLarge'] = stepLarge Carla.host._set_parameterRangeS(pluginId, index, ranges) @pyqtSlot(int, int, int) def slot_handleSetParameterMidiCC(self, pluginId, index, cc): Carla.host._set_parameterMidiCC(pluginId, index, cc) pwidget = self.m_plugin_list[pluginId] if pwidget: pwidget.edit_dialog.set_parameter_midi_cc(index, cc, True) @pyqtSlot(int, int, int) def slot_handleSetParameterMidiChannel(self, pluginId, index, channel): Carla.host._set_parameterMidiChannel(pluginId, index, channel) pwidget = self.m_plugin_list[pluginId] if pwidget: pwidget.edit_dialog.set_parameter_midi_channel(index, channel, True) @pyqtSlot(int, int, float) def slot_handleSetParameterValue(self, pluginId, parameterId, value): if parameterId >= 0: Carla.host._set_parameterValueS(pluginId, parameterId, value) pwidget = self.m_plugin_list[pluginId] if pwidget: if parameterId < PARAMETER_NULL: pwidget.m_parameterIconTimer = ICON_STATE_ON else: for param in pwidget.edit_dialog.m_parameterList: if param[1] == parameterId: if param[0] == PARAMETER_INPUT: pwidget.m_parameterIconTimer = ICON_STATE_ON break if parameterId == PARAMETER_ACTIVE: pwidget.set_active((value > 0.0), True, False) elif parameterId == PARAMETER_DRYWET: pwidget.set_drywet(value * 1000, True, False) elif parameterId == PARAMETER_VOLUME: pwidget.set_volume(value * 1000, True, False) elif parameterId == PARAMETER_BALANCE_LEFT: pwidget.set_balance_left(value * 1000, True, False) elif parameterId == PARAMETER_BALANCE_RIGHT: pwidget.set_balance_right(value * 1000, True, False) elif parameterId >= 0: pwidget.edit_dialog.set_parameter_to_update(parameterId) @pyqtSlot(int, int, float) def slot_handleSetDefaultValue(self, pluginId, parameterId, value): Carla.host._set_parameterDefaultValue(pluginId, parameterId, value) #pwidget = self.m_plugin_list[pluginId] #if pwidget: #pwidget.edit_dialog.set_parameter_default_value(parameterId, value) @pyqtSlot(int, int) def slot_handleSetProgram(self, pluginId, index): Carla.host._set_currentProgram(pluginId, index) pwidget = self.m_plugin_list[pluginId] if pwidget: pwidget.edit_dialog.set_program(index) pwidget.m_parameterIconTimer = ICON_STATE_ON @pyqtSlot(int, int) def slot_handleSetProgramCount(self, pluginId, count): Carla.host._set_programCount(pluginId, count) @pyqtSlot(int, int, str) def slot_handleSetProgramName(self, pluginId, index, name): Carla.host._set_programNameS(pluginId, index, name) @pyqtSlot(int, int) def slot_handleSetMidiProgram(self, pluginId, index): Carla.host._set_currentMidiProgram(pluginId, index) pwidget = self.m_plugin_list[pluginId] if pwidget: pwidget.edit_dialog.set_midi_program(index) pwidget.m_parameterIconTimer = ICON_STATE_ON @pyqtSlot(int, int) def slot_handleSetMidiProgramCount(self, pluginId, count): Carla.host._set_midiProgramCount(pluginId, count) @pyqtSlot(int, int, int, int, str) def slot_handleSetMidiProgramData(self, pluginId, index, bank, program, name): data = deepcopy(MidiProgramData) data['bank'] = bank data['program'] = program data['label'] = name Carla.host._set_midiProgramDataS(pluginId, index, data) @pyqtSlot(int, int, float) def slot_handleSetInputPeakValue(self, pluginId, portId, value): Carla.host._set_inPeak(pluginId, portId-1, value) @pyqtSlot(int, int, float) def slot_handleSetOutputPeakValue(self, pluginId, portId, value): Carla.host._set_outPeak(pluginId, portId-1, value) @pyqtSlot(int, int, int, int) def slot_handleNoteOn(self, pluginId, channel, note, velo): pwidget = self.m_plugin_list[pluginId] if pwidget: pwidget.edit_dialog.keyboard.sendNoteOn(note, False) @pyqtSlot(int, int, int) def slot_handleNoteOff(self, pluginId, channel, note): pwidget = self.m_plugin_list[pluginId] if pwidget: pwidget.edit_dialog.keyboard.sendNoteOff(note, False) @pyqtSlot() def slot_handleExit(self): self.remove_all() if self.lo_server: self.lo_server.stop() self.lo_server = None self.act_file_refresh.setEnabled(False) global lo_target, lo_targetName lo_target = None lo_targetName = "" self.lo_address = "" def saveSettings(self): self.settings.setValue("Geometry", self.saveGeometry()) #self.settings.setValue("ShowToolbar", self.toolBar.isVisible()) def loadSettings(self): self.restoreGeometry(self.settings.value("Geometry", "")) #show_toolbar = self.settings.value("ShowToolbar", True, type=bool) #self.act_settings_show_toolbar.setChecked(show_toolbar) #self.toolBar.setVisible(show_toolbar) def timerEvent(self, event): if event.timerId() == self.TIMER_GUI_STUFF: for pwidget in self.m_plugin_list: if pwidget: pwidget.check_gui_stuff() elif event.timerId() == self.TIMER_GUI_STUFF2: for pwidget in self.m_plugin_list: if pwidget: pwidget.check_gui_stuff2() QMainWindow.timerEvent(self, event) def closeEvent(self, event): self.saveSettings() global lo_target if lo_target and self.lo_server: lo_send(lo_target, "/unregister") QMainWindow.closeEvent(self, event) #--------------- main ------------------ if __name__ == '__main__': # App initialization app = QApplication(sys.argv) app.setApplicationName("Carla-Control") app.setApplicationVersion(VERSION) app.setOrganizationName("Cadence") app.setWindowIcon(QIcon(":/scalable/carla-control.svg")) Carla.host = Host() # Create GUI Carla.gui = CarlaControlW() # Set-up custom signal handling #setUpSignals(Carla.gui) # Show GUI Carla.gui.show() # App-Loop sys.exit(app.exec_())