More cleanup

src/claudia.py

@@ -16,14 +16,17 @@
 #
 # For a full copy of the GNU General Public License see the COPYING file
 
+# ------------------------------------------------------------------------------------------------------------
 # Imports (Global)
+
 from time import ctime
 from PyQt4.QtCore import QPointF
 from PyQt4.QtGui import QAction, QApplication, QVBoxLayout, QTableWidgetItem, QTreeWidgetItem
 
+# ------------------------------------------------------------------------------------------------------------
 # Imports (Custom Stuff)
-import claudia_launcher
-import systray
+
+import claudia_launcher, systray
 import ui_claudia
 import ui_claudia_studioname, ui_claudia_studiolist
 import ui_claudia_createroom, ui_claudia_projectname, ui_claudia_projectproperties
@@ -32,11 +35,8 @@ from shared_jack import *
 from shared_canvas import *
 from shared_settings import *
 
-try:
-    from PyQt4.QtOpenGL import QGLWidget
-    hasGL = True
-except:
-    hasGL = False
+# ------------------------------------------------------------------------------------------------------------
+# Try Import DBus
 
 try:
     import dbus
@@ -45,6 +45,18 @@ try:
 except:
     haveDBus = False
 
+# ------------------------------------------------------------------------------------------------------------
+# Try Import OpenGL
+
+try:
+    from PyQt4.QtOpenGL import QGLWidget
+    hasGL = True
+except:
+    hasGL = False
+
+# ------------------------------------------------------------------------------------------------------------
+# Static Variables
+
 # NOTE - set to true when supported
 USE_CLAUDIA_ADD_NEW = True
 
@@ -151,11 +163,15 @@ DEFAULT_CANVAS_HEIGHT = 2400
 
 RECENT_PROJECTS_STORE_MAX_ITEMS = 50
 
-# set default project folder
+# ------------------------------------------------------------------------------------------------------------
+# Set default project folder
+
 DEFAULT_PROJECT_FOLDER = os.path.join(HOME, "ladish-projects")
 setDefaultProjectFolder(DEFAULT_PROJECT_FOLDER)
 
+# ------------------------------------------------------------------------------------------------------------
 # Studio Name Dialog
+
 class StudioNameW(QDialog, ui_claudia_studioname.Ui_StudioNameW):
     NEW = 1
     RENAME = 2
@@ -552,14 +568,25 @@ class ClaudiaLauncherW(QDialog):
         QDialog.done(self, r)
         self.close()
 
-# Main Window
+# ------------------------------------------------------------------------------------------------------------
+# Claudia Main Window
+
 class ClaudiaMainW(AbstractJackW, ui_claudia.Ui_ClaudiaMainW):
     def __init__(self, parent=None):
         AbstractJackW.__init__(self, parent, "Claudia")
         self.setupUi(self)
 
+        self.m_lastItemType = None
+        self.m_lastRoomPath = None
+
+        self.m_crashedJACK   = False
+        self.m_crashedLADISH = False
+
         self.loadSettings(True)
 
+        # -------------------------------------------------------------
+        # Set-up GUI
+
         setIcons(self, ["canvas", "jack", "transport"])
 
         self.act_studio_new.setIcon(getIcon("document-new"))
@@ -597,7 +624,18 @@ class ClaudiaMainW(AbstractJackW, ui_claudia.Ui_ClaudiaMainW):
         self.act_quit.setIcon(getIcon("application-exit"))
         self.act_settings_configure.setIcon(getIcon("configure"))
 
-        # Global Systray
+        self.cb_buffer_size.clear()
+        self.cb_sample_rate.clear()
+
+        for buffer_size in BUFFER_SIZE_LIST:
+            self.cb_buffer_size.addItem(str(buffer_size))
+
+        for sample_rate in SAMPLE_RATE_LIST:
+            self.cb_sample_rate.addItem(str(sample_rate))
+
+        # -------------------------------------------------------------
+        # Set-up Systray
+
         if self.m_savedSettings["Main/UseSystemTray"]:
             self.systray = systray.GlobalSysTray(self, "Claudia", "claudia")
 
@@ -650,43 +688,36 @@ class ClaudiaMainW(AbstractJackW, ui_claudia.Ui_ClaudiaMainW):
         else:
             self.systray = None
 
-        self.m_last_item_type = None
-        self.m_last_room_path = None
-
-        self.m_crashedJACK   = False
-        self.m_crashedLADISH = False
-
         # -------------------------------------------------------------
         # Set-up Canvas
 
         self.scene = patchcanvas.PatchScene(self, self.graphicsView)
         self.graphicsView.setScene(self.scene)
         self.graphicsView.setRenderHint(QPainter.Antialiasing, bool(self.m_savedSettings["Canvas/Antialiasing"] == patchcanvas.ANTIALIASING_FULL))
-        self.graphicsView.setRenderHint(QPainter.TextAntialiasing, self.m_savedSettings["Canvas/TextAntialiasing"])
         if self.m_savedSettings["Canvas/UseOpenGL"] and hasGL:
             self.graphicsView.setViewport(QGLWidget(self.graphicsView))
             self.graphicsView.setRenderHint(QPainter.HighQualityAntialiasing, self.m_savedSettings["Canvas/HighQualityAntialiasing"])
 
-        p_options = patchcanvas.options_t()
-        p_options.theme_name       = self.m_savedSettings["Canvas/Theme"]
-        p_options.auto_hide_groups = self.m_savedSettings["Canvas/AutoHideGroups"]
-        p_options.use_bezier_lines = self.m_savedSettings["Canvas/UseBezierLines"]
-        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 = True
-        p_features.port_info    = True
-        p_features.port_rename  = True
-        p_features.handle_group_pos = False
-
-        patchcanvas.setOptions(p_options)
-        patchcanvas.setFeatures(p_features)
+        pOptions = patchcanvas.options_t()
+        pOptions.theme_name       = self.m_savedSettings["Canvas/Theme"]
+        pOptions.auto_hide_groups = self.m_savedSettings["Canvas/AutoHideGroups"]
+        pOptions.use_bezier_lines = self.m_savedSettings["Canvas/UseBezierLines"]
+        pOptions.antialiasing     = self.m_savedSettings["Canvas/Antialiasing"]
+        pOptions.eyecandy         = self.m_savedSettings["Canvas/EyeCandy"]
+
+        pFeatures = patchcanvas.features_t()
+        pFeatures.group_info   = False
+        pFeatures.group_rename = True
+        pFeatures.port_info    = True
+        pFeatures.port_rename  = True
+        pFeatures.handle_group_pos = False
+
+        patchcanvas.setOptions(pOptions)
+        patchcanvas.setFeatures(pFeatures)
         patchcanvas.init("Claudia", self.scene, self.canvasCallback, DEBUG)
 
-        patchcanvas.setInitialPos(DEFAULT_CANVAS_WIDTH / 2, DEFAULT_CANVAS_HEIGHT / 2)
         patchcanvas.setCanvasSize(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT)
+        patchcanvas.setInitialPos(DEFAULT_CANVAS_WIDTH / 2, DEFAULT_CANVAS_HEIGHT / 2)
         self.graphicsView.setSceneRect(0, 0, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT)
 
         # -------------------------------------------------------------
@@ -695,21 +726,10 @@ class ClaudiaMainW(AbstractJackW, ui_claudia.Ui_ClaudiaMainW):
         self.miniCanvasPreview.setRealParent(self)
         self.miniCanvasPreview.setViewTheme(patchcanvas.canvas.theme.rubberband_brush, patchcanvas.canvas.theme.rubberband_pen.color())
         self.miniCanvasPreview.init(self.scene, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT)
+        QTimer.singleShot(100, self, SLOT("slot_miniCanvasInit()"))
 
         # -------------------------------------------------------------
-        # Set-up GUI
-
-        self.cb_buffer_size.clear()
-        self.cb_sample_rate.clear()
-
-        for buffer_size in BUFFER_SIZE_LIST:
-            self.cb_buffer_size.addItem(str(buffer_size))
-
-        for sample_rate in SAMPLE_RATE_LIST:
-            self.cb_sample_rate.addItem(str(sample_rate))
-
-        # -------------------------------------------------------------
-        # ...
+        # Check DBus
 
         if DBus.jack.IsStarted():
             self.jackStarted()
@@ -726,9 +746,15 @@ class ClaudiaMainW(AbstractJackW, ui_claudia.Ui_ClaudiaMainW):
         else:
             self.studioUnloaded()
 
+        # -------------------------------------------------------------
+        # Set-up Timers
+
         self.m_timer120 = self.startTimer(self.m_savedSettings["Main/RefreshInterval"])
         self.m_timer600 = self.startTimer(self.m_savedSettings["Main/RefreshInterval"] * 5)
 
+        # -------------------------------------------------------------
+        # Set-up Connections
+
         setCanvasConnections(self)
         setJackConnections(self, ["jack", "transport", "misc"])
 
@@ -826,11 +852,13 @@ class ClaudiaMainW(AbstractJackW, ui_claudia.Ui_ClaudiaMainW):
         self.connect(self, SIGNAL("JackSampleRateCallback(int)"), SLOT("slot_JackSampleRateCallback(int)"))
         self.connect(self, SIGNAL("JackShutdownCallback()"), SLOT("slot_JackShutdownCallback()"))
 
-        # DBus Stuff
+        # -------------------------------------------------------------
+        # Set-up DBus
+
         DBus.bus.add_signal_receiver(self.DBusSignalReceiver, destination_keyword='dest', path_keyword='path',
             member_keyword='member', interface_keyword='interface', sender_keyword='sender', )
 
-        QTimer.singleShot(100, self, SLOT("slot_miniCanvasInit()"))
+        # -------------------------------------------------------------
 
     def canvasCallback(self, action, value1, value2, value_str):
         if action == patchcanvas.ACTION_GROUP_INFO:
@@ -974,8 +1002,8 @@ class ClaudiaMainW(AbstractJackW, ui_claudia.Ui_ClaudiaMainW):
         self.treeWidget.insertTopLevelItem(0, studio_item)
         self.treeWidget.setCurrentItem(studio_item)
 
-        self.m_last_item_type = ITEM_TYPE_STUDIO
-        self.m_last_room_path = None
+        self.m_lastItemType = ITEM_TYPE_STUDIO
+        self.m_lastRoomPath = None
 
         self.init_apps()
 
@@ -1228,24 +1256,24 @@ class ClaudiaMainW(AbstractJackW, ui_claudia.Ui_ClaudiaMainW):
         jack.client = None
 
         if self.m_nextSampleRate:
-            self.jack_sample_rate(self.m_nextSampleRate)
+            self.jack_setSampleRate(self.m_nextSampleRate)
 
-        buffer_size = jacksettings.getBufferSize()
-        sample_rate = jacksettings.getSampleRate()
-        buffer_size_test = bool(buffer_size != -1)
-        sample_rate_test = bool(sample_rate != -1)
+        bufferSize = jacksettings.getBufferSize()
+        sampleRate = jacksettings.getSampleRate()
+        bufferSizeTest = bool(bufferSize != -1)
+        sampleRateTest = bool(sampleRate != -1)
 
-        if buffer_size_test:
-            self.setBufferSize(buffer_size)
+        if bufferSizeTest:
+            self.setBufferSize(bufferSize)
 
-        if sample_rate_test:
-            self.setSampleRate(sample_rate)
+        if sampleRateTest:
+            self.setSampleRate(sampleRate)
 
         self.setRealTime(jacksettings.isRealtime())
         self.setXruns(-1)
 
-        self.cb_buffer_size.setEnabled(buffer_size_test)
-        self.cb_sample_rate.setEnabled(sample_rate_test)
+        self.cb_buffer_size.setEnabled(bufferSizeTest)
+        self.cb_sample_rate.setEnabled(sampleRateTest)
 
         self.act_jack_render.setEnabled(False)
         self.b_jack_render.setEnabled(False)
@@ -1331,8 +1359,8 @@ class ClaudiaMainW(AbstractJackW, ui_claudia.Ui_ClaudiaMainW):
         DBus.ladish_app_iface = None
         DBus.patchbay = None
 
-        self.m_last_item_type = None
-        self.m_last_room_path = None
+        self.m_lastItemType = None
+        self.m_lastRoomPath = None
 
         self.label_first_time.setVisible(True)
         self.graphicsView.setVisible(False)
@@ -1651,11 +1679,11 @@ class ClaudiaMainW(AbstractJackW, ui_claudia.Ui_ClaudiaMainW):
     def slot_app_add_new(self):
         proj_folder = ""
 
-        if self.m_last_item_type == ITEM_TYPE_STUDIO or self.m_last_item_type == ITEM_TYPE_STUDIO_APP:
+        if self.m_lastItemType == ITEM_TYPE_STUDIO or self.m_lastItemType == ITEM_TYPE_STUDIO_APP:
             proj_folder = self.m_savedSettings['Main/DefaultProjectFolder']
             is_room = False
 
-        elif self.m_last_item_type == ITEM_TYPE_ROOM or self.m_last_item_type == ITEM_TYPE_ROOM_APP:
+        elif self.m_lastItemType == ITEM_TYPE_ROOM or self.m_lastItemType == ITEM_TYPE_ROOM_APP:
             project_graph_version, project_properties = DBus.ladish_room.GetProjectProperties()
 
             if len(project_properties) > 0:
@@ -1674,7 +1702,7 @@ class ClaudiaMainW(AbstractJackW, ui_claudia.Ui_ClaudiaMainW):
 
     @pyqtSlot()
     def slot_app_run_custom(self):
-        dialog = RunCustomW(self, bool(self.m_last_item_type in (ITEM_TYPE_ROOM, ITEM_TYPE_ROOM_APP)))
+        dialog = RunCustomW(self, bool(self.m_lastItemType in (ITEM_TYPE_ROOM, ITEM_TYPE_ROOM_APP)))
         if dialog.exec_() and dialog.ret_app_obj:
             app_obj = dialog.ret_app_obj
             DBus.ladish_app_iface.RunCustom2(app_obj[iAppTerminal], app_obj[iAppCommand], app_obj[iAppName], app_obj[iAppLevel])
@@ -1725,7 +1753,7 @@ class ClaudiaMainW(AbstractJackW, ui_claudia.Ui_ClaudiaMainW):
         else:
             return
 
-        if ITEM_TYPE != self.m_last_item_type or room_path != self.m_last_room_path:
+        if ITEM_TYPE != self.m_lastItemType or room_path != self.m_lastRoomPath:
             if ITEM_TYPE == ITEM_TYPE_STUDIO:
                 object_path = DBus.ladish_studio
             elif ITEM_TYPE == ITEM_TYPE_ROOM:
@@ -1739,8 +1767,8 @@ class ClaudiaMainW(AbstractJackW, ui_claudia.Ui_ClaudiaMainW):
             DBus.ladish_manager = dbus.Interface(object_path, 'org.ladish.GraphManager')
             self.init_ports()
 
-        self.m_last_item_type = ITEM_TYPE
-        self.m_last_room_path = room_path
+        self.m_lastItemType = ITEM_TYPE
+        self.m_lastRoomPath = room_path
 
     @pyqtSlot(QTreeWidgetItem, int)
     def slot_doubleClickedAppList(self, item, row):
@@ -2405,22 +2433,22 @@ class ClaudiaMainW(AbstractJackW, ui_claudia.Ui_ClaudiaMainW):
             self.loadSettings(False)
             patchcanvas.clear()
 
-            p_options = patchcanvas.options_t()
-            p_options.theme_name       = self.m_savedSettings["Canvas/Theme"]
-            p_options.auto_hide_groups = self.m_savedSettings["Canvas/AutoHideGroups"]
-            p_options.use_bezier_lines = self.m_savedSettings["Canvas/UseBezierLines"]
-            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 = True
-            p_features.port_info    = True
-            p_features.port_rename  = True
-            p_features.handle_group_pos = False
-
-            patchcanvas.setOptions(p_options)
-            patchcanvas.setFeatures(p_features)
+            pOptions = patchcanvas.options_t()
+            pOptions.theme_name       = self.m_savedSettings["Canvas/Theme"]
+            pOptions.auto_hide_groups = self.m_savedSettings["Canvas/AutoHideGroups"]
+            pOptions.use_bezier_lines = self.m_savedSettings["Canvas/UseBezierLines"]
+            pOptions.antialiasing     = self.m_savedSettings["Canvas/Antialiasing"]
+            pOptions.eyecandy         = self.m_savedSettings["Canvas/EyeCandy"]
+
+            pFeatures = patchcanvas.features_t()
+            pFeatures.group_info   = False
+            pFeatures.group_rename = True
+            pFeatures.port_info    = True
+            pFeatures.port_rename  = True
+            pFeatures.handle_group_pos = False
+
+            patchcanvas.setOptions(pOptions)
+            patchcanvas.setFeatures(pFeatures)
             patchcanvas.init("Claudia", self.scene, self.canvasCallback, DEBUG)
 
             self.miniCanvasPreview.setViewTheme(patchcanvas.canvas.theme.rubberband_brush, patchcanvas.canvas.theme.rubberband_pen.color())
@@ -2475,7 +2503,6 @@ class ClaudiaMainW(AbstractJackW, ui_claudia.Ui_ClaudiaMainW):
             "Canvas/EyeCandy": self.settings.value("Canvas/EyeCandy", patchcanvas.EYECANDY_SMALL, type=int),
             "Canvas/UseOpenGL": self.settings.value("Canvas/UseOpenGL", False, type=bool),
             "Canvas/Antialiasing": self.settings.value("Canvas/Antialiasing", patchcanvas.ANTIALIASING_SMALL, type=int),
-            "Canvas/TextAntialiasing": self.settings.value("Canvas/TextAntialiasing", True, type=bool),
             "Canvas/HighQualityAntialiasing": self.settings.value("Canvas/HighQualityAntialiasing", False, type=bool)
         }
 

src/logs.py

@@ -337,6 +337,8 @@ class LogsW(QDialog, ui_logs.Ui_LogsW):
         self.connect(self.b_purge, SIGNAL("clicked()"), SLOT("slot_purgeLogs()"))
         self.connect(self.m_readThread, SIGNAL("updateLogs()"), SLOT("slot_updateLogs()"))
 
+        # -------------------------------------------------------------
+
     def setLogsText(self, text_jack, text_a2j, text_lash, text_ladish):
         while self.m_textLock:
             sleep(0.5)

src/render.py

@@ -67,6 +67,13 @@ class RenderW(QDialog, ui_render.Ui_RenderW):
         QDialog.__init__(self, parent)
         self.setupUi(self)
 
+        self.m_freewheel = False
+        self.m_lastTime  = 0
+        self.m_maxTime   = 180
+
+        self.m_timer   = QTimer(self)
+        self.m_process = QProcess(self)
+
         # -------------------------------------------------------------
         # Get JACK client and base information
 
@@ -87,16 +94,6 @@ class RenderW(QDialog, ui_render.Ui_RenderW):
             self.cb_buffer_size.addItem(str(self.m_bufferSize))
             self.cb_buffer_size.setCurrentIndex(self.cb_buffer_size.count() - 1)
 
-        # -------------------------------------------------------------
-        # Internal stuff
-
-        self.m_freewheel = False
-        self.m_lastTime  = 0
-        self.m_maxTime   = 180
-
-        self.m_timer   = QTimer(self)
-        self.m_process = QProcess(self)
-
         # -------------------------------------------------------------
         # Set-up GUI stuff
 
@@ -147,6 +144,8 @@ class RenderW(QDialog, ui_render.Ui_RenderW):
         self.connect(self.te_end, SIGNAL("timeChanged(const QTime)"), SLOT("slot_updateEndTime(const QTime)"))
         self.connect(self.m_timer, SIGNAL("timeout()"), SLOT("slot_updateProgressbar()"))
 
+        # -------------------------------------------------------------
+
     @pyqtSlot()
     def slot_renderStart(self):
         if not os.path.exists(self.le_folder.text()):

src/shared_jack.py

@@ -114,37 +114,42 @@ class AbstractJackW(QMainWindow):
     # -----------------------------------------------------------------
     # Property change calls
 
-    def jack_buffer_size(self, bufferSize):
-        if self.m_bufferSize != bufferSize:
-            if jack.client:
-                failed = bool(jacklib.set_buffer_size(jack.client, bufferSize) != 0)
-            else:
-                failed = bool(jacksettings.setBufferSize(bufferSize))
+    def jack_setBufferSize(self, bufferSize):
+        if self.m_bufferSize == bufferSize:
+            return
 
-            if failed:
-                print("Failed to change buffer-size as %i, reset to %i" % (bufferSize, self.m_bufferSize))
-                self.setBufferSize(self.m_bufferSize, True)
+        if jack.client:
+            failed = bool(jacklib.set_buffer_size(jack.client, bufferSize) != 0)
+        else:
+            failed = bool(jacksettings.setBufferSize(bufferSize))
 
-    def jack_sample_rate(self, sampleRate):
+        if failed:
+            print("Failed to change buffer-size as %i, reset to %i" % (bufferSize, self.m_bufferSize))
+            self.setBufferSize(self.m_bufferSize, True)
+
+    def jack_setSampleRate(self, sampleRate):
         if jack.client:
+            # Show change-in-future dialog
             self.setSampleRate(sampleRate, True)
         else:
+            # Try to set sampleRate via dbus now
             if jacksettings.setSampleRate(sampleRate):
                 self.setSampleRate(sampleRate)
 
-    @pyqtSlot(int)
-    def slot_jackBufferSize_Menu(self, bufferSize):
-        self.jack_buffer_size(bufferSize)
+    @pyqtSlot()
+    def slot_jackBufferSize_Menu(self):
+        bufferSize = int(self.sender().text())
+        self.jack_setBufferSize(bufferSize)
 
     @pyqtSlot(str)
     def slot_jackBufferSize_ComboBox(self, text):
         if text and text.isdigit():
-            self.jack_buffer_size(int(text))
+            self.jack_setBufferSize(int(text))
 
     @pyqtSlot(str)
     def slot_jackSampleRate_ComboBox(self, text):
         if text and text.isdigit():
-            self.jack_sample_rate(int(text))
+            self.jack_setSampleRate(int(text))
 
     # -----------------------------------------------------------------
     # Transport calls
@@ -233,8 +238,7 @@ class AbstractJackW(QMainWindow):
         state = jacklib.transport_query(jack.client, jacklib.pointer(pos))
 
         if self.m_curTransportView == TRANSPORT_VIEW_HMS:
-            frame = pos.frame
-            time = frame / self.m_sampleRate
+            time = pos.frame / self.m_sampleRate
             secs = time % 60
             mins = (time / 60) % 60
             hrs  = (time / 3600) % 60
@@ -243,11 +247,8 @@ class AbstractJackW(QMainWindow):
         elif self.m_curTransportView == TRANSPORT_VIEW_BBT:
             if pos.valid & jacklib.JackPositionBBT:
                 bar  = pos.bar
-                beat = pos.beat
-                tick = pos.tick
-                if bar == 0:
-                    beat = 0
-                    tick = 0
+                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))
             else:
                 self.label_time.setText("%03i|%02i|%04i" % (0, 0, 0))
@@ -331,20 +332,20 @@ class AbstractJackW(QMainWindow):
                         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)
+                #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:
             return
 
         if future:
-            if self.sender() == self.cb_sample_rate: # Changed using GUI
+            #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)
+                            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:
@@ -357,9 +358,8 @@ class AbstractJackW(QMainWindow):
 
         for i in range(len(SAMPLE_RATE_LIST)):
             sampleRate = SAMPLE_RATE_LIST[i]
-            sampleRateStr = str(sampleRate)
-
-            self.cb_sample_rate.setItemText(i, sampleRateStr)
+            #sampleRateStr = str(sampleRate)
+            #self.cb_sample_rate.setItemText(i, sampleRateStr)
 
             if self.m_sampleRate == sampleRate:
                 self.cb_sample_rate.setCurrentIndex(i)
@@ -416,17 +416,17 @@ def setJackConnections(self_, modes):
         self_.connect(self_.cb_sample_rate, SIGNAL("currentIndexChanged(QString)"), SLOT("slot_jackSampleRate_ComboBox(QString)"))
         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))
+    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()"))
 
     if "transport" in modes:
         self_.connect(self_.act_transport_play, SIGNAL("triggered(bool)"), SLOT("slot_transportPlayPause(bool)"))