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, 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(False, 5)
box.set_border_width(5)
# top header, includes graphic and instructions
hbox = gtk.HBox(False, 5)
pix = gui.readImageFromFile ("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, False)
label = gui.MnemonicLabel(_("Select the appropriate mouse for the system."))
label.set_line_wrap(True)
label.set_size_request(350, -1)
hbox.pack_start(label, False)
box.pack_start(hbox, 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, False)
# finally the emulate 3 buttons
box.pack_start(self.emulate3, False)
return box
def getScreen(self, anaconda):
self.running = 0
mainBox = gtk.VBox(False, 10)
hbox = gtk.HBox(False, 5)
pix = gui.readImageFromFile("config-language.png")
if pix:
a = gtk.Alignment()
a.add(pix)
hbox.pack_start(a, False)
label = gtk.Label(
_("What language would you like to use during the "
"installation process?"))
label.set_line_wrap(True)
label.set_size_request(350, -1)
hbox.pack_start(label, False)
self.instLang = anaconda.id.instLanguage
self.listStore = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING)
for locale in self.instLang.available():
iter = self.listStore.append()
nick = self.instLang.getLangByName(locale)
lang = '%s (<span lang="%s">%s</span>)' % (_(locale), "%s" % (
nick.split('.')[0], ), self.instLang.getNativeLangName(locale))
self.listStore.set_value(iter, 0, lang)
self.listStore.set_value(iter, 1, locale)
self.listStore.set_value(iter, 2, _(locale))
self.listStore.set_sort_column_id(2, gtk.SORT_ASCENDING)
self.listView = gtk.TreeView(self.listStore)
col = gtk.TreeViewColumn(None, gtk.CellRendererText(), markup=0)
self.listView.append_column(col)
self.listView.set_property("headers-visible", False)
current = self.instLang.getLangName(self.instLang.instLang)
iter = self.listStore.get_iter_first()
while iter:
if self.listStore.get_value(iter, 1) == current:
selection = self.listView.get_selection()
selection.unselect_all()
selection.select_iter(iter)
break
iter = self.listStore.iter_next(iter)
self.listView.connect("size-allocate", self.listScroll)
sw = gtk.ScrolledWindow()
sw.set_border_width(5)
sw.set_shadow_type(gtk.SHADOW_IN)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.add(self.listView)
setupTreeViewFixupIdleHandler(self.listView, self.listStore)
mainBox.pack_start(hbox, False, False, 10)
mainBox.pack_start(sw, True, True)
self.running = 1
return mainBox
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 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.running = 0
mainBox = gtk.VBox (False, 10)
hbox = gtk.HBox(False, 5)
pix = gui.readImageFromFile ("config-language.png")
if pix:
a = gtk.Alignment ()
a.add (pix)
hbox.pack_start (a, False)
label = gtk.Label (_("What language would you like to use during the "
"installation process?"))
label.set_line_wrap (True)
label.set_size_request(350, -1)
hbox.pack_start(label, False)
self.instLang = anaconda.instLanguage
self.listStore = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING)
for locale in self.instLang.available():
iter = self.listStore.append()
nick = self.instLang.getLangByName(locale)
lang = '%s (<span lang="%s">%s</span>)' % (
_(locale), "%s" % (nick.split('.')[0],),
self.instLang.getNativeLangName(locale))
self.listStore.set_value(iter, 0, lang)
self.listStore.set_value(iter, 1, locale)
self.listStore.set_value(iter, 2, _(locale))
self.listStore.set_sort_column_id(2, gtk.SORT_ASCENDING)
self.listView = gtk.TreeView(self.listStore)
col = gtk.TreeViewColumn(None, gtk.CellRendererText(), markup=0)
self.listView.append_column(col)
self.listView.set_property("headers-visible", False)
current = self.instLang.getLangName(self.instLang.instLang)
iter = self.listStore.get_iter_first()
while iter:
if self.listStore.get_value(iter, 1) == current:
selection = self.listView.get_selection()
selection.unselect_all()
selection.select_iter(iter)
break
iter = self.listStore.iter_next(iter)
self.listView.connect("size-allocate", self.listScroll)
sw = gtk.ScrolledWindow ()
sw.set_border_width (5)
sw.set_shadow_type(gtk.SHADOW_IN)
sw.set_policy (gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.add (self.listView)
setupTreeViewFixupIdleHandler(self.listView, self.listStore)
mainBox.pack_start (hbox, False, False, 10)
mainBox.pack_start (sw, True, True)
# Sabayon and RogentOS language packs options
# See Sabayon bug 2518
self.fullLangSupport = anaconda.instLanguage.fullLanguageSupport
self.asianLangSupport = anaconda.instLanguage.asianLanguageSupport
fullLangSupportCb = gtk.CheckButton(
_("Full language support (download extra language packs)"))
asianLangSupportCb = gtk.CheckButton(
_("Asian fonts support (IME, download extra fonts)"))
fullLangSupportCb.set_active(self.fullLangSupport)
fullLangSupportCb.connect("toggled", self._fullLangSupportCb,
anaconda)
asianLangSupportCb.set_active(self.asianLangSupport)
asianLangSupportCb.connect("toggled", self._asianLangSupportCb,
anaconda)
optsVbox = gtk.VBox(False, 1)
optsVbox.pack_start(fullLangSupportCb)
optsVbox.pack_start(asianLangSupportCb)
mainBox.pack_start(optsVbox, False, False)
self.running = 1
return mainBox
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, anaconda):
self.running = 0
mainBox = gtk.VBox (False, 10)
hbox = gtk.HBox(False, 5)
pix = gui.readImageFromFile ("gnome-globe.png")
if pix:
a = gtk.Alignment ()
a.add (pix)
hbox.pack_start (a, False)
label = gtk.Label (_("What language would you like to use during the "
"installation process?"))
label.set_line_wrap (True)
label.set_size_request(350, -1)
hbox.pack_start(label, False)
self.instLang = anaconda.id.instLanguage
self.listStore = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING)
for locale in self.instLang.available():
iter = self.listStore.append()
nick = self.instLang.getNickByName(locale)
lang = '%s (<span lang="%s">%s</span>)' % (
_(locale), "%s" % (nick.split('.')[0],),
self.instLang.getNativeLangName(locale))
self.listStore.set_value(iter, 0, lang)
self.listStore.set_value(iter, 1, locale)
self.listStore.set_value(iter, 2, _(locale))
self.listStore.set_sort_column_id(2, gtk.SORT_ASCENDING)
self.listView = gtk.TreeView(self.listStore)
col = gtk.TreeViewColumn(None, gtk.CellRendererText(), markup=0)
self.listView.append_column(col)
self.listView.set_property("headers-visible", False)
current = self.instLang.getLangNameByNick(self.instLang.getCurrent())
iter = self.listStore.get_iter_first()
while iter:
if self.listStore.get_value(iter, 1) == current:
selection = self.listView.get_selection()
selection.unselect_all()
selection.select_iter(iter)
break
iter = self.listStore.iter_next(iter)
self.listView.connect("size-allocate", self.listScroll)
sw = gtk.ScrolledWindow ()
sw.set_border_width (5)
sw.set_shadow_type(gtk.SHADOW_IN)
sw.set_policy (gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.add (self.listView)
setupTreeViewFixupIdleHandler(self.listView, self.listStore)
mainBox.pack_start (hbox, False, False, 10)
mainBox.pack_start (sw, True, True)
self.running = 1
return mainBox
