diff --git a/src/catia.py b/src/catia.py index abfe1d7..62c9390 100755 --- a/src/catia.py +++ b/src/catia.py @@ -17,7 +17,7 @@ # For a full copy of the GNU General Public License see the COPYING file # Imports (Global) -from PyQt4.QtCore import pyqtSlot, QSettings +from PyQt4.QtCore import QSettings from PyQt4.QtGui import QApplication, QMainWindow # Imports (Custom Stuff) @@ -73,6 +73,7 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): self.m_last_port_id = 1 self.m_last_connection_id = 1 + self.m_xruns = 0 self.m_buffer_size = 0 self.m_sample_rate = 0 self.m_last_buffer_size = 0 @@ -157,11 +158,11 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): self.cb_sample_rate.setEnabled(bool(DBus.jack != None)) - #self.m_timer120 = self.startTimer(self.saved_settings["Main/RefreshInterval"]) - #self.m_timer600 = self.startTimer(self.saved_settings["Main/RefreshInterval"]*5) + self.m_timer120 = self.startTimer(self.m_savedSettings["Main/RefreshInterval"]) + self.m_timer600 = self.startTimer(self.m_savedSettings["Main/RefreshInterval"]*5) setCanvasConnections(self) - #setJackConnections(self, ["jack", "buffer-size", "transport", "misc"]) + setJackConnections(self, ["jack", "buffer-size", "transport", "misc"]) self.connect(self.act_tools_jack_start, SIGNAL("triggered()"), SLOT("slot_JackServerStart()")) self.connect(self.act_tools_jack_stop, SIGNAL("triggered()"), SLOT("slot_JackServerStop()")) @@ -174,14 +175,13 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): self.connect(self.act_help_about, SIGNAL("triggered()"), SLOT("slot_aboutCatia()")) self.connect(self.act_help_about_qt, SIGNAL("triggered()"), app, SLOT("aboutQt()")) - #self.connect(self, SIGNAL("XRunCallback"), self._XRunCallback) - #self.connect(self, SIGNAL("BufferSizeCallback"), self._BufferSizeCallback) - #self.connect(self, SIGNAL("SampleRateCallback"), self._SampleRateCallback) - #self.connect(self, SIGNAL("ClientRegistrationCallback"), self._ClientRegistrationCallback) + self.connect(self, SIGNAL("XRunCallback()"), SLOT("slot_XRunCallback()")) + self.connect(self, SIGNAL("BufferSizeCallback(int)"), SLOT("slot_BufferSizeCallback(int)")) + self.connect(self, SIGNAL("SampleRateCallback(int)"), SLOT("slot_SampleRateCallback(int)")) self.connect(self, SIGNAL("PortRegistrationCallback(int, bool)"), SLOT("slot_PortRegistrationCallback(int, bool)")) self.connect(self, SIGNAL("PortConnectCallback(int, int, bool)"), SLOT("slot_PortConnectCallback(int, int, bool)")) - #self.connect(self, SIGNAL("PortRenameCallback"), self._PortRenameCallback) - #self.connect(self, SIGNAL("ShutdownCallback"), self._ShutdownCallback) + self.connect(self, SIGNAL("PortRenameCallback(int, QString, QString)"), SLOT("slot_PortRenameCallback(int, QString, QString)")) + self.connect(self, SIGNAL("ShutdownCallback()"), SLOT("slot_ShutdownCallback()")) if (DBus.jack or DBus.a2j): DBus.bus.add_signal_receiver(self.DBusSignalReceiver, destination_keyword='dest', path_keyword='path', @@ -191,26 +191,185 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): if (action == patchcanvas.ACTION_GROUP_INFO): pass + elif (action == patchcanvas.ACTION_GROUP_RENAME): + pass + + elif (action == patchcanvas.ACTION_GROUP_SPLIT): + group_id = value1 + patchcanvas.splitGroup(group_id) + + elif (action == patchcanvas.ACTION_GROUP_JOIN): + group_id = value1 + patchcanvas.joinGroup(group_id) + + elif (action == patchcanvas.ACTION_PORT_INFO): + port_id = value1 + + for port in self.m_port_list: + if (port[iPortId] == port_id): + port_nameR = port[iPortNameR] + break + else: + return + + port_ptr = jacklib.port_by_name(jack.client, port_nameR) + port_flags = jacklib.port_flags(port_ptr) + group_name = port_nameR.split(":", 1)[0] + + port_short_name = str(jacklib.port_short_name(port_ptr), encoding="ascii") + + port_type_str = str(jacklib.port_type(port_ptr), encoding="ascii") + if (port_type_str == jacklib.JACK_DEFAULT_AUDIO_TYPE): + type_text = self.tr("JACK Audio") + elif (port_type_str == jacklib.JACK_DEFAULT_MIDI_TYPE): + type_text = self.tr("JACK MIDI") + else: + type_text = self.tr("Unknown") + + aliases = jacklib.port_get_aliases(port_ptr) + if (aliases[0] == 1): + alias1text = aliases[1] + alias2text = "(none)" + elif (aliases[0] == 2): + alias1text = aliases[1] + alias2text = aliases[2] + else: + alias1text = "(none)" + alias2text = "(none)" + + flags = [] + if (port_flags & jacklib.JackPortIsInput): + flags.append(self.tr("Input")) + if (port_flags & jacklib.JackPortIsOutput): + flags.append(self.tr("Output")) + if (port_flags & jacklib.JackPortIsPhysical): + flags.append(self.tr("Physical")) + if (port_flags & jacklib.JackPortCanMonitor): + flags.append(self.tr("Can Monitor")) + if (port_flags & jacklib.JackPortIsTerminal): + flags.append(self.tr("Terminal")) + + flags_text = "" + for flag in flags: + if (flags_text): + flags_text += " | " + flags_text += flag + + port_latency = jacklib.port_get_latency(port_ptr) + port_total_latency = jacklib.port_get_total_latency(jack.client, port_ptr) + + latency_text = self.tr("%.1f ms (%i frames)" % (port_latency*1000/self.m_sample_rate, port_latency)) + latency_total_text = self.tr("%.1f ms (%i frames)" % (port_total_latency*1000/self.m_sample_rate, port_total_latency)) + + info = self.tr("" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "" + "
Group Name: %s
Port Name: %s
Full Port Name: %s
Port Alias #1: %s
Port Alias #2: %s
 
Port Flags: %s
Port Type: %s
 
Port Latency: %s
Total Port Latency: %s
" + % (group_name, port_short_name, port_nameR, alias1text, alias1text, flags_text, type_text, latency_text, latency_total_text)) + + QMessageBox.information(self, self.tr("Port Information"), info) + + elif (action == patchcanvas.ACTION_PORT_RENAME): + port_id = value1 + new_name = value_str + + for port in self.m_port_list: + if (port[iPortId] == port_id): + port_nameR = port[iPortNameR] + break + else: + return + + port_ptr = jacklib.port_by_name(jack.client, port_nameR) + aliases = jacklib.port_get_aliases(port_ptr) + + if (aliases[0] == 2): + # JACK only allows 2 aliases, remove 2nd + jacklib.port_unset_alias(port_ptr, aliases[2]) + + # If we're going for 1st alias, unset it too + if (self.m_savedSettings["Main/JackPortAlias"] == 1): + jacklib.port_unset_alias(port_ptr, aliases[1]) + + elif (aliases[0] == 1 and self.m_savedSettings["Main/JackPortAlias"] == 1): + jacklib.port_unset_alias(port_ptr, aliases[1]) + + elif (aliases[0] == 0 and self.m_savedSettings["Main/JackPortAlias"] == 2): + # If 2nd alias is enabled and port had no previous aliases, set the 1st alias now + jacklib.port_set_alias(port_ptr, new_name) + + if (jacklib.port_set_alias(port_ptr, new_name) == 0): + patchcanvas.renamePort(port_id, new_name) + + elif (action == patchcanvas.ACTION_PORTS_CONNECT): + port_a_id = value1 + port_b_id = value2 + port_a_nameR = "" + port_b_nameR = "" + + for port in self.m_port_list: + if (port[iPortId] == port_a_id): + port_a_nameR = port[iPortNameR] + if (port[iPortId] == port_b_id): + port_b_nameR = port[iPortNameR] + + if (port_a_nameR and port_b_nameR): + jacklib.connect(jack.client, port_a_nameR, port_b_nameR) + + elif (action == patchcanvas.ACTION_PORTS_DISCONNECT): + connection_id = value1 + + for connection in self.m_connection_list: + if (connection[iConnId] == connection_id): + port_a_id = connection[iConnOutput] + port_b_id = connection[iConnInput] + break + else: + return + + port_a_nameR = "" + port_b_nameR = "" + + for port in self.m_port_list: + if (port[iPortId] == port_a_id): + port_a_nameR = port[iPortNameR] + if (port[iPortId] == port_b_id): + port_b_nameR = port[iPortNameR] + + if (port_a_nameR and port_b_nameR): + jacklib.disconnect(jack.client, port_a_nameR, port_b_nameR) + def init_jack(self): if (not jack.client): # Jack Crash/Bug ? self.menu_Transport.setEnabled(False) self.group_transport.setEnabled(False) return - #buffer_size = int(jacklib.get_buffer_size(jack.client)) - #realtime = int(jacklib.is_realtime(jack.client)) - #sample_rate = int(jacklib.get_sample_rate(jack.client)) - #self.xruns = 0 - self.last_bpm = None - self.last_transport_state = None + self.m_xruns = 0 + self.m_last_bpm = None + self.m_last_transport_state = None + + buffer_size = int(jacklib.get_buffer_size(jack.client)) + sample_rate = int(jacklib.get_sample_rate(jack.client)) + realtime = bool(int(jacklib.is_realtime(jack.client))) - #setBufferSize(self, buffer_size) - #setRealTime(self, realtime) - #setSampleRate(self, sample_rate) - #setXruns(self, self.xruns) + setBufferSize(self, buffer_size) + setRealTime(self, realtime) + setSampleRate(self, sample_rate) + setXruns(self, 0) - #refreshDSPLoad(self) - #refreshTransport(self) + refreshDSPLoad(self) + refreshTransport(self) self.init_callbacks() self.init_ports() @@ -223,17 +382,15 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): if (not jack.client): return - #jacklib.set_buffer_size_callback(jack.client, self.JackBufferSizeCallback) - #jacklib.set_sample_rate_callback(jack.client, self.JackSampleRateCallback) - #jacklib.set_xrun_callback(jack.client, self.JackXRunCallback) - - #jacklib.set_client_registration_callback(jack.client, self.JackClientRegistrationCallback) + jacklib.set_buffer_size_callback(jack.client, self.JackBufferSizeCallback, None) + jacklib.set_sample_rate_callback(jack.client, self.JackSampleRateCallback, None) + jacklib.set_xrun_callback(jack.client, self.JackXRunCallback, None) jacklib.set_port_registration_callback(jack.client, self.JackPortRegistrationCallback, None) jacklib.set_port_connect_callback(jack.client, self.JackPortConnectCallback, None) - #jacklib.on_shutdown(jack.client, self.JackShutdownCallback) + jacklib.on_shutdown(jack.client, self.JackShutdownCallback, None) #if (JACK2): - #jacklib.set_port_rename_callback(jack.client, self.JackPortRenameCallback) + #jacklib.set_port_rename_callback(jack.client, self.JackPortRenameCallback, None) def init_ports_prepare(self): pass @@ -329,7 +486,11 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): port_name = aliases[1] port_flags = jacklib.port_flags(port_ptr) - group_name = port_name.split(":")[0] + + if (":" in port_name): + group_name = port_name.split(":")[0] + else: + group_name = port_nameR.split(":")[0] if (port_flags & jacklib.JackPortIsInput): port_mode = patchcanvas.PORT_MODE_INPUT @@ -347,7 +508,7 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): else: haveA2J = False - port_short_name = port_name.split(":", 1)[1] + port_short_name = port_name.replace("%s:" % (group_name), "", 1) port_type_str = str(jacklib.port_type(port_ptr), encoding="ascii") if (port_type_str == jacklib.JACK_DEFAULT_AUDIO_TYPE): @@ -478,8 +639,8 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): if (DBus.jack): self.cb_sample_rate.setEnabled(True) - self.pb_dsp_load.setValue(0) self.pb_dsp_load.setMaximum(100) + self.pb_dsp_load.setValue(0) self.pb_dsp_load.update() self.init_jack() @@ -488,9 +649,20 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): if (haveDBus): self.DBusReconnect() - if (jack.client): - # client already closed - jack.client = None + # client already closed + jack.client = None + + if (DBus.jack): + if (self.cb_buffer_size.isEnabled()): + setBufferSize(self, jacksettings.getBufferSize()) + if (self.cb_sample_rate.isEnabled()): + setSampleRate(self, jacksettings.getSampleRate()) + setRealTime(self, jacksettings.isRealtime()) + setXruns(self, -1) + else: + self.cb_buffer_size.setEnabled(False) + self.cb_sample_rate.setEnabled(False) + self.menu_Jack_Buffer_Size.setEnabled(False) self.act_jack_render.setEnabled(False) self.b_jack_render.setEnabled(False) @@ -498,22 +670,12 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): self.group_transport.setEnabled(False) self.menuJackServer(False) - #if (DBus.jack): - #setBufferSize(self, jacksettings.getBufferSize()) - #setSampleRate(self, jacksettings.getSampleRate()) - #setRealTime(self, jacksettings.isRealtime()) - #setXruns(self, -1) - #else: - #self.cb_buffer_size.setEnabled(False) - #self.cb_sample_rate.setEnabled(False) - #self.menu_Jack_Buffer_Size.setEnabled(False) - - #if (self.selected_transport_view == TRANSPORT_VIEW_HMS): - #self.label_time.setText("00:00:00") - #elif (self.selected_transport_view == TRANSPORT_VIEW_BBT): - #self.label_time.setText("000|0|0000") - #elif (self.selected_transport_view == TRANSPORT_VIEW_FRAMES): - #self.label_time.setText("000'000'000") + if (self.m_selected_transport_view == TRANSPORT_VIEW_HMS): + self.label_time.setText("00:00:00") + elif (self.m_selected_transport_view == TRANSPORT_VIEW_BBT): + self.label_time.setText("000|0|0000") + elif (self.m_selected_transport_view == TRANSPORT_VIEW_FRAMES): + self.label_time.setText("000'000'000") self.pb_dsp_load.setValue(0) self.pb_dsp_load.setMaximum(0) @@ -570,45 +732,41 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): DBus.a2j = None a2j_client_name = None - #def JackBufferSizeCallback(self, buffer_size, arg=None): - #if (DEBUG): print("JackBufferSizeCallback", buffer_size) - #self.emit(SIGNAL("BufferSizeCallback"), buffer_size) - #return 0 - - #def JackSampleRateCallback(self, sample_rate, arg=None): - #if (DEBUG): print("JackSampleRateCallback", sample_rate) - #self.emit(SIGNAL("SampleRateCallback"), sample_rate) - #return 0 + def JackBufferSizeCallback(self, buffer_size, arg): + if (DEBUG): print("JackBufferSizeCallback(%i)" % (buffer_size)) + self.emit(SIGNAL("BufferSizeCallback(int)"), buffer_size) + return 0 - #def JackXRunCallback(self, arg=None): - #if (DEBUG): print("JackXRunCallback", self.xruns+1) - #self.emit(SIGNAL("XRunCallback")) - #return 0 + def JackSampleRateCallback(self, sample_rate, arg): + if (DEBUG): print("JackSampleRateCallback(%i)" % (sample_rate)) + self.emit(SIGNAL("SampleRateCallback(int)"), sample_rate) + return 0 - #def JackClientRegistrationCallback(self, client_name, register_yesno, arg=None): - #if (DEBUG): print("JackClientRegistrationCallback", client_name, register_yesno) - #self.emit(SIGNAL("ClientRegistrationCallback"), client_name, register_yesno) - #return 0 + def JackXRunCallback(self, arg): + if (DEBUG): print("JackXRunCallback()") + self.emit(SIGNAL("XRunCallback()")) + return 0 def JackPortRegistrationCallback(self, port_id, register_yesno, arg): - if (DEBUG): print("JackPortRegistrationCallback", port_id, register_yesno) + if (DEBUG): print("JackPortRegistrationCallback(%i, %i)" % (port_id, register_yesno)) self.emit(SIGNAL("PortRegistrationCallback(int, bool)"), port_id, bool(register_yesno)) return 0 def JackPortConnectCallback(self, port_a, port_b, connect_yesno, arg): - if (DEBUG): print("JackPortConnectCallback", port_a, port_b, connect_yesno) + if (DEBUG): print("JackPortConnectCallback(%i, %i, %i)" % (port_a, port_b, connect_yesno)) self.emit(SIGNAL("PortConnectCallback(int, int, bool)"), port_a, port_b, bool(connect_yesno)) return 0 - #def JackPortRenameCallback(self, port_id, old_name, new_name, arg=None): - #if (DEBUG): print("JackPortRenameCallback", port_id, old_name, new_name) - #self.emit(SIGNAL("PortRenameCallback"), port_id, old_name, new_name) - #return 0 + def JackPortRenameCallback(self, port_id, old_name, new_name, arg=None): + # FIXME - check string args + if (DEBUG): print("JackPortRenameCallback(%i, %s, %s)" % (port_id, old_name, new_name)) + self.emit(SIGNAL("PortRenameCallback(int, QString, QString)"), port_id, old_name, new_name) + return 0 - #def JackShutdownCallback(self, arg=None): - #if (DEBUG): print("JackShutdownCallback") - #self.emit(SIGNAL("ShutdownCallback")) - #return 0 + def JackShutdownCallback(self, arg=None): + if (DEBUG): print("JackShutdownCallback()") + self.emit(SIGNAL("ShutdownCallback()")) + return 0 @pyqtSlot() def slot_JackServerStart(self): @@ -624,6 +782,11 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): else: return False + @pyqtSlot() + def slot_JackClearXruns(self): + self.m_xruns = 0 + setXruns(self, 0) + @pyqtSlot() def slot_A2JBridgeStart(self): if (DBus.a2j): @@ -648,21 +811,18 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): elif (ask == QMessageBox.No): DBus.a2j.set_hw_export(False) - #def _BufferSizeCallback(self, buffer_size): - #setBufferSize(self, buffer_size) - - #def _SampleRateCallback(self, sample_rate): - #setSampleRate(self, sample_rate) + @pyqtSlot() + def slot_XRunCallback(self): + self.m_xruns += 1 + setXruns(self, self.m_xruns) - #def _XRunCallback(self): - #self.xruns += 1 - #setXruns(self, self.xruns) + @pyqtSlot(int) + def slot_BufferSizeCallback(self, buffer_size): + setBufferSize(self, buffer_size) - #def _ClientRegistrationCallback(self, client_name, register_yesno): - #if (register_yesno): - #self.canvas_add_group(client_name) - #else: - #self.canvas_remove_group(client_name) + @pyqtSlot(int) + def slot_SampleRateCallback(self, sample_rate): + setSampleRate(self, sample_rate) @pyqtSlot(int, bool) def slot_PortRegistrationCallback(self, port_id_jack, register_yesno): @@ -693,12 +853,15 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): else: self.canvas_disconnect_ports(port_a_nameR, port_b_nameR) - #def _PortRenameCallback(self, port_id, old_name, new_name): + @pyqtSlot(int, str, str) + def slot_PortRenameCallback(self, port_id, old_name, new_name): + pass #self.canvas_rename_port(port_id, new_name) - #def _ShutdownCallback(self): - #self.jackStopped() - #jack.client = None + @pyqtSlot() + def slot_ShutdownCallback(self): + self.jackStopped() + jack.client = None @pyqtSlot() def slot_configureCatia(self): @@ -714,7 +877,15 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): p_options.antialiasing = self.m_savedSettings["Canvas/Antialiasing"] p_options.eyecandy = self.m_savedSettings["Canvas/EyeCandy"] + p_features = patchcanvas.features_t() + p_features.group_info = False + p_features.group_rename = False + p_features.port_info = True + p_features.port_rename = bool(self.m_savedSettings["Main/JackPortAlias"] > 0) + p_features.handle_group_pos = True + patchcanvas.setOptions(p_options) + patchcanvas.setFeatures(p_features) patchcanvas.init(self.scene, self.canvasCallback, DEBUG) self.init_ports() @@ -730,7 +901,7 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): self.settings.setValue("Geometry", self.saveGeometry()) self.settings.setValue("ShowToolbar", self.frame_toolbar.isVisible()) self.settings.setValue("ShowStatusbar", self.frame_statusbar.isVisible()) - #self.settings.setValue("TransportView", self.selected_transport_view) + self.settings.setValue("TransportView", self.m_selected_transport_view) def loadSettings(self, geometry): if (geometry): @@ -744,7 +915,7 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): self.act_settings_show_statusbar.setChecked(show_statusbar) self.frame_statusbar.setVisible(show_statusbar) - #transport_set_view(self, self.settings.value("TransportView", TRANSPORT_VIEW_HMS, type=int)) + transport_set_view(self, self.settings.value("TransportView", TRANSPORT_VIEW_HMS, type=int)) self.m_savedSettings = { "Main/RefreshInterval": self.settings.value("Main/RefreshInterval", 100, type=int), @@ -759,6 +930,17 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW): "Canvas/HighQualityAntialiasing": self.settings.value("Canvas/HighQualityAntialiasing", False, type=bool) } + def timerEvent(self, event): + if (event.timerId() == self.m_timer120): + if (jack.client): + refreshTransport(self) + elif (event.timerId() == self.m_timer600): + if (jack.client): + refreshDSPLoad(self) + else: + self.update() + QMainWindow.timerEvent(self, event) + def closeEvent(self, event): self.saveSettings() patchcanvas.clear() diff --git a/src/icons/16x16/media-playback-pause.png b/src/icons/16x16/media-playback-pause.png new file mode 100644 index 0000000..a9b3113 Binary files /dev/null and b/src/icons/16x16/media-playback-pause.png differ diff --git a/src/icons/icons.qrc b/src/icons/icons.qrc index e2d6bf7..8e728dd 100644 --- a/src/icons/icons.qrc +++ b/src/icons/icons.qrc @@ -12,6 +12,7 @@ 16x16/edit-rename.png 16x16/list-add.png 16x16/list-remove.png + 16x16/media-playback-pause.png 16x16/media-playback-start.png 16x16/media-playback-stop.png 16x16/media-record.png diff --git a/src/shared_jack.py b/src/shared_jack.py index 017305b..32e234c 100644 --- a/src/shared_jack.py +++ b/src/shared_jack.py @@ -17,7 +17,7 @@ # For a full copy of the GNU General Public License see the COPYING file # Imports (Global) -from PyQt4.QtCore import QTimer +from PyQt4.QtCore import pyqtSlot, QTimer from PyQt4.QtGui import QCursor, QFontMetrics, QMenu # Imports (Custom Stuff) @@ -86,3 +86,383 @@ DBus.ladish_app_daemon = None DBus.patchbay = None jack.client = None + +# ------------------------------------------------------------- +# Property change calls + +#def jack_buffer_size(self, buffer_size): + #if (buffer_size != self.buffer_size): + #if (jack.client): + #jacklib.set_buffer_size(jack.client, buffer_size) + #else: + #jacksettings.setBufferSize(buffer_size) + + #else: + ## Make GUIs show previous value + #if ("setBufferSize" in dir(self)): + #QTimer.singleShot(100, lambda bf=buffer_size: self.setBufferSize(bf)) + #else: + #QTimer.singleShot(100, lambda parent=self, bf=buffer_size: setBufferSize(parent, bf)) + +#def jack_sample_rate(self, sample_rate): + #if (jack.client): + #setSampleRate(self, sample_rate, True) + #else: + #jacksettings.setSampleRate(sample_rate) + #setSampleRate(self, sample_rate) + +#def jack_buffer_size_cb(self, text): + #if (text.isEmpty()): return + #jack_buffer_size(self, int(QStringStr(text).replace("*",""))) + +#def jack_buffer_size_m(self, buffer_size): + #jack_buffer_size(self, buffer_size) + +#def jack_sample_rate_cb(self, text): + #if (text.isEmpty()): return + #jack_sample_rate(self, int(QStringStr(text).replace("*",""))) + +# ------------------------------------------------------------- +# Transport calls + +#def transport_playpause(self, play): + #if (not jack.client): return + #if (play): + #jacklib.transport_start(jack.client) + #else: + #jacklib.transport_stop(jack.client) + #refreshTransport(self) + +#def transport_stop(self): + #if (not jack.client): return + #jacklib.transport_stop(jack.client) + #jacklib.transport_locate(jack.client, 0) + #refreshTransport(self) + +#def transport_backwards(self): + #if (not jack.client): return + #new_frame = int(jacklib.get_current_transport_frame(jack.client))-100000 + #if (new_frame < 0): new_frame = 0 + #jacklib.transport_locate(jack.client, new_frame) + +#def transport_forwards(self): + #if (not jack.client): return + #new_frame = int(jacklib.get_current_transport_frame(jack.client))+100000 + #jacklib.transport_locate(jack.client, new_frame) + +#def transport_view_menu(self): + #menu = QMenu(self) + #act_t_hms = menu.addAction("Hours:Minutes:Seconds") + #act_t_bbt = menu.addAction("Beat:Bar:Tick") + #act_t_fr = menu.addAction("Frames") + + #act_t_hms.setCheckable(True) + #act_t_bbt.setCheckable(True) + #act_t_fr.setCheckable(True) + + #if (self.selected_transport_view == TRANSPORT_VIEW_HMS): + #act_t_hms.setChecked(True) + #elif (self.selected_transport_view == TRANSPORT_VIEW_BBT): + #act_t_bbt.setChecked(True) + #elif (self.selected_transport_view == TRANSPORT_VIEW_FRAMES): + #act_t_fr.setChecked(True) + + #act_selected = menu.exec_(QCursor().pos()) + + #if (act_selected == act_t_hms): + #transport_set_view(self, TRANSPORT_VIEW_HMS) + #elif (act_selected == act_t_bbt): + #transport_set_view(self, TRANSPORT_VIEW_BBT) + #elif (act_selected == act_t_fr): + #transport_set_view(self, TRANSPORT_VIEW_FRAMES) + +def transport_set_view(self, view): + if (view == TRANSPORT_VIEW_HMS): + self.m_selected_transport_view = TRANSPORT_VIEW_HMS + self.label_time.setMinimumWidth(QFontMetrics(self.label_time.font()).width("00:00:00")+3) + elif (view == TRANSPORT_VIEW_BBT): + self.m_selected_transport_view = TRANSPORT_VIEW_BBT + self.label_time.setMinimumWidth(QFontMetrics(self.label_time.font()).width("000|00|0000")+3) + elif (view == TRANSPORT_VIEW_FRAMES): + self.m_selected_transport_view = TRANSPORT_VIEW_FRAMES + self.label_time.setMinimumWidth(QFontMetrics(self.label_time.font()).width("000'000'000")+3) + else: + self.m_selected_transport_view = None + +#def transport_bpm_set(self, bpm): + #if (not jack.client): return + #if (self.last_bpm != bpm): + #pos = jacklib.jack_position_t + #pos.valid = 0 + #state = jacklib.transport_query(jack.client, pos) + + #pos.beats_per_minute = bpm + + #if (state > jacklib.TransportStopped): + #pos.frame += self.buffer_size + + #if (not pos.valid & jacklib.PositionBBT): + #pos.bar = 1 + #pos.beat = 1 + #pos.tick = 0 + #pos.valid = jacklib.PositionBBT + #QTimer.singleShot(self.buffer_size, transport_fix) + + #jacklib.transport_reposition(jack.client, pos) + + #self.last_bpm = bpm + +#def transport_fix(): + #pos = jacklib.jack_position_t + #pos.valid = 0 + #jacklib.transport_query(jack.client, pos) + #pos.frame += jacklib.get_buffer_size(jack.client) + #jacklib.transport_reposition(jack.client, pos) + +# ------------------------------------------------------------- +# Refresh GUI stuff + +#def refreshBufferSize(self): + #if (self.last_buffer_size != self.buffer_size): + #setBufferSize(self, self.buffer_size) + + #self.last_buffer_size = self.buffer_size + +#def refreshSampleRate(self): + #if (self.last_sample_rate != self.sample_rate): + #setSampleRate(self, self.sample_rate) + + #self.last_sample_rate = self.sample_rate + +def refreshDSPLoad(self): + if (not jack.client): return + setDSPLoad(self, int(jacklib.cpu_load(jack.client))) + +def refreshTransport(self): + if (not jack.client): return + pos = jacklib.jack_position_t() + pos.valid = 0 + state = jacklib.transport_query(jack.client, jacklib.pointer(pos)) + + if (self.m_selected_transport_view == TRANSPORT_VIEW_HMS): + frame = pos.frame + time = frame / self.m_sample_rate + secs = time % 60 + mins = (time / 60) % 60 + hrs = (time / 3600) % 60 + secH = minH = hrsH = "" + if secs < 10: secH = "0" + if mins < 10: minH = "0" + if hrs < 10: hrsH = "0" + self.label_time.setText("%s%i:%s%i:%s%i" % (hrsH, hrs, minH, mins, secH, secs)) + + #elif (self.m_selected_transport_view == TRANSPORT_VIEW_BBT): + #if (pos.valid & jacklib.PositionBBT): + #bar = pos.bar + #beat = pos.beat + #tick = pos.tick + #barH = beatH = tickH = "" + #if (bar == 0): + #beat = 0 + #tick = 0 + #barH = "00" + #elif bar < 10: barH = "00" + #elif bar < 100: barH = "0" + #if tick < 10: tickH = "000" + #elif tick < 100: tickH = "00" + #elif tick < 1000: tickH = "0" + #self.label_time.setText(barH+str(bar)+"|"+beatH+str(beat)+"|"+tickH+str(tick)) + #else: + #self.label_time.setText("000|00|0000") + + #elif (self.m_selected_transport_view == TRANSPORT_VIEW_FRAMES): + #frame = pos.frame + #frame1 = pos.frame % 1000 + #frame2 = (pos.frame / 1000) % 1000 + #frame3 = (pos.frame / 1000000) % 1000 + #frame1h = frame2h = frame3h = "" + #if frame1 < 10: frame1h = "00" + #elif frame1 < 100: frame1h = "0" + #if frame2 < 10: frame2h = "00" + #elif frame2 < 100: frame2h = "0" + #if frame3 < 10: frame3h = "00" + #elif frame3 < 100: frame3h = "0" + #self.label_time.setText(frame3h+str(frame3)+"'"+frame2h+str(frame2)+"'"+frame1h+str(frame1)) + + if (pos.valid & jacklib.JackPositionBBT): + if (self.m_last_bpm != pos.beats_per_minute): + self.sb_bpm.setValue(pos.beats_per_minute) + self.sb_bpm.setStyleSheet("") + else: + pos.beats_per_minute = -1 + if (self.m_last_bpm != pos.beats_per_minute): + self.sb_bpm.setStyleSheet("QDoubleSpinBox { color: palette(mid); }") + + self.m_last_bpm = pos.beats_per_minute + + if (state != self.m_last_transport_state): + if (state == jacklib.JackTransportStopped): + icon = getIcon("media-playback-start") + self.act_transport_play.setChecked(False) + self.act_transport_play.setIcon(icon) + self.act_transport_play.setText(self.tr("&Play")) + self.b_transport_play.setChecked(False) + self.b_transport_play.setIcon(icon) + else: + icon = getIcon("media-playback-pause") + self.act_transport_play.setChecked(True) + self.act_transport_play.setIcon(icon) + self.act_transport_play.setText(self.tr("&Pause")) + self.b_transport_play.setChecked(True) + self.b_transport_play.setIcon(icon) + self.m_last_transport_state = state + +# ------------------------------------------------------------- +# Set GUI stuff + +def setBufferSize(self, buffer_size): + if (self.m_buffer_size == buffer_size): + return + + self.m_buffer_size = buffer_size + if (buffer_size): + if (buffer_size == 16): + self.cb_buffer_size.setCurrentIndex(0) + elif (buffer_size == 32): + self.cb_buffer_size.setCurrentIndex(1) + elif (buffer_size == 64): + self.cb_buffer_size.setCurrentIndex(2) + elif (buffer_size == 128): + self.cb_buffer_size.setCurrentIndex(3) + elif (buffer_size == 256): + self.cb_buffer_size.setCurrentIndex(4) + elif (buffer_size == 512): + self.cb_buffer_size.setCurrentIndex(5) + elif (buffer_size == 1024): + self.cb_buffer_size.setCurrentIndex(6) + elif (buffer_size == 2048): + self.cb_buffer_size.setCurrentIndex(7) + elif (buffer_size == 4096): + self.cb_buffer_size.setCurrentIndex(8) + elif (buffer_size == 8192): + self.cb_buffer_size.setCurrentIndex(9) + else: + QMessageBox.warning(self, self.tr("Warning"), self.tr("Invalid JACK buffer-size requested")) + + #if ("act_jack_bf_list" in dir(self)): + if (buffer_size): + for act_bf in self.act_jack_bf_list: + act_bf.setEnabled(True) + if (act_bf.text().replace("&","") == str(buffer_size)): + #if (act_bf.isChecked() == False): + act_bf.setChecked(True) + else: + if (act_bf.isChecked()): + act_bf.setChecked(False) + #else: + #for i in range(len(self.act_jack_bf_list)): + #self.act_jack_bf_list[i].setEnabled(False) + #if (self.act_jack_bf_list[i].isChecked()): + #self.act_jack_bf_list[i].setChecked(False) + +def setSampleRate(self, sample_rate, future=False): + if (self.m_sample_rate == sample_rate): + return + + if (future): + pass + #if (self.sender() == self.cb_sample_rate): # Changed using GUI + #ask = QMessageBox.question(self, self.tr("Change Sample Rate"), self.tr("It's not possible to change Sample Rate while JACK is running.\n" + #"Do you want to change as soon as JACK stops?"), QMessageBox.Ok|QMessageBox.Cancel) + #if (ask == QMessageBox.Ok): + #self.next_sample_rate = sample_rate + #else: + #self.next_sample_rate = 0 + + # not future + else: + self.m_sample_rate = sample_rate + self.m_next_sample_rate = 0 + + for i in range(len(sample_rates)): + sample_rate = sample_rates[i] + sample_rate_str = str(sample_rate) + + #if (self.m_next_sample_rate != 0 and self.m_next_sample_rate != self.m_sample_rate and self.m_sample_rate == sample_rate): + #text += "*" + + self.cb_sample_rate.setItemText(i, sample_rate_str) + + if (self.m_sample_rate == sample_rate): + self.cb_sample_rate.setCurrentIndex(i) + +def setRealTime(self, realtime): + self.label_realtime.setText(" RT " if realtime else " RT ") + self.label_realtime.setEnabled(realtime) + +def setDSPLoad(self, dsp_load): + self.pb_dsp_load.setValue(dsp_load) + +def setXruns(self, xruns): + self.b_xruns.setText("%s Xrun%s" % ((str(xruns) if (xruns >= 0) else "--"), ("" if (xruns == 1) else "s"))) + +# ------------------------------------------------------------- +# External Dialogs + +@pyqtSlot() +def slot_showJackSettings(self): + jacksettings.JackSettingsW(self).exec_() + +@pyqtSlot() +def slot_showLogs(self): + logs.LogsW(self).show() + +@pyqtSlot() +def slot_showRender(self): + render.RenderW(self).exec_() + +# ------------------------------------------------------------- +# Shared Connections + +def setJackConnections(self, modes): + pass + if ("jack" in modes): + self.connect(self.act_jack_clear_xruns, SIGNAL("triggered()"), SLOT("slot_JackClearXruns()")) + self.connect(self.act_jack_render, SIGNAL("triggered()"), lambda: slot_showRender(self)) + self.connect(self.act_jack_configure, SIGNAL("triggered()"), lambda: slot_showJackSettings(self)) + self.connect(self.b_jack_clear_xruns, SIGNAL("clicked()"), SLOT("slot_JackClearXruns()")) + self.connect(self.b_jack_configure, SIGNAL("clicked()"), lambda: slot_showJackSettings(self)) + self.connect(self.b_jack_render, SIGNAL("clicked()"), lambda: slot_showRender(self)) + #self.connect(self.cb_buffer_size, SIGNAL("currentIndexChanged(QString)"), lambda: jack_buffer_size_cb(self, self.cb_buffer_size.currentText())) + #self.connect(self.cb_sample_rate, SIGNAL("currentIndexChanged(QString)"), lambda: jack_sample_rate_cb(self, self.cb_sample_rate.currentText())) + self.connect(self.b_xruns, SIGNAL("clicked()"), SLOT("slot_JackClearXruns()")) + + #if ("buffer-size" in modes): + #self.connect(self.act_jack_bf_16, SIGNAL("triggered(bool)"), lambda: jack_buffer_size_m(self, 16)) + #self.connect(self.act_jack_bf_32, SIGNAL("triggered(bool)"), lambda: jack_buffer_size_m(self, 32)) + #self.connect(self.act_jack_bf_64, SIGNAL("triggered(bool)"), lambda: jack_buffer_size_m(self, 64)) + #self.connect(self.act_jack_bf_128, SIGNAL("triggered(bool)"), lambda: jack_buffer_size_m(self, 128)) + #self.connect(self.act_jack_bf_256, SIGNAL("triggered(bool)"), lambda: jack_buffer_size_m(self, 256)) + #self.connect(self.act_jack_bf_512, SIGNAL("triggered(bool)"), lambda: jack_buffer_size_m(self, 512)) + #self.connect(self.act_jack_bf_1024, SIGNAL("triggered(bool)"), lambda: jack_buffer_size_m(self, 1024)) + #self.connect(self.act_jack_bf_2048, SIGNAL("triggered(bool)"), lambda: jack_buffer_size_m(self, 2048)) + #self.connect(self.act_jack_bf_4096, SIGNAL("triggered(bool)"), lambda: jack_buffer_size_m(self, 4096)) + #self.connect(self.act_jack_bf_8192, SIGNAL("triggered(bool)"), lambda: jack_buffer_size_m(self, 8192)) + + #if ("transport" in modes): + #self.connect(self.act_transport_play, SIGNAL("triggered(bool)"), lambda: transport_playpause(self, self.act_transport_play.isChecked())) + #self.connect(self.act_transport_stop, SIGNAL("triggered()"), lambda: transport_stop(self)) + #self.connect(self.act_transport_backwards, SIGNAL("triggered()"), lambda: transport_backwards(self)) + #self.connect(self.act_transport_forwards, SIGNAL("triggered()"), lambda: transport_forwards(self)) + #self.connect(self.b_transport_play, SIGNAL("clicked(bool)"), lambda: transport_playpause(self, self.b_transport_play.isChecked())) + #self.connect(self.b_transport_stop, SIGNAL("clicked()"), lambda: transport_stop(self)) + #self.connect(self.b_transport_backwards, SIGNAL("clicked()"), lambda: transport_backwards(self)) + #self.connect(self.b_transport_forwards, SIGNAL("clicked()"), lambda: transport_forwards(self)) + #self.connect(self.sb_bpm, SIGNAL("valueChanged(double)"), lambda: transport_bpm_set(self, self.sb_bpm.value())) + #self.connect(self.label_time, SIGNAL("customContextMenuRequested(QPoint)"), lambda: transport_view_menu(self)) + + if ("misc" in modes): + if (LINUX): + self.connect(self.act_show_logs, SIGNAL("triggered()"), lambda: slot_showLogs(self)) + else: + self.act_show_logs.setEnabled(False)