home *** CD-ROM | disk | FTP | other *** search
/ Australian Personal Computer 2000 July / CD 3 / redhat-6.2.iso / RedHat / instimage / usr / lib / anaconda / gui.py < prev    next >
Encoding:
Python Source  |  2000-03-08  |  23.5 KB  |  740 lines
  1. import gettext_rh
  2. import os
  3. from gtk import *
  4. from gtk import _root_window
  5. from _gtk import gtk_set_locale
  6. import GdkImlib
  7. from GDK import *
  8. from translate import cat, _
  9.  
  10. im = None
  11. splashwindow = None
  12. try:
  13.     im = GdkImlib.Image ("/usr/share/anaconda/pixmaps/first.png")
  14. except:
  15.     try:
  16.         im = GdkImlib.Image ("pixmaps/first.png")
  17.     except:
  18.         print "Unable to load", file
  19. if im:
  20.     root = _root_window ()
  21.     cursor = cursor_new (LEFT_PTR)
  22.     root.set_cursor (cursor)
  23.     threads_enter ()
  24.     im.render ()
  25.     splashwindow = GtkWindow ()
  26.     splashwindow.set_position (WIN_POS_CENTER)
  27.     box = GtkEventBox ()
  28.     pix = im.make_pixmap ()
  29.     style = box.get_style ().copy ()
  30.     style.bg[STATE_NORMAL] = style.white
  31.     box.set_style (style)
  32.     box.add (pix)
  33.     splashwindow.add (box)
  34.     splashwindow.show_all ()
  35.     while events_pending ():
  36.         mainiteration (FALSE)
  37.     threads_leave ()        
  38.  
  39. from gnome.ui import *
  40. from gnome.xmhtml import *
  41. from iw.language import *
  42. from iw.welcome import *
  43. from iw.mouse import *
  44. from iw.keyboard import *
  45. from iw.installpath import *
  46.  
  47. import isys
  48. import sys
  49.  
  50. import rpm
  51. from thread import *
  52. from threading import *
  53.  
  54. class WaitWindow:
  55.     def __init__(self, title, text):
  56.     threads_enter ()
  57.         self.window = GtkWindow (WINDOW_POPUP)
  58.         self.window.set_title (_(title))
  59.         self.window.set_position (WIN_POS_CENTER)
  60.         self.window.set_modal (TRUE)
  61.         label = GtkLabel (_(text))
  62.         label.set_line_wrap (TRUE)
  63.         box = GtkFrame ()
  64.         box.set_border_width (10)
  65.         box.add (label)
  66.         box.set_shadow_type (SHADOW_NONE)
  67.         frame = GtkFrame ()
  68.         frame.set_shadow_type (SHADOW_OUT)
  69.         frame.add (box)
  70.     self.window.add (frame)
  71.     self.window.show_all ()
  72.         thread = currentThread ()
  73.         if thread.getName () == "gtk_main":
  74.             while events_pending ():
  75.                 mainiteration (FALSE)
  76.         threads_leave ()
  77.             
  78.     def pop(self):
  79.     threads_enter ()
  80.         self.window.destroy ()
  81.     threads_leave ()
  82.  
  83. class ProgressWindow:
  84.     def __init__(self, title, text, total):
  85.     threads_enter ()
  86.         self.window = GtkWindow (WINDOW_POPUP)
  87.         self.window.set_title (_(title))
  88.         self.window.set_position (WIN_POS_CENTER)
  89.         self.window.set_modal (TRUE)
  90.         box = GtkVBox (5)
  91.         box.set_border_width (10)
  92.  
  93.         label = GtkLabel (_(text))
  94.         label.set_line_wrap (TRUE)
  95.         label.set_alignment (0.0, 0.5)
  96.         box.pack_start (label)
  97.         
  98.         self.total = total
  99.     self.progress = GtkProgressBar ()
  100.         box.pack_start (self.progress)
  101.         
  102.         frame = GtkFrame ()
  103.         frame.set_shadow_type (SHADOW_OUT)
  104.         frame.add (box)
  105.     self.window.add (frame)
  106.     self.window.show_all ()
  107.         threads_leave ()
  108.  
  109.     def set (self, amount):
  110.         threads_enter ()
  111.     self.progress.update (float (amount) / self.total)
  112.         threads_leave ()
  113.     
  114.     def pop(self):
  115.     threads_enter ()
  116.         self.window.destroy ()
  117.     threads_leave ()
  118.  
  119. class GtkMainThread (Thread):
  120.     def run (self):
  121.         self.setName ("gtk_main")
  122.         threads_enter ()
  123.         mainloop ()
  124.         threads_leave ()
  125.  
  126. class MessageWindow:
  127.     def quit (self, dialog, button):
  128.         self.rc = button
  129.         if self.mutex:
  130.             self.mutex.set ()
  131.  
  132.     def okcancelquit (self, button):
  133.         self.rc = button
  134.         if self.mutex:
  135.             self.mutex.set ()
  136.  
  137.     def getrc (self):
  138.         return self.rc
  139.     
  140.     def __init__ (self, title, text, type = "ok"):
  141.         threads_enter ()
  142.         if type == "ok":
  143.             self.window = GnomeOkDialog (_(text))
  144.             self.window.connect ("clicked", self.quit)
  145.         if type == "okcancel":
  146.             self.window = GnomeOkCancelDialog (_(text), self.okcancelquit)
  147.         # this is the pixmap + the label
  148.         hbox = self.window.vbox.children ()[0]
  149.         label = hbox.children ()[1]
  150.         label.set_line_wrap (TRUE)
  151.         self.window.set_position (WIN_POS_CENTER)
  152.         
  153.         self.window.show_all ()
  154.  
  155.         threads_leave ()
  156.  
  157.         # there are two cases to cover here in order to be
  158.         # modal:
  159.         # 1) the MessageWindow is being created by the gtk_main
  160.         #    thread, in which case we must call the mainloop recursively.
  161.         # 2) the MessageWindow is created by some other thread, in
  162.         #    which case we must _not_ call the mainloop (currently,
  163.         #    you can not call the mainloop from a second thread).
  164.         #    Instead, create an Event mutex and wait for it to get set.
  165.         #    by the clicked signal handler
  166.         thread = currentThread ()
  167.         if thread.getName () == "gtk_main":
  168.             self.mutex = None
  169.             threads_enter ()
  170.             self.rc = self.window.run ()
  171.             threads_leave ()
  172.         else:
  173.             self.mutex = Event ()
  174.             self.mutex.wait ()
  175.     
  176. class InstallInterface:
  177.     def setPackageProgressWindow (self, ppw):
  178.         self.ppw = ppw
  179.  
  180.     def waitWindow (self, title, text):
  181.     return WaitWindow (title, text)
  182.  
  183.     def progressWindow (self, title, text, total):
  184.     return ProgressWindow (title, text, total)
  185.  
  186.     def packageProgressWindow (self, total, totalSize):
  187.         self.ppw.setSizes (total, totalSize)
  188.         return self.ppw
  189.  
  190.     def messageWindow(self, title, text):
  191.         return MessageWindow (title, text)
  192.  
  193.     def exceptionWindow(self, title, text):
  194.         print text
  195.         return 1
  196.  
  197.     def getBootdisk ():
  198.         return None
  199.  
  200.     def getCongratulation ():
  201.         return CongratulationWindow
  202.  
  203.     def run (self, todo, test = 0):
  204.         gtkThread = GtkMainThread ()
  205.         gtkThread.start ()
  206.  
  207.         # This is the same as the file
  208.         if todo.reconfigOnly:
  209.             if todo.serial:
  210.                 commonSteps = [ ( LanguageWindow, "language" ), 
  211.                                 ]
  212.             else:
  213.                 commonSteps = [ ( ReconfigWelcomeWindow, "reconfig"),
  214.                                 ( LanguageWindow, "language" ), 
  215.                                 ( KeyboardWindow, "keyboard" ),
  216.                                 ]
  217.  
  218.             commonSteps = commonSteps + [
  219.              ( NetworkWindow, "network" ),
  220.              ( TimezoneWindow, "timezone" ),
  221.              ( AccountWindow, "accounts" ),
  222.              ( AuthWindow, "authentication" ),
  223.              ( ReconfigCongratulationWindow, "complete" )
  224.            ]
  225.  
  226.         else:
  227.             if todo.serial:
  228.                 commonSteps = [ ( LanguageWindow, "language" ), 
  229.                                 ( WelcomeWindow, "welcome" ),
  230.                                 ( InstallPathWindow, "installtype" ),
  231.                                 ]
  232.             else:
  233.                 commonSteps = [ ( LanguageWindow, "language" ), 
  234.                                 ( KeyboardWindow, "keyboard" ),
  235.                                 ( MouseWindow, "mouse" ),
  236.                                 ( WelcomeWindow, "welcome" ),
  237.                                 ( InstallPathWindow, "installtype" ),
  238.                                 ]
  239.  
  240.         self.finishedTODO = Event ()
  241.         if todo.instClass.keyboard:
  242.             from xkb import XKB
  243.             kb = XKB()
  244.         info = todo.keyboard.getXKB()
  245.         if info:
  246.                 (rules, model, layout, variant, options) = info
  247.                 kb.setRule (model, layout, variant, "complete")
  248.         self.icw = InstallControlWindow (self, commonSteps, todo)
  249.         self.icw.start ()
  250.         self.finishedTODO.wait ()
  251.  
  252. class InstallControlWindow (Thread):
  253.     def setLanguage (self, lang):
  254.         newlangs = [lang]
  255.         
  256.         if len(lang) > 2:
  257.             newlangs.append(lang[:2])
  258.         self.locale = lang[:2]
  259.  
  260.         cat.setlangs (newlangs)
  261.  
  262.         for l in newlangs:
  263.             if os.access ("/etc/gtk/gtkrc." + l, os.R_OK):
  264.                 rc_parse("/etc/gtk/gtkrc." + l)
  265.  
  266.         gtk_set_locale ()
  267.         self.window.reset_rc_styles ()
  268.         # XXX recreate html widget to set new locale
  269.         # there has to be a better way to do this, but I
  270.         # can't find it.  I try html.set_font_charset, but
  271.         # it screws everything up.
  272.         self.box.remove(self.html)
  273.         self.html = GtkXmHTML()
  274.         self.box.add (self.html)
  275.         self.html.show ()
  276.         self.html.source (self.currentScreen.getICS ().getHTML ())
  277.  
  278.         # get the labels
  279.         for (button, text) in [ (self.nextButtonStock, _("Next")),
  280.                                 (self.prevButtonStock, _("Back")),
  281.                                 (self.showHelpButton, _("Show Help")),
  282.                                 (self.hideHelpButton, _("Hide Help")),
  283.                                 (self.finishButton, _("Finish")) ]:
  284.             label = button.children ()[0].children ()[0].children()[1]
  285.             label.set_text (text)
  286.         self.helpFrame.set_label (_("Online Help"))
  287.         self.installFrame.set_label (_("Language Selection"))
  288.  
  289.     def instantiateWindow (self, windowClass):
  290.         ics = InstallControlState (self, self.ii, self.todo)
  291.         self.buildingWindows = 1
  292.         window = windowClass (ics)
  293.         self.buildingWindows = 0
  294.         self.windowList.append (window)
  295.         return window
  296.  
  297.     def setStateList (self, list, pos):
  298.         self.stateList = []
  299.     self.stateTagByWindow = {}
  300.         for x in list:
  301.         if type(x) == type((1,)):
  302.         (x, tag) = x
  303.         else:
  304.         tag = None
  305.             instantiated = 0
  306.             for y in self.windowList:
  307.                 if isinstance (y, x):
  308.                     self.stateList.append (y)
  309.             self.stateTagByWindow[y] = tag
  310.                     instantiated = 1
  311.                     break
  312.             if not instantiated:
  313.         instance = self.instantiateWindow (x)
  314.                 self.stateList.append (instance)
  315.         self.stateTagByWindow[instance] = tag
  316.  
  317.         self.stateListIndex = pos
  318.         
  319.     def prevClicked (self, *args):
  320.         self.currentScreen.getPrev ()
  321. #          if prev:
  322. #              instantiated = 0
  323. #              for x in self.windowList:
  324. #                  if isinstance (x, prev):
  325. #                      self.currentScreen = x
  326. #                      instantiated = 1
  327. #                      break
  328. #              if not instantiated:
  329. #                  self.currentScreen = self.instantiateWindow (prev)
  330.             
  331. #          else:
  332. #              self.stateListIndex = self.stateListIndex - 1
  333. #              self.currentScreen = self.stateList[self.stateListIndex]
  334.  
  335.         self.prevList.pop ()
  336.         (self.currentScreen, self.stateListIndex) = self.prevList[-1]
  337.         self.setScreen (self.currentScreen, self.prevClicked)
  338.  
  339.     def nextClicked (self, *args):
  340.         next = self.currentScreen.getNext ()
  341.         if next:
  342.             instantiated = 0
  343.             for x in self.windowList:
  344.                 if isinstance (x, next):
  345.                     self.currentScreen = x
  346.                     instantiated = 1
  347.                     break
  348.             if not instantiated:
  349.                 self.currentScreen = self.instantiateWindow (next)
  350.         else:
  351.             self.stateListIndex = self.stateListIndex + 1
  352.             if self.stateListIndex < len (self.stateList):
  353.                 self.currentScreen = self.stateList[self.stateListIndex]
  354.             else:
  355.                 self.ii.finishedTODO.set ()
  356.                 sys.exit (0)
  357.         self.setScreen (self.currentScreen, self.nextClicked)
  358.  
  359.     def helpClicked (self, widget, simulated = 0):
  360.     if not simulated:
  361.             self.helpState = (widget == self.showHelpButton)
  362.             
  363.         self.hbox.remove (widget)
  364.         if widget == self.hideHelpButton:
  365.             self.bin.remove (self.table)
  366.             self.installFrame.reparent (self.bin)
  367.  
  368.             self.showHelpButton.show ()
  369.             self.showHelpButton.set_state (STATE_NORMAL)
  370.  
  371.             self.hbox.pack_start (self.showHelpButton, FALSE)
  372.             self.hbox.reorder_child (self.showHelpButton, 0)
  373.             self.displayHelp = FALSE
  374.         else:
  375.             self.bin.remove (self.installFrame)
  376.             self.table.attach (self.installFrame, 1, 3, 0, 1)
  377.             self.bin.add (self.table)
  378.             # fix to set the bgcolor to white (xmhtml sucks)
  379.             self.html.source ("<HTML><BODY BGCOLOR=white></BODY></HTML>")
  380.             self.html.source (self.currentScreen.getICS ().getHTML ())
  381.             self.hideHelpButton.show ()
  382.             self.showHelpButton.set_state (STATE_NORMAL)
  383.             self.hbox.pack_start (self.hideHelpButton, FALSE)
  384.             self.hbox.reorder_child (self.hideHelpButton, 0)
  385.             self.displayHelp = TRUE
  386.  
  387.     def setScreen (self, screen, direction):
  388.         # if getScreen returns None, or we're supposed to skip this screen
  389.     # entirely, we continue advancing in direction given
  390.     if (self.stateTagByWindow.has_key(screen) and
  391.             self.todo.instClass.skipStep(self.stateTagByWindow[screen])):
  392.             direction ()
  393.             return
  394.  
  395.     new_screen = screen.getScreen ()
  396.     if not new_screen:
  397.             direction ()
  398.             return
  399.  
  400.         # if we're the initial screen (because of kickstart), make sure we can't go back.
  401.         if not self.initialScreenShown:
  402.             self.initialScreenShown = 1
  403.             screen.getICS ().setPrevEnabled (FALSE)
  404.             self.prevList = []
  405.  
  406.         if not direction == self.prevClicked:
  407.             self.prevList.append ((screen, self.stateListIndex))
  408.  
  409.         if self.helpState != self.displayHelp:
  410.             if self.displayHelp:
  411.                 self.helpClicked (self.hideHelpButton, 1)
  412.             else:
  413.                 self.helpClicked (self.showHelpButton, 1)
  414.         
  415.         self.update (screen.getICS ())
  416.  
  417.         children = self.installFrame.children ()
  418.         if children:
  419.             child = children[0]
  420.             self.installFrame.remove (child)
  421.             child.destroy ()
  422.  
  423.         self.installFrame.add (new_screen)
  424.         self.installFrame.show_all ()
  425.  
  426.     def update (self, ics):
  427.         if self.buildingWindows or ics != self.currentScreen.getICS ():
  428.             return
  429.  
  430.         self.installFrame.set_label (_(ics.getTitle ()))
  431.  
  432.         buttons = { "prev" : ics.getPrevButton (),
  433.                     "next" : ics.getNextButton () }
  434.  
  435.     for (name, button) in buttons.items ():
  436.             if button["pixmap"] == STOCK_BUTTON_PREV and not button["label"]:
  437.                 buttons[name] = self.prevButtonStock
  438.             elif button["pixmap"] == STOCK_BUTTON_NEXT and not button["label"]:
  439.                 buttons[name] = self.nextButtonStock
  440.             else:
  441.                 buttons[name] = GnomePixmapButton (GnomeStock (button["pixmap"]), _(button["label"]))
  442.                 if   name == "prev": buttons[name].connect ("clicked", self.prevClicked)
  443.                 elif name == "next": buttons[name].connect ("clicked", self.nextClicked)
  444.                 buttons[name].show ()
  445.  
  446.         children = self.buttonBox.children ()
  447.         if not buttons["prev"] in children:
  448.             self.buttonBox.remove (children[0])
  449.             self.buttonBox.pack_start (buttons["prev"])
  450.         if not buttons["next"] in children:
  451.             self.buttonBox.remove (children[1])
  452.             self.buttonBox.pack_end (buttons["next"])
  453.  
  454.         buttons["prev"].set_sensitive (ics.getPrevEnabled ())
  455.         buttons["next"].set_sensitive (ics.getNextEnabled ())
  456.  
  457.         if ics.getHelpEnabled () == FALSE:
  458.             if self.displayHelp:
  459.                 self.helpClicked (self.hideHelpButton, 1)
  460.         elif ics.getHelpEnabled () == TRUE:
  461.             if not self.displayHelp:
  462.                 self.helpClicked (self.showHelpButton, 1)
  463.         
  464.         if self.displayHelp:
  465.             self.html.source (ics.getHTML ())
  466.  
  467.         if (ics.getGrabNext ()):
  468.             buttons["next"].grab_focus ()
  469.  
  470.     def __init__ (self, ii, steps, todo):
  471.         Thread.__init__ (self)
  472.         self.ii = ii
  473.         self.todo = todo
  474.         self.steps = steps
  475.         if os.environ.has_key ("LC_ALL"):
  476.             self.locale = os.environ["LC_ALL"][:2]
  477.         else:
  478.             self.locale = "C"
  479.  
  480.     def keyRelease (self, window, event):
  481.         if ((event.keyval == KP_Delete or event.keyval == Delete)
  482.             and (event.state & (CONTROL_MASK | MOD1_MASK))):
  483.             os.kill (os.getpid(), 9)
  484.  
  485.     def run (self):
  486.         threads_enter ()
  487.         self.window = GtkWindow ()
  488.  
  489.         self.window.set_default_size (640, 480)
  490.         self.window.set_usize (640, 480)
  491.         cursor = cursor_new (LEFT_PTR)
  492.         _root_window ().set_cursor (cursor)
  493.  
  494.         self.window.set_border_width (10)
  495.  
  496.     title = _("Red Hat Linux Installer")
  497.     if os.environ["DISPLAY"][:1] != ':':
  498.         # from gnome.zvt import *
  499.         # zvtwin = GtkWindow ()
  500.         shtitle = _("Red Hat Linux Install Shell")
  501.         try:
  502.         f = open ("/tmp/netinfo", "r")
  503.         except:
  504.         pass
  505.         else:
  506.         lines = f.readlines ()
  507.         f.close ()
  508.         for line in lines:
  509.             netinf = string.splitfields (line, '=')
  510.             if netinf[0] == "HOSTNAME":
  511.             title = _("Red Hat Linux Installer on %s") % string.strip (netinf[1])
  512.             shtitle = _("Red Hat Linux Install Shell on %s") % string.strip (netinf[1])
  513.             break
  514.  
  515.         # zvtwin.set_title (shtitle)
  516.         # zvt = ZvtTerm (80, 24)
  517.         # if zvt.forkpty() == 0:
  518.         #     os.execv ("/bin/sh", [ "/bin/sh" ])
  519.         # zvt.show ()
  520.         # zvtwin.add (zvt)
  521.         # zvtwin.show_all ()
  522.  
  523.     self.window.set_title (title)
  524.         self.window.set_position (WIN_POS_CENTER)
  525.         vbox = GtkVBox (FALSE, 10)
  526.  
  527.         self.buttonBox = GtkHButtonBox ()
  528.         self.buttonBox.set_layout (BUTTONBOX_END)
  529.         self.prevButtonStock = GnomePixmapButton (GnomeStock (STOCK_BUTTON_PREV), _("Back"))
  530.         self.nextButtonStock = GnomePixmapButton (GnomeStock (STOCK_BUTTON_NEXT), _("Next"))
  531.         
  532.         self.finishButton = GnomePixmapButton (GnomeStock (STOCK_BUTTON_APPLY), _("Finish"))
  533.     self.hideHelpButton = GnomePixmapButton (GnomeStock (STOCK_BUTTON_HELP), _("Hide Help"))
  534.         self.showHelpButton = GnomePixmapButton (GnomeStock (STOCK_BUTTON_HELP), _("Show Help"))
  535.         self.hideHelpButton.connect ("clicked", self.helpClicked)
  536.         self.showHelpButton.connect ("clicked", self.helpClicked)
  537.         self.prevButtonStock.connect ("clicked", self.prevClicked)
  538.         self.nextButtonStock.connect ("clicked", self.nextClicked)
  539.  
  540.         group = GtkAccelGroup()
  541.         self.nextButtonStock.add_accelerator ("clicked", group, F12, RELEASE_MASK, 0);
  542.         self.window.add_accel_group (group)
  543.         self.window.connect_after ("key-release-event", self.keyRelease)
  544.  
  545.         self.buttonBox.add (self.prevButtonStock)
  546.         self.buttonBox.add (self.nextButtonStock)
  547.  
  548.     self.hbox = GtkHBox ()
  549.     self.hbox.pack_start (self.hideHelpButton, FALSE)
  550.     self.hbox.pack_start (self.buttonBox)
  551.  
  552.         vbox.pack_end (self.hbox, FALSE)
  553.  
  554.         self.html = GtkXmHTML()
  555.         self.html.set_allow_body_colors(TRUE)
  556.         self.html.source ("<HTML><BODY>HTML Help Window</BODY></HTML>")
  557.         self.displayHelp = TRUE
  558.         self.helpState = TRUE
  559.  
  560.         self.helpFrame = GtkFrame (_("Online Help"))
  561.         self.box = GtkVBox (FALSE, 0)
  562.         
  563.         self.box.pack_start (GtkHSeparator (), FALSE)
  564.         self.box.pack_start (self.html, TRUE)
  565.         self.helpFrame.add (self.box)
  566.  
  567.         table = GtkTable (1, 3, TRUE)
  568.         table.attach (self.helpFrame, 0, 1, 0, 1)
  569.  
  570.         self.installFrame = GtkFrame ()
  571. #        self.installFrame.set_shadow_type (SHADOW_NONE)
  572.  
  573.         self.windowList = []
  574.  
  575.         self.setStateList (self.steps, 0)
  576.         self.currentScreen = self.stateList[self.stateListIndex]
  577.         self.initialScreenShown = 0
  578.         self.setScreen (self.currentScreen, self.nextClicked)
  579.                           
  580.         table.attach (self.installFrame, 1, 3, 0, 1)
  581.         table.set_col_spacing (0, 5)
  582.  
  583.         self.bin = GtkFrame ()
  584.         self.bin.set_shadow_type (SHADOW_NONE)
  585.         self.bin.add (table)
  586.         vbox.pack_end (self.bin, TRUE, TRUE)
  587.         self.table = table
  588.  
  589.         self.window.add (vbox)
  590.         threads_leave ()
  591.  
  592.         # let her rip...
  593.     self.mutex = allocate_lock ()
  594.         self.mutex.acquire ()
  595.  
  596.         # Popup the ICW and wait for it to wake us back up
  597.         threads_enter ()
  598.         self.window.show_all ()
  599.         global splashwindow
  600.         if splashwindow:
  601.             splashwindow.destroy ()
  602.         threads_leave ()
  603.  
  604.         self.mutex.acquire ()
  605.         
  606. class InstallControlState:
  607.     def __init__ (self, cw, ii, todo, title = "Install Window",
  608.                   prevEnabled = 1, nextEnabled = 0, html = ""):
  609.         self.searchPath = [ "/usr/share/anaconda/", "./" ]
  610.         self.ii = ii
  611.         self.cw = cw
  612.         self.todo = todo
  613.         self.prevEnabled = prevEnabled
  614.         self.nextEnabled = nextEnabled
  615.         self.title = title
  616.         self.html = html
  617.         self.htmlFile = None
  618.         self.nextButton = STOCK_BUTTON_NEXT
  619.         self.prevButton = STOCK_BUTTON_PREV
  620.         self.nextButtonLabel = None
  621.         self.prevButtonLabel = None
  622.         self.helpEnabled = 3 # Values other than TRUE or FALSE don't change the help setting
  623.         self.grabNext = 0
  624.  
  625.     def getState (self):
  626.         return (self.title, prevEnabled, nextEnabled, prevText, nextTest)
  627.  
  628.     def setTitle (self, title):
  629.         self.title = title
  630.         self.cw.update (self)
  631.         
  632.     def getTitle (self):
  633.         return self.title
  634.  
  635.     def setPrevEnabled (self, value):
  636.         if value == self.prevEnabled: return
  637.         self.prevEnabled = value
  638.         self.cw.update (self)
  639.  
  640.     def getPrevEnabled (self):
  641.         if (self.prevEnabled != 0):
  642.             return TRUE
  643.         return FALSE
  644.     
  645.     def setNextEnabled (self, value):
  646.         if value == self.nextEnabled: return
  647.         self.nextEnabled = value
  648.         self.cw.update (self)
  649.  
  650.     def getNextEnabled (self):
  651.         if (self.nextEnabled != 0):
  652.             return TRUE
  653.         return FALSE
  654.  
  655.     def readPixmap (self, file):
  656.         try:
  657.             im = GdkImlib.Image ("/usr/share/anaconda/pixmaps/" + file)
  658.         except:
  659.             try:
  660.                 im = GdkImlib.Image ("pixmaps/" + file)
  661.             except:
  662.                 print "Unable to load", file
  663.                 return None
  664.         return im
  665.  
  666.     def readHTML (self, file):
  667.         self.htmlFile = file
  668.  
  669.     def setHTML (self, text):
  670.         self.html = text
  671.         self.cw.update (self)
  672.  
  673.     def getHTML (self):
  674.         text = None
  675.         if self.htmlFile:
  676.             file = self.htmlFile
  677.             for path in self.searchPath:
  678.                 try:
  679.                     text = open("%s/help/%s/s1-help-screens-%s.html" %
  680.                                 (path, self.cw.locale, file)).read ()
  681.                 except IOError:
  682.                     try:
  683.                         text = open("%s/help/C/s1-help-screens-%s.html" %
  684.                                     (path, file)).read ()
  685.                     except IOError:
  686.                         continue
  687.  
  688.                 if text:
  689.                     break
  690.  
  691.             if text:
  692.                 return text
  693.             else:
  694.                 print "Unable to read %s help text" % (file,)
  695.  
  696.         return self.html
  697.     
  698.     def getToDo (self):
  699.         return self.todo
  700.  
  701.     def setNextButton (self, button, label=None):
  702.         self.nextButton = button
  703.         self.nextButtonLabel = label
  704.  
  705.     def getNextButton (self):
  706.         return { "pixmap" : self.nextButton, "label" : self.nextButtonLabel }
  707.  
  708.     def setPrevButton (self, button, label=None):
  709.         self.prevButton = button
  710.         self.prevButtonLabel = label
  711.  
  712.     def getPrevButton (self):
  713.         return { "pixmap" : self.prevButton, "label" : self.prevButtonLabel }
  714.  
  715.     def setScreenPrev (self):
  716.         self.cw.prevClicked ()
  717.  
  718.     def setScreenNext (self):
  719.         self.cw.nextClicked ()
  720.  
  721.     def getInstallInterface (self):
  722.         return self.ii
  723.  
  724.     def setHelpEnabled (self, value):
  725.         self.helpEnabled = value
  726.         self.cw.update (self)
  727.  
  728.     def getHelpEnabled (self):
  729.         return self.helpEnabled
  730.  
  731.     def setGrabNext (self, value):
  732.         self.grabNext = value
  733.         self.cw.update (self)
  734.  
  735.     def getGrabNext (self):
  736.         return self.grabNext
  737.  
  738.     def getICW (self):
  739.         return self.cw
  740.