Viewing file:  soundcard.py (30.76 KB) -rwxr-xr-x
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
## soundcard.py - Contains the UI code needed for system-config-soundcard
## Copyright (C) 2002, 2003 Red Hat, Inc.
## Copyright (C) 2002, 2003 Brent Fox <bfox@redhat.com>
## Copyright (C) 2004, 2005 Bastien Nocera <hadess@hadess.net>
## 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 2 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, write to the Free Software
## Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
import string
import gtk
import gobject
import string
import sys
import os
import time
import commands
sys.path.append('/usr/share/system-config-soundcard/')
import soundcardBackend
##
## I18N
##
from rhpl.translate import _, N_
import rhpl.translate as translate
translate.textdomain ("system-config-soundcard")
DETECTION_KUDZU = "kudzu"
DETECTION_PROC = "proc"
DETECTION_HAL = "hal"
##
## Loading image from file
##
def load_image(file, file_back):
pix = None
try:
pix = gtk.gdk.pixbuf_new_from_file(file)
except:
try:
pix = gtk.gdk.pixbuf_new_from_file(file_back)
except:
pass
image = gtk.Image()
if pix:
image.set_from_pixbuf(pix)
return image
##
## Icon for windows
##
iconPixbuf = None
try:
iconPixbuf = gtk.gdk.pixbuf_new_from_file("/usr/share/system-config-soundcard/pixmaps/system-config-soundcard.png")
except:
pass
class childWindow:
#You must specify a runPriority for the order in which you wish your module to run
runPriority = 64
moduleName = _("Soundcard Detection")
commentTag = _("Auto-detect and configure soundcard")
def destroy(self, *args):
if self.play_sound_card_index != None :
self.soundcardBackend.stopTestSound(self.play_sound_card_index)
self.play_sound_card_index = None
gtk.main_quit()
def __init__(self, doDebug=None, backend=None):
self.mainWindow = None
self.card_list = None
self.doDebug = doDebug
if backend == None:
self.soundcardBackend = soundcardBackend.soundcardBackend()
else:
self.soundcardBackend = backend
# Last slide in notebook
self.last_slide = None
# Sound question
self.question = False
# play test sound repeatedly
self.repeat = False
# State variable
# 0 - don't play
# 1 - let's play
self.play_sound = False
# Last tested card
self.play_sound_card_index = None
# Stop button pressed
self.play_sound_stop = False
# tun callback
self.timer = gtk.timeout_add (100, self.checkStatus, self)
def checkStatus(self, obj):
page_num = self.notebook_cardlist.get_current_page()
if page_num == -1:
return True
card_index = self.notebook_card_indexes[page_num]
status = self.soundcardBackend.checkTestSound(card_index)
if self.doDebug:
print "checkStatus - status", status
# notebook switch - stop sound
#page = self.notebook_cardlist.get_nth_page(page_num)
if self.last_slide != page_num:
self.last_slide = page_num
self.play_sound_stop = True
# sound finished - stop sound
if (status[1] and not self.repeat):
self.play_sound_stop = True
self.question = True
# request for stoping sound
if self.play_sound_stop:
self.play_sound_stop = False
self.play_sound = False
if self.play_sound:
if self.doDebug:
print "Play sound"
if(status[0]):
return True
self.playLabelSet(True, page_num)
self.soundcardBackend.playTestSound(card_index)
self.play_sound_card_index = card_index
return True
if not self.play_sound:
if self.doDebug:
print "Stop sound"
self.playLabelSet(False, page_num)
if status[0]:
self.soundcardBackend.stopTestSound(self.play_sound_card_index)
self.play_sound_card_index = None
if self.question:
self.soundQuestion()
self.question = False
return True
def getRepeat(self):
return self.repeat
def setRepeat(self, widget):
self.repeat = widget.get_active();
for rbutton in self.notebook_card_repeats:
rbutton.set_active(self.repeat)
def cancelClicked(self, *args):
self.mainWindow.destroy()
self.destroy()
def okayClicked(self, *args):
self.applyChanges()
self.mainWindow.destroy()
self.destroy()
def changeHW(self, widget, data=None):
self.soundcardBackend.setHardwareDevice(widget.get_active())
def applyChanges(self, *args):
self.soundcardBackend.writeConfig()
def playLabelSet(self, state, page):
if state:
self.notebook_card_labels[page].set_text(_("--- Playing ---"))
else:
self.notebook_card_labels[page].set_text(_("--- Stopped ---"))
def playButtonClicked(self, button, card_index):
self.play_sound = True
def stopButtonClicked(self, button, card_index):
self.play_sound_stop = True
def volumeChanged(self, adj, card_index):
self.soundcardBackend.setVolume(card_index, adj.value)
def soundQuestion(self):
text = (_("Did you hear the sample sound?"))
dlg = gtk.MessageDialog(self.mainWindow, 0, gtk.MESSAGE_QUESTION, gtk.BUTTONS_YES_NO,text)
dlg.set_title("")
dlg.set_default_size(100, 100)
dlg.set_position (gtk.WIN_POS_CENTER_ON_PARENT)
dlg.set_border_width(2)
dlg.set_modal(True)
rc = dlg.run()
dlg.destroy()
if rc == gtk.RESPONSE_NO:
self.soundcardBackend.writeLog()
#Oh well, they couldn't hear the sound. Notify the user and then quit. We did our best
self.showErrorDialog(_("Automatic detection of the sound card did not work. " \
"This audio device will not be available on the system.\n\n" \
"You can create %s, %s on the System tab and " \
"file a new bug\nat http://bugzilla.redhat.com.\n\nPlease click " \
"OK to continue.") % ("/root/scsconfig.log", "/root/scsrun.log"))
def writeUnloadReload(self, selectedItem, module):
self.soundcardBackend.writeFile(selectedItem)
self.soundcardBackend.unloadModules()
result = self.soundcardBackend.loadModules()
if result != 0:
#Loading the module failed. Notify the user that things are broken
self.showErrorDialog(_("The %s driver could not be loaded." % module))
else:
self.soundcardBackend.setVolume()
def create_frame(self, widget, border = 5, label = None, shadow = gtk.SHADOW_NONE):
frame = gtk.Frame(label)
frame.set_border_width(border)
frame.set_shadow_type(shadow)
frame.add(widget)
frame.show_all()
return frame
def change_selected_card(self, noteboook, page, page_num):
print "self:", self
print "noteboook:", noteboook
print "page:", page
print "page_num:", page_num
return 0
def create_test_page_fill(self, card):
table = gtk.Table(2, 3)
table.set_border_width(6)
table.set_col_spacings(10)
table.set_row_spacings(4)
maker_label = gtk.Label("")
maker_label2 = gtk.Label("")
if card.maker != None:
maker_label.set_markup("<span><b>"
"%s</b></span>" % _("Vendor:"))
maker_label.set_alignment(0.0, 0.5)
maker_label2 = gtk.Label(card.maker)
maker_label2.set_alignment(0.0, 0.5)
elif card.type != None:
maker_label.set_markup("<span><b>"
"%s</b></span>" % _("Card:"))
maker_label.set_alignment(0.0, 0.5)
maker_label2 = gtk.Label(card.type)
maker_label2.set_alignment(0.0, 0.5)
model_label = gtk.Label("")
model_label.set_markup("<span><b>"
"%s</b></span>" % _("Model:"))
model_label.set_alignment(0.0, 0.5)
model_label2 = gtk.Label(card.model)
model_label2.set_alignment(0.0, 0.5)
module_label = gtk.Label("")
module_label.set_markup("<span><b>"
"%s</b></span>" % _("Module:"))
module_label.set_alignment(0.0, 0.5)
module_label2 = gtk.Label(_(card.driver))
module_label2.set_alignment(0.0, 0.5)
align = gtk.Alignment(0.0, 0.0, 1.0, 1.0)
table.attach(maker_label, 0, 1, 0, 1, gtk.FILL, gtk.FILL)
table.attach(maker_label2, 1, 2, 0, 1, gtk.FILL, gtk.FILL)
table.attach(model_label, 0, 1, 1, 2, gtk.FILL, gtk.FILL)
table.attach(model_label2, 1, 2, 1, 2, gtk.FILL, gtk.FILL)
table.attach(module_label, 0, 1, 2, 3, gtk.FILL, gtk.FILL)
table.attach(module_label2, 1, 2, 2, 3, gtk.FILL, gtk.FILL)
description = self.create_frame(table, 0, _("Selected card"), gtk.SHADOW_ETCHED_IN)
#Create box that contains volume slider
#Image with zero volume
image_volume_zero = load_image("../pixmaps/stock-volume-zero.png",
"/usr/share/system-config-soundcard/pixmaps/stock-volume-zero.png")
# Volume slider
adj1 = gtk.Adjustment(self.soundcardBackend.getVolume(card.index), 45, 100, 1, 1, 1)
adj1.connect("value_changed", self.volumeChanged, card.index)
volume = gtk.HScale(adj1)
volume.set_update_policy(gtk.UPDATE_CONTINUOUS)
volume.set_draw_value(False)
# Image with max-volume
image_volume_max = load_image("../pixmaps/stock-volume-max.png",
"/usr/share/system-config-soundcard/pixmaps/stock-volume-max.png")
volumeBox = gtk.HBox(False, 5)
volumeBox.pack_start(image_volume_zero,False)
volumeBox.pack_start(volume)
volumeBox.pack_end(image_volume_max,False)
# Control box with Play/Stop/repeat button and status
# Create a check-box for repeat
rbutton = gtk.CheckButton(_("Repeat"))
rbutton.set_active(self.getRepeat())
rbutton.connect("toggled", self.setRepeat)
# Create a play button
image1 = load_image("../pixmaps/stock-media-play.png",
"/usr/share/system-config-soundcard/pixmaps/stock-media-play.png")
play_button = gtk.Button()
play_button.add(image1)
play_button.connect("clicked", self.playButtonClicked, card.index)
# Create a stop button
image2 = load_image("../pixmaps/stock-media-stop.png",
"/usr/share/system-config-soundcard/pixmaps/stock-media-stop.png")
stop_button = gtk.Button()
stop_button.add(image2)
stop_button.connect("clicked", self.stopButtonClicked, card.index)
# Label with status
play_label = gtk.Label()
play_label.set_text(_("--- Stopped ---"))
controlBox = gtk.HBox(False, 8)
controlBox.pack_start(play_button,False)
controlBox.pack_start(stop_button,False)
controlBox.pack_start(play_label)
controlBox.pack_end(rbutton,False)
controlBox = self.create_frame(self.create_frame(controlBox), 0, \
_("Sound test"), gtk.SHADOW_ETCHED_IN)
volumeBox = self.create_frame(self.create_frame(volumeBox), 0, \
_("Volume settings"), gtk.SHADOW_ETCHED_IN)
deviceBox = self.create_frame(self.create_frame(self.create_sub_device_menu_create( \
_("PCM device"), self.test_device_menu_handler,card.index,card.test_sound_device)), 0, \
_("Device settings"), gtk.SHADOW_ETCHED_IN)
tmp = gtk.VBox(False, 8)
tmp.add(description)
tmp.add(controlBox)
tmp.add(volumeBox)
tmp.add(deviceBox)
tmp.show_all()
return tmp, play_label, rbutton
def create_test_page(self, firsboot = False):
# Entire page
self.toplevel = gtk.VBox()
self.toplevel.set_spacing(10)
# A box with icon and description...
self.icon_box = gtk.HBox()
self.icon_box.set_spacing(5)
#Add icon to the top frame
if not firsboot:
self.icon = load_image("../pixmaps/system-config-soundcard.png",
"/usr/share/system-config-soundcard/pixmaps/system-config-soundcard.png")
self.icon_box.pack_start(self.icon, False)
#Add label
cardNum = self.soundcardBackend.getCardNum()
if cardNum == 0:
self.label = gtk.Label(_("No soundcards were detected."))
else:
if cardNum == 1:
self.label = gtk.Label(_("The following audio device was detected."))
else:
self.label = gtk.Label(_("The following audio devices were detected."))
self.icon_box.pack_start(self.label, False)
# add icon-box to page
self.toplevel.pack_start(self.icon_box, False)
self.notebook_card_indexes = []
self.notebook_card_labels = []
self.notebook_card_repeats = []
self.notebook_cardlist = gtk.Notebook()
self.notebook_cardlist.set_tab_pos(gtk.POS_LEFT)
#self.notebook_cardlist.connect("switch-page", self.change_selected_card)
if cardNum == 0:
label = gtk.Label("")
else:
cardList = self.soundcardBackend.getCardArray()
for card in cardList:
if not card.active:
continue;
page, label, repeat_button = self.create_test_page_fill(card)
page = self.create_frame(page, 10)
self.notebook_cardlist.append_page(page, gtk.Label(card.getDescription()))
self.notebook_card_indexes.append(card.index)
self.notebook_card_labels.append(label)
self.notebook_card_repeats.append(repeat_button)
self.toplevel.pack_start(self.notebook_cardlist, False)
self.notebook_cardlist.set_current_page(0)
if cardNum == 1:
self.notebook_cardlist.set_show_tabs(False)
self.notebook_cardlist.set_show_border(False)
return self.toplevel
def create_sub_device_menu_refresh(self, device_menu_handler, card_index, default_device):
#print "create_sub_device_menu_refresh, device = %d" % default_device
list = gtk.Menu()
device_list = self.soundcardBackend.getCardDevices(card_index)
selected = 0
if device_list != [] :
order = 0
for device in device_list:
menu_item = gtk.MenuItem(device[1])
menu_item.connect_object("activate",device_menu_handler,device[0])
list.append(menu_item)
if(device[0] == default_device):
selected = order
else:
order += 1
list.set_active(selected)
self.sub_device_menu.set_menu(list)
self.sub_device_menu.show_all()
def create_sub_device_menu_create(self, label, device_menu_handler, card_index, default_device):
self.sub_device_menu = gtk.OptionMenu()
self.create_sub_device_menu_refresh(device_menu_handler, card_index, default_device)
tmpBox = gtk.HBox(False, 8)
tmpBox.pack_start(gtk.Label(label), False)
tmpBox.pack_start(self.sub_device_menu, True)
return tmpBox
def default_device_menu_handler(self, data):
#print "Default device %d" % data
card_index = self.soundcardBackend.getDefaultCard()
self.soundcardBackend.setCardDefaultDevice(card_index, data)
def test_device_menu_handler(self, data):
#print "Test device %d" % data
page_num = self.notebook_cardlist.get_current_page()
card_index = self.notebook_card_indexes[page_num]
self.soundcardBackend.setCardTestDevice(card_index, data)
def create_combo_box(self, label):
Menu = gtk.OptionMenu()
tmpBox = gtk.HBox(False, 8)
tmpBox.pack_start(gtk.Label(label), False)
tmpBox.pack_start(Menu, True)
return tmpBox
def create_combo_box_cardlist_refresh(self, menu_handler, selected_card):
list = gtk.Menu()
cardList = self.soundcardBackend.getCardArray()
selected = 0
for card in cardList:
if card.active:
menuItem = gtk.MenuItem(("%s %s") % (card.maker, card.model))
else:
menuItem = gtk.MenuItem(_(" - "))
menuItem.connect_object("activate", menu_handler,card.index)
list.append(menuItem)
list.set_active(selected_card)
self.card_combo_menu.set_menu(list)
self.card_combo_menu.show_all()
def create_combo_box_cardlist_create(self, label, menu_handler, selected_card):
self.card_combo_menu = gtk.OptionMenu()
self.create_combo_box_cardlist_refresh(menu_handler, selected_card)
tmpBox = gtk.HBox(False, 8)
tmpBox.pack_start(gtk.Label(label), False)
tmpBox.pack_start(self.card_combo_menu, True)
return tmpBox
def create_combo_box_cardlist_handler(self, data):
#print "Default card %d" % data
self.soundcardBackend.setDefaultCard(data)
#print self.soundcardBackend.getCardDefaultDevice(data)
#print "card %d device %d" % (data, self.soundcardBackend.getDefaultCardDevice(data))
self.create_sub_device_menu_refresh(self.default_device_menu_handler, data, \
self.soundcardBackend.getCardDefaultDevice(data))
def create_settings_page_card_list_callback(self, treeview):
#print "Zmena"
treeselection = treeview.get_selection()
model, iter = treeselection.get_selected()
store = treeview.get_model()
val0 = store.get_value(iter,0)
val1 = store.get_value(iter,1)
#print val0
#print val1
return
# nacist hodnotu indexu zvukovky (co je vybrana)
# zvysit/snizit jeji indexu
# podivat se na okolni karty a podle toho ji zaradit
def switch_store_find(self, store, index):
iter = store.get_iter_first()
while iter:
akt_index = store.get_value(iter, 0)
if akt_index == index:
return iter
iter = store.iter_next(iter)
return None
def switch_store_set_index(self, store, iter, direction):
store.set_value(iter, 0, store.get_value(iter, 0) + direction)
return
def switch_store_swap_index(self, store, new_iter, old_iter):
new = store.get_value(new_iter, 0)
old = store.get_value(old_iter, 0)
store.set_value(old_iter, 0, new)
store.set_value(new_iter, 0, old)
store.swap(old_iter, new_iter)
return
def switch_store(self, store, index, direction):
old_iter = self.switch_store_find(store, index)
new_iter = self.switch_store_find(store, index + direction)
if new_iter == None:
self.switch_store_set_index(store, old_iter, direction)
else:
self.switch_store_swap_index(store, old_iter, new_iter)
return
def create_settings_page_card_list_button(self, button, direction):
treeselection = self.card_list.get_selection()
model, iter = treeselection.get_selected()
if(iter != None):
store = self.card_list.get_model()
index = store.get_value(iter, 0)
new_index = index + direction
if self.soundcardBackend.isCardIndexValid(new_index):
#print "Old position %d" % index
#print "New position %d" % (index + direction)
self.soundcardBackend.setCardIndexAndReOrder(index, direction)
self.switch_store(store, index, direction)
# re-order list of default cards
self.create_combo_box_cardlist_refresh(self.create_combo_box_cardlist_handler,\
self.soundcardBackend.getDefaultCard())
#self.soundcardBackend.dumpCards()
#self.soundcardBackend.soundConfig.dump()
self.soundcardBackend.cardIndexChanged()
return
def create_settings_page(self):
default_card = self.soundcardBackend.getDefaultCard()
tmpBox1 = self.create_combo_box_cardlist_create(_("Default audio card:"), \
self.create_combo_box_cardlist_handler, default_card)
tmpBox2 = self.create_sub_device_menu_create(_("Default PCM device:"), \
self.default_device_menu_handler, default_card, \
self.soundcardBackend.getCardDefaultDevice(default_card))
defaultBox = gtk.VBox(True, 5)
defaultBox.pack_start(tmpBox1, False, False)
defaultBox.pack_start(tmpBox2, False, False)
defaultBox.show_all()
defaultBox = self.create_frame(self.create_frame(defaultBox,8),0,_("Default audio devices"),gtk.SHADOW_ETCHED_IN)
settingsBox = gtk.VBox(False, 8)
settingsBox.pack_start(defaultBox, False, False)
configBox = gtk.VBox(False, 0)
#Create a check-box for hw/sw config
button = gtk.CheckButton(_("Disable specific card configuration"))
button.set_active(self.soundcardBackend.getHardwareDevice())
button.connect("toggled", self.changeHW)
configBox.pack_start(button)
configBox.show_all()
configBox = self.create_frame(self.create_frame(configBox,8),0,_("ALSA plugins"),gtk.SHADOW_ETCHED_IN)
settingsBox.pack_start(configBox, False, False)
# card order
cardBox = gtk.HBox(False, 5)
liststore = gtk.ListStore(int, str)
cardList = self.soundcardBackend.getCardArray()
for card in cardList:
if card.active:
liststore.append([card.index, card.getName()])
self.card_list = gtk.TreeView(liststore)
cell = gtk.CellRendererText()
tvcolumn = gtk.TreeViewColumn(_("Index"))
tvcolumn.pack_start(cell, True)
tvcolumn.set_attributes(cell, text=0)
self.card_list.append_column(tvcolumn)
tvcolumn1 = gtk.TreeViewColumn(_("Card"))
cell1 = gtk.CellRendererText()
tvcolumn1.pack_start(cell1, True)
tvcolumn1.set_attributes(cell1, text=1)
self.card_list.append_column(tvcolumn1)
#tvcolumn.set_sort_column_id(0)
#treeview.set_search_column(0)
self.card_list.set_reorderable(False)
self.card_list.connect("cursor-changed", self.create_settings_page_card_list_callback)
cardBox.pack_start(self.card_list, True, True)
# Reorder buttons
buttonBox = gtk.VBox(False, 5)
up_button = gtk.Button(_("Move Up"), gtk.STOCK_GO_UP)
up_button.connect("clicked", self.create_settings_page_card_list_button,-1)
down_button = gtk.Button(_("Move Down"), gtk.STOCK_GO_DOWN)
down_button.connect("clicked", self.create_settings_page_card_list_button,1)
buttonBox.pack_end(down_button,False,False)
buttonBox.pack_end(up_button,False,False)
cardBox.pack_start(buttonBox, False, False)
cardBox.show_all()
cardBox = self.create_frame(self.create_frame(cardBox,8),0,_("Audio cards order"),gtk.SHADOW_ETCHED_IN)
settingsBox.pack_start(cardBox, False, False)
return settingsBox
def create_system_page_modules_reload(self, widget):
self.soundcardBackend.reloadModules()
def create_system_page(self):
table = gtk.Table(2, 3)
table.set_border_width(6)
table.set_col_spacings(10)
table.set_row_spacings(4)
maker_label = gtk.Label("")
maker_label.set_markup("<span><b>"
"%s</b></span>" % _("ALSA Driver version:"))
maker_label.set_alignment(0.0, 0.5)
maker_label2 = gtk.Label(self.soundcardBackend.getDriverVersion())
maker_label2.set_alignment(0.0, 0.5)
model_label = gtk.Label("")
model_label.set_markup("<span><b>"
"%s</b></span>" % _("ALSA Lib package(s):"))
model_label.set_alignment(0.0, 0.5)
model_label2 = gtk.Label(self.soundcardBackend.getLibVersion())
model_label2.set_alignment(0.0, 0.5)
module_label = gtk.Label("")
module_label.set_markup("<span><b>"
"%s</b></span>" % _("ALSA Utils package(s):"))
module_label.set_alignment(0.0, 0.5)
module_label2 = gtk.Label(self.soundcardBackend.getUtilsVersion())
module_label2.set_alignment(0.0, 0.5)
align = gtk.Alignment(0.0, 0.0, 1.0, 1.0)
table.attach(maker_label, 0, 1, 0, 1, gtk.FILL, gtk.FILL)
table.attach(maker_label2, 1, 2, 0, 1, gtk.FILL, gtk.FILL)
table.attach(model_label, 0, 1, 1, 2, gtk.FILL, gtk.FILL)
table.attach(model_label2, 1, 2, 1, 2, gtk.FILL, gtk.FILL)
table.attach(module_label, 0, 1, 2, 3, gtk.FILL, gtk.FILL)
table.attach(module_label2, 1, 2, 2, 3, gtk.FILL, gtk.FILL)
infoBox = gtk.VBox(False, 8)
alsaBox = self.create_frame(self.create_frame(table,8),0,_("ALSA sound system information"),gtk.SHADOW_ETCHED_IN)
infoBox.pack_start(alsaBox,False,False)
report_button = gtk.Button(_("Generate sound log file %s") % "/root/scsconfig.log")
report_button.connect("clicked", self.soundcardBackend.writeLog)
reportBox = self.create_frame(self.create_frame(report_button,8),0,_("Report"),gtk.SHADOW_ETCHED_IN)
infoBox.pack_start(reportBox,False,False)
reload_button = gtk.Button(_("Reload audio drivers"))
reload_button.connect("clicked", self.create_system_page_modules_reload)
detectionBox = gtk.HBox(False, 8)
detectionBox.pack_start(reload_button, True, True)
detectionBox = self.create_frame(self.create_frame(detectionBox,8),0,_("Drivers"),gtk.SHADOW_ETCHED_IN)
infoBox.pack_start(detectionBox, False, False)
return infoBox
def refresh_notebook(self):
self.notebook.remove_page(0)
self.notebook.remove_page(0)
self.notebook.prepend_page(self.create_frame(self.create_settings_page()), gtk.Label(_("Settings")))
self.notebook.prepend_page(self.create_frame(self.create_test_page()), gtk.Label(_("Sound test")))
self.notebook.show_all()
def launch(self):
print "Running from first-boot..."
self.mainVBox = gtk.VBox()
self.internalVBox = gtk.VBox(False, 10)
self.internalVBox.set_border_width(10)
eventBox = gtk.EventBox()
eventBox.add(self.icon_box)
eventBox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse ("#cc0000"))
self.icon_box.pack_start(self.icon, False, True)
self.icon_box.pack_start(self.title)
self.mainVBox.pack_start(eventBox, False)
self.msg_label.set_size_request(500, -1)
self.internalVBox.pack_start(self.msg_label, False)
self.mainVBox.pack_start(self.internalVBox, True)
return self.mainVBox, eventBox
def stand_alone(self):
print "Running from command-line..."
self.mainWindow = gtk.Dialog()
self.mainWindow.vbox.set_spacing(5)
self.mainWindow.connect("destroy", self.destroy)
self.mainWindow.set_title(_("Audio configuration"))
self.mainWindow.set_border_width(10)
self.mainWindow.set_position(gtk.WIN_POS_CENTER)
self.mainWindow.set_icon(iconPixbuf)
self.applyButton = self.mainWindow.add_button('gtk-apply', 0)
self.applyButton.connect("clicked", self.applyChanges)
self.okButton = self.mainWindow.add_button('gtk-ok', 0)
self.okButton.connect("clicked", self.okayClicked)
self.cancelButton = self.mainWindow.add_button('gtk-cancel', 0)
self.cancelButton.connect("clicked", self.cancelClicked)
# Create main page
self.notebook = gtk.Notebook()
self.notebook.append_page(self.create_frame(self.create_test_page()), gtk.Label(_("Sound test")))
self.notebook.append_page(self.create_frame(self.create_settings_page()), gtk.Label(_("Settings")))
self.notebook.append_page(self.create_frame(self.create_system_page()), gtk.Label(_("System")))
self.notebook.set_current_page(0)
#Remove the hsep from the dialog. It's ugly
hsep = self.mainWindow.get_children()[0].get_children()[0]
self.mainWindow.get_children()[0].remove(hsep)
self.mainWindow.vbox.pack_start(self.notebook)
self.mainWindow.show_all()
gtk.main()
def showErrorDialog(self, text):
dlg = gtk.MessageDialog(self.mainWindow, 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, text)
dlg.set_title(_("Error"))
dlg.set_default_size(100, 100)
dlg.set_position (gtk.WIN_POS_CENTER_ON_PARENT)
dlg.set_border_width(2)
dlg.set_modal(True)
rc = dlg.run()
dlg.destroy()
return
def showInfoDialog(self, text):
dlg = gtk.MessageDialog(self.mainWindow, 0, gtk.MESSAGE_INFO, gtk.BUTTONS_OK, text)
dlg.set_title(_("Information"))
dlg.set_default_size(100, 100)
dlg.set_position (gtk.WIN_POS_CENTER_ON_PARENT)
dlg.set_border_width(2)
dlg.set_modal(True)
rc = dlg.run()
dlg.destroy()
return
def getSoundcardBox(self):
box = gtk.HBox()
box.pack_start(self.create_test_page(True), True, False)
return box
|