More work on Catia

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("" 
+                  "<table>"
+                  "<tr><td align='right'><b>Group Name:</b></td><td>&nbsp;%s</td></tr>"
+                  "<tr><td align='right'><b>Port Name:</b></td><td>&nbsp;%s</td></tr>"
+                  "<tr><td align='right'><b>Full Port Name:</b></td><td>&nbsp;%s</td></tr>"
+                  "<tr><td align='right'><b>Port Alias #1:</b></td><td>&nbsp;%s</td></tr>"
+                  "<tr><td align='right'><b>Port Alias #2:</b></td><td>&nbsp;%s</td></tr>"
+                  "<tr><td colspan='2'>&nbsp;</td></tr>"
+                  "<tr><td align='right'><b>Port Flags:</b></td><td>&nbsp;%s</td></tr>"
+                  "<tr><td align='right'><b>Port Type:</b></td><td>&nbsp;%s</td></tr>"
+                  "<tr><td colspan='2'>&nbsp;</td></tr>"
+                  "<tr><td align='right'><b>Port Latency:</b></td><td>&nbsp;%s</td></tr>"
+                  "<tr><td align='right'><b>Total Port Latency:</b></td><td>&nbsp;%s</td></tr>"
+                  "</table>"
+                  % (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()

src/icons/icons.qrc

@@ -12,6 +12,7 @@
             <file>16x16/edit-rename.png</file>
             <file>16x16/list-add.png</file>
             <file>16x16/list-remove.png</file>
+            <file>16x16/media-playback-pause.png</file>
             <file>16x16/media-playback-start.png</file>
             <file>16x16/media-playback-stop.png</file>
             <file>16x16/media-record.png</file>

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 " <s>RT</s> ")
+    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)