diff --git a/src/catarina.py b/src/catarina.py
index 283c891..84e2bd4 100755
--- a/src/catarina.py
+++ b/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
diff --git a/src/catia.py b/src/catia.py
index f934708..18754b9 100755
--- a/src/catia.py
+++ b/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())
diff --git a/src/claudia.py b/src/claudia.py
index 6333413..3b8c681 100755
--- a/src/claudia.py
+++ b/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())
diff --git a/src/digitalpeakmeter.py b/src/digitalpeakmeter.py
index dbc945d..b9811ea 100644
--- a/src/digitalpeakmeter.py
+++ b/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)
diff --git a/src/jacklib.py b/src/jacklib.py
index 1376f72..f91f9c1 100644
--- a/src/jacklib.py
+++ b/src/jacklib.py
@@ -31,6 +31,15 @@ try:
 except:
   jacklib = None
 
+# JACK2 test
+try:
+  if (jacklib and jacklib.jack_get_version_string):
+    JACK2 = True
+  else:
+    JACK2 = False
+except:
+  JACK2 = False
+
 # ---------------------------------------------------------------------------------------------------------------------
 # Pre-definitions
 
@@ -250,326 +259,449 @@ JackSessionCallback = CFUNCTYPE(None, jack_session_event_t, c_void_p)
 # ---------------------------------------------------------------------------------------------------------------------
 # Functions
 
-def get_version_string(): # JACK2 only
+if (JACK2):
   jacklib.jack_get_version_string.argtypes = None
   jacklib.jack_get_version_string.restype = c_char_p
-  return jacklib.jack_get_version_string()
 
-def client_open(client_name, options, status):
-  jacklib.jack_client_open.argtypes = [c_char_p, jack_options_t, POINTER(jack_status_t)]
-  jacklib.jack_client_open.restype = POINTER(jack_client_t)
-  return jacklib.jack_client_open(client_name.encode("ascii"), options, status)
+jacklib.jack_client_open.argtypes = [c_char_p, jack_options_t, POINTER(jack_status_t), c_char_p]
+jacklib.jack_client_open.restype = POINTER(jack_client_t)
+
+jacklib.jack_client_new.argtypes = [c_char_p]
+jacklib.jack_client_new.restype = POINTER(jack_client_t)
+
+jacklib.jack_client_close.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_client_close.restype = c_int
+
+jacklib.jack_client_name_size.argtypes = None
+jacklib.jack_client_name_size.restype = c_int
+
+jacklib.jack_get_client_name.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_get_client_name.restype = c_char_p
+
+jacklib.jack_internal_client_new.argtypes = [c_char_p, c_char_p, c_char_p]
+jacklib.jack_internal_client_new.restype = c_int
+
+jacklib.jack_internal_client_close.argtypes = [c_char_p]
+jacklib.jack_internal_client_close.restype = None
+
+jacklib.jack_activate.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_activate.restype = c_int
+
+jacklib.jack_deactivate.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_deactivate.restype = c_int
+
+if (JACK2):
+  jacklib.jack_get_client_pid.argtypes = [c_char_p]
+  jacklib.jack_get_client_pid.restype = c_int
+
+jacklib.jack_client_thread_id.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_client_thread_id.restype = jack_native_thread_t
+
+jacklib.jack_is_realtime.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_is_realtime.restype = c_int
+
+def get_version_string(): # JACK2 only
+  return jacklib.jack_get_version_string()
 
-def client_open_uuid(client_name, options, status, uuid): # Extra function for jack-session support
-  jacklib.jack_client_open.argtypes = [c_char_p, jack_options_t, POINTER(jack_status_t), c_char_p]
-  jacklib.jack_client_open.restype = POINTER(jack_client_t)
+def client_open(client_name, options, status, uuid=""):
   return jacklib.jack_client_open(client_name.encode("ascii"), options, status, uuid.encode("ascii"))
 
 def client_new(client_name):
-  jacklib.jack_client_new.argtypes = [c_char_p]
-  jacklib.jack_client_new.restype = POINTER(jack_client_t)
   return jacklib.jack_client_new(client_name.encode("ascii"))
 
 def client_close(client):
-  jacklib.jack_client_close.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_client_close.restype = c_int
   return jacklib.jack_client_close(client)
 
 def client_name_size():
-  jacklib.jack_client_name_size.argtypes = None
-  jacklib.jack_client_name_size.restype = c_int
   return jacklib.jack_client_name_size()
 
 def get_client_name(client):
-  jacklib.jack_get_client_name.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_get_client_name.restype = c_char_p
   return jacklib.jack_get_client_name(client)
 
 def internal_client_new(client_name, load_name, load_init):
-  jacklib.jack_internal_client_new.argtypes = [c_char_p, c_char_p, c_char_p]
-  jacklib.jack_internal_client_new.restype = c_int
   return jacklib.jack_internal_client_new(client_name.encode("ascii"), load_name.encode("ascii"), load_init.encode("ascii"))
 
 def internal_client_close(client_name):
-  jacklib.jack_internal_client_close.argtypes = [c_char_p]
-  jacklib.jack_internal_client_close.restype = None
   jacklib.jack_internal_client_close(client_name.encode("ascii"))
 
 def activate(client):
-  jacklib.jack_activate.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_activate.restype = c_int
   return jacklib.jack_activate(client)
 
 def deactivate(client):
-  jacklib.jack_deactivate.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_deactivate.restype = c_int
   return jacklib.jack_deactivate(client)
 
 def get_client_pid(name): # JACK2 only
-  jacklib.jack_get_client_pid.argtypes = [c_char_p]
-  jacklib.jack_get_client_pid.restype = c_int
   return jacklib.jack_get_client_pid(name.encode("ascii"))
 
 def client_thread_id(client):
-  jacklib.jack_client_thread_id.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_client_thread_id.restype = jack_native_thread_t
   return jacklib.jack_client_thread_id(client)
 
 def is_realtime(client):
-  jacklib.jack_is_realtime.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_is_realtime.restype = c_int
   return jacklib.jack_is_realtime(client)
 
 
 # Non Callback API
 
+global _thread_callback
+
+_thread_callback = None
+
+jacklib.jack_thread_wait.argtypes = [POINTER(jack_client_t), c_int]
+jacklib.jack_thread_wait.restype = jack_nframes_t
+
+jacklib.jack_cycle_wait.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_cycle_wait.restype = jack_nframes_t
+
+jacklib.jack_cycle_signal.argtypes = [POINTER(jack_client_t), c_int]
+jacklib.jack_cycle_signal.restype = None
+
+jacklib.jack_set_process_thread.argtypes = [POINTER(jack_client_t), JackThreadCallback, c_void_p]
+jacklib.jack_set_process_thread.restype = c_int
+
 def thread_wait(client, status):
-  jacklib.jack_thread_wait.argtypes = [POINTER(jack_client_t), c_int]
-  jacklib.jack_thread_wait.restype = jack_nframes_t
   return jacklib.jack_thread_wait(client, status)
 
 def cycle_wait(client):
-  jacklib.jack_cycle_wait.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_cycle_wait.restype = jack_nframes_t
   return jacklib.jack_cycle_wait(client)
 
 def cycle_signal(client, status):
-  jacklib.jack_cycle_signal.argtypes = [POINTER(jack_client_t), c_int]
-  jacklib.jack_cycle_signal.restype = None
   jacklib.jack_cycle_signal(client, status)
 
 def set_process_thread(client, thread_callback, arg):
   global _thread_callback
   _thread_callback = JackThreadCallback(thread_callback)
-  jacklib.jack_set_process_thread.argtypes = [POINTER(jack_client_t), JackThreadCallback, c_void_p]
-  jacklib.jack_set_process_thread.restype = c_int
   return jacklib.jack_set_process_thread(client, _thread_callback, arg)
 
 
 # Client Callbacks
 
+global _thread_init_callback
+global _shutdown_callback
+global _info_shutdown_callback
+global _process_callback
+global _freewheel_callback
+global _bufsize_callback
+global _srate_callback
+global _client_registration_callback
+global _port_registration_callback
+global _connect_callback
+global _rename_callback
+global _graph_callback
+global _xrun_callback
+global _latency_callback
+
+_thread_init_callback = _shutdown_callback = _info_shutdown_callback = None
+_process_callback = _freewheel_callback = _bufsize_callback = _srate_callback = None
+_client_registration_callback = _port_registration_callback = _connect_callback = _rename_callback = None
+_graph_callback = _xrun_callback = _latency_callback = None
+
+jacklib.jack_set_thread_init_callback.argtypes = [POINTER(jack_client_t), JackThreadInitCallback, c_void_p]
+jacklib.jack_set_thread_init_callback.restype = c_int
+
+jacklib.jack_on_shutdown.argtypes = [POINTER(jack_client_t), JackShutdownCallback, c_void_p]
+jacklib.jack_on_shutdown.restype = None
+
+try: # JACK_WEAK_EXPORT
+  jacklib.jack_on_info_shutdown.argtypes = [POINTER(jack_client_t), JackInfoShutdownCallback, c_void_p]
+  jacklib.jack_on_info_shutdown.restype = None
+except:
+  jacklib.jack_on_info_shutdown = None
+
+jacklib.jack_set_process_callback.argtypes = [POINTER(jack_client_t), JackProcessCallback, c_void_p]
+jacklib.jack_set_process_callback.restype = c_int
+
+jacklib.jack_set_freewheel_callback.argtypes = [POINTER(jack_client_t), JackFreewheelCallback, c_void_p]
+jacklib.jack_set_freewheel_callback.restype = c_int
+
+jacklib.jack_set_buffer_size_callback.argtypes = [POINTER(jack_client_t), JackBufferSizeCallback, c_void_p]
+jacklib.jack_set_buffer_size_callback.restype = c_int
+
+jacklib.jack_set_sample_rate_callback.argtypes = [POINTER(jack_client_t), JackSampleRateCallback, c_void_p]
+jacklib.jack_set_sample_rate_callback.restype = c_int
+
+jacklib.jack_set_client_registration_callback.argtypes = [POINTER(jack_client_t), JackClientRegistrationCallback, c_void_p]
+jacklib.jack_set_client_registration_callback.restype = c_int
+
+jacklib.jack_set_port_registration_callback.argtypes = [POINTER(jack_client_t), JackPortRegistrationCallback, c_void_p]
+jacklib.jack_set_port_registration_callback.restype = c_int
+
+jacklib.jack_set_port_connect_callback.argtypes = [POINTER(jack_client_t), JackPortConnectCallback, c_void_p]
+jacklib.jack_set_port_connect_callback.restype = c_int
+
+if (JACK2):
+  jacklib.jack_set_port_rename_callback.argtypes = [POINTER(jack_client_t), JackPortRenameCallback, c_void_p]
+  jacklib.jack_set_port_rename_callback.restype = c_int
+
+jacklib.jack_set_graph_order_callback.argtypes = [POINTER(jack_client_t), JackGraphOrderCallback, c_void_p]
+jacklib.jack_set_graph_order_callback.restype = c_int
+
+jacklib.jack_set_xrun_callback.argtypes = [POINTER(jack_client_t), JackXRunCallback, c_void_p]
+jacklib.jack_set_xrun_callback.restype = c_int
+
+try: # JACK_WEAK_EXPORT
+  jacklib.jack_set_latency_callback.argtypes = [POINTER(jack_client_t), JackLatencyCallback, c_void_p]
+  jacklib.jack_set_latency_callback.restype = c_int
+except:
+  jacklib.jack_set_latency_callback = None
+
 def set_thread_init_callback(client, thread_init_callback, arg):
   global _thread_init_callback
   _thread_init_callback = JackThreadInitCallback(thread_init_callback)
-  jacklib.jack_set_thread_init_callback.argtypes = [POINTER(jack_client_t), JackThreadInitCallback, c_void_p]
-  jacklib.jack_set_thread_init_callback.restype = c_int
   return jacklib.jack_set_thread_init_callback(client, _thread_init_callback, arg)
 
 def on_shutdown(client, shutdown_callback, arg):
   global _shutdown_callback
   _shutdown_callback = JackShutdownCallback(shutdown_callback)
-  jacklib.jack_on_shutdown.argtypes = [POINTER(jack_client_t), JackShutdownCallback, c_void_p]
-  jacklib.jack_on_shutdown.restype = None
   jacklib.jack_on_shutdown(client, _shutdown_callback, arg)
 
-def on_info_shutdown(client, info_shutdown_callback, arg):
-  global _info_shutdown_callback
-  _info_shutdown_callback = JackInfoShutdownCallback(info_shutdown_callback)
-  jacklib.jack_on_info_shutdown.argtypes = [POINTER(jack_client_t), JackInfoShutdownCallback, c_void_p]
-  jacklib.jack_on_info_shutdown.restype = None
-  jacklib.jack_on_info_shutdown(client, _info_shutdown_callback, arg)
+def on_info_shutdown(client, info_shutdown_callback, arg): # JACK_WEAK_EXPORT
+  if (jacklib.jack_on_info_shutdown):
+    global _info_shutdown_callback
+    _info_shutdown_callback = JackInfoShutdownCallback(info_shutdown_callback)
+    jacklib.jack_on_info_shutdown(client, _info_shutdown_callback, arg)
 
 def set_process_callback(client, process_callback, arg):
   global _process_callback
   _process_callback = JackProcessCallback(process_callback)
-  jacklib.jack_set_process_callback.argtypes = [POINTER(jack_client_t), JackProcessCallback, c_void_p]
-  jacklib.jack_set_process_callback.restype = c_int
   return jacklib.jack_set_process_callback(client, _process_callback, arg)
 
 def set_freewheel_callback(client, freewheel_callback, arg):
   global _freewheel_callback
   _freewheel_callback = JackFreewheelCallback(freewheel_callback)
-  jacklib.jack_set_freewheel_callback.argtypes = [POINTER(jack_client_t), JackFreewheelCallback, c_void_p]
-  jacklib.jack_set_freewheel_callback.restype = c_int
   return jacklib.jack_set_freewheel_callback(client, _freewheel_callback, arg)
 
 def set_buffer_size_callback(client, bufsize_callback, arg):
   global _bufsize_callback
   _bufsize_callback = JackBufferSizeCallback(bufsize_callback)
-  jacklib.jack_set_buffer_size_callback.argtypes = [POINTER(jack_client_t), JackBufferSizeCallback, c_void_p]
-  jacklib.jack_set_buffer_size_callback.restype = c_int
   return jacklib.jack_set_buffer_size_callback(client, _bufsize_callback, arg)
 
 def set_sample_rate_callback(client, srate_callback, arg):
   global _srate_callback
   _srate_callback = JackSampleRateCallback(srate_callback)
-  jacklib.jack_set_sample_rate_callback.argtypes = [POINTER(jack_client_t), JackSampleRateCallback, c_void_p]
-  jacklib.jack_set_sample_rate_callback.restype = c_int
   return jacklib.jack_set_sample_rate_callback(client, _srate_callback, arg)
 
 def set_client_registration_callback(client, client_registration_callback, arg):
   global _client_registration_callback
   _client_registration_callback = JackClientRegistrationCallback(client_registration_callback)
-  jacklib.jack_set_client_registration_callback.argtypes = [POINTER(jack_client_t), JackClientRegistrationCallback, c_void_p]
-  jacklib.jack_set_client_registration_callback.restype = c_int
   return jacklib.jack_set_client_registration_callback(client, _client_registration_callback, arg)
 
 def set_port_registration_callback(client, port_registration_callback, arg):
   global _port_registration_callback
   _port_registration_callback = JackPortRegistrationCallback(port_registration_callback)
-  jacklib.jack_set_port_registration_callback.argtypes = [POINTER(jack_client_t), JackPortRegistrationCallback, c_void_p]
-  jacklib.jack_set_port_registration_callback.restype = c_int
   return jacklib.jack_set_port_registration_callback(client, _port_registration_callback, arg)
 
 def set_port_connect_callback(client, connect_callback, arg):
   global _connect_callback
   _connect_callback = JackPortConnectCallback(connect_callback)
-  jacklib.jack_set_port_connect_callback.argtypes = [POINTER(jack_client_t), JackPortConnectCallback, c_void_p]
-  jacklib.jack_set_port_connect_callback.restype = c_int
   return jacklib.jack_set_port_connect_callback(client, _connect_callback, arg)
 
 def set_port_rename_callback(client, rename_callback, arg): # JACK2 only
   global _rename_callback
   _rename_callback = JackPortRenameCallback(rename_callback)
-  jacklib.jack_set_port_rename_callback.argtypes = [POINTER(jack_client_t), JackPortRenameCallback, c_void_p]
-  jacklib.jack_set_port_rename_callback.restype = c_int
   return jacklib.jack_set_port_rename_callback(client, _rename_callback, arg)
 
 def set_graph_order_callback(client, graph_callback, arg):
   global _graph_callback
   _graph_callback = JackGraphOrderCallback(graph_callback)
-  jacklib.jack_set_graph_order_callback.argtypes = [POINTER(jack_client_t), JackGraphOrderCallback, c_void_p]
-  jacklib.jack_set_graph_order_callback.restype = c_int
   return jacklib.jack_set_graph_order_callback(client, _graph_callback, arg)
 
 def set_xrun_callback(client, xrun_callback, arg):
   global _xrun_callback
   _xrun_callback = JackXRunCallback(xrun_callback)
-  jacklib.jack_set_xrun_callback.argtypes = [POINTER(jack_client_t), JackXRunCallback, c_void_p]
-  jacklib.jack_set_xrun_callback.restype = c_int
   return jacklib.jack_set_xrun_callback(client, _xrun_callback, arg)
 
-def set_latency_callback(client, latency_callback, arg):
-  global _latency_callback
-  _latency_callback = JackLatencyCallback(latency_callback)
-  jacklib.jack_set_latency_callback.argtypes = [POINTER(jack_client_t), JackLatencyCallback, c_void_p]
-  jacklib.jack_set_latency_callback.restype = c_int
-  return jacklib.jack_set_latency_callback(client, _latency_callback, arg)
+def set_latency_callback(client, latency_callback, arg): # JACK_WEAK_EXPORT
+  if (jacklib.jack_set_latency_callback):
+    global _latency_callback
+    _latency_callback = JackLatencyCallback(latency_callback)
+    return jacklib.jack_set_latency_callback(client, _latency_callback, arg)
+  return -1
 
 
 # Server Control
 
+jacklib.jack_set_freewheel.argtypes = [POINTER(jack_client_t), c_int]
+jacklib.jack_set_freewheel.restype = c_int
+
+jacklib.jack_set_buffer_size.argtypes = [POINTER(jack_client_t), jack_nframes_t]
+jacklib.jack_set_buffer_size.restype = c_int
+
+jacklib.jack_get_sample_rate.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_get_sample_rate.restype = jack_nframes_t
+
+jacklib.jack_get_buffer_size.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_get_buffer_size.restype = jack_nframes_t
+
+jacklib.jack_engine_takeover_timebase.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_engine_takeover_timebase.restype = c_int
+
+jacklib.jack_cpu_load.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_cpu_load.restype = c_float
+
 def set_freewheel(client, onoff):
-  jacklib.jack_set_freewheel.argtypes = [POINTER(jack_client_t), c_int]
-  jacklib.jack_set_freewheel.restype = c_int
   return jacklib.jack_set_freewheel(client, onoff)
 
 def set_buffer_size(client, nframes):
-  jacklib.jack_set_buffer_size.argtypes = [POINTER(jack_client_t), jack_nframes_t]
-  jacklib.jack_set_buffer_size.restype = c_int
   return jacklib.jack_set_buffer_size(client, nframes)
 
 def get_sample_rate(client):
-  jacklib.jack_get_sample_rate.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_get_sample_rate.restype = jack_nframes_t
   return jacklib.jack_get_sample_rate(client)
 
 def get_buffer_size(client):
-  jacklib.jack_get_buffer_size.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_get_buffer_size.restype = jack_nframes_t
   return jacklib.jack_get_buffer_size(client)
 
 def engine_takeover_timebase(client):
-  jacklib.jack_engine_takeover_timebase.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_engine_takeover_timebase.restype = c_int
   return jacklib.jack_engine_takeover_timebase(client)
 
 def cpu_load(client):
-  jacklib.jack_cpu_load.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_cpu_load.restype = c_float
   return jacklib.jack_cpu_load(client)
 
 
 # Port Functions
 
+jacklib.jack_port_register.argtypes = [POINTER(jack_client_t), c_char_p, c_char_p, c_ulong, c_ulong]
+jacklib.jack_port_register.restype = POINTER(jack_port_t)
+
+jacklib.jack_port_unregister.argtypes = [POINTER(jack_client_t), POINTER(jack_port_t)]
+jacklib.jack_port_unregister.restype = c_int
+
+jacklib.jack_port_get_buffer.argtypes = [POINTER(jack_port_t), jack_nframes_t]
+jacklib.jack_port_get_buffer.restype = c_void_p
+
+jacklib.jack_port_name.argtypes = [POINTER(jack_port_t)]
+jacklib.jack_port_name.restype = c_char_p
+
+jacklib.jack_port_short_name.argtypes = [POINTER(jack_port_t)]
+jacklib.jack_port_short_name.restype = c_char_p
+
+jacklib.jack_port_flags.argtypes = [POINTER(jack_port_t)]
+jacklib.jack_port_flags.restype = c_int
+
+jacklib.jack_port_type.argtypes = [POINTER(jack_port_t)]
+jacklib.jack_port_type.restype = c_char_p
+
+if (JACK2):
+  jacklib.jack_port_type_id.argtypes = [POINTER(jack_port_t)]
+  jacklib.jack_port_type_id.restype = jack_port_type_id_t
+
+jacklib.jack_port_is_mine.argtypes = [POINTER(jack_client_t), POINTER(jack_port_t)]
+jacklib.jack_port_is_mine.restype = c_int
+
+jacklib.jack_port_connected.argtypes = [POINTER(jack_port_t)]
+jacklib.jack_port_connected.restype = c_int
+
+jacklib.jack_port_connected_to.argtypes = [POINTER(jack_port_t), c_char_p]
+jacklib.jack_port_connected_to.restype = c_int
+
+jacklib.jack_port_get_connections.argtypes = [POINTER(jack_port_t)]
+jacklib.jack_port_get_connections.restype = POINTER(c_char_p)
+
+jacklib.jack_port_get_all_connections.argtypes = [POINTER(jack_client_t), POINTER(jack_port_t)]
+jacklib.jack_port_get_all_connections.restype = POINTER(c_char_p)
+
+jacklib.jack_port_tie.argtypes = [POINTER(jack_port_t), POINTER(jack_port_t)]
+jacklib.jack_port_tie.restype = c_int
+
+jacklib.jack_port_untie.argtypes = [POINTER(jack_port_t)]
+jacklib.jack_port_untie.restype = c_int
+
+jacklib.jack_port_set_name.argtypes = [POINTER(jack_port_t), c_char_p]
+jacklib.jack_port_set_name.restype = c_int
+
+jacklib.jack_port_set_alias.argtypes = [POINTER(jack_port_t), c_char_p]
+jacklib.jack_port_set_alias.restype = c_int
+
+jacklib.jack_port_unset_alias.argtypes = [POINTER(jack_port_t), c_char_p]
+jacklib.jack_port_unset_alias.restype = c_int
+
+jacklib.jack_port_get_aliases.argtypes = [POINTER(jack_port_t), POINTER(ARRAY(c_char_p, 2))]
+jacklib.jack_port_get_aliases.restype = c_int
+
+jacklib.jack_port_request_monitor.argtypes = [POINTER(jack_port_t), c_int]
+jacklib.jack_port_request_monitor.restype = c_int
+
+jacklib.jack_port_request_monitor_by_name.argtypes = [POINTER(jack_client_t), c_char_p, c_int]
+jacklib.jack_port_request_monitor_by_name.restype = c_int
+
+jacklib.jack_port_ensure_monitor.argtypes = [POINTER(jack_port_t), c_int]
+jacklib.jack_port_ensure_monitor.restype = c_int
+
+jacklib.jack_port_monitoring_input.argtypes = [POINTER(jack_port_t)]
+jacklib.jack_port_monitoring_input.restype = c_int
+
+jacklib.jack_connect.argtypes = [POINTER(jack_client_t), c_char_p, c_char_p]
+jacklib.jack_connect.restype = c_int
+
+jacklib.jack_disconnect.argtypes = [POINTER(jack_client_t), c_char_p, c_char_p]
+jacklib.jack_disconnect.restype = c_int
+
+jacklib.jack_port_disconnect.argtypes = [POINTER(jack_client_t), POINTER(jack_port_t)]
+jacklib.jack_port_disconnect.restype = c_int
+
+jacklib.jack_port_name_size.argtypes = None
+jacklib.jack_port_name_size.restype = c_int
+
+jacklib.jack_port_type_size.argtypes = None
+jacklib.jack_port_type_size.restype = c_int
+
+try: # JACK_WEAK_EXPORT
+  jacklib.jack_port_type_get_buffer_size.argtypes = [POINTER(jack_client_t), c_char_p]
+  jacklib.jack_port_type_get_buffer_size.restype = c_size_t
+except:
+  jacklib.jack_port_type_get_buffer_size = None
+
 def port_register(client, port_name, port_type, flags, buffer_size):
-  jacklib.jack_port_register.argtypes = [POINTER(jack_client_t), c_char_p, c_char_p, c_ulong, c_ulong]
-  jacklib.jack_port_register.restype = POINTER(jack_port_t)
   return jacklib.jack_port_register(client, port_name.encode("ascii"), port_type.encode("ascii"), flags, buffer_size)
 
 def port_unregister(client, port):
-  jacklib.jack_port_unregister.argtypes = [POINTER(jack_client_t), POINTER(jack_port_t)]
-  jacklib.jack_port_unregister.restype = c_int
   return jacklib.jack_port_unregister(client, port)
 
 def port_get_buffer(port, nframes):
-  jacklib.jack_port_get_buffer.argtypes = [POINTER(jack_port_t), jack_nframes_t]
-  jacklib.jack_port_get_buffer.restype = c_void_p
   return jacklib.jack_port_get_buffer(port, nframes)
 
 def port_name(port):
-  jacklib.jack_port_name.argtypes = [POINTER(jack_port_t)]
-  jacklib.jack_port_name.restype = c_char_p
   return jacklib.jack_port_name(port)
 
 def port_short_name(port):
-  jacklib.jack_port_short_name.argtypes = [POINTER(jack_port_t)]
-  jacklib.jack_port_short_name.restype = c_char_p
   return jacklib.jack_port_short_name(port)
 
 def port_flags(port):
-  jacklib.jack_port_flags.argtypes = [POINTER(jack_port_t)]
-  jacklib.jack_port_flags.restype = c_int
   return jacklib.jack_port_flags(port)
 
 def port_type(port):
-  jacklib.jack_port_type.argtypes = [POINTER(jack_port_t)]
-  jacklib.jack_port_type.restype = c_char_p
   return jacklib.jack_port_type(port)
 
 def port_type_id(port): # JACK2 only
-  jacklib.jack_port_type_id.argtypes = [POINTER(jack_port_t)]
-  jacklib.jack_port_type_id.restype = jack_port_type_id_t
   return jacklib.jack_port_type_id(port)
 
 def port_is_mine(client, port):
-  jacklib.jack_port_is_mine.argtypes = [POINTER(jack_client_t), POINTER(jack_port_t)]
-  jacklib.jack_port_is_mine.restype = c_int
   return jacklib.jack_port_is_mine(client, port)
 
 def port_connected(port):
-  jacklib.jack_port_connected.argtypes = [POINTER(jack_port_t)]
-  jacklib.jack_port_connected.restype = c_int
   return jacklib.jack_port_connected(port)
 
 def port_connected_to(port, port_name):
-  jacklib.jack_port_connected_to.argtypes = [POINTER(jack_port_t), c_char_p]
-  jacklib.jack_port_connected_to.restype = c_int
   return jacklib.jack_port_connected_to(port, port_name.encode("ascii"))
 
 def port_get_connections(port):
-  jacklib.jack_port_get_connections.argtypes = [POINTER(jack_port_t)]
-  jacklib.jack_port_get_connections.restype = POINTER(c_char_p)
   return jacklib.jack_port_get_connections(port)
 
 def port_get_all_connections(client, port):
-  jacklib.jack_port_get_all_connections.argtypes = [POINTER(jack_client_t), POINTER(jack_port_t)]
-  jacklib.jack_port_get_all_connections.restype = POINTER(c_char_p)
   return jacklib.jack_port_get_all_connections(client, port)
 
 def port_tie(src, dst):
-  jacklib.jack_port_tie.argtypes = [POINTER(jack_port_t), POINTER(jack_port_t)]
-  jacklib.jack_port_tie.restype = c_int
   return jacklib.jack_port_tie(src, dst)
 
 def port_untie(port):
-  jacklib.jack_port_untie.argtypes = [POINTER(jack_port_t)]
-  jacklib.jack_port_untie.restype = c_int
   return jacklib.jack_port_untie(port)
 
 def port_set_name(port, port_name):
-  jacklib.jack_port_set_name.argtypes = [POINTER(jack_port_t), c_char_p]
-  jacklib.jack_port_set_name.restype = c_int
   return jacklib.jack_port_set_name(port, port_name.encode("ascii"))
 
 def port_set_alias(port, alias):
-  jacklib.jack_port_set_alias.argtypes = [POINTER(jack_port_t), c_char_p]
-  jacklib.jack_port_set_alias.restype = c_int
   return jacklib.jack_port_set_alias(port, alias.encode("ascii"))
 
 def port_unset_alias(port, alias):
-  jacklib.jack_port_unset_alias.argtypes = [POINTER(jack_port_t), c_char_p]
-  jacklib.jack_port_unset_alias.restype = c_int
   return jacklib.jack_port_unset_alias(port, alias.encode("ascii"))
 
 def port_get_aliases(port):
@@ -579,149 +711,152 @@ def port_get_aliases(port):
   alias_type = c_char_p*2
   aliases = alias_type(" ".encode("ascii")*name_size, " ".encode("ascii")*name_size)
 
-  jacklib.jack_port_get_aliases.argtypes = [POINTER(jack_port_t), POINTER(ARRAY(c_char_p, 2))]
-  jacklib.jack_port_get_aliases.restype = c_int
-
   ret = jacklib.jack_port_get_aliases(port, pointer(aliases))
   return (ret, str(aliases[0], encoding="ascii"), str(aliases[1], encoding="ascii"))
 
 def port_request_monitor(port, onoff):
-  jacklib.jack_port_request_monitor.argtypes = [POINTER(jack_port_t), c_int]
-  jacklib.jack_port_request_monitor.restype = c_int
   return jacklib.jack_port_request_monitor(port, onoff)
 
 def port_request_monitor_by_name(client, port_name, onoff):
-  jacklib.jack_port_request_monitor_by_name.argtypes = [POINTER(jack_client_t), c_char_p, c_int]
-  jacklib.jack_port_request_monitor_by_name.restype = c_int
   return jacklib.jack_port_request_monitor_by_name(client, port_name.encode("ascii"), onoff)
 
 def port_ensure_monitor(port, onoff):
-  jacklib.jack_port_ensure_monitor.argtypes = [POINTER(jack_port_t), c_int]
-  jacklib.jack_port_ensure_monitor.restype = c_int
   return jacklib.jack_port_ensure_monitor(port, onoff)
 
 def port_monitoring_input(port):
-  jacklib.jack_port_monitoring_input.argtypes = [POINTER(jack_port_t)]
-  jacklib.jack_port_monitoring_input.restype = c_int
   return jacklib.jack_port_monitoring_input(port)
 
 def connect(client, source_port, destination_port):
-  jacklib.jack_connect.argtypes = [POINTER(jack_client_t), c_char_p, c_char_p]
-  jacklib.jack_connect.restype = c_int
   return jacklib.jack_connect(client, source_port.encode("ascii"), destination_port.encode("ascii"))
 
 def disconnect(client, source_port, destination_port):
-  jacklib.jack_disconnect.argtypes = [POINTER(jack_client_t), c_char_p, c_char_p]
-  jacklib.jack_disconnect.restype = c_int
   return jacklib.jack_disconnect(client, source_port.encode("ascii"), destination_port.encode("ascii"))
 
 def port_disconnect(client, port):
-  jacklib.jack_port_disconnect.argtypes = [POINTER(jack_client_t), POINTER(jack_port_t)]
-  jacklib.jack_port_disconnect.restype = c_int
   return jacklib.jack_port_disconnect(client, port)
 
 def port_name_size():
-  jacklib.jack_port_name_size.argtypes = None
-  jacklib.jack_port_name_size.restype = c_int
   return jacklib.jack_port_name_size()
 
 def port_type_size():
-  jacklib.jack_port_type_size.argtypes = None
-  jacklib.jack_port_type_size.restype = c_int
   return jacklib.jack_port_type_size()
 
-def port_type_get_buffer_size(client, port_type):
-  jacklib.jack_port_type_get_buffer_size.argtypes = [POINTER(jack_client_t), c_char_p]
-  jacklib.jack_port_type_get_buffer_size.restype = c_size_t
-  return jacklib.jack_port_type_get_buffer_size(client, port_type.encode("ascii"))
+def port_type_get_buffer_size(client, port_type): # JACK_WEAK_EXPORT
+  if (jacklib.jack_port_type_get_buffer_size):
+    return jacklib.jack_port_type_get_buffer_size(client, port_type.encode("ascii"))
+  return 0
 
 
 # Latency Functions
 
-def port_set_latency(port, nframes):
-  jacklib.jack_port_set_latency.argtypes = [POINTER(jack_port_t), jack_nframes_t]
-  jacklib.jack_port_set_latency.restype = None
-  jacklib.jack_port_set_latency(port, nframes)
+jacklib.jack_port_set_latency.argtypes = [POINTER(jack_port_t), jack_nframes_t]
+jacklib.jack_port_set_latency.restype = None
 
-def port_get_latency_range(port, mode, range_):
+try: # JACK_WEAK_EXPORT
   jacklib.jack_port_get_latency_range.argtypes = [POINTER(jack_port_t), jack_latency_callback_mode_t, POINTER(jack_latency_range_t)]
   jacklib.jack_port_get_latency_range.restype = None
-  jacklib.jack_port_get_latency_range(port, mode, range_)
+except:
+  jacklib.jack_port_get_latency_range = None
 
-def port_set_latency_range(port, mode, range_):
+try: # JACK_WEAK_EXPORT
   jacklib.jack_port_set_latency_range.argtypes = [POINTER(jack_port_t), jack_latency_callback_mode_t, POINTER(jack_latency_range_t)]
   jacklib.jack_port_set_latency_range.restype = None
-  jacklib.jack_port_set_latency_range(port, mode, range_)
+except:
+  jacklib.jack_port_set_latency_range = None
+
+jacklib.jack_recompute_total_latencies.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_recompute_total_latencies.restype = c_int
+
+jacklib.jack_port_get_latency.argtypes = [POINTER(jack_port_t)]
+jacklib.jack_port_get_latency.restype = jack_nframes_t
+
+jacklib.jack_port_get_total_latency.argtypes = [POINTER(jack_client_t), POINTER(jack_port_t)]
+jacklib.jack_port_get_total_latency.restype = jack_nframes_t
+
+jacklib.jack_recompute_total_latency.argtypes = [POINTER(jack_client_t), POINTER(jack_port_t)]
+jacklib.jack_recompute_total_latency.restype = c_int
+
+def port_set_latency(port, nframes):
+  jacklib.jack_port_set_latency(port, nframes)
+
+def port_get_latency_range(port, mode, range_): # JACK_WEAK_EXPORT
+  if (jacklib.jack_port_get_latency_range):
+    jacklib.jack_port_get_latency_range(port, mode, range_)
+
+def port_set_latency_range(port, mode, range_): # JACK_WEAK_EXPORT
+  if (jacklib.jack_port_set_latency_range):
+    jacklib.jack_port_set_latency_range(port, mode, range_)
 
 def recompute_total_latencies():
-  jacklib.recompute_total_latencies.argtypes = [POINTER(jack_client_t)]
-  jacklib.recompute_total_latencies.restype = c_int
-  return jacklib.recompute_total_latencies()
+  return jacklib.jack_recompute_total_latencies()
 
 def port_get_latency(port):
-  jacklib.jack_port_get_latency.argtypes = [POINTER(jack_port_t)]
-  jacklib.jack_port_get_latency.restype = jack_nframes_t
   return jacklib.jack_port_get_latency(port)
 
 def port_get_total_latency(client, port):
-  jacklib.jack_port_get_total_latency.argtypes = [POINTER(jack_client_t), POINTER(jack_port_t)]
-  jacklib.jack_port_get_total_latency.restype = jack_nframes_t
   return jacklib.jack_port_get_total_latency(client, port)
 
 def recompute_total_latency(client, port):
-  jacklib.jack_recompute_total_latency.argtypes = [POINTER(jack_client_t), POINTER(jack_port_t)]
-  jacklib.jack_recompute_total_latency.restype = c_int
   return jacklib.jack_recompute_total_latency(client, port)
 
 
 # Port Searching
 
+jacklib.jack_get_ports.argtypes = [POINTER(jack_client_t), c_char_p, c_char_p, c_ulong]
+jacklib.jack_get_ports.restype = POINTER(c_char_p)
+
+jacklib.jack_port_by_name.argtypes = [POINTER(jack_client_t), c_char_p]
+jacklib.jack_port_by_name.restype = POINTER(jack_port_t)
+
+jacklib.jack_port_by_id.argtypes = [POINTER(jack_client_t), jack_port_id_t]
+jacklib.jack_port_by_id.restype = POINTER(jack_port_t)
+
 def get_ports(client, port_name_pattern, type_name_pattern, flags):
-  jacklib.jack_get_ports.argtypes = [POINTER(jack_client_t), c_char_p, c_char_p, c_ulong]
-  jacklib.jack_get_ports.restype = POINTER(c_char_p)
   return jacklib.jack_get_ports(client, port_name_pattern.encode("ascii"), type_name_pattern.encode("ascii"), flags)
 
 def port_by_name(client, port_name):
-  jacklib.jack_port_by_name.argtypes = [POINTER(jack_client_t), c_char_p]
-  jacklib.jack_port_by_name.restype = POINTER(jack_port_t)
   return jacklib.jack_port_by_name(client, port_name.encode("ascii"))
 
 def port_by_id(client, port_id):
-  jacklib.jack_port_by_id.argtypes = [POINTER(jack_client_t), jack_port_id_t]
-  jacklib.jack_port_by_id.restype = POINTER(jack_port_t)
   return jacklib.jack_port_by_id(client, port_id)
 
 
 # Time Functions
 
+jacklib.jack_frames_since_cycle_start.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_frames_since_cycle_start.restype = jack_nframes_t
+
+jacklib.jack_frame_time.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_frame_time.restype = jack_nframes_t
+
+jacklib.jack_last_frame_time.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_last_frame_time.restype = jack_nframes_t
+
+jacklib.jack_frames_to_time.argtypes = [POINTER(jack_client_t), jack_nframes_t]
+jacklib.jack_frames_to_time.restype = jack_time_t
+
+jacklib.jack_time_to_frames.argtypes = [POINTER(jack_client_t), jack_time_t]
+jacklib.jack_time_to_frames.restype = jack_nframes_t
+
+jacklib.jack_get_time.argtypes = None
+jacklib.jack_get_time.restype = jack_time_t
+
 def frames_since_cycle_start(client):
-  jacklib.jack_frames_since_cycle_start.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_frames_since_cycle_start.restype = jack_nframes_t
   return jacklib.jack_frames_since_cycle_start(client)
 
 def frame_time(client):
-  jacklib.jack_frame_time.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_frame_time.restype = jack_nframes_t
   return jacklib.jack_frame_time(client)
 
 def last_frame_time(client):
-  jacklib.jack_last_frame_time.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_last_frame_time.restype = jack_nframes_t
   return jacklib.jack_last_frame_time(client)
 
 def frames_to_time(client, nframes):
-  jacklib.jack_frames_to_time.argtypes = [POINTER(jack_client_t), jack_nframes_t]
-  jacklib.jack_frames_to_time.restype = jack_time_t
   return jacklib.jack_frames_to_time(client, nframes)
 
 def time_to_frames(client, time):
-  jacklib.jack_time_to_frames.argtypes = [POINTER(jack_client_t), jack_time_t]
-  jacklib.jack_time_to_frames.restype = jack_nframes_t
   return jacklib.jack_time_to_frames(client, time)
 
 def get_time():
-  jacklib.jack_get_time.argtypes = None
-  jacklib.jack_get_time.restype = jack_time_t
   return jacklib.jack_get_time()
 
 
@@ -731,167 +866,254 @@ def get_time():
 
 # Misc
 
+jacklib.jack_free.argtypes = [c_void_p]
+jacklib.jack_free.restype = None
+
 def free(ptr):
-  jacklib.jack_free.argtypes = [c_void_p]
-  jacklib.jack_free.restype = None
   return jacklib.jack_free(ptr)
 
 
 # Transport
 
+global _sync_callback
+global _timebase_callback
+
+_sync_callback = _timebase_callback = None
+
+jacklib.jack_release_timebase.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_release_timebase.restype = c_int
+
+jacklib.jack_set_sync_callback.argtypes = [POINTER(jack_client_t), JackSyncCallback, c_void_p]
+jacklib.jack_set_sync_callback.restype = c_int
+
+jacklib.jack_set_sync_timeout.argtypes = [POINTER(jack_client_t), jack_time_t]
+jacklib.jack_set_sync_timeout.restype = c_int
+
+jacklib.jack_set_timebase_callback.argtypes = [POINTER(jack_client_t), c_int, JackTimebaseCallback, c_void_p]
+jacklib.jack_set_timebase_callback.restype = c_int
+
+jacklib.jack_transport_locate.argtypes = [POINTER(jack_client_t), jack_nframes_t]
+jacklib.jack_transport_locate.restype = c_int
+
+jacklib.jack_transport_query.argtypes = [POINTER(jack_client_t), POINTER(jack_position_t)]
+jacklib.jack_transport_query.restype = jack_transport_state_t
+
+jacklib.jack_get_current_transport_frame.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_get_current_transport_frame.restype = jack_nframes_t
+
+jacklib.jack_transport_reposition.argtypes = [POINTER(jack_client_t), POINTER(jack_position_t)]
+jacklib.jack_transport_reposition.restype = c_int
+
+jacklib.jack_transport_start.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_transport_start.restype = None
+
+jacklib.jack_transport_stop.argtypes = [POINTER(jack_client_t)]
+jacklib.jack_transport_stop.restype = None
+
+jacklib.jack_get_transport_info.argtypes = [POINTER(jack_client_t), POINTER(jack_transport_info_t)]
+jacklib.jack_get_transport_info.restype = None
+
+jacklib.jack_set_transport_info.argtypes = [POINTER(jack_client_t), POINTER(jack_transport_info_t)]
+jacklib.jack_set_transport_info.restype = None
+
 def release_timebase(client):
-  jacklib.jack_release_timebase.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_release_timebase.restype = c_int
   return jacklib.jack_release_timebase(client)
 
 def set_sync_callback(client, sync_callback, arg):
   global _sync_callback
   _sync_callback = JackSyncCallback(sync_callback)
-  jacklib.jack_set_sync_callback.argtypes = [POINTER(jack_client_t), JackSyncCallback, c_void_p]
-  jacklib.jack_set_sync_callback.restype = c_int
   return jacklib.jack_set_sync_callback(client, _sync_callback, arg)
 
 def set_sync_timeout(client, timeout):
-  jacklib.jack_set_sync_timeout.argtypes = [POINTER(jack_client_t), jack_time_t]
-  jacklib.jack_set_sync_timeout.restype = c_int
   return jacklib.jack_set_sync_timeout(client, timeout)
 
 def set_timebase_callback(client, conditional, timebase_callback, arg):
   global _timebase_callback
   _timebase_callback = JackTimebaseCallback(timebase_callback)
-  jacklib.jack_set_timebase_callback.argtypes = [POINTER(jack_client_t), c_int, JackTimebaseCallback, c_void_p]
-  jacklib.jack_set_timebase_callback.restype = c_int
   return jacklib.jack_set_timebase_callback(client, conditional, _timebase_callback, arg)
 
 def transport_locate(client, frame):
-  jacklib.jack_transport_locate.argtypes = [POINTER(jack_client_t), jack_nframes_t]
-  jacklib.jack_transport_locate.restype = c_int
   return jacklib.jack_transport_locate(client, frame)
 
 def transport_query(client, pos):
-  jacklib.jack_transport_query.argtypes = [POINTER(jack_client_t), POINTER(jack_position_t)]
-  jacklib.jack_transport_query.restype = jack_transport_state_t
   return jacklib.jack_transport_query(client, pos)
 
 def get_current_transport_frame(client):
-  jacklib.jack_get_current_transport_frame.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_get_current_transport_frame.restype = jack_nframes_t
   return jacklib.jack_get_current_transport_frame(client)
 
 def transport_reposition(client, pos):
-  jacklib.jack_transport_reposition.argtypes = [POINTER(jack_client_t), POINTER(jack_position_t)]
-  jacklib.jack_transport_reposition.restype = c_int
   return jacklib.jack_transport_reposition(client, pos)
 
 def transport_start(client):
-  jacklib.jack_transport_start.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_transport_start.restype = None
   return jacklib.jack_transport_start(client)
 
 def transport_stop(client):
-  jacklib.jack_transport_stop.argtypes = [POINTER(jack_client_t)]
-  jacklib.jack_transport_stop.restype = None
   return jacklib.jack_transport_stop(client)
 
 def get_transport_info(client, tinfo):
-  jacklib.jack_get_transport_info.argtypes = [POINTER(jack_client_t), POINTER(jack_transport_info_t)]
-  jacklib.jack_get_transport_info.restype = None
   return jacklib.jack_get_transport_info(client, tinfo)
 
 def set_transport_info(client, tinfo):
-  jacklib.jack_set_transport_info.argtypes = [POINTER(jack_client_t), POINTER(jack_transport_info_t)]
-  jacklib.jack_set_transport_info.restype = None
   return jacklib.jack_set_transport_info(client, tinfo)
 
 
 # MIDI
 
+jacklib.jack_midi_get_event_count.argtypes = [c_void_p]
+jacklib.jack_midi_get_event_count.restype = jack_nframes_t
+
+jacklib.jack_midi_event_get.argtypes = [POINTER(jack_midi_event_t), c_void_p, c_uint32]
+jacklib.jack_midi_event_get.restype = c_int
+
+jacklib.jack_midi_clear_buffer.argtypes = [c_void_p]
+jacklib.jack_midi_clear_buffer.restype = None
+
+jacklib.jack_midi_max_event_size.argtypes = [c_void_p]
+jacklib.jack_midi_max_event_size.restype = c_size_t
+
+jacklib.jack_midi_event_reserve.argtypes = [c_void_p, jack_nframes_t, c_size_t]
+jacklib.jack_midi_event_reserve.restype = POINTER(jack_midi_data_t)
+
+jacklib.jack_midi_event_write.argtypes = [c_void_p, jack_nframes_t, POINTER(jack_midi_data_t), c_size_t]
+jacklib.jack_midi_event_write.restype = c_int
+
+jacklib.jack_midi_get_lost_event_count.argtypes = [c_void_p]
+jacklib.jack_midi_get_lost_event_count.restype = c_uint32
+
 def midi_get_event_count(port_buffer):
-  jacklib.jack_midi_get_event_count.argtypes = [c_void_p]
-  jacklib.jack_midi_get_event_count.restype = jack_nframes_t
   return jacklib.jack_midi_get_event_count(port_buffer)
 
 def midi_event_get(event, port_buffer, event_index):
-  jacklib.jack_midi_event_get.argtypes = [POINTER(jack_midi_event_t), c_void_p, c_uint32]
-  jacklib.jack_midi_event_get.restype = c_int
   return jacklib.jack_midi_event_get(event, port_buffer, event_index)
 
 def midi_clear_buffer(port_buffer):
-  jacklib.jack_midi_clear_buffer.argtypes = [c_void_p]
-  jacklib.jack_midi_clear_buffer.restype = None
   return jacklib.jack_midi_clear_buffer(port_buffer)
 
 def midi_max_event_size(port_buffer):
-  jacklib.jack_midi_max_event_size.argtypes = [c_void_p]
-  jacklib.jack_midi_max_event_size.restype = c_size_t
   return jacklib.jack_midi_max_event_size(port_buffer)
 
 def midi_event_reserve(port_buffer, time, data_size):
-  jacklib.jack_midi_event_reserve.argtypes = [c_void_p, jack_nframes_t, c_size_t]
-  jacklib.jack_midi_event_reserve.restype = POINTER(jack_midi_data_t)
   return jacklib.jack_midi_event_reserve(port_buffer, time, data_size)
 
 def midi_event_write(port_buffer, time, data, data_size):
-  jacklib.jack_midi_event_write.argtypes = [c_void_p, jack_nframes_t, POINTER(jack_midi_data_t), c_size_t]
-  jacklib.jack_midi_event_write.restype = c_int
   return jacklib.jack_midi_event_write(port_buffer, time, data, data_size)
 
 def midi_get_lost_event_count(port_buffer):
-  jacklib.jack_midi_get_lost_event_count.argtypes = [c_void_p]
-  jacklib.jack_midi_get_lost_event_count.restype = c_uint32
   return jacklib.jack_midi_get_lost_event_count(port_buffer)
 
 
 # Session
 
-def set_session_callback(client, session_callback, arg):
-  global _session_callback
-  _session_callback = JackSessionCallback(session_callback)
+global _session_callback
+
+_session_callback = None
+
+try: # JACK_WEAK_EXPORT
   jacklib.jack_set_session_callback.argtypes = [POINTER(jack_client_t), JackSessionCallback, c_void_p]
   jacklib.jack_set_session_callback.restype = c_int
-  return jacklib.jack_set_session_callback(client, _session_callback, arg)
+except:
+  jacklib.jack_set_session_callback = None
 
-def session_reply(client, event):
+try: # JACK_WEAK_EXPORT
   jacklib.jack_session_reply.argtypes = [POINTER(jack_client_t), POINTER(jack_session_event_t)]
   jacklib.jack_session_reply.restype = c_int
-  return jacklib.jack_session_reply(client, event)
+except:
+  jacklib.jack_session_reply = None
 
-def session_event_free(event):
+try: # JACK_WEAK_EXPORT
   jacklib.jack_session_event_free.argtypes = [POINTER(jack_session_event_t)]
-  jacklib.jack_session_event_free.restype = c_int
-  return jacklib.jack_session_event_free(event)
+  jacklib.jack_session_event_free.restype = None
+except:
+  jacklib.jack_session_event_free = None
 
-def client_get_uuid(client):
+try: # JACK_WEAK_EXPORT
   jacklib.jack_client_get_uuid.argtypes = [POINTER(jack_client_t)]
   jacklib.jack_client_get_uuid.restype = c_char_p
-  return jacklib.jack_client_get_uuid(client)
+except:
+  jacklib.jack_client_get_uuid = None
 
-def session_notify(client, target, type_, path):
+try: # JACK_WEAK_EXPORT
   jacklib.jack_session_notify.argtypes = [POINTER(jack_client_t), c_char_p, jack_session_event_type_t, c_char_p]
   jacklib.jack_session_notify.restype = POINTER(jack_session_command_t)
-  return jacklib.jack_session_notify(client, target.encode("ascii"), type_, path.encode("ascii"))
+except:
+  jacklib.jack_session_notify = None
 
-def session_commands_free(cmds):
+try: # JACK_WEAK_EXPORT
   jacklib.jack_session_commands_free.argtypes = [POINTER(jack_session_command_t)]
   jacklib.jack_session_commands_free.restype = None
-  return jacklib.jack_session_commands_free(cmds)
+except:
+  jacklib.jack_session_commands_free = None
 
-def get_uuid_for_client_name(client, client_name):
+try: # JACK_WEAK_EXPORT
   jacklib.jack_get_uuid_for_client_name.argtypes = [POINTER(jack_client_t), c_char_p]
   jacklib.jack_get_uuid_for_client_name.restype = c_char_p
-  return jacklib.jack_get_uuid_for_client_name(client, client_name.encode("ascii"))
+except:
+  jacklib.jack_get_uuid_for_client_name = None
 
-def get_client_name_by_uuid(client, client_uuid):
+try: # JACK_WEAK_EXPORT
   jacklib.jack_get_client_name_by_uuid.argtypes = [POINTER(jack_client_t), c_char_p]
   jacklib.jack_get_client_name_by_uuid.restype = c_char_p
-  return jacklib.jack_get_client_name_by_uuid(client, client_uuid.encode("ascii"))
+except:
+  jacklib.jack_get_client_name_by_uuid = None
 
-def reserve_client_name(client, name, uuid):
+try: # JACK_WEAK_EXPORT
   jacklib.jack_reserve_client_name.argtypes = [POINTER(jack_client_t), c_char_p, c_char_p]
   jacklib.jack_reserve_client_name.restype = c_int
-  return jacklib.jack_reserve_client_name(client, name.encode("ascii"), uuid.encode("ascii"))
+except:
+  jacklib.jack_reserve_client_name = None
 
-def client_has_session_callback(client, client_name):
+try: # JACK_WEAK_EXPORT
   jacklib.jack_client_has_session_callback.argtypes = [POINTER(jack_client_t), c_char_p]
   jacklib.jack_client_has_session_callback.restype = c_int
-  return jacklib.jack_client_has_session_callback(client, client_name.encode("ascii"))
+except:
+  jacklib.jack_client_has_session_callback = None
+
+def set_session_callback(client, session_callback, arg): # JACK_WEAK_EXPORT
+  if (jacklib.jack_set_session_callback):
+    global _session_callback
+    _session_callback = JackSessionCallback(session_callback)
+    return jacklib.jack_set_session_callback(client, _session_callback, arg)
+  return -1
+
+def session_reply(client, event): # JACK_WEAK_EXPORT
+  if (jacklib.jack_session_reply):
+    return jacklib.jack_session_reply(client, event)
+  return -1
+
+def session_event_free(event): # JACK_WEAK_EXPORT
+  if (jacklib.jack_session_event_free):
+    jacklib.jack_session_event_free(event)
+
+def client_get_uuid(client): # JACK_WEAK_EXPORT
+  if (jacklib.jack_client_get_uuid):
+    return jacklib.jack_client_get_uuid(client)
+  return c_char_p()
+
+def session_notify(client, target, type_, path): # JACK_WEAK_EXPORT
+  if (jacklib.jack_session_notify):
+    return jacklib.jack_session_notify(client, target.encode("ascii"), type_, path.encode("ascii"))
+  return jack_session_command_t()
+
+def session_commands_free(cmds): # JACK_WEAK_EXPORT
+  if (jacklib.jack_session_commands_free):
+    jacklib.jack_session_commands_free(cmds)
+
+def get_uuid_for_client_name(client, client_name): # JACK_WEAK_EXPORT
+  if (jacklib.jack_get_uuid_for_client_name):
+    return jacklib.jack_get_uuid_for_client_name(client, client_name.encode("ascii"))
+  return c_char_p()
+
+def get_client_name_by_uuid(client, client_uuid): # JACK_WEAK_EXPORT
+  if (jacklib.jack_get_client_name_by_uuid):
+    return jacklib.jack_get_client_name_by_uuid(client, client_uuid.encode("ascii"))
+  return c_char_p()
+
+def reserve_client_name(client, name, uuid): # JACK_WEAK_EXPORT
+  if (jacklib.jack_reserve_client_name):
+    return jacklib.jack_reserve_client_name(client, name.encode("ascii"), uuid.encode("ascii"))
+  return -1
+
+def client_has_session_callback(client, client_name): # JACK_WEAK_EXPORT
+  if (jacklib.jack_client_has_session_callback):
+    return jacklib.jack_client_has_session_callback(client, client_name.encode("ascii"))
+  return -1
diff --git a/src/jackmeter.py b/src/jackmeter.py
index 3e102f6..62c9282 100755
--- a/src/jackmeter.py
+++ b/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))))
diff --git a/src/jacksettings.py b/src/jacksettings.py
index 46c2e96..31b8187 100755
--- a/src/jacksettings.py
+++ b/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_())
diff --git a/src/logs.py b/src/logs.py
index ee82df5..f626b06 100755
--- a/src/logs.py
+++ b/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
diff --git a/src/render.py b/src/render.py
index 5206c4b..6ecd52d 100755
--- a/src/render.py
+++ b/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
diff --git a/src/shared.py b/src/shared.py
index cecb22b..d00749d 100644
--- a/src/shared.py
+++ b/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"))
diff --git a/src/shared_canvas.py b/src/shared_canvas.py
index 4a6c44e..0e989d9 100644
--- a/src/shared_canvas.py
+++ b/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_))
diff --git a/src/shared_jack.py b/src/shared_jack.py
index 781396e..c9874c9 100644
--- a/src/shared_jack.py
+++ b/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)
diff --git a/src/shared_settings.py b/src/shared_settings.py
index 8bedb8c..3eca4c5 100644
--- a/src/shared_settings.py
+++ b/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)
 
diff --git a/src/ui/claudia.ui b/src/ui/claudia.ui
index 908cef7..5f2dc4c 100644
--- a/src/ui/claudia.ui
+++ b/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>
diff --git a/src/xycontroller.py b/src/xycontroller.py
index 14a87b8..4884dfc 100755
--- a/src/xycontroller.py
+++ b/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))))