# # xconfig_gui: gui X configuration # # Brent Fox # # Copyright 2001 Red Hat, Inc. # # This software may be freely redistributed under the terms of the GNU # library public license. # # You should have received a copy of the GNU Library Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. # import copy import string import sys import iutil import glob import gui import gobject import gtk from iw_gui import * from translate import _, N_ from monitor import isValidSyncRange from videocard import Videocard_blacklist from log import log ddc_monitor_string = _("DDC Probed Monitor") unprobed_monitor_string = _("Unprobed Monitor") class XCustomWindow (InstallWindow): htmlTag = "xcustom" windowTitle = N_("Customize Graphics Configuration") def __init__ (self, ics): InstallWindow.__init__ (self, ics) self.ics.setNextEnabled (gtk.TRUE) def getNext (self): newmodes = {} newmodes[self.selectedDepth] = [] newmodes[self.selectedDepth].append (self.selectedRes) self.xconfig.setManualModes(newmodes) self.desktop.setDefaultDesktop (self.newDesktop) if self.text.get_active (): rl = 3 elif self.graphical.get_active (): rl = 5 self.desktop.setDefaultRunLevel(rl) def testPressed (self, widget, *args): newmodes = {} newmodes[self.selectedDepth] = [] newmodes[self.selectedDepth].append (self.selectedRes) manmodes = self.xconfig.getManualModes() self.xconfig.setManualModes(newmodes) try: self.xconfig.test (root="/mnt/sysimage/") except RuntimeError: ### test failed window pass self.xconfig.setManualModes(manmodes) def numCompare (self, first, second): first = string.atoi (first) second = string.atoi (second) if first > second: return 1 elif first < second: return -1 return 0 def depth_cb (self, widget, data): depth = self.depth_combo.list.child_position (data) if self.selectedDepth == self.bit_depth[depth]: return self.selectedDepth = self.bit_depth[depth] curres = self.selectedRes newmodes = self.xconfig.availableModes()[self.selectedDepth] self.res_combo.set_popdown_strings(newmodes) if curres in newmodes: self.res_combo.list.select_item(newmodes.index(curres)) def res_cb (self, widget, data): newres = self.res_combo.list.child_position (data) if self.currentRes == newres: return self.currentRes = self.res_combo.list.child_position (data) self.selectedRes = self.res_list[self.currentRes] self.swap_monitor (self.currentRes) def load_monitor_preview_pixmap(self, file): if self.monitor_align: self.hbox.remove (self.monitor_align) pix = self.ics.readPixmap (file) if pix: self.monitor_align = gtk.Alignment () self.monitor_align.add (pix) self.monitor_align.set (0.5, 0.5, 1.0, 1.0) self.hbox.pack_start (self.monitor_align, gtk.TRUE, gtk.TRUE) self.hbox.show_all() def swap_monitor (self, num): def find_monitor_pixmaps(): files = [] pixmaps1 = glob.glob("/usr/share/anaconda/pixmaps/monitor_*") pixmaps2 = glob.glob("pixmaps/monitor_*") if len(pixmaps1) < len(pixmaps2): files = pixmaps2 else: files = pixmaps1 pixmaps = [] for pixmap in files: pixmaps.append(pixmap[string.find(pixmap, "monitor_"):]) pixmaps.sort() return pixmaps if self.monitor_pixmaps == None: self.monitor_pixmaps = find_monitor_pixmaps() self.load_monitor_preview_pixmap(self.monitor_pixmaps[num]) def display_desktop_pixmap(self, desktop): self.vbox4.destroy () self.vbox4 = gtk.VBox () if desktop == "GNOME": pix = self.ics.readPixmap("gnome.png") elif desktop == "KDE": pix = self.ics.readPixmap("kde.png") else: pix = None if pix: a = gtk.Alignment () a.add (pix) a.set (0.5, 0.5, 1.0, 1.0) self.vbox4.pack_start (a, gtk.TRUE, gtk.TRUE) self.hbox4.pack_start (self.vbox4) self.hbox4.show_all () def desktop_cb (self, widget, desktop): self.newDesktop = desktop self.display_desktop_pixmap(desktop) # XCustomWindow tag="xcustom" def getScreen (self, xconfig, monitor, videocard, desktop, comps): self.xconfig = xconfig self.monitor = monitor self.videocard = videocard self.desktop = desktop # create toplevel packing structure self.box = gtk.VBox (gtk.FALSE) self.box.set_border_width (5) # hbox and alignment used for monitor preview area # list of pixmaps for monitor preview self.monitor_pixmaps = None self.hbox = gtk.HBox (gtk.FALSE, 5) self.monitor_align = None self.desktop_align = None self.load_monitor_preview_pixmap("monitor.png") self.box.pack_start (self.hbox) # determine video modes available for this card/monitor combo available = self.xconfig.availableModes() availableDepths = [] for adepth in available.keys(): if len(available[adepth]) > 0: availableDepths.append(adepth) availableDepths.sort(self.numCompare) hbox1 = gtk.HBox (gtk.FALSE, 5) hbox3 = gtk.HBox (gtk.FALSE, 5) hbox4 = gtk.HBox (gtk.FALSE, 5) frame1 = gtk.Frame (_("Color Depth:")) frame1.set_shadow_type (gtk.SHADOW_NONE) frame1.set_border_width (10) hbox1.pack_start(frame1, gtk.TRUE, gtk.FALSE, 0) depth_list = [(_("256 Colors (8 Bit)")), (_("High Color (16 Bit)")), (_("True Color (24 Bit)"))] self.bit_depth = ["8", "16", "32"] self.avail_depths = depth_list[:len(availableDepths)] self.depth_combo = gtk.Combo () self.depth_combo.entry.set_property("editable", gtk.FALSE) self.depth_combo.set_popdown_strings (self.avail_depths) frame1.add (self.depth_combo) frame2 = gtk.Frame (_("Screen Resolution:")) frame2.set_shadow_type (gtk.SHADOW_NONE) frame2.set_border_width (10) hbox1.pack_start (frame2, gtk.TRUE, gtk.FALSE, 2) self.res_list = ["640x480", "800x600", "1024x768", "1152x864", "1280x1024", "1400x1050", "1600x1200"] self.res_combo = gtk.Combo () self.res_combo.entry.set_property("editable", gtk.FALSE) # determine current selection, or if none exists, pick reasonable # defaults. # # getManualModes() should return a dictionary with one key (depth), # which has a single corresponding resolution # manualmodes = self.xconfig.getManualModes() if manualmodes: self.selectedDepth = manualmodes.keys()[0] self.selectedRes = manualmodes[self.selectedDepth][0] else: self.selectedDepth = None self.selectedRes = None # if selected depth not acceptable then force it to be at least 8bpp if self.selectedDepth and int(self.selectedDepth) < 8: self.selectedDepth = "8" if not self.selectedDepth or not self.selectedRes: if len(available) == 1: self.res_combo.set_popdown_strings (available["8"]) self.selectedDepth = "8" self.selectedRes = available[self.selectedDepth][0] elif len(available) >= 2: #--If they can do 16 bit color, default to 16 bit at 1024x768 self.depth_combo.list.select_item (1) self.selectedDepth = "16" self.res_combo.set_popdown_strings (available["16"]) if "1024x768" in available["16"]: self.selectedRes = "1024x768" elif "800x600" in available["16"]: self.selectedRes = "800x600" else: self.selectedRes = "640x480" else: self.res_combo.set_popdown_strings (available[self.selectedDepth]) frame2.add (self.res_combo) # apply current configuration to UI count = 0 for depth in self.bit_depth: if depth == self.selectedDepth: self.depth_combo.list.select_item (count) break count = count + 1 count = 0 self.currentRes = 0 for res in self.res_list: if res == self.selectedRes: self.res_combo.list.select_item (count) self.currentRes = count break count = count + 1 location = available[self.selectedDepth].index(self.selectedRes) self.swap_monitor(location) self.depth_combo.list.connect ("select-child", self.depth_cb) self.res_combo.list.connect ("select-child", self.res_cb) self.box.pack_start (hbox1, gtk.FALSE) # cannot reliably test on i810 or Voodoo driver, or on Suns who dont # need it since they are fixed resolution self.cantprobe = not self.videocard.primaryCard().canTestSafely() if not self.cantprobe: test = gtk.Alignment (.9, 0, 0, 0) button = gtk.Button (_(" Test Setting ")) button.connect ("clicked", self.testPressed) test.add (button) self.box.pack_start (test, gtk.FALSE) #--If both KDE and GNOME are selected if comps: gnomeSelected = (comps.packages.has_key('gnome-core') and comps.packages['gnome-core'].selected) kdeSelected = (comps.packages.has_key('kdebase') and comps.packages['kdebase'].selected) else: gnomeSelected = 0 kdeSelected = 0 self.newDesktop = "" self.origDesktop = self.desktop.getDefaultDesktop() if gnomeSelected or kdeSelected: hsep = gtk.HSeparator () self.box.pack_start (hsep) if gnomeSelected and kdeSelected: frame3 = gtk.Frame (_("Please choose your default desktop environment:")) else: frame3 = gtk.Frame (_("Your desktop environment is:")) frame3.set_shadow_type (gtk.SHADOW_NONE) hbox3.pack_start (frame3, gtk.TRUE, gtk.FALSE, 2) self.hbox4 = gtk.HBox () frame3.add (self.hbox4) # need to have this around so self.display_desktop_pixmap() # will work later. (messy) self.vbox4 = gtk.VBox() if gnomeSelected and kdeSelected: vbox3 = gtk.VBox() gnome_radio = gtk.RadioButton (None, (_("GNOME"))) vbox3.pack_start (gnome_radio, gtk.TRUE, gtk.FALSE, 2) kde_radio = gtk.RadioButton(gnome_radio, (_("KDE"))) vbox3.pack_start (kde_radio, gtk.TRUE, gtk.FALSE, 2) self.hbox4.pack_start (vbox3) self.hbox4.pack_start (self.vbox4) #--Set the desktop GUI widget to what the user has selected if self.origDesktop == "GNOME": gnome_radio.set_active (gtk.TRUE) self.display_desktop_pixmap("GNOME") elif self.origDesktop == "KDE": kde_radio.set_active (gtk.TRUE) self.display_desktop_pixmap("KDE") gnome_radio.connect ("clicked", self.desktop_cb, "GNOME") kde_radio.connect ("clicked", self.desktop_cb, "KDE") else: self.hbox4.pack_start(gtk.Label(self.origDesktop)) self.display_desktop_pixmap(self.origDesktop) self.box.pack_start (hbox3, gtk.FALSE, gtk.TRUE, 2) else: gnome_radio = None kde_radio = None hsep = gtk.HSeparator () self.box.pack_start (hsep) frame4 = gtk.Frame (_("Please choose your login type:")) frame4.set_shadow_type (gtk.SHADOW_NONE) hbox4.pack_start (frame4, gtk.TRUE, gtk.FALSE, 2) self.hbox5 = gtk.HBox (gtk.TRUE, 2) frame4.add (self.hbox5) self.text = gtk.RadioButton (None, (_("Text"))) self.graphical = gtk.RadioButton (self.text, (_("Graphical"))) self.runLevel = self.desktop.getDefaultRunLevel() if self.runLevel == 3: self.text.set_active (gtk.TRUE) elif self.runLevel == 5: self.graphical.set_active (gtk.TRUE) self.hbox5.pack_start (self.graphical, gtk.FALSE, 2) self.hbox5.pack_start (self.text, gtk.FALSE, 2) self.box.pack_start (hbox4, gtk.FALSE, gtk.TRUE, 2) return self.box class MonitorWindow (InstallWindow): windowTitle = N_("Monitor Configuration") htmlTag = ("monitor") def __init__ (self, ics): InstallWindow.__init__ (self, ics) self.ics.setNextEnabled (gtk.FALSE) self.ics.setPrevEnabled (gtk.TRUE) def getNext (self): if self.currentMonitor: monHoriz = string.replace(self.hEntry.get_text(), " ", "") monVert = string.replace(self.vEntry.get_text(), " ", "") if self.currentMonitor[:len(ddc_monitor_string)] == ddc_monitor_string: idname = "DDCPROBED" elif self.currentMonitor == unprobed_monitor_string: idname = "Unprobed Monitor" else: idname = self.currentMonitor self.monitor.setSpecs(monHoriz, monVert, id=idname, name=self.currentMonitor) return None def setSyncField(self, field, value): self.ignoreEntryChanges = 1 if value: field.set_text(value) else: field.set_text("") self.ignoreEntryChanges = 0 def enableIfSyncsValid(self, entry, other): aval = entry.get_text() bval = other.get_text() if isValidSyncRange(aval) and isValidSyncRange(bval): self.ics.setNextEnabled (gtk.TRUE) else: self.ics.setNextEnabled (gtk.FALSE) def setCurrent(self, monitorname, recenter=1): self.ignoreEvents = 1 self.currentMonitor = monitorname parent = None iter = self.monitorstore.get_iter_root() next = 1 # iterate over the list, looking for the current monitor selection while next: # if this is a parent node, get the first child and iter over them if self.monitorstore.iter_has_child(iter): parent = iter iter = self.monitorstore.iter_children(parent) continue # if it's not a parent node and the mouse matches, select it. elif self.monitorstore.get_value(iter, 0) == monitorname: path = self.monitorstore.get_path(parent) self.monitorview.expand_row(path, gtk.TRUE) selection = self.monitorview.get_selection() selection.unselect_all() selection.select_iter(iter) path = self.monitorstore.get_path(iter) col = self.monitorview.get_column(0) self.monitorview.set_cursor(path, col, gtk.FALSE) if recenter: self.monitorview.scroll_to_cell(path, col, gtk.TRUE, 0.0, 0.5) break # get the next row. next = self.monitorstore.iter_next(iter) # if there isn't a next row and we had a parent, go to the node # after the parent we've just gotten the children of. if not next and parent: next = self.monitorstore.iter_next(parent) iter = parent # set sync rates if monitorname == self.origMonitorName: hsync = self.origHsync vsync = self.origVsync elif monitorname[:len(ddc_monitor_string)] == ddc_monitor_string: hsync = self.ddcmon[2] vsync = self.ddcmon[3] elif monitorname == unprobed_monitor_string: hsync = "31.5" vsync = "50-61" # hsync = self.ddcmon[2] # vsync = self.ddcmon[3] else: monname = self.monitorstore.get_value(iter, 0) rc = self.monitor.lookupMonitorByName(monname) if rc: (model, eisa, vsync, hsync) = rc else: # no match for model ACK! print "Could not find match for monitor %s in list!" % monname print "How could this happen?" # use 640x480 to be safe hsync = "31.5" vsync = "50-61" self.setSyncField(self.hEntry, hsync) self.setSyncField(self.vEntry, vsync) self.enableIfSyncsValid(self.hEntry, self.vEntry) self.ignoreEvents = 0 def selectMonitorType (self, selection, *args): if self.ignoreEvents: return rc = selection.get_selected() if rc: monxxx, iter = rc monid = monxxx.get_value(iter, 0) self.setCurrent(monid, recenter=0) else: print "unknown error in selectMonitorType!" def monitorviewSelectCb(self, path): # XXX 01/09/2002 - work around broken gtkwidget, fix when jrb fixes if len(path) == 1: if self.lastvalidselection: self.ignoreEvents = 1 selection = self.monitorview.get_selection() if not selection.path_is_selected(self.lastvalidselection): selection.select_path(self.lastvalidselection) self.ignoreEvents = 0 return 0 self.lastvalidselection = path return 1 def resetCb (self, data): # if we have a ddc probe value, reset to that if self.ddcmon: self.setCurrent(ddc_monitor_string + " - " + self.ddcmon[1]) else: self.setCurrent(unprobed_monitor_string) self.setSyncField(self.hEntry, self.origHsync) self.setSyncField(self.vEntry, self.origVsync) self.enableIfSyncsValid(self.hEntry, self.vEntry) self.currentMonitor = self.origMonitorName def insertCb (self, pos, text, len, data, entrys): if self.ignoreEntryChanges: return (entry, other) = entrys list = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "-", " ", ".", ","] if not(text[:1] in list): entry.emit_stop_by_name ("insert-text") self.enableIfSyncsValid(entry, other) def changedCb (self, data, entrys): if self.ignoreEntryChanges: return (entry, other) = entrys self.enableIfSyncsValid(entry, other) def getScreen (self, xconfig, monitor): self.monitor = monitor self.xconfig = xconfig # 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) # 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 keys.remove("Generic") keys.insert(0, "Generic") 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 + " - " + self.ddcmon[1] else: title = unprobed_monitor_string 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, title) # set as current monitor if necessary if self.origMonitorID == "DDCPROBED" or self.origMonitorID == "Unprobed Monitor": self.currentMonitor = title self.origMonitorName = title # now insert rest of monitors, unless we match the ddc probed id for man in keys: if man == "Generic": title = _("Generic") else: title = man toplevels[man] = self.monitorstore.append(None) self.monitorstore.set_value(toplevels[man], 0, man) models = monitorslist[man] models.sort() 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 = gtk.Label (_("Horizontal Sync:")) hlabel.set_alignment (0, 0.5) vlabel = gtk.Label (_("Vertical Sync:")) vlabel.set_alignment (0, 0.5) 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) return box class XConfigWindow (InstallWindow): htmlTag ="xconf" windowTitle = N_("Graphical Interface (X) Configuration") def __init__ (self, ics): InstallWindow.__init__ (self, ics) self.ics = ics def getNext (self): if self.skip.get_active(): self.dispatch.skipStep("monitor") self.dispatch.skipStep("xcustom") self.dispatch.skipStep("writexconfig") self.xconfig.skipx = 1 return None else: self.dispatch.skipStep("monitor", skip = 0) self.dispatch.skipStep("xcustom", skip = 0) self.dispatch.skipStep("writexconfig", skip = 0) self.xconfig.skipx = 0 # set videocard type (assuming we're working with PRIMARY card) if self.currentCard: try: selected = self.cards[self.currentCard] except: self.intf.messageWindow(_("Unknown video card"), _("An error has occurred selecting " "the video card %s. Please report " "this error to bugzilla.redhat.com.") %self.currentCard) raise gui.StayOnScreen primary_card = self.videocard.primaryCard() primary_card.setCardData(selected) primary_card.setDevID (selected["NAME"]) primary_card.setDescription (selected["NAME"]) # pull out resolved version of card data card_data = primary_card.getCardData() if (card_data.has_key("DRIVER") and not card_data.has_key("UNSUPPORTED")): server = "XFree86" else: server = "XF86_" + card_data["SERVER"] primary_card.setXServer(server) else: selected = None if selected == None: self.intf.messageWindow(_("Unspecified video card"), _("You need to pick a video card before " "X configuration can continue. If you " "want to skip X configuration entirely " "choose the 'Skip X Configuration' button.")) raise gui.StayOnScreen # see if they actually picked a card, otherwise keep going # sniff out the selected ram size menu = self.ramOption.get_menu ().get_active() index = 0 for menu_item in self.ramOption.get_menu ().children (): if menu_item == menu: break index = index + 1 vidram = self.videocard.possible_ram_sizes()[index] self.videocard.primaryCard().setVideoRam(str(vidram)) self.xconfig.setVideoCard(self.videocard.primaryCard()) self.xconfig.filterModesByMemory () return None def skipToggled (self, widget, *args): self.configbox.set_sensitive (not widget.get_active ()) def selectCardType (self, selection, *args): if self.ignoreEvents: return rc = selection.get_selected() if rc: model, iter = rc self.currentCard = model.get_value(iter, 0) else: print "unknown error in selectCardType!" def restorePressed (self, button): self.currentCard = self.probedCard self.currentMem = self.probedMem self.setCurrent(self.probedCard, self.probedMem) def desktopCb (self, widget, desktop): self.newDesktop = desktop def cardviewSelectCb(self, path): # XXX 01/09/2002 - work around broken gtkwidget, fix when jrb fixes if len(path) == 1: if self.lastvalidselection: self.ignoreEvents = 1 selection = self.cardview.get_selection() if not selection.path_is_selected(self.lastvalidselection): selection.select_path(self.lastvalidselection) self.ignoreEvents = 0 return 0 self.lastvalidselection = path return 1 def setCurrent(self, cardname, recenter=1): self.ignoreEvents = 1 self.currentCard = cardname parent = None iter = self.cardstore.get_iter_root() next = 1 # iterate over the list, looking for the current mouse selection while next: # if this is a parent node, get the first child and iter over them if self.cardstore.iter_has_child(iter): parent = iter iter = self.cardstore.iter_children(parent) continue # if it's not a parent node and the mouse matches, select it. elif self.cardstore.get_value(iter, 0) == cardname: path = self.cardstore.get_path(parent) self.cardview.expand_row(path, gtk.TRUE) selection = self.cardview.get_selection() selection.unselect_all() selection.select_iter(iter) path = self.cardstore.get_path(iter) col = self.cardview.get_column(0) self.cardview.set_cursor(path, col, gtk.FALSE) if recenter: self.cardview.scroll_to_cell(path, col, gtk.TRUE, 0.0, 0.5) break # get the next row. next = self.cardstore.iter_next(iter) # if there isn't a next row and we had a parent, go to the node # after the parent we've just gotten the children of. if not next and parent: next = self.cardstore.iter_next(parent) iter = parent #--Some video cards don't return exact numbers, so do some hacks try: vidRam = string.atoi (self.currentMem) except: vidRam = 1024 count = self.videocard.index_closest_ram_size(vidRam) self.ramOption.remove_menu() self.ramMenu.set_active(count) self.ramOption.set_menu(self.ramMenu) self.ignoreEvents = 0 # XConfigWindow tag="xconf" def getScreen (self, dispatch, xconfig, videocard, intf): self.ics.setHelpEnabled (gtk.TRUE) def makeFormattedLabel(text): label = gtk.Label (text) label.set_justify (gtk.JUSTIFY_LEFT) label.set_line_wrap (gtk.TRUE) label.set_alignment (0.0, 0.5) label.set_size_request (400, -1) return label self.dispatch = dispatch self.videocard = videocard self.xconfig = xconfig self.intf = intf box = gtk.VBox (gtk.FALSE, 0) box.set_border_width (0) self.autoBox = gtk.VBox (gtk.FALSE, 5) arch = iutil.getArch() if arch == "alpha" or arch == "ia64": 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) elif arch == "i386": # but we can on everything else self.autoBox = gtk.VBox (gtk.FALSE, 5) label = makeFormattedLabel (_("In most cases your video hardware " "can be probed to automatically " "determine the best settings for " "your display.")) self.autoBox.pack_start (label, gtk.FALSE) label = makeFormattedLabel (_("If the probed settings do not " "match your hardware, select the " "correct hardware settings below:")) self.autoBox.pack_start (label, gtk.FALSE) box.pack_start (self.autoBox, gtk.FALSE) else: # sparc return # 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) # don't let them configure VGA16 if card in Videocard_blacklist: other_cards.remove(card) continue 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) box.pack_start (sw, gtk.TRUE) #Memory configuration menu hbox = gtk.HBox() hbox.set_border_width(3) label = gtk.Label (_("Video card RAM: ")) self.ramOption = gtk.OptionMenu() 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) 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) 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) return self.topbox