jacksettings/jacksettings.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 # Imports (Global)
   5 import dbus, sys
   6 from PyQt4.QtCore import Qt, SIGNAL
   7 from PyQt4.QtGui import QApplication, QDialog, QDialogButtonBox, QMessageBox
   8
   9 # Imports (Plugins and Resources)
  10 import ui_settings_jack
  11
  12 global jackctl
  13 jackctl = None
  14
  15 state_driver_list = ["alsa","firewire","netone"]
  16
  17 # Connect to DBus
  18 def initBus(bus):
  19   global jackctl
  20   try:
  21     jackctl = dbus.Interface(bus.get_object("org.jackaudio.service", "/org/jackaudio/Controller"), "org.jackaudio.Configure")
  22     return 0
  23   except:
  24     jackctl = None
  25     return 1
  26
  27 def getBufferSize():
  28   if (jackctl and jackctl.GetParameterValue(["engine","driver"])[2] in state_driver_list):
  29     return jackctl.GetParameterValue(["driver","period"])[2]
  30   else:
  31     return None
  32
  33 def getSampleRate():
  34   if (jackctl and jackctl.GetParameterValue(["engine","driver"])[2] in state_driver_list):
  35     return jackctl.GetParameterValue(["driver","rate"])[2]
  36   else:
  37     return None
  38
  39 def isRealtime():
  40   return bool(jackctl.GetParameterValue(["engine","realtime"])[2])
  41
  42 def setBufferSize(bsize):
  43   bsize = dbus.UInt32(bsize)
  44   if (jackctl and jackctl.GetParameterValue(["engine","driver"])[2] in state_driver_list):
  45     return jackctl.SetParameterValue(["driver","period"],bsize)
  46   else:
  47     return False
  48
  49 def setSampleRate(srate):
  50   srate = dbus.UInt32(srate)
  51   if (jackctl and jackctl.GetParameterValue(["engine","driver"])[2] in state_driver_list):
  52     return jackctl.SetParameterValue(["driver","rate"],srate)
  53   else:
  54     return False
  55
  56 # Jack Settings Dialog
  57 class JackSettingsW(QDialog, ui_settings_jack.Ui_JackSettingsW):
  58     def __init__(self, parent=None):
  59         super(JackSettingsW, self).__init__(parent)
  60         self.setupUi(self)
  61
  62         if not jackctl:
  63           QMessageBox.warning(self, self.tr("Failed"), self.tr("jackdbus is not available!\nIs not possible to configure JACK at this point."))
  64
  65         self.driver = None
  66         driver_list = jackctl.ReadContainer(["drivers"])[1]
  67
  68         try:
  69           jackctl.GetParameterValue(["engine","self-connect-mode"])
  70         except:
  71           self.group_server_self_connect_mode.setEnabled(False)
  72
  73         for i in range(self.obj_server_driver.rowCount()):
  74           self.obj_server_driver.item(0, i).setTextAlignment(Qt.AlignCenter)
  75           if (not self.obj_server_driver.item(0, i).text().toLower() in driver_list):
  76             self.obj_server_driver.hideRow(i)
  77
  78         self.connect(self.buttonBox.button(QDialogButtonBox.Reset), SIGNAL("clicked()"), self.resetJackSettings)
  79         self.connect(self, SIGNAL("accepted()"), self.saveJackSettings)
  80
  81         self.connect(self.obj_driver_duplex, SIGNAL("clicked(bool)"), self.checkDuplexSelection)
  82         self.connect(self.obj_server_driver, SIGNAL("currentCellChanged(int, int, int, int)"), self.checkDriverSelection)
  83
  84         self.loadServerSettings()
  85         self.loadDriverSettings(True)
  86
  87         # Load selected Jack driver
  88         self.driver = jackctl.GetParameterValue(["engine","driver"])[2]
  89         for i in range(self.obj_server_driver.rowCount()):
  90           if (self.obj_server_driver.item(i, 0).text().toLower() == self.driver):
  91             self.obj_server_driver.setCurrentCell(i, 0)
  92             break
  93
  94     def resetJackSettings(self):
  95         if (self.tabWidget.currentIndex() == 0):
  96           self.loadServerSettings(True, True)
  97         elif (self.tabWidget.currentIndex() == 1):
  98           self.loadDriverSettings(True, True)
  99
 100     def saveJackSettings(self):
 101         self.saveServerSettings()
 102         self.saveDriverSettings()
 103
 104     def loadJackSettings(self):
 105         self.loadServerSettings()
 106         self.loadDriverSettings()
 107
 108     def saveServerSettings(self):
 109         server_name = unicode(self.obj_server_name.text())
 110         if (server_name != jackctl.GetParameterValue(["engine","name"])[2]):
 111           jackctl.SetParameterValue(["engine","name"],server_name)
 112
 113         realtime = self.obj_server_realtime.isChecked()
 114         if (realtime != jackctl.GetParameterValue(["engine","realtime"])[2]):
 115           jackctl.SetParameterValue(["engine","realtime"],realtime)
 116
 117         realtime_priority = self.obj_server_realtime_priority.value()
 118         if (realtime_priority != jackctl.GetParameterValue(["engine","realtime-priority"])[2]):
 119           jackctl.SetParameterValue(["engine","realtime-priority"],realtime_priority)
 120
 121         temporary = self.obj_server_temporary.isChecked()
 122         if (temporary != jackctl.GetParameterValue(["engine","temporary"])[2]):
 123           jackctl.SetParameterValue(["engine","temporary"],temporary)
 124
 125         verbose = self.obj_server_verbose.isChecked()
 126         if (verbose != jackctl.GetParameterValue(["engine","verbose"])[2]):
 127           jackctl.SetParameterValue(["engine","verbose"],verbose)
 128
 129         client_timeout = self.obj_server_client_timeout.currentText().toInt()[0]
 130         if (client_timeout != jackctl.GetParameterValue(["engine","client-timeout"])[2]):
 131           jackctl.SetParameterValue(["engine","client-timeout"],client_timeout)
 132
 133         # FIXME - need to know how this works, but it's probably broken
 134         #if (self.obj_server_clock_source_cycle.isChecked()):
 135           #clock_source = dbus.Byte("c")
 136         #elif (self.obj_server_clock_source_hpet.isChecked()):
 137           #clock_source = dbus.Byte("h")
 138         #elif (self.obj_server_clock_source_system.isChecked()):
 139           #clock_source = dbus.Byte("s")
 140         #if (clock_source != jackctl.GetParameterValue(["engine","clock-source"])[2]):
 141           #jackctl.SetParameterValue(["engine","clock-source"],clock_source)
 142
 143         port_max = self.obj_server_port_max.currentText().toInt()[0]
 144         if (port_max != jackctl.GetParameterValue(["engine","port-max"])[2]):
 145           jackctl.SetParameterValue(["engine","port-max"],port_max)
 146
 147         replace_registry = self.obj_server_replace_registry.isChecked()
 148         if (replace_registry != jackctl.GetParameterValue(["engine","replace-registry"])[2]):
 149           jackctl.SetParameterValue(["engine","replace-registry"],replace_registry)
 150
 151         sync = self.obj_server_sync.isChecked()
 152         if (sync != jackctl.GetParameterValue(["engine","sync"])[2]):
 153           jackctl.SetParameterValue(["engine","sync"],sync)
 154
 155         if (self.obj_server_self_connect_mode_0.isChecked()):
 156           self_connect_mode = dbus.Byte(" ")
 157         elif (self.obj_server_self_connect_mode_1.isChecked()):
 158           self_connect_mode = dbus.Byte("E")
 159         elif (self.obj_server_self_connect_mode_2.isChecked()):
 160           self_connect_mode = dbus.Byte("e")
 161         elif (self.obj_server_self_connect_mode_3.isChecked()):
 162           self_connect_mode = dbus.Byte("A")
 163         elif (self.obj_server_self_connect_mode_4.isChecked()):
 164           self_connect_mode = dbus.Byte("a")
 165         if (self_connect_mode != jackctl.GetParameterValue(["engine","self-connect-mode"])[2]):
 166           jackctl.SetParameterValue(["engine","self-connect-mode"],self_connect_mode)
 167
 168     def loadServerSettings(self, reset=False, force_reset=False):
 169         settings = jackctl.ReadContainer(["engine"])
 170         for i in range(len(settings[1])):
 171           attribute = settings[1][i]
 172           if (reset):
 173             value = jackctl.GetParameterValue(["engine",attribute])[1]
 174             if (force_reset and attribute != "driver"):
 175               jackctl.ResetParameterValue(["engine",attribute])
 176           else:
 177             value = jackctl.GetParameterValue(["engine",attribute])[2]
 178
 179           if (attribute == "name"):
 180             self.obj_server_name.setText(unicode(value))
 181           elif (attribute == "realtime"):
 182             self.obj_server_realtime.setChecked(bool(value))
 183           elif (attribute == "realtime-priority"):
 184             self.obj_server_realtime_priority.setValue(int(value))
 185           elif (attribute == "temporary"):
 186             self.obj_server_temporary.setChecked(bool(value))
 187           elif (attribute == "verbose"):
 188             self.obj_server_verbose.setChecked(bool(value))
 189           elif (attribute == "client-timeout"):
 190             self.setComboBoxValue(self.obj_server_client_timeout, str(value))
 191           elif (attribute == "clock-source"):
 192             value = str(value)
 193             if (value == "h"):
 194               self.obj_server_clock_source_hpet.setChecked(True)
 195             elif (value == "s"):
 196               self.obj_server_clock_source_system.setChecked(True)
 197             elif (value == "c"):
 198               self.obj_server_clock_source_cycle.setChecked(True)
 199           elif (attribute == "port-max"):
 200             self.setComboBoxValue(self.obj_server_port_max, str(value))
 201           elif (attribute == "replace-registry"):
 202             self.obj_server_replace_registry.setChecked(bool(value))
 203           elif (attribute == "sync"):
 204             self.obj_server_sync.setChecked(bool(value))
 205           elif (attribute == "self-connect-mode"):
 206             value = str(value)
 207             if (value == "E"):
 208               self.obj_server_self_connect_mode_1.setChecked(True)
 209             elif (value == "e"):
 210               self.obj_server_self_connect_mode_2.setChecked(True)
 211             elif (value == "A"):
 212               self.obj_server_self_connect_mode_3.setChecked(True)
 213             elif (value == "a"):
 214               self.obj_server_self_connect_mode_4.setChecked(True)
 215             else: #(value == " ")
 216               self.obj_server_self_connect_mode_0.setChecked(True)
 217
 218     def saveDriverSettings(self):
 219         if (self.obj_driver_device.isEnabled()):
 220           value = unicode(self.obj_driver_device.currentText()).split(" ")[0]
 221           if (value != jackctl.GetParameterValue(["driver","device"])[2]):
 222             jackctl.SetParameterValue(["driver","device"],value)
 223
 224         if (self.obj_driver_capture.isEnabled()):
 225           if (self.driver == "alsa"):
 226             value = unicode(self.obj_driver_capture.currentText()).split(" ")[0]
 227           elif (self.driver == "firewire"):
 228             value = True if (self.obj_driver_capture.currentIndex() == 1) else False
 229           if (value != jackctl.GetParameterValue(["driver","capture"])[2]):
 230             jackctl.SetParameterValue(["driver","capture"],value)
 231
 232         if (self.obj_driver_playback.isEnabled()):
 233           if (self.driver == "alsa"):
 234             value = unicode(self.obj_driver_playback.currentText()).split(" ")[0]
 235           elif (self.driver == "firewire"):
 236             value = True if (self.obj_driver_playback.currentIndex() == 1) else False
 237           if (value != jackctl.GetParameterValue(["driver","playback"])[2]):
 238             jackctl.SetParameterValue(["driver","playback"],value)
 239
 240         if (self.obj_driver_rate.isEnabled()):
 241           value = dbus.UInt32(self.obj_driver_rate.currentText().toInt()[0])
 242           if (value != jackctl.GetParameterValue(["driver","rate"])[2]):
 243             jackctl.SetParameterValue(["driver","rate"],value)
 244
 245         if (self.obj_driver_period.isEnabled()):
 246           value = dbus.UInt32(self.obj_driver_period.currentText().toInt()[0])
 247           if (value != jackctl.GetParameterValue(["driver","period"])[2]):
 248             jackctl.SetParameterValue(["driver","period"],value)
 249
 250         if (self.obj_driver_nperiods.isEnabled()):
 251           value = dbus.UInt32(self.obj_driver_nperiods.value())
 252           if (value != jackctl.GetParameterValue(["driver","nperiods"])[2]):
 253             jackctl.SetParameterValue(["driver","nperiods"],value)
 254
 255         if (self.obj_driver_hwmon.isEnabled()):
 256           value = self.obj_driver_hwmon.isChecked()
 257           if (value != jackctl.GetParameterValue(["driver","hwmon"])[2]):
 258             jackctl.SetParameterValue(["driver","hwmon"],value)
 259
 260         if (self.obj_driver_hwmeter.isEnabled()):
 261           value = self.obj_driver_hwmeter.isChecked()
 262           if (value != jackctl.GetParameterValue(["driver","hwmeter"])[2]):
 263             jackctl.SetParameterValue(["driver","hwmeter"],value)
 264
 265         if (self.obj_driver_duplex.isEnabled()):
 266           value = self.obj_driver_duplex.isChecked()
 267           if (value != jackctl.GetParameterValue(["driver","duplex"])[2]):
 268             jackctl.SetParameterValue(["driver","duplex"],value)
 269
 270         if (self.obj_driver_softmode.isEnabled()):
 271           value = self.obj_driver_softmode.isChecked()
 272           if (value != jackctl.GetParameterValue(["driver","softmode"])[2]):
 273             jackctl.SetParameterValue(["driver","softmode"],value)
 274
 275         if (self.obj_driver_monitor.isEnabled()):
 276           value = self.obj_driver_monitor.isChecked()
 277           if (value != jackctl.GetParameterValue(["driver","monitor"])[2]):
 278             jackctl.SetParameterValue(["driver","monitor"],value)
 279
 280         if (self.obj_driver_dither.isEnabled()):
 281           if (self.obj_driver_dither.currentIndex() == 1):
 282             value = dbus.Byte("r")
 283           elif (self.obj_driver_dither.currentIndex() == 2):
 284             value = dbus.Byte("s")
 285           elif (self.obj_driver_dither.currentIndex() == 3):
 286             value = dbus.Byte("t")
 287           else: # 0
 288             value = dbus.Byte("n")
 289           if (value != jackctl.GetParameterValue(["driver","dither"])[2]):
 290             jackctl.SetParameterValue(["driver","dither"],value)
 291
 292         if (self.obj_driver_inchannels.isEnabled()):
 293           value = dbus.UInt32(self.obj_driver_inchannels.value())
 294           if (value != jackctl.GetParameterValue(["driver","inchannels"])[2]):
 295             jackctl.SetParameterValue(["driver","inchannels"],value)
 296
 297         if (self.obj_driver_outchannels.isEnabled()):
 298           value = dbus.UInt32(self.obj_driver_outchannels.value())
 299           if (value != jackctl.GetParameterValue(["driver","outchannels"])[2]):
 300             jackctl.SetParameterValue(["driver","outchannels"],value)
 301
 302         if (self.obj_driver_shorts.isEnabled()):
 303           value = self.obj_driver_shorts.isChecked()
 304           if (value != jackctl.GetParameterValue(["driver","shorts"])[2]):
 305             jackctl.SetParameterValue(["driver","shorts"],value)
 306
 307         if (self.obj_driver_input_latency.isEnabled()):
 308           value = dbus.UInt32(self.obj_driver_input_latency.value())
 309           if (value != jackctl.GetParameterValue(["driver","input-latency"])[2]):
 310             jackctl.SetParameterValue(["driver","input-latency"],value)
 311
 312         if (self.obj_driver_output_latency.isEnabled()):
 313           value = dbus.UInt32(self.obj_driver_output_latency.value())
 314           if (value != jackctl.GetParameterValue(["driver","output-latency"])[2]):
 315             jackctl.SetParameterValue(["driver","output-latency"],value)
 316
 317         if (self.obj_driver_midi_driver.isEnabled()):
 318           if (self.obj_driver_midi_driver.currentIndex() == 1):
 319             value = "seq"
 320           elif (self.obj_driver_midi_driver.currentIndex() == 2):
 321             value = "raw"
 322           else: # 0
 323             value = "none"
 324           if (value != jackctl.GetParameterValue(["driver","midi-driver"])[2]):
 325             jackctl.SetParameterValue(["driver","midi-driver"],value)
 326
 327         if (self.obj_driver_wait.isEnabled()):
 328           value = dbus.UInt32(self.obj_driver_wait.value())
 329           if (value != jackctl.GetParameterValue(["driver","wait"])[2]):
 330             jackctl.SetParameterValue(["driver","wait"],value)
 331
 332         if (self.obj_driver_verbose.isEnabled()):
 333           value = dbus.UInt32(self.obj_driver_verbose.value())
 334           if (value != jackctl.GetParameterValue(["driver","verbose"])[2]):
 335             jackctl.SetParameterValue(["driver","verbose"],value)
 336
 337         if (self.obj_driver_snoop.isEnabled()):
 338           value = self.obj_driver_snoop.isChecked()
 339           if (value != jackctl.GetParameterValue(["driver","snoop"])[2]):
 340             jackctl.SetParameterValue(["driver","snoop"],value)
 341
 342         if (self.obj_driver_channels.isEnabled()):
 343           value = self.obj_driver_channels.value()
 344           if (value != jackctl.GetParameterValue(["driver","channels"])[2]):
 345             jackctl.SetParameterValue(["driver","channels"],value)
 346
 347     def loadDriverSettings(self, reset=False, force_reset=False):
 348         settings = jackctl.ReadContainer(["driver"])
 349         for i in range(len(settings[1])):
 350           attribute = settings[1][i]
 351           if (reset):
 352             value = jackctl.GetParameterValue(["driver",attribute])[1]
 353             if (force_reset):
 354               jackctl.ResetParameterValue(["driver",attribute])
 355           else:
 356             value = jackctl.GetParameterValue(["driver",attribute])[2]
 357
 358           if (attribute == "device"):
 359             self.setComboBoxValue(self.obj_driver_device, str(value), True)
 360           elif (attribute == "capture"):
 361             if (self.driver == "alsa"):
 362               self.setComboBoxValue(self.obj_driver_capture, str(value), True)
 363             elif (self.driver == "firewire"):
 364               if (bool(value)):
 365                 self.obj_driver_capture.setCurrentIndex(1)
 366               else:
 367                 self.obj_driver_capture.setCurrentIndex(0)
 368           elif (attribute == "playback"):
 369             if (self.driver == "alsa"):
 370               self.setComboBoxValue(self.obj_driver_playback, str(value), True)
 371             elif (self.driver == "firewire"):
 372               if (bool(value)):
 373                 self.obj_driver_playback.setCurrentIndex(1)
 374               else:
 375                 self.obj_driver_playback.setCurrentIndex(0)
 376           elif (attribute == "rate"):
 377             self.setComboBoxValue(self.obj_driver_rate, str(value))
 378           elif (attribute == "period"):
 379             self.setComboBoxValue(self.obj_driver_period, str(value))
 380           elif (attribute == "nperiods"):
 381             self.obj_driver_nperiods.setValue(int(value))
 382           elif (attribute == "hwmon"):
 383             self.obj_driver_hwmon.setChecked(bool(value))
 384           elif (attribute == "hwmeter"):
 385             self.obj_driver_hwmeter.setChecked(bool(value))
 386           elif (attribute == "duplex"):
 387             self.obj_driver_duplex.setChecked(bool(value))
 388           elif (attribute == "softmode"):
 389             self.obj_driver_softmode.setChecked(bool(value))
 390           elif (attribute == "monitor"):
 391             self.obj_driver_monitor.setChecked(bool(value))
 392           elif (attribute == "dither"):
 393             value = str(value)
 394             if (value == "n"):
 395               self.obj_driver_dither.setCurrentIndex(0)
 396             elif (value == "r"):
 397               self.obj_driver_dither.setCurrentIndex(1)
 398             elif (value == "s"):
 399               self.obj_driver_dither.setCurrentIndex(2)
 400             elif (value == "t"):
 401               self.obj_driver_dither.setCurrentIndex(3)
 402           elif (attribute == "inchannels"):
 403             self.obj_driver_inchannels.setValue(int(value))
 404           elif (attribute == "outchannels"):
 405             self.obj_driver_outchannels.setValue(int(value))
 406           elif (attribute == "shorts"):
 407             self.obj_driver_shorts.setChecked(bool(value))
 408           elif (attribute == "input-latency"):
 409             self.obj_driver_input_latency.setValue(int(value))
 410           elif (attribute == "output-latency"):
 411             self.obj_driver_output_latency.setValue(int(value))
 412           elif (attribute == "midi-driver"):
 413             value = str(value)
 414             if (value == "none"):
 415               self.obj_driver_midi_driver.setCurrentIndex(0)
 416             elif (value == "seq"):
 417               self.obj_driver_midi_driver.setCurrentIndex(1)
 418             elif (value == "raw"):
 419               self.obj_driver_midi_driver.setCurrentIndex(2)
 420           elif (attribute == "wait"):
 421             self.obj_driver_wait.setValue(int(value))
 422           elif (attribute == "verbose"):
 423             self.obj_driver_verbose.setValue(int(value))
 424           elif (attribute == "snoop"):
 425             self.obj_driver_snoop.setChecked(bool(value))
 426           elif (attribute == "channels"):
 427             self.obj_driver_channels.setValue(int(value))
 428
 429     def setComboBoxValue(self, box, text, split=False):
 430         for i in range(box.count()):
 431           if (box.itemText(i) == text or (box.itemText(i).split(" ")[0] == text and split)):
 432             box.setCurrentIndex(i)
 433             break
 434         else:
 435           if (text):
 436             box.addItem(text)
 437             box.setCurrentIndex(box.count()-1)
 438
 439     def checkDuplexSelection(self, active):
 440         if (self.driver == "alsa" or self.driver == "firewire"):
 441           self.obj_driver_capture.setEnabled(active)
 442           self.obj_driver_capture_label.setEnabled(active)
 443           self.obj_driver_inchannels.setEnabled(active)
 444           self.obj_driver_inchannels_label.setEnabled(active)
 445           self.obj_driver_input_latency.setEnabled(active)
 446           self.obj_driver_input_latency_label.setEnabled(active)
 447
 448     def checkDriverSelection(self, row, column, prev_row, prev_column):
 449         # Save previous settings
 450         self.saveDriverSettings()
 451
 452         # Set new Jack driver
 453         self.driver = unicode(self.obj_server_driver.item(row, 0).text().toLower())
 454         jackctl.SetParameterValue(["engine","driver"],self.driver)
 455
 456         # Hack for device
 457         self.obj_driver_device.clear()
 458         if (self.driver == "alsa" or self.driver == "firewire"):
 459           dev_list = jackctl.GetParameterConstraint(["driver","device"])[3]
 460           for i in range(len(dev_list)):
 461             self.obj_driver_device.addItem(dev_list[i][0]+" ["+dev_list[i][1]+"]")
 462
 463         # Hack for alsa and firewire capture/playback
 464         self.obj_driver_capture.clear()
 465         self.obj_driver_playback.clear()
 466         if (self.driver == "alsa"):
 467           self.obj_driver_capture.addItem("none")
 468           self.obj_driver_playback.addItem("none")
 469           dev_list = jackctl.GetParameterConstraint(["driver","device"])[3]
 470           for i in range(len(dev_list)):
 471             self.obj_driver_capture.addItem(dev_list[i][0]+" ["+dev_list[i][1]+"]")
 472             self.obj_driver_playback.addItem(dev_list[i][0]+" ["+dev_list[i][1]+"]")
 473         elif (self.driver == "firewire"):
 474           self.obj_driver_capture.addItem("no")
 475           self.obj_driver_capture.addItem("yes")
 476           self.obj_driver_playback.addItem("no")
 477           self.obj_driver_playback.addItem("yes")
 478
 479         # Load Driver Settings
 480         self.loadDriverSettings()
 481
 482         # Disable all widgets
 483         self.obj_driver_capture.setEnabled(False)
 484         self.obj_driver_capture_label.setEnabled(False)
 485         self.obj_driver_playback.setEnabled(False)
 486         self.obj_driver_playback_label.setEnabled(False)
 487         self.obj_driver_device.setEnabled(False)
 488         self.obj_driver_device_label.setEnabled(False)
 489         self.obj_driver_rate.setEnabled(False)
 490         self.obj_driver_rate_label.setEnabled(False)
 491         self.obj_driver_period.setEnabled(False)
 492         self.obj_driver_period_label.setEnabled(False)
 493         self.obj_driver_nperiods.setEnabled(False)
 494         self.obj_driver_nperiods_label.setEnabled(False)
 495         self.obj_driver_hwmon.setEnabled(False)
 496         self.obj_driver_hwmeter.setEnabled(False)
 497         self.obj_driver_duplex.setEnabled(False)
 498         self.obj_driver_softmode.setEnabled(False)
 499         self.obj_driver_monitor.setEnabled(False)
 500         self.obj_driver_dither.setEnabled(False)
 501         self.obj_driver_dither_label.setEnabled(False)
 502         self.obj_driver_inchannels.setEnabled(False)
 503         self.obj_driver_inchannels_label.setEnabled(False)
 504         self.obj_driver_outchannels.setEnabled(False)
 505         self.obj_driver_outchannels_label.setEnabled(False)
 506         self.obj_driver_shorts.setEnabled(False)
 507         self.obj_driver_input_latency.setEnabled(False)
 508         self.obj_driver_input_latency_label.setEnabled(False)
 509         self.obj_driver_output_latency.setEnabled(False)
 510         self.obj_driver_output_latency_label.setEnabled(False)
 511         self.obj_driver_midi_driver.setEnabled(False)
 512         self.obj_driver_midi_driver_label.setEnabled(False)
 513         self.obj_driver_wait.setEnabled(False)
 514         self.obj_driver_wait_label.setEnabled(False)
 515         self.obj_driver_verbose.setEnabled(False)
 516         self.obj_driver_verbose_label.setEnabled(False)
 517         self.obj_driver_snoop.setEnabled(False)
 518         self.obj_driver_channels.setEnabled(False)
 519         self.obj_driver_channels_label.setEnabled(False)
 520
 521         # Restore widgets according to driver
 522         if (self.obj_server_driver.item(0, row).text() == "ALSA"):
 523           self.toolbox_driver_misc.setCurrentIndex(1)
 524           self.obj_driver_capture.setEnabled(True)
 525           self.obj_driver_capture_label.setEnabled(True)
 526           self.obj_driver_capture_label.setText(self.tr("Input Device:"))
 527           self.obj_driver_playback.setEnabled(True)
 528           self.obj_driver_playback_label.setEnabled(True)
 529           self.obj_driver_playback_label.setText(self.tr("Output Device:"))
 530           self.obj_driver_device.setEnabled(True)
 531           self.obj_driver_device_label.setEnabled(True)
 532           self.obj_driver_rate.setEnabled(True)
 533           self.obj_driver_rate_label.setEnabled(True)
 534           self.obj_driver_period.setEnabled(True)
 535           self.obj_driver_period_label.setEnabled(True)
 536           self.obj_driver_nperiods.setEnabled(True)
 537           self.obj_driver_nperiods_label.setEnabled(True)
 538           self.obj_driver_hwmon.setEnabled(True)
 539           self.obj_driver_hwmeter.setEnabled(True)
 540           self.obj_driver_duplex.setEnabled(True)
 541           self.obj_driver_softmode.setEnabled(True)
 542           self.obj_driver_monitor.setEnabled(True)
 543           self.obj_driver_dither.setEnabled(True)
 544           self.obj_driver_dither_label.setEnabled(True)
 545           self.obj_driver_inchannels.setEnabled(True)
 546           self.obj_driver_inchannels_label.setEnabled(True)
 547           self.obj_driver_outchannels.setEnabled(True)
 548           self.obj_driver_outchannels_label.setEnabled(True)
 549           self.obj_driver_shorts.setEnabled(True)
 550           self.obj_driver_input_latency.setEnabled(True)
 551           self.obj_driver_input_latency_label.setEnabled(True)
 552           self.obj_driver_output_latency.setEnabled(True)
 553           self.obj_driver_output_latency_label.setEnabled(True)
 554           self.obj_driver_midi_driver.setEnabled(True)
 555           self.obj_driver_midi_driver_label.setEnabled(True)
 556
 557         elif (self.obj_server_driver.item(0, row).text() == "Dummy"):
 558           self.toolbox_driver_misc.setCurrentIndex(2)
 559           self.obj_driver_wait.setEnabled(True)
 560           self.obj_driver_wait_label.setEnabled(True)
 561
 562         elif (self.obj_server_driver.item(0, row).text() == "FireWire"):
 563           self.toolbox_driver_misc.setCurrentIndex(3)
 564           self.obj_driver_capture.setEnabled(True)
 565           self.obj_driver_capture_label.setEnabled(True)
 566           self.obj_driver_capture_label.setText(self.tr("Capture Ports:"))
 567           self.obj_driver_playback.setEnabled(True)
 568           self.obj_driver_playback_label.setEnabled(True)
 569           self.obj_driver_playback_label.setText(self.tr("Playback Ports:"))
 570           self.obj_driver_device.setEnabled(True)
 571           self.obj_driver_device_label.setEnabled(True)
 572           self.obj_driver_rate.setEnabled(True)
 573           self.obj_driver_rate_label.setEnabled(True)
 574           self.obj_driver_period.setEnabled(True)
 575           self.obj_driver_period_label.setEnabled(True)
 576           self.obj_driver_nperiods.setEnabled(True)
 577           self.obj_driver_nperiods_label.setEnabled(True)
 578           self.obj_driver_duplex.setEnabled(True)
 579           self.obj_driver_inchannels.setEnabled(True)
 580           self.obj_driver_inchannels_label.setEnabled(True)
 581           self.obj_driver_outchannels.setEnabled(True)
 582           self.obj_driver_outchannels_label.setEnabled(True)
 583           self.obj_driver_input_latency.setEnabled(True)
 584           self.obj_driver_input_latency_label.setEnabled(True)
 585           self.obj_driver_output_latency.setEnabled(True)
 586           self.obj_driver_output_latency_label.setEnabled(True)
 587           self.obj_driver_verbose.setEnabled(True)
 588           self.obj_driver_verbose_label.setEnabled(True)
 589           self.obj_driver_snoop.setEnabled(True)
 590
 591         elif (self.obj_server_driver.item(0, row).text() == "Loopback"):
 592           self.toolbox_driver_misc.setCurrentIndex(4)
 593           self.obj_driver_channels.setEnabled(True)
 594           self.obj_driver_channels_label.setEnabled(True)
 595
 596         elif (self.obj_server_driver.item(0, row).text() == "Net"):
 597           self.toolbox_driver_misc.setCurrentIndex(0)
 598
 599         elif (self.obj_server_driver.item(0, row).text() == "NetOne"):
 600           self.toolbox_driver_misc.setCurrentIndex(0)
 601           self.obj_driver_rate.setEnabled(True)
 602           self.obj_driver_rate_label.setEnabled(True)
 603           self.obj_driver_period.setEnabled(True)
 604           self.obj_driver_period_label.setEnabled(True)
 605
 606         self.checkDuplexSelection(self.obj_driver_duplex.isChecked())
 607
 608
 609
 610 # Allow to use this as a standalone app
 611 if __name__ == '__main__':
 612
 613     # App initialization
 614     app = QApplication(sys.argv)
 615
 616     # Connect to DBus
 617     initBus(dbus.SessionBus())
 618
 619     # Show GUI
 620     gui = JackSettingsW()
 621     gui.show()
 622
 623     # App-Loop
 624     sys.exit(app.exec_())