merge anaconda-gtk-2-0-branch to HEAD

1 files changed, 260 insertions, 241 deletions

diff --git a/gui.py b/gui.py
index 0f9001d0d..c9254391e 100755
--- a/gui.py
+++ b/gui.py
@@ -14,20 +14,13 @@
 #
 
 import os
-import GDK
-import gdkpixbuf
 import iutil
 import string
 import isys
 import sys
 import parted
+import gtk
 from translate import _, N_
-from gnome.ui import *
-from gnome.util import *
-from gnome.xmhtml import *
-from gtk import *
-from _gtk import gtk_set_locale, gtk_rc_init, gtk_rc_reparse_all
-from _gtk import _gtk_nuke_rc_files, _gtk_nuke_rc_mtimes
 from language import expandLangs
 from splashscreen import splashScreenPop
 from log import log
@@ -82,9 +75,9 @@ else:
 # setup globals
 
 def processEvents():
-    gdk_flush()
-    while events_pending ():
-        mainiteration (FALSE)
+    gtk.gdk.flush()
+    while gtk.events_pending():
+        gtk.main_iteration(gtk.FALSE)
 
 def partedExceptionWindow(exc):
     # if our only option is to cancel, let us handle the exception
@@ -94,10 +87,9 @@ def partedExceptionWindow(exc):
     print exc.type_string
     print exc.message
     print exc.options
-    win = GnomeDialog (exc.type_string)
-    win.set_position (WIN_POS_CENTER)
-    label = GtkLabel(exc.message)
-    label.set_line_wrap (TRUE)
+    win = gtk.Dialog (exc.type_string)
+    win.set_position (gtk.WIN_POS_CENTER)
+    label = WrappingLabel(exc.message)
     win.vbox.pack_start (label)
     numButtons = 0
     buttonToAction = {}
@@ -115,51 +107,74 @@ def partedExceptionWindow(exc):
             buttonToAction[numButtons] = flag
             numButtons = numButtons + 1
     win.show_all()
-    rc = win.run_and_close()
+    rc = win.run()
     return buttonToAction[rc]
 
+def widgetExpander(widget, growTo=None):
+    widget.connect("size-allocate", growToParent, growTo)
+
+def growToParent(widget, rect, growTo=None):
+    if not widget.parent:
+        return
+    ignore = widget.__dict__.get("ignoreEvents")
+    if not ignore:
+        if growTo:
+            x, y, width, height = growTo.get_allocation()
+            widget.set_usize(width, -1)
+        else:
+            widget.set_usize(rect.width, -1)
+        widget.ignoreEvents = 1
+    else:
+        widget.ignoreEvents = 0
+
+class WrappingLabel(gtk.Label):
+    def __init__(self, label=""):
+        gtk.Label.__init__(self, label)
+        self.set_line_wrap(gtk.TRUE)
+        self.ignoreEvents = 0
+        self.set_usize(-1, 1)
+        widgetExpander(self)
+
 class WaitWindow:
     def __init__(self, title, text):
-        self.window = GtkWindow (WINDOW_POPUP)
-        self.window.set_title (_(title))
-        self.window.set_position (WIN_POS_CENTER)
-        self.window.set_modal (TRUE)
-        label = GtkLabel (_(text))
-        label.set_line_wrap (TRUE)
-        box = GtkFrame ()
-        box.set_border_width (10)
-        box.add (label)
-        box.set_shadow_type (SHADOW_NONE)
-        frame = GtkFrame ()
-        frame.set_shadow_type (SHADOW_OUT)
+        self.window = gtk.Window(gtk.WINDOW_POPUP)
+        self.window.set_title(_(title))
+        self.window.set_position(gtk.WIN_POS_CENTER)
+        self.window.set_modal(gtk.TRUE)
+        label = WrappingLabel(_(text))
+        box = gtk.Frame()
+        box.set_border_width(10)
+        box.add(label)
+        box.set_shadow_type(gtk.SHADOW_NONE)
+        frame = gtk.Frame ()
+        frame.set_shadow_type(gtk.SHADOW_OUT)
         frame.add (box)
-	self.window.add (frame)
-	self.window.show_all ()
-        processEvents ()
+	self.window.add(frame)
+	self.window.show_all()
+        processEvents()
             
     def pop(self):
-        self.window.destroy ()
+        self.window.destroy()
 
 class ProgressWindow:
     def __init__(self, title, text, total):
-        self.window = GtkWindow (WINDOW_POPUP)
+        self.window = gtk.Window (gtk.WINDOW_POPUP)
         self.window.set_title (_(title))
-        self.window.set_position (WIN_POS_CENTER)
-        self.window.set_modal (TRUE)
-        box = GtkVBox (FALSE, 5)
+        self.window.set_position (gtk.WIN_POS_CENTER)
+        self.window.set_modal (gtk.TRUE)
+        box = gtk.VBox (gtk.FALSE, 5)
         box.set_border_width (10)
 
-        label = GtkLabel (_(text))
-        label.set_line_wrap (TRUE)
+        label = WrappingLabel (_(text))
         label.set_alignment (0.0, 0.5)
-        box.pack_start (label, FALSE)
+        box.pack_start (label, gtk.FALSE)
         
         self.total = total
-	self.progress = GtkProgressBar ()
-        box.pack_start (self.progress, TRUE)
+	self.progress = gtk.ProgressBar ()
+        box.pack_start (self.progress, gtk.TRUE)
         
-        frame = GtkFrame ()
-        frame.set_shadow_type (SHADOW_OUT)
+        frame = gtk.Frame ()
+        frame.set_shadow_type (gtk.SHADOW_OUT)
         frame.add (box)
 	self.window.add (frame)
 	self.window.show_all ()
@@ -174,43 +189,42 @@ class ProgressWindow:
 
 class ExceptionWindow:
     def __init__ (self, text):
-        win = GnomeDialog ("Exception Occured")
-        win.connect ("clicked", self.quit)
-        win.append_button ("Debug")
-        win.append_button ("Save to floppy")
-        win.append_button_with_pixmap ("OK", STOCK_BUTTON_OK)
-        textbox = GtkText()
-        textbox.insert_defaults (text)
-        sw = GtkScrolledWindow ()
+        win = gtk.Dialog ("Exception Occured")
+        win.add_button("Debug", 0)
+        win.add_button("Save to floppy", 1)
+        win.add_button('gtk-ok', 2)
+        buffer = gtk.TextBuffer(None)
+        buffer.set_text(text)
+        textbox = gtk.TextView()
+        textbox.set_buffer(buffer)
+        textbox.set_property("editable", gtk.FALSE)
+        textbox.set_property("cursor_visible", gtk.FALSE)
+        sw = gtk.ScrolledWindow ()
         sw.add (textbox)
-        sw.set_policy (POLICY_AUTOMATIC, POLICY_AUTOMATIC)
-
-        hbox = GtkHBox (FALSE)
-        file = pixmap_file('gnome-warning.png')
-        if file:
-            hbox.pack_start (GnomePixmap (file), FALSE)
-
-        info = GtkLabel(_("An unhandled exception has occured.  This "
-                          "is most likely a bug.  Please copy the "
-                          "full text of this exception or save the crash "
-                          "dump to a floppy then file a detailed bug "
-                          "report against anaconda at "
-                          "http://bugzilla.redhat.com/bugzilla/"))
-        info.set_line_wrap (TRUE)
+        sw.set_policy (gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+
+        hbox = gtk.HBox (gtk.FALSE)
+##         file = pixmap_file('gnome-warning.png')
+##         if file:
+##             hbox.pack_start (GnomePixmap (file), gtk.FALSE)
+
+        info = WrappingLabel(_("An unhandled exception has occured.  This "
+                               "is most likely a bug.  Please copy the "
+                               "full text of this exception or save the crash "
+                               "dump to a floppy then file a detailed bug "
+                               "report against anaconda at "
+                               "http://bugzilla.redhat.com/bugzilla/"))
         info.set_usize (400, -1)
 
-        hbox.pack_start (sw, TRUE)
-        win.vbox.pack_start (info, FALSE)            
-        win.vbox.pack_start (hbox, TRUE)
+        hbox.pack_start (sw, gtk.TRUE)
+        win.vbox.pack_start (info, gtk.FALSE)            
+        win.vbox.pack_start (hbox, gtk.TRUE)
         win.set_usize (500, 300)
-        win.set_position (WIN_POS_CENTER)
+        win.set_position (gtk.WIN_POS_CENTER)
         win.show_all ()
         self.window = win
         self.rc = self.window.run ()
         
-    def quit (self, dialog, button):
-        self.rc = button
-
     def getrc (self):
         # I did it this way for future expantion
         # 0 is debug
@@ -229,16 +243,6 @@ class ExceptionWindow:
             return 0
 
 class MessageWindow:
-    def quit (self, dialog, button=None):
-        if button != None:
-            self.rc = button
-
-    def okcancelquit (self, button):
-        self.rc = button
-
-    def questionquit (self, button):
-        self.rc = not button
-
     def getrc (self):
         return self.rc
     
@@ -248,38 +252,36 @@ class MessageWindow:
             self.rc = 1
             return
         self.rc = None
+#        window = gtk.Dialog(flags=gtk.DIALOG_MODAL)
+        window = gtk.Dialog("Foo", None, gtk.DIALOG_MODAL)
+        window = gtk.Dialog()
+        window.vbox.pack_start(WrappingLabel(_(text)), gtk.FALSE)
         if type == "ok":
-            self.window = GnomeOkDialog (_(text))
-            self.window.connect ("clicked", self.quit)
-            self.window.connect ("close", self.quit)
+            window.add_button('gtk-ok', 1)
         if type == "okcancel":
-            self.window = GnomeOkCancelDialog (_(text), self.okcancelquit)
+            window.add_button('gtk-ok', 1)
+            window.add_button('gtk-cancel', 0)
         if type == "yesno":
-            self.window = GnomeQuestionDialog (_(text), self.questionquit)
-
-        # this is the pixmap + the label
-        hbox = self.window.vbox.children ()[0]
-        label = hbox.children ()[1]
-        label.set_line_wrap (TRUE)
-        self.window.set_position (WIN_POS_CENTER)
-        win = self.window.get_window()
-        win.keyboard_grab(0)
-        self.window.show_all ()
-        self.rc = self.window.run ()
-
-        # invert result from yes/no dialog for some reason
-        if type == "yesno":
-            self.rc = not self.rc
-        
-        win.keyboard_ungrab()
+            window.add_button('gtk-yes', 1)
+            window.add_button('gtk-no', 0)
+        if default == "no":
+            window.set_default_response(0)
+        elif default == "yes" or default == "ok":
+            window.set_default_response(1)
+        else:
+            raise RuntimeError, "unhandled default"
+        window.set_position (gtk.WIN_POS_CENTER)
+        window.show_all ()
+        self.rc = window.run ()
+        window.destroy()
     
 class InstallInterface:
     def __init__ (self):
         # figure out if we want to run interface at 800x600 or 640x480
-        if screen_width() >= 800:
+        if gtk.gdk.screen_width() >= 800:
             self.runres = "800x600"
         else:
-            self.runres = "640x480"            
+            self.runres = "640x480"
 
     def __del__ (self):
         pass
@@ -351,29 +353,28 @@ class InstallInterface:
 
 class InstallControlWindow:
     def setLanguage (self, locale):
-        gtk_set_locale ()
-        _gtk_nuke_rc_files ()
-        gtk_rc_init ()
-        gtk_rc_reparse_all ()
+        #gtk_set_locale ()
+        #gtk_rc_init ()
+        #gtk_rc_reparse_all ()
 
 	self.langSearchPath = expandLangs(locale) + ['C']
         
-        found = 0
-        for l in self.langSearchPath:
-            if os.access ("/etc/gtk/gtkrc." + l, os.R_OK):
-                rc_parse("/etc/gtk/gtkrc." + l)
-                found = 1
-        if not found:
-            rc_parse("/etc/gtk/gtkrc")
-
-        _gtk_nuke_rc_mtimes ()
-        gtk_rc_reparse_all ()
+##         found = 0
+##         for l in self.langSearchPath:
+##             if os.access ("/etc/gtk/gtkrc." + l, os.R_OK):
+##                 rc_parse("/etc/gtk/gtkrc." + l)
+##                 found = 1
+##         if not found:
+##             rc_parse("/etc/gtk/gtkrc")
+
+##         #_gtk_nuke_rc_mtimes ()
+##         gtk_rc_reparse_all ()
         
 	if not self.__dict__.has_key('window'): return
 
         self.reloadRcQueued = 1
 
-        self.html.set_font_charset (locale)
+##         self.html.set_font_charset (locale)
 	self.updateStockButtons()
         self.helpFrame.set_label (_("Online Help"))
         self.installFrame.set_label (_("Language Selection"))
@@ -407,72 +408,82 @@ class InstallControlWindow:
             self.bin.remove (self.table)
             self.installFrame.reparent (self.bin)
             self.showHelpButton.show ()
-            self.showHelpButton.set_state (STATE_NORMAL)
-            self.hbox.pack_start (self.showHelpButton, FALSE)
+            self.showHelpButton.set_state (gtk.STATE_NORMAL)
+            self.hbox.pack_start (self.showHelpButton, gtk.FALSE)
             self.hbox.reorder_child (self.showHelpButton, 0)
-            self.displayHelp = FALSE
+            self.showHelpButton.grab_focus()            
+            self.displayHelp = gtk.FALSE
         else:
             self.bin.remove (self.installFrame)
-            self.table.attach (self.installFrame, 1, 3, 0, 1)
+            self.table.attach (self.installFrame, 1, 3, 0, 1,
+                               gtk.FILL | gtk.EXPAND,
+                               gtk.FILL | gtk.EXPAND)
             self.bin.add (self.table)
             # fix to set the bgcolor to white (xmhtml sucks)
-            self.html.source ("<HTML><BODY BGCOLOR=white></BODY></HTML>")
-            self.html.source (self.currentWindow.getICS().getHTML(self.langSearchPath))        
+##             self.html.source ("<HTML><BODY BGCOLOR=white></BODY></HTML>")
+##             self.html.source (self.currentWindow.getICS().getHTML(self.langSearchPath))        
             self.hideHelpButton.show ()
-            self.showHelpButton.set_state (STATE_NORMAL)
-            self.hbox.pack_start (self.hideHelpButton, FALSE)
+            self.showHelpButton.set_state (gtk.STATE_NORMAL)
+            self.hbox.pack_start (self.hideHelpButton, gtk.FALSE)
             self.hbox.reorder_child (self.hideHelpButton, 0)
-            self.displayHelp = TRUE
+            self.hideHelpButton.grab_focus()
+            self.displayHelp = gtk.TRUE
 
-    def close (self, args):
+    def close (self, *args):
         self.textWin.destroy()
-        self.releaseButton.set_sensitive(TRUE)
+        self.releaseButton.set_sensitive(gtk.TRUE)
 
     def releaseClicked (self, widget):
-        self.textWin = GnomeDialog ()
-        self.releaseButton.set_sensitive(FALSE)
+        self.textWin = gtk.Dialog ()
+        self.releaseButton.set_sensitive(gtk.FALSE)
 
-        table = GtkTable(3, 3, FALSE)
+        table = gtk.Table(3, 3, gtk.FALSE)
         self.textWin.vbox.pack_start(table)
-        self.textWin.append_button(_("Close"))
-        self.textWin.button_connect (0, self.close)
-
-        vbox1 = GtkVBox ()        
+        self.textWin.add_button('gtk-close', gtk.RESPONSE_NONE)
+        self.textWin.connect("response", self.close)
+        vbox1 = gtk.VBox ()        
         vbox1.set_border_width (10)
-        frame = GtkFrame (_("Release Notes"))
+        frame = gtk.Frame (_("Release Notes"))
         frame.add(vbox1)
         frame.set_label_align (0.5, 0.5)
-        frame.set_shadow_type (SHADOW_NONE)
+        frame.set_shadow_type (gtk.SHADOW_NONE)
         
-        self.textWin.set_position (WIN_POS_CENTER)
+        self.textWin.set_position (gtk.WIN_POS_CENTER)
 
         if self.buff != "":
-            text = GtkText()
-            text.insert (None, None, None, self.buff)
+            buffer = gtk.TextBuffer(None)
+            buffer.set_text(self.buff)
+            text = gtk.TextView()
+            text.set_buffer(buffer)
+            text.set_property("editable", gtk.FALSE)
+            text.set_property("cursor_visible", gtk.FALSE)
                 
-            sw = GtkScrolledWindow()
-            sw.set_policy(POLICY_NEVER, POLICY_ALWAYS)
+            sw = gtk.ScrolledWindow()
+            sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
+            sw.set_shadow_type(gtk.SHADOW_IN)
             sw.add(text)
             vbox1.pack_start(sw)
 
-            a = GtkAlignment ()
+            a = gtk.Alignment (0, 0, 1.0, 1.0)
             a.add (frame)
-            a.set (0, 0, 1.0, 1.0)
             
             self.textWin.set_default_size (635, 393)
             self.textWin.set_usize (635, 393)
-            self.textWin.set_position (WIN_POS_CENTER)
+            self.textWin.set_position (gtk.WIN_POS_CENTER)
 
-            table.attach (a, 1, 2, 1, 2, FILL|EXPAND, FILL|EXPAND, 5, 5)
+            table.attach (a, 1, 2, 1, 2,
+                          gtk.FILL | gtk.EXPAND,
+                          gtk.FILL | gtk.EXPAND, 5, 5)
 
             self.textWin.set_border_width(0)
             self.textWin.show_all()
 
         else:
-            self.textWin.set_position (WIN_POS_CENTER)
-            label = GtkLabel(_("Unable to load file!"))
+            self.textWin.set_position (gtk.WIN_POS_CENTER)
+            label = gtk.Label(_("Unable to load file!"))
 
-            table.attach (label, 1, 2, 1, 2, FILL|EXPAND, FILL|EXPAND, 5, 5)
+            table.attach (label, 1, 2, 1, 2,
+                          gtk.FILL | gtk.EXPAND, gtk.FILL | gtk.EXPAND, 5, 5)
 
             self.textWin.set_border_width(0)
             self.textWin.show_all()
@@ -498,12 +509,12 @@ class InstallControlWindow:
         if flags.autostep:
             self.nextClicked()
         else:
-            idle_remove(self.handle)
+            gtk.idle_remove(self.handle)
 
     def setScreen (self):
 	(step, args) = self.dispatch.currentStep()
 	if not step:
-	    mainquit()
+	    gtk.mainquit()
 	    return
 
 	if not stepToClass[step]:
@@ -514,7 +525,8 @@ class InstallControlWindow:
 		
 	(file, className) = stepToClass[step]
         newScreenClass = None
-	s = "from %s import %s; newScreenClass = %s" % (file, className, className)
+	s = "from %s import %s; newScreenClass = %s" % (file, className,
+                                                        className)
 	exec s
 
 	ics = InstallControlState (self)
@@ -533,15 +545,15 @@ class InstallControlWindow:
         self.installFrame.add (new_screen)
         self.installFrame.show_all ()
 
-	self.handle = idle_add(self.handleRenderCallback)
+	self.handle = gtk.idle_add(self.handleRenderCallback)
 
         if self.reloadRcQueued:
             self.window.reset_rc_styles ()
             self.reloadRcQueued = 0
 
-        if self.displayHelp:
-            self.html.source ("<HTML><BODY BGCOLOR=white></BODY></HTML>")
-            self.html.source (ics.getHTML(self.langSearchPath))
+##         if self.displayHelp:
+##             self.html.source ("<HTML><BODY BGCOLOR=white></BODY></HTML>")
+##             self.html.source (ics.getHTML(self.langSearchPath))
 
     def destroyCurrentWindow(self):
         children = self.installFrame.children ()
@@ -559,7 +571,8 @@ class InstallControlWindow:
 
 	if ics.getNextButton():
 	    (icon, text) = ics.getNextButton()
-	    nextButton = GnomePixmapButton (GnomeStock (icon), text)
+	    nextButton = Button(stock=icon)
+#            nextButton.set_property("label", _(text))
 	    nextButton.connect ("clicked", self.nextClicked)
 	    nextButton.show_all()
 
@@ -578,10 +591,10 @@ class InstallControlWindow:
         self.hideHelpButton.set_sensitive (ics.getHelpButtonEnabled ())
         self.showHelpButton.set_sensitive (ics.getHelpButtonEnabled ())
 
-        if ics.getHelpEnabled () == FALSE:
+        if ics.getHelpEnabled () == gtk.FALSE:
             if self.displayHelp:
                 self.helpClicked (self.hideHelpButton, 1)
-        elif ics.getHelpEnabled () == TRUE:
+        elif ics.getHelpEnabled () == gtk.TRUE:
             if not self.displayHelp:
                 self.helpClicked (self.showHelpButton, 1)
  
@@ -595,18 +608,16 @@ class InstallControlWindow:
         self.showHelpButton = None
         self.hideHelpButton = None
 
-	self.stockButtons = [ 
-	    (STOCK_BUTTON_PREV, "prevButtonStock",
-             N_("Back"), self.prevClicked),
-	    (STOCK_BUTTON_NEXT, "nextButtonStock",
-             N_("Next"), self.nextClicked),
-	    (STOCK_BUTTON_HELP, "releaseButton",
-             N_("Release Notes"), self.releaseClicked),
-	    (STOCK_BUTTON_HELP, "showHelpButton",
-             N_("Show Help"), self.helpClicked),
-	    (STOCK_BUTTON_HELP, "hideHelpButton",
-             N_("Hide Help"), self.helpClicked),
-	    ]
+	self.stockButtons = (('gtk-go-back', "prevButtonStock",
+                              N_("_Back"), self.prevClicked),
+                             ('gtk-go-forward', "nextButtonStock",
+                              N_("_Next"), self.nextClicked),
+                             ('gtk-new', "releaseButton",
+                              N_("_Release Notes"), self.releaseClicked),
+                             ('gtk-help', "showHelpButton",
+                              N_("Show _Help"), self.helpClicked),
+                             ('gtk-help', "hideHelpButton",
+                              N_("Hide _Help"), self.helpClicked))
 
         self.reloadRcQueued = 0
         self.ii = ii
@@ -615,28 +626,40 @@ class InstallControlWindow:
         self.handle = None
 
     def keyRelease (self, window, event):
-        if ((event.keyval == GDK.KP_Delete or event.keyval == GDK.Delete)
-            and (event.state & (GDK.CONTROL_MASK | GDK.MOD1_MASK))):
-            mainquit ()
-            os._exit (0)
+        if ((event.keyval == gtk.keysyms.KP_Delete
+             or event.keyval == gtk.keysyms.Delete)
+            and (event.state & (gtk.gdk.CONTROL_MASK | gtk.gdk.MOD1_MASK))):
+            gtk.mainquit()
+            os._exit(0)
 
     def buildStockButtons(self):
 	for (icon, item, text, action) in self.stockButtons:
-	    button = GnomePixmapButton(GnomeStock(icon), _(text))
+            button = gtk.Button()
+            box = gtk.HBox(gtk.FALSE, 0)
+            image = gtk.Image()
+            image.set_from_stock(icon, gtk.ICON_SIZE_BUTTON)
+            box.pack_start(image, gtk.FALSE, gtk.FALSE)
+            label = gtk.Label(_(text))
+            label.set_property("use-underline", gtk.TRUE)
+            box.pack_start(label, gtk.TRUE, gtk.TRUE)
+            button.add(box)
 	    button.connect("clicked", action)
 	    button.show_all()
+            button.label = label
 	    self.__dict__[item] = button
 
     def updateStockButtons(self):
 	for (icon, item, text, action) in self.stockButtons:
 	    button = self.__dict__[item]
-            label = button.children ()[0].children ()[0].children()[1]
-            label.set_text (_(text))
+            foo = _(text)
+            print text, foo
+            print "len", len(foo)
+            button.label.set_text_with_mnemonic(_(text))
             button.queue_resize()
 
     def setup_window (self, runres):
-        self.window = GtkWindow ()
-        self.window.set_events (GDK.KEY_RELEASE_MASK)
+        self.window = gtk.Window ()
+        self.window.set_events (gtk.gdk.KEY_RELEASE_MASK)
 
         if runres == '640x480':
             self.window.set_default_size (640, 480)
@@ -650,7 +673,7 @@ class InstallControlWindow:
 	title = _("Red Hat Linux Installer")
 	if os.environ["DISPLAY"][:1] != ':':
 	    # from gnome.zvt import *
-	    # zvtwin = GtkWindow ()
+	    # zvtwin = gtk.Window ()
 #	    shtitle = _("Red Hat Linux Install Shell")
 	    try:
 		f = open ("/tmp/netinfo", "r")
@@ -675,9 +698,9 @@ class InstallControlWindow:
 	    # zvtwin.show_all ()
 
 	self.window.set_title (title)
-        self.window.set_position (WIN_POS_CENTER)
+        self.window.set_position (gtk.WIN_POS_CENTER)
         self.window.set_border_width(0)
-        vbox = GtkVBox (FALSE, 10)
+        vbox = gtk.VBox (gtk.FALSE, 10)
 
         image = self.configFileData["TitleBar"]
 
@@ -686,19 +709,17 @@ class InstallControlWindow:
             for dir in ("/usr/share/anaconda/",
                         "",
                         "/tmp/updates"):
-                try:
-                    p = gdkpixbuf.new_from_file(dir + image)
-                except:
-                    p = None
-                else:
+                pixbuf = gtk.gdk.pixbuf_new_from_file(dir + image)
+                if not pixbuf is None:
                     break
                 
-            if p:
-                pix = apply(GtkPixmap, p.render_pixmap_and_mask())
-                a = GtkAlignment ()
-                a.add (pix)
-                a.set (0.5, 0.5, 1.0, 1.0)
-                vbox.pack_start (a, FALSE, TRUE, 0)
+            if pixbuf:
+                p = gtk.Image()
+                p.set_from_pixbuf(pixbuf)
+                a = gtk.Alignment()
+                a.set(0.5, 0.5, 1.0, 1.0)
+                a.add(p)
+                vbox.pack_start(a, gtk.FALSE, gtk.TRUE, 0)
             else:
                 print _("Unable to load title bar")
 
@@ -707,66 +728,68 @@ class InstallControlWindow:
 
         vbox.set_spacing(0)
 
-        self.buttonBox = GtkHButtonBox ()
-        self.buttonBox.set_layout (BUTTONBOX_END)
+        self.buttonBox = gtk.HButtonBox ()
+        self.buttonBox.set_layout (gtk.BUTTONBOX_END)
         self.buttonBox.set_spacing (30)
 
 	self.buildStockButtons()
 
-        group = GtkAccelGroup()
-        self.nextButtonStock.add_accelerator ("clicked", group, GDK.F12,
-                                              GDK.RELEASE_MASK, 0);
-        self.hideHelpButton.add_accelerator ("clicked", group, GDK.F10,
-                                              GDK.RELEASE_MASK, 0);
-        self.showHelpButton.add_accelerator ("clicked", group, GDK.F11,
-                                             GDK.RELEASE_MASK, 0);
+        group = gtk.AccelGroup()
+        self.nextButtonStock.add_accelerator ("clicked", group, gtk.keysyms.F12,
+                                              gtk.gdk.RELEASE_MASK, 0);
         self.window.add_accel_group (group)
+
+        # set up ctrl+alt+delete handler
         self.window.connect ("key-release-event", self.keyRelease)
 
         self.buttonBox.add (self.prevButtonStock)
         self.buttonBox.add (self.nextButtonStock)
 
-	self.hbox = GtkHBox ()
+	self.hbox = gtk.HBox ()
         self.hbox.set_border_width(5)
-	self.hbox.pack_start (self.hideHelpButton, FALSE)
+	self.hbox.pack_start (self.hideHelpButton, gtk.FALSE)
         self.hbox.set_spacing (25)
-        self.hbox.pack_start (self.releaseButton, FALSE)
+        self.hbox.pack_start (self.releaseButton, gtk.FALSE)
 	self.hbox.pack_start (self.buttonBox)
 
-        vbox.pack_end (self.hbox, FALSE)
+        vbox.pack_end (self.hbox, gtk.FALSE)
 
-        self.html = GtkXmHTML()
-        self.html.set_allow_body_colors(TRUE)
-        self.html.source ("<HTML><BODY BGCOLOR=white></BODY></HTML>")
-        self.displayHelp = TRUE
-        self.helpState = TRUE
+##         self.html = gtk.XmHTML()
+##         self.html.set_allow_body_colors(gtk.TRUE)
+##         self.html.source ("<HTML><BODY BGCOLOR=white></BODY></HTML>")
+        self.displayHelp = gtk.TRUE
+        self.helpState = gtk.TRUE
 
-        self.helpFrame = GtkFrame (_("Online Help"))
-        self.box = GtkVBox (FALSE, 0)
+        self.helpFrame = gtk.Frame (_("Online Help"))
+        self.box = gtk.VBox (gtk.FALSE, 0)
         self.box.set_spacing(0)
 
-        self.box.pack_start (GtkHSeparator (), FALSE)
-        self.box.pack_start (self.html, TRUE)
+        self.box.pack_start (gtk.HSeparator (), gtk.FALSE)
+##         self.box.pack_start (self.html, gtk.TRUE)
         
         self.helpFrame.add (self.box)
 
-        table = GtkTable (1, 3, TRUE)
-        table.attach (self.helpFrame, 0, 1, 0, 1)
+        table = gtk.Table (1, 3, gtk.TRUE)
+        table.attach (self.helpFrame, 0, 1, 0, 1,
+                      gtk.FILL | gtk.EXPAND,
+                      gtk.FILL | gtk.EXPAND)
 
-        self.installFrame = GtkFrame ()
+        self.installFrame = gtk.Frame ()
 
         self.windowList = []
 
         #self.setStateList (self.steps, 0)
         self.setScreen ()
                           
-        table.attach (self.installFrame, 1, 3, 0, 1)
+        table.attach (self.installFrame, 1, 3, 0, 1,
+                      gtk.FILL | gtk.EXPAND,
+                      gtk.FILL | gtk.EXPAND)
         table.set_col_spacing (0, 5)
 
-        self.bin = GtkFrame ()
-        self.bin.set_shadow_type (SHADOW_NONE)
+        self.bin = gtk.Frame ()
+        self.bin.set_shadow_type (gtk.SHADOW_NONE)
         self.bin.add (table)
-        vbox.pack_end (self.bin, TRUE, TRUE)
+        vbox.pack_end (self.bin, gtk.TRUE, gtk.TRUE)
         self.table = table
 
         self.window.add (vbox)
@@ -778,8 +801,8 @@ class InstallControlWindow:
 
     def run (self, runres, configFileData):
         self.configFileData = configFileData
-        self.setup_window (runres)
-        mainloop ()
+        self.setup_window(runres)
+        gtk.main()
             
 class InstallControlState:
     def __init__ (self, cw):
@@ -788,15 +811,15 @@ class InstallControlState:
         self.prevEnabled = 1
         self.nextEnabled = 1
 	self.nextButtonInfo = None
-        self.helpButtonEnabled = TRUE
+        self.helpButtonEnabled = gtk.TRUE
         self.title = _("Install Window")
         self.html = ""
         self.htmlFile = None
-        self.nextButton = STOCK_BUTTON_NEXT
-        self.prevButton = STOCK_BUTTON_PREV
+        self.nextButton = 'gtk-next'
+        self.prevButton = 'gtk-prev'
         self.nextButtonLabel = None
         self.prevButtonLabel = None
-        # Values other than TRUE or FALSE don't change the help setting        
+        # Values other than gtk.TRUE or gtk.FALSE don't change the help setting        
         self.helpEnabled = 3 
         self.grabNext = 0
 
@@ -846,17 +869,13 @@ class InstallControlState:
         if not fn:
             log("unable to load %s", file)
             return None
-        try:
-            p = gdkpixbuf.new_from_file (fn)
-        except RuntimeError:
+        pixbuf = gtk.gdk.pixbuf_new_from_file(fn)
+        if pixbuf is None:
             log("unable to read %s", file)
             return None
-        if p:
-            pix = apply (GtkPixmap, p.render_pixmap_and_mask())
-            return pix
-        else:
-            log("unable to read %s", file)
-        return None
+        p = gtk.Image()
+        p.set_from_pixbuf(pixbuf)
+        return p
 
     def readHTML (self, file):
         self.htmlFile = file