147 lines
7.5 KiB
Python
Executable File
147 lines
7.5 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
# pyjackctl - The python jackdbus controller suite
|
|
# jackctl_logview - A log viewer for the python JACK dbus suite
|
|
# Copyright (C) 2007-2008, Marc-Olivier Barre and Nedko Arnaudov.
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
import pygtk
|
|
pygtk.require('2.0')
|
|
import gtk
|
|
import gtk.glade
|
|
import laditools
|
|
|
|
class jackctl_conf(gtk.glade.XML):
|
|
def __init__(self):
|
|
# Dbus interface
|
|
self.jack = pyjackctl.jack_configure()
|
|
# Load the glade file
|
|
gtk.glade.XML.__init__(self, "/usr/share/pyjackctl/data/jackconf_ui.glade")
|
|
# Get the ui ready for action
|
|
self.event_dict = {"on_jackctl_conf_ui_destroy" : self.on_quit,
|
|
"on_close_button_clicked" : self.on_quit,
|
|
"on_apply_button_clicked" : self.on_apply}
|
|
self.signal_autoconnect(self.event_dict)
|
|
self.engine_param_dict = {}
|
|
self.driver_param_dict = {}
|
|
self.changed_engine_params = []
|
|
self.changed_driver_params = []
|
|
self.apply_button = self.get_widget("apply_button")
|
|
# Driver tab setup
|
|
self.driver_vbox_left = self.get_widget("driver_vbox_left")
|
|
self.driver_vbox_right = self.get_widget("driver_vbox_right")
|
|
self.driver_params = self.jack.get_driver_param_names()
|
|
for driver_param in self.driver_params:
|
|
typestr = self.jack.get_driver_param_type(driver_param)
|
|
isset, default, value = self.jack.get_driver_param_value(driver_param)
|
|
short_descr = self.jack.get_driver_short_description(driver_param)
|
|
if typestr == "b":
|
|
self.driver_vbox_left.pack_start(self.make_checkbox(driver_param, value, short_descr, self.driver_param_dict), False)
|
|
elif typestr == "s":
|
|
self.driver_vbox_right.pack_start(self.make_textentry(driver_param, value, short_descr, self.driver_param_dict), False)
|
|
elif typestr == "u" or typestr == "i":
|
|
self.driver_vbox_right.pack_start(self.make_spinbutton(driver_param, value, short_descr, self.driver_param_dict), False)
|
|
#Engine tab setup
|
|
self.engine_vbox_left = self.get_widget("engine_vbox_left")
|
|
self.engine_vbox_right = self.get_widget("engine_vbox_right")
|
|
self.engine_params = self.jack.get_engine_param_names()
|
|
for engine_param in self.engine_params:
|
|
typestr = self.jack.get_engine_param_type(engine_param)
|
|
isset, default, value = self.jack.get_engine_param_value(engine_param)
|
|
short_descr = self.jack.get_engine_short_description(engine_param)
|
|
if typestr == "b":
|
|
self.engine_vbox_left.pack_start(self.make_checkbox(engine_param, value, short_descr, self.engine_param_dict), False)
|
|
elif typestr == "s":
|
|
self.engine_vbox_right.pack_start(self.make_textentry(engine_param, value, short_descr, self.engine_param_dict), False)
|
|
elif typestr == "u" or typestr == "i":
|
|
self.engine_vbox_right.pack_start(self.make_spinbutton(engine_param, value, short_descr, self.engine_param_dict), False)
|
|
|
|
def make_checkbox(self, param_name, value, short_descr, storage_dict):
|
|
storage_dict[param_name] = gtk.CheckButton(param_name)
|
|
storage_dict[param_name].set_active(value)
|
|
storage_dict[param_name].set_tooltip_text(short_descr)
|
|
storage_dict[param_name].connect("toggled", self.on_param_update, param_name)
|
|
storage_dict[param_name].show()
|
|
return storage_dict[param_name]
|
|
|
|
def make_spinbutton(self, param_name, value, short_descr, storage_dict):
|
|
storage_dict[param_name] = gtk.SpinButton()
|
|
storage_dict[param_name].set_range(0, 100000)
|
|
storage_dict[param_name].set_increments(1, 1000)
|
|
storage_dict[param_name].set_value(value)
|
|
storage_dict[param_name].set_tooltip_text(short_descr)
|
|
param_label = gtk.Label(param_name)
|
|
param_label.set_alignment(1, 0.5)
|
|
param_label.set_padding(10, 0)
|
|
param_widget = gtk.HBox()
|
|
param_widget.set_homogeneous(True)
|
|
param_widget.pack_start(param_label)
|
|
param_widget.pack_start(storage_dict[param_name])
|
|
storage_dict[param_name].connect("changed", self.on_param_update, param_name)
|
|
param_widget.show_all()
|
|
return param_widget
|
|
|
|
def make_textentry(self, param_name, value, short_descr, storage_dict):
|
|
storage_dict[param_name] = gtk.Entry()
|
|
storage_dict[param_name].set_text(value)
|
|
storage_dict[param_name].set_tooltip_text(short_descr)
|
|
param_label = gtk.Label(param_name)
|
|
param_label.set_alignment(1, 0.5)
|
|
param_label.set_padding(10, 0)
|
|
param_widget = gtk.HBox()
|
|
param_widget.set_homogeneous(True)
|
|
param_widget.pack_start(param_label)
|
|
param_widget.pack_start(storage_dict[param_name])
|
|
param_widget.show_all()
|
|
storage_dict[param_name].connect("changed", self.on_param_update, param_name)
|
|
return param_widget
|
|
|
|
def on_param_update(self, widget, param_name):
|
|
if param_name in self.driver_params and param_name not in self.changed_driver_params:
|
|
self.changed_driver_params.append(param_name)
|
|
if param_name in self.engine_params and param_name not in self.changed_engine_params:
|
|
self.changed_engine_params.append(param_name)
|
|
self.apply_button.set_sensitive(True)
|
|
|
|
def on_apply(self, data=None):
|
|
for changed_driver_param in self.changed_driver_params:
|
|
widget_type = type(self.driver_param_dict[changed_driver_param])
|
|
if widget_type is gtk.CheckButton:
|
|
self.jack.set_driver_param_value(changed_driver_param, self.driver_param_dict[changed_driver_param].get_active())
|
|
elif widget_type is gtk.SpinButton:
|
|
self.jack.set_driver_param_value(changed_driver_param, self.driver_param_dict[changed_driver_param].get_value())
|
|
elif widget_type is gtk.Entry:
|
|
self.jack.set_driver_param_value(changed_driver_param, self.driver_param_dict[changed_driver_param].get_text())
|
|
for changed_engine_param in self.changed_engine_params:
|
|
widget_type = type(self.engine_param_dict[changed_engine_param])
|
|
if widget_type is gtk.CheckButton:
|
|
self.jack.set_engine_param_value(changed_engine_param, self.engine_param_dict[changed_engine_param].get_active())
|
|
elif widget_type is gtk.SpinButton:
|
|
self.jack.set_engine_param_value(changed_engine_param, self.engine_param_dict[changed_engine_param].get_value())
|
|
elif widget_type is gtk.Entry:
|
|
self.jack.set_engine_param_value(changed_engine_param, self.engine_param_dict[changed_engine_param].get_text())
|
|
self.apply_button.set_sensitive(False)
|
|
self.changed_engine_params = []
|
|
self.changed_driver_params = []
|
|
|
|
def on_quit(self, data=None):
|
|
gtk.main_quit()
|
|
|
|
def run(self):
|
|
gtk.main()
|
|
return 0
|
|
|
|
jackctl_conf().run()
|