def __init__(self):
assistant = gtk.Assistant()
assistant.set_title("New odML-Document wizard")
assistant.set_default_size(800, 500)
assistant.set_position(gtk.WIN_POS_CENTER_ALWAYS)
assistant.connect("apply", self.apply)
assistant.connect("close", self.cancel)
assistant.connect("cancel", self.cancel)
# General information and URL to a terminology repository
data_page = DataPage()
data_page.deploy(assistant, "Document information")
self.data_page = data_page
# Page displaying terminology sections available for import
# via the terminology URL in the DataPage.
section_page = SectionPage()
section_page.data = data_page
section_page.deploy(assistant, "Repository section import")
self.section_page = section_page
# Wrap up page before the new document is created
SummaryPage().deploy(assistant, "Complete")
assistant.connect("prepare", self.prepare)
assistant.show_all()
def __init__(self):
assistant = gtk.Assistant()
assistant.set_title("New odML-Document wizard")
assistant.set_default_size(-1, 500)
assistant.connect("apply", self.apply)
assistant.connect("close", self.cancel)
assistant.connect("cancel", self.cancel)
IntroPage().deploy(assistant, "New Document Wizard")
data_page = DataPage()
data_page.deploy(assistant, "Setup generic information")
self.data_page = data_page
section_page = SectionPage()
section_page.data = data_page
section_page.deploy(
assistant, "Select which sections to import from the repository")
self.section_page = section_page
SummaryPage().deploy(assistant, "Complete")
assistant.connect('prepare', self.prepare)
# third page loads the repository and offers which sections to import
# initially
assistant.show_all()
def __init__(self):
self.assistant = gtk.Assistant()
self.assistant.set_title(_('Knoppix Remasterscript'))
self.assistant.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.assistant.set_icon_from_file(
os.path.join(os.path.dirname(__file__), 'resources', 'icon.png'))
self.assistant.connect('prepare', self._prepare_page)
self._setup_page_welcome()
self._setup_page_unpack()
self._setup_page_remaster()
self._pulse = None
def init_gui(self):
self.assistant = gtk.Assistant()
#self.assistant.set_forward_page_func(None, None)
widget = self.page_wellcome()
self.assistant.append_page(widget)
self.assistant.set_page_title(widget, 'Bicéfalo')
self.assistant.set_page_type(widget, gtk.ASSISTANT_PAGE_INTRO)
self.assistant.set_page_complete(widget, True)
widget = self.page_number_of_seats()
self.assistant.append_page(widget)
self.assistant.set_page_title(widget, 'Number of seats')
self.assistant.set_page_complete(widget, True)
self.monitores = MonitoresGUI()
widget = self.monitores.init_gui_area()
self.assistant.append_page(widget)
self.assistant.set_page_title(widget, 'Screen')
self.assistant.set_page_complete(widget, True)
self.number_of_seats_entry.set_text(
str(len(self.monitores.modes_combos)))
self.mouse_keyboard = MouseKeyboard()
widget = self.mouse_keyboard.init_gui_area(
int(self.number_of_seats_entry.get_text()))
self.assistant.append_page(widget)
self.assistant.set_page_title(widget, 'Mouse and Keyboard')
self.assistant.set_page_complete(widget, True)
self.usbs = USBsGUI(int(self.number_of_seats_entry.get_text()))
widget = self.usbs.init_gui_area()
self.assistant.append_page(widget)
self.assistant.set_page_title(widget, 'USB')
self.assistant.set_page_complete(widget, True)
widget = self.page_final()
self.assistant.append_page(widget)
self.assistant.set_page_title(widget, 'Summary')
self.assistant.set_page_type(widget, gtk.ASSISTANT_PAGE_CONFIRM)
self.assistant.set_page_complete(widget, True)
self.final_widget = widget
self.assistant.update_buttons_state()
self.number_of_seats_entry.connect("changed",
self.update_number_seats_callback)
#self.assistant.connect("close", self.destroy)
self.assistant.connect("cancel", self.destroy)
self.assistant.connect("set-focus-child", self.summary_check_callback)
self.assistant.connect("apply", self.apply_callback)
return self.assistant
def __init__(self):
self.assistant = gtk.Assistant()
self.assistant.set_title(_('Knoppix Remasterscript'))
self.assistant.set_position(gtk.WIN_POS_CENTER_ALWAYS)
self.assistant.set_icon_from_file(
os.path.join(os.path.dirname(__file__), 'resources', 'icon.png'))
self.assistant.connect('prepare', self._prepare)
self.script = Script(build, _steps)
self.script.event('success').connect(self._success)
self._setup_page_welcome()
self._setup_page_summary()
self._setup_page_build()
self._setup_page_finished()
def __init__(self):
subprocess.call('sudo /etc/init.d/flumotion restart', shell=True)
subprocess.call('xset s off', shell=True)
subprocess.call('xset -dpms', shell=True)
# Stop the screensaver and screen blanking
self.inhibitor = inhibitor.Inhibitor()
self.inhibitor.inhibit(reason="Video streaming!")
flumotion = FlumotionConnection()
xml = PortableXML()
self.xml = xml
assistant = gtk.Assistant()
self.assistant = assistant
battery = BatteryPage(assistant, xml)
network = NetworkPage(assistant, xml)
presentation = PresentationPage(assistant, xml)
camera = CameraPage(assistant, xml)
audio_inroom = AudioInRoomPage(flumotion, assistant, xml)
#audio_standalone = AudioStandAlonePage(flumotion, assistant, xml)
#interaction = xml.get_page("interaction")
#assistant.append_page(interaction)
#assistant.set_page_title(interaction, "Interaction Setup")
#assistant.set_page_type(interaction, gtk.ASSISTANT_PAGE_CONTENT)
#assistant.set_page_complete(interaction, False)
success = SuccessPage(flumotion, assistant, xml)
# and the window
assistant.show_all()
assistant.connect("close", gtk.main_quit, "WM destroy")
assistant.fullscreen()
def __init__(self):
assistant = gtk.Assistant()
assistant.set_title("New odML-Document wizard")
assistant.set_default_size(800, 500)
assistant.set_position(gtk.WIN_POS_CENTER_ALWAYS)
assistant.connect("apply", self.apply)
assistant.connect("close", self.cancel)
assistant.connect("cancel", self.cancel)
data_page = DataPage()
data_page.deploy(assistant, "Document information")
self.data_page = data_page
section_page = SectionPage()
section_page.data = data_page
section_page.deploy(assistant, "Repository section import")
self.section_page = section_page
SummaryPage().deploy(assistant, "Complete")
assistant.connect('prepare', self.prepare)
# third page loads the repository and offers which sections to import initially
assistant.show_all()
def __init__(self, apply_callback):
""" Initialize assistant window """
self.apply_callback = apply_callback
#
# init project datas
#
self.project_data = dict()
self.assistant = gtk.Assistant()
self.assistant.connect('delete-event', self.on_quit)
self.assistant.connect('destroy-event', self.on_quit)
self.assistant.connect('apply', self.on_apply)
self.assistant.connect('cancel', self.on_cancel)
self.assistant.connect('close', self.on_close)
self.assistant.connect('prepare', self.on_prepare)
self.assistant.set_property('title', _('Luciole project assistant'))
# assistant logo with no text
image = LIMG.Image('images/luciole_logo.png', True, 2, False)
#
# configure page 1
#
self.p1 = Page_intro(self.assistant, self.project_data)
self.assistant.append_page(self.p1)
self.assistant.set_page_title(self.p1, _(' Select a project path '))
self.assistant.set_page_type(self.p1, gtk.ASSISTANT_PAGE_INTRO)
self.assistant.set_page_side_image(self.p1, image.pixbuf_thumb)
#
# configure page 2
#
self.p2 = Page_matos(self.assistant, self.project_data)
self.assistant.append_page(self.p2)
self.assistant.set_page_title(self.p2, _(' Select hardware '))
self.assistant.set_page_type(self.p2, gtk.ASSISTANT_PAGE_CONTENT)
self.assistant.set_page_complete(self.p2, True)
self.assistant.set_page_side_image(self.p1, image.pixbuf_thumb)
#
# configure page 3
#
self.p3 = Page_webcam(self.assistant, self.project_data)
self.assistant.append_page(self.p3)
self.assistant.set_page_title(self.p3, _(' Webcam detection '))
#self.assistant.set_page_type( self.p3, gtk.ASSISTANT_PAGE_PROGRESS)
self.assistant.set_page_type(self.p3, gtk.ASSISTANT_PAGE_CONTENT)
self.assistant.set_page_side_image(self.p1, image.pixbuf_thumb)
#
# configure page 4
#
self.p4 = Page_summary(self.assistant, self.project_data)
self.assistant.append_page(self.p4)
self.assistant.set_page_title(self.p4, _(' Project overview '))
self.assistant.set_page_type(self.p4, gtk.ASSISTANT_PAGE_CONFIRM)
self.assistant.set_page_complete(self.p4, True)
self.assistant.set_page_side_image(self.p1, image.pixbuf_thumb)
# page_func setup : used to manage the page sequences.
self.assistant.set_forward_page_func(self.page_func)
self.assistant.show_all()
def add_toolbar_button_assistant():
def cb_close(assistant):
assi.destroy()
return False
def cb_name_entry_key_press(entry, event):
assi.set_page_complete(entry.get_parent(),
len(entry.get_text()) > 0)
def cb_func_entry_key_press(entry, event):
assi.set_page_complete(entry.get_parent(),
len(entry.get_text()) > 0)
def cb_entry_key_press(entry, event):
assi.set_page_complete(entry.get_parent(),
len(entry.get_text()) > 0)
def cb_apply(assistant):
name_str = name_entry.get_text()
func_str = func_entry.get_text()
save_qm = radiobutton_yes.get_active()
icon_iter = icon_combobox.get_active_iter()
icon = None
if (icon_iter):
icon, icon_stock, icon_filename = icon_model.get(
icon_iter, 0, 1, 2)
if (icon_stock):
icon = icon_stock
coot_toolbar_button(name_str, func_str, icon)
if (save_qm):
save_toolbar_to_init_file(name_str, func_str, icon)
assi = gtk.Assistant()
assi.set_title("Toolbutton Assistant")
assi.connect('delete_event', cb_close)
assi.connect('close', cb_close)
assi.connect('cancel', cb_close)
assi.connect('apply', cb_apply)
# Construct page 0 (enter the button name)
vbox = gtk.VBox(False, 5)
vbox.set_border_width(5)
vbox.show()
assi.append_page(vbox)
assi.set_page_title(vbox, 'Create a new Coot toolbutton')
assi.set_page_type(vbox, gtk.ASSISTANT_PAGE_CONTENT)
label = gtk.Label(
"Please enter the name for the new toolbutton...")
label.set_line_wrap(True)
label.show()
vbox.pack_start(label, True, True, 0)
name_entry = gtk.Entry()
name_entry.connect("key-press-event", cb_name_entry_key_press)
name_entry.show()
vbox.pack_end(name_entry)
# check if name exists!!!!
# Construct page 1 (enter the function)
vbox = gtk.VBox(False, 5)
vbox.set_border_width(5)
vbox.show()
assi.append_page(vbox)
assi.set_page_title(vbox, 'Set the function')
assi.set_page_type(vbox, gtk.ASSISTANT_PAGE_CONTENT)
label = gtk.Label(
"Please enter the python function... (e.g. refine_active_residue())"
)
label.set_line_wrap(True)
label.show()
vbox.pack_start(label, True, True, 0)
func_entry = gtk.Entry()
func_entry.connect("key-press-event", cb_func_entry_key_press)
func_entry.show()
vbox.pack_start(func_entry, True, True, 0)
# add advanced option? FIXME (for callable func and args!?)
#adv_button = gtk.Button("Advanced options...")
#adv_button.show()
#vbox.pack_start(adv_button, False, False, 0)
# Construct page 2 (save?)
vbox = gtk.VBox(False, 5)
vbox.set_border_width(5)
vbox.show()
assi.append_page(vbox)
assi.set_page_title(vbox, 'Save to preferences?')
assi.set_page_type(vbox, gtk.ASSISTANT_PAGE_CONTENT)
label = gtk.Label(
"Do you want to save the button in your preferences?")
label.set_line_wrap(True)
label.show()
vbox.pack_start(label, True, True, 0)
radiobutton_yes = gtk.RadioButton(None, "Yes")
radiobutton_no = gtk.RadioButton(radiobutton_yes, "No")
radiobutton_yes.set_active(True)
radiobutton_yes.show()
radiobutton_no.show()
vbox.pack_start(radiobutton_yes, True, True, 0)
vbox.pack_start(radiobutton_no, True, True, 0)
assi.set_page_complete(radiobutton_yes.get_parent(), True)
# Construct page 3 (select icon)
vbox = gtk.VBox(False, 5)
vbox.set_border_width(5)
vbox.show()
assi.append_page(vbox)
assi.set_page_title(vbox, 'Select an icon')
assi.set_page_type(vbox, gtk.ASSISTANT_PAGE_CONTENT)
label = gtk.Label("Please select an icon or leave as it is...")
label.set_line_wrap(True)
label.show()
vbox.pack_start(label, True, True, 0)
hbox = gtk.HBox(False, 5)
icon_model = make_icons_model()
icon_combobox = icon_selection_combobox(icon_model)
icon_combobox.show()
hbox.show()
hbox.pack_start(icon_combobox, True, False, 2)
vbox.pack_end(hbox)
assi.set_page_complete(label.get_parent(), True)
# Final page
# As this is the last page needs to be of page_type
# gtk.ASSISTANT_PAGE_CONFIRM or gtk.ASSISTANT_PAGE_SUMMARY
label = gtk.Label('Thanks for using the toolbutton assistent!')
label.set_line_wrap(True)
label.show()
assi.append_page(label)
assi.set_page_title(label, 'Finish')
assi.set_page_complete(label, True)
assi.set_page_type(label, gtk.ASSISTANT_PAGE_CONFIRM)
assi.show()
def __init__(self):
self.capturing = False
assistant = gtk.Assistant()
self.assistant = assistant
f = open('/proc/asound/cards', 'r')
cards = {}
for c in f.read().split('\n'):
try:
dev = int(c.lstrip().split(' ')[0])
name = c.split(']: ')[1]
cards[dev] = name
except:
pass
f.close()
output = subprocess.Popen(['xrandr', '-q'],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE).communicate()[0]
resolutions = []
for line in output.split('\n'):
try:
if line.startswith('Screen'):
res = line.split(',')[1].strip().split(' ')
resolutions += ["%sx%s+0+0" % (res[1], res[3])]
elif line.find(' connected ') > 0:
resolutions += [line.split(' ')[2]]
except:
pass
assistant.connect("close", self.button_pressed, "Close")
assistant.connect("cancel", self.button_pressed, "Cancel")
vbox = gtk.VBox()
vbox.set_border_width(5)
page = assistant.append_page(vbox)
assistant.set_page_title(vbox, "Page 1: Intro")
assistant.set_page_type(vbox, gtk.ASSISTANT_PAGE_INTRO)
label = gtk.Label('Screen recording for Opencast Matterhorn…')
label.set_line_wrap(True)
vbox.pack_start(label, True, True, 0)
assistant.set_page_complete(vbox, True)
table = gtk.Table(5, 2)
table.set_col_spacings(3)
assistant.append_page(table)
assistant.set_page_title(table, "Page 2: Select options")
assistant.set_page_type(vbox, gtk.ASSISTANT_PAGE_CONTENT)
# Device selection
label = gtk.Label("Select device for audio input:")
self.cardchooser = gtk.combo_box_new_text()
for d, n in cards.items():
self.cardchooser.append_text(str(d) + ': ' + n)
self.cardchooser.append_text('pulse')
self.cardchooser.set_active(0)
table.attach(label, 0, 1, 0, 1)
table.attach(self.cardchooser, 1, 2, 0, 1)
# Rregion
label = gtk.Label("Region to capture:")
#self.regionentry = gtk.Entry()
#self.regionentry.set_text( "1920x1200+0+0" )
self.regionentry = gtk.Combo()
self.regionentry.set_popdown_strings(resolutions)
table.attach(label, 0, 1, 1, 2)
table.attach(self.regionentry, 1, 2, 1, 2)
# Output file
label = gtk.Label("select output file:")
#self.filechooserbutton = gtk.FileChooserButton("Select A File", None)
self.filechooserbutton = gtk.Entry()
table.attach(label, 0, 1, 2, 3)
table.attach(self.filechooserbutton, 1, 2, 2, 3)
# Audio codec
label = gtk.Label("Select audio codec:")
self.acodecchooser = gtk.combo_box_new_text()
for codec in ['flac', 'libmp3lame', 'libvorbis', 'vorbis', 'aac']:
self.acodecchooser.append_text(codec)
self.acodecchooser.set_active(0)
table.attach(label, 0, 1, 3, 4)
table.attach(self.acodecchooser, 1, 2, 3, 4)
# Video codec
label = gtk.Label("Select video codec:")
self.vcodecchooser = gtk.combo_box_new_text()
for codec in [
'mpeg2video', 'libtheora', 'theora', 'vp8', 'libx264',
'libxvid', 'ljpeg', 'flv'
]:
self.vcodecchooser.append_text(codec)
self.vcodecchooser.set_active(0)
table.attach(label, 0, 1, 4, 5)
table.attach(self.vcodecchooser, 1, 2, 4, 5)
# page complete
assistant.set_page_complete(table, True)
vbox = gtk.VBox()
vbox.set_border_width(5)
assistant.append_page(vbox)
assistant.set_page_title(vbox, "Page 3: Start capturing")
assistant.set_page_type(vbox, gtk.ASSISTANT_PAGE_PROGRESS)
self.capturebutton = gtk.Button('Start capturing…')
vbox.pack_start(self.capturebutton, False, False, 0)
self.capturebutton.connect('clicked', self.capture)
vbox = gtk.VBox()
vbox.set_border_width(5)
assistant.append_page(vbox)
assistant.set_page_title(vbox, "Page 4: The Finale")
assistant.set_page_type(vbox, gtk.ASSISTANT_PAGE_SUMMARY)
label = gtk.Label("TODO: Upload to Opencast Matterhorn…")
label.set_line_wrap(True)
vbox.pack_start(label, True, True, 0)
assistant.set_page_complete(vbox, True)
assistant.show_all()
def __init__(self, setup_profiles):
self.setup_profiles = setup_profiles
self.assistant = gtk.Assistant()
self.assistant.connect('delete_event', self.delete)
self.assistant.connect('close', self.close)
## Construct Page 0
vbox_0 = gtk.VBox(False, 5)
vbox_0.set_border_width(5)
vbox_0.show()
profile_name = gtk.Entry(max=0)
profile_name.show()
profile_name.connect('changed', self.check_profile_name)
vbox_0.pack_start(profile_name, True, True, 0)
self.assistant.append_page(vbox_0)
self.assistant.set_page_title(vbox_0, 'Profile Name')
self.assistant.set_page_type(vbox_0, gtk.ASSISTANT_PAGE_CONTENT)
## Construct Page 1
vbox_1 = gtk.VBox(False, 5)
vbox_1.set_border_width(5)
vbox_1.show()
spring_binary_location = gtk.Entry(max=0)
spring_binary_location.show()
spring_binary_location.connect('changed', self.check_spring_binary)
vbox_1.pack_start(spring_binary_location, True, True, 0)
self.assistant.append_page(vbox_1)
self.assistant.set_page_title(vbox_1, 'Spring Excuteable Location')
self.assistant.set_page_type(vbox_1, gtk.ASSISTANT_PAGE_CONTENT)
## Construct Page 2
vbox_2 = gtk.VBox(False, 5)
vbox_2.set_border_width(5)
vbox_2.show()
spring_datadir_location = gtk.Entry(max=0)
spring_datadir_location.show()
spring_datadir_location.connect('changed', self.check_spring_datadir)
vbox_2.pack_start(spring_datadir_location, True, True, 0)
self.assistant.append_page(vbox_2)
self.assistant.set_page_title(vbox_2, 'Spring Datadir Location')
self.assistant.set_page_type(vbox_2, gtk.ASSISTANT_PAGE_CONTENT)
## Contstruct Page 3
vbox_3 = gtk.VBox(False, 5)
vbox_3.set_border_width(5)
vbox_3.show()
label = gtk.Label(
"UnityLobby is still under development & multiplayer is not yet in working condition."
)
label.show()
vbox_3.pack_start(label, True, True, 0)
self.assistant.append_page(vbox_3)
self.assistant.set_page_title(vbox_3, "Author's Notes")
self.assistant.set_page_type(vbox_3, gtk.ASSISTANT_PAGE_SUMMARY)
self.assistant.show()
def create_ui(self):
self.widget = gtk.Assistant()
self.widget.connect("prepare", self.assistant_prepared)
self.widget.connect("cancel", self.cancel_button_clicked)
self.widget.connect("close", self.close_button_clicked)
self.widget.connect("apply", self.apply_button_clicked)
# # Introduction #
box = gtk.HBox()
self.widget.append_page(box)
self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_INTRO)
self.widget.set_page_title(box, "Introduction")
content = (
'This wizard will guide you through the process of '
'calibrating the device load feedback measurement circuit. '
'This feedback circuit is used to measure the impedance '
'between the actuated area and ground. This impedance is '
'related to the volume of liquid between the actuated area'
'\n\nSee '
r'<a href="http://microfluidics.utoronto.ca/trac/dropbot/wiki/Control board calibration#device-load-impedance-calibration">'
'here</a> for more details.')
label = gtk.Label(content)
label.set_use_markup(True)
label.set_line_wrap(True)
image = gtk.Image()
img_path = pkg_resources.resource_filename(
'dmf_control_board_firmware', 'gui/impedance_feedback_intro.png')
image.set_from_file(str(img_path))
box.pack_start(label, True, False, padding=15)
box.pack_start(image, True, True, padding=5)
self.widget.set_page_complete(box, True)
# # Connect hardware #
box = gtk.HBox()
self.widget.append_page(box)
self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_CONTENT)
self.widget.set_page_title(box, "Connect hardware")
label = gtk.Label(
' - Connect DropBot "<tt>Out to Amp</tt>" to amplifier input.\n'
' - Connect amplifier output to DropBot "<tt>In from Amp</tt>".\n'
' - Connect DropBot "<tt>0-39</tt>" to test board.')
image = gtk.Image()
img_path = pkg_resources.resource_filename(
'dmf_control_board_firmware', 'gui/impedance_feedback_setup.png')
image.set_from_file(str(img_path))
label.set_line_wrap(True)
label.set_use_markup(True)
box.pack_start(label, True, False, padding=15)
box.pack_start(image, True, True, padding=5)
self.widget.set_page_complete(box, True)
# # Select frequencies #
form = Form.of(
Integer.named('start_frequency').using(
default=self.control_board.min_waveform_frequency,
optional=True,
validators=[
ValueAtLeast(
minimum=self.control_board.min_waveform_frequency),
ValueAtMost(
maximum=self.control_board.max_waveform_frequency)
]),
Integer.named('end_frequency').using(
default=self.control_board.max_waveform_frequency,
optional=True,
validators=[
ValueAtLeast(
minimum=self.control_board.min_waveform_frequency),
ValueAtMost(
maximum=self.control_board.max_waveform_frequency)
]),
Integer.named('number_of_steps').using(default=10,
optional=True,
validators=[
ValueAtLeast(minimum=2),
]),
Integer.named('RMS_voltage').using(
default=min(100, self.control_board.max_waveform_voltage),
optional=True,
validators=[
ValueAtLeast(minimum=10),
ValueAtMost(
maximum=self.control_board.max_waveform_voltage)
]))
box = gtk.HBox()
self.form_view = create_form_view(form)
box.pack_start(self.form_view.widget, fill=False, padding=40)
self.widget.append_page(box)
self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_CONTENT)
self.widget.set_page_title(box, "Select calibration frequencies")
self.widget.set_page_complete(box, True)
## # Record measurements #
box1 = gtk.VBox()
self.widget.append_page(box1)
self.widget.set_page_type(box1, gtk.ASSISTANT_PAGE_PROGRESS)
self.widget.set_page_title(box1, "Record measurements")
self.measurements_label = gtk.Label('Ready.')
self.measurements_label.set_line_wrap(True)
self.measure_progress = gtk.ProgressBar()
box1.pack_start(self.measurements_label, True, True, 0)
box1.pack_start(self.measure_progress,
expand=False,
fill=False,
padding=15)
self.box1 = box1
# # Confirm fitted parameters #
box = gtk.VBox()
self.widget.append_page(box)
self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_CONFIRM)
self.widget.set_page_title(box, "Confirm fitted parameters")
self.figure = Figure(dpi=72)
self.canvas = FigureCanvasGTK(self.figure)
toolbar = NavigationToolbar(self.canvas, self.widget)
#self.axis = figure.add_subplot(111)
box.pack_start(self.canvas)
box.pack_start(toolbar, False, False)
self.widget.set_page_complete(box, True)
## # Summary #
box = gtk.VBox()
self.widget.append_page(box)
self.widget.set_page_type(box, gtk.ASSISTANT_PAGE_SUMMARY)
self.widget.set_page_title(box, "Summary")
label = gtk.Label('Calibration of device load feedback circuit is '
'complete. The impedance between actuated device '
'area and ground should now be measured accurately '
'by the control board.')
label.set_line_wrap(True)
box.pack_start(label, True, True, 0)
self.widget.set_page_complete(box, True)
def __init__(self):
self.asst = gtk.Assistant()
self.asst.set_title(_('Debian Live Magic'))
self.asst.set_default_size(640, 480)
self.asst.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
self.asst.set_position(gtk.WIN_POS_CENTER)
self.asst.connect('apply', self.controller.on_wizard_apply)
self.asst.connect('cancel', self.controller.on_wizard_cancel)
def add_about_button():
label = gtk.Label(_('About'))
label.show()
image = gtk.Image()
image.set_from_stock(gtk.STOCK_ABOUT, gtk.ICON_SIZE_BUTTON)
image.show()
vbox = gtk.HBox(spacing=4)
vbox.add(label)
vbox.add(image)
vbox.show()
btn = gtk.Button()
btn.add(vbox)
btn.connect('clicked', self.controller.on_about_request)
btn.show()
self.asst.add_action_widget(btn)
add_about_button()
# Load paages from Glade resource file.
notebook = self['notebook_wizard']
page_types = [gtk.ASSISTANT_PAGE_INTRO] + \
[gtk.ASSISTANT_PAGE_CONTENT] * (notebook.get_n_pages() - 2) + \
[gtk.ASSISTANT_PAGE_CONFIRM]
hide_distribution = False
try:
f = open('/etc/debian_version')
if f.read(3) == "5.0":
hide_distribution = True
f.close()
except:
pass
for i in range(notebook.get_n_pages()):
if i == 2 and hide_distribution:
# Hide distribution when running Lenny as stable.
continue
if i == 5 and self.controller.get_host_architecture() != 'amd64':
# Only show architecture page if using amd64
continue
page = notebook.get_nth_page(i)
page.unparent()
self.asst.append_page(page)
self.asst.set_page_complete(page, True)
self.asst.set_page_type(page, page_types[i])
self.asst.set_page_title(page, notebook.get_tab_label_text(page))
c = self['combobox_mirror']
c.prepend_text(get_mirror())
c.set_active(0)
c = self['combo_net_root_filesystem']
c.append_text('NFS')
c.append_text('CIFS')
c.set_active(0)
c = self['combo_locale']
c.set_active(0)
match = os.environ.get('LANG', 'en_US.UTF-8')
found = False
for idx, locale in enumerate(self.controller.get_locales()):
c.append_text(locale)
if found:
continue
if locale.replace('-', '_') == match.replace('-', '_'):
c.set_active(idx)
found = True
elif match.startswith(locale):
c.set_active(idx)
c = self['combo_keyboard']
match = None
try:
kv = KeyVar('/etc/default',
'console-setup', {},
filename='/etc/default/console-setup')
match = kv.get('XKBLAYOUT')
except IOError:
pass
pat = re.compile(r'\s*Option\s*"XkbLayout"\s*"([^"]+)"')
try:
xorgconf = file('/etc/X11/xorg.conf')
for line in xorgconf:
m = pat.match(line)
if m:
match = m.group(1)
except IOError:
pass
if match is None:
match = "us"
elif match == 'gb':
match = 'uk'
for idx, layout in enumerate(self.controller.get_keyboard_layouts()):
code, name = layout
c.append_text('%s (%s)' % (name, code.upper()))
if code == match:
c.set_active(idx)
server = '192.168.1.1'
path = '/srv/debian-live'
try:
kv = KeyVar('/etc/default',
'live-helper', {},
filename='/etc/default/live-helper')
server = kv.get('LH_NET_ROOT_SERVER', server)
path = kv.get('LH_NET_ROOT_PATH', path)
except IOError:
pass
self['entry_net_root_server'].set_text(server)
self['entry_net_root_path'].set_text(path)
f = self['filechooser_build_directory']
f.set_uri(self.controller.get_homedir())
