Update Catia code

src/shared.py

@@ -262,38 +262,37 @@ def setIcons(self_, modes):
     if gGui is None:
         gGui = self_
 
-    # TODO - need to update Catia and Claudia code first
     if "canvas" in modes:
-        gGui.act_canvas_arrange.setIcon(getIcon("view-sort-ascending"))
-        gGui.act_canvas_refresh.setIcon(getIcon("view-refresh"))
-        gGui.act_canvas_zoom_fit.setIcon(getIcon("zoom-fit-best"))
-        gGui.act_canvas_zoom_in.setIcon(getIcon("zoom-in"))
-        gGui.act_canvas_zoom_out.setIcon(getIcon("zoom-out"))
-        gGui.act_canvas_zoom_100.setIcon(getIcon("zoom-original"))
-        gGui.act_canvas_print.setIcon(getIcon("document-print"))
-        gGui.b_canvas_zoom_fit.setIcon(getIcon("zoom-fit-best"))
-        gGui.b_canvas_zoom_in.setIcon(getIcon("zoom-in"))
-        gGui.b_canvas_zoom_out.setIcon(getIcon("zoom-out"))
-        gGui.b_canvas_zoom_100.setIcon(getIcon("zoom-original"))
+        gGui.ui.act_canvas_arrange.setIcon(getIcon("view-sort-ascending"))
+        gGui.ui.act_canvas_refresh.setIcon(getIcon("view-refresh"))
+        gGui.ui.act_canvas_zoom_fit.setIcon(getIcon("zoom-fit-best"))
+        gGui.ui.act_canvas_zoom_in.setIcon(getIcon("zoom-in"))
+        gGui.ui.act_canvas_zoom_out.setIcon(getIcon("zoom-out"))
+        gGui.ui.act_canvas_zoom_100.setIcon(getIcon("zoom-original"))
+        gGui.ui.act_canvas_print.setIcon(getIcon("document-print"))
+        gGui.ui.b_canvas_zoom_fit.setIcon(getIcon("zoom-fit-best"))
+        gGui.ui.b_canvas_zoom_in.setIcon(getIcon("zoom-in"))
+        gGui.ui.b_canvas_zoom_out.setIcon(getIcon("zoom-out"))
+        gGui.ui.b_canvas_zoom_100.setIcon(getIcon("zoom-original"))
 
     if "jack" in modes:
-        gGui.act_jack_clear_xruns.setIcon(getIcon("edit-clear"))
-        gGui.act_jack_configure.setIcon(getIcon("configure"))
-        gGui.act_jack_render.setIcon(getIcon("media-record"))
-        gGui.b_jack_clear_xruns.setIcon(getIcon("edit-clear"))
-        gGui.b_jack_configure.setIcon(getIcon("configure"))
-        gGui.b_jack_render.setIcon(getIcon("media-record"))
+        gGui.ui.act_jack_clear_xruns.setIcon(getIcon("edit-clear"))
+        gGui.ui.act_jack_configure.setIcon(getIcon("configure"))
+        gGui.ui.act_jack_render.setIcon(getIcon("media-record"))
+        gGui.ui.b_jack_clear_xruns.setIcon(getIcon("edit-clear"))
+        gGui.ui.b_jack_configure.setIcon(getIcon("configure"))
+        gGui.ui.b_jack_render.setIcon(getIcon("media-record"))
 
     if "transport" in modes:
-        gGui.act_transport_play.setIcon(getIcon("media-playback-start"))
-        gGui.act_transport_stop.setIcon(getIcon("media-playback-stop"))
-        gGui.act_transport_backwards.setIcon(getIcon("media-seek-backward"))
-        gGui.act_transport_forwards.setIcon(getIcon("media-seek-forward"))
-        gGui.b_transport_play.setIcon(getIcon("media-playback-start"))
-        gGui.b_transport_stop.setIcon(getIcon("media-playback-stop"))
-        gGui.b_transport_backwards.setIcon(getIcon("media-seek-backward"))
-        gGui.b_transport_forwards.setIcon(getIcon("media-seek-forward"))
+        gGui.ui.act_transport_play.setIcon(getIcon("media-playback-start"))
+        gGui.ui.act_transport_stop.setIcon(getIcon("media-playback-stop"))
+        gGui.ui.act_transport_backwards.setIcon(getIcon("media-seek-backward"))
+        gGui.ui.act_transport_forwards.setIcon(getIcon("media-seek-forward"))
+        gGui.ui.b_transport_play.setIcon(getIcon("media-playback-start"))
+        gGui.ui.b_transport_stop.setIcon(getIcon("media-playback-stop"))
+        gGui.ui.b_transport_backwards.setIcon(getIcon("media-seek-backward"))
+        gGui.ui.b_transport_forwards.setIcon(getIcon("media-seek-forward"))
 
     if "misc" in modes:
-        gGui.act_quit.setIcon(getIcon("application-exit"))
-        gGui.act_configure.setIcon(getIcon("configure"))
+        gGui.ui.act_quit.setIcon(getIcon("application-exit"))
+        gGui.ui.act_configure.setIcon(getIcon("configure"))

src/shared_canvasjack.py

@@ -19,7 +19,7 @@
 # ------------------------------------------------------------------------------------------------------------
 # Imports (Global)
 
-from PyQt4.QtCore import pyqtSlot, QSettings, QTimer
+from PyQt4.QtCore import pyqtSlot, QTimer
 from PyQt4.QtGui import QCursor, QFontMetrics, QImage, QMainWindow, QMenu, QPainter, QPrinter, QPrintDialog
 
 # ------------------------------------------------------------------------------------------------------------
@@ -67,18 +67,18 @@ class DBusObject(object):
         'patchbay'
     ]
 
-DBus = DBusObject()
-DBus.loop = None
-DBus.bus  = None
-DBus.a2j  = None
-DBus.jack = None
-DBus.ladish_control = None
-DBus.ladish_studio  = None
-DBus.ladish_room    = None
-DBus.ladish_graph   = None
-DBus.ladish_app_iface  = None
-DBus.ladish_app_daemon = None
-DBus.patchbay = None
+gDBus = DBusObject()
+gDBus.loop = None
+gDBus.bus  = None
+gDBus.a2j  = None
+gDBus.jack = None
+gDBus.ladish_control = None
+gDBus.ladish_studio  = None
+gDBus.ladish_room    = None
+gDBus.ladish_graph   = None
+gDBus.ladish_app_iface  = None
+gDBus.ladish_app_daemon = None
+gDBus.patchbay = None
 
 # ------------------------------------------------------------------------------------------------------------
 # Global JACK object
@@ -88,8 +88,8 @@ class JackObject(object):
         'client'
     ]
 
-jack = JackObject()
-jack.client = None
+gJack = JackObject()
+gJack.client = None
 
 # ------------------------------------------------------------------------------------------------------------
 # Abstract Canvas and JACK Class
@@ -98,50 +98,49 @@ class AbstractCanvasJackClass(QMainWindow):
     def __init__(self, parent, appName):
         QMainWindow.__init__(self, parent)
 
-        self.m_appName          = appName
-        self.m_curTransportView = TRANSPORT_VIEW_HMS
+        self.fAppName          = appName
+        self.fCurTransportView = TRANSPORT_VIEW_HMS
 
-        self.m_lastBPM = None
-        self.m_lastTransportState = None
+        self.fLastBPM = None
+        self.fLastTransportState = None
 
-        self.m_xruns = -1
-        self.m_bufferSize = 0
-        self.m_sampleRate = 0
-        self.m_nextSampleRate = 0
+        self.fXruns = -1
+        self.fBufferSize = 0
+        self.fSampleRate = 0.0
+        self.fNextSampleRate = 0.0
 
-        self.m_logsW = None
-
-        self.settings = QSettings("Cadence", appName)
+        self.fLogsW = None
 
     # -----------------------------------------------------------------
     # JACK Property change calls
 
     def jack_setBufferSize(self, bufferSize):
-        if self.m_bufferSize == bufferSize:
+        if self.fBufferSize == bufferSize:
             return
 
-        if jack.client:
-            failed = bool(jacklib.set_buffer_size(jack.client, bufferSize) != 0)
+        if gJack.client:
+            failed = bool(jacklib.set_buffer_size(gJack.client, bufferSize) != 0)
         else:
             failed = bool(jacksettings.setBufferSize(bufferSize))
 
         if failed:
-            print("Failed to change buffer-size as %i, reset to %i" % (bufferSize, self.m_bufferSize))
-            self.setBufferSize(self.m_bufferSize, True)
+            print("Failed to change buffer-size as %i, reset to %i" % (bufferSize, self.fBufferSize))
+            self.ui_setBufferSize(self.fBufferSize, True)
 
     def jack_setSampleRate(self, sampleRate):
-        if jack.client:
+        if gJack.client:
             # Show change-in-future dialog
-            self.setSampleRate(sampleRate, True)
+            self.ui_setSampleRate(sampleRate, True)
         else:
             # Try to set sampleRate via dbus now
             if jacksettings.setSampleRate(sampleRate):
-                self.setSampleRate(sampleRate)
+                self.ui_setSampleRate(sampleRate)
 
     @pyqtSlot()
     def slot_jackBufferSize_Menu(self):
-        bufferSize = int(self.sender().text())
-        self.jack_setBufferSize(bufferSize)
+        text = self.sender().text()
+        if text and text.isdigit():
+            self.jack_setBufferSize(int(text))
 
     @pyqtSlot(str)
     def slot_jackBufferSize_ComboBox(self, text):
@@ -158,225 +157,234 @@ class AbstractCanvasJackClass(QMainWindow):
 
     def setTransportView(self, view):
         if view == TRANSPORT_VIEW_HMS:
-            self.m_curTransportView = TRANSPORT_VIEW_HMS
-            self.label_time.setMinimumWidth(QFontMetrics(self.label_time.font()).width("00:00:00") + 3)
+            self.fCurTransportView = TRANSPORT_VIEW_HMS
+            self.ui.label_time.setMinimumWidth(QFontMetrics(self.ui.label_time.font()).width("00:00:00") + 3)
         elif view == TRANSPORT_VIEW_BBT:
-            self.m_curTransportView = TRANSPORT_VIEW_BBT
-            self.label_time.setMinimumWidth(QFontMetrics(self.label_time.font()).width("000|00|0000") + 3)
+            self.fCurTransportView = TRANSPORT_VIEW_BBT
+            self.ui.label_time.setMinimumWidth(QFontMetrics(self.ui.label_time.font()).width("000|00|0000") + 3)
         elif view == TRANSPORT_VIEW_FRAMES:
-            self.m_curTransportView = TRANSPORT_VIEW_FRAMES
-            self.label_time.setMinimumWidth(QFontMetrics(self.label_time.font()).width("000'000'000") + 3)
+            self.fCurTransportView = TRANSPORT_VIEW_FRAMES
+            self.ui.label_time.setMinimumWidth(QFontMetrics(self.ui.label_time.font()).width("000'000'000") + 3)
         else:
             self.setTransportView(TRANSPORT_VIEW_HMS)
 
     @pyqtSlot(bool)
     def slot_transportPlayPause(self, play):
-        if not jack.client: return
+        if not gJack.client:
+            return
+
         if play:
-            jacklib.transport_start(jack.client)
+            jacklib.transport_start(gJack.client)
         else:
-            jacklib.transport_stop(jack.client)
+            jacklib.transport_stop(gJack.client)
+
         self.refreshTransport()
 
     @pyqtSlot()
     def slot_transportStop(self):
-        if not jack.client: return
-        jacklib.transport_stop(jack.client)
-        jacklib.transport_locate(jack.client, 0)
+        if not gJack.client:
+            return
+
+        jacklib.transport_stop(gJack.client)
+        jacklib.transport_locate(gJack.client, 0)
+
         self.refreshTransport()
 
     @pyqtSlot()
     def slot_transportBackwards(self):
-        if not jack.client: return
-        newFrame = jacklib.get_current_transport_frame(jack.client) - 100000
+        if not gJack.client:
+            return
+
+        newFrame = jacklib.get_current_transport_frame(gJack.client) - 100000
+
         if newFrame < 0:
             newFrame = 0
-        jacklib.transport_locate(jack.client, newFrame)
+
+        jacklib.transport_locate(gJack.client, newFrame)
 
     @pyqtSlot()
     def slot_transportForwards(self):
-        if not jack.client: return
-        newFrame = jacklib.get_current_transport_frame(jack.client) + 100000
-        jacklib.transport_locate(jack.client, newFrame)
+        if not gJack.client:
+            return
+
+        newFrame = jacklib.get_current_transport_frame(gJack.client) + 100000
+        jacklib.transport_locate(gJack.client, newFrame)
 
     @pyqtSlot()
     def slot_transportViewMenu(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")
+        actHMS    = menu.addAction("Hours:Minutes:Seconds")
+        actBBT    = menu.addAction("Beat:Bar:Tick")
+        actFrames = menu.addAction("Frames")
 
-        act_t_hms.setCheckable(True)
-        act_t_bbt.setCheckable(True)
-        act_t_fr.setCheckable(True)
+        actHMS.setCheckable(True)
+        actBBT.setCheckable(True)
+        actFrames.setCheckable(True)
 
-        if self.m_curTransportView == TRANSPORT_VIEW_HMS:
-            act_t_hms.setChecked(True)
-        elif self.m_curTransportView == TRANSPORT_VIEW_BBT:
-            act_t_bbt.setChecked(True)
-        elif self.m_curTransportView == TRANSPORT_VIEW_FRAMES:
-            act_t_fr.setChecked(True)
+        if self.fCurTransportView == TRANSPORT_VIEW_HMS:
+            actHMS.setChecked(True)
+        elif self.fCurTransportView == TRANSPORT_VIEW_BBT:
+            actBBT.setChecked(True)
+        elif self.fCurTransportView == TRANSPORT_VIEW_FRAMES:
+            actFrames.setChecked(True)
 
-        act_selected = menu.exec_(QCursor().pos())
+        actSelected = menu.exec_(QCursor().pos())
 
-        if act_selected == act_t_hms:
+        if actSelected == actHMS:
             self.setTransportView(TRANSPORT_VIEW_HMS)
-        elif act_selected == act_t_bbt:
+        elif actSelected == actBBT:
             self.setTransportView(TRANSPORT_VIEW_BBT)
-        elif act_selected == act_t_fr:
+        elif actSelected == actFrames:
             self.setTransportView(TRANSPORT_VIEW_FRAMES)
 
     # -----------------------------------------------------------------
     # Refresh JACK stuff
 
     def refreshDSPLoad(self):
-        if not jack.client: return
-        self.setDSPLoad(int(jacklib.cpu_load(jack.client)))
+        if not gJack.client:
+            return
+
+        self.ui_setDSPLoad(int(jacklib.cpu_load(gJack.client)))
 
     def refreshTransport(self):
-        if not jack.client: return
+        if not gJack.client:
+            return
+
         pos = jacklib.jack_position_t()
         pos.valid = 0
-        state = jacklib.transport_query(jack.client, jacklib.pointer(pos))
 
-        if self.m_curTransportView == TRANSPORT_VIEW_HMS:
-            time = pos.frame / self.m_sampleRate
+        state = jacklib.transport_query(gJack.client, jacklib.pointer(pos))
+
+        if self.fCurTransportView == TRANSPORT_VIEW_HMS:
+            time = pos.frame / int(self.fSampleRate)
             secs = time % 60
             mins = (time / 60) % 60
             hrs  = (time / 3600) % 60
-            self.label_time.setText("%02i:%02i:%02i" % (hrs, mins, secs))
+            self.ui.label_time.setText("%02i:%02i:%02i" % (hrs, mins, secs))
 
-        elif self.m_curTransportView == TRANSPORT_VIEW_BBT:
+        elif self.fCurTransportView == TRANSPORT_VIEW_BBT:
             if pos.valid & jacklib.JackPositionBBT:
                 bar  = pos.bar
                 beat = pos.beat if bar != 0 else 0
                 tick = pos.tick if bar != 0 else 0
-                self.label_time.setText("%03i|%02i|%04i" % (bar, beat, tick))
+                self.ui.label_time.setText("%03i|%02i|%04i" % (bar, beat, tick))
             else:
-                self.label_time.setText("%03i|%02i|%04i" % (0, 0, 0))
+                self.ui.label_time.setText("%03i|%02i|%04i" % (0, 0, 0))
 
-        elif self.m_curTransportView == TRANSPORT_VIEW_FRAMES:
+        elif self.fCurTransportView == TRANSPORT_VIEW_FRAMES:
             frame1 = pos.frame % 1000
             frame2 = (pos.frame / 1000) % 1000
             frame3 = (pos.frame / 1000000) % 1000
-            self.label_time.setText("%03i'%03i'%03i" % (frame3, frame2, frame1))
+            self.ui.label_time.setText("%03i'%03i'%03i" % (frame3, frame2, frame1))
 
         if pos.valid & jacklib.JackPositionBBT:
-            if self.m_lastBPM != pos.beats_per_minute:
-                self.sb_bpm.setValue(pos.beats_per_minute)
-                self.sb_bpm.setStyleSheet("")
+            if self.fLastBPM != pos.beats_per_minute:
+                self.ui.sb_bpm.setValue(pos.beats_per_minute)
+                self.ui.sb_bpm.setStyleSheet("")
         else:
             pos.beats_per_minute = -1
-            if self.m_lastBPM != pos.beats_per_minute:
-                self.sb_bpm.setStyleSheet("QDoubleSpinBox { color: palette(mid); }")
+            if self.fLastBPM != pos.beats_per_minute:
+                self.ui.sb_bpm.setStyleSheet("QDoubleSpinBox { color: palette(mid); }")
+
+        self.fLastBPM = pos.beats_per_minute
 
-        self.m_lastBPM = pos.beats_per_minute
+        if state != self.fLastTransportState:
+            self.fLastTransportState = state
 
-        if state != self.m_lastTransportState:
             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)
+                self.ui.act_transport_play.setChecked(False)
+                self.ui.act_transport_play.setIcon(icon)
+                self.ui.act_transport_play.setText(self.tr("&Play"))
+                self.ui.b_transport_play.setChecked(False)
+                self.ui.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_lastTransportState = state
+                self.ui.act_transport_play.setChecked(True)
+                self.ui.act_transport_play.setIcon(icon)
+                self.ui.act_transport_play.setText(self.tr("&Pause"))
+                self.ui.b_transport_play.setChecked(True)
+                self.ui.b_transport_play.setIcon(icon)
 
     # -----------------------------------------------------------------
     # Set JACK stuff
 
-    def setBufferSize(self, bufferSize, forced=False):
-        if self.m_bufferSize == bufferSize and not forced:
+    def ui_setBufferSize(self, bufferSize, forced=False):
+        if self.fBufferSize == bufferSize and not forced:
             return
 
-        self.m_bufferSize = bufferSize
+        self.fBufferSize = bufferSize
 
         if bufferSize:
             if bufferSize == 16:
-                self.cb_buffer_size.setCurrentIndex(0)
+                self.ui.cb_buffer_size.setCurrentIndex(0)
             elif bufferSize == 32:
-                self.cb_buffer_size.setCurrentIndex(1)
+                self.ui.cb_buffer_size.setCurrentIndex(1)
             elif bufferSize == 64:
-                self.cb_buffer_size.setCurrentIndex(2)
+                self.ui.cb_buffer_size.setCurrentIndex(2)
             elif bufferSize == 128:
-                self.cb_buffer_size.setCurrentIndex(3)
+                self.ui.cb_buffer_size.setCurrentIndex(3)
             elif bufferSize == 256:
-                self.cb_buffer_size.setCurrentIndex(4)
+                self.ui.cb_buffer_size.setCurrentIndex(4)
             elif bufferSize == 512:
-                self.cb_buffer_size.setCurrentIndex(5)
+                self.ui.cb_buffer_size.setCurrentIndex(5)
             elif bufferSize == 1024:
-                self.cb_buffer_size.setCurrentIndex(6)
+                self.ui.cb_buffer_size.setCurrentIndex(6)
             elif bufferSize == 2048:
-                self.cb_buffer_size.setCurrentIndex(7)
+                self.ui.cb_buffer_size.setCurrentIndex(7)
             elif bufferSize == 4096:
-                self.cb_buffer_size.setCurrentIndex(8)
+                self.ui.cb_buffer_size.setCurrentIndex(8)
             elif bufferSize == 8192:
-                self.cb_buffer_size.setCurrentIndex(9)
+                self.ui.cb_buffer_size.setCurrentIndex(9)
             else:
-                QMessageBox.warning(self, self.tr("Warning"), self.tr("Invalid JACK buffer-size requested: %i" % bufferSize))
-
-        if self.m_appName == "Catia":
-            if bufferSize:
-                for act_bf in self.act_jack_bf_list:
-                    act_bf.setEnabled(True)
-                    if act_bf.text().replace("&", "") == str(bufferSize):
-                        if not act_bf.isChecked():
-                            act_bf.setChecked(True)
-                    else:
-                        if act_bf.isChecked():
-                            act_bf.setChecked(False)
-            #else:
-                #for act_bf in self.act_jack_bf_list:
-                    #act_bf.setEnabled(False)
-                    #if act_bf.isChecked():
-                        #act_bf.setChecked(False)
-
-    def setSampleRate(self, sampleRate, future=False):
-        if self.m_sampleRate == sampleRate:
+                self.ui.cb_buffer_size.setCurrentIndex(-1)
+
+        if self.fAppName == "Catia" and bufferSize:
+            for actBufSize in self.ui.act_jack_bf_list:
+                actBufSize.setEnabled(True)
+
+                if actBufSize.text().replace("&", "") == str(bufferSize):
+                    if not actBufSize.isChecked():
+                        actBufSize.setChecked(True)
+                elif actBufSize.isChecked():
+                    actBufSize.setChecked(False)
+
+    def ui_setSampleRate(self, sampleRate, future=False):
+        if self.fSampleRate == sampleRate:
             return
 
         if future:
-            #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.m_nextSampleRate = sampleRate
-                else:
-                    self.m_nextSampleRate = 0
+            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.fNextSampleRate = sampleRate
+            else:
+                self.fNextSampleRate = 0.0
 
         # not future
         else:
-            self.m_sampleRate = sampleRate
-            self.m_nextSampleRate = 0
+            self.fSampleRate     = sampleRate
+            self.fNextSampleRate = 0.0
 
         for i in range(len(SAMPLE_RATE_LIST)):
             sampleRate = SAMPLE_RATE_LIST[i]
-            #sampleRateStr = str(sampleRate)
-            #self.cb_sample_rate.setItemText(i, sampleRateStr)
 
-            if self.m_sampleRate == sampleRate:
-                self.cb_sample_rate.setCurrentIndex(i)
+            if self.fSampleRate == sampleRate:
+                self.ui.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 ui_setRealTime(self, isRealtime):
+        self.ui.label_realtime.setText(" RT " if isRealtime else " <s>RT</s> ")
+        self.ui.label_realtime.setEnabled(isRealtime)
 
-    def setDSPLoad(self, dsp_load):
-        self.pb_dsp_load.setValue(dsp_load)
+    def ui_setDSPLoad(self, dspLoad):
+        self.ui.pb_dsp_load.setValue(dspLoad)
 
-    def setXruns(self, xruns):
+    def ui_setXruns(self, xruns):
         txt1 = str(xruns) if (xruns >= 0) else "--"
         txt2 = "" if (xruns == 1) else "s"
-        self.b_xruns.setText("%s Xrun%s" % (txt1, txt2))
+        self.ui.b_xruns.setText("%s Xrun%s" % (txt1, txt2))
 
     # -----------------------------------------------------------------
     # External Dialogs
@@ -388,14 +396,14 @@ class AbstractCanvasJackClass(QMainWindow):
         del jacksettingsW
 
         # Force update of gui widgets
-        if not jack.client:
+        if not gJack.client:
             self.jackStopped()
 
     @pyqtSlot()
     def slot_showLogs(self):
-        if self.m_logsW is None:
-            self.m_logsW = logs.LogsW(self)
-        self.m_logsW.show()
+        if self.fLogsW is None:
+            self.fLogsW = logs.LogsW(self)
+        self.fLogsW.show()
 
     @pyqtSlot()
     def slot_showRender(self):
@@ -434,11 +442,11 @@ class AbstractCanvasJackClass(QMainWindow):
     @pyqtSlot()
     def slot_canvasPrint(self):
         self.scene.clearSelection()
-        self.m_exportPrinter = QPrinter()
-        dialog = QPrintDialog(self.m_exportPrinter, self)
+        self.fExportPrinter = QPrinter()
+        dialog = QPrintDialog(self.fExportPrinter, self)
 
         if dialog.exec_():
-            painter = QPainter(self.m_exportPrinter)
+            painter = QPainter(self.fExportPrinter)
             painter.setRenderHint(QPainter.Antialiasing)
             painter.setRenderHint(QPainter.TextAntialiasing)
             self.scene.render(painter)
@@ -450,6 +458,7 @@ class AbstractCanvasJackClass(QMainWindow):
         if newPath:
             self.scene.clearSelection()
 
+            # FIXME - must be a better way...
             if newPath.endswith((".jpg", ".jpG", ".jPG", ".JPG", ".JPg", ".Jpg")):
                 imgFormat = "JPG"
             elif newPath.endswith((".png", ".pnG", ".pNG", ".PNG", ".PNg", ".Png")):
@@ -459,68 +468,68 @@ class AbstractCanvasJackClass(QMainWindow):
                 imgFormat = "PNG"
                 newPath  += ".png"
 
-            self.m_exportImage = QImage(self.scene.sceneRect().width(), self.scene.sceneRect().height(), QImage.Format_RGB32)
-            painter = QPainter(self.m_exportImage)
+            self.fExportImage = QImage(self.scene.sceneRect().width(), self.scene.sceneRect().height(), QImage.Format_RGB32)
+            painter = QPainter(self.fExportImage)
             painter.setRenderHint(QPainter.Antialiasing) # TODO - set true, cleanup this
             painter.setRenderHint(QPainter.TextAntialiasing)
             self.scene.render(painter)
-            self.m_exportImage.save(newPath, imgFormat, 100)
+            self.fExportImage.save(newPath, imgFormat, 100)
 
     # -----------------------------------------------------------------
     # Shared Connections
 
     def setCanvasConnections(self):
-        self.act_canvas_arrange.setEnabled(False) # TODO, later
-        self.connect(self.act_canvas_arrange, SIGNAL("triggered()"), SLOT("slot_canvasArrange()"))
-        self.connect(self.act_canvas_refresh, SIGNAL("triggered()"), SLOT("slot_canvasRefresh()"))
-        self.connect(self.act_canvas_zoom_fit, SIGNAL("triggered()"), SLOT("slot_canvasZoomFit()"))
-        self.connect(self.act_canvas_zoom_in, SIGNAL("triggered()"), SLOT("slot_canvasZoomIn()"))
-        self.connect(self.act_canvas_zoom_out, SIGNAL("triggered()"), SLOT("slot_canvasZoomOut()"))
-        self.connect(self.act_canvas_zoom_100, SIGNAL("triggered()"), SLOT("slot_canvasZoomReset()"))
-        self.connect(self.act_canvas_print, SIGNAL("triggered()"), SLOT("slot_canvasPrint()"))
-        self.connect(self.act_canvas_save_image, SIGNAL("triggered()"), SLOT("slot_canvasSaveImage()"))
-        self.connect(self.b_canvas_zoom_fit, SIGNAL("clicked()"), SLOT("slot_canvasZoomFit()"))
-        self.connect(self.b_canvas_zoom_in, SIGNAL("clicked()"), SLOT("slot_canvasZoomIn()"))
-        self.connect(self.b_canvas_zoom_out, SIGNAL("clicked()"), SLOT("slot_canvasZoomOut()"))
-        self.connect(self.b_canvas_zoom_100, SIGNAL("clicked()"), SLOT("slot_canvasZoomReset()"))
+        self.ui.act_canvas_arrange.setEnabled(False) # TODO, later
+        self.connect(self.ui.act_canvas_arrange, SIGNAL("triggered()"), SLOT("slot_canvasArrange()"))
+        self.connect(self.ui.act_canvas_refresh, SIGNAL("triggered()"), SLOT("slot_canvasRefresh()"))
+        self.connect(self.ui.act_canvas_zoom_fit, SIGNAL("triggered()"), SLOT("slot_canvasZoomFit()"))
+        self.connect(self.ui.act_canvas_zoom_in, SIGNAL("triggered()"), SLOT("slot_canvasZoomIn()"))
+        self.connect(self.ui.act_canvas_zoom_out, SIGNAL("triggered()"), SLOT("slot_canvasZoomOut()"))
+        self.connect(self.ui.act_canvas_zoom_100, SIGNAL("triggered()"), SLOT("slot_canvasZoomReset()"))
+        self.connect(self.ui.act_canvas_print, SIGNAL("triggered()"), SLOT("slot_canvasPrint()"))
+        self.connect(self.ui.act_canvas_save_image, SIGNAL("triggered()"), SLOT("slot_canvasSaveImage()"))
+        self.connect(self.ui.b_canvas_zoom_fit, SIGNAL("clicked()"), SLOT("slot_canvasZoomFit()"))
+        self.connect(self.ui.b_canvas_zoom_in, SIGNAL("clicked()"), SLOT("slot_canvasZoomIn()"))
+        self.connect(self.ui.b_canvas_zoom_out, SIGNAL("clicked()"), SLOT("slot_canvasZoomOut()"))
+        self.connect(self.ui.b_canvas_zoom_100, SIGNAL("clicked()"), SLOT("slot_canvasZoomReset()"))
 
     def setJackConnections(self, modes):
         if "jack" in modes:
-            self.connect(self.act_jack_clear_xruns, SIGNAL("triggered()"), SLOT("slot_JackClearXruns()"))
-            self.connect(self.act_jack_render, SIGNAL("triggered()"), SLOT("slot_showRender()"))
-            self.connect(self.act_jack_configure, SIGNAL("triggered()"), SLOT("slot_showJackSettings()"))
-            self.connect(self.b_jack_clear_xruns, SIGNAL("clicked()"), SLOT("slot_JackClearXruns()"))
-            self.connect(self.b_jack_configure, SIGNAL("clicked()"), SLOT("slot_showJackSettings()"))
-            self.connect(self.b_jack_render, SIGNAL("clicked()"), SLOT("slot_showRender()"))
-            self.connect(self.cb_buffer_size, SIGNAL("currentIndexChanged(QString)"), SLOT("slot_jackBufferSize_ComboBox(QString)"))
-            self.connect(self.cb_sample_rate, SIGNAL("currentIndexChanged(QString)"), SLOT("slot_jackSampleRate_ComboBox(QString)"))
-            self.connect(self.b_xruns, SIGNAL("clicked()"), SLOT("slot_JackClearXruns()"))
+            self.connect(self.ui.act_jack_clear_xruns, SIGNAL("triggered()"), SLOT("slot_JackClearXruns()"))
+            self.connect(self.ui.act_jack_render, SIGNAL("triggered()"), SLOT("slot_showRender()"))
+            self.connect(self.ui.act_jack_configure, SIGNAL("triggered()"), SLOT("slot_showJackSettings()"))
+            self.connect(self.ui.b_jack_clear_xruns, SIGNAL("clicked()"), SLOT("slot_JackClearXruns()"))
+            self.connect(self.ui.b_jack_configure, SIGNAL("clicked()"), SLOT("slot_showJackSettings()"))
+            self.connect(self.ui.b_jack_render, SIGNAL("clicked()"), SLOT("slot_showRender()"))
+            self.connect(self.ui.cb_buffer_size, SIGNAL("currentIndexChanged(QString)"), SLOT("slot_jackBufferSize_ComboBox(QString)"))
+            self.connect(self.ui.cb_sample_rate, SIGNAL("currentIndexChanged(QString)"), SLOT("slot_jackSampleRate_ComboBox(QString)"))
+            self.connect(self.ui.b_xruns, SIGNAL("clicked()"), SLOT("slot_JackClearXruns()"))
 
         if "buffer-size" in modes:
-            self.connect(self.act_jack_bf_16, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
-            self.connect(self.act_jack_bf_32, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
-            self.connect(self.act_jack_bf_64, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
-            self.connect(self.act_jack_bf_128, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
-            self.connect(self.act_jack_bf_256, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
-            self.connect(self.act_jack_bf_512, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
-            self.connect(self.act_jack_bf_1024, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
-            self.connect(self.act_jack_bf_2048, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
-            self.connect(self.act_jack_bf_4096, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
-            self.connect(self.act_jack_bf_8192, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
+            self.connect(self.ui.act_jack_bf_16, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
+            self.connect(self.ui.act_jack_bf_32, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
+            self.connect(self.ui.act_jack_bf_64, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
+            self.connect(self.ui.act_jack_bf_128, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
+            self.connect(self.ui.act_jack_bf_256, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
+            self.connect(self.ui.act_jack_bf_512, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
+            self.connect(self.ui.act_jack_bf_1024, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
+            self.connect(self.ui.act_jack_bf_2048, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
+            self.connect(self.ui.act_jack_bf_4096, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
+            self.connect(self.ui.act_jack_bf_8192, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
 
         if "transport" in modes:
-            self.connect(self.act_transport_play, SIGNAL("triggered(bool)"), SLOT("slot_transportPlayPause(bool)"))
-            self.connect(self.act_transport_stop, SIGNAL("triggered()"), SLOT("slot_transportStop()"))
-            self.connect(self.act_transport_backwards, SIGNAL("triggered()"), SLOT("slot_transportBackwards()"))
-            self.connect(self.act_transport_forwards, SIGNAL("triggered()"), SLOT("slot_transportForwards()"))
-            self.connect(self.b_transport_play, SIGNAL("clicked(bool)"), SLOT("slot_transportPlayPause(bool)"))
-            self.connect(self.b_transport_stop, SIGNAL("clicked()"), SLOT("slot_transportStop()"))
-            self.connect(self.b_transport_backwards, SIGNAL("clicked()"), SLOT("slot_transportBackwards()"))
-            self.connect(self.b_transport_forwards, SIGNAL("clicked()"), SLOT("slot_transportForwards()"))
-            self.connect(self.label_time, SIGNAL("customContextMenuRequested(QPoint)"), SLOT("slot_transportViewMenu()"))
+            self.connect(self.ui.act_transport_play, SIGNAL("triggered(bool)"), SLOT("slot_transportPlayPause(bool)"))
+            self.connect(self.ui.act_transport_stop, SIGNAL("triggered()"), SLOT("slot_transportStop()"))
+            self.connect(self.ui.act_transport_backwards, SIGNAL("triggered()"), SLOT("slot_transportBackwards()"))
+            self.connect(self.ui.act_transport_forwards, SIGNAL("triggered()"), SLOT("slot_transportForwards()"))
+            self.connect(self.ui.b_transport_play, SIGNAL("clicked(bool)"), SLOT("slot_transportPlayPause(bool)"))
+            self.connect(self.ui.b_transport_stop, SIGNAL("clicked()"), SLOT("slot_transportStop()"))
+            self.connect(self.ui.b_transport_backwards, SIGNAL("clicked()"), SLOT("slot_transportBackwards()"))
+            self.connect(self.ui.b_transport_forwards, SIGNAL("clicked()"), SLOT("slot_transportForwards()"))
+            self.connect(self.ui.label_time, SIGNAL("customContextMenuRequested(QPoint)"), SLOT("slot_transportViewMenu()"))
 
         if "misc" in modes:
             if LINUX:
-                self.connect(self.act_show_logs, SIGNAL("triggered()"), SLOT("slot_showLogs()"))
+                self.connect(self.ui.act_show_logs, SIGNAL("triggered()"), SLOT("slot_showLogs()"))
             else:
-                self.act_show_logs.setEnabled(False)
+                self.ui.act_show_logs.setEnabled(False)