def getScreen(self, mouse):
self.mouse = mouse
self.flags = flags
self.ignoreEvents = 0
self.mice = mouse.mouseModels
self.serialDevice = None
currentDev = mouse.getDevice()
currentMouse, emulate3 = mouse.getMouse()
# populate the big widgets with the available selections
self.setupMice()
self.setupDeviceList()
self.emulate3 = gtk.CheckButton(_("_Emulate 3 buttons"))
self.setCurrent(currentDev, currentMouse, emulate3)
# set up the box for this screen
box = gtk.VBox(gtk.FALSE, 5)
box.set_border_width(5)
# top header, includes graphic and instructions
hbox = gtk.HBox(gtk.FALSE, 5)
pix = self.ics.readPixmap("gnome-mouse.png")
if pix:
a = gtk.Alignment()
a.add(pix)
a.set(0.0, 0.0, 0.0, 0.0)
hbox.pack_start(a, gtk.FALSE)
label = gui.MnemonicLabel(
_("Select the appropriate mouse for the system."))
label.set_line_wrap(gtk.TRUE)
label.set_size_request(350, -1)
hbox.pack_start(label, gtk.FALSE)
box.pack_start(hbox, gtk.FALSE)
# next is the mouse tree
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_IN)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.add(self.mouseview)
box.pack_start(sw)
label.set_mnemonic_widget(self.mouseview)
gui.setupTreeViewFixupIdleHandler(self.mouseview, self.mousestore)
# then the port list
serial_sw = gtk.ScrolledWindow()
serial_sw.set_shadow_type(gtk.SHADOW_IN)
serial_sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_NEVER)
serial_sw.add(self.devview)
box.pack_start(serial_sw, gtk.FALSE)
# finally the emulate 3 buttons
box.pack_start(self.emulate3, gtk.FALSE)
return box
def getScreen(self, anaconda):
self.abiquoPassword = anaconda.id.abiquoPassword
self.intf = anaconda.intf
self.idata = anaconda.id
box = gtk.VBox(spacing=6)
box.set_border_width(5)
#hbox = gtk.HBox()
#pix = gui.readImageFromFile ("root-password.png")
#if pix:
# hbox.pack_start (pix, False)
label = gtk.Label("")
label.set_markup(
"<b><big>Abiquo Cloud Administrator (admin) password</big></b>")
label.set_alignment(0.0, 0.5)
box.pack_start(label, False)
#box.pack_start(hbox, False)
self.forward = lambda widget, box=box: box.emit(
'focus', gtk.DIR_TAB_FORWARD)
table = gtk.Table(2, 2)
table.set_size_request(365, -1)
table.set_row_spacings(5)
table.set_col_spacings(5)
pass1 = gui.MnemonicLabel("Password: "******"Confirm: ")
pass2.set_alignment(0.0, 0.5)
table.attach(pass2, 0, 1, 1, 2, gtk.FILL, 0, 10)
self.pw = gtk.Entry(128)
pass1.set_mnemonic_widget(self.pw)
self.pw.connect("activate", self.forward)
self.pw.connect("map-event", self.setFocus)
self.pw.set_visibility(False)
self.confirm = gtk.Entry(128)
pass2.set_mnemonic_widget(self.confirm)
self.confirm.connect("activate", self.forward)
self.confirm.set_visibility(False)
table.attach(self.pw, 1, 2, 0, 1, gtk.FILL | gtk.EXPAND, 5)
table.attach(self.confirm, 1, 2, 1, 2, gtk.FILL | gtk.EXPAND, 5)
hbox = gtk.HBox()
hbox.pack_start(table, False)
box.pack_start(hbox, False)
# Description
label = gtk.Label("")
label.set_markup("The Cloud Administrator account is used for "
"administering Abiquo.\n\n"
"<b>Default user:</b> admin\n"
"<b>Default password:</b> xabiquo")
label.set_line_wrap(True)
label.set_size_request(400, -1)
label.set_alignment(0.0, 0.5)
box.pack_start(label, False)
# root password statusbar
self.rootStatus = gtk.Label("")
wrapper = gtk.HBox(0, False)
wrapper.pack_start(self.rootStatus)
box.pack_start(wrapper, False)
self.pw.set_text(self.abiquoPassword)
self.confirm.set_text(self.abiquoPassword)
return box
def getScreen(self, dispatch, xsetup, videocard, intf):
self.ics.setHelpEnabled(gtk.TRUE)
self.dispatch = dispatch
self.videocard = videocard
self.xsetup = xsetup
self.intf = intf
self.lastvalidselection = None
box = gtk.VBox(gtk.FALSE, 0)
box.set_border_width(0)
self.autoBox = gtk.VBox(gtk.FALSE, 5)
self.force_ppc_fb = 0
arch = iutil.getArch()
# we can only probe video ram on i386
# and we force frame buffer on ppc currently
if arch == "ppc":
label = makeFormattedLabel(
_("Your system will be setup to "
"use the frame buffer driver for "
"the X Window System. If you do "
"not want to setup the X Window "
"System, choose "
"'Skip X Configuration' below."))
box.pack_start(label, gtk.FALSE, gtk.FALSE)
self.force_ppc_fb = 1
elif arch != "i386":
label = makeFormattedLabel(
_("Your video ram size can not be "
"autodetected. Choose your video "
"ram size from the choices below:"))
box.pack_start(label, gtk.FALSE)
else:
self.autoBox = gtk.VBox(gtk.FALSE, 5)
label = makeFormattedLabel(
_("In most cases, the video hardware "
"can be automatically detected. "
"If the detected settings are not "
"correct for the hardware, select "
"the right settings."))
self.autoBox.pack_start(label, gtk.FALSE)
box.pack_start(self.autoBox, gtk.FALSE)
# load in card database
self.cards = self.videocard.cardsDB()
cards = self.cards.keys()
cards.sort()
other_cards = copy.copy(cards)
self.currentCard = None
self.probedCard = None
if self.videocard.primaryCard():
carddata = self.videocard.primaryCard().getCardData(dontResolve=1)
if carddata:
self.currentCard = carddata["NAME"]
else:
self.currentCard = None
carddata = self.videocard.primaryCard(useProbed=1).getCardData()
if carddata:
self.probedCard = carddata["NAME"]
else:
self.probedCard = None
# load images of videocard
fn = self.ics.findPixmap("videocard.png")
p = gtk.gdk.pixbuf_new_from_file(fn)
if p:
self.videocard_p, self.videocard_b = p.render_pixmap_and_mask()
# Videocard selection tree - preset 'Generic' and 'Other' nodes
self.cardstore = gtk.TreeStore(gobject.TYPE_STRING,
gobject.TYPE_STRING)
toplevels = {}
# add "Generic" in before "Other" if supporting XFree86 3.x
# Note other changes in videocard.py and elsewhere required to support
# XFree86 3.x again
manufacturers = ["Other"] + self.videocard.manufacturerDB()
for man in manufacturers:
toplevels[man] = self.cardstore.append(None)
self.cardstore.set_value(toplevels[man], 0, man)
# now go through cards and matchup with manufacturers
for card in cards:
temp = string.lower(card)
for man in manufacturers:
if string.lower(man) == temp[:len(man)]:
parent = toplevels.get(man)
iter = self.cardstore.append(parent)
self.cardstore.set_value(iter, 0, card)
other_cards.remove(card)
# now add cards not categorized into above manufacturers
for card in other_cards:
parent = toplevels.get("Other")
iter = self.cardstore.append(parent)
self.cardstore.set_value(iter, 0, card)
self.cardview = gtk.TreeView(self.cardstore)
self.cardview.set_property("headers-visible", gtk.FALSE)
col = gtk.TreeViewColumn(None, gtk.CellRendererText(), text=0)
self.cardview.append_column(col)
selection = self.cardview.get_selection()
selection.connect("changed", self.selectCardType)
selection.set_select_function(self.cardviewSelectCb)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_IN)
sw.add(self.cardview)
# only show this option on non-ppc
if not self.force_ppc_fb:
box.pack_start(sw, gtk.TRUE)
#Memory configuration menu
hbox = gtk.HBox()
hbox.set_border_width(3)
label = gui.MnemonicLabel(_("_Video card RAM: "))
self.ramOption = gtk.OptionMenu()
label.set_mnemonic_widget(self.ramOption)
self.ramOption.set_size_request(40, 20)
self.ramMenu = gtk.Menu()
for mem in self.videocard.possible_ram_sizes():
if mem < 1000:
tag = "%d KB" % (mem)
else:
tag = "%d MB" % (mem / 1024)
memitem = gtk.MenuItem(tag)
self.ramMenu.add(memitem)
hbox.pack_start(label, gtk.FALSE)
hbox.pack_start(self.ramOption, gtk.TRUE, gtk.TRUE, 25)
self.ramOption.set_menu(self.ramMenu)
# only show this option on non-ppc
if not self.force_ppc_fb:
box.pack_start(hbox, gtk.FALSE)
restore = gtk.Button(_("Restore _original values"))
restore.connect("clicked", self.restorePressed)
hbox.pack_start(restore, gtk.FALSE, 25)
self.skip = gtk.CheckButton(_("_Skip X configuration"))
self.skip.connect("toggled", self.skipToggled)
hbox = gtk.HBox(gtk.TRUE, 5)
self.topbox = gtk.VBox(gtk.FALSE, 5)
self.topbox.set_border_width(5)
if self.force_ppc_fb:
# tweak packing
self.topbox.pack_start(box, gtk.FALSE, gtk.FALSE)
self.topbox.pack_start(self.skip, gtk.FALSE, gtk.FALSE)
else:
self.topbox.pack_start(box, gtk.TRUE, gtk.TRUE)
self.topbox.pack_start(self.skip, gtk.FALSE)
self.configbox = box
self.skip.set_active(self.dispatch.stepInSkipList("monitor"))
# set state
self.ignoreEvents = 0
self.currentMem = self.videocard.primaryCard(useProbed=0).getVideoRam()
self.probedMem = self.videocard.primaryCard(useProbed=1).getVideoRam()
self.setCurrent(self.currentCard, self.currentMem)
setupTreeViewFixupIdleHandler(self.cardview, self.cardstore)
return self.topbox
def editOther(self, oldDevice, oldLabel, isDefault, isRoot = 0):
dialog = gtk.Dialog(_("Image"), self.parent)
dialog.add_button('gtk-cancel', 2)
dialog.add_button('gtk-ok', 1)
dialog.set_position(gtk.WIN_POS_CENTER)
gui.addFrame(dialog)
dialog.vbox.pack_start(gui.WrappingLabel(
_("Enter a label to be displayed in the boot loader menu. The "
"device (or hard drive and partition number) is the device "
"from which it boots.")))
spacer = gtk.Label("")
spacer.set_size_request(10, 1)
dialog.vbox.pack_start(spacer, False)
table = gtk.Table(2, 5)
table.set_row_spacings(5)
table.set_col_spacings(5)
label = gui.MnemonicLabel(_("_Label"))
table.attach(label, 0, 1, 1, 2, gtk.FILL, 0, 10)
labelEntry = gtk.Entry(32)
label.set_mnemonic_widget(labelEntry)
table.attach(labelEntry, 1, 2, 1, 2, gtk.FILL, 0, 10)
if oldLabel:
labelEntry.set_text(oldLabel)
label = gui.MnemonicLabel(_("_Device"))
table.attach(label, 0, 1, 2, 3, gtk.FILL, 0, 10)
if not isRoot:
# XXX should potentially abstract this out into a function
pedparts = []
parts = []
disks = self.diskset.disks
for drive in disks.keys():
pedparts.extend(partedUtils.get_all_partitions(disks[drive]))
for part in pedparts:
parts.append(partedUtils.get_partition_name(part))
del pedparts
parts.sort()
deviceCombo = datacombo.DataComboBox()
defindex = 0
i = 0
for part in parts:
deviceCombo.append("/dev/%s" %(part,), part)
if oldDevice and oldDevice == part:
defindex = i
i = i + 1
deviceCombo.set_active(defindex)
table.attach(deviceCombo, 1, 2, 2, 3, gtk.FILL, 0, 10)
label.set_mnemonic_widget(deviceCombo)
else:
table.attach(gtk.Label(oldDevice), 1, 2, 2, 3, gtk.FILL, 0, 10)
default = gtk.CheckButton(_("Default Boot _Target"))
table.attach(default, 0, 2, 3, 4, gtk.FILL, 0, 10)
if isDefault != 0:
default.set_active(True)
if self.numentries == 1 and oldDevice != None:
default.set_sensitive(False)
else:
default.set_sensitive(True)
dialog.vbox.pack_start(table)
dialog.show_all()
while 1:
rc = dialog.run()
# cancel
if rc == 2:
break
label = labelEntry.get_text()
if not isRoot:
dev = deviceCombo.get_active_value()
else:
dev = oldDevice
if not label:
self.intf.messageWindow(_("Error"),
_("You must specify a label for the "
"entry"),
type="warning")
continue
foundBad = 0
for char in self.illegalChars:
if char in label:
self.intf.messageWindow(_("Error"),
_("Boot label contains illegal "
"characters"),
type="warning")
foundBad = 1
break
if foundBad:
continue
# verify that the label hasn't been used
foundBad = 0
for key in self.imagelist.keys():
if dev == key:
continue
if self.blname == "GRUB":
thisLabel = self.imagelist[key][1]
else:
thisLabel = self.imagelist[key][0]
# if the label is the same as it used to be, they must
# have changed the device which is fine
if thisLabel == oldLabel:
continue
if thisLabel == label:
self.intf.messageWindow(_("Duplicate Label"),
_("This label is already in "
"use for another boot entry."),
type="warning")
foundBad = 1
break
if foundBad:
continue
# XXX need to do some sort of validation of the device?
# they could be duplicating a device, which we don't handle
if dev in self.imagelist.keys() and (not oldDevice or
dev != oldDevice):
self.intf.messageWindow(_("Duplicate Device"),
_("This device is already being "
"used for another boot entry."),
type="warning")
continue
# if we're editing a previous, get what the old info was for
# labels. otherwise, make it something safe for grub and the
# device name for lilo for lack of any better ideas
if oldDevice:
(oldshort, oldlong, oldisroot) = self.imagelist[oldDevice]
else:
(oldshort, oldlong, oldisroot) = (dev, label, None)
# if we're editing and the device has changed, delete the old
if oldDevice and dev != oldDevice:
del self.imagelist[oldDevice]
# go ahead and add it
if self.blname == "GRUB":
self.imagelist[dev] = (oldshort, label, isRoot)
else:
self.imagelist[dev] = (label, oldlong, isRoot)
if default.get_active():
self.defaultDev = dev
# refill the os list store
self.fillOSList()
break
dialog.destroy()
def passwordWindow(self, *args):
dialog = gtk.Dialog(_("Enter Boot Loader Password"), self.parent)
dialog.add_button('gtk-cancel', 2)
dialog.add_button('gtk-ok', 1)
dialog.set_position(gtk.WIN_POS_CENTER)
gui.addFrame(dialog)
label = gui.WrappingLabel(_("Enter a boot loader password and then confirm it. (Note that your BIOS keymap may be different than the actual keymap you are used to.)"))
label.set_alignment(0.0, 0.0)
dialog.vbox.pack_start(label)
table = gtk.Table(2, 2)
table.set_row_spacings(5)
table.set_col_spacings(5)
label = gui.MnemonicLabel(_("_Password:"******"Con_firm:"))
table.attach(label, 0, 1, 3, 4, gtk.FILL, 0, 10)
confirmEntry = gtk.Entry (16)
confirmEntry.set_visibility (False)
label.set_mnemonic_widget(confirmEntry)
table.attach(confirmEntry, 1, 2, 3, 4, gtk.FILL, 0, 10)
dialog.vbox.pack_start(table)
# set the default
if self.password:
pwEntry.set_text(self.password)
confirmEntry.set_text(self.password)
dialog.show_all()
while 1:
rc = dialog.run()
if rc == 2:
break
if pwEntry.get_text() != confirmEntry.get_text():
self.intf.messageWindow(_("Passwords don't match"),
_("Passwords do not match"),
type='warning')
continue
thePass = pwEntry.get_text()
if not thePass:
continue
if len(thePass) < 6:
ret = self.intf.messageWindow(_("Warning"),
_("Your boot loader password is less than "
"six characters. We recommend a longer "
"boot loader password."
"\n\n"
"Would you like to continue with this "
"password?"),
type = "yesno")
if ret == 0:
continue
self.password = thePass
break
dialog.destroy()
return rc
def getScreen(self, xsetup, monitor, intf):
self.intf = intf
self.xsetup = xsetup
self.monitor = monitor
# some flags to let us know when to ignore callbacks we caused
self.ignoreEntryChanges = 0
self.ignoreEvents = 0
self.lastvalidselection = None
box = gtk.VBox(gtk.FALSE, 5)
label = makeFormattedLabel(
_("In most cases, the monitor can be "
"automatically detected. If the "
"detected settings are not correct "
"for the monitor, select the right "
"settings."))
box.pack_start(label, gtk.FALSE)
# Monitor selection tree
self.monitorstore = gtk.TreeStore(gobject.TYPE_STRING,
gobject.TYPE_STRING)
self.hEntry = gtk.Entry()
self.vEntry = gtk.Entry()
fn = self.ics.findPixmap("monitor-small.png")
p = gtk.gdk.pixbuf_new_from_file(fn)
if p:
self.monitor_p, self.monitor_b = p.render_pixmap_and_mask()
# load monitor list and insert into tree
self.origMonitorID = self.monitor.getMonitorID()
self.origMonitorName = self.monitor.getMonitorName()
if not self.origMonitorName:
self.origMonitorName = self.origMonitorID
self.origHsync = self.monitor.getMonitorHorizSync()
self.origVsync = self.monitor.getMonitorVertSync()
monitorslist = self.monitor.monitorsDB()
keys = monitorslist.keys()
keys.sort()
# treat Generic monitors special
idx = 0
for man in ["Generic LCD Display", "Generic CRT Display", "Generic"]:
if man in keys:
keys.remove(man)
keys.insert(idx, man)
idx += 1
self.currentMonitor = None
toplevels = {}
# Insert DDC probed monitor if it had no match in database
# or otherwise if we did not detect a monitor at all
#--Add a category for a DDC probed monitor if a DDC monitor was probed
self.ddcmon = self.monitor.getDDCProbeResults()
if self.ddcmon:
title = ddc_monitor_string
monentry = title + " - " + self.ddcmon[1]
else:
title = unprobed_monitor_string
monentry = title
man = title
toplevels[man] = self.monitorstore.append(None)
self.monitorstore.set_value(toplevels[man], 0, title)
iter = self.monitorstore.append(toplevels[man])
self.monitorstore.set_value(iter, 0, monentry)
# set as current monitor if necessary
if self.origMonitorID == "DDCPROBED" or self.origMonitorID == "Unprobed Monitor":
self.currentMonitor = monentry
self.origMonitorName = monentry
# now insert rest of monitors, unless we match the ddc probed id
for man in keys:
models = monitorslist[man]
if man in [
"Generic LCD Display", "Generic CRT Display", "Generic"
]:
title = _(man)
# dont sort generic, present in order in file
else:
title = man
models.sort()
toplevels[man] = self.monitorstore.append(None)
self.monitorstore.set_value(toplevels[man], 0, man)
previous_monitor = ""
for amonitor in models:
if previous_monitor != "":
if amonitor[0] == previous_monitor:
continue
if self.ddcmon and string.upper(
self.ddcmon[0]) == string.upper(amonitor[1]):
continue
previous_monitor = amonitor[0]
iter = self.monitorstore.append(toplevels[man])
self.monitorstore.set_value(iter, 0, amonitor[0])
if amonitor[0] == self.monitor.getMonitorID():
self.currentMonitor = amonitor[0]
self.monitorview = gtk.TreeView(self.monitorstore)
self.monitorview.set_property("headers-visible", gtk.FALSE)
col = gtk.TreeViewColumn(None, gtk.CellRendererText(), text=0)
self.monitorview.append_column(col)
sw = gtk.ScrolledWindow()
sw.add(self.monitorview)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_IN)
box.pack_start(sw, gtk.TRUE, gtk.TRUE)
self.setCurrent(self.currentMonitor)
selection = self.monitorview.get_selection()
selection.connect("changed", self.selectMonitorType)
selection.set_select_function(self.monitorviewSelectCb)
self.hEntry.connect("insert_text", self.insertCb,
(self.hEntry, self.vEntry))
self.vEntry.connect("insert_text", self.insertCb,
(self.vEntry, self.hEntry))
self.hEntry.connect("changed", self.changedCb,
(self.hEntry, self.vEntry))
self.vEntry.connect("changed", self.changedCb,
(self.vEntry, self.hEntry))
self.reset = gtk.Button(_("Restore _original values"))
self.reset.connect("clicked", self.resetCb)
align = gtk.Alignment
align = gtk.Alignment(1, 0.5)
align.add(self.reset)
synctable = gtk.Table(2, 4, gtk.FALSE)
hlabel = gui.MnemonicLabel(_("Hori_zontal Sync:"))
hlabel.set_alignment(0, 0.5)
hlabel.set_mnemonic_widget(self.hEntry)
vlabel = gui.MnemonicLabel(_("_Vertical Sync:"))
vlabel.set_alignment(0, 0.5)
vlabel.set_mnemonic_widget(self.vEntry)
self.hEntry.set_size_request(80, -1)
self.vEntry.set_size_request(80, -1)
hz = gtk.Label(_("kHz"))
hz.set_alignment(0, 0.5)
khz = gtk.Label(_("Hz"))
khz.set_alignment(0, 0.5)
synctable.attach(hlabel, 0, 1, 0, 1, gtk.SHRINK, gtk.FILL, 5)
synctable.attach(self.hEntry, 1, 2, 0, 1, gtk.SHRINK)
synctable.attach(hz, 2, 3, 0, 1, gtk.FILL, gtk.FILL, 5)
synctable.attach(vlabel, 0, 1, 1, 2, gtk.SHRINK, gtk.FILL, 5)
synctable.attach(self.vEntry, 1, 2, 1, 2, gtk.SHRINK)
synctable.attach(khz, 2, 3, 1, 2, gtk.FILL, gtk.FILL, 5)
synctable.attach(align, 3, 4, 1, 2)
box.pack_start(synctable, gtk.FALSE, gtk.FALSE)
setupTreeViewFixupIdleHandler(self.monitorview, self.monitorstore)
return box
def getScreen (self, anaconda):
self.rootPassword = anaconda.id.rootPassword
self.intf = anaconda.intf
self.passwords = {}
box = gtk.VBox ()
box.set_border_width(5)
hbox = gtk.HBox()
pix = gui.readImageFromFile ("root-password.png")
if pix:
hbox.pack_start (pix, False)
label = gui.WrappingLabel (_("The root account is used for "
"administering the system. Enter "
"a password for the root user."))
label.set_line_wrap(True)
label.set_size_request(350, -1)
label.set_alignment(0.0, 0.5)
hbox.pack_start(label, False)
box.pack_start(hbox, False)
self.forward = lambda widget, box=box: box.emit('focus', gtk.DIR_TAB_FORWARD)
table = gtk.Table (2, 2)
table.set_size_request(365, -1)
table.set_row_spacings (5)
table.set_col_spacings (5)
pass1 = gui.MnemonicLabel (_("Root _Password: "******"_Confirm: "))
pass2.set_alignment (0.0, 0.5)
table.attach (pass2, 0, 1, 1, 2, gtk.FILL, 0, 10)
self.pw = gtk.Entry (128)
pass1.set_mnemonic_widget(self.pw)
self.pw.connect ("activate", self.forward)
self.pw.connect ("map-event", self.setFocus)
self.pw.set_visibility (False)
self.confirm = gtk.Entry (128)
pass2.set_mnemonic_widget(self.confirm)
self.confirm.connect ("activate", self.forward)
self.confirm.set_visibility (False)
table.attach (self.pw, 1, 2, 0, 1, gtk.FILL|gtk.EXPAND, 5)
table.attach (self.confirm, 1, 2, 1, 2, gtk.FILL|gtk.EXPAND, 5)
hbox = gtk.HBox()
hbox.pack_start(table, False)
box.pack_start (hbox, False)
# root password statusbar
self.rootStatus = gtk.Label ("")
wrapper = gtk.HBox(0, False)
wrapper.pack_start (self.rootStatus)
box.pack_start (wrapper, False)
if not self.rootPassword["isCrypted"]:
self.pw.set_text(self.rootPassword["password"])
self.confirm.set_text(self.rootPassword["password"])
else:
self.pw.set_text("xxxxxxxx")
self.confirm.set_text("xxxxxxxx")
return box
def getScreen(self, anaconda):
self.neededSwap = 0
self.storage = anaconda.storage
self.intf = anaconda.intf
self.dispatch = anaconda.dispatch
rc = anaconda.upgradeSwapInfo
self.neededSwap = 1
self.row = 0
box = gtk.VBox(False, 5)
box.set_border_width(5)
label = gtk.Label(
_("Recent kernels (2.4 or newer) need significantly more "
"swap than older kernels, up to twice "
"the amount of RAM on the system. "
"You currently have %dMB of swap configured, but "
"you may create additional swap space on one of "
"your file systems now.") % (iutil.swapAmount() / 1024) +
_("\n\nThe installer has detected %s MB of RAM.\n") %
(iutil.memInstalled() / 1024))
label.set_alignment(0.5, 0.0)
# label.set_size_request(400, 200)
label.set_line_wrap(True)
box.pack_start(label, False)
hs = gtk.HSeparator()
box.pack_start(hs, False)
self.option1 = gtk.RadioButton(None,
(_("I _want to create a swap file")))
box.pack_start(self.option1, False)
(fsList, suggSize, suggMntPoint) = rc
self.swapbox = gtk.VBox(False, 5)
box.pack_start(self.swapbox, False)
label = gui.MnemonicLabel(
_("Select the _partition to put the swap file on:"))
a = gtk.Alignment(0.2, 0.5)
a.add(label)
self.swapbox.pack_start(a, False)
self.store = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING)
for (dev, size) in fsList:
iter = self.store.append()
self.store.set_value(iter, 0, dev)
self.store.set_value(iter, 1, str(size))
self.view = gtk.TreeView(self.store)
label.set_mnemonic_widget(self.view)
i = 0
for title in [(_("Mount Point")), (_("Partition")),
(_("Free Space (MB)"))]:
col = gtk.TreeViewColumn(title, gtk.CellRendererText(), text=i)
self.view.append_column(col)
i = i + 1
sw = gtk.ScrolledWindow()
sw.add(self.view)
sw.set_shadow_type(gtk.SHADOW_IN)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.set_size_request(300, 90)
a = gtk.Alignment(0.5, 0.5)
a.add(sw)
self.swapbox.pack_start(a, False, True, 10)
rootiter = self.store.get_iter_first()
sel = self.view.get_selection()
sel.select_iter(rootiter)
label = gtk.Label(
_("A minimum swap file size of "
"%d MB is recommended. Please enter a size for the swap "
"file:") % suggSize)
label.set_size_request(400, 40)
label.set_line_wrap(True)
a = gtk.Alignment(0.5, 0.5)
a.add(label)
self.swapbox.pack_start(a, False, True, 10)
hbox = gtk.HBox(False, 5)
a = gtk.Alignment(0.4, 0.5)
a.add(hbox)
self.swapbox.pack_start(a, False)
label = gui.MnemonicLabel(_("Swap file _size (MB):"))
hbox.pack_start(label, False)
self.entry = gtk.Entry(4)
label.set_mnemonic_widget(self.entry)
self.entry.set_size_request(40, 25)
self.entry.set_text(str(suggSize))
hbox.pack_start(self.entry, False, True, 10)
self.option2 = gtk.RadioButton(self.option1,
(_("I _don't want to create a swap "
"file")))
box.pack_start(self.option2, False, True, 20)
self.option1.connect("toggled", self.toggle)
return box
def getScreen (self, auth):
self.auth = auth
box = gtk.VBox (gtk.FALSE, 10)
nb = gtk.Notebook ()
self.md5 = gtk.CheckButton (_("Enable _MD5 passwords"))
self.shadow = gtk.CheckButton (_("Enable shado_w passwords"))
# nis
self.nis = gtk.CheckButton (_("Enable N_IS"))
self.nisBroadcast = gtk.CheckButton (_("Use _broadcast to find NIS server"))
self.nisDomain = gtk.Entry ()
self.nisServer = gtk.Entry ()
self.md5.set_active (self.auth.useMD5)
self.shadow.set_active (self.auth.useShadow)
self.nis.set_active (self.auth.useNIS)
self.nisDomain.set_text (self.auth.nisDomain)
self.nisBroadcast.set_active (self.auth.nisuseBroadcast)
self.nisServer.set_text (self.auth.nisServer )
self.nisDomainLabel = gui.MnemonicLabel (_("NIS _Domain: "))
self.nisDomainLabel.set_alignment (0, 0)
self.nisDomainLabel.set_mnemonic_widget(self.nisDomain)
self.nisServerLabel = gui.MnemonicLabel (_("NIS _Server: "))
self.nisServerLabel.set_alignment (0, 0)
self.nisServerLabel.set_mnemonic_widget(self.nisServer)
self.nis.connect ("toggled", self.setSensitivities)
self.nisBroadcast.connect ("toggled", self.setSensitivities)
a = gtk.Alignment (0, 0)
a.add (self.nisBroadcast)
nistable = gtk.Table (10, 4, gtk.FALSE)
nistable.attach (self.nis, 0, 10, 0, 1, gtk.FILL, gtk.SHRINK, 0.0, 0.5)
spacer = gtk.Label("")
spacer.set_size_request(10, 1)
nistable.attach (spacer, 0, 1, 1, 2, gtk.SHRINK, gtk.SHRINK, 0.0, 0.5)
nistable.attach (self.nisDomainLabel, 2, 3, 1, 2, gtk.FILL, gtk.SHRINK, 0.0, 0.5)
nistable.attach (self.nisDomain, 3, 15, 1, 2, gtk.SHRINK, gtk.SHRINK, 0.0, 0.5)
nistable.attach (a, 2, 10, 2, 3, gtk.SHRINK, gtk.SHRINK, 0.0, 0.5)
nistable.attach (self.nisServerLabel, 2, 5, 3, 4, gtk.FILL, gtk.SHRINK, 0.0, 0.5)
nistable.attach (self.nisServer, 3, 10, 3, 4, gtk.SHRINK, gtk.SHRINK, 0.0, 0.5)
# ldap
self.ldap = gtk.CheckButton (_("Enable _LDAP"))
self.ldapServer = gtk.Entry ()
self.ldapBasedn = gtk.Entry ()
self.ldapTLS = gtk.CheckButton (_("Use _TLS lookups"))
self.ldapServerLabel = gui.MnemonicLabel (_("LDAP _Server:"))
self.ldapServerLabel.set_alignment (0, 0)
self.ldapServerLabel.set_mnemonic_widget(self.ldapServer)
self.ldapBasednLabel = gui.MnemonicLabel (_("LDAP _Base DN:"))
self.ldapBasednLabel.set_alignment (0, 0)
self.ldapBasednLabel.set_mnemonic_widget(self.ldapBasedn)
# restore ldap settings
self.ldap.set_active (self.auth.useLdap)
self.ldapServer.set_text (self.auth.ldapServer)
self.ldapBasedn.set_text (self.auth.ldapBasedn)
ldaptable = gtk.Table (10, 4, gtk.FALSE)
ldaptable.attach (self.ldap, 0, 10, 0, 1, gtk.FILL, gtk.SHRINK, 0.0, 0.5)
spacer = gtk.Label("")
spacer.set_size_request(10, 1)
ldaptable.attach (spacer, 0, 1, 1, 2, gtk.SHRINK, gtk.SHRINK, 0.0, 0.5)
ldaptable.attach (self.ldapServerLabel, 2, 3, 1, 2, gtk.FILL, gtk.SHRINK, 0.0, 0.5)
ldaptable.attach (self.ldapServer, 3, 10, 1, 2, gtk.SHRINK, gtk.SHRINK, 0.0, 0.5)
ldaptable.attach (self.ldapBasednLabel, 2, 3, 2, 3, gtk.FILL, gtk.SHRINK, 0.0, 0.5)
ldaptable.attach (self.ldapBasedn, 3, 10, 2, 3, gtk.SHRINK, gtk.SHRINK, 0.0, 0.5)
a = gtk.Alignment (0, 0)
a.add (self.ldapTLS)
ldaptable.attach (a, 2, 3, 3, 4, gtk.SHRINK, gtk.SHRINK, 0.0, 0.5)
self.ldap.connect ("toggled", self.setSensitivities)
# krb5
self.krb5 = gtk.CheckButton (_("Enable _Kerberos"))
self.krb5Realm = gtk.Entry ()
self.krb5Kdc = gtk.Entry ()
self.krb5Admin = gtk.Entry ()
self.krb5RealmLabel = gui.MnemonicLabel (_("R_ealm:"))
self.krb5RealmLabel.set_alignment (0, 0)
self.krb5RealmLabel.set_mnemonic_widget(self.krb5Realm)
self.krb5KdcLabel = gui.MnemonicLabel (_("K_DC:"))
self.krb5KdcLabel.set_alignment (0, 0)
self.krb5KdcLabel.set_mnemonic_widget(self.krb5Kdc)
self.krb5AdminLabel = gui.MnemonicLabel (_("_Admin Server:"))
self.krb5AdminLabel.set_alignment (0, 0)
self.krb5AdminLabel.set_mnemonic_widget(self.krb5Admin)
# restore krb5 settings
self.krb5.set_active (self.auth.useKrb5)
self.krb5Realm.set_text (self.auth.krb5Realm)
self.krb5Kdc.set_text (self.auth.krb5Kdc)
self.krb5Admin.set_text (self.auth.krb5Admin)
krb5table = gtk.Table (10, 4, gtk.FALSE)
krb5table.attach (self.krb5, 0, 10, 0, 1, gtk.FILL, gtk.SHRINK, 0.0, 0.5)
spacer = gtk.Label("")
spacer.set_size_request(10, 1)
krb5table.attach (spacer, 0, 1, 1, 2, gtk.SHRINK, gtk.SHRINK, 0.0, 0.5)
krb5table.attach (self.krb5RealmLabel, 2, 3, 1, 2, gtk.FILL, gtk.SHRINK, 0.0, 0.5)
krb5table.attach (self.krb5Realm, 3, 10, 1, 2, gtk.SHRINK, gtk.SHRINK, 0.0, 0.5)
krb5table.attach (self.krb5KdcLabel, 2, 3, 2, 3, gtk.FILL, gtk.SHRINK, 0.0, 0.5)
krb5table.attach (self.krb5Kdc, 3, 10, 2, 3, gtk.SHRINK, gtk.SHRINK, 0.0, 0.5)
krb5table.attach (self.krb5AdminLabel, 2, 3, 3, 4, gtk.FILL, gtk.SHRINK, 0.0, 0.5)
krb5table.attach (self.krb5Admin, 3, 10, 3, 4, gtk.SHRINK, gtk.SHRINK, 0.0, 0.5)
self.krb5.connect ("toggled", self.setSensitivities)
# samba
self.samba = gtk.CheckButton (_("Enable SMB _Authentication"))
self.sambaServer = gtk.Entry ()
self.sambaWorkgroup = gtk.Entry ()
self.sambaLabel1 = gui.MnemonicLabel (_("SMB _Server:"))
self.sambaLabel1.set_alignment (0, 0)
self.sambaLabel1.set_mnemonic_widget(self.sambaServer)
self.sambaLabel2 = gui.MnemonicLabel (_("SMB Work_group:"))
self.sambaLabel2.set_alignment (0, 0)
self.sambaLabel2.set_mnemonic_widget(self.sambaWorkgroup)
# restore ldap settings
self.samba.set_active (self.auth.useSamba)
self.sambaServer.set_text (self.auth.sambaServer)
self.sambaWorkgroup.set_text (self.auth.sambaWorkgroup)
sambatable = gtk.Table (10, 3, gtk.FALSE)
sambatable.attach (self.samba, 0, 10, 0, 1, gtk.FILL, gtk.SHRINK, 0.0, 0.5)
spacer = gtk.Label("")
spacer.set_size_request(10, 1)
sambatable.attach (spacer, 0, 1, 1, 2, gtk.SHRINK, gtk.SHRINK, 0.0, 0.5)
sambatable.attach (self.sambaLabel1, 2, 3, 1, 2, gtk.FILL, gtk.SHRINK, 0.0, 0.5)
sambatable.attach (self.sambaServer, 3, 10, 1, 2, gtk.SHRINK, gtk.SHRINK, 0.0, 0.5)
sambatable.attach (self.sambaLabel2, 2, 3, 2, 3, gtk.FILL, gtk.SHRINK, 0.0, 0.5)
sambatable.attach (self.sambaWorkgroup, 3, 10, 2, 3, gtk.SHRINK, gtk.SHRINK, 0.0, 0.5)
self.samba.connect ("toggled", self.setSensitivities)
# pack everything
self.setSensitivities()
nisLabel = gtk.Label (_("NIS"))
ldapLabel = gtk.Label (_("LDAP"))
krb5Label = gtk.Label (_("Kerberos 5"))
sambaLabel = gtk.Label (_("SMB"))
nb.append_page(nistable, nisLabel)
nb.append_page(ldaptable, ldapLabel)
nb.append_page(krb5table, krb5Label)
nb.append_page(sambatable, sambaLabel)
box.pack_start (self.md5, gtk.FALSE)
box.pack_start (self.shadow, gtk.FALSE)
box.pack_start (nb, gtk.TRUE)
box.set_border_width (5)
return box
def getScreen(self, langs):
self.langs = langs
self.languages = self.langs.getAllSupported()
self.supportedLangs = self.langs.getSupported()
self.origLangs = []
for i in self.supportedLangs:
self.origLangs.append(i)
self.defaultLang = self.langs.getDefault()
self.oldDefaultLang = self.defaultLang
# first time we hit this point in install this is not initialized
if self.origLangs == []:
self.origLangs.append(self.defaultLang)
vbox = gtk.VBox(gtk.FALSE, 10)
vbox.set_border_width(5)
hbox = gtk.HBox(gtk.FALSE)
# create option menu of default langs
label = gui.MnemonicLabel(
_("Select the _default language for the system: "))
self.deflang_optionmenu = None
self.deflang_menu = None
self.deflang_values = None
self.createDefaultLangMenu(self.supportedLangs)
label.set_mnemonic_widget(self.deflang_optionmenu)
hbox.pack_start(label, gtk.FALSE, 20)
hbox.pack_start(self.deflang_optionmenu, gtk.FALSE, 20)
vbox.pack_start(hbox, gtk.FALSE, 50)
sep = gtk.HSeparator()
vbox.pack_start(sep, gtk.FALSE, 15)
label = gui.MnemonicLabel(
_("Select _additional languages to install "
"on the system:"))
label.set_alignment(0.0, 0.5)
label.set_line_wrap(gtk.TRUE)
label.set_size_request(400, -1)
vbox.pack_start(label, gtk.FALSE)
hbox = gtk.HBox(gtk.FALSE, 5)
# langs we want to support
self.languageList = checklist.CheckList(1)
label.set_mnemonic_widget(self.languageList)
self.maxrows = 0
list = []
for locale in self.languages:
if locale == self.defaultLang or (locale in self.supportedLangs):
self.languageList.append_row((locale, ""), gtk.TRUE)
list.append(locale)
else:
self.languageList.append_row((locale, ""), gtk.FALSE)
self.maxrows = self.maxrows + 1
self.setCurrent(self.defaultLang)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.add(self.languageList)
sw.set_shadow_type(gtk.SHADOW_IN)
vbox2 = gtk.VBox(gtk.FALSE, 12)
all_button = gtk.Button(_("_Select All"))
all_button.set_size_request(160, -1)
all_button.connect('clicked', self.select_all)
a1 = gtk.Alignment(0.5, 0.5)
a1.add(all_button)
# this one tends to be too long
default_button = gtk.Button()
label = gui.MnemonicLabel(_("Select Default _Only"))
label.set_size_request(150, -1)
label.set_line_wrap(gtk.TRUE)
label.set_justify(gtk.JUSTIFY_CENTER)
label.set_mnemonic_widget(default_button)
default_button.add(label)
default_button.set_size_request(160, -1)
default_button.connect('clicked', self.select_default)
a2 = gtk.Alignment(0.5, 0.5)
a2.add(default_button)
reset_button = gtk.Button(_("Rese_t"))
reset_button.set_size_request(160, -1)
reset_button.connect('clicked', self.reset)
a3 = gtk.Alignment(0.5, 0.5)
a3.add(reset_button)
vbox2.pack_start(a1, gtk.FALSE, 10)
vbox2.pack_start(a2, gtk.FALSE)
vbox2.pack_start(a3, gtk.FALSE)
hbox.pack_start(sw, gtk.TRUE, 10)
hbox.pack_start(vbox2, gtk.FALSE, 10)
vbox.pack_start(hbox, gtk.TRUE)
# default button
# alignment = gtk.Alignment (0.0, 0.0)
# button = gtk.Button (_("Select as default"))
# alignment.add (button)
# connect CB for when they change selected langs
self.languageList.checkboxrenderer.connect("toggled",
self.toggled_language)
store = self.languageList.get_model()
setupTreeViewFixupIdleHandler(self.languageList, store)
return vbox
def getScreen(self, intf, rootPw):
self.rootPw = rootPw
self.intf = intf
self.passwords = {}
box = gtk.VBox()
box.set_border_width(5)
hbox = gtk.HBox()
pix = self.ics.readPixmap("root-password.png")
if pix:
hbox.pack_start(pix, gtk.FALSE)
label = gtk.Label(
_("Enter the root (administrator) password "
"for the system."))
label.set_line_wrap(gtk.TRUE)
label.set_size_request(350, -1)
label.set_alignment(0.0, 0.5)
hbox.pack_start(label, gtk.FALSE)
box.pack_start(hbox, gtk.FALSE)
self.forward = lambda widget, box=box: box.emit(
'focus', gtk.DIR_TAB_FORWARD)
table = gtk.Table(2, 2)
table.set_size_request(365, -1)
table.set_row_spacings(5)
table.set_col_spacings(5)
pass1 = gui.MnemonicLabel(_("Root _Password: "******"_Confirm: "))
pass2.set_alignment(0.0, 0.5)
table.attach(pass2, 0, 1, 1, 2, gtk.FILL, 0, 10)
self.pw = gtk.Entry(128)
pass1.set_mnemonic_widget(self.pw)
self.pw.connect("activate", self.forward)
self.pw.connect("map-event", self.setFocus)
self.pw.set_visibility(gtk.FALSE)
self.confirm = gtk.Entry(128)
pass2.set_mnemonic_widget(self.confirm)
self.confirm.connect("activate", self.forward)
self.confirm.set_visibility(gtk.FALSE)
table.attach(self.pw, 1, 2, 0, 1, gtk.FILL | gtk.EXPAND, 5)
table.attach(self.confirm, 1, 2, 1, 2, gtk.FILL | gtk.EXPAND, 5)
hbox = gtk.HBox()
hbox.pack_start(table, gtk.FALSE)
box.pack_start(hbox, gtk.FALSE)
# root password statusbar
self.rootStatus = gtk.Label("")
wrapper = gtk.HBox(0, gtk.FALSE)
wrapper.pack_start(self.rootStatus)
box.pack_start(wrapper, gtk.FALSE)
pw = self.rootPw.getPure()
if pw:
self.pw.set_text(pw)
self.confirm.set_text(pw)
return box
def getScreen (self, intf, network, firewall, security):
self.firewall = firewall
self.security = security
self.network = network
self.intf = intf
self.devices = self.network.available().keys()
self.devices.sort()
self.netCBs = {}
box = gtk.VBox (gtk.FALSE, 5)
box.set_border_width (5)
label = gui.WrappingLabel (_("A firewall can help prevent unauthorized access to your computer from the outside world. Would you like to enable a firewall?"))
label.set_alignment (0.0, 0)
label.set_size_request(450, -1)
box.pack_start(label, gtk.FALSE)
vbox = gtk.VBox (gtk.FALSE)
self.disabled_radio = gtk.RadioButton (None, (_("N_o firewall")))
self.enabled_radio = gtk.RadioButton (self.disabled_radio,
(_("_Enable firewall")))
self.custom_radio = gtk.RadioButton (self.disabled_radio,
(_("_Custom firewall")))
self.disabled_radio.connect("clicked", self.activate_firewall)
self.custom_radio.connect("clicked", self.activate_firewall)
self.enabled_radio.connect("clicked", self.activate_firewall)
vbox.pack_start (self.disabled_radio)
vbox.pack_start (self.enabled_radio)
a = gtk.Alignment ()
a.add (vbox)
a.set (0.3, 0, 0.7, 1.0)
box.pack_start (a, gtk.FALSE, 5)
self.table = gtk.Table (2, 8)
box.pack_start (self.table, gtk.FALSE, 5)
y = 0
label = gtk.Label (_("What services should be allowed to pass through "
"the firewall?"))
label.set_size_request(450, -1)
label.set_alignment(0.0, 0.0)
self.table.attach(label, 0, 2, y, y + 1, gtk.EXPAND | gtk.FILL, gtk.FILL, 5, 5)
y = y + 1
hbox = gtk.HBox(gtk.FALSE, 10)
self.label2 = gui.MnemonicLabel (_("_Allow incoming:"))
self.label2.set_alignment (0.2, 0.0)
self.incoming = checklist.CheckList(1)
self.incoming.set_size_request(-1, 125)
self.label2.set_mnemonic_widget(self.incoming)
incomingSW = gtk.ScrolledWindow()
incomingSW.set_border_width(5)
incomingSW.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
incomingSW.set_shadow_type(gtk.SHADOW_IN)
incomingSW.add(self.incoming)
# self.table.attach (self.label2, 0, 1, y, y + 1, gtk.FILL, gtk.FILL, 5, 5)
self.table.attach (incomingSW, 0, 2, y, y + 1, gtk.EXPAND|gtk.FILL, gtk.FILL, 5, 5)
self.knownPorts = {"SSH": self.firewall.ssh,
"Telnet": self.firewall.telnet,
"WWW (HTTP)": self.firewall.http,
"Mail (SMTP)": self.firewall.smtp,
"FTP": self.firewall.ftp}
for item in self.knownPorts.keys():
self.incoming.append_row ((item, ""), self.knownPorts[item])
y = y + 1
self.label3 = gui.MnemonicLabel (_("Other _ports:"))
self.ports = gtk.Entry ()
self.label3.set_mnemonic_widget(self.ports)
self.table.attach (self.label3, 0, 1, y, y + 1, gtk.FILL, gtk.FILL, 5, 5)
self.table.attach (self.ports, 1, 2, y, y + 1, gtk.EXPAND|gtk.FILL, gtk.FILL, 10, 5)
y = y + 1
label = gui.WrappingLabel (_("If you would like to allow all traffic "
"from a device, select it below."))
label.set_size_request(450, -1)
label.set_alignment(0, 1)
self.table.attach(label, 0, 2, y, y + 1,
gtk.FILL, gtk.FILL, 5, 5)
y = y + 1
hbox = gtk.HBox(gtk.FALSE, 10)
self.label1 = gui.MnemonicLabel (_("_Trusted devices:"))
self.label1.set_alignment (0.2, 0.0)
self.trusted = checklist.CheckList(1)
self.trusted.set_size_request(-1, 40)
self.label1.set_mnemonic_widget(self.trusted)
trustedSW = gtk.ScrolledWindow()
trustedSW.set_border_width(5)
trustedSW.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
trustedSW.set_shadow_type(gtk.SHADOW_IN)
trustedSW.add(self.trusted)
if self.devices != []:
# self.table.attach (self.label1, 0, 1, y, y + 1, gtk.FILL, gtk.FILL, 5, 5)
self.table.attach (trustedSW, 0, 2, y, y + 1, gtk.EXPAND|gtk.FILL, gtk.FILL, 5, 0)
for device in self.devices:
if device in self.firewall.trustdevs:
self.trusted.append_row ((device, device), gtk.TRUE)
else:
self.trusted.append_row ((device, device), gtk.FALSE)
y = y + 1
if self.firewall.enabled == 0:
self.disabled_radio.set_active (gtk.TRUE)
else:
self.enabled_radio.set_active(gtk.TRUE)
if self.firewall.portlist != "":
self.ports.set_text (self.firewall.portlist)
self.activate_firewall(None)
box.pack_start (gtk.HSeparator(), gtk.FALSE)
label = gtk.Label(_("_Security Enhanced Linux (SELinux) Extensions:"))
label.set_use_underline(gtk.TRUE)
self.se_option_menu = gtk.OptionMenu()
label.set_mnemonic_widget(self.se_option_menu)
se_menu = gtk.Menu()
for i in (_("Disabled"), _("Warn"), _("Active")):
se_menu.add(gtk.MenuItem(i))
self.se_option_menu.set_menu(se_menu)
self.se_option_menu.set_history(self.security.getSELinux())
hbox = gtk.HBox()
hbox.set_spacing(8)
hbox.pack_start(label, gtk.FALSE)
hbox.pack_start(self.se_option_menu, gtk.TRUE)
if flags.selinux == 0:
hbox.set_sensitive(gtk.FALSE)
if (SELINUX_DEFAULT == 1) or flags.selinux:
box.pack_start(hbox, gtk.FALSE)
return box
def getScreen(self, intf, fsset, instPath, swapInfo, dispatch):
#
# use to test function
#
# fslist = [('/', 'hda1', 1000)]
# fslist.append(('/var', 'hda2', 100))
# fslist.append(('/opt', 'hda3', 500))
# swapInfo = (fslist, 1000, '/var')
self.neededSwap = 0
self.fsset = fsset
self.instPath = instPath
self.intf = intf
self.dispatch = dispatch
rc = swapInfo
self.neededSwap = 1
self.row = 0
box = gtk.VBox(gtk.FALSE, 5)
box.set_border_width(5)
label = gtk.Label(
_("The 2.4 kernel needs significantly more "
"swap than older kernels, as much as twice "
"as much swap space as RAM on the system. "
"You currently have %dMB of swap configured, but "
"you may create additional swap space on one of "
"your file systems now.") % (iutil.swapAmount() / 1024) +
_("\n\nThe installer has detected %s MB of RAM.\n") %
(iutil.memInstalled() / 1024))
label.set_alignment(0.5, 0.0)
# label.set_size_request(400, 200)
label.set_line_wrap(gtk.TRUE)
box.pack_start(label, gtk.FALSE)
hs = gtk.HSeparator()
box.pack_start(hs, gtk.FALSE)
self.option1 = gtk.RadioButton(None,
(_("I _want to create a swap file")))
box.pack_start(self.option1, gtk.FALSE)
(fsList, suggSize, suggMntPoint) = rc
self.swapbox = gtk.VBox(gtk.FALSE, 5)
box.pack_start(self.swapbox, gtk.FALSE)
label = gui.MnemonicLabel(
_("Select the _partition to put the swap file on:"))
a = gtk.Alignment(0.2, 0.5)
a.add(label)
self.swapbox.pack_start(a, gtk.FALSE)
self.store = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING)
for (mnt, part, size) in fsList:
iter = self.store.append()
self.store.set_value(iter, 0, mnt)
self.store.set_value(iter, 1, part)
self.store.set_value(iter, 2, str(size))
self.view = gtk.TreeView(self.store)
label.set_mnemonic_widget(self.view)
i = 0
for title in [(_("Mount Point")), (_("Partition")),
(_("Free Space (MB)"))]:
col = gtk.TreeViewColumn(title, gtk.CellRendererText(), text=i)
self.view.append_column(col)
i = i + 1
sw = gtk.ScrolledWindow()
sw.add(self.view)
sw.set_shadow_type(gtk.SHADOW_IN)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.set_size_request(300, 90)
a = gtk.Alignment(0.5, 0.5)
a.add(sw)
self.swapbox.pack_start(a, gtk.FALSE, gtk.TRUE, 10)
rootiter = self.store.get_iter_first()
sel = self.view.get_selection()
sel.select_iter(rootiter)
label = gtk.Label(
_("It is recommended that your swap file be at "
"least %d MB. Please enter a size for the swap "
"file:") % suggSize)
label.set_size_request(400, 40)
label.set_line_wrap(gtk.TRUE)
a = gtk.Alignment(0.5, 0.5)
a.add(label)
self.swapbox.pack_start(a, gtk.FALSE, gtk.TRUE, 10)
hbox = gtk.HBox(gtk.FALSE, 5)
a = gtk.Alignment(0.4, 0.5)
a.add(hbox)
self.swapbox.pack_start(a, gtk.FALSE)
label = gui.MnemonicLabel(_("Swap file _size (MB):"))
hbox.pack_start(label, gtk.FALSE)
self.entry = gtk.Entry(4)
label.set_mnemonic_widget(self.entry)
self.entry.set_size_request(40, 25)
self.entry.set_text(str(suggSize))
hbox.pack_start(self.entry, gtk.FALSE, gtk.TRUE, 10)
self.option2 = gtk.RadioButton(self.option1,
(_("I _don't want to create a swap "
"file")))
box.pack_start(self.option2, gtk.FALSE, gtk.TRUE, 20)
self.option1.connect("toggled", self.toggle)
return box
