Massive internal fixing

src/catarina.py

@@ -22,7 +22,7 @@ from PyQt4.QtGui import QApplication, QDialog, QDialogButtonBox, QMainWindow, QT
 from PyQt4.QtXml import QDomDocument
 
 # Imports (Custom Stuff)
-import ui_catarina, icons_rc
+import ui_catarina
 import ui_catarina_addgroup, ui_catarina_removegroup, ui_catarina_renamegroup
 import ui_catarina_addport, ui_catarina_removeport, ui_catarina_renameport
 import ui_catarina_connectports, ui_catarina_disconnectports
@@ -808,21 +808,18 @@ class CatarinaMainW(QMainWindow, ui_catarina.Ui_CatarinaMainW):
         content += "</CATARINA>\n"
 
         try:
-          if (open(path, "w").write(content) == False):
-            raiseError
+          open(path, "w").write(content)
         except:
           QMessageBox.critical(self, self.tr("Error"), self.tr("Failed to save file"))
 
     def loadFile(self, path):
-        if (os.path.exists(path) == False):
+        if (not os.path.exists(path)):
           QMessageBox.critical(self, self.tr("Error"), self.tr("The file '%s' does not exist" % (path)))
           self.m_save_path = None
           return
 
         try:
           read = open(path, "r").read()
-          if (not read):
-            raiseError
         except:
           QMessageBox.critical(self, self.tr("Error"), self.tr("Failed to load file"))
           self.m_save_path = None

src/catia.py

@@ -39,6 +39,9 @@ try:
 except:
   haveDBus = False
 
+global a2j_client_name
+a2j_client_name = None
+
 iGroupId   = 0
 iGroupName = 1
 
@@ -276,6 +279,8 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):
           QMessageBox.information(self, self.tr("Port Information"), info)
 
         elif (action == patchcanvas.ACTION_PORT_RENAME):
+          global a2j_client_name
+
           port_id = value1
           port_short_name = unicode2ascii(value_str)
 
@@ -386,7 +391,7 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):
         jacklib.set_session_callback(jack.client, self.JackSessionCallback, None)
         jacklib.on_shutdown(jack.client, self.JackShutdownCallback, None)
 
-        if (JACK2):
+        if (jacklib.JACK2):
           jacklib.set_port_rename_callback(jack.client, self.JackPortRenameCallback, None)
 
     def init_ports(self):
@@ -405,6 +410,8 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):
         a2j_name_list  = []
         port_name_list = c_char_p_p_to_list(jacklib.get_ports(jack.client, "", "", 0))
 
+        global a2j_client_name
+
         h = 0
         for i in range(len(port_name_list)):
           if (port_name_list[i-h].split(":")[0] == a2j_client_name):
@@ -417,8 +424,6 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):
 
         del a2j_name_list
 
-        import hashlib
-
         # Add ports
         for port_name in port_name_list:
           port_ptr = jacklib.port_by_name(jack.client, port_name)
@@ -435,7 +440,6 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):
           port_connection_names = c_char_p_p_to_list(jacklib.port_get_all_connections(jack.client, port_ptr))
 
           for port_con_name in port_connection_names:
-            port_con_ptr = jacklib.port_by_name(jack.client, port_con_name)
             self.canvas_connect_ports(port_name, port_con_name)
 
     def canvas_add_group(self, group_name):
@@ -465,6 +469,8 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):
         patchcanvas.removeGroup(group_id)
 
     def canvas_add_port(self, port_ptr, port_name):
+        global a2j_client_name
+
         port_id  = self.m_last_port_id
         group_id = -1
 
@@ -489,13 +495,11 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):
           port_mode = patchcanvas.PORT_MODE_NULL
 
         if (group_name == a2j_client_name):
-          haveA2J    = True
           port_type  = patchcanvas.PORT_TYPE_MIDI_A2J
           group_name = port_name.replace("%s:" % (a2j_client_name), "", 1).split(" [", 1)[0]
           port_short_name = port_name.split("): ", 1)[1]
 
         else:
-          haveA2J = False
           port_short_name = port_name.replace("%s:" % (group_name), "", 1)
 
           port_type_str = str(jacklib.port_type(port_ptr), encoding="ascii")
@@ -602,7 +606,7 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):
 
     def jackStarted(self):
         if (not jack.client):
-          jack.client = jacklib.client_open_uuid("catia", jacklib.JackNoStartServer|jacklib.JackSessionID, None, "")
+          jack.client = jacklib.client_open("catia", jacklib.JackNoStartServer|jacklib.JackSessionID, None)
           if (not jack.client):
             return self.jackStopped()
 
@@ -719,6 +723,8 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):
             self.a2jStopped()
 
     def DBusReconnect(self):
+        global a2j_client_name
+
         try:
           DBus.jack = DBus.bus.get_object("org.jackaudio.service", "/org/jackaudio/Controller")
           jacksettings.initBus(DBus.bus)
@@ -902,6 +908,8 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):
 
     @pyqtSlot()
     def slot_handleCrash_a2j(self):
+        global a2j_client_name
+
         try:
           DBus.a2j = dbus.Interface(DBus.bus.get_object("org.gna.home.a2jmidid", "/"), "org.gna.home.a2jmidid.control")
           a2j_client_name = str(DBus.a2j.get_jack_client_name())

src/claudia.py

@@ -307,7 +307,7 @@ class ProjectNameW(QDialog, ui_claudia_projectname.Ui_ProjectNameW):
     def slot_checkFolder(self):
         # Create default project folder if the project has not been set yet 
         if (not self.le_path.text()):
-          if (os.path.exists(self.m_proj_folder) == False):
+          if (not os.path.exists(self.m_proj_folder)):
             os.mkdir(self.m_proj_folder)
 
         if (self.le_path.text()):
@@ -405,7 +405,7 @@ class RunCustomW(QDialog, ui_claudia_runcustom.Ui_RunCustomW):
         else:
           self.rb_level_0.setChecked(True)
 
-        if (isRoom == False):
+        if (not isRoom):
           self.rb_level_lash.setEnabled(False)
           self.rb_level_js.setEnabled(False)
 
@@ -865,7 +865,7 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):
         studio_iface = dbus.Interface(DBus.ladish_studio, 'org.ladish.AppSupervisor')
         studio_item  = self.treeWidget.topLevelItem(0)
 
-        graph_version, app_list = DBus.ladish_app_iface.GetAll2()
+        graph_version, app_list = studio_iface.GetAll2()
 
         for app in app_list:
           number, name, active, terminal, level = app
@@ -882,7 +882,7 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):
             text += "L"
           text += level.upper()
           text += "] "
-          if (active == False):
+          if (not active):
             text += "(inactive) "
           text += name
 
@@ -918,7 +918,7 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):
               text += "L"
             text += level.upper()
             text += "] "
-            if (active == False):
+            if (not active):
               text += "(inactive) "
             text += name
 
@@ -976,7 +976,7 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):
 
         # Remove old unused item if needed
         iItem = self.treeWidget.topLevelItem(room_index)
-        if (iItem and iItem.isVisible() == False):
+        if (iItem and not iItem.isVisible()):
           self.treeWidget.takeTopLevelItem(room_index)
 
         # Insert padding of items if needed
@@ -989,12 +989,8 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):
         graph_version, project_properties = room_project_properties
 
         if (len(project_properties) > 0):
-          project_path = str(project_properties['dir'])
-          project_name = str(project_properties['name'])
-          item_string  = " (%s)" % (project_name)
+          item_string  = " (%s)" % (project_properties['name'])
         else:
-          project_path = None
-          project_name = None
           item_string  = ""
 
         prop_obj = [None, None]
@@ -2005,7 +2001,7 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):
 
           if (item and item.type() == ITEM_TYPE_ROOM and item.properties[iItemPropRoomPath] == room_path):
             for j in range(item.childCount()):
-              top_level_item.takeChild(j)
+              item.takeChild(j)
 
             self.treeWidget.takeTopLevelItem(i)
             break
@@ -2083,7 +2079,7 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):
           text += "L"
         text += level.upper()
         text += "] "
-        if (active == False):
+        if (not active):
           text += "(inactive) "
         text += name
 
@@ -2137,7 +2133,7 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):
           text += "L"
         text += level.upper()
         text += "] "
-        if (active == False):
+        if (not active):
           text += "(inactive) "
         text += name
 
@@ -2266,8 +2262,8 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):
     def saveSettings(self):
         self.settings.setValue("Geometry", self.saveGeometry())
         self.settings.setValue("SplitterSizes", self.splitter.saveState())
-        self.settings.setValue("ShowToolbar", self.frame_toolbar.isVisible())
-        self.settings.setValue("ShowStatusbar", self.frame_statusbar.isVisible())
+        self.settings.setValue("ShowToolbar", self.frame_toolbar.isEnabled())
+        self.settings.setValue("ShowStatusbar", self.frame_statusbar.isEnabled())
         self.settings.setValue("TransportView", self.m_selected_transport_view)
         self.settings.setValue("HorizontalScrollBarValue", self.graphicsView.horizontalScrollBar().value())
         self.settings.setValue("VerticalScrollBarValue", self.graphicsView.verticalScrollBar().value())

src/digitalpeakmeter.py

@@ -224,6 +224,8 @@ class DigitalPeakMeter(QWidget):
           painter.setPen(QColor(110, 15, 15, 100))
           painter.drawLine(1, lsmall-(lsmall/1.04), lfull, lsmall-(lsmall/1.04))
 
+        QWidget.paintEvent(self, event)
+
     def resizeEvent(self, event):
         self.updateSizes()
         QWidget.resizeEvent(self, event)

src/jackmeter.py

@@ -131,7 +131,7 @@ if __name__ == '__main__':
 
     # JACK initialization
     jack_status = jacklib.jack_status_t(0)
-    client = jacklib.client_open_uuid("M", jacklib.JackSessionID, jacklib.pointer(jack_status), "")
+    client = jacklib.client_open("M", jacklib.JackSessionID, jacklib.pointer(jack_status))
 
     if not client:
       QMessageBox.critical(None, app.translate("MeterW", "Error"), app.translate("MeterW", "Could not connect to JACK, possible errors:\n%s" % (get_jack_status_error_string(jack_status))))

src/jacksettings.py

@@ -86,13 +86,13 @@ def engineHasFeature(feature):
   return bool(dbus.String(feature) in feature_list)
 
 def getEngineParameter(parameter, error):
-    if (engineHasFeature(parameter) == False):
+    if (not engineHasFeature(parameter)):
       return error
     else:
       return jackctl.GetParameterValue(["engine",parameter])[2]
 
 def setEngineParameter(parameter, value, optional=True):
-    if (engineHasFeature(parameter) == False):
+    if (not engineHasFeature(parameter)):
       return False
     elif (optional):
       if (value != jackctl.GetParameterValue(["engine",parameter])[2]):
@@ -110,13 +110,13 @@ def driverHasFeature(feature):
     return bool(dbus.String(feature) in feature_list)
 
 def getDriverParameter(parameter, error):
-    if (driverHasFeature(parameter) == False):
+    if (not driverHasFeature(parameter)):
       return error
     else:
       return jackctl.GetParameterValue(["driver",parameter])[2]
 
 def setDriverParameter(parameter, value, optional=True):
-    if (driverHasFeature(parameter) == False):
+    if (not driverHasFeature(parameter)):
       return False
     elif (optional):
       if (value != jackctl.GetParameterValue(["driver",parameter])[2]):
@@ -157,7 +157,7 @@ class JackSettingsW(QDialog, ui_settings_jack.Ui_JackSettingsW):
         self.connect(self.buttonBox.button(QDialogButtonBox.Reset), SIGNAL("clicked()"), SLOT("slot_resetJackSettings()"))
 
         self.connect(self.obj_driver_duplex, SIGNAL("clicked(bool)"), SLOT("slot_checkDuplexSelection(bool)"))
-        self.connect(self.obj_server_driver, SIGNAL("currentCellChanged(int, int, int, int)"), SLOT("slot_checkDriverSelection(int, int, int, int)"))
+        self.connect(self.obj_server_driver, SIGNAL("currentCellChanged(int, int, int, int)"), SLOT("slot_checkDriverSelection(int)"))
 
         self.connect(self.obj_driver_capture, SIGNAL("currentIndexChanged(int)"), SLOT("slot_checkALSASelection()"))
         self.connect(self.obj_driver_playback, SIGNAL("currentIndexChanged(int)"), SLOT("slot_checkALSASelection()"))
@@ -201,7 +201,7 @@ class JackSettingsW(QDialog, ui_settings_jack.Ui_JackSettingsW):
         self.obj_server_self_connect_mode.setEnabled(engineHasFeature("self-connect-mode"))
 
         # Disable clock-source if not on Linux
-        if (LINUX == False):
+        if (not LINUX):
           self.obj_server_clock_source.setEnabled(False)
 
     # -------------------------------------------------------------
@@ -232,7 +232,7 @@ class JackSettingsW(QDialog, ui_settings_jack.Ui_JackSettingsW):
           value = dbus.Int32(int(self.obj_server_client_timeout.currentText()))
           setEngineParameter("client-timeout", value, True)
 
-        if (self.obj_server_clock_source.isEnabled() or 1):
+        if (self.obj_server_clock_source.isEnabled()):
           value = None
           if (self.obj_server_clock_source_system.isChecked()):
             if (self.m_server_clock_source_broken):
@@ -472,7 +472,10 @@ class JackSettingsW(QDialog, ui_settings_jack.Ui_JackSettingsW):
             print("JackSettings::saveDriverSettings() - Cannot save midi-driver value")
 
           if (value != None):
-            setDriverParameter("midi-driver", value, True)
+            if (driverHasFeature("midi")):
+              setDriverParameter("midi", value, True)
+            else:
+              setDriverParameter("midi-driver", value, True)
 
         if (self.obj_driver_wait.isEnabled()):
           value = dbus.UInt32(self.obj_driver_wait.value())
@@ -553,7 +556,7 @@ class JackSettingsW(QDialog, ui_settings_jack.Ui_JackSettingsW):
             self.obj_driver_input_latency.setValue(int(value))
           elif (attribute == "output-latency"):
             self.obj_driver_output_latency.setValue(int(value))
-          elif (attribute == "midi-driver"):
+          elif (attribute in ("midi", "midi-driver")):
             value = str(value)
             if (value == "none"):
               self.obj_driver_midi_driver.setCurrentIndex(0)
@@ -611,8 +614,8 @@ class JackSettingsW(QDialog, ui_settings_jack.Ui_JackSettingsW):
 
         self.slot_checkALSASelection()
 
-    @pyqtSlot(int, int, int, int)
-    def slot_checkDriverSelection(self, row, column, prev_row, prev_column):
+    @pyqtSlot(int)
+    def slot_checkDriverSelection(self, row):
         # Save previous settings
         self.saveDriverSettings()
 
@@ -681,8 +684,8 @@ class JackSettingsW(QDialog, ui_settings_jack.Ui_JackSettingsW):
         self.obj_driver_input_latency_label.setEnabled(driverHasFeature("input-latency"))
         self.obj_driver_output_latency.setEnabled(driverHasFeature("output-latency"))
         self.obj_driver_output_latency_label.setEnabled(driverHasFeature("output-latency"))
-        self.obj_driver_midi_driver.setEnabled(driverHasFeature("midi-driver"))
-        self.obj_driver_midi_driver_label.setEnabled(driverHasFeature("midi-driver"))
+        self.obj_driver_midi_driver.setEnabled(driverHasFeature("midi") or driverHasFeature("midi-driver"))
+        self.obj_driver_midi_driver_label.setEnabled(driverHasFeature("midi") or driverHasFeature("midi-driver"))
         self.obj_driver_wait.setEnabled(driverHasFeature("wait"))
         self.obj_driver_wait_label.setEnabled(driverHasFeature("wait"))
         self.obj_driver_verbose.setEnabled(driverHasFeature("verbose"))
@@ -737,20 +740,21 @@ class JackSettingsW(QDialog, ui_settings_jack.Ui_JackSettingsW):
 if __name__ == '__main__':
 
     # Additional imports
-    import sys, icons_rc
+    import icons_rc
+    from sys import argv as sys_argv, exit as sys_exit
     from PyQt4.QtGui import QApplication, QIcon
 
     # App initialization
-    app = QApplication(sys.argv)
+    app = QApplication(sys_argv)
 
     # Connect to DBus
     if (dbus):
       if (initBus(dbus.SessionBus())):
         QMessageBox.critical(None, app.translate("JackSettingsW", "Error"), app.translate("JackSettingsW", "jackdbus is not available!\nIs not possible to configure JACK at this point."))
-        sys.exit(1)
+        sys_exit(1)
     else:
       QMessageBox.critical(None, app.translate("JackSettingsW", "Error"), app.translate("JackSettingsW", "DBus is not available, cannot continue."))
-      sys.exit(1)
+      sys_exit(1)
 
     # Show GUI
     gui = JackSettingsW(None)
@@ -758,4 +762,4 @@ if __name__ == '__main__':
     gui.show()
 
     # App-Loop
-    sys.exit(app.exec_())
+    sys_exit(app.exec_())

src/logs.py

@@ -243,22 +243,22 @@ class LogsW(QDialog, ui_logs.Ui_LogsW):
 
         tab_index = 0
 
-        if (os.path.exists(self.LOG_FILE_JACK) == False):
+        if (not os.path.exists(self.LOG_FILE_JACK)):
           self.LOG_FILE_JACK = None
           self.tabWidget.removeTab(0-tab_index)
           tab_index += 1
 
-        if (os.path.exists(self.LOG_FILE_A2J) == False):
+        if (not os.path.exists(self.LOG_FILE_A2J)):
           self.LOG_FILE_A2J = None
           self.tabWidget.removeTab(1-tab_index)
           tab_index += 1
 
-        if (os.path.exists(self.LOG_FILE_LASH) == False):
+        if (not os.path.exists(self.LOG_FILE_LASH)):
           self.LOG_FILE_LASH = None
           self.tabWidget.removeTab(2-tab_index)
           tab_index += 1
 
-        if (os.path.exists(self.LOG_FILE_LADISH) == False):
+        if (not os.path.exists(self.LOG_FILE_LADISH)):
           self.LOG_FILE_LADISH = None
           self.tabWidget.removeTab(3-tab_index)
           tab_index += 1

src/render.py

@@ -105,7 +105,7 @@ class RenderW(QDialog, ui_render.Ui_RenderW):
 
     @pyqtSlot()
     def slot_renderStart(self):
-        if (os.path.exists(self.le_folder.text()) == False):
+        if (not os.path.exists(self.le_folder.text())):
           QMessageBox.warning(self, self.tr("Warning"), self.tr("The selected directory does not exist. Please choose a valid one."))
           return
 
@@ -255,7 +255,7 @@ class RenderW(QDialog, ui_render.Ui_RenderW):
         time = jacklib.get_current_transport_frame(self.m_jack_client)/self.m_sample_rate
         self.progressBar.setValue(time)
 
-        if (time > self.m_max_time or (self.m_last_time > time and self.m_freewheel == False)):
+        if (time > self.m_max_time or (self.m_last_time > time and not self.m_freewheel)):
           self.slot_renderStop()
 
         self.m_last_time = time

src/shared.py

@@ -38,7 +38,7 @@ else:
   LINUX   = False
   WINDOWS = False
 
-if (WINDOWS == False):
+if (not WINDOWS):
   from signal import signal, SIGINT, SIGTERM, SIGUSR1, SIGUSR2
 
 # Set Version
@@ -56,7 +56,7 @@ HOME = os.getenv("HOME")
 if (HOME == None):
   qWarning("HOME variable not set")
   HOME = "/tmp"
-elif (os.path.exists(HOME) == False):
+elif (not os.path.exists(HOME)):
   qWarning("HOME variable set but not valid")
   HOME = "/tmp"
 
@@ -201,15 +201,15 @@ def getIcon(icon, size=16):
   return QIcon.fromTheme(icon, QIcon(":/%ix%i/%s.png" % (size, size, icon)))
 
 # QLineEdit and QPushButtom combo
-def getAndSetPath(self, currentPath, lineEdit):
-    newPath = QFileDialog.getExistingDirectory(self, self.tr("Set Path"), currentPath, QFileDialog.ShowDirsOnly)
+def getAndSetPath(self_, currentPath, lineEdit):
+    newPath = QFileDialog.getExistingDirectory(self_, self_.tr("Set Path"), currentPath, QFileDialog.ShowDirsOnly)
     if (newPath):
       lineEdit.setText(newPath)
     return newPath
 
 # Custom MessageBox
-def CustomMessageBox(self, icon, title, text, extraText="", buttons=QMessageBox.Yes|QMessageBox.No, defButton=QMessageBox.No):
-    msgBox = QMessageBox(self)
+def CustomMessageBox(self_, icon, title, text, extraText="", buttons=QMessageBox.Yes|QMessageBox.No, defButton=QMessageBox.No):
+    msgBox = QMessageBox(self_)
     msgBox.setIcon(icon)
     msgBox.setWindowTitle(title)
     msgBox.setText(text)
@@ -233,7 +233,7 @@ def set_up_signals(_gui):
     x_gui.connect(x_gui, SIGNAL("SIGUSR2()"), lambda gui=x_gui: showWindow(gui))
     x_gui.connect(x_gui, SIGNAL("SIGTERM()"), SLOT("close()"))
 
-def signal_handler(sig=0, frame=0):
+def signal_handler(sig):
   global x_gui
   if (sig in (SIGINT, SIGTERM)):
     x_gui.emit(SIGNAL("SIGTERM()"))
@@ -242,45 +242,45 @@ def signal_handler(sig=0, frame=0):
   elif (sig == SIGUSR2):
     x_gui.emit(SIGNAL("SIGUSR2()"))
 
-def showWindow(self):
-  if (self.isMaximized()):
-    self.showMaximized()
+def showWindow(self_):
+  if (self_.isMaximized()):
+    self_.showMaximized()
   else:
-    self.showNormal()
+    self_.showNormal()
 
 # Shared Icons
-def setIcons(self, modes):
+def setIcons(self_, modes):
   if ("canvas" in modes):
-    self.act_canvas_arrange.setIcon(getIcon("view-sort-ascending"))
-    self.act_canvas_refresh.setIcon(getIcon("view-refresh"))
-    self.act_canvas_zoom_fit.setIcon(getIcon("zoom-fit-best"))
-    self.act_canvas_zoom_in.setIcon(getIcon("zoom-in"))
-    self.act_canvas_zoom_out.setIcon(getIcon("zoom-out"))
-    self.act_canvas_zoom_100.setIcon(getIcon("zoom-original"))
-    self.act_canvas_print.setIcon(getIcon("document-print"))
-    self.b_canvas_zoom_fit.setIcon(getIcon("zoom-fit-best"))
-    self.b_canvas_zoom_in.setIcon(getIcon("zoom-in"))
-    self.b_canvas_zoom_out.setIcon(getIcon("zoom-out"))
-    self.b_canvas_zoom_100.setIcon(getIcon("zoom-original"))
+    self_.act_canvas_arrange.setIcon(getIcon("view-sort-ascending"))
+    self_.act_canvas_refresh.setIcon(getIcon("view-refresh"))
+    self_.act_canvas_zoom_fit.setIcon(getIcon("zoom-fit-best"))
+    self_.act_canvas_zoom_in.setIcon(getIcon("zoom-in"))
+    self_.act_canvas_zoom_out.setIcon(getIcon("zoom-out"))
+    self_.act_canvas_zoom_100.setIcon(getIcon("zoom-original"))
+    self_.act_canvas_print.setIcon(getIcon("document-print"))
+    self_.b_canvas_zoom_fit.setIcon(getIcon("zoom-fit-best"))
+    self_.b_canvas_zoom_in.setIcon(getIcon("zoom-in"))
+    self_.b_canvas_zoom_out.setIcon(getIcon("zoom-out"))
+    self_.b_canvas_zoom_100.setIcon(getIcon("zoom-original"))
 
   if ("jack" in modes):
-    self.act_jack_clear_xruns.setIcon(getIcon("edit-clear"))
-    self.act_jack_configure.setIcon(getIcon("configure"))
-    self.act_jack_render.setIcon(getIcon("media-record"))
-    self.b_jack_clear_xruns.setIcon(getIcon("edit-clear"))
-    self.b_jack_configure.setIcon(getIcon("configure"))
-    self.b_jack_render.setIcon(getIcon("media-record"))
+    self_.act_jack_clear_xruns.setIcon(getIcon("edit-clear"))
+    self_.act_jack_configure.setIcon(getIcon("configure"))
+    self_.act_jack_render.setIcon(getIcon("media-record"))
+    self_.b_jack_clear_xruns.setIcon(getIcon("edit-clear"))
+    self_.b_jack_configure.setIcon(getIcon("configure"))
+    self_.b_jack_render.setIcon(getIcon("media-record"))
 
   if ("transport" in modes):
-    self.act_transport_play.setIcon(getIcon("media-playback-start"))
-    self.act_transport_stop.setIcon(getIcon("media-playback-stop"))
-    self.act_transport_backwards.setIcon(getIcon("media-seek-backward"))
-    self.act_transport_forwards.setIcon(getIcon("media-seek-forward"))
-    self.b_transport_play.setIcon(getIcon("media-playback-start"))
-    self.b_transport_stop.setIcon(getIcon("media-playback-stop"))
-    self.b_transport_backwards.setIcon(getIcon("media-seek-backward"))
-    self.b_transport_forwards.setIcon(getIcon("media-seek-forward"))
+    self_.act_transport_play.setIcon(getIcon("media-playback-start"))
+    self_.act_transport_stop.setIcon(getIcon("media-playback-stop"))
+    self_.act_transport_backwards.setIcon(getIcon("media-seek-backward"))
+    self_.act_transport_forwards.setIcon(getIcon("media-seek-forward"))
+    self_.b_transport_play.setIcon(getIcon("media-playback-start"))
+    self_.b_transport_stop.setIcon(getIcon("media-playback-stop"))
+    self_.b_transport_backwards.setIcon(getIcon("media-seek-backward"))
+    self_.b_transport_forwards.setIcon(getIcon("media-seek-forward"))
 
   if ("misc" in modes):
-    self.act_quit.setIcon(getIcon("application-exit"))
-    self.act_configure.setIcon(getIcon("configure"))
+    self_.act_quit.setIcon(getIcon("application-exit"))
+    self_.act_configure.setIcon(getIcon("configure"))

src/shared_canvas.py

@@ -24,41 +24,41 @@ from PyQt4.QtGui import QFileDialog, QImage, QPainter, QPrinter, QPrintDialog
 import patchcanvas
 
 # Shared Canvas code
-def canvas_arrange(self):
+def canvas_arrange():
     patchcanvas.arrange()
 
-def canvas_refresh(self):
+def canvas_refresh(self_):
     patchcanvas.clear()
-    self.init_ports()
+    self_.init_ports()
 
-def canvas_zoom_fit(self):
-    self.scene.zoom_fit()
+def canvas_zoom_fit(self_):
+    self_.scene.zoom_fit()
 
-def canvas_zoom_in(self):
-    self.scene.zoom_in()
+def canvas_zoom_in(self_):
+    self_.scene.zoom_in()
 
-def canvas_zoom_out(self):
-    self.scene.zoom_out()
+def canvas_zoom_out(self_):
+    self_.scene.zoom_out()
 
-def canvas_zoom_reset(self):
-    self.scene.zoom_reset()
+def canvas_zoom_reset(self_):
+    self_.scene.zoom_reset()
 
-def canvas_print(self):
-    self.scene.clearSelection()
-    self.m_export_printer = QPrinter()
-    dialog = QPrintDialog(self.m_export_printer, self)
+def canvas_print(self_):
+    self_.scene.clearSelection()
+    self_.m_export_printer = QPrinter()
+    dialog = QPrintDialog(self_.m_export_printer, self_)
     if (dialog.exec_()):
-      painter = QPainter(self.m_export_printer)
+      painter = QPainter(self_.m_export_printer)
       painter.setRenderHint(QPainter.Antialiasing)
       painter.setRenderHint(QPainter.TextAntialiasing)
-      self.scene.render(painter)
+      self_.scene.render(painter)
 
-def canvas_save_image(self):
-    newPath = QFileDialog.getSaveFileName(self, self.tr("Save Image"), filter=self.tr("PNG Image (*.png);;JPEG Image (*.jpg)"))
+def canvas_save_image(self_):
+    newPath = QFileDialog.getSaveFileName(self_, self_.tr("Save Image"), filter=self_.tr("PNG Image (*.png);;JPEG Image (*.jpg)"))
     print(newPath)
 
     if (newPath):
-      self.scene.clearSelection()
+      self_.scene.clearSelection()
       if (newPath.endswith((".jpg", ".jpG", ".jPG", ".JPG", ".JPg", ".Jpg"))):
         img_format = "JPG"
       elif (newPath.endswith((".png", ".pnG", ".pNG", ".PNG", ".PNg", ".Png"))):
@@ -68,25 +68,25 @@ def canvas_save_image(self):
         img_format = "PNG"
         newPath   += ".png"
 
-      self.m_export_image = QImage(self.scene.sceneRect().width(), self.scene.sceneRect().height(), QImage.Format_RGB32)
-      painter = QPainter(self.m_export_image)
+      self_.m_export_image = QImage(self_.scene.sceneRect().width(), self_.scene.sceneRect().height(), QImage.Format_RGB32)
+      painter = QPainter(self_.m_export_image)
       painter.setRenderHint(QPainter.Antialiasing)
       painter.setRenderHint(QPainter.TextAntialiasing)
-      self.scene.render(painter)
-      self.m_export_image.save(newPath, img_format, 100)
+      self_.scene.render(painter)
+      self_.m_export_image.save(newPath, img_format, 100)
 
 # Shared Connections
-def setCanvasConnections(self):
-  self.act_canvas_arrange.setEnabled(False)
-  self.connect(self.act_canvas_arrange, SIGNAL("triggered()"), lambda: canvas_arrange(self))
-  self.connect(self.act_canvas_refresh, SIGNAL("triggered()"), lambda: canvas_refresh(self))
-  self.connect(self.act_canvas_zoom_fit, SIGNAL("triggered()"), lambda: canvas_zoom_fit(self))
-  self.connect(self.act_canvas_zoom_in, SIGNAL("triggered()"), lambda: canvas_zoom_in(self))
-  self.connect(self.act_canvas_zoom_out, SIGNAL("triggered()"), lambda: canvas_zoom_out(self))
-  self.connect(self.act_canvas_zoom_100, SIGNAL("triggered()"), lambda: canvas_zoom_reset(self))
-  self.connect(self.act_canvas_print, SIGNAL("triggered()"), lambda: canvas_print(self))
-  self.connect(self.act_canvas_save_image, SIGNAL("triggered()"), lambda: canvas_save_image(self))
-  self.connect(self.b_canvas_zoom_fit, SIGNAL("clicked()"), lambda: canvas_zoom_fit(self))
-  self.connect(self.b_canvas_zoom_in, SIGNAL("clicked()"), lambda: canvas_zoom_in(self))
-  self.connect(self.b_canvas_zoom_out, SIGNAL("clicked()"), lambda: canvas_zoom_out(self))
-  self.connect(self.b_canvas_zoom_100, SIGNAL("clicked()"), lambda: canvas_zoom_reset(self))
+def setCanvasConnections(self_):
+  self_.act_canvas_arrange.setEnabled(False)
+  self_.connect(self_.act_canvas_arrange, SIGNAL("triggered()"), lambda: canvas_arrange())
+  self_.connect(self_.act_canvas_refresh, SIGNAL("triggered()"), lambda: canvas_refresh(self_))
+  self_.connect(self_.act_canvas_zoom_fit, SIGNAL("triggered()"), lambda: canvas_zoom_fit(self_))
+  self_.connect(self_.act_canvas_zoom_in, SIGNAL("triggered()"), lambda: canvas_zoom_in(self_))
+  self_.connect(self_.act_canvas_zoom_out, SIGNAL("triggered()"), lambda: canvas_zoom_out(self_))
+  self_.connect(self_.act_canvas_zoom_100, SIGNAL("triggered()"), lambda: canvas_zoom_reset(self_))
+  self_.connect(self_.act_canvas_print, SIGNAL("triggered()"), lambda: canvas_print(self_))
+  self_.connect(self_.act_canvas_save_image, SIGNAL("triggered()"), lambda: canvas_save_image(self_))
+  self_.connect(self_.b_canvas_zoom_fit, SIGNAL("clicked()"), lambda: canvas_zoom_fit(self_))
+  self_.connect(self_.b_canvas_zoom_in, SIGNAL("clicked()"), lambda: canvas_zoom_in(self_))
+  self_.connect(self_.b_canvas_zoom_out, SIGNAL("clicked()"), lambda: canvas_zoom_out(self_))
+  self_.connect(self_.b_canvas_zoom_100, SIGNAL("clicked()"), lambda: canvas_zoom_reset(self_))

src/shared_jack.py

@@ -26,12 +26,9 @@ from shared import *
 from jacklib_helpers import *
 
 # Have JACK2 ?
-try:
-  JACK2 = True
+if (jacklib.JACK2):
   version_str = str(jacklib.get_version_string(), encoding="ascii")
   print("Using JACK2, version %s" % (version_str))
-except:
-  JACK2 = False
 
 # Can Render ?
 for iPATH in PATH:
@@ -92,88 +89,88 @@ jack.client = None
 # -------------------------------------------------------------
 # Property change calls
 
-def jack_buffer_size(self, buffer_size):
-    if (self.m_buffer_size != buffer_size):
+def jack_buffer_size(self_, buffer_size):
+    if (self_.m_buffer_size != buffer_size):
       if (jack.client):
         failed = bool(jacklib.set_buffer_size(jack.client, buffer_size) != 0)
       else:
         failed = bool(jacksettings.setBufferSize(buffer_size))
 
       if (failed):
-        print("Failed to change buffer-size as %i, reset to %i" % (buffer_size, self.m_buffer_size))
-        setBufferSize(self, self.m_buffer_size, True)
+        print("Failed to change buffer-size as %i, reset to %i" % (buffer_size, self_.m_buffer_size))
+        setBufferSize(self_, self_.m_buffer_size, True)
 
-def jack_sample_rate(self, sample_rate):
+def jack_sample_rate(self_, sample_rate):
     if (jack.client):
-      setSampleRate(self, sample_rate, True)
+      setSampleRate(self_, sample_rate, True)
     else:
       if (jacksettings.setSampleRate(sample_rate)):
-        setSampleRate(self, sample_rate)
+        setSampleRate(self_, sample_rate)
 
-@pyqtSlot(str)
-def slot_jackBufferSize_ComboBox(self, text):
-    if (not text or text.isdigit() == False):
+#@pyqtSlot(str)
+def slot_jackBufferSize_ComboBox(self_, text):
+    if (not text or not text.isdigit()):
       return
-    jack_buffer_size(self, int(text))
+    jack_buffer_size(self_, int(text))
 
-@pyqtSlot(int)
-def slot_jackBufferSize_Menu(self, buffer_size):
-    jack_buffer_size(self, buffer_size)
+#@pyqtSlot(int)
+def slot_jackBufferSize_Menu(self_, buffer_size):
+    jack_buffer_size(self_, buffer_size)
 
-@pyqtSlot(str)
-def slot_jackSampleRate_ComboBox(self, text):
-    if (not text or text.isdigit() == False):
+#@pyqtSlot(str)
+def slot_jackSampleRate_ComboBox(self_, text):
+    if (not text or not text.isdigit()):
       return
-    jack_sample_rate(self, int(text))
+    jack_sample_rate(self_, int(text))
 
 # -------------------------------------------------------------
 # Transport calls
 
-def setTransportView(self, view):
+def setTransportView(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)
+      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)
+      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)
+      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
+      self_.m_selected_transport_view = None
 
-@pyqtSlot(bool)
-def slot_transportPlayPause(self, play):
+#@pyqtSlot(bool)
+def slot_transportPlayPause(self_, play):
     if (not jack.client): return
     if (play):
       jacklib.transport_start(jack.client)
     else:
       jacklib.transport_stop(jack.client)
-    refreshTransport(self)
+    refreshTransport(self_)
 
-@pyqtSlot()
-def slot_transportStop(self):
+#@pyqtSlot()
+def slot_transportStop(self_):
     if (not jack.client): return
     jacklib.transport_stop(jack.client)
     jacklib.transport_locate(jack.client, 0)
-    refreshTransport(self)
+    refreshTransport(self_)
 
-@pyqtSlot()
-def slot_transportBackwards(self):
+#@pyqtSlot()
+def slot_transportBackwards():
     if (not jack.client): return
     new_frame = jacklib.get_current_transport_frame(jack.client)-100000
     if (new_frame < 0): new_frame = 0
     jacklib.transport_locate(jack.client, new_frame)
 
-@pyqtSlot()
-def slot_transportForwards(self):
+#@pyqtSlot()
+def slot_transportForwards():
     if (not jack.client): return
     new_frame = jacklib.get_current_transport_frame(jack.client)+100000
     jacklib.transport_locate(jack.client, new_frame)
 
-@pyqtSlot()
-def slot_transportViewMenu(self):
-    menu = QMenu(self)
+#@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")
@@ -182,44 +179,44 @@ def slot_transportViewMenu(self):
     act_t_bbt.setCheckable(True)
     act_t_fr.setCheckable(True)
 
-    if (self.m_selected_transport_view == TRANSPORT_VIEW_HMS):
+    if (self_.m_selected_transport_view == TRANSPORT_VIEW_HMS):
       act_t_hms.setChecked(True)
-    elif (self.m_selected_transport_view == TRANSPORT_VIEW_BBT):
+    elif (self_.m_selected_transport_view == TRANSPORT_VIEW_BBT):
       act_t_bbt.setChecked(True)
-    elif (self.m_selected_transport_view == TRANSPORT_VIEW_FRAMES):
+    elif (self_.m_selected_transport_view == TRANSPORT_VIEW_FRAMES):
       act_t_fr.setChecked(True)
 
     act_selected = menu.exec_(QCursor().pos())
 
     if (act_selected == act_t_hms):
-      setTransportView(self, TRANSPORT_VIEW_HMS)
+      setTransportView(self_, TRANSPORT_VIEW_HMS)
     elif (act_selected == act_t_bbt):
-      setTransportView(self, TRANSPORT_VIEW_BBT)
+      setTransportView(self_, TRANSPORT_VIEW_BBT)
     elif (act_selected == act_t_fr):
-      setTransportView(self, TRANSPORT_VIEW_FRAMES)
+      setTransportView(self_, TRANSPORT_VIEW_FRAMES)
 
 # -------------------------------------------------------------
 # Refresh GUI stuff
 
-def refreshDSPLoad(self):
+def refreshDSPLoad(self_):
     if (not jack.client): return
-    setDSPLoad(self, int(jacklib.cpu_load(jack.client)))
+    setDSPLoad(self_, int(jacklib.cpu_load(jack.client)))
 
-def refreshTransport(self):
+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):
+    if (self_.m_selected_transport_view == TRANSPORT_VIEW_HMS):
       frame = pos.frame
-      time  = frame / self.m_sample_rate
+      time  = frame / self_.m_sample_rate
       secs  = time % 60
       mins  = (time / 60) % 60
       hrs   = (time / 3600) % 60
-      self.label_time.setText("%02i:%02i:%02i" % (hrs, mins, secs))
+      self_.label_time.setText("%02i:%02i:%02i" % (hrs, mins, secs))
 
-    elif (self.m_selected_transport_view == TRANSPORT_VIEW_BBT):
+    elif (self_.m_selected_transport_view == TRANSPORT_VIEW_BBT):
       if (pos.valid & jacklib.JackPositionBBT):
         bar  = pos.bar
         beat = pos.beat
@@ -227,83 +224,84 @@ def refreshTransport(self):
         if (bar == 0):
           beat = 0
           tick = 0
-        self.label_time.setText("%03i|%02i|%04i" % (bar, beat, tick))
+        self_.label_time.setText("%03i|%02i|%04i" % (bar, beat, tick))
       else:
-        self.label_time.setText("000|00|0000")
+        self_.label_time.setText("000|00|0000")
 
-    elif (self.m_selected_transport_view == TRANSPORT_VIEW_FRAMES):
+    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
-      self.label_time.setText("%03i'%03i'%03i" % (frame3, frame2, frame1))
+      self_.label_time.setText("%03i'%03i'%03i" % (frame3, frame2, 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("")
+      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); }")
+      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
+    self_.m_last_bpm = pos.beats_per_minute
 
-    if (state != self.m_last_transport_state):
+    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)
+        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
+        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, forced=False):
-    if (self.m_buffer_size == buffer_size and not forced):
+def setBufferSize(self_, buffer_size, forced=False):
+    if (self_.m_buffer_size == buffer_size and not forced):
       return
 
-    self.m_buffer_size = buffer_size
+    self_.m_buffer_size = buffer_size
     if (buffer_size):
       if (buffer_size == 16):
-        self.cb_buffer_size.setCurrentIndex(0)
+        self_.cb_buffer_size.setCurrentIndex(0)
       elif (buffer_size == 32):
-        self.cb_buffer_size.setCurrentIndex(1)
+        self_.cb_buffer_size.setCurrentIndex(1)
       elif (buffer_size == 64):
-        self.cb_buffer_size.setCurrentIndex(2)
+        self_.cb_buffer_size.setCurrentIndex(2)
       elif (buffer_size == 128):
-        self.cb_buffer_size.setCurrentIndex(3)
+        self_.cb_buffer_size.setCurrentIndex(3)
       elif (buffer_size == 256):
-        self.cb_buffer_size.setCurrentIndex(4)
+        self_.cb_buffer_size.setCurrentIndex(4)
       elif (buffer_size == 512):
-        self.cb_buffer_size.setCurrentIndex(5)
+        self_.cb_buffer_size.setCurrentIndex(5)
       elif (buffer_size == 1024):
-        self.cb_buffer_size.setCurrentIndex(6)
+        self_.cb_buffer_size.setCurrentIndex(6)
       elif (buffer_size == 2048):
-        self.cb_buffer_size.setCurrentIndex(7)
+        self_.cb_buffer_size.setCurrentIndex(7)
       elif (buffer_size == 4096):
-        self.cb_buffer_size.setCurrentIndex(8)
+        self_.cb_buffer_size.setCurrentIndex(8)
       elif (buffer_size == 8192):
-        self.cb_buffer_size.setCurrentIndex(9)
+        self_.cb_buffer_size.setCurrentIndex(9)
       else:
-        QMessageBox.warning(self, self.tr("Warning"), self.tr("Invalid JACK buffer-size requested: %i" % (buffer_size)))
+        QMessageBox.warning(self_, self_.tr("Warning"), self_.tr("Invalid JACK buffer-size requested: %i" % (buffer_size)))
 
-    if ("act_jack_bf_list" in dir(self)):
+    if ("act_jack_bf_list" in dir(self_)):
       if (buffer_size):
-        for act_bf in self.act_jack_bf_list:
+        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):
+            if (not act_bf.isChecked()):
               act_bf.setChecked(True)
           else:
             if (act_bf.isChecked()):
@@ -314,104 +312,104 @@ def setBufferSize(self, buffer_size, forced=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):
+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"
+      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_next_sample_rate = sample_rate
+          self_.m_next_sample_rate = sample_rate
         else:
-          self.m_next_sample_rate = 0
+          self_.m_next_sample_rate = 0
 
     # not future
     else:
-      self.m_sample_rate = sample_rate
-      self.m_next_sample_rate = 0
+      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)
 
-      self.cb_sample_rate.setItemText(i, sample_rate_str)
+      self_.cb_sample_rate.setItemText(i, sample_rate_str)
 
-      if (self.m_sample_rate == sample_rate):
-        self.cb_sample_rate.setCurrentIndex(i)
+      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 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 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"))
+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_()
+def slot_showJackSettings(self_):
+    jacksettings.JackSettingsW(self_).exec_()
 
     if (not jack.client):
       # Force update of gui widgets
-      self.jackStopped()
+      self_.jackStopped()
 
 @pyqtSlot()
-def slot_showLogs(self):
-    logs.LogsW(self).show()
+def slot_showLogs(self_):
+    logs.LogsW(self_).show()
 
 @pyqtSlot()
-def slot_showRender(self):
-    render.RenderW(self).exec_()
+def slot_showRender(self_):
+    render.RenderW(self_).exec_()
 
 # -------------------------------------------------------------
 # Shared Connections
 
-def setJackConnections(self, modes):
+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: slot_jackBufferSize_ComboBox(self, self.cb_buffer_size.currentText()))
-    self.connect(self.cb_sample_rate, SIGNAL("currentIndexChanged(QString)"), lambda: slot_jackSampleRate_ComboBox(self, self.cb_sample_rate.currentText()))
-    self.connect(self.b_xruns, SIGNAL("clicked()"), SLOT("slot_JackClearXruns()"))
+    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: slot_jackBufferSize_ComboBox(self_, self_.cb_buffer_size.currentText()))
+    self_.connect(self_.cb_sample_rate, SIGNAL("currentIndexChanged(QString)"), lambda: slot_jackSampleRate_ComboBox(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: slot_jackBufferSize_Menu(self, 16))
-    self.connect(self.act_jack_bf_32, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 32))
-    self.connect(self.act_jack_bf_64, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 64))
-    self.connect(self.act_jack_bf_128, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 128))
-    self.connect(self.act_jack_bf_256, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 256))
-    self.connect(self.act_jack_bf_512, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 512))
-    self.connect(self.act_jack_bf_1024, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 1024))
-    self.connect(self.act_jack_bf_2048, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 2048))
-    self.connect(self.act_jack_bf_4096, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 4096))
-    self.connect(self.act_jack_bf_8192, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 8192))
+    self_.connect(self_.act_jack_bf_16, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 16))
+    self_.connect(self_.act_jack_bf_32, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 32))
+    self_.connect(self_.act_jack_bf_64, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 64))
+    self_.connect(self_.act_jack_bf_128, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 128))
+    self_.connect(self_.act_jack_bf_256, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 256))
+    self_.connect(self_.act_jack_bf_512, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 512))
+    self_.connect(self_.act_jack_bf_1024, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 1024))
+    self_.connect(self_.act_jack_bf_2048, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 2048))
+    self_.connect(self_.act_jack_bf_4096, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 4096))
+    self_.connect(self_.act_jack_bf_8192, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 8192))
 
   if ("transport" in modes):
-    self.connect(self.act_transport_play, SIGNAL("triggered(bool)"),  lambda: slot_transportPlayPause(self, self.act_transport_play.isChecked()))
-    self.connect(self.act_transport_stop, SIGNAL("triggered()"),      lambda: slot_transportStop(self))
-    self.connect(self.act_transport_backwards, SIGNAL("triggered()"), lambda: slot_transportBackwards(self))
-    self.connect(self.act_transport_forwards, SIGNAL("triggered()"),  lambda: slot_transportForwards(self))
-    self.connect(self.b_transport_play, SIGNAL("clicked(bool)"),  lambda: slot_transportPlayPause(self, self.b_transport_play.isChecked()))
-    self.connect(self.b_transport_stop, SIGNAL("clicked()"),      lambda: slot_transportStop(self))
-    self.connect(self.b_transport_backwards, SIGNAL("clicked()"), lambda: slot_transportBackwards(self))
-    self.connect(self.b_transport_forwards, SIGNAL("clicked()"),  lambda: slot_transportForwards(self))
-    self.connect(self.label_time, SIGNAL("customContextMenuRequested(QPoint)"), lambda: slot_transportViewMenu(self))
+    self_.connect(self_.act_transport_play, SIGNAL("triggered(bool)"),  lambda: slot_transportPlayPause(self_, self_.act_transport_play.isChecked()))
+    self_.connect(self_.act_transport_stop, SIGNAL("triggered()"),      lambda: slot_transportStop(self_))
+    self_.connect(self_.act_transport_backwards, SIGNAL("triggered()"), lambda: slot_transportBackwards())
+    self_.connect(self_.act_transport_forwards, SIGNAL("triggered()"),  lambda: slot_transportForwards())
+    self_.connect(self_.b_transport_play, SIGNAL("clicked(bool)"),  lambda: slot_transportPlayPause(self_, self_.b_transport_play.isChecked()))
+    self_.connect(self_.b_transport_stop, SIGNAL("clicked()"),      lambda: slot_transportStop(self_))
+    self_.connect(self_.b_transport_backwards, SIGNAL("clicked()"), lambda: slot_transportBackwards())
+    self_.connect(self_.b_transport_forwards, SIGNAL("clicked()"),  lambda: slot_transportForwards())
+    self_.connect(self_.label_time, SIGNAL("customContextMenuRequested(QPoint)"), lambda: slot_transportViewMenu(self_))
 
   if ("misc" in modes):
     if (LINUX):
-      self.connect(self.act_show_logs, SIGNAL("triggered()"), lambda: slot_showLogs(self))
+      self_.connect(self_.act_show_logs, SIGNAL("triggered()"), lambda: slot_showLogs(self_))
     else:
-      self.act_show_logs.setEnabled(False)
+      self_.act_show_logs.setEnabled(False)

src/shared_settings.py

@@ -52,7 +52,7 @@ def setDefaultProjectFolder(folder):
 
 # Settings Dialog
 class SettingsW(QDialog, ui_settings_app.Ui_SettingsW):
-    def __init__(self, parent, appName, hasGL):
+    def __init__(self, parent, appName, hasOpenGL):
         QDialog.__init__(self, parent)
         self.setupUi(self)
 
@@ -84,7 +84,7 @@ class SettingsW(QDialog, ui_settings_app.Ui_SettingsW):
         self.settings = self.parent().settings
         self.loadSettings()
 
-        if not hasGL:
+        if (not hasOpenGL):
           self.cb_canvas_use_opengl.setChecked(False)
           self.cb_canvas_use_opengl.setEnabled(False)
 

src/ui/claudia.ui

@@ -1416,5 +1416,37 @@
     </hint>
    </hints>
   </connection>
+  <connection>
+   <sender>act_settings_show_toolbar</sender>
+   <signal>triggered(bool)</signal>
+   <receiver>frame_toolbar</receiver>
+   <slot>setEnabled(bool)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>438</x>
+     <y>52</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>act_settings_show_statusbar</sender>
+   <signal>triggered(bool)</signal>
+   <receiver>frame_statusbar</receiver>
+   <slot>setEnabled(bool)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>438</x>
+     <y>546</y>
+    </hint>
+   </hints>
+  </connection>
  </connections>
 </ui>

src/xycontroller.py

@@ -591,7 +591,7 @@ if __name__ == '__main__':
 
     # Start jack
     jack_status = jacklib.jack_status_t(0)
-    jack_client = jacklib.client_open_uuid("XY-Controller", jacklib.JackSessionID, jacklib.pointer(jack_status), "")
+    jack_client = jacklib.client_open("XY-Controller", jacklib.JackSessionID, jacklib.pointer(jack_status))
 
     if not jack_client:
       QMessageBox.critical(None, app.translate("XYControllerW", "Error"), app.translate("XYControllerW", "Could not connect to JACK, possible errors:\n%s" % (get_jack_status_error_string(jack_status))))