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

43 files changed, 2192 insertions, 1550 deletions

diff --git a/Makefile b/Makefile
index 2ab1868eb..b2ebc24e8 100644
--- a/Makefile
+++ b/Makefile
@@ -11,7 +11,7 @@ endif
 
 SUBDIRSHD = balkan isys collage $(MINISLANG) loader po text-help \
 	    textw utils scripts bootdisk installclasses \
-	    keymaps fonts gnome-map iw help pixmaps $(STUBS)
+	    keymaps fonts gnome-map iw help pixmaps $(STUBS) iconvmodule
 SUBDIRS = $(SUBDIRSHD)
 
 ifeq (i386, $(ARCH))
@@ -28,11 +28,11 @@ PYFILES = $(wildcard *.py)
 all: subdirs _xkb.so xmouse.so $(CATALOGS) lang-table
 
 _xkb.so: xkb.c
-	gcc -Wall -o _xkb.o -O2 -fPIC -I/usr/include/python1.5 `gtk-config --cflags gtk` -c xkb.c 
+	gcc -Wall -o _xkb.o -O2 -fPIC -I$(PYTHONINCLUDE) `gtk-config --cflags gtk` -c xkb.c 
 	gcc -o _xkb.so -shared _xkb.o /usr/X11R6/lib/libxkbfile.a `gtk-config --libs gtk`
 
 xmouse.so: xmouse.c
-	gcc -Wall -o xmouse.o -fPIC -I/usr/X11R6/include -I/usr/include/python1.5 -I /usr/include/python1.5 -c xmouse.c 
+	gcc -Wall -o xmouse.o -fPIC -I/usr/X11R6/include -I$(PYTHONINCLUDE) -I $(PYTHONINCLUDE) -c xmouse.c 
 	gcc -o xmouse.so -shared xmouse.o /usr/X11R6/lib/libXxf86misc.a -L/usr/X11R6/lib -lX11 -lXext
 
 depend:
diff --git a/Makefile.inc b/Makefile.inc
index 0facf62b9..d236fb8d2 100644
--- a/Makefile.inc
+++ b/Makefile.inc
@@ -5,6 +5,8 @@
 PYTHONLIBDIR = /usr/lib/anaconda
 RUNTIMEDIR = /usr/lib/anaconda-runtime
 ANACONDADATADIR = /usr/share/anaconda
+PYTHON = python2.2
+PYTHONINCLUDE = /usr/include/python2.2
 
 ARCH := $(patsubst i%86,i386,$(shell uname -m))
 ARCH := $(patsubst sparc%,sparc,$(ARCH))
diff --git a/anaconda b/anaconda
index 33dabc2cb..78519c94a 100755
--- a/anaconda
+++ b/anaconda
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python2.2
 #
 # anaconda: The Red Hat Linux Installation program
 #
@@ -38,6 +38,7 @@ if (os.path.exists('isys')):
     sys.path.append('iw')
     sys.path.append('installclasses')
     sys.path.append('edd')
+    sys.path.append('iconvmodule')
 else:
     sys.path.append('/usr/lib/anaconda')
     sys.path.append('/usr/lib/anaconda/textw')
diff --git a/balkan/Makefile b/balkan/Makefile
index 059eea203..218a2f751 100644
--- a/balkan/Makefile
+++ b/balkan/Makefile
@@ -3,7 +3,7 @@ include ../Makefile.inc
 #PYTHONLIBDIR = $(DESTDIR)/usr/lib/python1.5/site-packages
 
 OBJECTS = rw.o dos.o sun.o bsdlabel.o
-CFLAGS=-I/usr/include/python1.5 -Os
+CFLAGS=-I$(PYTHONINCLUDE) -Os
 
 TARGET = libbalkan.a
 
diff --git a/edd/Makefile b/edd/Makefile
index bf5d8dfd8..6add37b1d 100644
--- a/edd/Makefile
+++ b/edd/Makefile
@@ -1,6 +1,6 @@
 include ../Makefile.inc
 
-CFLAGS=-Wall -O -g -fpic -I/usr/include/python1.5# -DDEBUG
+CFLAGS=-Wall -O -g -fpic -I$(PYTHONINCLUDE)# -DDEBUG
 
 TARGETS=eddmodule.so libedd.a(edd.o lrmi.o)
 
diff --git a/gnome-map/Makefile b/gnome-map/Makefile
index f631f13b5..01f32ca63 100644
--- a/gnome-map/Makefile
+++ b/gnome-map/Makefile
@@ -2,7 +2,7 @@ include ../Makefile.inc
 
 all: gglobe-canvas timezonemapmodule.so
 
-CFLAGS=-g -O2 -Wall -fPIC `gnome-config --cflags gnomeui gtk` -I/usr/include/python1.5 -DENABLE_NLS
+CFLAGS=-g -O2 -Wall -fPIC `gnome-config --cflags gnomeui gtk` -I$(PYTHONINCLUDE) -DENABLE_NLS
 LDFLAGS=`gnome-config --libs gnomeui gtk`
 
 install: timezonemapmodule.so
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
diff --git a/iconvmodule/.cvsignore b/iconvmodule/.cvsignore
new file mode 100644
index 000000000..0d20b6487
--- /dev/null
+++ b/iconvmodule/.cvsignore
@@ -0,0 +1 @@
+*.pyc
diff --git a/iconvmodule/Makefile b/iconvmodule/Makefile
new file mode 100644
index 000000000..70f1198c2
--- /dev/null
+++ b/iconvmodule/Makefile
@@ -0,0 +1,7 @@
+include ../Makefile.inc
+
+all:
+	$(PYTHON) setup.py build --build-platlib=`pwd`
+
+install:
+	$(PYTHON) setup.py install --install-lib=$(DESTDIR)/$(PYTHONLIBDIR)
diff --git a/iconvmodule/README.en b/iconvmodule/README.en
new file mode 100644
index 000000000..83a842033
--- /dev/null
+++ b/iconvmodule/README.en
@@ -0,0 +1,66 @@
+Iconv-based codec library for Python
+====================================
+Written by Martin v. Loewis
+
+This package provides a set of codecs to Python based on the
+underlying iconv library of the operating system, as available on
+glibc 2, Solaris, or other Unix variants. It consists of two modules:
+iconv and iconvcodec.
+
+Installation
+------------
+To install the module, simply type
+
+python setup.py install
+
+This module package requires atleast Python 2.0.
+
+Module iconv
+------------
+The iconv module exposes a global function to create iconv objects:
+
+open(tocode, fromcode)
+Return descriptor for character set conversion. If the conversion
+of fromcode to tocode is not known to the system, a ValueError is
+raised.
+
+Iconv objects provide a single method to convert a string
+
+iconv(in[, outlen[, return_unicode[, count_only]]])
+Return the string resulting from the conversion of in. The parameter
+in can be a byte or unicode string, or an arbitrary buffer object.
+It is the caller's responsibility to guarantee that the internal
+representation of the in object indeed uses fromcode of the Iconv
+object. The parameter outlen represents an estimate of the resulting
+string size (in bytes, or in characters if return_unicode is true).
+If the buffer is to small, an exception is thrown. If return_unicode
+is set, a Unicode object is the result. If count_only is set,
+no conversion is attempted, but the number of necessary bytes is
+returned.
+
+In case of an error, the iconv method raises the exception iconv.error.
+This exception has four arguments:
+  - the error string as returned from strerror
+  - the error number
+  - the number of input bytes processed
+  - the output string produced so far
+
+Module iconvcodecs
+------------------
+This module encapsulates the iconv module into a set of codecs. To use it,
+simply import it. As a result, the C library's codecs will be available:
+
+  unicode("Hello","T.61")
+  u"World".encode("JOHAB")
+
+License
+-------
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+Author
+------
+Martin v. Loewis
+loewis@informatik.hu-berlin.de
diff --git a/iconvmodule/iconvcodec.py b/iconvmodule/iconvcodec.py
new file mode 100644
index 000000000..a887b587e
--- /dev/null
+++ b/iconvmodule/iconvcodec.py
@@ -0,0 +1,86 @@
+import sys, iconv, codecs, errno
+
+# First we need to find out what the Unicode code set name is
+# in this iconv implementation
+
+if sys.platform.startswith("linux"):
+    unicodename = "unicode"+sys.byteorder
+else:
+    # may need to try UCS-2, UCS-2-LE/BE, Unicode, ...
+    raise ImportError,"cannot establish name of 2-byte Unicode"
+
+class Codec(codecs.Codec):
+    def __init__(self):
+        self.encoder = iconv.open(self.codeset,unicodename)
+        self.decoder = iconv.open(unicodename,self.codeset)
+        
+    def encode(self, msg, errors = 'strict'):
+        try:
+            return self.encoder.iconv(msg),len(msg)
+        except iconv.error,e:
+            print e
+            errstring,code,inlen,outres=e.args
+            assert inlen % 2 == 0
+            inlen /= 2
+            if code == errno.E2BIG:
+                # outbuffer was too small, try to encode rest
+                out1,len1 = self.encode(msg[inlen:],errors)
+                return outres+out1, inlen+len1
+            if code == errno.EINVAL:
+                # An incomplete multibyte sequence has been
+                # encountered in the input. Should not happen in Unicode
+                raise AssertionError("EINVAL in encode")
+            if code == errno.EILSEQ:
+                # An invalid multibyte sequence has been encountered
+                # in the input. Used to indicate that the character is
+                # not supported in the target code
+                if errors == 'strict':
+                    raise UnicodeError(*args)
+                if errors == 'replace':
+                    out1,len1 = self.encode(u"?"+msg[inlen+1:],errors)
+                elif errors == 'ignore':
+                    out1,len1 = self.encode(msg[inlen+1:],errors)
+                else:
+                    raise ValueError("unsupported error handling")
+                return outres+out1, inlen+1+len1
+            raise
+
+    def decode(self, msg, errors = 'strict'):
+        try:
+            return self.decoder.iconv(msg, return_unicode=1),len(msg)
+        except iconv.error,e:
+            errstring,code,inlen,outres = e.args
+            if code == errno.E2BIG:
+                # buffer too small
+                out1,len1 = self.decode(msg[inlen:],errors)
+                return outres+out1, inlen+len1
+            if code == errno.EINVAL:
+                # An incomplete multibyte sequence has been
+                # encountered in the input.
+                return outres,inlen
+            if code == errno.EILSEQ:
+                # An invalid multibyte sequence has been encountered
+                # in the input. Ignoring or replacing it is hard to
+                # achieve, just try one character at a time
+                if errors == 'strict':
+                    raise UnicodeError(*e.args)
+                if errors == 'replace':
+                    outres += u'\uFFFD'
+                    out1,len1 = self.decode(msg[inlen:],errors)
+                elif errors == 'ignore':
+                    out1,len1 = self.decode(msg[inlen:],errors)
+                else:
+                    raise ValueError("unsupported error handling")
+                return outres+out1,inlen+len1
+
+def lookup(encoding):
+    class SpecialCodec(Codec):pass
+    SpecialCodec.codeset = encoding
+    class Reader(SpecialCodec, codecs.StreamReader):pass
+    class Writer(SpecialCodec, codecs.StreamWriter):pass
+    try:
+        return SpecialCodec().encode,SpecialCodec().decode, Reader, Writer
+    except ValueError:
+        return None
+
+codecs.register(lookup)
diff --git a/iconvmodule/iconvmodule.c b/iconvmodule/iconvmodule.c
new file mode 100644
index 000000000..6841bc85b
--- /dev/null
+++ b/iconvmodule/iconvmodule.c
@@ -0,0 +1,190 @@
+#include <iconv.h>
+#include <Python.h>
+
+typedef struct {
+	PyObject_HEAD
+	iconv_t handle;
+} IconvObject;
+
+static PyObject *error;
+
+staticforward PyTypeObject Iconv_Type;
+
+static char iconv_open__doc__[]=
+"open(tocode, fromcode) -> iconv handle\n"
+"allocate descriptor for character set conversion";
+
+static PyObject*
+py_iconv_open(PyObject* unused, PyObject* args)
+{
+	char *tocode, *fromcode;
+	iconv_t result;
+	IconvObject *self;
+	if (!PyArg_ParseTuple(args, "ss", &tocode, &fromcode))
+		return NULL;
+	result = iconv_open(tocode, fromcode);
+	if (result == (iconv_t)(-1)){
+		PyErr_SetFromErrno(PyExc_ValueError);
+		return NULL;
+	}
+	self = PyObject_New(IconvObject, &Iconv_Type);
+	if (self == NULL){
+		iconv_close(result);
+		return NULL;
+	}
+	self->handle = result;
+	return (PyObject*)self;
+}
+
+static void
+Iconv_dealloc(IconvObject *self)
+{
+	iconv_close(self->handle);
+	PyObject_Del(self);
+}
+
+static char Iconv_iconv__doc__[]=
+"iconv(in[, outlen[, return_unicode[, count_only]]]) -> out\n"
+"Convert in to out. outlen is the size of the output buffer;\n"
+"it defaults to len(in).";
+
+static PyObject*
+Iconv_iconv(IconvObject *self, PyObject *args, PyObject* kwargs)
+{
+	PyObject *inbuf_obj;
+	const char *inbuf;
+	char *outbuf;
+	size_t inbuf_size, outbuf_size, iresult;
+	int inbuf_size_int, outbuf_size_int = -1;
+	int return_unicode = 0, count_only = 0;
+	PyObject *result;
+	static char *kwarg_names[]={
+		"s",
+		"outlen",
+		"return_unicode",
+		"count_only",
+		NULL
+	};
+	if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+					 "O|iii:iconv", kwarg_names,
+					 &inbuf_obj, &outbuf_size_int,
+					 &return_unicode, &count_only))
+		return NULL;
+
+	if (inbuf_obj == Py_None){
+		/* None means to clear the iconv object */
+		inbuf = NULL;
+		inbuf_size_int = 0;
+	}else if (inbuf_obj->ob_type->tp_as_buffer){
+		if (PyObject_AsReadBuffer(inbuf_obj, (const void**)&inbuf, 
+					  &inbuf_size_int) == -1)
+			return NULL;
+	}else{
+		PyErr_SetString(PyExc_TypeError, 
+				"iconv expects string as first argument");
+		return NULL;
+	}
+	/* If no result size estimate was given, estimate that the result
+	   string is the same size as the input string. */
+	if (outbuf_size_int == -1)
+		outbuf_size_int = inbuf_size_int;
+	inbuf_size = inbuf_size_int;
+	if (count_only){
+		result = NULL;
+		outbuf = NULL;
+		outbuf_size = outbuf_size_int;
+	}else if(return_unicode){
+		/* Allocate the result string. */
+		result = PyUnicode_FromUnicode(NULL, outbuf_size_int);
+		outbuf = (char*)PyUnicode_AS_UNICODE(result);
+		outbuf_size = outbuf_size_int*2;
+	}else{
+		/* Allocate the result string. */
+		result = PyString_FromStringAndSize(NULL, outbuf_size_int);
+		if (!result)
+			return NULL;
+		outbuf = PyString_AS_STRING(result);
+		outbuf_size = outbuf_size_int;
+	}
+	/* Perform the conversion. */
+	iresult = iconv(self->handle, &inbuf, &inbuf_size, &outbuf, &outbuf_size);
+	if (count_only){
+		result = PyInt_FromLong(outbuf_size_int-outbuf_size);
+	}else if (return_unicode) {
+		/* If the conversion was successful, the result string may be
+		   larger than necessary; outbuf_size will present the extra
+		   bytes. */
+		PyUnicode_Resize(&result, outbuf_size_int-outbuf_size/2);
+	}else{
+		_PyString_Resize(&result, outbuf_size_int-outbuf_size);
+	}
+
+	if (iresult == -1){
+		PyObject *exc;
+		exc = PyObject_CallFunction(error,"siiO",
+					    strerror(errno),errno,
+					    inbuf_size_int - inbuf_size, 
+					    result);
+		Py_DECREF(result);
+		PyErr_SetObject(error,exc);
+		return NULL;
+	}
+	return result;
+}
+
+static PyMethodDef Iconv_methods[] = {
+	{"iconv",	(PyCFunction)Iconv_iconv,	
+	 METH_KEYWORDS|METH_VARARGS,	Iconv_iconv__doc__},
+	{NULL,		NULL}		/* sentinel */
+};
+
+static PyObject *
+Iconv_getattr(PyObject *self, char *name)
+{
+	return Py_FindMethod(Iconv_methods, self, name);
+}
+
+statichere PyTypeObject Iconv_Type = {
+	PyObject_HEAD_INIT(NULL)
+	0,			/*ob_size*/
+	"Iconv",		/*tp_name*/
+	sizeof(IconvObject),	/*tp_basicsize*/
+	0,			/*tp_itemsize*/
+	/* methods */
+	(destructor)Iconv_dealloc, /*tp_dealloc*/
+	0,			/*tp_print*/
+	(getattrfunc)Iconv_getattr, /*tp_getattr*/
+	0,			/*tp_setattr*/
+	0,			/*tp_compare*/
+	0,			/*tp_repr*/
+	0,			/*tp_as_number*/
+	0,			/*tp_as_sequence*/
+	0,			/*tp_as_mapping*/
+	0,			/*tp_hash*/
+};
+
+static PyMethodDef iconv_methods[] = {
+	{"open",	py_iconv_open,
+	 METH_VARARGS,	iconv_open__doc__},
+	{NULL,		NULL}		/* sentinel */
+};
+
+static char __doc__[]=
+"The iconv module provides an interface to the iconv library.";
+
+DL_EXPORT(void)
+initiconv(void)
+{
+	PyObject *m, *d;
+
+	Iconv_Type.ob_type = &PyType_Type;
+
+	/* Create the module and add the functions */
+	m = Py_InitModule4("iconv", iconv_methods, __doc__, 
+			   NULL, PYTHON_API_VERSION);
+
+	/* Add some symbolic constants to the module */
+	d = PyModule_GetDict(m);
+	error = PyErr_NewException("iconv.error", PyExc_ValueError, NULL);
+	PyDict_SetItemString(d, "error", error);
+}
diff --git a/iconvmodule/setup.py b/iconvmodule/setup.py
new file mode 100644
index 000000000..c5ff5d6eb
--- /dev/null
+++ b/iconvmodule/setup.py
@@ -0,0 +1,19 @@
+from distutils.core import setup, Extension
+
+setup (name = "iconv",
+       version = "1.0",
+       description = "iconv-based Unicode converter",
+       author = "Martin v. Loewis",
+       author_email = "loewis@informatik.hu-berlin.de",
+       url = "http://sourceforge.net/projects/python-codecs/",
+       long_description =
+"""The iconv module exposes the operating system's iconv character
+conversion routine to Python. This package provides an iconv wrapper
+as well as a Python codec to convert between Unicode objects and
+all iconv-provided encodings.
+""",
+
+       py_modules = ['iconvcodec'],
+       ext_modules = [Extension("iconv",sources=["iconvmodule.c"])]
+       )
+
diff --git a/iconvmodule/test_iconv.py b/iconvmodule/test_iconv.py
new file mode 100644
index 000000000..d8c6f8325
--- /dev/null
+++ b/iconvmodule/test_iconv.py
@@ -0,0 +1,8 @@
+import iconv
+s=iconv.open("unicodelittle","iso-8859-1")
+r=s.iconv("Hallo",11,return_unicode=1)
+print repr(r),len(r)
+
+s=iconv.open("iso-8859-1","unicodelittle")
+r=s.iconv(u"Hallo",110)
+print r
diff --git a/iconvmodule/test_iconvcodec.py b/iconvmodule/test_iconvcodec.py
new file mode 100644
index 000000000..f4567ec4a
--- /dev/null
+++ b/iconvmodule/test_iconvcodec.py
@@ -0,0 +1,4 @@
+import iconvcodec
+
+print u"Hallo".encode("T.61")
+print repr(unicode("Hallo","T.61"))
diff --git a/isys/Makefile b/isys/Makefile
index 6646f8a79..da9cff007 100644
--- a/isys/Makefile
+++ b/isys/Makefile
@@ -2,7 +2,7 @@ include ../Makefile.inc
 
 ARCH := $(patsubst i%86,i386,$(shell uname -m))
 ARCH := $(patsubst sparc%,sparc,$(ARCH))
-CFLAGS = -ffunction-sections -I/usr/include/python1.5 -I.. -Wall -Os -g  -DHAVE_NFS -D_LARGEFILE_SOURCE=1 -D_LARGEFILE64_SOURCE=1
+CFLAGS = -ffunction-sections -I$(PYTHONINCLUDE) -I.. -Wall -Os -g  -DHAVE_NFS -D_LARGEFILE_SOURCE=1 -D_LARGEFILE64_SOURCE=1
 
 OBJECTS = nfsmount.o dns.o nfsmount_clnt.o nfsmount_xdr.o imount.o \
           smp.o moduleinfo.o devnodes.o cpio.o probe.o uncpio.o \
diff --git a/iw/account_gui.py b/iw/account_gui.py
index b77d3861a..bba29ba35 100644
--- a/iw/account_gui.py
+++ b/iw/account_gui.py
@@ -11,12 +11,12 @@
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 
-from gtk import *
-from iw_gui import *
-from translate import _, N_
+import gtk
 import re
 import string
-from gnome.ui import *
+from gui import WrappingLabel
+from iw_gui import *
+from translate import _, N_
 from flags import flags
 
 class AccountWindow (InstallWindow):
@@ -45,7 +45,7 @@ class AccountWindow (InstallWindow):
         confirm = self.confirm.get_text ()
 
         if pw == confirm and len (pw) >= 6:
-            self.ics.setNextEnabled (TRUE)
+            self.ics.setNextEnabled (gtk.TRUE)
             self.rootStatus.set_text (_("Root password accepted."))
         else:
 	    if not pw and not confirm:
@@ -55,31 +55,36 @@ class AccountWindow (InstallWindow):
             else:
                 self.rootStatus.set_text (_("Root passwords do not match."))
                 
-            self.ics.setNextEnabled (FALSE)
+            self.ics.setNextEnabled (gtk.FALSE)
 
     def userOkay(self, *args):
 	accountName = self.accountName.get_text()
 	password1 = self.userPass1.get_text()
 	password2 = self.userPass2.get_text()
 
-        systemUsers = ['root', 'bin', 'daemon', 'adm', 'lp', 'sync', 'shutdown', 'halt', 'mail',
-                       'news', 'uucp', 'operator', 'games', 'gopher', 'ftp', 'nobody', 'nscd',
-                       'mailnull', 'rpm', 'ident', 'rpc', 'rpcuser', 'radvd', 'xfs', 'gdm', 'apache',
-                       'squid']
-
-	if (password1 and password1 == password2 and
-	    self.userAccountMatch.search(accountName) and
-	    len(password1) > 5) and accountName not in systemUsers:
+        systemUsers = ('root', 'bin', 'daemon', 'adm', 'lp', 'sync',
+                       'shutdown', 'halt', 'mail', 'news', 'uucp',
+                       'operator', 'games', 'gopher', 'ftp', 'nobody',
+                       'nscd', 'mailnull', 'rpm', 'ident', 'rpc',
+                       'rpcuser', 'radvd', 'xfs', 'gdm', 'apache',
+                       'squid')
+
+	if ((password1 and password1 == password2 and
+             self.userAccountMatch.search(accountName) and
+             len(accountName) <= 8 and len(password1) > 5) and
+            accountName != "root" and accountName not in systemUsers):
 	    self.userPwLabel.set_text(_("User password accepted."))
-            self.win.set_sensitive(0, TRUE)
+            self.win.set_sensitive(0, gtk.TRUE)
 	else:
-            self.win.set_sensitive(0, FALSE)
+            self.win.set_sensitive(0, gtk.FALSE)
 	    if not accountName:
 		self.userPwLabel.set_text("")
 	    elif accountName == "root":
-		self.userPwLabel.set_text (_("Root account can not be added here."))
+		self.userPwLabel.set_text (
+                    _("Root account can not be added here."))
             elif accountName in systemUsers:
-                self.userPwLabel.set_text (_("System accounts can not be added here."))
+                self.userPwLabel.set_text (
+                    _("System accounts can not be added here."))
 	    elif not password1 and not password2:
 		self.userPwLabel.set_text (_("Please enter user password."))
 	    elif len (password1) < 6:
@@ -94,9 +99,10 @@ class AccountWindow (InstallWindow):
 	accountName = self.userList.get_text(index, 0)
 	fullName = self.userList.get_text(index, 1)
 	password = self.passwords[accountName]
-        self.edit.set_sensitive(TRUE)
-        self.delete.set_sensitive(TRUE)
-        #Keep track of the data in the CList so we can edit the entry when Edit button is clicked
+        self.edit.set_sensitive(gtk.TRUE)
+        self.delete.set_sensitive(gtk.TRUE)
+        # Keep track of the data in the CList so we can edit the entry
+        # when Edit button is clicked
         self.data = [index, accountName, password, password, fullName]
 
     def addUser_cb(self, widget, *args):
@@ -122,8 +128,8 @@ class AccountWindow (InstallWindow):
         self.accountName.grab_focus ()
 	self.passwords[accountName] = password1
 
-        self.edit.set_sensitive(FALSE)
-        self.delete.set_sensitive(FALSE)
+        self.edit.set_sensitive(gtk.FALSE)
+        self.delete.set_sensitive(gtk.FALSE)
         self.win.destroy()
         
     def editUser_cb(self, widget, *args):
@@ -133,12 +139,15 @@ class AccountWindow (InstallWindow):
 	accountName = self.accountName.get_text()
 	password1 = self.userPass1.get_text()
 	fullName = self.fullName.get_text()
-        index = index[0]        #Get first item in the list
+        # Get first item in the list
+        index = index[0]
 
-        #if the username has not changed, reset the password
+        # if the username has not changed, reset the password
         if accountName in self.passwords.keys():
             self.passwords[accountName] = password1
-        else:  #the username has changed, we need to remove that username from password dictionary
+        else:
+            # the username has changed, we need to remove that
+            # username from password dictionary
             currAccount = self.userList.get_text(index, 0)
             del self.passwords[currAccount]
             self.passwords[accountName] = password1
@@ -146,8 +155,8 @@ class AccountWindow (InstallWindow):
         self.userList.set_text(index, 0, accountName)
         self.userList.set_text(index, 1, fullName)
 
-        self.edit.set_sensitive(FALSE)
-        self.delete.set_sensitive(FALSE)
+        self.edit.set_sensitive(gtk.FALSE)
+        self.delete.set_sensitive(gtk.FALSE)
         self.userList.unselect_all()
         self.win.destroy()
 
@@ -158,12 +167,13 @@ class AccountWindow (InstallWindow):
         self.win.append_button_with_pixmap(_("Cancel"), STOCK_BUTTON_CANCEL)
         self.win.button_connect(0, self.addUser_cb)
         self.win.button_connect(1, self.win.destroy)
-        self.win.set_sensitive(0, FALSE)
+        self.win.set_sensitive(0, gtk.FALSE)
         self.win.show_all()
 
     def editUser (self, widget):
         title = _("Edit User")
-        if self.data:   #if there is data there to edit
+        if self.data:
+            # if there is data there to edit
             self.win = self.userWindow(title, self.data)
             self.win.append_button_with_pixmap(_("OK"), STOCK_BUTTON_OK)
             self.win.append_button_with_pixmap(_("Cancel"), STOCK_BUTTON_CANCEL)
@@ -172,46 +182,44 @@ class AccountWindow (InstallWindow):
             self.win.show_all()
 
     def userWindow (self, title, data=None):
-        userWin = GnomeDialog()
-        userWin.set_modal(TRUE)
+        userWin = gtk.Dialog()
+        userWin.set_modal(gtk.TRUE)
         userWin.set_usize(350, 200)		
-        userWin.set_position (WIN_POS_CENTER)
+        userWin.set_position (gtk.WIN_POS_CENTER)
 
-        userTable = GtkTable (5,2)
-        userTable.set_homogeneous(FALSE)
+        userTable = gtk.Table (5,2)
+        userTable.set_homogeneous(gtk.FALSE)
 
-        vbox = GtkVBox()
+        vbox = gtk.VBox()
         vbox.pack_start(userTable)
-        userAddFrame = GtkFrame (title)
+        userAddFrame = gtk.Frame (title)
         userAddFrame.add(vbox)
         userWin.vbox.pack_start(userAddFrame)
 
-        #Labels
-        label = GtkLabel (_("User Name:"))
+        # Labels
+        label = gtk.Label (_("User Name:"))
         userTable.attach(label, 0, 1, 0, 1)
-        label = GtkLabel (_("Full Name:"))
+        label = gtk.Label (_("Full Name:"))
         userTable.attach(label, 0, 1, 1, 2)
-        label = GtkLabel (_("Password:"))
+        label = gtk.Label (_("Password:"))
         userTable.attach(label, 0, 1, 2, 3)
-        label = GtkLabel (_("Confirm:"))
+        label = gtk.Label (_("Confirm:"))
         userTable.attach(label, 0, 1, 3, 4)
-        #user password label
-        self.userPwLabel = GtkLabel(_("Please enter user name"))
+        # user password label
+        self.userPwLabel = gtk.Label(_("Please enter user name"))
         vbox.pack_start(self.userPwLabel)
 
-        self.forward = lambda widget, box=userWin: box.focus (DIR_TAB_FORWARD)
-
-        #entry boxes
-        self.accountName = GtkEntry ()
-        userTable.attach(self.accountName, 1, 2, 0, 1, SHRINK, SHRINK)
-        self.fullName = GtkEntry ()
-        userTable.attach(self.fullName, 1, 2, 1, 2, SHRINK, SHRINK)
-        self.userPass1 = GtkEntry ()
-        self.userPass1.set_visibility(FALSE)
-        userTable.attach(self.userPass1, 1, 2, 2, 3, SHRINK, SHRINK)
-        self.userPass2 = GtkEntry ()
-        self.userPass2.set_visibility(FALSE)
-        userTable.attach (self.userPass2, 1, 2, 3, 4, SHRINK, SHRINK)
+        # entry boxes
+        self.accountName = gtk.Entry (8)
+        userTable.attach(self.accountName, 1, 2, 0, 1, gtk.SHRINK, gtk.SHRINK)
+        self.fullName = gtk.Entry ()
+        userTable.attach(self.fullName, 1, 2, 1, 2, gtk.SHRINK, gtk.SHRINK)
+        self.userPass1 = gtk.Entry ()
+        self.userPass1.set_visibility(gtk.FALSE)
+        userTable.attach(self.userPass1, 1, 2, 2, 3, gtk.SHRINK, gtk.SHRINK)
+        self.userPass2 = gtk.Entry ()
+        self.userPass2.set_visibility(gtk.FALSE)
+        userTable.attach (self.userPass2, 1, 2, 3, 4, gtk.SHRINK, gtk.SHRINK)
 
         if data:
             index, account, password, password, name = data
@@ -224,12 +232,9 @@ class AccountWindow (InstallWindow):
         self.accountName.connect("changed", self.userOkay)
         self.accountName.connect("insert-text", self.filter)
         self.accountName.connect("activate", self.forward)
-        self.fullName.connect("activate", self.forward)
         self.userPass1.connect("changed", self.userOkay)
-        self.userPass1.connect("activate", self.forward)
         self.userPass2.connect("changed", self.userOkay)
-        self.userPass2.connect("activate", self.forward)
-
+       
         return userWin
         
     def deleteUser(self, *args):
@@ -240,8 +245,8 @@ class AccountWindow (InstallWindow):
 
 	del self.passwords[accountName]
 	self.userList.remove(index)
-        self.edit.set_sensitive(FALSE)
-        self.delete.set_sensitive(FALSE)
+        self.edit.set_sensitive(gtk.FALSE)
+        self.delete.set_sensitive(gtk.FALSE)
 
     def filter(self, widget, text, len, pos):
         # XXX this doesn't check copy/pase
@@ -272,118 +277,119 @@ class AccountWindow (InstallWindow):
 	self.passwords = {}
 	self.editingUser = None
 
-        box = GtkVBox ()
+        box = gtk.VBox ()
 
-        hbox = GtkHBox()
+        hbox = gtk.HBox()
         pix = self.ics.readPixmap ("root-password.png")
         if pix:
-            a = GtkAlignment ()
+            a = gtk.Alignment ()
             a.add (pix)
             a.set (0.0, 0.0, 0.0, 0.0)
-            hbox.pack_start (a, FALSE)
+            hbox.pack_start (a, gtk.FALSE)
 
-        label = GtkLabel (_("Enter the password for the root user (administrator) of this system."))
-        label.set_line_wrap(TRUE)
+        label = gtk.Label (_("Enter the password for the root user "
+                             "(administrator) of this system."))
+        label.set_line_wrap(gtk.TRUE)
         label.set_usize(350, -1)
 
-        a = GtkAlignment ()
+        a = gtk.Alignment ()
         a.add (label)
         a.set (0.0, 0.5, 0.0, 0.0)
-        hbox.pack_start(a, FALSE, 20)
-        box.pack_start(hbox, FALSE)
+        hbox.pack_start(a, gtk.FALSE, 20)
+        box.pack_start(hbox, gtk.FALSE)
        
-        self.forward = lambda widget, box=box: box.focus (DIR_TAB_FORWARD)
+        self.forward = lambda widget, box=box: box.focus (gtk.DIR_TAB_FORWARD)
 
-        table = GtkTable (2, 2)
+        table = gtk.Table (2, 2)
         table.set_row_spacings (5)
 	table.set_col_spacings (5)
 
-        pass1 = GtkLabel (_("Root Password: "))
+        pass1 = gtk.Label (_("Root Password: "))
         pass1.set_alignment (0.0, 0.5)
-        table.attach (pass1, 0, 1, 0, 1, FILL, 0, 10)
-        pass2 = GtkLabel (_("Confirm: "))
+        table.attach (pass1, 0, 1, 0, 1, gtk.FILL, 0, 10)
+        pass2 = gtk.Label (_("Confirm: "))
         pass2.set_alignment (0.0, 0.5)
-        table.attach (pass2, 0, 1, 1, 2, FILL, 0, 10)
-        self.pw = GtkEntry (128)
+        table.attach (pass2, 0, 1, 1, 2, gtk.FILL, 0, 10)
+        self.pw = gtk.Entry (128)
+        
         self.pw.connect ("activate", self.forward)
         self.pw.connect ("changed", self.rootPasswordsMatch)
-        self.pw.connect ("draw", self.setFocus)
-        self.pw.set_visibility (FALSE)
-        self.confirm = GtkEntry (128)
-        self.confirm.connect ("activate", self.forward)
-        self.confirm.set_visibility (FALSE)
-        self.confirm.connect ("changed", self.rootPasswordsMatch)
-        table.attach (self.pw,      1, 2, 0, 1, FILL|EXPAND, 5)
-        table.attach (self.confirm, 1, 2, 1, 2, FILL|EXPAND, 5)
+        self.pw.connect ("map-event", self.setFocus)
+        self.pw.set_visibility (gtk.FALSE)
+        self.confirm = gtk.Entry (128)
+#        self.confirm.connect ("activate", self.forward)
+        self.confirm.set_visibility (gtk.FALSE)
+#        self.confirm.connect ("changed", self.rootPasswordsMatch)
+        table.attach (self.pw,      1, 2, 0, 1, gtk.FILL|gtk.EXPAND, 5)
+        table.attach (self.confirm, 1, 2, 1, 2, gtk.FILL|gtk.EXPAND, 5)
 
-        box.pack_start (table, FALSE)
+        box.pack_start (table, gtk.FALSE)
 
         # root password statusbar
-        self.rootStatus = GtkLabel ("")
+        self.rootStatus = gtk.Label ("")
         self.rootPasswordsMatch ()
-        wrapper = GtkHBox(0, FALSE)
+        wrapper = gtk.HBox(0, gtk.FALSE)
         wrapper.pack_start (self.rootStatus)
-        box.pack_start (wrapper, FALSE)
+        box.pack_start (wrapper, gtk.FALSE)
 
-        box.pack_start (GtkHSeparator (), FALSE, padding=3)
+        box.pack_start (gtk.HSeparator (), gtk.FALSE, padding=3)
 
  	pw = self.rootPw.getPure()
 	if pw:
 	    self.pw.set_text(pw)
 	    self.confirm.set_text(pw)
 
-        sw = GtkScrolledWindow ()
-        sw.set_policy (POLICY_AUTOMATIC, POLICY_AUTOMATIC)
+        sw = gtk.ScrolledWindow ()
+        sw.set_policy (gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
-        self.userList = GtkCList (2, (_("Account Name"), _("Full Name")))
-        self.userList.set_column_auto_resize(0, TRUE)
+        self.userList = gtk.CList (2, (_("Account Name"), _("Full Name")))
         for x in range (2):
             self.userList.column_title_passive (x)
 
 	self.userList.connect("select_row", self.userSelected)
         sw.add (self.userList)
 
-        self.add = GtkButton (_("Add"))
+        self.add = gtk.Button (_("Add"))
 	self.add.connect("clicked", self.addUser)
-        self.edit = GtkButton (_("Edit"))
+        self.edit = gtk.Button (_("Edit"))
 	self.edit.connect("clicked", self.editUser)
-        self.edit.set_sensitive(FALSE)
-        self.delete = GtkButton (_("Delete"))
+        self.edit.set_sensitive(gtk.FALSE)
+        self.delete = gtk.Button (_("Delete"))
 	self.delete.connect("clicked", self.deleteUser)
-        self.delete.set_sensitive(FALSE)
+        self.delete.set_sensitive(gtk.FALSE)
 
-        bb = GtkVButtonBox ()
+        bb = gtk.VButtonBox ()
         bb.set_border_width (5)
-        bb.set_layout_default(BUTTONBOX_START)
+        bb.set_layout(gtk.BUTTONBOX_START)
         bb.pack_start (self.add)
         bb.pack_start (self.edit)
         bb.pack_start (self.delete)
 
-        hbox = GtkHBox()
+        hbox = gtk.HBox()
         pix = self.ics.readPixmap ("users.png")
         if pix:
-            a = GtkAlignment ()
+            a = gtk.Alignment ()
             a.add (pix)
             a.set (0.5, 0.5, 0, 0)
-            hbox.pack_start (a, FALSE, padding=7)
-
-        a = GtkAlignment (0.0, 0.5)
-        label = GtkLabel (_("Additional accounts can be created for other "
-                            "users of this system. Such accounts could be for "
-                            "a personal login account, or for other "
-                            "non-administrative users who need to use this "
-                            "system. Use the <Add> button to enter additional "
-                            "user accounts."))
-        label.set_line_wrap(TRUE)
-        label.set_usize(350, -1)
+            hbox.pack_start (a, gtk.FALSE, padding=7)
+
+        a = gtk.Alignment (0.0, 0.5)
+        label = WrappingLabel(
+            _("Additional accounts can be created for other "
+              "users of this system. Such accounts could be for "
+              "a personal login account, or for other "
+              "non-administrative users who need to use this "
+              "system. Use the <Add> button to enter additional "
+              "user accounts."))
+        label.set_line_wrap(gtk.TRUE)
         a.add(label)
-        hbox.pack_start(a, FALSE)
+        hbox.pack_start(a, gtk.FALSE)
 
-        box.pack_start(hbox, FALSE)
+        box.pack_start(hbox, gtk.FALSE)
         
-        hbox = GtkHBox(FALSE)
-        hbox.pack_start(sw, TRUE)
-        hbox.pack_start(bb, FALSE)
+        hbox = gtk.HBox(gtk.FALSE)
+        hbox.pack_start(sw, gtk.TRUE)
+        hbox.pack_start(bb, gtk.FALSE)
         box.pack_start(hbox)
         
         index = 0
@@ -393,11 +399,11 @@ class AccountWindow (InstallWindow):
 	    index = index + 1
 
         if flags.reconfig:
-            label.set_sensitive(FALSE)
-            self.userList.set_sensitive(FALSE)
-            self.add.set_sensitive(FALSE)
-            self.edit.set_sensitive(FALSE)
-            self.delete.set_sensitive(FALSE)
+            label.set_sensitive(gtk.FALSE)
+            self.userList.set_sensitive(gtk.FALSE)
+            self.add.set_sensitive(gtk.FALSE)
+            self.edit.set_sensitive(gtk.FALSE)
+            self.delete.set_sensitive(gtk.FALSE)
 
 	box.set_border_width (5)
 
diff --git a/iw/bootloader_gui.py b/iw/bootloader_gui.py
index 8dd0c2bca..4a065a2da 100644
--- a/iw/bootloader_gui.py
+++ b/iw/bootloader_gui.py
@@ -11,21 +11,14 @@
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 
-# must replace with explcit form so update disks will work
+import gtk
+import iutil
+import gui
 from iw_gui import *
-
-from gtk import *
-from gnome.ui import *
 from translate import _, N_
-import gdkpixbuf
-import iutil
 from package_gui import queryUpgradeContinue
-import gui
 
 class BootloaderWindow (InstallWindow):
-    checkMark = None
-    checkMark_Off = None
-
     windowTitle = N_("Boot Loader Configuration")
     htmlTag = "bootloader"
 
@@ -150,13 +143,13 @@ class BootloaderWindow (InstallWindow):
             return
         
         if not widget.get_active ():
-            state = TRUE
+            state = gtk.TRUE
             if self.checkLiloReqs():
                 self.ics.setNextEnabled (1)
             else:
                 self.ics.setNextEnabled (0)            
         else:
-            state = FALSE
+            state = gtk.FALSE
             self.ics.setNextEnabled(1)
 
         list = self.bootDevice.keys()
@@ -192,11 +185,11 @@ class BootloaderWindow (InstallWindow):
 
         # cannot allow user to select as default is zero length
         if label:
-            self.defaultCheck.set_sensitive (TRUE)
+            self.defaultCheck.set_sensitive (gtk.TRUE)
         else:
             self.ignoreSignals = 1
             self.defaultCheck.set_active(0)
-            self.defaultCheck.set_sensitive (FALSE)
+            self.defaultCheck.set_sensitive (gtk.FALSE)
             if self.default != None and self.default == index:
                 self.imageList.set_text(self.default, 0, "")
                 self.default = None
@@ -248,7 +241,7 @@ class BootloaderWindow (InstallWindow):
         # do not allow blank label to be default
         if not label:
             self.defaultCheck.set_active(0)
-            self.defaultCheck.set_sensitive (FALSE)
+            self.defaultCheck.set_sensitive (gtk.FALSE)
 
         self.ignoreSignals = 1
         if index == self.default:
@@ -279,10 +272,14 @@ class BootloaderWindow (InstallWindow):
 
     # LiloWindow tag="lilo"
     def getScreen(self, dispatch, bl, fsset, diskSet):
-        if not BootloaderWindow.checkMark:
-            BootloaderWindow.checkMark = self.ics.readPixmap("checkbox-on.png")
-        if not BootloaderWindow.checkMark_Off:
-            BootloaderWindow.checkMark_Off = self.ics.readPixmap("checkbox-off.png")            
+        fn = self.ics.findPixmap("checkbox-on.png")
+        if fn:
+            pixbuf = gtk.gdk.pixbuf_new_from_file(fn)
+            self.checkMark = pixbuf.render_pixmap_and_mask()[0]
+        fn = self.ics.findPixmap("checkbox-off.png")
+        if fn:
+            pixbuf = gtk.gdk.pixbuf_new_from_file(fn)
+            self.checkMark_Off = pixbuf.render_pixmap_and_mask()[0]
 
 	self.dispatch = dispatch
 	self.bl = bl
@@ -294,17 +291,17 @@ class BootloaderWindow (InstallWindow):
 	defaultDevice = bl.images.getDefault()
         self.ignoreSignals = 0
 
-        self.radioBox = GtkTable(2, 6)
+        self.radioBox = gtk.Table(2, 6)
 	self.bootDevice = {}
         self.radioBox.set_border_width (5)
         
-        spacer = GtkLabel("")
+        spacer = gtk.Label("")
         spacer.set_usize(10, 1)
-        self.radioBox.attach(spacer, 0, 1, 2, 4, FALSE)
+        self.radioBox.attach(spacer, 0, 1, 2, 4, gtk.FALSE)
 
-        label = GtkLabel(_("Install Boot Loader record on:"))
+        label = gtk.Label(_("Install Boot Loader record on:"))
         label.set_alignment(0.0, 0.5)
-        self.liloLocationBox = GtkVBox (FALSE, 0)
+        self.liloLocationBox = gtk.VBox (gtk.FALSE, 0)
         self.liloLocationBox.pack_start(label)
         self.radioBox.attach(self.liloLocationBox, 0, 2, 1, 2)
 
@@ -313,7 +310,7 @@ class BootloaderWindow (InstallWindow):
 	    radio = None
 	    count = 0
 	    for (device, desc) in choices:
-		radio = GtkRadioButton(radio,  
+		radio = gtk.RadioButton(radio,  
 				("/dev/%s %s" % (device, _(desc))))
 		self.radioBox.attach(radio, 1, 2, count + 2, count + 3)
 		self.bootDevice[radio] = device
@@ -323,41 +320,42 @@ class BootloaderWindow (InstallWindow):
 
 		count = count + 1
 
-        label = GtkLabel(_("Kernel Parameters") + ":")
+        label = gtk.Label(_("Kernel Parameters") + ":")
         label.set_alignment(0.0, 0.5)
-        self.appendEntry = GtkEntry()
+        self.appendEntry = gtk.Entry()
         if bl.args.get():
             self.appendEntry.set_text(bl.args.get())
-        box = GtkHBox(FALSE, 5)
+        box = gtk.HBox(gtk.FALSE, 5)
         box.pack_start(label)
         box.pack_start(self.appendEntry)
-        alignment = GtkAlignment()
+        alignment = gtk.Alignment()
         alignment.set(0.0, 0.5, 0, 1.0)
         alignment.add(box)
-        self.lba = GtkCheckButton(_("Force use of LBA32 (not normally required)"))
+        self.lba = gtk.CheckButton(_("Force use of LBA32 (not normally required)"))
         self.lba.set_active(self.bl.forceLBA32)
-        vbox = GtkVBox(FALSE, 5)
+        vbox = gtk.VBox(gtk.FALSE, 5)
         vbox.pack_start(alignment)
         vbox.pack_end(self.lba)
         self.radioBox.attach(vbox, 0, 2, 5, 6)
         
-        box = GtkVBox (FALSE, 0)
-
-        label = GtkLabel(_("Please select the boot loader that the computer will use.  GRUB is the default boot loader. "
-                           "However, if you do not wish to overwrite your current boot loader, "
-                           "select \"Do not install a boot loader.\"  "))
-        label.set_usize(400, -1)
-        label.set_line_wrap(TRUE)
+        box = gtk.VBox (gtk.FALSE, 0)
+
+        label = gui.WrappingLabel(_("Please select the boot loader that "
+                                    "the computer will use.  GRUB is the "
+                                    "default boot loader. However, if you "
+                                    "do not wish to overwrite your current "
+                                    "boot loader, select \"Do not install "
+                                    "a boot loader.\"  "))
         label.set_alignment(0.0, 0.0)
-        self.editBox = GtkVBox ()
-        self.imageList = GtkCList (4, ( _("Default"), _("Device"),
+        self.editBox = gtk.VBox ()
+        self.imageList = gtk.CList (4, ( _("Default"), _("Device"),
                                         _("Partition type"), _("Boot label")))
-        self.sw = GtkScrolledWindow ()
+        self.sw = gtk.ScrolledWindow ()
 
                            
-        self.grub_radio = GtkRadioButton(None, (_("Use GRUB as the boot loader")))
-        self.lilo_radio = GtkRadioButton(self.grub_radio, (_("Use LILO as the boot loader")))
-        self.none_radio = GtkRadioButton(self.grub_radio, (_("Do not install a boot loader")))
+        self.grub_radio = gtk.RadioButton(None, (_("Use GRUB as the boot loader")))
+        self.lilo_radio = gtk.RadioButton(self.grub_radio, (_("Use LILO as the boot loader")))
+        self.none_radio = gtk.RadioButton(self.grub_radio, (_("Do not install a boot loader")))
 
 
         self.lilo_radio.connect("toggled", self.bootloaderchange)
@@ -365,28 +363,28 @@ class BootloaderWindow (InstallWindow):
         self.none_radio.connect("toggled", self.toggled)
 
  	if not dispatch.stepInSkipList("instbootloader"):
- 	    self.none_radio.set_active (FALSE)
+ 	    self.none_radio.set_active (gtk.FALSE)
  	else:
-             self.none_radio.set_active (TRUE)
+             self.none_radio.set_active (gtk.TRUE)
              self.toggled (self.none_radio)
 
              for n in (self.appendEntry, self.editBox, 
                        self.imageList, self.liloLocationBox, self.radioBox ):
-                 n.set_sensitive (FALSE)
+                 n.set_sensitive (gtk.FALSE)
 
         self.lastselected = None
 
-        self.radio_vbox = GtkVBox(FALSE, 2)
+        self.radio_vbox = gtk.VBox(gtk.FALSE, 2)
         self.radio_vbox.set_border_width(5)
-        self.radio_vbox.pack_start(label, FALSE)
-        self.radio_vbox.pack_start(self.grub_radio, FALSE)
-        self.radio_vbox.pack_start(self.lilo_radio, FALSE)
-        self.radio_vbox.pack_start(self.none_radio, FALSE)
+        self.radio_vbox.pack_start(label, gtk.FALSE)
+        self.radio_vbox.pack_start(self.grub_radio, gtk.FALSE)
+        self.radio_vbox.pack_start(self.lilo_radio, gtk.FALSE)
+        self.radio_vbox.pack_start(self.none_radio, gtk.FALSE)
         
-        box.pack_start(self.radio_vbox, FALSE)
+        box.pack_start(self.radio_vbox, gtk.FALSE)
 
-        box.pack_start (GtkHSeparator (), FALSE)
-        box.pack_start (self.radioBox, FALSE)
+        box.pack_start (gtk.HSeparator (), gtk.FALSE)
+        box.pack_start (self.radioBox, gtk.FALSE)
         
         sortedKeys = imageList.keys()
         sortedKeys.sort()
@@ -429,53 +427,53 @@ class BootloaderWindow (InstallWindow):
         self.imageList.column_title_passive (1)
         self.imageList.set_border_width (5)
 
-        self.deviceLabel = GtkLabel(_("Partition") + ":")
-        self.typeLabel = GtkLabel(_("Type") + ":")
+        self.deviceLabel = gtk.Label(_("Partition") + ":")
+        self.typeLabel = gtk.Label(_("Type") + ":")
 
-        tempBox = GtkHBox(TRUE)
+        tempBox = gtk.HBox(gtk.TRUE)
         self.deviceLabel.set_alignment(0.0, 0.0)
         self.typeLabel.set_alignment(0.0, 0.0)
-        tempBox.pack_start(self.deviceLabel, FALSE)
-        tempBox.pack_start(self.typeLabel, FALSE)
-        self.defaultCheck = GtkCheckButton(_("Default boot image"))
+        tempBox.pack_start(self.deviceLabel, gtk.FALSE)
+        tempBox.pack_start(self.typeLabel, gtk.FALSE)
+        self.defaultCheck = gtk.CheckButton(_("Default boot image"))
 
         # Alliteration!
-        self.labelLabel = GtkLabel(_("Boot label") + ":")
-        self.labelEntry = GtkEntry(15)
+        self.labelLabel = gtk.Label(_("Boot label") + ":")
+        self.labelEntry = gtk.Entry(15)
 
         self.imageList.connect("select_row", self.labelSelected)
         self.defaultCheck.connect("toggled", self.defaultUpdated)
         self.labelEntry.connect("changed", self.labelUpdated)
         self.labelEntry.connect("insert_text", self.labelInsertText)
 
-        tempBox2 = GtkHBox(FALSE, 5)
+        tempBox2 = gtk.HBox(gtk.FALSE, 5)
         self.labelLabel.set_alignment(0.0, 0.5)
-        tempBox2.pack_start(self.labelLabel, FALSE)
-        tempBox2.pack_start(self.labelEntry, FALSE)
+        tempBox2.pack_start(self.labelLabel, gtk.FALSE)
+        tempBox2.pack_start(self.labelEntry, gtk.FALSE)
 
-        self.editBox.pack_start (tempBox, FALSE)
-        self.editBox.pack_start (self.defaultCheck, FALSE)
-        self.editBox.pack_start (tempBox2, FALSE)
+        self.editBox.pack_start (tempBox, gtk.FALSE)
+        self.editBox.pack_start (self.defaultCheck, gtk.FALSE)
+        self.editBox.pack_start (tempBox2, gtk.FALSE)
         self.editBox.set_border_width (5)
 
-        box.pack_start (GtkHSeparator (), FALSE)
-        box.pack_start (self.editBox, FALSE)
+        box.pack_start (gtk.HSeparator (), gtk.FALSE)
+        box.pack_start (self.editBox, gtk.FALSE)
 
-        self.imageList.set_selection_mode (SELECTION_BROWSE)
+        self.imageList.set_selection_mode (gtk.SELECTION_BROWSE)
 
-        self.sw.set_policy (POLICY_AUTOMATIC, POLICY_AUTOMATIC)
+        self.sw.set_policy (gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
         self.sw.add (self.imageList)
-        box.pack_start (self.sw, TRUE)
+        box.pack_start (self.sw, gtk.TRUE)
 
 	if not dispatch.stepInSkipList("instbootloader"):
-            self.editBox.set_sensitive(TRUE)
-            tempBox2.set_sensitive(TRUE)
-            self.radioBox.set_sensitive(TRUE)
-            self.sw.set_sensitive(TRUE)
+            self.editBox.set_sensitive(gtk.TRUE)
+            tempBox2.set_sensitive(gtk.TRUE)
+            self.radioBox.set_sensitive(gtk.TRUE)
+            self.sw.set_sensitive(gtk.TRUE)
         else:
-            self.editBox.set_sensitive(FALSE)
-            self.radioBox.set_sensitive(FALSE)
-            self.sw.set_sensitive(FALSE)
+            self.editBox.set_sensitive(gtk.FALSE)
+            self.radioBox.set_sensitive(gtk.FALSE)
+            self.sw.set_sensitive(gtk.FALSE)
             
         self.ignoreSignals = 0
 
diff --git a/iw/bootloaderpassword_gui.py b/iw/bootloaderpassword_gui.py
index eddd6f45b..91afc4598 100644
--- a/iw/bootloaderpassword_gui.py
+++ b/iw/bootloaderpassword_gui.py
@@ -11,13 +11,10 @@
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 
-from iw_gui import *
-
-from gtk import *
-from gnome.ui import *
-from translate import _, N_
-import GdkImlib
+import gtk
 import gui
+from translate import _, N_
+from iw_gui import *
 
 class BootloaderPasswordWindow (InstallWindow):
 
@@ -50,7 +47,7 @@ class BootloaderPasswordWindow (InstallWindow):
         confirm = self.confirm.get_text ()
 
         if pw == confirm and len(pw) >= 1:
-            self.ics.setNextEnabled (TRUE)
+            self.ics.setNextEnabled (gtk.TRUE)
             self.rootStatus.set_text (_("Password accepted."))
         else:
             if not pw and not confirm:
@@ -60,44 +57,47 @@ class BootloaderPasswordWindow (InstallWindow):
             else:
                 self.rootStatus.set_text (_("Passwords do not match."))
                 
-            self.ics.setNextEnabled (FALSE)
+            self.ics.setNextEnabled (gtk.FALSE)
         
     def getScreen(self, bl, intf):
         self.bl = bl
         self.intf = intf
 
-        box = GtkVBox(FALSE, 5)
+        box = gtk.VBox(gtk.FALSE, 5)
         box.set_border_width (5)
 
         self.forward = lambda widget, box=box: box.focus (DIR_TAB_FORWARD)
 
-        self.passtable = GtkTable (2, 2)
+        self.passtable = gtk.Table (2, 2)
         self.passtable.set_row_spacings (5)
 	self.passtable.set_col_spacings (5)
-        grubpassinfo = GtkLabel(_("A boot loader password prevents users from passing arbitrary options to the kernel.  For highest security, we recommend setting a password, but this is not necessary for more casual users."))
+        grubpassinfo =  gui.WrappingLabel(
+            _("A boot loader password prevents users from "
+              "passing arbitrary options to the kernel.  For "
+              "highest security, we recommend setting a "
+              "password, but this is not necessary for more "
+              "casual users."))
         self.password = None
-        grubpassinfo.set_line_wrap(TRUE)
-        grubpassinfo.set_usize(400, -1)
         grubpassinfo.set_alignment(0.0,0.0)
-        box.pack_start(grubpassinfo, FALSE)
-
-        self.usegrubpasscb = GtkCheckButton(_("Use a GRUB Password?"))
-        box.pack_start(self.usegrubpasscb, FALSE)
-
-        self.passtable.attach(GtkLabel(_("Password:")), 0, 1, 2, 3, FILL, 0, 10)
-        self.pw = GtkEntry (16)
-        self.pw.set_visibility (FALSE)
-        self.passtable.attach(self.pw, 1, 2, 2, 3, FILL, 0, 10)
-        self.passtable.attach(GtkLabel(_("Confirm:")), 0, 1, 3, 4, FILL, 0, 10) 
-        self.confirm = GtkEntry (16)
-        self.confirm.set_visibility (FALSE)
-        self.passtable.attach(self.confirm, 1, 2, 3, 4, FILL, 0, 10)
+        box.pack_start(grubpassinfo, gtk.FALSE)
+
+        self.usegrubpasscb = gtk.CheckButton(_("Use a GRUB Password?"))
+        box.pack_start(self.usegrubpasscb, gtk.FALSE)
+
+        self.passtable.attach(gtk.Label(_("Password:")), 0, 1, 2, 3, gtk.FILL, 0, 10)
+        self.pw = gtk.Entry (16)
+        self.pw.set_visibility (gtk.FALSE)
+        self.passtable.attach(self.pw, 1, 2, 2, 3, gtk.FILL, 0, 10)
+        self.passtable.attach(gtk.Label(_("Confirm:")), 0, 1, 3, 4, gtk.FILL, 0, 10) 
+        self.confirm = gtk.Entry (16)
+        self.confirm.set_visibility (gtk.FALSE)
+        self.passtable.attach(self.confirm, 1, 2, 3, 4, gtk.FILL, 0, 10)
         
         if self.bl.getPassword():
             passwd = self.bl.getPassword()
             self.pw.set_text(passwd)
             self.confirm.set_text(passwd)
-            self.usegrubpasscb.set_active(TRUE)
+            self.usegrubpasscb.set_active(gtk.TRUE)
 
         self.pw.connect ("changed", self.rootPasswordsMatch)
         self.pw.connect ("activate", self.forward)
@@ -106,11 +106,11 @@ class BootloaderPasswordWindow (InstallWindow):
         self.passtable.set_sensitive(self.usegrubpasscb.get_active())
         self.usegrubpasscb.connect("toggled", self.toggle)
 
-        self.rootStatus = GtkLabel(_("Please enter password"))
-        a = GtkAlignment (0.2, 0.5)
+        self.rootStatus = gtk.Label(_("Please enter password"))
+        a = gtk.Alignment (0.2, 0.5)
         a.add(self.rootStatus)
-        box.pack_start(self.passtable, FALSE)
-        box.pack_start(a, FALSE)
+        box.pack_start(self.passtable, gtk.FALSE)
+        box.pack_start(a, gtk.FALSE)
 
 
         return box
diff --git a/iw/checklist.py b/iw/checklist.py
index c68e83a70..6d478b95c 100644
--- a/iw/checklist.py
+++ b/iw/checklist.py
@@ -14,16 +14,15 @@
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 
-from gtk import *
-import GTK
+import gtk
 
-class CheckList (GtkCList):
-    """A class (derived from GtkCList) that provides a list of
+class CheckList (gtk.CList):
+    """A class (derived from gtk.CList) that provides a list of
     checkbox / text string pairs"""
     CHECK_SIZE = 13
 
     def __init__ (self, columns = 1):
-        GtkCList.__init__ (self, columns+1)
+        gtk.CList.__init__ (self, columns+1)
 
         self.set_column_auto_resize(0, 1)
         #for i in range(columns):
@@ -51,14 +50,14 @@ class CheckList (GtkCList):
         self.set_row_data (row, (not not init_value, row_data, ""))
         self.n_rows = self.n_rows + 1
 
-        if (self.flags() & GTK.REALIZED):
+        if (self.flags() & gtk.REALIZED):
             self._update_row (row)
 
         return row
 
     def clear (self):
         "Remove all rows"
-        GtkCList.clear(self)
+        gtk.CList.clear(self)
         self.n_rows = 0
 
     def set_toggled_func (self, func):
@@ -77,8 +76,8 @@ class CheckList (GtkCList):
 
     def _color_pixmaps(self):
         style = self.get_style()
-        base_gc = self.on_pixmap.new_gc(foreground = style.base[GTK.STATE_NORMAL])
-        text_gc = self.on_pixmap.new_gc(foreground = style.text[GTK.STATE_NORMAL])
+        base_gc = self.on_pixmap.new_gc(foreground = style.base[gtk.STATE_NORMAL])
+        text_gc = self.on_pixmap.new_gc(foreground = style.text[gtk.STATE_NORMAL])
         
         self.mask = create_pixmap(None,CheckList.CHECK_SIZE,CheckList.CHECK_SIZE,1)
         # HACK - we really want to just use a color with a pixel value of 1
@@ -110,7 +109,7 @@ class CheckList (GtkCList):
         self.on_pixmap = create_pixmap(self.get_window(), CheckList.CHECK_SIZE,CheckList.CHECK_SIZE)
         self.off_pixmap = create_pixmap(self.get_window(), CheckList.CHECK_SIZE,CheckList.CHECK_SIZE)
 
-        # We can't connect this callback before because of a bug in PyGtk where it doesn't
+        # We can't connect this callback before because of a bug in Pygtk. where it doesn't
         # like style_set to be called with a NULL old_style
         self.connect ("style_set", lambda self, old_style: self._color_pixmaps)
         self._color_pixmaps()
diff --git a/iw/confirm_gui.py b/iw/confirm_gui.py
index 501dba162..7ce633f00 100644
--- a/iw/confirm_gui.py
+++ b/iw/confirm_gui.py
@@ -11,7 +11,7 @@
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 
-from gtk import *
+import gtk
 from iw_gui import *
 from translate import _, N_
 from package_gui import queryUpgradeContinue
@@ -21,29 +21,29 @@ class ConfirmWindow (InstallWindow):
 
     # ConfirmWindow tag="aboutupgrade" or "aboutinstall"
     def getScreen (self, labelText, longText):
-        hbox = GtkHBox (TRUE, 5)
-        box = GtkVBox (FALSE, 5)
+        hbox = gtk.HBox (gtk.TRUE, 5)
+        box = gtk.VBox (gtk.FALSE, 5)
 
         pix = self.ics.readPixmap ("about-to-install.png")
         if pix:
-            a = GtkAlignment ()
+            a = gtk.Alignment ()
             a.add (pix)
             a.set (0.5, 0.5, 1.0, 1.0)
-            hbox.pack_start (a, FALSE)
+            hbox.pack_start (a, gtk.FALSE)
 
-	label = GtkLabel (labelText)
-        label.set_line_wrap (TRUE)
+	label = gtk.Label (labelText)
+        label.set_line_wrap (gtk.TRUE)
         label.set_usize(190, -1)
 
-	label2 = GtkLabel (longText)
-        label2.set_line_wrap (TRUE)
+	label2 = gtk.Label (longText)
+        label2.set_line_wrap (gtk.TRUE)
         label2.set_usize(190, -1)
         
-        box.pack_start (label, FALSE)
-        box.pack_start (label2, FALSE)
+        box.pack_start (label, gtk.FALSE)
+        box.pack_start (label2, gtk.FALSE)
         box.set_border_width (5)
 
-        a = GtkAlignment ()
+        a = gtk.Alignment ()
         a.add (box)
         a.set (0.5, 0.5, 0.0, 0.0)
 
diff --git a/iw/congrats_gui.py b/iw/congrats_gui.py
index 9be3b32fc..a87d5c5c8 100644
--- a/iw/congrats_gui.py
+++ b/iw/congrats_gui.py
@@ -11,8 +11,7 @@
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 
-from gtk import *
-from gnome.ui import *
+import gtk
 from iw_gui import *
 from translate import _, N_
 import iutil
@@ -24,24 +23,24 @@ class CongratulationWindow (InstallWindow):
     def __init__ (self, ics):
 	InstallWindow.__init__ (self, ics)
 
-        ics.setPrevEnabled (FALSE)
+        ics.setPrevEnabled (gtk.FALSE)
         ics.setNextButton (STOCK_PIXMAP_QUIT, _("Exit"))
-        ics.setHelpButtonEnabled (FALSE)
-        ics.setHelpEnabled(FALSE)
+        ics.setHelpButtonEnabled (gtk.FALSE)
+        ics.setHelpEnabled(gtk.FALSE)
 	ics.setGrabNext (1)
 
     # CongratulationWindow tag=NA
     def getScreen (self):
-        self.ics.setHelpEnabled (FALSE)
+        self.ics.setHelpEnabled (gtk.FALSE)
 
-        hbox = GtkHBox (TRUE, 5)
+        hbox = gtk.HBox (gtk.TRUE, 5)
         
         pix = self.ics.readPixmap ("done.png")
         if pix:
-            a = GtkAlignment ()
+            a = gtk.Alignment ()
             a.add (pix)
             a.set (0.5, 0.5, 1.0, 1.0)
-            hbox.pack_start (a, FALSE)
+            hbox.pack_start (a, gtk.FALSE)
 
         if iutil.getArch() != "ia64":
             bootstr = _("If you created a boot disk to use to boot your "
@@ -51,7 +50,7 @@ class CongratulationWindow (InstallWindow):
             bootstr = ""
             
 
-	label = GtkLabel(
+	label = gtk.Label(
              _("Congratulations, your Red Hat Linux installation is "
                "complete.\n\n"
                "Remove any floppy diskettes you used during the "
@@ -65,11 +64,11 @@ class CongratulationWindow (InstallWindow):
                "at http://www.redhat.com/support/manuals.") % bootstr,
              )
                 
-        label.set_line_wrap (TRUE)
+        label.set_line_wrap (gtk.TRUE)
         label.set_alignment (0.0, 0.5)
 
-        box = GtkVBox (FALSE, 10)
-        box.pack_start (label, TRUE, TRUE, 0)
+        box = gtk.VBox (gtk.FALSE, 10)
+        box.pack_start (label, gtk.TRUE, gtk.TRUE, 0)
 
         hbox.pack_start (box)
         return hbox
@@ -90,27 +89,27 @@ class ReconfigCongratulationWindow (InstallWindow):
     def getScreen (self):
         self.ics.setHelpEnabled (0)
 
-        hbox = GtkHBox (TRUE, 5)
+        hbox = gtk.HBox (gtk.TRUE, 5)
         
         pix = self.ics.readPixmap ("done.png")
         if pix:
-            a = GtkAlignment ()
+            a = gtk.Alignment ()
             a.add (pix)
             a.set (0.5, 0.5, 1.0, 1.0)
-            hbox.pack_start (a, FALSE)
+            hbox.pack_start (a, gtk.FALSE)
 
-        label = GtkLabel(_("Congratulations, configuration is complete.\n\n"
+        label = gtk.Label(_("Congratulations, configuration is complete.\n\n"
                   "For information on errata (updates and bug fixes), visit "
                   "http://www.redhat.com/errata.\n\n"
                   "Information on using and configuring your "
                   "system is available in the Red Hat Linux manuals "
                   "at http://www.redhat.com/support/manuals."))
         
-        label.set_line_wrap (TRUE)
+        label.set_line_wrap (gtk.TRUE)
         label.set_alignment (0.0, 0.5)
         
-        box = GtkVBox (FALSE, 10)
-        box.pack_start (label, TRUE, TRUE, 0)
+        box = gtk.VBox (gtk.FALSE, 10)
+        box.pack_start (label, gtk.TRUE, gtk.TRUE, 0)
 
         hbox.pack_start (box)
         return hbox
diff --git a/iw/firewall_gui.py b/iw/firewall_gui.py
index 181c1c0f8..4a2695398 100644
--- a/iw/firewall_gui.py
+++ b/iw/firewall_gui.py
@@ -11,12 +11,11 @@
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 
-from gtk import *
-from gnome.ui import *
+import checklist
+import gtk
 from iw_gui import *
 from isys import *
 from translate import _, N_
-import checklist
 
 class FirewallWindow (InstallWindow):		
 
@@ -111,12 +110,12 @@ class FirewallWindow (InstallWindow):
                     from gnome.ui import *
                     import gui
                     self.textWin = GnomeDialog ()
-                    self.textWin.set_modal (TRUE)
+                    self.textWin.set_modal (gtk.TRUE)
 
-                    vbox = GtkVBox()
-                    hbox = GtkHBox()
+                    vbox = gtk.VBox()
+                    hbox = gtk.HBox()
 
-                    hbox.pack_start (GnomePixmap ('/usr/share/pixmaps/gnome-warning.png'), FALSE)
+                    hbox.pack_start (GnomePixmap ('/usr/share/pixmaps/gnome-warning.png'), gtk.FALSE)
                     self.textWin.vbox.pack_start(hbox)
                     hbox.pack_start(vbox)
                     
@@ -126,10 +125,10 @@ class FirewallWindow (InstallWindow):
                     self.textWin.set_usize (500, 200)
                     self.textWin.set_position (WIN_POS_CENTER)
 
-                    label = GtkLabel((_("Warning: ")) + bad_token + (_(" is an invalid port.")))
+                    label = gtk.Label((_("Warning: ")) + bad_token + (_(" is an invalid port.")))
                     vbox.pack_start(label)
 
-                    label = GtkLabel(_("The format is 'port:protocol'.  For example, '1234:udp'"))
+                    label = gtk.Label(_("The format is 'port:protocol'.  For example, '1234:udp'"))
                     vbox.pack_start(label)
                     
                     self.textWin.append_button(_("Close"))
@@ -156,8 +155,8 @@ class FirewallWindow (InstallWindow):
             self.label2.set_sensitive(active)
             self.label3.set_sensitive(active)
         else:
-            self.default_radio.set_sensitive (TRUE)
-            self.custom_radio.set_sensitive (TRUE) 
+            self.default_radio.set_sensitive (gtk.TRUE)
+            self.custom_radio.set_sensitive (gtk.TRUE) 
 
             if self.custom_radio.get_active ():
                 self.trusted.set_sensitive(self.custom_radio.get_active())
@@ -213,88 +212,88 @@ class FirewallWindow (InstallWindow):
         
 	self.netCBs = {}
 
-        box = GtkVBox (FALSE, 5)
+        box = gtk.VBox (gtk.FALSE, 5)
         box.set_border_width (5)
 
-        label = GtkLabel (_("Please choose your security level:  "))
+        label = gtk.Label (_("Please choose your security level:  "))
         label.set_alignment (0.0, 0.5)
 
-        label.set_line_wrap (TRUE)
+        label.set_line_wrap (gtk.TRUE)
         
-        box.pack_start(label, FALSE)
+        box.pack_start(label, gtk.FALSE)
 
-        hbox = GtkHBox (FALSE)
+        hbox = gtk.HBox (gtk.FALSE)
 
-        self.sec_high_radio = GtkRadioButton (None, (_("High")))
-        self.sec_med_radio = GtkRadioButton (self.sec_high_radio, (_("Medium")))
-        self.sec_none_radio = GtkRadioButton (self.sec_high_radio, (_("No firewall")))
+        self.sec_high_radio = gtk.RadioButton (None, (_("High")))
+        self.sec_med_radio = gtk.RadioButton (self.sec_high_radio, (_("Medium")))
+        self.sec_none_radio = gtk.RadioButton (self.sec_high_radio, (_("No firewall")))
         self.sec_none_radio.connect ("clicked", self.activate_firewall)
 
         hbox.pack_start (self.sec_high_radio)
         hbox.pack_start (self.sec_med_radio)
         hbox.pack_start (self.sec_none_radio)
 
-        a = GtkAlignment ()
+        a = gtk.Alignment ()
         a.add (hbox)
         a.set (1.0, 0.5, 0.7, 1.0)
 
-        box.pack_start (a, FALSE)
+        box.pack_start (a, gtk.FALSE)
 
-        hsep = GtkHSeparator ()
-        box.pack_start (hsep, FALSE)
+        hsep = gtk.HSeparator ()
+        box.pack_start (hsep, gtk.FALSE)
 
-        self.default_radio = GtkRadioButton (None, (_("Use default firewall rules")))
-        self.custom_radio = GtkRadioButton (self.default_radio, (_("Customize")))
-        self.default_radio.set_active (TRUE)
+        self.default_radio = gtk.RadioButton (None, (_("Use default firewall rules")))
+        self.custom_radio = gtk.RadioButton (self.default_radio, (_("Customize")))
+        self.default_radio.set_active (gtk.TRUE)
 
         self.default_radio.connect ("clicked", self.activate_firewall)
         self.custom_radio.connect ("clicked", self.activate_firewall)
         
-        box.pack_start (self.default_radio, FALSE)
-        box.pack_start (self.custom_radio, FALSE)
+        box.pack_start (self.default_radio, gtk.FALSE)
+        box.pack_start (self.custom_radio, gtk.FALSE)
 
-        table = GtkTable (2, 3)
+        table = gtk.Table (2, 3)
         box.pack_start (table)
 
-        hbox = GtkHBox(FALSE, 10)
-        self.label1 = GtkLabel (_("Trusted devices:"))
+        hbox = gtk.HBox(gtk.FALSE, 10)
+        self.label1 = gtk.Label (_("Trusted devices:"))
         self.label1.set_alignment (0.2, 0.0)
         self.trusted = checklist.CheckList(1)
         self.trusted.connect ('button_press_event', self.trusted_select_row)
         self.trusted.connect ("key_press_event", self.trusted_key_press)
 
         if self.devices != []:
-            table.attach (self.label1, 0, 1, 0, 1, FILL, FILL, 5, 5)
-            table.attach (self.trusted, 1, 2, 0, 1, EXPAND|FILL, FILL, 5, 5)
+            table.attach (self.label1, 0, 1, 0, 1, gtk.FILL, gtk.FILL, 5, 5)
+            table.attach (self.trusted, 1, 2, 0, 1, gtk.EXPAND|gtk.FILL, gtk.FILL, 5, 5)
 
             count = 0
             for device in self.devices:
                 if self.firewall.trustdevs == []:
-                    self.trusted.append_row ((device, device), FALSE)
+                    self.trusted.append_row ((device, device), gtk.FALSE)
                 else:
                     if device in self.firewall.trustdevs:
-                        self.trusted.append_row ((device, device), TRUE)
+                        self.trusted.append_row ((device, device), gtk.TRUE)
                     else:
-                        self.trusted.append_row ((device, device), FALSE)
+                        self.trusted.append_row ((device, device), gtk.FALSE)
                 if self.network.netdevices[device].get('bootproto') == 'dhcp':
                     self.firewall.dhcp = 1
 
             count = count + 1
 
-        hbox = GtkHBox(FALSE, 10)        
-        self.label2 = GtkLabel (_("Allow incoming:"))
+        hbox = gtk.HBox(gtk.FALSE, 10)        
+        self.label2 = gtk.Label (_("Allow incoming:"))
         self.label2.set_alignment (0.2, 0.0)
         self.incoming = checklist.CheckList(1)
         self.incoming.connect ('button_press_event', self.incoming_select_row)
         self.incoming.connect ("key_press_event", self.incoming_key_press)
-        table.attach (self.label2, 0, 1, 1, 2, FILL, FILL, 5, 5)
-        table.attach (self.incoming, 1, 2, 1, 2, EXPAND|FILL, FILL, 5, 5)
+        table.attach (self.label2, 0, 1, 1, 2, gtk.FILL, gtk.FILL, 5, 5)
+        table.attach (self.incoming, 1, 2, 1, 2, gtk.EXPAND|gtk.FILL, gtk.FILL, 5, 5)
 
         self.list = ["DHCP", "SSH", "Telnet", "WWW (HTTP)", "Mail (SMTP)", "FTP"]
 
         count = 0
         for item in self.list:
-            self.incoming.append_row ((item, ""), FALSE)
+            self.incoming.append_row ((item, ""), gtk.FALSE)
 
             if item == "DHCP":
                 self.incoming.set_row_data (count, (self.firewall.dhcp, item, item)) 
@@ -311,31 +310,31 @@ class FirewallWindow (InstallWindow):
 
             count = count + 1
 
-        self.label3 = GtkLabel (_("Other ports:"))
-        self.ports = GtkEntry ()
+        self.label3 = gtk.Label (_("Other ports:"))
+        self.ports = gtk.Entry ()
 
-        table.attach (self.label3, 0, 1, 2, 3, FILL, FILL, 5, 5)
-        table.attach (self.ports, 1, 2, 2, 3, EXPAND|FILL, FILL, 5, 5)
+        table.attach (self.label3, 0, 1, 2, 3, gtk.FILL, gtk.FILL, 5, 5)
+        table.attach (self.ports, 1, 2, 2, 3, gtk.EXPAND|gtk.FILL, gtk.FILL, 5, 5)
 
         if self.firewall.enabled == 0:
-            self.sec_none_radio.set_active (TRUE)
+            self.sec_none_radio.set_active (gtk.TRUE)
         elif self.firewall.policy == 0:
-            self.sec_high_radio.set_active (TRUE)
+            self.sec_high_radio.set_active (gtk.TRUE)
         elif self.firewall.policy == 1:
-            self.sec_med_radio.set_active (TRUE)
+            self.sec_med_radio.set_active (gtk.TRUE)
 
         if self.firewall.portlist != "":
             self.ports.set_text (self.firewall.portlist)
 
         if self.firewall.custom == 1:
-            self.custom_radio.set_active(TRUE)
+            self.custom_radio.set_active(gtk.TRUE)
         else:
-            self.trusted.set_sensitive(FALSE)
-            self.incoming.set_sensitive(FALSE)
-            self.ports.set_sensitive(FALSE)
-            self.label1.set_sensitive(FALSE)
-            self.label2.set_sensitive(FALSE)
-            self.label3.set_sensitive(FALSE)
+            self.trusted.set_sensitive(gtk.FALSE)
+            self.incoming.set_sensitive(gtk.FALSE)
+            self.ports.set_sensitive(gtk.FALSE)
+            self.label1.set_sensitive(gtk.FALSE)
+            self.label2.set_sensitive(gtk.FALSE)
+            self.label3.set_sensitive(gtk.FALSE)
 
         return box
 
diff --git a/iw/installpath_gui.py b/iw/installpath_gui.py
index 2a603a87d..33235efc9 100644
--- a/iw/installpath_gui.py
+++ b/iw/installpath_gui.py
@@ -12,7 +12,7 @@
 #
 
 import installclass
-from gtk import *
+import gtk
 from iw_gui import InstallWindow
 from flags import flags
 from translate import _, N_
@@ -65,15 +65,15 @@ class InstallPathWindow (InstallWindow):
     def pixRadioButton (self, group, label, pixmap):
         pix = self.ics.readPixmap (pixmap)
         if pix:
-            hbox = GtkHBox (FALSE, 5)
-            hbox.pack_start (pix, FALSE, FALSE, 0)
-            label = GtkLabel (label)
+            hbox = gtk.HBox (gtk.FALSE, 5)
+            hbox.pack_start (pix, gtk.FALSE, gtk.FALSE, 0)
+            label = gtk.Label (label)
             label.set_alignment (0.0, 0.5)
-            hbox.pack_start (label, TRUE, TRUE, 15)
-            button = GtkRadioButton (group)
+            hbox.pack_start (label, gtk.TRUE, gtk.TRUE, 15)
+            button = gtk.RadioButton (group)
             button.add (hbox)
         else:
-            button = GtkRadioButton (group, label)
+            button = gtk.RadioButton (group, label)
         return button
 
     # InstallPathWindow tag="instpath"
@@ -131,7 +131,7 @@ class InstallPathWindow (InstallWindow):
 		topLevelGroup = self.pixRadioButton(topLevelGroup,
 		    _(parentName), parentPixmap)
 
-		box = GtkVBox (FALSE, 0)
+		box = gtk.VBox (gtk.FALSE, 0)
 		box.set_usize(300, -1)
 		group = None
 
@@ -141,7 +141,7 @@ class InstallPathWindow (InstallWindow):
 		    group = self.pixRadioButton(group, _(name), pixmap)
 		    self.buttonToObject[group] = obj
 		    buttons.append(group)
-		    box.pack_start (group, FALSE)
+		    box.pack_start (group, gtk.FALSE)
 
 		    if currentClass == obj:
 			group.set_active(1)
@@ -154,21 +154,22 @@ class InstallPathWindow (InstallWindow):
 	    if box:
 		tableRows = tableRows + 1
 
-	table = GtkTable(2, tableRows + 1)
+	table = gtk.Table(2, tableRows + 1)
 	row = 0
 
 	for (button, box, buttons) in self.topLevelButtonList:
-	    table.attach(button, 0, 3, row, row + 1, xoptions = FILL | EXPAND)
+	    table.attach(button, 0, 3, row, row + 1,
+                         xoptions = gtk.FILL | gtk.EXPAND)
 
-	    #table.attach(align, 2, 3, row, row + 1, xoptions = FALSE)
+	    #table.attach(align, 2, 3, row, row + 1, xoptions = gtk.FALSE)
 	    row = row + 1
 
 	    if box:
 		table.attach(box, 1, 3, row, row + 1)
 		row = row + 1
 
-	box = GtkVBox (FALSE, 5)
-	box.pack_start(table, FALSE)
+	box = gtk.VBox (gtk.FALSE, 5)
+	box.pack_start(table, gtk.FALSE)
         box.set_border_width (5)
 
         return box
diff --git a/iw/keyboard_gui.py b/iw/keyboard_gui.py
index a372a94ef..ae984807d 100644
--- a/iw/keyboard_gui.py
+++ b/iw/keyboard_gui.py
@@ -15,8 +15,8 @@ import isys
 import iutil
 import string
 import xkb
+import gtk
 from iw_gui import *
-from gtk import *
 from kbd import Keyboard
 from log import log
 from flags import flags
@@ -90,30 +90,29 @@ class KeyboardWindow (InstallWindow):
 		    self.layout = kbd.layout
 
 
-	box = GtkVBox(FALSE, 5)
-        hbox = GtkHBox(FALSE, 5)
+	box = gtk.VBox(gtk.FALSE, 5)
+        hbox = gtk.HBox(gtk.FALSE, 5)
         pix = self.ics.readPixmap("gnome-keyboard.png")
         if pix:
-            a = GtkAlignment()
+            a = gtk.Alignment(0.0, 0.0, 0.0, 0.0)
             a.add(pix)
-            a.set(0.0, 0.0, 0.0, 0.0)
-            hbox.pack_start(a, FALSE)
+            hbox.pack_start(a, gtk.FALSE)
 
-        label = GtkLabel(_("Which model keyboard is attached to the computer?"))
-        label.set_line_wrap(TRUE)
+        label = gtk.Label(_("Which model keyboard is attached to the computer?"))
+        label.set_line_wrap(gtk.TRUE)
         label.set_usize(350, -1)
-        hbox.pack_start(label, FALSE)
-        box.pack_start(hbox, FALSE)
+        hbox.pack_start(label, gtk.FALSE)
+        box.pack_start(hbox, gtk.FALSE)
 
 	def moveto(widget, *args):
             widget.moveto(widget.selection[0], 0, 0.5, 0.5)
 
-	box.pack_start(GtkLabel(_("Model")), FALSE)
-        sw = GtkScrolledWindow()
-        sw.set_policy(POLICY_AUTOMATIC, POLICY_AUTOMATIC)
-        self.modelList = GtkCList()
+	box.pack_start(gtk.Label(_("Model")), gtk.FALSE)
+        sw = gtk.ScrolledWindow()
+        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        self.modelList = gtk.CList(1)
 	self.modelList.freeze()
-        self.modelList.set_selection_mode(SELECTION_BROWSE)
+        self.modelList.set_selection_mode(gtk.SELECTION_BROWSE)
         for key, model in self.rules[0].items():
             loc = self.modelList.append((model,))
 	    self.modelList.set_row_data(loc, key)
@@ -122,18 +121,18 @@ class KeyboardWindow (InstallWindow):
         self.modelList.sort()
         self.modelList.connect("select_row", self.select_row)
         self.modelList.columns_autosize()
-        self.modelList.connect_after("draw", moveto)
+        self.modelList.connect_after("size-allocate", moveto)
 	self.modelList.thaw()
         sw.add(self.modelList)
-        sw.set_policy(POLICY_NEVER, POLICY_AUTOMATIC)
-        box.pack_start(sw, TRUE)
+        sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
+        box.pack_start(sw, gtk.TRUE)
 
-	box.pack_start(GtkLabel(_("Layout")), FALSE)
-        sw = GtkScrolledWindow()
-        sw.set_policy(POLICY_AUTOMATIC, POLICY_AUTOMATIC)
-        self.layoutList = GtkCList()
+	box.pack_start(gtk.Label(_("Layout")), gtk.FALSE)
+        sw = gtk.ScrolledWindow()
+        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        self.layoutList = gtk.CList(1)
 	self.layoutList.freeze()
-        self.layoutList.set_selection_mode(SELECTION_BROWSE)
+        self.layoutList.set_selection_mode(gtk.SELECTION_BROWSE)
         for key, layout in self.rules[1].items():
             loc = self.layoutList.append((layout,))
 	    self.layoutList.set_row_data(loc, key)
@@ -142,17 +141,17 @@ class KeyboardWindow (InstallWindow):
         self.layoutList.sort()
         self.layoutList.connect("select_row", self.select_row)
         self.layoutList.columns_autosize()
-	self.layoutList.connect_after("draw", moveto)
+	self.layoutList.connect_after("size-allocate", moveto)
 	self.layoutList.thaw()
         sw.add(self.layoutList)
-        sw.set_policy(POLICY_NEVER, POLICY_AUTOMATIC)
-	box.pack_start(sw, TRUE)
-
-	box.pack_start(GtkLabel(_("Dead Keys")), FALSE)
-        sw = GtkScrolledWindow()
-        sw.set_policy(POLICY_AUTOMATIC, POLICY_AUTOMATIC)
-        self.variantList = GtkCList()
-        self.variantList.set_selection_mode(SELECTION_BROWSE)
+        sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
+	box.pack_start(sw, gtk.TRUE)
+
+	box.pack_start(gtk.Label(_("Dead Keys")), gtk.FALSE)
+        sw = gtk.ScrolledWindow()
+        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        self.variantList = gtk.CList(1)
+        self.variantList.set_selection_mode(gtk.SELECTION_BROWSE)
 #  For now, the only variant is deadkeys, so we'll just handle that
 #  as special case, so the text can be less confusing.
 #        self.variantList.append(("None",))
@@ -170,14 +169,14 @@ class KeyboardWindow (InstallWindow):
         self.variantList.connect("select_row", self.select_row)
         self.variantList.columns_autosize()
         sw.add(self.variantList)
-	box.pack_start(sw, FALSE)
+	box.pack_start(sw, gtk.FALSE)
 
-        label = GtkLabel(_("Test your selection here:"))
+        label = gtk.Label(_("Test your selection here:"))
         label.set_alignment(0.0, 0.5)
-        box.pack_start(label, FALSE)
+        box.pack_start(label, gtk.FALSE)
 
-        entry = GtkEntry()
-        box.pack_start(entry, FALSE)
+        entry = gtk.Entry()
+        box.pack_start(entry, gtk.FALSE)
 
         entry.connect("grab-focus", self.setMap)
 
diff --git a/iw/language_gui.py b/iw/language_gui.py
index c0028e756..3c0cd91e8 100644
--- a/iw/language_gui.py
+++ b/iw/language_gui.py
@@ -11,7 +11,8 @@
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 
-from gtk import *
+import gobject
+import gtk
 from iw_gui import *
 from translate import _, N_
 
@@ -24,60 +25,82 @@ class LanguageWindow (InstallWindow):
 	InstallWindow.__init__ (self, ics)
 
     def getNext (self):
+        rc = self.listView.get_selection().get_selected()
+        if rc:
+            model, iter = rc
+            self.lang = self.listStore.get_value(iter, 1)
+
 	self.instLang.setRuntimeLanguage(self.lang)
 	self.ics.getICW().setLanguage (self.instLang.getLangNick(self.lang))
 
         return None
 
-    def select_row (self, clist, row, col, event):
-        if self.running:
-            self.lang = clist.get_row_data (clist.selection[0])
+    def listScroll(self, widget, *args):
+        # recenter the list
+        rc = self.listView.get_selection().get_selected()
+        if rc is None:
+            return
+        model, iter = rc
+        
+        path = self.listStore.get_path(iter)
+        col = self.listView.get_column(0)
+        self.listView.scroll_to_cell(path, col, gtk.TRUE, 0.5, 0.5)
 
     # LanguageWindow tag="lang"
     def getScreen (self, intf, instLang):
         self.running = 0
-        mainBox = GtkVBox (FALSE, 10)
+        mainBox = gtk.VBox (gtk.FALSE, 10)
 
-        hbox = GtkHBox(FALSE, 5)
+        hbox = gtk.HBox(gtk.FALSE, 5)
         pix = self.ics.readPixmap ("gnome-globe.png")
         if pix:
-            a = GtkAlignment ()
+            a = gtk.Alignment ()
             a.add (pix)
-            a.set (0.0, 0.0, 0.0, 0.0)
-            hbox.pack_start (a, FALSE)
+            hbox.pack_start (a, gtk.FALSE)
             
-        label = GtkLabel (_("What language would you like to use during the "
+        label = gtk.Label (_("What language would you like to use during the "
                          "installation process?"))
-        label.set_line_wrap (TRUE)
+        label.set_line_wrap (gtk.TRUE)
         label.set_usize(350, -1)
-        hbox.pack_start(label, FALSE)
+        hbox.pack_start(label, gtk.FALSE)
         
-        self.language = GtkCList ()
-        self.language.set_selection_mode (SELECTION_BROWSE)
-        self.language.connect ("select_row", self.select_row)
 	self.instLang = instLang
 
-        default = -1
-        n = 0
+        self.listStore = gtk.ListStore(gobject.TYPE_STRING,
+                                       gobject.TYPE_STRING)
+
         for locale in instLang.available():
-            row = self.language.append ((_(locale),))
-            self.language.set_row_data (row, locale)
+            iter = self.listStore.append()
+            self.listStore.set_value(iter, 0, _(locale))
+            self.listStore.set_value(iter, 1, locale)
+
+        self.listStore.set_sort_column_id(0, gtk.SORT_ASCENDING)
 
-            if locale == instLang.getCurrent():
-                self.lang = locale
-                default = n
-            n = n + 1
+        self.listView = gtk.TreeView(self.listStore)
+        col = gtk.TreeViewColumn(None, gtk.CellRendererText(), text=0)
+        self.listView.append_column(col)
+        self.listView.set_property("headers-visible", gtk.FALSE)
 
-        if default > 0:
-            self.language.select_row (default, 0)
+        current = instLang.getCurrent()
+        iter = self.listStore.get_iter_root()
+        next = 1
+        while next:
+            if self.listStore.get_value(iter, 1) == current:
+                selection = self.listView.get_selection()
+                selection.unselect_all()
+                selection.select_iter(iter)
+                break
+            next = self.listStore.iter_next(iter)
+        self.listView.connect("size-allocate", self.listScroll)
 
-        sw = GtkScrolledWindow ()
+        sw = gtk.ScrolledWindow ()
         sw.set_border_width (5)
-        sw.set_policy (POLICY_NEVER, POLICY_NEVER)
-        sw.add (self.language)
+        sw.set_shadow_type(gtk.SHADOW_IN)
+        sw.set_policy (gtk.POLICY_NEVER, gtk.POLICY_NEVER)
+        sw.add (self.listView)
         
-        mainBox.pack_start (hbox, FALSE, FALSE, 10)
-        mainBox.pack_start (sw, TRUE)
+        mainBox.pack_start (hbox, gtk.FALSE, gtk.FALSE, 10)
+        mainBox.pack_start (sw, gtk.TRUE, gtk.TRUE)
 
         self.running = 1
         
diff --git a/iw/language_support_gui.py b/iw/language_support_gui.py
index 8381f023f..76574548a 100644
--- a/iw/language_support_gui.py
+++ b/iw/language_support_gui.py
@@ -11,11 +11,9 @@
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 
-import gdkpixbuf
 import checklist
-from gtk import *
+import gtk
 from iw_gui import *
-from gnome.ui import *
 from flags import flags
 from translate import _, N_
 
@@ -59,9 +57,9 @@ class LanguageSupportWindow (InstallWindow):
 	
 	if len(list) == 0:
 	    list = [""]
-	    self.ics.setNextEnabled (FALSE)
+	    self.ics.setNextEnabled (gtk.FALSE)
 	else:
-	    self.ics.setNextEnabled (TRUE)
+	    self.ics.setNextEnabled (gtk.TRUE)
 
         self.defaultLang = self.combo.entry.get_text()
 	self.combo.set_popdown_strings(list)
@@ -80,16 +78,16 @@ class LanguageSupportWindow (InstallWindow):
         self.language._update_row (row)
         
     def select_all (self, data):
-        self.ics.setNextEnabled (TRUE)
+        self.ics.setNextEnabled (gtk.TRUE)
         for row in range(self.maxrows):
             (val, row_data, header) = self.language.get_row_data (row)
-            self.language.set_row_data (row, (TRUE, row_data, header)) 
+            self.language.set_row_data (row, (gtk.TRUE, row_data, header)) 
             self.language._update_row (row)
 
 	self.rebuild_combo_box()
 
     def reset (self, data):
-        self.ics.setNextEnabled (TRUE)
+        self.ics.setNextEnabled (gtk.TRUE)
 	list = []
 
         for row in range(self.maxrows):
@@ -135,32 +133,32 @@ class LanguageSupportWindow (InstallWindow):
         if self.origLangs == []:
             self.origLangs.append(self.defaultLang)
         
-        vbox = GtkVBox (FALSE, 10)
-        hbox = GtkHBox (FALSE)
+        vbox = gtk.VBox (gtk.FALSE, 10)
+        hbox = gtk.HBox (gtk.FALSE)
         
-        label = GtkLabel (_("Choose the default language for this system:   "))
-        hbox.pack_start (label, FALSE, 20)
+        label = gtk.Label (_("Choose the default language for this system:   "))
+        hbox.pack_start (label, gtk.FALSE, 20)
 
-        self.combo = GtkCombo ()
+        self.combo = gtk.Combo ()
 
-        hbox.pack_start (self.combo, FALSE, 20)
-        vbox.pack_start (hbox, FALSE, 50)
+        hbox.pack_start (self.combo, gtk.FALSE, 20)
+        vbox.pack_start (hbox, gtk.FALSE, 50)
 
-        sep = GtkHSeparator ()
-        vbox.pack_start (sep, FALSE, 15)
+        sep = gtk.HSeparator ()
+        vbox.pack_start (sep, gtk.FALSE, 15)
 
         if flags.reconfig:
-            label = GtkLabel (_("Currently installed languages:"))
+            label = gtk.Label (_("Currently installed languages:"))
         else:
-            label = GtkLabel (_("Choose additional languages you would "
+            label = gtk.Label (_("Choose additional languages you would "
                                 "like to use on this system:"))
 
         label.set_alignment (0.0, 0.5)
-        label.set_line_wrap (TRUE)
+        label.set_line_wrap (gtk.TRUE)
         label.set_usize(400, -1)
-        vbox.pack_start (label, FALSE)
+        vbox.pack_start (label, gtk.FALSE)
         
-        hbox = GtkHBox (FALSE)
+        hbox = gtk.HBox (gtk.FALSE)
 
         # langs we want to support
         self.language = checklist.CheckList(1)
@@ -175,7 +173,7 @@ class LanguageSupportWindow (InstallWindow):
 
         for locale in self.languages:
 	    if locale == self.defaultLang or (locale in self.supportedLangs):
-		self.language.append_row((locale, ""), TRUE)
+		self.language.append_row((locale, ""), gtk.TRUE)
 		list.append(locale)
 
 		if locale == self.defaultLang:
@@ -184,49 +182,49 @@ class LanguageSupportWindow (InstallWindow):
 		else:
 		    comboCurr = comboCurr + 1
 	    else:
-		self.language.append_row((locale, ""), FALSE)
+		self.language.append_row((locale, ""), gtk.FALSE)
 
             self.maxrows = self.maxrows + 1
 
-        self.language.connect_after ("draw", moveto, firstItem)
+        self.language.connect_after ("expose-event", moveto, firstItem)
             
         self.combo.set_popdown_strings (list)
         self.combo.list.select_item(sel)
-        self.combo.entry.set_editable(FALSE)
+        self.combo.entry.set_editable(gtk.FALSE)
 
-        sw = GtkScrolledWindow ()
+        sw = gtk.ScrolledWindow ()
         sw.set_border_width (5)
-        sw.set_policy (POLICY_NEVER, POLICY_AUTOMATIC)
+        sw.set_policy (gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
         sw.add (self.language)
 
-        vbox2 = GtkVBox (FALSE, 12)
+        vbox2 = gtk.VBox (gtk.FALSE, 12)
 
-        all_button = GtkButton (_("Select all"))
+        all_button = gtk.Button (_("Select all"))
         all_button.set_usize(160, -1)
         all_button.connect ('clicked', self.select_all)
-        a1 = GtkAlignment (0.5, 0.5)
+        a1 = gtk.Alignment (0.5, 0.5)
         a1.add (all_button)
 
-        reset_button = GtkButton (_("Reset"))
+        reset_button = gtk.Button (_("Reset"))
         reset_button.set_usize(160, -1)
         reset_button.connect ('clicked', self.reset)
-        a2 = GtkAlignment (0.5, 0.5)
+        a2 = gtk.Alignment (0.5, 0.5)
         a2.add (reset_button)
 
-        vbox2.pack_start (a1, FALSE, 10)
-        vbox2.pack_start (a2, FALSE)
-        hbox.pack_start (sw, TRUE, 10)
-        hbox.pack_start (vbox2, FALSE, 10)
-        vbox.pack_start (hbox, TRUE)
+        vbox2.pack_start (a1, gtk.FALSE, 10)
+        vbox2.pack_start (a2, 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 = GtkAlignment (0.0, 0.0)
-        button = GtkButton (_("Select as default"))
+        alignment = gtk.Alignment (0.0, 0.0)
+        button = gtk.Button (_("Select as default"))
         alignment.add (button)
 
         # in reconfig mode make some widgets unchangable
         if flags.reconfig:
-            self.language.set_sensitive(FALSE)
-            all_button.set_sensitive(FALSE)
+            self.language.set_sensitive(gtk.FALSE)
+            all_button.set_sensitive(gtk.FALSE)
 
         return vbox
diff --git a/iw/mouse_gui.py b/iw/mouse_gui.py
index 0d4ccb0c0..aad1a0db6 100644
--- a/iw/mouse_gui.py
+++ b/iw/mouse_gui.py
@@ -12,9 +12,9 @@
 #
 
 import tree
-from gtk import *
+import gtk
+import string
 from iw_gui import *
-from string import *
 from re import *
 from translate import _, N_
 from flags import flags
@@ -34,15 +34,15 @@ class MouseWindow (InstallWindow):
         if (list == ()): return
         
         if (len (list) > 1 and isinstance (list[1], type (()))): 
-	    leaf = FALSE
+	    leaf = gtk.FALSE
         else:
-	    leaf = TRUE
+	    leaf = gtk.TRUE
     
         if isinstance (list[0], type (())):
             self.build_ctree (list[0], prev_node, None)
             self.build_ctree (list[1:], cur_parent, None)
         else:
-            index = find (list[0], " - ")
+            index = string.find (list[0], " - ")
             if index != -1:
                 list_item = list[0][0:index] + list[0][index+2:]
             else:
@@ -98,61 +98,37 @@ class MouseWindow (InstallWindow):
         return None
     
     def selectDeviceType(self, *args):
-        if len(self.locList.selection) == 0:
-            self.ics.setNextEnabled (FALSE)
-        else:
-            self.ics.setNextEnabled (TRUE)
+	self.ics.setNextEnabled (gtk.TRUE)
 
     def selectMouseType (self, widget, node, *args):
         if not node.is_leaf:
 	    self.locList.unselect_all ()
-	    self.locList.set_sensitive (FALSE)
-            self.emulate3.set_sensitive (FALSE)
-            self.ics.setNextEnabled (FALSE)
+	    self.locList.set_sensitive (gtk.FALSE)
+            self.emulate3.set_sensitive (gtk.FALSE)
+            self.ics.setNextEnabled (gtk.FALSE)
 	    return
 
 	cur = self.getCurrentKey()
 	if (not self.availableMice.has_key(cur)):
-            self.ics.setNextEnabled (FALSE)
+            self.ics.setNextEnabled (gtk.FALSE)
 	    return
 
-        self.emulate3.set_sensitive (TRUE)
+        self.emulate3.set_sensitive (gtk.TRUE)
 	(gpm, xdev, device, emulate, shortname) = self.availableMice[cur]
         self.emulate3.set_active (emulate)
 	if device == "ttyS":
 	    if (self.serialDevice):
 		self.locList.select_row(int(self.serialDevice[4]), 1)
-		self.ics.setNextEnabled (TRUE)
+		self.ics.setNextEnabled (gtk.TRUE)
 	    else:
 		self.locList.unselect_all()
-		self.ics.setNextEnabled (FALSE)
+		self.ics.setNextEnabled (gtk.FALSE)
 
-	    self.locList.set_sensitive (TRUE)
+	    self.locList.set_sensitive (gtk.TRUE)
 	else:
 	    self.locList.unselect_all()
-	    self.locList.set_sensitive(FALSE)
-	    self.ics.setNextEnabled (TRUE)
-
-    def reset (self, *args):
-        self.selectMouseInTree(self.mouse.get_Orig())
-
-    def selectMouseInTree(self, mouse):
-        (currMouse, emulate3) = mouse
-
-	splitv = string.split (currMouse, " - ", 1)
-	nodes = self.ctree.base_nodes ()
-        # do a simple search on the root nodes, since leaf reduction creates
-        # a special case
-        found = 0
-	for x in nodes:
-            if self.ctree.get_node_info (x)[0] == "%s %s" % tuple (splitv):
-                found = 1
-                self.ctree.select (x)
-                break
-        if not found:
-            self.selectMouse (nodes, splitv)
-            
-        self.emulate3.set_active (emulate3)
+	    self.locList.set_sensitive(gtk.FALSE)
+	    self.ics.setNextEnabled (gtk.TRUE)
 
     # MouseWindow tag="mouse"
     def getScreen (self, mouse):
@@ -164,34 +140,35 @@ class MouseWindow (InstallWindow):
         sorted_mice_keys.sort ()
 
         currentDev = mouse.getDevice ()
+	(currentMouse, emulate3) = mouse.get ()
 
 	deviceList = [ (_("/dev/ttyS0 (COM1 under DOS)"), "ttyS0" ),
     		       (_("/dev/ttyS1 (COM2 under DOS)"), "ttyS1" ),
 		       (_("/dev/ttyS2 (COM3 under DOS)"), "ttyS2" ),
 		       (_("/dev/ttyS3 (COM4 under DOS)"), "ttyS3" ) ]
 
-        self.emulate3 = GtkCheckButton (_("Emulate 3 Buttons"))
-        box = GtkVBox (FALSE)
+        self.emulate3 = gtk.CheckButton (_("Emulate 3 Buttons"))
+        box = gtk.VBox (gtk.FALSE)
         
-        sw = GtkScrolledWindow ()
+        sw = gtk.ScrolledWindow ()
         sw.set_border_width (5)
-        sw.set_policy (POLICY_AUTOMATIC, POLICY_AUTOMATIC)
-        self.locList = GtkCList (2, (_("Port"), _("Device")))
-        self.locList.set_selection_mode (SELECTION_SINGLE)
+        sw.set_policy (gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        self.locList = gtk.CList (2, (_("Port"), _("Device")))
+        self.locList.set_selection_mode (gtk.SELECTION_SINGLE)
 
 	for (descrip, dev) in deviceList:
 	    self.locList.append((dev, descrip))
 
         self.locList.columns_autosize ()
-        self.locList.set_column_resizeable (0, FALSE)
+        self.locList.set_column_resizeable (0, gtk.FALSE)
         self.locList.column_title_passive (0)
         self.locList.column_title_passive (1)
         self.locList.set_border_width (5)
 
-        sw = GtkScrolledWindow ()
+        sw = gtk.ScrolledWindow ()
         sw.set_border_width (5)
-        sw.set_policy (POLICY_AUTOMATIC, POLICY_AUTOMATIC)
-        self.ctree = GtkCTree (1)
+        sw.set_policy (gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        self.ctree = gtk.CTree (1, 0)
 
         groups = ()
         for x in sorted_mice_keys:
@@ -199,15 +176,14 @@ class MouseWindow (InstallWindow):
         groups = self.reduce_leafs (groups)
 
         self.build_ctree (groups)
-        self.ctree.set_selection_mode (SELECTION_BROWSE)
+        self.ctree.set_selection_mode (gtk.SELECTION_BROWSE)
         self.ctree.columns_autosize ()
         self.ctree.connect ("tree_select_row", self.selectMouseType)
         self.locList.connect ("select_row", self.selectDeviceType)
-        self.locList.connect ("unselect_row", self.selectDeviceType)
-	self.locList.set_sensitive(FALSE)
+	self.locList.set_sensitive(gtk.FALSE)
 
-        self.ctree.set_expander_style(CTREE_EXPANDER_TRIANGLE)
-        self.ctree.set_line_style(CTREE_LINES_NONE)
+        self.ctree.set_expander_style(gtk.CTREE_EXPANDER_TRIANGLE)
+        self.ctree.set_line_style(gtk.CTREE_LINES_NONE)
 
         sw.add (self.ctree)
 	
@@ -218,32 +194,43 @@ class MouseWindow (InstallWindow):
 	    self.locList.unselect_all();
 	    self.serialDevice = None
 
-        self.selectMouseInTree(mouse.get())
-        
-        lowerHBox = GtkHBox(FALSE, 5)
-        lowerHBox.pack_start(self.emulate3)
+	splitv = string.split (currentMouse, " - ", 1)
+	nodes = self.ctree.base_nodes ()
+        # do a simple search on the root nodes, since leaf reduction creates
+        # a special case
+        found = 0
+	for x in nodes:
+            if self.ctree.get_node_info (x)[0] == "%s %s" % tuple (splitv):
+                found = 1
+                self.ctree.select (x)
+                break
+        if not found:
+            self.selectMouse (nodes, splitv)
+
+        self.emulate3.set_active (emulate3)
 
-        resetButton = GtkButton(_("Reset to default"))
-        resetButton.connect("clicked", self.reset)
-        lowerHBox.pack_start(resetButton)
+        align = gtk.Alignment ()
+        align.add (self.emulate3)
+        align.set_border_width (5)
 
-        hbox = GtkHBox(FALSE, 5)
+        hbox = gtk.HBox(gtk.FALSE, 5)
 
         pix = self.ics.readPixmap ("gnome-mouse.png")
         if pix:
-            a = GtkAlignment ()
+            a = gtk.Alignment ()
             a.add (pix)
             a.set (0.0, 0.0, 0.0, 0.0)
-            hbox.pack_start (a, FALSE)
+            hbox.pack_start (a, gtk.FALSE)
 
-        label = GtkLabel (_("Which model mouse is attached to the computer?"))
-        label.set_line_wrap (TRUE)
+        label = gtk.Label (_("Which model mouse is attached to the computer?"))
+        label.set_line_wrap (gtk.TRUE)
         label.set_usize(350, -1)
-        hbox.pack_start(label, FALSE)
-        box.pack_start(hbox, FALSE)
+        hbox.pack_start(label, gtk.FALSE)
+        box.pack_start(hbox, gtk.FALSE)
             
         box.pack_start (sw)
-        box.pack_start (self.locList, FALSE)
-        box.pack_start(lowerHBox, FALSE)
+        box.pack_start (self.locList, gtk.FALSE)
+        box.pack_start (align, gtk.FALSE)
 
         return box
+
diff --git a/iw/network_gui.py b/iw/network_gui.py
index 95e32102b..62ba61448 100644
--- a/iw/network_gui.py
+++ b/iw/network_gui.py
@@ -11,7 +11,7 @@
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 
-from gtk import *
+import gtk
 from iw_gui import *
 from isys import *
 from translate import _, N_
@@ -122,7 +122,7 @@ class NetworkWindow(InstallWindow):
         ip = ip.get_text()
         dots = 0
         valid_list = ("1", "2", "3", "4", "5", "6", "7", "8" , "9", "0", ".")
-        valid_ip = TRUE
+        valid_ip = gtk.TRUE
 
         for x in ip:
             if x == '.':
@@ -130,10 +130,10 @@ class NetworkWindow(InstallWindow):
             #-if there's an invalid char in the widget, don't calculate netmask
             if x not in valid_list:
                 print "found invalid char"
-                valid_ip = FALSE
+                valid_ip = gtk.FALSE
         if dots != 3: return
 
-        if valid_ip == TRUE:
+        if valid_ip == gtk.TRUE:
             try:
                 new_nm = inet_calcNetmask(ip)
                 if(new_nm != nm.get_text()):
@@ -161,43 +161,43 @@ class NetworkWindow(InstallWindow):
 
     # NetworkWindow tag="netconf"
     def getScreen(self, network):
-        box = GtkVBox()
+        box = gtk.VBox()
         box.set_border_width(5)
 	self.network = network
         
-        notebook = GtkNotebook()
+        notebook = gtk.Notebook()
         devs = self.network.available()
         if not devs: return None
 
         devs.keys().sort()
         num = 0
         for i in devs.keys():
-            devbox = GtkVBox()
-            align = GtkAlignment()
-            DHCPcb = GtkCheckButton(_("Configure using DHCP"))
+            devbox = gtk.VBox()
+            align = gtk.Alignment()
+            DHCPcb = gtk.CheckButton(_("Configure using DHCP"))
 
             align.add(DHCPcb)
-            devbox.pack_start(align, FALSE)
+            devbox.pack_start(align, gtk.FALSE)
 
-            align = GtkAlignment()
-            bootcb = GtkCheckButton(_("Activate on boot"))
+            align = gtk.Alignment()
+            bootcb = gtk.CheckButton(_("Activate on boot"))
             onboot = devs[i].get("onboot")
 	    bootcb.connect("toggled", self.onBootToggled, devs[i])
             bootcb.set_active((num == 0 and not onboot)
                                or onboot == "yes")
             align.add(bootcb)
 
-            devbox.pack_start(align, FALSE)
+            devbox.pack_start(align, gtk.FALSE)
 
-            devbox.pack_start(GtkHSeparator(), FALSE, padding=3)
+            devbox.pack_start(gtk.HSeparator(), gtk.FALSE, padding=3)
 
             options = [(_("IP Address"), "ipaddr"),
                        (_("Netmask"),    "netmask"),
                        (_("Network"),    "network"),
                        (_("Broadcast"),  "broadcast")]
-            ipTable = GtkTable(len(options), 2)
+            ipTable = gtk.Table(len(options), 2)
             # this is the iptable used for DNS, et. al
-            self.ipTable = GtkTable(len(options), 2)
+            self.ipTable = gtk.Table(len(options), 2)
 
             DHCPcb.connect("toggled", self.DHCPtoggled, (devs[i], ipTable))
             bootproto = devs[i].get("bootproto")
@@ -210,17 +210,17 @@ class NetworkWindow(InstallWindow):
             forward = lambda widget, box=box: box.focus(DIR_TAB_FORWARD)
 
             for t in range(len(options)):
-                label = GtkLabel("%s:" %(options[t][0],))
+                label = gtk.Label("%s:" %(options[t][0],))
                 label.set_alignment(0.0, 0.5)
-                ipTable.attach(label, 0, 1, t, t+1, FILL, 0, 10)
-                entry = GtkEntry(15)
+                ipTable.attach(label, 0, 1, t, t+1, gtk.FILL, 0, 10)
+                entry = gtk.Entry(15)
           # entry.set_usize(gdk_char_width(entry.get_style().font, '0')*15, -1)
                 entry.set_usize(7 * 15, -1)
                 entry.connect("activate", forward)
 
                 entry.set_text(devs[i].get(options[t][1]))
                 options[t] = entry
-                ipTable.attach(entry, 1, 2, t, t+1, 0, FILL|EXPAND)
+                ipTable.attach(entry, 1, 2, t, t+1, 0, gtk.FILL|gtk.EXPAND)
 
             for t in range(len(options)):
                 if t == 0 or t == 1:
@@ -240,31 +240,31 @@ class NetworkWindow(InstallWindow):
             options[2].connect("focus_out_event", self.focusOutNW, devs[i])
             options[3].connect("focus_out_event", self.focusOutBC, devs[i])
 
-            devbox.pack_start(ipTable, FALSE, FALSE, 5)
+            devbox.pack_start(ipTable, gtk.FALSE, gtk.FALSE, 5)
 
             devbox.show_all()
-            notebook.append_page(devbox, GtkLabel(i))
+            notebook.append_page(devbox, gtk.Label(i))
 
-        box.pack_start(notebook, FALSE)
-        box.pack_start(GtkHSeparator(), FALSE, padding=10)
+        box.pack_start(notebook, gtk.FALSE)
+        box.pack_start(gtk.HSeparator(), gtk.FALSE, padding=10)
 
         options = [_("Hostname"), _("Gateway"), _("Primary DNS"),
                    _("Secondary DNS"), _("Ternary DNS")]
 
         for i in range(len(options)):
-            label = GtkLabel("%s:" %(options[i],))
+            label = gtk.Label("%s:" %(options[i],))
             label.set_alignment(0.0, 0.0)
-            self.ipTable.attach(label, 0, 1, i, i+1, FILL, 0, 10)
+            self.ipTable.attach(label, 0, 1, i, i+1, gtk.FILL, 0, 10)
             if i == 0:
-                options[i] = GtkEntry()
+                options[i] = gtk.Entry()
                 options[i].set_usize(7 * 30, -1)
             else:
-                options[i] = GtkEntry(15)
+                options[i] = gtk.Entry(15)
                 options[i].set_usize(7 * 15, -1)
             options[i].connect("activate", forward)
-            align = GtkAlignment(0, 0.5)
+            align = gtk.Alignment(0, 0.5)
             align.add(options[i])
-            self.ipTable.attach(align, 1, 2, i, i+1, FILL, 0)
+            self.ipTable.attach(align, 1, 2, i, i+1, gtk.FILL, 0)
         self.ipTable.set_row_spacing(0, 5)
 
         self.hostname = options[0]
@@ -284,7 +284,7 @@ class NetworkWindow(InstallWindow):
 
         self.ns3 = options[4]
         self.ns3.set_text(self.network.ternaryNS)
-        box.pack_start(self.ipTable, FALSE, FALSE, 5)
+        box.pack_start(self.ipTable, gtk.FALSE, gtk.FALSE, 5)
 
         return box
 
diff --git a/iw/package_gui.py b/iw/package_gui.py
index 3b6cc4029..af994e9f5 100644
--- a/iw/package_gui.py
+++ b/iw/package_gui.py
@@ -16,9 +16,7 @@ import gui
 import string
 import sys
 import checklist
-import gdkpixbuf
-from gtk import *
-from gnome.ui import *
+import gtk
 from iw_gui import *
 from string import *
 from thread import *
@@ -44,16 +42,16 @@ class IndividualPackageSelectionWindow (InstallWindow):
     def __init__ (self, ics):
 	InstallWindow.__init__ (self, ics)
         self.ics = ics
-        self.ics.setHelpEnabled (FALSE)
+        self.ics.setHelpEnabled (gtk.FALSE)
         self.DIR = 0
         self.DIR_UP = 1
         self.RPM = 2
         self.rownum = 0
         self.maxrows = 0
-        self.updatingIcons = FALSE
+        self.updatingIcons = gtk.FALSE
 
     def getPrev (self):
-        self.ics.setHelpEnabled (TRUE)
+        self.ics.setHelpEnabled (gtk.TRUE)
         return None
     
     def build_tree (self, x):
@@ -75,15 +73,17 @@ class IndividualPackageSelectionWindow (InstallWindow):
     def build_ctree (self, list, cur_parent = None, prev_node = None, path = ""):
         if (list == ()): return
         
-        if (len (list) > 1 and isinstance (list[1], type (()))): leaf = FALSE
-        else: leaf = TRUE
+        if (len (list) > 1 and isinstance (list[1], type (()))): leaf = gtk.FALSE
+        else: leaf = gtk.TRUE
     
         if isinstance (list[0], type (())):
             self.build_ctree (list[0], prev_node, None, self.ctree.node_get_row_data (prev_node))
             self.build_ctree (list[1:], cur_parent, None, path)
         else:
+##             node = self.ctree.insert_node (cur_parent, None, (list[0],), 2,
+##                                            self.closed_p, self.closed_b, self.open_p, self.open_b, leaf)
             node = self.ctree.insert_node (cur_parent, None, (list[0],), 2,
-                                           self.closed_p, self.closed_b, self.open_p, self.open_b, leaf)
+                                           is_leaf=leaf)
             cur_path = path + "/" + list[0]
             self.ctree.node_set_row_data (node, cur_path)
             self.build_ctree (list[1:], cur_parent, node, path)
@@ -153,10 +153,10 @@ class IndividualPackageSelectionWindow (InstallWindow):
              (val, row_data, header) = self.packageList.get_row_data (i)
              if select_all == 1:
                  header.select ()
-                 self.packageList.set_row_data (i, (TRUE, row_data, header)) 
+                 self.packageList.set_row_data (i, (gtk.TRUE, row_data, header)) 
              elif select_all == 0:
                  header.unselect()
-                 self.packageList.set_row_data (i, (FALSE, row_data, header)) 
+                 self.packageList.set_row_data (i, (gtk.FALSE, row_data, header)) 
              self.packageList._update_row (i)
 
         self.updateSize()
@@ -241,10 +241,10 @@ class IndividualPackageSelectionWindow (InstallWindow):
 
                 dirSize = dirSize/1000000
                 if dirSize > 1:
-                    self.rownum = self.packageList.append_row((dirName, "%s" % dirSize), TRUE, dirDesc)
+                    self.rownum = self.packageList.append_row((dirName, "%s" % dirSize), gtk.TRUE, dirDesc)
                 else:
                     row = [ "", dirName, "1"]
-                    self.rownum = self.packageList.append_row((dirName, "1"), TRUE, dirDesc)
+                    self.rownum = self.packageList.append_row((dirName, "1"), gtk.TRUE, dirDesc)
 
                 if header.isSelected():
                     self.packageList.set_row_data(self.rownum, (1, dirDesc, header))
@@ -262,12 +262,12 @@ class IndividualPackageSelectionWindow (InstallWindow):
                 self.sort_list (args, 0)
 
             self.packageList.column_titles_active ()
-            self.selectAllButton.set_sensitive (TRUE)
-            self.unselectAllButton.set_sensitive (TRUE)
+            self.selectAllButton.set_sensitive (gtk.TRUE)
+            self.unselectAllButton.set_sensitive (gtk.TRUE)
             
         except:
-            self.selectAllButton.set_sensitive (FALSE)
-            self.unselectAllButton.set_sensitive (FALSE)
+            self.selectAllButton.set_sensitive (gtk.FALSE)
+            self.unselectAllButton.set_sensitive (gtk.FALSE)
             pass
 
         self.packageList.thaw ()
@@ -316,10 +316,10 @@ class IndividualPackageSelectionWindow (InstallWindow):
                     desc = header[rpm.RPMTAG_DESCRIPTION]
                     
                     if header.isSelected():
-                        self.rownum = self.packageList.append_row((name, "%s" %size), TRUE, desc)
+                        self.rownum = self.packageList.append_row((name, "%s" %size), gtk.TRUE, desc)
                         self.packageList.set_row_data(self.rownum, (1, desc, header))
                     else:
-                        self.rownum = self.packageList.append_row((name, "%s" %size), FALSE, desc)
+                        self.rownum = self.packageList.append_row((name, "%s" %size), gtk.FALSE, desc)
                         self.packageList.set_row_data(self.rownum, (0, desc, header))
             self.packageList.thaw()
             
@@ -330,28 +330,24 @@ class IndividualPackageSelectionWindow (InstallWindow):
         self.pkgs = hdList
         
         self.path_mapping = {}
-        self.ctree = GtkCTree()
-        self.ctree.set_selection_mode (SELECTION_BROWSE)
-        self.ctree.set_expander_style(CTREE_EXPANDER_TRIANGLE)
-        self.ctree.set_line_style(CTREE_LINES_NONE)
+        self.ctree = gtk.CTree()
+        self.ctree.set_selection_mode (gtk.SELECTION_BROWSE)
 
-        self.ctreeAllPkgs = GtkCTree()
-        self.ctreeAllPkgs.set_selection_mode (SELECTION_BROWSE)
-        self.ctreeAllPkgs.set_expander_style(CTREE_EXPANDER_TRIANGLE)
-        self.ctreeAllPkgs.set_line_style(CTREE_LINES_NONE)
+        self.ctreeAllPkgs = gtk.CTree()
+        self.ctreeAllPkgs.set_selection_mode (gtk.SELECTION_BROWSE)
 
         # Kludge to get around CTree s extremely broken focus behavior
         # self.ctree.unset_flags (CAN_FOCUS)     
 
-        if (not self.__dict__.has_key ("open_p")):
-            fn = self.ics.findPixmap("directory-open.png")
-            p = gdkpixbuf.new_from_file (fn)
-            if p:
-                self.open_p, self.open_b = p.render_pixmap_and_mask()
-            fn = self.ics.findPixmap("directory-closed.png")
-            p = gdkpixbuf.new_from_file (fn)
-            if p:
-                self.closed_p, self.closed_b = p.render_pixmap_and_mask()
+##         if (not self.__dict__.has_key ("open_p")):
+##             fn = self.ics.findPixmap("directory-open.png")
+##             p = gdkpixbuf.new_from_file (fn)
+##             if p:
+##                 self.open_p, self.open_b = p.render_pixmap_and_mask()
+##             fn = self.ics.findPixmap("directory-closed.png")
+##             p = gdkpixbuf.new_from_file (fn)
+##             if p:
+##                 self.closed_p, self.closed_b = p.render_pixmap_and_mask()
             
         groups = {}
 
@@ -393,37 +389,33 @@ class IndividualPackageSelectionWindow (InstallWindow):
         self.ctree.thaw ()
 
         self.ctree.connect ("tree_select_row", self.select)
-        self.sw = GtkScrolledWindow ()
-        self.sw.set_policy (POLICY_NEVER, POLICY_AUTOMATIC)
-
-        # Set the style for the tree
-        self.ctree.set_expander_style(CTREE_EXPANDER_TRIANGLE)
-        self.ctree.set_line_style(CTREE_LINES_NONE)
+        self.sw = gtk.ScrolledWindow ()
+        self.sw.set_policy (gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 
         self.sw.add(self.ctree)
-        packageHBox = GtkHBox()
+        packageHBox = gtk.HBox()
 
-        self.leftVBox = GtkVBox(FALSE)
-        optionHBox = GtkHBox()
+        self.leftVBox = gtk.VBox(gtk.FALSE)
+        optionHBox = gtk.HBox()
 
-        self.treeRadio = GtkRadioButton(None, (_("Tree View")))
+        self.treeRadio = gtk.RadioButton(None, (_("Tree View")))
         self.treeRadio.connect("clicked", self.changePkgView)
-        self.flatRadio = GtkRadioButton(self.treeRadio, (_("Flat View")))
+        self.flatRadio = gtk.RadioButton(self.treeRadio, (_("Flat View")))
 
         optionHBox.pack_start(self.treeRadio)
         optionHBox.pack_start(self.flatRadio)
         
-        self.leftVBox.pack_start(optionHBox, FALSE)
-        self.leftVBox.pack_start(self.sw, TRUE)
-        packageHBox.pack_start(self.leftVBox, FALSE)
+        self.leftVBox.pack_start(optionHBox, gtk.FALSE)
+        self.leftVBox.pack_start(self.sw, gtk.TRUE)
+        packageHBox.pack_start(self.leftVBox, gtk.FALSE)
 
         self.packageList = checklist.CheckList(2)
 
         self.sortType = "Package"
         self.packageList.set_column_title (1, (_("Package")))
-        self.packageList.set_column_auto_resize (1, TRUE)
+        self.packageList.set_column_auto_resize (1, gtk.TRUE)
         self.packageList.set_column_title (2, (_("Size (MB)")))
-        self.packageList.set_column_auto_resize (2, TRUE)
+        self.packageList.set_column_auto_resize (2, gtk.TRUE)
         self.packageList.column_titles_show ()
 
         self.packageList.set_column_min_width(0, 16)
@@ -434,9 +426,9 @@ class IndividualPackageSelectionWindow (InstallWindow):
         self.packageList.connect ('button_press_event', self.button_press)
         self.packageList.connect ("key_press_event", self.key_press_cb)
 
-        self.packageListSW = GtkScrolledWindow ()
+        self.packageListSW = gtk.ScrolledWindow ()
         self.packageListSW.set_border_width (5)
-        self.packageListSW.set_policy (POLICY_AUTOMATIC, POLICY_AUTOMATIC)
+        self.packageListSW.set_policy (gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
         self.packageListSW.add(self.packageList)
 
         self.packageListVAdj = self.packageListSW.get_vadjustment ()
@@ -446,47 +438,47 @@ class IndividualPackageSelectionWindow (InstallWindow):
 
         packageHBox.pack_start (self.packageListSW)
 
-        descVBox = GtkVBox ()        
-        descVBox.pack_start (GtkHSeparator (), FALSE, padding=2)
+        descVBox = gtk.VBox ()        
+        descVBox.pack_start (gtk.HSeparator (), gtk.FALSE, padding=2)
 
-        hbox = GtkHBox ()
-        bb = GtkHButtonBox ()
+        hbox = gtk.HBox ()
+        bb = gtk.HButtonBox ()
         bb.set_layout (BUTTONBOX_END)
 
-        self.totalSizeLabel = GtkLabel (_("Total size: "))
-        hbox.pack_start (self.totalSizeLabel, FALSE, FALSE, 0)
+        self.totalSizeLabel = gtk.Label (_("Total size: "))
+        hbox.pack_start (self.totalSizeLabel, gtk.FALSE, gtk.FALSE, 0)
 
-        self.selectAllButton = GtkButton (_("Select all in group"))
-        bb.pack_start (self.selectAllButton, FALSE)
+        self.selectAllButton = gtk.Button (_("Select all in group"))
+        bb.pack_start (self.selectAllButton, gtk.FALSE)
         self.selectAllButton.connect ('clicked', self.select_all, 1)
 
-        self.unselectAllButton = GtkButton(_("Unselect all in group"))
-        bb.pack_start(self.unselectAllButton, FALSE)
+        self.unselectAllButton = gtk.Button(_("Unselect all in group"))
+        bb.pack_start(self.unselectAllButton, gtk.FALSE)
         self.unselectAllButton.connect ('clicked', self.select_all, 0)
         
         hbox.pack_start (bb)
 
-        self.selectAllButton.set_sensitive (FALSE)
-        self.unselectAllButton.set_sensitive (FALSE)
+        self.selectAllButton.set_sensitive (gtk.FALSE)
+        self.unselectAllButton.set_sensitive (gtk.FALSE)
 
-        descVBox.pack_start (hbox, FALSE)
+        descVBox.pack_start (hbox, gtk.FALSE)
 
-        descSW = GtkScrolledWindow ()
+        descSW = gtk.ScrolledWindow ()
         descSW.set_border_width (5)
-        descSW.set_policy (POLICY_AUTOMATIC, POLICY_AUTOMATIC)
+        descSW.set_policy (gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
-        self.packageDesc = GtkText ()
-        self.packageDesc.set_word_wrap (TRUE)
-        self.packageDesc.set_line_wrap (TRUE)
-        self.packageDesc.set_editable (FALSE)
+        self.packageDesc = gtk.Text ()
+        self.packageDesc.set_word_wrap (gtk.TRUE)
+        self.packageDesc.set_line_wrap (gtk.TRUE)
+        self.packageDesc.set_editable (gtk.FALSE)
         descSW.add (self.packageDesc)
         descSW.set_usize (-1, 100)
 
         descVBox.pack_start (descSW)
 
-        vbox = GtkVBox ()
+        vbox = gtk.VBox ()
         vbox.pack_start (packageHBox)
-        vbox.pack_start (descVBox, FALSE)
+        vbox.pack_start (descVBox, gtk.FALSE)
 
 	self.updateSize()
 
@@ -500,7 +492,7 @@ class PackageSelectionWindow (InstallWindow):
 	InstallWindow.__init__ (self, ics)
         self.ics = ics
         self.ics.setNextEnabled (1)
-        self.files_found = "FALSE"
+        self.files_found = "gtk.FALSE"
         
     def getPrev (self):
 	self.comps.setSelectionState(self.origSelection)
@@ -533,10 +525,10 @@ class PackageSelectionWindow (InstallWindow):
 
 	self.origSelection = self.comps.getSelectionState()
             
-        sw = GtkScrolledWindow ()
-        sw.set_policy (POLICY_AUTOMATIC, POLICY_AUTOMATIC)
+        sw = gtk.ScrolledWindow ()
+        sw.set_policy (gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
-        box = GtkVBox (FALSE, 2)
+        box = gtk.VBox (gtk.FALSE, 2)
 
         self.checkButtons = []
         for comp in self.comps:
@@ -550,23 +542,23 @@ class PackageSelectionWindow (InstallWindow):
                 checkButton = None
                 pix = self.ics.readPixmap (pixname)
                 if pix:
-                    hbox = GtkHBox (FALSE, 5)
-                    hbox.pack_start (pix, FALSE, FALSE, 0)
-                    label = GtkLabel (_(comp.name))
+                    hbox = gtk.HBox (gtk.FALSE, 5)
+                    hbox.pack_start (pix, gtk.FALSE, gtk.FALSE, 0)
+                    label = gtk.Label (_(comp.name))
                     label.set_alignment (0.0, 0.5)
-                    hbox.pack_start (label, TRUE, TRUE, 0)
-                    checkButton = GtkCheckButton ()
+                    hbox.pack_start (label, gtk.TRUE, gtk.TRUE, 0)
+                    checkButton = gtk.CheckButton ()
                     checkButton.add (hbox)
                 else:
-                    checkButton = GtkCheckButton (comp.name)
+                    checkButton = gtk.CheckButton (comp.name)
 
                 checkButton.set_active (comp.isSelected(justManual = 1))
                 checkButton.connect('toggled', self.componentToggled, comp)
                 self.checkButtons.append ((checkButton, comp))
                 box.pack_start (checkButton)
 
-        wrapper = GtkVBox (FALSE, 0)
-        wrapper.pack_start (box, FALSE)
+        wrapper = gtk.VBox (gtk.FALSE, 0)
+        wrapper.pack_start (box, gtk.FALSE)
         
         sw.add_with_viewport (wrapper)
         viewport = sw.children()[0]
@@ -574,21 +566,21 @@ class PackageSelectionWindow (InstallWindow):
         box.set_focus_hadjustment(sw.get_hadjustment ())
         box.set_focus_vadjustment(sw.get_vadjustment ())
 
-        hbox = GtkHBox (FALSE, 5)
+        hbox = gtk.HBox (gtk.FALSE, 5)
 
-        self.individualPackages = GtkCheckButton (
+        self.individualPackages = gtk.CheckButton (
 		_("Select individual packages"))
         self.individualPackages.set_active (
 		not dispatch.stepInSkipList("indivpackage"))
-        hbox.pack_start (self.individualPackages, FALSE)
+        hbox.pack_start (self.individualPackages, gtk.FALSE)
 
-        self.sizelabel = GtkLabel ("")
+        self.sizelabel = gtk.Label ("")
         self.setSize()
-        hbox.pack_start (self.sizelabel, TRUE)
+        hbox.pack_start (self.sizelabel, gtk.TRUE)
         
-        vbox = GtkVBox (FALSE, 5)
-        vbox.pack_start (sw, TRUE)
-        vbox.pack_start (hbox, FALSE)
+        vbox = gtk.VBox (gtk.FALSE, 5)
+        vbox.pack_start (sw, gtk.TRUE)
+        vbox.pack_start (hbox, gtk.FALSE)
         vbox.set_border_width (5)
 
         return vbox
diff --git a/iw/partition_gui.py b/iw/partition_gui.py
index 26a0c1691..41a38b838 100644
--- a/iw/partition_gui.py
+++ b/iw/partition_gui.py
@@ -13,11 +13,11 @@
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 
+import gtk
+import gnome.canvas
+import pango
+from gui import WrappingLabel, widgetExpander
 from iw_gui import *
-from gtk import *
-from GDK import *
-from gnome.ui import *
-from gnome.util import *
 from translate import _, N_
 from partitioning import *
 from fsset import *
@@ -46,13 +46,13 @@ MAX_PART_SIZE = 1024*1024*1024
 
 class DiskStripeSlice:
     def eventHandler(self, widget, event):
-        if event.type == GDK.BUTTON_PRESS:
+        if event.type == gtk.gdk.BUTTON_PRESS:
             if event.button == 1:
                 self.parent.selectSlice(self.partition, 1)
-        elif event.type == GDK._2BUTTON_PRESS:
+        elif event.type == gtk.gdk._2BUTTON_PRESS:
             self.editCb(self.ctree)
                 
-        return TRUE
+        return gtk.TRUE
 
     def shutDown(self):
         self.parent = None
@@ -84,6 +84,8 @@ class DiskStripeSlice:
         return "cornsilk1"
 
     def hideOrShowText(self):
+        # XXX disable until CanvasRect's bounds function gets implemetned
+        return
         if self.box.get_bounds()[2] < self.text.get_bounds()[2]:
             self.text.hide()
         else:
@@ -109,7 +111,7 @@ class DiskStripeSlice:
                              * disk.dev.cylinders)
 
         # XXX hack but will work for now
-        if screen_width() > 640:
+        if gtk.gdk.screen_width() > 640:
             width = CANVAS_WIDTH_800
         else:
             width = CANVAS_WIDTH_640
@@ -130,10 +132,10 @@ class DiskStripeSlice:
                      outline_color='black', width_units=1.0)
         self.text.set(x=2.0, y=texty + 2.0, text=self.sliceText(),
                       fill_color='black',
-                      anchor=ANCHOR_NW, clip=TRUE,
+                      anchor=gtk.ANCHOR_NW, clip=gtk.TRUE,
                       clip_width=xlength-1, clip_height=yheight-1)
         self.hideOrShowText()
-        
+       
     def __init__(self, parent, partition, ctree, editCb):
         self.text = None
         self.partition = partition
@@ -142,11 +144,11 @@ class DiskStripeSlice:
         self.editCb = editCb
         pgroup = parent.getGroup()
 
-        self.group = pgroup.add("group")
-        self.box = self.group.add ("rect")
+        self.group = pgroup.add(gnome.canvas.CanvasGroup)
+        self.box = self.group.add(gnome.canvas.CanvasRect)
         self.group.connect("event", self.eventHandler)
-        self.text = self.group.add ("text",
-                                    fontset="-*-helvetica-medium-r-*-*-8-*")
+        self.text = self.group.add (gnome.canvas.CanvasText,
+                                    font="helvetica", size_points=8)
         self.update()
 
 class DiskStripe:
@@ -162,14 +164,14 @@ class DiskStripe:
         self.selected = None
 
         # XXX hack but will work for now
-        if screen_width() > 640:
+        if gtk.gdk.screen_width() > 640:
             width = CANVAS_WIDTH_800
         else:
             width = CANVAS_WIDTH_640
         
-        group.add ("rect", x1=0.0, y1=10.0, x2=width,
-                   y2=STRIPE_HEIGHT, fill_color='green',
-                   outline_color='grey71', width_units=1.0)
+        group.add(gnome.canvas.CanvasRect, x1=0.0, y1=10.0, x2=width,
+                  y2=STRIPE_HEIGHT, fill_color='green',
+                  outline_color='grey71', width_units=1.0)
         group.lower_to_bottom()
 
     def shutDown(self):
@@ -182,7 +184,7 @@ class DiskStripe:
         del self.disk
 
     def holds(self, partition):
-        return self.hash.has_key (partition)
+        return self.hash.has_key(partition)
 
     def getSlice(self, partition):
         return self.hash[partition]
@@ -193,10 +195,10 @@ class DiskStripe:
     def getDrive(self):
         return self.drive
 
-    def getGroup (self):
+    def getGroup(self):
         return self.group
 
-    def getCanvas (self):
+    def getCanvas(self):
         return self.canvas
 
     def selectSlice(self, partition, updateTree=0):
@@ -209,24 +211,24 @@ class DiskStripe:
             self.tree.unselect(self.tree.selection[0])
             nodes = self.tree.base_nodes()
             for node in nodes:
-                row = self.tree.find_by_row_data (node, partition)
+                row = self.tree.find_by_row_data(node, partition)
                 self.tree.select(row)
                 break
         self.selected = slice
 
     def deselect(self):
         if self.selected:
-            self.selected.deselect ()
+            self.selected.deselect()
         self.selected = None
     
-    def add (self, partition):
+    def add(self, partition):
         stripe = DiskStripeSlice(self, partition, self.tree, self.editCb)
         self.slices.append(stripe)
         self.hash[partition] = stripe
 
 class DiskStripeGraph:
     def __init__(self, ctree, editCb):
-        self.canvas = GnomeCanvas()
+        self.canvas = gnome.canvas.Canvas()
         self.diskStripes = []
         self.textlabels = []
         self.ctree = ctree
@@ -267,23 +269,28 @@ class DiskStripeGraph:
             if stripe.holds(partition):
                 return stripe.getDisk()
 
-    def add (self, drive, disk):
+    def add(self, drive, disk):
 #        yoff = len(self.diskStripes) * (STRIPE_HEIGHT + 5)
         yoff = self.next_ypos
-        text = self.canvas.root().add ("text", x=0.0, y=yoff,
-                          fontset="-*-helvetica-bold-r-normal-*-*-120-*-*-p-*-iso8859-1")
-        drivetext = "Drive %s (Geom: %s/%s/%s) (Model: %s)" % ('/dev/' + drive,
+        text = self.canvas.root().add(gnome.canvas.CanvasText,
+                                      x=0.0, y=yoff,
+                                      font="sans",
+                                      size_points=12)
+        drivetext = ("Drive %s (Geom: %s/%s/%s) "
+                     "(Model: %s)") % ('/dev/' + drive,
                                        disk.dev.cylinders,
                                        disk.dev.heads,
                                        disk.dev.sectors,
                                        disk.dev.model)
-        text.set(text=drivetext, fill_color='black', anchor=ANCHOR_NW)
+        text.set(text=drivetext, fill_color='black', anchor=gtk.ANCHOR_NW,
+                 weight=pango.WEIGHT_BOLD)
         (xxx1, yyy1, xxx2, yyy2) =  text.get_bounds()
         textheight = yyy2 - yyy1
         self.textlabels.append(text)
-
-        group = self.canvas.root().add("group", x=0, y=yoff+textheight)
-        stripe = DiskStripe (drive, disk, group, self.ctree, self.canvas, self.editCb)
+        group = self.canvas.root().add(gnome.canvas.CanvasGroup,
+                                       x=0, y=yoff+textheight)
+        stripe = DiskStripe(drive, disk, group, self.ctree, self.canvas,
+                             self.editCb)
         self.diskStripes.append(stripe)
         self.next_ypos = self.next_ypos + STRIPE_HEIGHT+textheight+10
         return stripe
@@ -292,14 +299,14 @@ class DiskStripeGraph:
 # this should probably go into a class
 # some helper functions for build UI components
 def createAlignedLabel(text):
-    label = GtkLabel(text)
+    label = gtk.Label(text)
     label.set_alignment(0.0, 0.0)
 
     return label
 
 def createMountPointCombo(request):
-    mountCombo = GtkCombo()
-    mountCombo.set_popdown_strings (defaultMountPoints)
+    mountCombo = gtk.Combo()
+    mountCombo.set_popdown_strings(defaultMountPoints)
 
     mountpoint = request.mountpoint
 
@@ -343,8 +350,8 @@ def fstypechangeCB(widget, mountCombo):
     setMntPtComboStateFromType(fstype, mountCombo)
     
 def createAllowedDrivesClist(disks, reqdrives):
-    driveclist = GtkCList()
-    driveclist.set_selection_mode (SELECTION_MULTIPLE)
+    driveclist = gtk.CList()
+    driveclist.set_selection_mode(gtk.SELECTION_MULTIPLE)
     driveclist.set_usize(-1, 75)
 
     driverow = 0
@@ -367,15 +374,15 @@ def createAllowedDrivesClist(disks, reqdrives):
 
 def createAllowedRaidPartitionsClist(allraidparts, reqraidpart):
 
-    partclist = GtkCList()
-    partclist.set_selection_mode (SELECTION_MULTIPLE)
+    partclist = gtk.CList()
+    partclist.set_selection_mode(gtk.SELECTION_MULTIPLE)
     partclist.set_usize(-1, 95)
-    sw = GtkScrolledWindow()
+    sw = gtk.ScrolledWindow()
     sw.add(partclist)
-    sw.set_policy(POLICY_NEVER, POLICY_AUTOMATIC)
+    sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 
     partrow = 0
-    for (part, size, used) in allraidparts:
+    for part, size, used in allraidparts:
         partname = "%s: %8.0f MB" % (part, size)
         partclist.append((partname,))
 
@@ -386,13 +393,13 @@ def createAllowedRaidPartitionsClist(allraidparts, reqraidpart):
     return (partclist, sw)
 
 def createRaidLevelMenu(levels, reqlevel, raidlevelchangeCB, sparesb):
-    leveloption = GtkOptionMenu()
-    leveloptionmenu = GtkMenu()
+    leveloption = gtk.OptionMenu()
+    leveloptionmenu = gtk.Menu()
     defindex = None
     i = 0
     for lev in levels:
-        item = GtkMenuItem(lev)
-        item.set_data ("level", lev)
+        item = gtk.MenuItem(lev)
+        item.set_data("level", lev)
         leveloptionmenu.add(item)
         if reqlevel and lev == reqlevel:
             defindex = i
@@ -400,7 +407,7 @@ def createRaidLevelMenu(levels, reqlevel, raidlevelchangeCB, sparesb):
             item.connect("activate", raidlevelchangeCB, sparesb)
         i = i + 1
 
-    leveloption.set_menu (leveloptionmenu)
+    leveloption.set_menu(leveloptionmenu)
     
     if defindex:
         leveloption.set_history(defindex)
@@ -413,8 +420,8 @@ def createRaidLevelMenu(levels, reqlevel, raidlevelchangeCB, sparesb):
 # pass in callback for when fs changes because of python scope issues
 def createFSTypeMenu(fstype, fstypechangeCB, mountCombo,
                      availablefstypes = None, ignorefs = None):
-    fstypeoption = GtkOptionMenu ()
-    fstypeoptionMenu = GtkMenu ()
+    fstypeoption = gtk.OptionMenu()
+    fstypeoptionMenu = gtk.Menu()
     types = fileSystemTypeGetTypes()
     if availablefstypes:
         names = availablefstypes
@@ -436,8 +443,8 @@ def createFSTypeMenu(fstype, fstypechangeCB, mountCombo,
             continue
         
         if fileSystemTypeGet(name).isFormattable():
-            item = GtkMenuItem(name)
-            item.set_data ("type", types[name])
+            item = gtk.MenuItem(name)
+            item.set_data("type", types[name])
             fstypeoptionMenu.add(item)
             if default and default.getName() == name:
                 defindex = i
@@ -446,7 +453,7 @@ def createFSTypeMenu(fstype, fstypechangeCB, mountCombo,
                 item.connect("activate", fstypechangeCB, mountCombo)
             i = i + 1
 
-    fstypeoption.set_menu (fstypeoptionMenu)
+    fstypeoption.set_menu(fstypeoptionMenu)
 
     if defindex:
         fstypeoption.set_history(defindex)
@@ -480,8 +487,8 @@ def raidlevelchangeCB(widget, sparesb):
 class PartitionWindow(InstallWindow):
     def __init__(self, ics):
 	InstallWindow.__init__(self, ics)
-        ics.setTitle (_("Disk Setup"))
-        ics.setNextEnabled (TRUE)
+        ics.setTitle(_("Disk Setup"))
+        ics.setNextEnabled(gtk.TRUE)
         ics.readHTML("partition")
         self.parent = ics.getICW().window
 
@@ -490,50 +497,50 @@ class PartitionWindow(InstallWindow):
 
     def presentPartitioningComments(self, type,
                                     title, labelstr1, labelstr2, comments):
-        win = GnomeDialog(title)
+        win = gtk.Dialog(title)
         
         if type == "ok":
-            win.append_button(_("OK"))
+            win.add_button('gtk-ok', 1)
         elif type == "yesno":
-            win.append_button(_("Yes"))
-            win.append_button(_("No"))
+            win.add_button('gtk-yes', 1)
+            win.add_button('gtk-no', 2)
 
-        hbox = GtkHBox(FALSE)
-        file = pixmap_file('gnome-warning.png')
-        if file:
-            hbox.pack_start(GnomePixmap(file), FALSE)
+        image = gtk.Image()
+        image.set_from_stock('gtk-dialog-warning', gtk.ICON_SIZE_DIALOG)
+        hbox = gtk.HBox(gtk.FALSE)
+        hbox.pack_start(image, gtk.FALSE)
 
-        win.connect ("clicked", self.quit)
-        textbox = GtkText()
-        textbox.insert_defaults (comments)
+        win.connect("clicked", self.quit)
+        textbox = gtk.Text()
+        textbox.insert_defaults(comments)
         textbox.set_word_wrap(1)
         textbox.set_editable(0)
         
-        sw = GtkScrolledWindow()
+        sw = gtk.ScrolledWindow()
         sw.add(textbox)
-        sw.set_policy(POLICY_AUTOMATIC, POLICY_AUTOMATIC)
+        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
 
-        info1 = GtkLabel(labelstr1)
-        info1.set_line_wrap(TRUE)
-        info1.set_usize(300, -1)
+        info1 = gtk.Label(labelstr1)
+        info1.set_line_wrap(gtk.TRUE)
+#        info1.set_usize(300, -1)
 
-        info2 = GtkLabel(labelstr2)
-        info2.set_line_wrap(TRUE)
-        info2.set_usize(300, -1)
+        info2 = gtk.Label(labelstr2)
+        info2.set_line_wrap(gtk.TRUE)
+#        info2.set_usize(300, -1)
         
-        vbox = GtkVBox(FALSE)
-        vbox.pack_start(info1, FALSE)
-        vbox.pack_start(sw, TRUE)
-        vbox.pack_start(info2, FALSE)
-        hbox.pack_start(vbox, FALSE)
+        vbox = gtk.VBox(gtk.FALSE)
+        vbox.pack_start(info1, gtk.FALSE)
+        vbox.pack_start(sw, gtk.TRUE)
+        vbox.pack_start(info2, gtk.FALSE)
+        hbox.pack_start(vbox, gtk.FALSE)
 
         win.vbox.pack_start(hbox)
-        win.set_usize(400,300)
-        win.set_position(WIN_POS_CENTER)
+#        win.set_usize(400,300)
+        win.set_position(gtk.WIN_POS_CENTER)
         win.show_all()
         rc = win.run()
         win.close()
-        return not rc
+        return rc
         
     def getNext(self):
         (errors, warnings) = sanityCheckAllRequests(self.partitions,
@@ -548,11 +555,11 @@ class PartitionWindow(InstallWindow):
                           "Red Hat Linux.")
 
             commentstr = string.join(errors, "\n\n")
-
-            rc = self.presentPartitioningComments("ok",
-                                                  _("Partitioning Errors"),
-                                                  labelstr1, labelstr2,
-                                                  commentstr)
+            
+            self.presentPartitioningComments("ok",
+                                             _("Partitioning Errors"),
+                                             labelstr1, labelstr2,
+                                             commentstr)
             raise gui.StayOnScreen
         
         if warnings:
@@ -606,7 +613,7 @@ class PartitionWindow(InstallWindow):
         del self.parent
         return None
     
-    def populate (self, initial = 0):
+    def populate(self, initial = 0):
         drives = self.diskset.disks.keys()
         drives.sort()
 
@@ -617,19 +624,20 @@ class PartitionWindow(InstallWindow):
             sectorsPerCyl = disk.dev.heads * disk.dev.sectors
 
             # add a disk stripe to the graph
-            stripe = self.diskStripeGraph.add (drive, disk)
+            stripe = self.diskStripeGraph.add(drive, disk)
 
             # add a parent node to the tree
-            parent = self.tree.insert_node (None, None, text,
-                                            is_leaf = FALSE, expanded = TRUE,
-                                            spacing = TREE_SPACING)
+            parent = self.tree.insert_node(None, None, text,
+                                           is_leaf = gtk.FALSE,
+                                           expanded = gtk.TRUE,
+                                           spacing = TREE_SPACING)
             extendedParent = None
-            part = disk.next_partition ()
+            part = disk.next_partition()
             while part:
                 if part.type & parted.PARTITION_METADATA:
-                    part = disk.next_partition (part)
+                    part = disk.next_partition(part)
                     continue
-                stripe.add (part)
+                stripe.add(part)
 
                 text = [""] * self.numCols
                 device = get_partition_name(part)
@@ -683,26 +691,26 @@ class PartitionWindow(InstallWindow):
                         raise RuntimeError, ("can't handle more than "
                                              "one extended partition per disk")
                     extendedParent = \
-                                   self.tree.insert_node (parent,
-                                                          None, text,
-                                                          is_leaf=FALSE,
-                                                          expanded=TRUE,
-                                                          spacing=TREE_SPACING)
+                                   self.tree.insert_node(parent,
+                                                         None, text,
+                                                         is_leaf=gtk.FALSE,
+                                                         expanded=gtk.TRUE,
+                                                         spacing=TREE_SPACING)
                     node = extendedParent
                                         
                 elif part.type & parted.PARTITION_LOGICAL:
                     if not extendedParent:
                         raise RuntimeError, ("crossed logical partition "
                                              "before extended")
-                    node = self.tree.insert_node (extendedParent, None, text,
-                                                  spacing = TREE_SPACING)
+                    node = self.tree.insert_node(extendedParent, None, text,
+                                                 spacing = TREE_SPACING)
                 else:
-                    node = self.tree.insert_node (parent, None, text,
-                                                  spacing = TREE_SPACING)
+                    node = self.tree.insert_node(parent, None, text,
+                                                 spacing = TREE_SPACING)
                
-                self.tree.node_set_row_data (node, part)
+                self.tree.node_set_row_data(node, part)
 
-                part = disk.next_partition (part)
+                part = disk.next_partition(part)
 
         # handle RAID next
         raidcounter = 0
@@ -732,11 +740,11 @@ class PartitionWindow(InstallWindow):
                                           "%g" % (request.size)
 
                 # add a parent node to the tree
-                parent = self.tree.insert_node (None, None, text,
-                                                is_leaf = FALSE,
-                                                expanded = TRUE,
-                                                spacing = TREE_SPACING)
-                self.tree.node_set_row_data (parent, request.device)
+                parent = self.tree.insert_node(None, None, text,
+                                               is_leaf = gtk.FALSE,
+                                               expanded = gtk.TRUE,
+                                               spacing = TREE_SPACING)
+                self.tree.node_set_row_data(parent, request.device)
                 raidcounter = raidcounter + 1
                 
         canvas = self.diskStripeGraph.getCanvas()
@@ -745,11 +753,11 @@ class PartitionWindow(InstallWindow):
 
     def treeSelectClistRowCb(self, list, row, column, event, tree):
         if event:
-            if event.type == GDK._2BUTTON_PRESS:
+            if event.type == gtk.gdk._2BUTTON_PRESS:
                 self.editCb(tree)
 
     def treeSelectCb(self, tree, node, column):
-        partition = tree.node_get_row_data (node)
+        partition = tree.node_get_row_data(node)
         if partition:
             self.diskStripeGraph.selectSlice(partition)
 
@@ -792,7 +800,8 @@ class PartitionWindow(InstallWindow):
 
         def cylspinchangedCB(widget, data):
             (dev, startcylspin, endcylspin, bycyl_sizelabel) = data
-            startsec = start_cyl_to_sector(dev, startcylspin.get_value_as_int())
+            startsec = start_cyl_to_sector(dev,
+                                           startcylspin.get_value_as_int())
             endsec = end_cyl_to_sector(dev, endcylspin.get_value_as_int())
             cursize = (endsec - startsec)/2048
             bycyl_sizelabel.set_text("%s" % (int(cursize))) 
@@ -802,21 +811,24 @@ class PartitionWindow(InstallWindow):
 
         # pass in CB defined above because of two scope limitation of python!
         def createSizeOptionsFrame(request, fillmaxszCB):
-            frame = GtkFrame (_("Additional Size Options"))
-            sizeoptiontable = GtkTable()
+            frame = gtk.Frame(_("Additional Size Options"))
+            sizeoptiontable = gtk.Table()
             sizeoptiontable.set_row_spacings(5)
             sizeoptiontable.set_border_width(4)
             
-            fixedrb     = GtkRadioButton(label=_("Fixed size"))
-            fillmaxszrb = GtkRadioButton(group=fixedrb, label=_("Fill all space up to (MB):"))
-            maxsizeAdj = GtkAdjustment (value = 1, lower = 1,
+            fixedrb     = gtk.RadioButton(label=_("Fixed size"))
+            fillmaxszrb = gtk.RadioButton(group=fixedrb,
+                                          label=_("Fill all space up "
+                                                  "to (MB):"))
+            maxsizeAdj = gtk.Adjustment(value = 1, lower = 1,
                                         upper = MAX_PART_SIZE, step_incr = 1)
-            fillmaxszsb = GtkSpinButton(maxsizeAdj, digits = 0)
-            fillmaxszhbox = GtkHBox()
+            fillmaxszsb = gtk.SpinButton(maxsizeAdj, digits = 0)
+            fillmaxszhbox = gtk.HBox()
             fillmaxszhbox.pack_start(fillmaxszrb)
             fillmaxszhbox.pack_start(fillmaxszsb)
-            fillunlimrb = GtkRadioButton(group=fixedrb,
-                                         label=_("Fill to maximum allowable size"))
+            fillunlimrb = gtk.RadioButton(group=fixedrb,
+                                         label=_("Fill to maximum allowable "
+                                                 "size"))
 
             fillmaxszrb.connect("toggled", fillmaxszCB, fillmaxszsb)
 
@@ -845,16 +857,14 @@ class PartitionWindow(InstallWindow):
         #
 
 
-        dialog = GnomeDialog(_("Add Partition"))
-        dialog.set_parent(self.parent)
-        dialog.append_button (_("OK"))
-        dialog.append_button (_("Cancel"))
-        dialog.set_position(WIN_POS_CENTER)
-        dialog.close_hides(TRUE)
+        dialog = gtk.Dialog(_("Add Partition"), self.parent)
+        dialog.add_button('gtk-ok', 1)
+        dialog.add_button('gtk-cancel', 2)
+        dialog.set_position(gtk.WIN_POS_CENTER)
         
-        maintable = GtkTable()
-        maintable.set_row_spacings (5)
-        maintable.set_col_spacings (5)
+        maintable = gtk.Table()
+        maintable.set_row_spacings(5)
+        maintable.set_col_spacings(5)
         row = 0
 
         # see if we are creating a floating request or by cylinder
@@ -878,18 +888,20 @@ class PartitionWindow(InstallWindow):
                                                           mountCombo)
             maintable.attach(newfstype, 1, 2, row, row + 1)
         else:
-            maintable.attach(createAlignedLabel(_("Original Filesystem Type:")),
+            maintable.attach(createAlignedLabel(_("Original Filesystem "
+                                                  "Type:")),
                              0, 1, row, row + 1)
 
             if origrequest.origfstype:
                 typestr = origrequest.origfstype.getName()
                 if origrequest.origfstype.getName() == "foreign":
-                    part = get_partition_by_name(self.diskset.disks, origrequest.device)
+                    part = get_partition_by_name(self.diskset.disks,
+                                                 origrequest.device)
                     typestr = map_foreign_to_fsname(part.native_type)
             else:
                 typestr = _("Unknown")
 
-            fstypelabel = GtkLabel(typestr)
+            fstypelabel = gtk.Label(typestr)
             maintable.attach(fstypelabel, 1, 2, row, row + 1)
             newfstype = None
             newfstypeMenu = None
@@ -905,9 +917,9 @@ class PartitionWindow(InstallWindow):
                 driveclist = createAllowedDrivesClist(self.diskset.disks,
                                                       origrequest.drive)
 
-                sw = GtkScrolledWindow()
+                sw = gtk.ScrolledWindow()
                 sw.add(driveclist)
-                sw.set_policy(POLICY_AUTOMATIC, POLICY_AUTOMATIC)
+                sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
                 maintable.attach(sw, 1, 2, row, row + 1)
             else:
                 maintable.attach(createAlignedLabel(_("Drive:")),
@@ -919,9 +931,10 @@ class PartitionWindow(InstallWindow):
 
         # original fs label
         if origrequest.type != REQUEST_NEW and origrequest.fslabel:
-            maintable.attach(createAlignedLabel(_("Original Filesystem Label:")),
+            maintable.attach(createAlignedLabel(_("Original Filesystem "
+                                                  "Label:")),
                              0, 1, row, row + 1)
-            fslabel = GtkLabel(origrequest.fslabel)
+            fslabel = gtk.Label(origrequest.fslabel)
             maintable.attach(fslabel, 1, 2, row, row + 1)
 
             row = row + 1
@@ -932,9 +945,9 @@ class PartitionWindow(InstallWindow):
                 # Size specification
                 maintable.attach(createAlignedLabel(_("Size (MB):")),
                                  0, 1, row, row + 1)
-                sizeAdj = GtkAdjustment (value = 1, lower = 1,
+                sizeAdj = gtk.Adjustment(value = 1, lower = 1,
                                          upper = MAX_PART_SIZE, step_incr = 1)
-                sizespin = GtkSpinButton(sizeAdj, digits = 0)
+                sizespin = gtk.SpinButton(sizeAdj, digits = 0)
 
                 if origrequest.size:
                     sizespin.set_value(origrequest.size)
@@ -954,21 +967,21 @@ class PartitionWindow(InstallWindow):
                                  0, 1, row, row + 1)
 
                 maxcyl = self.diskset.disks[origrequest.drive[0]].dev.cylinders
-                cylAdj = GtkAdjustment (value = origrequest.start,
-                                        lower = origrequest.start,
-                                        upper = maxcyl,
-                                        step_incr = 1)
-                startcylspin = GtkSpinButton(cylAdj, digits = 0)
+                cylAdj = gtk.Adjustment(value=origrequest.start,
+                                        lower=origrequest.start,
+                                        upper=maxcyl,
+                                        step_incr=1)
+                startcylspin = gtk.SpinButton(cylAdj, digits=0)
                 maintable.attach(startcylspin, 1, 2, row, row + 1)
                 row = row + 1
                 
-                endcylAdj = GtkAdjustment (value = origrequest.end,
-                                        lower = origrequest.start,
-                                        upper = maxcyl,
-                                        step_incr = 1)
+                endcylAdj = gtk.Adjustment(value=origrequest.end,
+                                           lower=origrequest.start,
+                                           upper=maxcyl,
+                                           step_incr=1)
                 maintable.attach(createAlignedLabel(_("End Cylinder:")),
                                  0, 1, row, row + 1)
-                endcylspin = GtkSpinButton(endcylAdj, digits = 0)
+                endcylspin = gtk.SpinButton(endcylAdj, digits = 0)
                 maintable.attach(endcylspin, 1, 2, row, row + 1)
 
                 startcylspin.connect("changed", cylspinchangedCB,
@@ -983,7 +996,7 @@ class PartitionWindow(InstallWindow):
         else:
             maintable.attach(createAlignedLabel(_("Size (MB):")),
                              0, 1, row, row + 1)
-            sizelabel = GtkLabel("%d" % (origrequest.size))
+            sizelabel = gtk.Label("%d" % (origrequest.size))
             maintable.attach(sizelabel, 1, 2, row, row + 1)
             sizespin = None
             
@@ -994,24 +1007,25 @@ class PartitionWindow(InstallWindow):
 
             ofstype = origrequest.fstype
             
-            maintable.attach(GtkHSeparator(), 0, 2, row, row + 1)
+            maintable.attach(gtk.HSeparator(), 0, 2, row, row + 1)
             row = row + 1
 
-            label = GtkLabel(_("How would you like to prepare the filesystem "
+            label = gtk.Label(_("How would you like to prepare the filesystem "
                                "on this partition?"))
             label.set_line_wrap(1)
             label.set_alignment(0.0, 0.0)
-            label.set_usize(400, -1)
+#            label.set_usize(400, -1)
 
             maintable.attach(label, 0, 2, row, row + 1)
             row = row + 1
             
-            noformatrb = GtkRadioButton (label=_("Leave unchanged (preserve data)"))
+            noformatrb = gtk.RadioButton(label=_("Leave unchanged "
+                                                 "(preserve data)"))
             noformatrb.set_active(1)
             maintable.attach(noformatrb, 0, 2, row, row + 1)
             row = row + 1
 
-            formatrb = GtkRadioButton (label=_("Format partition as:"),
+            formatrb = gtk.RadioButton(label=_("Format partition as:"),
                                        group = noformatrb)
             formatrb.set_active(0)
             if origrequest.format:
@@ -1031,8 +1045,8 @@ class PartitionWindow(InstallWindow):
                                                          mountCombo, ofstype))
 
             if origrequest.origfstype.isMigratable():
-                migraterb = GtkRadioButton (label=_("Migrate partition to:"),
-                                                  group=noformatrb)
+                migraterb = gtk.RadioButton(label=_("Migrate partition to:"),
+                                            group=noformatrb)
                 migraterb.set_active(0)
                 if origrequest.migrate:
                     migraterb.set_active(1)
@@ -1055,7 +1069,7 @@ class PartitionWindow(InstallWindow):
             else:
                 migraterb = None
 
-            badblocks = GtkCheckButton(_("Check for bad blocks?"))
+            badblocks = gtk.CheckButton(_("Check for bad blocks?"))
             badblocks.set_active(0)
             maintable.attach(badblocks, 0, 1, row, row + 1)
             formatrb.connect("toggled", noformatCB, badblocks)
@@ -1075,7 +1089,9 @@ class PartitionWindow(InstallWindow):
         # size options
         if origrequest.type == REQUEST_NEW:
             if not newbycyl:
-                (sizeframe, fixedrb, fillmaxszrb, fillmaxszsb) = createSizeOptionsFrame(origrequest, fillmaxszCB)
+                (sizeframe, fixedrb, fillmaxszrb,
+                 fillmaxszsb) = createSizeOptionsFrame(origrequest,
+                                                       fillmaxszCB)
                 sizespin.connect("changed", sizespinchangedCB, fillmaxszsb)
 
                 maintable.attach(sizeframe, 0, 2, row, row + 1)
@@ -1088,14 +1104,15 @@ class PartitionWindow(InstallWindow):
 
         # create only as primary
         if origrequest.type == REQUEST_NEW:
-            primonlycheckbutton = GtkCheckButton(_("Force to be a primary partition"))
+            primonlycheckbutton = gtk.CheckButton(_("Force to be a primary "
+                                                    "partition"))
             primonlycheckbutton.set_active(0)
             if origrequest.primary:
                 primonlycheckbutton.set_active(1)
             maintable.attach(primonlycheckbutton, 0, 2, row, row+1)
             row = row + 1
 
-            badblocks = GtkCheckButton(_("Check for bad blocks"))
+            badblocks = gtk.CheckButton(_("Check for bad blocks"))
             badblocks.set_active(0)
             maintable.attach(badblocks, 0, 1, row, row + 1)
             row = row + 1
@@ -1110,8 +1127,8 @@ class PartitionWindow(InstallWindow):
             rc = dialog.run()
 
             # user hit cancel, do nothing
-            if rc == 1:
-                dialog.close()
+            if rc == 2:
+                dialog.destroy()
                 return
 
             if origrequest.type == REQUEST_NEW:
@@ -1120,7 +1137,7 @@ class PartitionWindow(InstallWindow):
 
                 request = copy.copy(origrequest)
                 request.fstype = filesystem
-                request.format = TRUE
+                request.format = gtk.TRUE
                 
                 if request.fstype.isMountable():
                     request.mountpoint = mountCombo.entry.get_text()
@@ -1128,12 +1145,12 @@ class PartitionWindow(InstallWindow):
                     request.mountpoint = None
                     
                 if primonlycheckbutton.get_active():
-                    primonly = TRUE
+                    primonly = gtk.TRUE
                 else:
                     primonly = None
 
                 if badblocks and badblocks.get_active():
-                    request.badblocks = TRUE
+                    request.badblocks = gtk.TRUE
                 else:
                     request.badblocks = None
 
@@ -1141,7 +1158,7 @@ class PartitionWindow(InstallWindow):
                     if fixedrb.get_active():
                         grow = None
                     else:
-                        grow = TRUE
+                        grow = gtk.TRUE
 
                     if fillmaxszrb.get_active():
                         maxsize = fillmaxszsb.get_value_as_int()
@@ -1186,7 +1203,7 @@ class PartitionWindow(InstallWindow):
                     if request.format:
                         request.fstype = fstypeMenu.get_active().get_data("type")
                     if badblocks and badblocks.get_active():
-                        request.badblocks = TRUE
+                        request.badblocks = gtk.TRUE
                     else:
                         request.badblocks = None
                         
@@ -1220,7 +1237,8 @@ class PartitionWindow(InstallWindow):
 #                    if not queryFormatPreExisting(self.intf):
 #                        continue
 
-                if not request.format and request.mountpoint and isFormatOnByDefault(request):
+                if (not request.format and
+                    request.mountpoint and isFormatOnByDefault(request)):
                     if not queryNoFormatPreExisting(self.intf):
                         continue
             
@@ -1236,15 +1254,16 @@ class PartitionWindow(InstallWindow):
                     self.partitions.addRequest(origrequest)
                 if self.refresh():
                     # this worked before and doesn't now...
-                    raise RuntimeError, "Returning partitions to state prior to edit failed"
+                    raise RuntimeError, ("Returning partitions to state "
+                                         "prior to edit failed")
             else:
                 break
 
-        dialog.close()
+        dialog.destroy()
 
     def deleteCb(self, widget):
         node = self.tree.selection[0]
-        partition = self.tree.node_get_row_data (node)
+        partition = self.tree.node_get_row_data(node)
 
         if doDeletePartitionByRequest(self.intf, self.partitions, partition):
             self.refresh()
@@ -1254,8 +1273,8 @@ class PartitionWindow(InstallWindow):
         while node:
             self.tree.remove_node(node)
             node = self.tree.node_nth(0)
-        self.tree.set_selection_mode (SELECTION_SINGLE)
-        self.tree.set_selection_mode (SELECTION_BROWSE)
+        self.tree.set_selection_mode(gtk.SELECTION_SINGLE)
+        self.tree.set_selection_mode(gtk.SELECTION_BROWSE)
 
     def resetCb(self, *args):
         if not confirmResetPartitionState(self.intf):
@@ -1283,21 +1302,24 @@ class PartitionWindow(InstallWindow):
             rc = -1
         except PartitioningWarning, msg:
             # XXX somebody other than me should make this look better
-            dialog = GnomeDialog(_("Warning"))
+            # XXX this doesn't handle the 'delete /boot partition spec' case
+            #     (it says 'add anyway')
+            dialog = gtk.Dialog(_("Warning"))
             dialog.set_parent(self.parent)
-            dialog.append_button(_("Modify Partition"))
-            dialog.append_button(_("Add anyway"))
-            dialog.set_position(WIN_POS_CENTER)
-            dialog.close_hides(TRUE)
-
-            label = GtkLabel(_("Warning: %s.") %(msg))
-            label.set_line_wrap(TRUE)
+            button = gtk.Button(_("_Modify Partition"))
+            dialog.add_action_widget(button, 1)
+            button = gtk.Button(_("_Continue"))
+            dialog.add_action_widget(button, 2)
+            dialog.set_position(gtk.WIN_POS_CENTER)
+
+            label = gtk.Label(_("Warning: %s.") % (msg))
+            label.set_line_wrap(gtk.TRUE)
             dialog.vbox.pack_start(label)
             dialog.show_all()
             rc = dialog.run()
-            dialog.close()
+            dialog.destroy()
             
-            if rc != 1:
+            if rc == 1:
                 rc = -1
             else:
                 rc = 0
@@ -1311,9 +1333,10 @@ class PartitionWindow(InstallWindow):
 
     def editCb(self, widget):
         node = self.tree.selection[0]
-        part = self.tree.node_get_row_data (node)
+        part = self.tree.node_get_row_data(node)
 
-        (type, request) = doEditPartitionByRequest(self.intf, self.partitions, part)
+        (type, request) = doEditPartitionByRequest(self.intf, self.partitions,
+                                                   part)
         if request:
             if type == "RAID":
                 self.editRaidRequest(request)
@@ -1327,31 +1350,30 @@ class PartitionWindow(InstallWindow):
         #
         # start of editRaidRuquest
         #
-        dialog = GnomeDialog(_("Make RAID Device"))
-        dialog.set_parent(self.parent)
-        dialog.append_button (_("OK"))
-        dialog.append_button (_("Cancel"))
-        dialog.set_position(WIN_POS_CENTER)
-        dialog.close_hides(TRUE)
-        
-        maintable = GtkTable()
-        maintable.set_row_spacings (5)
-        maintable.set_col_spacings (5)
-        row = 0
-
         availraidparts = get_available_raid_partitions(self.diskset,
                                                        self.partitions,
                                                        raidrequest)
 
         # if no raid partitions exist, raise an error message and return
         if len(availraidparts) < 2:
-            dlg = GnomeMessageBox(_("At least two software RAID partitions are needed."),
-                                  MESSAGE_BOX_ERROR,STOCK_BUTTON_OK)
-            dlg.set_position(WIN_POS_CENTER)
-            dlg.show()
-            dlg.run_and_close()
+            dlg = gtk.MessageDialog(None, 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
+                                    _("At least two software RAID "
+                                      "partitions are needed."))
+            dlg.set_position(gtk.WIN_POS_CENTER)
+            dlg.run()
+            dlg.destroy()
             return
 
+        dialog = gtk.Dialog(_("Make RAID Device"), self.parent)
+        dialog.add_button('gtk-ok', 1)
+        dialog.add_button('gtk-cancel', 2)
+        dialog.set_position(gtk.WIN_POS_CENTER)
+        
+        maintable = gtk.Table()
+        maintable.set_row_spacings(5)
+        maintable.set_col_spacings(5)
+        row = 0
+
         # Mount Point entry
         maintable.attach(createAlignedLabel(_("Mount Point:")),
                                             0, 1, row, row + 1)
@@ -1387,9 +1409,9 @@ class PartitionWindow(InstallWindow):
         else:
             maxspares = 0
 
-        spareAdj = GtkAdjustment (value = nspares, lower = 0,
-                               upper = maxspares, step_incr = 1)
-        sparesb = GtkSpinButton(spareAdj, digits = 0)
+        spareAdj = gtk.Adjustment(value = nspares, lower = 0,
+                                  upper = maxspares, step_incr = 1)
+        sparesb = gtk.SpinButton(spareAdj, digits = 0)
         sparesb.set_data("numparts", numparts)
 
         if maxspares > 0:
@@ -1425,7 +1447,7 @@ class PartitionWindow(InstallWindow):
 
         # format or not?
         if raidrequest.fstype and raidrequest.fstype.isFormattable():
-            formatButton = GtkCheckButton (_("Format partition?"))
+            formatButton = gtk.CheckButton(_("Format partition?"))
             # XXX this probably needs more logic once we detect existing raid
             if raidrequest.format == None or raidrequest.format != 0:
                 formatButton.set_active(1)
@@ -1446,12 +1468,9 @@ class PartitionWindow(InstallWindow):
             rc = dialog.run()
 
             # user hit cancel, do nothing
-            if rc == 1:
-                dialog.close()
+            if rc == 2:
+                dialog.destroy()
                 return
-            elif rc == -1:
-                # something died in dialog
-                raise ValueError, "Died inside of raid edit dialog!"
 
             # read out UI into a partition specification
             request = copy.copy(raidrequest)
@@ -1499,17 +1518,18 @@ class PartitionWindow(InstallWindow):
                 if not isNew:
                     self.partitions.addRequest(raidrequest)
                 if self.refresh():
-                    raise RuntimeError, "Returning partitions to state prior to RAID edit failed"
+                    raise RuntimeError, ("Returning partitions to state "
+                                         "prior to RAID edit failed")
             else:
                 break
 
-        dialog.close()
+        dialog.destroy()
 
     def makeraidCB(self, widget):
         request = PartitionSpec(fileSystemTypeGetDefault(), REQUEST_RAID, 1)
         self.editRaidRequest(request, isNew = 1)
 
-    def getScreen (self, fsset, diskset, partitions, intf):
+    def getScreen(self, fsset, diskset, partitions, intf):
         self.fsset = fsset
         self.diskset = diskset
         self.intf = intf
@@ -1524,10 +1544,8 @@ class PartitionWindow(InstallWindow):
 #        self.newFsset = self.fsset.copy()
 
         # operational buttons
-        buttonBox = GtkHButtonBox()
-        buttonBox.set_layout (BUTTONBOX_SPREAD)
-
-        self.accelgroup = GtkAccelGroup()
+        buttonBox = gtk.HButtonBox()
+        buttonBox.set_layout(gtk.BUTTONBOX_SPREAD)
 
         ops = ((_("_New"), self.newCB),
                (_("_Edit"), self.editCb),
@@ -1536,17 +1554,10 @@ class PartitionWindow(InstallWindow):
                (_("Make _RAID"), self.makeraidCB))
         
         for label, cb in ops:
-            labelwid = GtkLabel(label)
-            key = labelwid.parse_uline(label)
-            button = GtkButton ()
-            button.add(labelwid)
-            button.add_accelerator("clicked", self.accelgroup, key,
-                                   GDK.MOD1_MASK, 0)
+            button = gtk.Button(label)
             buttonBox.add (button)
             button.connect ("clicked", cb)
 
-        self.ics.getICW().window.add_accel_group (self.accelgroup)
-        
         # set up the tree
         titles = [N_("Device"), N_("Start"), N_("End"),
                   N_("Size (MB)"), N_("Type"), N_("Mount Point"), N_("Format")]
@@ -1560,42 +1571,44 @@ class PartitionWindow(InstallWindow):
             i = i + 1
 
         self.numCols = len(titles)
-        self.tree = GtkCTree (self.numCols, 0, titles)
-        self.tree.set_selection_mode (SELECTION_BROWSE)
+        self.tree = gtk.CTree(self.numCols, 0, titles)
+        self.tree.set_selection_mode(gtk.SELECTION_BROWSE)
         self.tree.column_titles_passive()
         for i in range(self.numCols):
             self.tree.set_column_resizeable(i, 0)
             
-        self.tree.set_column_justification(1, JUSTIFY_RIGHT)
-        self.tree.set_column_justification(2, JUSTIFY_RIGHT)
-        self.tree.set_column_justification(3, JUSTIFY_RIGHT)
-        self.tree.connect ("select_row", self.treeSelectClistRowCb, self.tree)
-        self.tree.connect ("tree_select_row", self.treeSelectCb)
+        self.tree.set_column_justification(1, gtk.JUSTIFY_RIGHT)
+        self.tree.set_column_justification(2, gtk.JUSTIFY_RIGHT)
+        self.tree.set_column_justification(3, gtk.JUSTIFY_RIGHT)
+        self.tree.connect("select_row", self.treeSelectClistRowCb, self.tree)
+        self.tree.connect("tree_select_row", self.treeSelectCb)
 
         # set up the canvas
         self.diskStripeGraph = DiskStripeGraph(self.tree, self.editCb)
         
         # do the initial population of the tree and the graph
-        self.populate (initial = 1)
-
-        box = GtkVBox(FALSE, 5)
-        sw = GtkScrolledWindow()
-        sw.add (self.diskStripeGraph.getCanvas())
-        sw.set_policy (POLICY_NEVER, POLICY_AUTOMATIC)
-        box.pack_start (sw, TRUE)
-        box.pack_start (buttonBox, FALSE)
-        sw = GtkScrolledWindow()
-        sw.add (self.tree)
-        sw.set_policy (POLICY_NEVER, POLICY_AUTOMATIC)
-        box.pack_start (sw, TRUE)
+        self.populate(initial = 1)
+
+        box = gtk.VBox(gtk.FALSE, 5)
+        sw = gtk.ScrolledWindow()
+        sw.add(self.diskStripeGraph.getCanvas())
+        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        frame = gtk.Frame()
+        frame.add(sw)
+        box.pack_start(frame, gtk.TRUE, gtk.TRUE)
+        box.pack_start(buttonBox, gtk.FALSE)
+        sw = gtk.ScrolledWindow()
+        sw.add(self.tree)
+        sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
+        box.pack_start(sw, gtk.TRUE)
 
 	return box
 
 class AutoPartitionWindow(InstallWindow):
     def __init__(self, ics):
     	InstallWindow.__init__(self, ics)
-        ics.setTitle (_("Automatic Partitioning"))
-        ics.setNextEnabled (TRUE)
+        ics.setTitle(_("Automatic Partitioning"))
+        ics.setNextEnabled(gtk.TRUE)
         ics.readHTML("autopart")
         self.parent = ics.getICW().window
 
@@ -1613,8 +1626,9 @@ class AutoPartitionWindow(InstallWindow):
 
         if len(allowdrives) < 1:
             self.intf.messageWindow(_("Warning"), 
-                                    _("You need to select at least one drive to have "
-                                      "Red Hat Linux installed onto."), type = "ok")
+                                    _("You need to select at least one "
+                                      "drive to have Red Hat Linux installed "
+                                      "onto."), type = "ok")
             raise gui.StayOnScreen
 
         self.partitions.autoClearPartDrives = allowdrives
@@ -1640,32 +1654,29 @@ class AutoPartitionWindow(InstallWindow):
         type = partitions.autoClearPartType
         cleardrives = partitions.autoClearPartDrives
         
-        box = GtkVBox (FALSE)
-        box.set_border_width (5)
-
-        label = GtkLabel(_(AUTOPART_DISK_CHOICE_DESCR_TEXT))
+        box = gtk.VBox(gtk.FALSE)
+        box.set_border_width(5)
 
-        label.set_line_wrap(1)
+        label = WrappingLabel(_(AUTOPART_DISK_CHOICE_DESCR_TEXT))
         label.set_alignment(0.0, 0.0)
-        label.set_usize(400, -1)
-        box.pack_start(label, FALSE, FALSE)
+        box.pack_start(label, gtk.FALSE, gtk.FALSE)
 
         # what partition types to remove
-        clearbox = GtkVBox(FALSE)
-        label = GtkLabel(_("I want to have automatic partitioning:"))
+        clearbox = gtk.VBox(gtk.FALSE)
+        label = WrappingLabel(_("I want to have automatic partitioning:"))
         label.set_alignment(0.0, 0.0)
-        clearbox.pack_start(label, FALSE, FALSE, 10)
+        clearbox.pack_start(label, gtk.FALSE, gtk.FALSE, 10)
         
-        radioBox = GtkVBox (FALSE)
-        self.clearLinuxRB = GtkRadioButton(
+        radioBox = gtk.VBox(gtk.FALSE)
+        self.clearLinuxRB = gtk.RadioButton(
             None, _(CLEARPART_TYPE_LINUX_DESCR_TEXT))
-	radioBox.pack_start(self.clearLinuxRB, FALSE, FALSE)
-        self.clearAllRB = GtkRadioButton(
+	radioBox.pack_start(self.clearLinuxRB, gtk.FALSE, gtk.FALSE)
+        self.clearAllRB = gtk.RadioButton(
             self.clearLinuxRB, _(CLEARPART_TYPE_ALL_DESCR_TEXT))
-	radioBox.pack_start(self.clearAllRB, FALSE, FALSE)
-        self.clearNoneRB = GtkRadioButton(
+	radioBox.pack_start(self.clearAllRB, gtk.FALSE, gtk.FALSE)
+        self.clearNoneRB = gtk.RadioButton(
             self.clearLinuxRB, _(CLEARPART_TYPE_NONE_DESCR_TEXT))
-	radioBox.pack_start(self.clearNoneRB, FALSE, FALSE)
+	radioBox.pack_start(self.clearNoneRB, gtk.FALSE, gtk.FALSE)
 
         if type == CLEARPART_TYPE_LINUX:
             self.clearLinuxRB.set_active(1)
@@ -1674,52 +1685,52 @@ class AutoPartitionWindow(InstallWindow):
         else:
             self.clearNoneRB.set_active(1)
            
-	align = GtkAlignment()
+	align = gtk.Alignment()
 	align.add(radioBox)
 	align.set(0.5, 0.5, 0.0, 0.0)
-	clearbox.pack_start(align, FALSE, FALSE)
+	clearbox.pack_start(align, gtk.FALSE, gtk.FALSE)
 
-        box.pack_start(clearbox, FALSE, FALSE, 10)
+        box.pack_start(clearbox, gtk.FALSE, gtk.FALSE, 10)
 
         # which drives to use?
-        drivesbox = GtkVBox(FALSE)
-        label = GtkLabel(_("Which drive(s) do you want to use for this "
-                           "installation?"))
+        drivesbox = gtk.VBox(gtk.FALSE)
+        label = WrappingLabel(_("Which drive(s) do you want to use for this "
+                                "installation?"))
         label.set_alignment(0.0, 0.0)
-        drivesbox.pack_start(label, FALSE, FALSE, 10)
+        drivesbox.pack_start(label, gtk.FALSE, gtk.FALSE, 10)
         self.driveclist = createAllowedDrivesClist(diskset.disks,
                                                    cleardrives)
         # XXX bad use of usize
         self.driveclist.set_usize(300, 80)
 
-        sw = GtkScrolledWindow()
+        sw = gtk.ScrolledWindow()
         sw.add(self.driveclist)
-        sw.set_policy(POLICY_NEVER, POLICY_AUTOMATIC)
+        sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
         
-	align = GtkAlignment()
+	align = gtk.Alignment()
 	align.add(sw)
 	align.set(0.5, 0.5, 0.0, 0.0)
         
-        drivesbox.pack_start(align, FALSE, FALSE)
+        drivesbox.pack_start(align, gtk.FALSE, gtk.FALSE)
 
-        box.pack_start(drivesbox, FALSE, FALSE)
+        box.pack_start(drivesbox, gtk.FALSE, gtk.FALSE)
 
-        self.inspect = GtkCheckButton()
-        label = GtkLabel(_("Review (allows you to see and "
-                  "change the automatic partitioning results)"))
+        self.inspect = gtk.CheckButton()
+        widgetExpander(self.inspect)
+        label = gtk.Label(_("Review (allows you to see and change the "
+                            "automatic partitioning results)"))
+        label.set_line_wrap(gtk.TRUE)
+        widgetExpander(label, self.inspect)
         label.set_alignment(0.0, 1.0)
-        label.set_line_wrap(TRUE)
-        label.set_usize(400, -1)
-        
         self.inspect.add(label)
 
         self.inspect.set_active(not dispatch.stepInSkipList("partition"))
-        
-	box.pack_start(self.inspect, FALSE, FALSE, 10)
 
-        self.ics.setNextEnabled (TRUE)
+	box.pack_start(self.inspect, gtk.TRUE, gtk.TRUE, 10)
+
+        self.ics.setNextEnabled(gtk.TRUE)
 
-	align = GtkAlignment()
+	align = gtk.Alignment()
 	align.add(box)
 	align.set(0.5, 0.5, 0.0, 0.0)
 
diff --git a/iw/partmethod_gui.py b/iw/partmethod_gui.py
index e15be39a2..efb84ada8 100644
--- a/iw/partmethod_gui.py
+++ b/iw/partmethod_gui.py
@@ -13,8 +13,9 @@
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 
+import gtk
+from gui import WrappingLabel
 from iw_gui import *
-from gtk import *
 from translate import _
 from autopart import PARTMETHOD_TYPE_DESCR_TEXT
 
@@ -43,27 +44,25 @@ class PartitionMethodWindow(InstallWindow):
 
         self.partitions = partitions
         
-        box = GtkVBox (FALSE)
+        box = gtk.VBox (gtk.FALSE)
         box.set_border_width (5)
 
-        label=GtkLabel(_(PARTMETHOD_TYPE_DESCR_TEXT))
-        label.set_line_wrap(1)
+        label=WrappingLabel(_(PARTMETHOD_TYPE_DESCR_TEXT))
         label.set_alignment(0.0, 0.0)
-        label.set_usize(400, -1)
 
-        box.pack_start(label, FALSE, FALSE)
+        box.pack_start(label, gtk.TRUE, gtk.TRUE)
 
-        radioBox = GtkVBox (FALSE)
+        radioBox = gtk.VBox (gtk.FALSE)
 
-        self.useAuto = GtkRadioButton(
+        self.useAuto = gtk.RadioButton(
             None, _("Have the installer automatically partition for you"))
-	radioBox.pack_start(self.useAuto, FALSE, FALSE)
-        self.useDS = GtkRadioButton(
+	radioBox.pack_start(self.useAuto, gtk.FALSE, gtk.FALSE)
+        self.useDS = gtk.RadioButton(
             self.useAuto, _("Manually partition with Disk Druid"))
-	radioBox.pack_start(self.useDS, FALSE, FALSE)
-        self.useFdisk = GtkRadioButton(
+	radioBox.pack_start(self.useDS, gtk.FALSE, gtk.FALSE)
+        self.useFdisk = gtk.RadioButton(
             self.useAuto, _("Manually partition with fdisk [experts only]"))
-	radioBox.pack_start(self.useFdisk, FALSE, FALSE)
+	radioBox.pack_start(self.useFdisk, gtk.FALSE, gtk.FALSE)
 
         if partitions.useAutopartitioning:
             self.useAuto.set_active(1)
@@ -72,17 +71,17 @@ class PartitionMethodWindow(InstallWindow):
         else:
             self.useDS.set_active(1)
             
-	align = GtkAlignment()
+	align = gtk.Alignment()
 	align.add(radioBox)
 	align.set(0.5, 0.5, 0.0, 0.0)
 
-	box.pack_start(align, FALSE, FALSE, 10)
+	box.pack_start(align, gtk.FALSE, gtk.FALSE, 10)
 
 	box.set_border_width (5)
 
-        self.ics.setNextEnabled (TRUE)
+        self.ics.setNextEnabled (gtk.TRUE)
 
-        align = GtkAlignment()
+        align = gtk.Alignment()
         align.add(box)
         align.set(0.5, 0.5, 0.0, 0.0)
 
diff --git a/iw/progress_gui.py b/iw/progress_gui.py
index 7a466025b..3bf498bab 100644
--- a/iw/progress_gui.py
+++ b/iw/progress_gui.py
@@ -17,7 +17,7 @@ import os
 import gui
 import sys
 import timer
-from gtk import *
+import gtk
 from iw_gui import *
 from translate import _, N_
 from packages import doInstall
@@ -31,10 +31,10 @@ class InstallProgressWindow (InstallWindow):
     def __init__ (self, ics):
 	InstallWindow.__init__ (self, ics)
 
-        ics.setPrevEnabled (FALSE)
-        ics.setNextEnabled (FALSE)
+        ics.setPrevEnabled (gtk.FALSE)
+        ics.setNextEnabled (gtk.FALSE)
         
-        ics.setHelpButtonEnabled (FALSE)
+        ics.setHelpButtonEnabled (gtk.FALSE)
 
 	self.numComplete = 0
 	self.sizeComplete = 0
@@ -188,47 +188,47 @@ class InstallProgressWindow (InstallWindow):
         self.pixtimer = timer.Timer()
         self.pixcurnum = 0
         
-	table = GtkTable (3, 2)
+	table = gtk.Table (3, 2)
         self.curPackage = { "package" : _("Package"),
                             "size"    : _("Size"),
                             "summary" : _("Summary") }
         i = 0
         for key in ("package", "size", "summary"):
-            label = GtkLabel ("%s: " % (self.curPackage[key],))
+            label = gtk.Label ("%s: " % (self.curPackage[key],))
             label.set_alignment (0, 0)
             if key == "summary":
-                fillopts = EXPAND|FILL
+                fillopts = gtk.EXPAND|gtk.FILL
             else:
-                fillopts = FILL
+                fillopts = gtk.FILL
 
-            table.attach (label, 0, 1, i, i+1, FILL, fillopts)
-            label = GtkLabel ()
+            table.attach (label, 0, 1, i, i+1, gtk.FILL, fillopts)
+            label = gtk.Label ("")
             label.set_alignment (0, 0)
-            label.set_line_wrap (TRUE)
+            label.set_line_wrap (gtk.TRUE)
             if key == "summary":
                 label.set_text ("\n\n")
                 label.set_usize(450, 35)
 #                label.set_usize(-1, 1)
             self.curPackage[key] = label
-            table.attach (label, 1, 2, i, i+1, FILL, fillopts)
+            table.attach (label, 1, 2, i, i+1, gtk.FILL, fillopts)
             i = i + 1
 
 
-        vbox = GtkVBox (FALSE, 10)
-        vbox.pack_start (table, FALSE, FALSE)
+        vbox = gtk.VBox (gtk.FALSE, 10)
+        vbox.pack_start (table, gtk.FALSE, gtk.FALSE)
 
-	self.progress = GtkProgressBar ()
-        self.totalProgress = GtkProgressBar ()
+	self.progress = gtk.ProgressBar ()
+        self.totalProgress = gtk.ProgressBar ()
 
-        progressTable = GtkTable (2, 2, FALSE)
-        label = GtkLabel (_("Package Progress: "))
+        progressTable = gtk.Table (2, 2, gtk.FALSE)
+        label = gtk.Label (_("Package Progress: "))
         label.set_alignment (0, 0)
-        progressTable.attach (label, 0, 1, 0, 1, SHRINK)
+        progressTable.attach (label, 0, 1, 0, 1, gtk.SHRINK)
         progressTable.attach (self.progress, 1, 2, 0, 1)
 
-        label = GtkLabel (_("Total Progress:   "))
+        label = gtk.Label (_("Total Progress:   "))
         label.set_alignment (0, 0)
-        progressTable.attach (label, 0, 1, 1, 2, SHRINK)
+        progressTable.attach (label, 0, 1, 1, 2, gtk.SHRINK)
         progressTable.attach (self.totalProgress, 1, 2, 1, 2)
 
         self.status =  {
@@ -243,16 +243,16 @@ class InstallProgressWindow (InstallWindow):
                             "time"     : (2, 3) }
             }
 
-        clist = GtkCList (4, (_("Status"), _("Packages"), _("Size"), _("Time")))
+        clist = gtk.CList (4, (_("Status"), _("Packages"), _("Size"), _("Time")))
         clist.column_titles_passive ()
-        clist.set_column_resizeable (0, FALSE)
-        clist.set_column_resizeable (1, FALSE)
-        clist.set_column_resizeable (2, FALSE)
-        clist.set_column_resizeable (3, FALSE)
-        clist.set_column_justification (0, JUSTIFY_LEFT)
-        clist.set_column_justification (1, JUSTIFY_RIGHT)
-        clist.set_column_justification (2, JUSTIFY_RIGHT)
-        clist.set_column_justification (3, JUSTIFY_RIGHT)
+        clist.set_column_resizeable (0, gtk.FALSE)
+        clist.set_column_resizeable (1, gtk.FALSE)
+        clist.set_column_resizeable (2, gtk.FALSE)
+        clist.set_column_resizeable (3, gtk.FALSE)
+        clist.set_column_justification (0, gtk.JUSTIFY_LEFT)
+        clist.set_column_justification (1, gtk.JUSTIFY_RIGHT)
+        clist.set_column_justification (2, gtk.JUSTIFY_RIGHT)
+        clist.set_column_justification (3, gtk.JUSTIFY_RIGHT)
         clist.append ((_("Total"),     "0", "0 M", "0:00:00"))
         clist.append ((_("Completed"), "0", "0 M", "0:00:00"))
         clist.append ((_("Remaining"), "0", "0 M", "0:00:00"))
@@ -262,32 +262,30 @@ class InstallProgressWindow (InstallWindow):
         for x in range (4):
             clist.column_title_passive (x)
         for x in range (3):
-            clist.set_selectable (x, FALSE)
-        clist['can_focus'] = FALSE
+            clist.set_selectable (x, gtk.FALSE)
+        clist.set_property('can_focus', gtk.FALSE)
         self.clist = clist
-#        align = GtkAlignment (0.5, 0.5)
+#        align = gtk.Alignment (0.5, 0.5)
 #        align.add (clist)
-#        vbox.pack_start (align, FALSE)
-        hbox = GtkHBox (FALSE, 5)
+#        vbox.pack_start (align, gtk.FALSE)
+        hbox = gtk.HBox (gtk.FALSE, 5)
         
-        vbox.pack_start (progressTable, FALSE)
-        hbox.pack_start (clist, TRUE)
-        vbox.pack_start (hbox, FALSE)
+        vbox.pack_start (progressTable, gtk.FALSE)
+        hbox.pack_start (clist, gtk.TRUE)
+        vbox.pack_start (hbox, gtk.FALSE)
         
         pix = self.ics.readPixmap ("progress_first.png")
         if pix:
-            frame = GtkFrame()
-            frame.set_shadow_type (SHADOW_IN)
-            box = GtkEventBox ()
+            frame = gtk.Frame()
+            frame.set_shadow_type(gtk.SHADOW_IN)
+            box = gtk.EventBox()
             self.adpix = pix
-            style = box.get_style ().copy ()
-            style.bg[STATE_NORMAL] = style.white
-            box.set_style (style)
+            box.modify_bg(gtk.STATE_NORMAL, box.get_style().white)
 #            self.adpix.set_alignment (0, 0)
-            box.add (self.adpix)
+            box.add(self.adpix)
             self.adbox = box
             frame.add (box)
-            vbox.pack_start (frame);
+            vbox.pack_start(frame);
 
 	intf.setPackageProgressWindow (self)
 	id.setInstallProgressClass(self)
diff --git a/iw/timezone_gui.py b/iw/timezone_gui.py
index 32f779761..ea2b31e4a 100644
--- a/iw/timezone_gui.py
+++ b/iw/timezone_gui.py
@@ -13,31 +13,12 @@
 
 import string
 import iutil
-from gtk import *
+import gtk
+from timezone_map_gui import TimezoneMap, ZoneTab
 from iw_gui import *
-from gnome.ui import GnomeCanvas
 from translate import _
 
-import timezonemap
-
-class Map (GnomeCanvas):
-    def __init__ (self, map):
-        self._o = map
-
-class List (GtkScrolledWindow):
-    def __init__ (self, list):
-        self._o = list
-
-class Status (GtkStatusbar):
-    def __init__ (self, bar):
-        self._o = bar
-
-class Option (GtkOptionMenu):
-    def __init__ (self, option):
-        self._o = option
-
 class TimezoneWindow (InstallWindow):
-
     def __init__ (self, ics):
 	InstallWindow.__init__ (self, ics)
 
@@ -77,18 +58,12 @@ class TimezoneWindow (InstallWindow):
                           (("+12", ""), ("Etc/GMT+12", "Etc/GMT+12")))                    
 
     def getNext (self):
-	if not self.__dict__.has_key('list'): return None
-
         self.old_page = self.nb.get_current_page ()
         self.timezone.utcOffset = self.nb.get_current_page ()
         self.timezone.dst = self.daylightCB.get_active ()
         
         if self.old_page == 0:
-            newzone = "America/New_York"
-            try:
-                newzone = self.tz.getzone (self.list.get_text (self.list.selection[0], 0))
-            except:
-                pass
+            newzone = self.tz.getCurrent().tz
             self.timezone.setTimezoneInfo (newzone, self.systemUTC.get_active ())
         else:
             timezone = self.timeZones[self.ulist.selection[0]][1]
@@ -108,10 +83,10 @@ class TimezoneWindow (InstallWindow):
         cb2.set_data ("toggling", 0)
 
     def view_change (self, widget, *args):
-        if not self.list.selection:
-            self.ics.setNextEnabled (FALSE)
+        if not self.tz.getCurrent():
+            self.ics.setNextEnabled (gtk.FALSE)
         else:
-            self.ics.setNextEnabled (TRUE)
+            self.ics.setNextEnabled (gtk.TRUE)
 
     def setcurrent (self, widget, area):
         try:
@@ -136,18 +111,18 @@ class TimezoneWindow (InstallWindow):
         else:
             path = "/usr/share/anaconda/pixmaps/map480.png"
         
-	nb = GtkNotebook ()
+	nb = gtk.Notebook ()
         self.nb = nb
 
-        mainBox = GtkVBox (FALSE, 5)
+        mainBox = gtk.VBox (gtk.FALSE, 5)
 
-        tz = timezonemap.new (path)
-        self.tz = tz
-        map = Map (tz.map)
-        swList = List (tz.citylist)
-        self.list = swList.children ()[0]
+        zonetab = ZoneTab()
+        self.tz = TimezoneMap(zonetab=zonetab, map=path)
 
 	(self.default, asUTC, asArc) = self.timezone.getTimezoneInfo()
+        entry = zonetab.findEntryByTZ(self.default)
+        if entry:
+            self.tz.setCurrent(entry)
 
         self.old_page = timezone.utcOffset
         self.old_use_dst = timezone.dst
@@ -169,66 +144,42 @@ class TimezoneWindow (InstallWindow):
             # self.default = _("America/New_York")
             self.default = "America/New_York"
 
-        self.id = self.list.connect ("draw", self.setcurrent)
-
         self.nb.connect ("realize", lambda widget, self=self:
-                         self.nb.set_page (self.old_page))
-
-        status = Status (tz.statusbar)
-        views = Option (tz.views)
-
-
-        for menu_item in views.get_menu ().children ():
-            menu_item.connect ("activate", self.view_change)
-
-	# fix for current map weirdness in dr mike's code.
-	views.get_menu ().children ()[0].activate ()
+                         self.nb.set_current_page (self.old_page))
 
-        label = GtkLabel (_("View:"))
-        hbox = GtkHBox (FALSE, 5)
-        hbox.pack_start (label, FALSE)
-        align = GtkAlignment (0.5, 0.5)
-        align.add (views)
-        hbox.pack_start (align, FALSE)
-        self.p1_align = align
-
-        systemUTCCopy = GtkCheckButton (_("System clock uses UTC"))
-        self.systemUTC = GtkCheckButton (_("System clock uses UTC"))
+        systemUTCCopy = gtk.CheckButton (_("System clock uses UTC"))
+        self.systemUTC = gtk.CheckButton (_("System clock uses UTC"))
 
         systemUTCCopy.connect ("toggled", self.copy_toggled, self.systemUTC)
         self.systemUTC.connect ("toggled", self.copy_toggled, systemUTCCopy)
 
         self.systemUTC.set_active (asUTC)
 
-        align = GtkAlignment (0.5, 0.5)
+        hbox = gtk.HBox(gtk.FALSE, 5)
+        align = gtk.Alignment (0.5, 0.5)
         align.add (self.systemUTC)
-        hbox.pack_start (align, FALSE)
+        hbox.pack_start (align, gtk.FALSE)
 
         pix = self.ics.readPixmap ("timezone.png")
         if pix:
-            a = GtkAlignment ()
+            a = gtk.Alignment ()
             a.add (pix)
             a.set (1.0, 0.0, 0.0, 0.0)
-            hbox.pack_start (a, TRUE)
+            hbox.pack_start (a, gtk.TRUE)
         
-        frame = GtkFrame ()
-        frame.set_shadow_type (SHADOW_NONE)
-        frame.add (map)
+        mainBox.pack_start(hbox, gtk.FALSE)
+        mainBox.pack_start(self.tz, gtk.TRUE, gtk.TRUE)
+        mainBox.set_border_width (5)
+       	nb.append_page (mainBox, gtk.Label (_("Location")))
         
-        mainBox.pack_start (hbox, FALSE)
-        box = GtkVBox (FALSE, 0)
-        box.pack_start (frame, FALSE)
-        box.pack_start (status, FALSE)
-        mainBox.pack_start (box, FALSE)
-        mainBox.pack_start (swList, TRUE)
-
-	tzBox = GtkVBox (FALSE)
-        sw = GtkScrolledWindow ()
-        sw.set_policy (POLICY_AUTOMATIC, POLICY_AUTOMATIC)
-	self.ulist = GtkCList (2)
-        self.ulist.connect ("draw", lambda widget, area, self=self:
+        # set up page 2
+	tzBox = gtk.VBox (gtk.FALSE)
+        sw = gtk.ScrolledWindow ()
+        sw.set_policy (gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+	self.ulist = gtk.CList (2)
+        self.ulist.connect ("expose-event", lambda widget, area, self=self:
                             self.ulist.moveto (self.old_ulist_row))
-        self.ulist.set_selection_mode (SELECTION_BROWSE)
+        self.ulist.set_selection_mode (gtk.SELECTION_BROWSE)
         self.ulist.freeze ()
         for zone in self.timeZones:
             self.ulist.append (("UTC%s" % (zone[0][0],), zone[0][1]))
@@ -237,41 +188,38 @@ class TimezoneWindow (InstallWindow):
         self.ulist.select_row (self.old_ulist_row, 0)
         sw.add (self.ulist)
         tzBox.pack_start (sw)
-        box = GtkHBox (FALSE)
-        align = GtkAlignment (0.5, 0.5)
-        self.daylightCB = GtkCheckButton (_("Use Daylight Saving Time (US only)"))
+        box = gtk.HBox (gtk.FALSE)
+        align = gtk.Alignment (0.5, 0.5)
+        self.daylightCB = gtk.CheckButton (_("Use Daylight Saving Time (US only)"))
         self.daylightCB.set_active (self.old_use_dst)
         align.add (self.daylightCB)
-        box.pack_start (align, FALSE)
+        box.pack_start (align, gtk.FALSE)
 
-        align = GtkAlignment (1.0, 0.5)
+        align = gtk.Alignment (1.0, 0.5)
         align.add (systemUTCCopy)
 
-        box.pack_start (align, TRUE)
-        tzBox.pack_start (box, FALSE)
+        box.pack_start (align, gtk.TRUE)
+        tzBox.pack_start (box, gtk.FALSE)
         tzBox.set_border_width (5)
         self.tzBox = tzBox
 
-        mainBox.set_border_width (5)
-	nb.append_page (mainBox, GtkLabel (_("Location")))
-        nb.append_page (tzBox, GtkLabel (_("UTC Offset")))
+        nb.append_page (tzBox, gtk.Label (_("UTC Offset")))
 
         def switch_page (widget, page, page_num, self=self):
             if page_num == 1:
-                self.ics.setNextEnabled (TRUE)
+                self.ics.setNextEnabled (gtk.TRUE)
             else:
                 self.view_change (None)
                 
         nb.connect ("switch_page", switch_page)
-        self.list.connect ("select_row", self.view_change)
         
-        box = GtkVBox (FALSE, 5)
+        box = gtk.VBox (gtk.FALSE, 5)
         box.pack_start (nb)
-#        self.systemUTC = GtkCheckButton (_("System clock uses UTC"))
+#        self.systemUTC = gtk.CheckButton (_("System clock uses UTC"))
 #        self.systemUTC.set_active (asUTC)
-#        align = GtkAlignment (0, 0)
+#        align = gtk.Alignment (0, 0)
 #        align.add (self.systemUTC)
-#        box.pack_start (align, FALSE)
+#        box.pack_start (align, gtk.FALSE)
         box.set_border_width (5)
 
         return box
diff --git a/iw/timezone_map_gui.py b/iw/timezone_map_gui.py
new file mode 100644
index 000000000..1fd0ec19d
--- /dev/null
+++ b/iw/timezone_map_gui.py
@@ -0,0 +1,293 @@
+#
+# timezone_map_gui.py: gui timezone map widget.
+#
+# 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 gobject
+import pango
+import gtk
+import gnome.canvas
+import string
+import re
+import math
+
+class Enum:
+    def __init__(self, *args):
+        i = 0
+        for arg in args:
+            self.__dict__[arg] = i
+            i += 1
+
+class TimezoneMap(gtk.VBox):
+    def __init__(self, zonetab, default="America/New_York",
+                 map='/usr/share/anaconda/pixmaps/map480.png'):
+        gtk.VBox.__init__(self, gtk.FALSE, 5)
+
+        # set up class member objects
+        self.zonetab = zonetab
+        self.markers = {}
+        self.highlightedEntry = None
+
+        # set up the map canvas
+        self.canvas = gnome.canvas.Canvas()
+        root = self.canvas.root()
+        pixbuf = gtk.gdk.pixbuf_new_from_file(map)
+        self.mapWidth = pixbuf.get_width()
+        self.mapHeight = pixbuf.get_height()
+        root.add(gnome.canvas.CanvasPixbuf, x=0, y=0, pixbuf=pixbuf)
+        x1, y1, x2, y2 = root.get_bounds()
+        self.canvas.set_scroll_region(x1, y1, x2, y2)
+        self.canvas.set_usize(x2, y2)
+        self.pack_start(self.canvas, gtk.FALSE, gtk.FALSE)
+
+        self.current = root.add(gnome.canvas.CanvasText, text='x',
+                                fill_color='red', anchor=gtk.ANCHOR_CENTER,
+                                weight=pango.WEIGHT_BOLD)
+        
+        root.connect("event", self.mapEvent)
+        self.canvas.connect("event", self.canvasEvent)
+
+        self.arrow = root.add(gnome.canvas.CanvasLine,
+                              fill_color='limegreen',
+                              width_pixels=2,
+                              first_arrowhead=gtk.FALSE,
+                              last_arrowhead=gtk.TRUE,
+                              arrow_shape_a=4.0,
+                              arrow_shape_b=8.0,
+                              arrow_shape_c=4.0,
+                              points=(0.0, 0.0, 0.0, 0.0))
+        self.arrow.hide()
+
+        # set up status bar
+        self.status = gtk.Statusbar()
+        self.status.set_has_resize_grip(gtk.FALSE)
+        self.statusContext = self.status.get_context_id("")
+        self.pack_start(self.status, gtk.FALSE, gtk.FALSE)
+
+        self.columns = Enum("TZ", "COMMENTS", "ENTRY")
+        
+        # set up list of timezones
+        self.listStore = gtk.ListStore(gobject.TYPE_STRING,
+                                       gobject.TYPE_STRING,
+                                       gobject.TYPE_PYOBJECT)
+        
+        for entry in zonetab.getEntries():
+            iter = self.listStore.append()
+            self.listStore.set_value(iter, self.columns.TZ, entry.tz)
+            if entry.comments:
+                self.listStore.set_value(iter, self.columns.COMMENTS,
+                                         entry.comments)
+            else:
+                self.listStore.set_value(iter, self.columns.COMMENTS, "")
+            self.listStore.set_value(iter, self.columns.ENTRY, entry)
+            
+            x, y = self.map2canvas(entry.lat, entry.long)
+            marker = root.add(gnome.canvas.CanvasText, x=x, y=y,
+                              text=u'\u00B7', fill_color='yellow',
+                              anchor=gtk.ANCHOR_CENTER,
+                              weight=pango.WEIGHT_BOLD)
+            self.markers[entry.tz] = marker
+            if entry.tz == default:
+                self.currentEntry = entry
+
+        self.listStore.set_sort_column_id(self.columns.TZ, gtk.SORT_ASCENDING)
+
+        self.listView = gtk.TreeView(self.listStore)
+        self.listView.connect("size-allocate", self.listScroll)
+        selection = self.listView.get_selection()
+        selection.connect("changed", self.selectionChanged)
+        self.listView.set_property("headers-visible", gtk.FALSE)
+        col = gtk.TreeViewColumn(None, gtk.CellRendererText(), text=0)
+        self.listView.append_column(col)
+        col = gtk.TreeViewColumn(None, gtk.CellRendererText(), text=1)
+        self.listView.append_column(col)
+
+        sw = gtk.ScrolledWindow ()
+        sw.add(self.listView)
+        sw.set_shadow_type(gtk.SHADOW_IN)
+        self.pack_start(sw, gtk.TRUE, gtk.TRUE)
+
+        self.setCurrent(self.currentEntry)
+
+    def getCurrent(self):
+        return self.currentEntry
+
+    def selectionChanged(self, selection, *args):
+        # XXX broken, returns None if there is no selection, so I have to
+        #     check before unpacking
+        rc = selection.get_selected()
+        if rc is None:
+            return
+        model, iter = rc
+        tz = self.listStore.get_value(iter, self.columns.TZ)
+        self.setCurrent(self.zonetab.findEntryByTZ(tz), skipList=1)
+
+    def listScroll(self, widget, *args):
+        # recenter the list
+        rc = self.listView.get_selection().get_selected()
+        if rc is None:
+            return
+        model, iter = rc
+        
+        path = self.listStore.get_path(iter)
+        col = self.listView.get_column(0)
+        self.listView.scroll_to_cell(path, col, gtk.TRUE, 0.5, 0.5)
+        
+    def mapEvent(self, widget, event=None):
+        if event.type == gtk.gdk.MOTION_NOTIFY:
+            x1, y1 = self.canvas.root().w2i(event.x, event.y)
+            lat, long = self.canvas2map(x1, y1)
+            last = self.highlightedEntry
+            self.highlightedEntry = self.zonetab.findNearest(lat, long)
+            if last != self.highlightedEntry:
+                self.status.pop(self.statusContext)
+                status = self.highlightedEntry.tz
+                if self.highlightedEntry.comments:
+                    status = "%s - %s" % (status,
+                                          self.highlightedEntry.comments)
+                self.status.push(self.statusContext, status)
+
+            x2, y2 = self.map2canvas(self.highlightedEntry.lat,
+                                       self.highlightedEntry.long)
+            self.arrow.set(points=(x1, y1, x2, y2))
+            self.arrow.show()
+        elif event.type == gtk.gdk.BUTTON_PRESS:
+            if event.button == 1:
+                self.setCurrent(self.highlightedEntry)
+                
+    def setCurrent(self, entry, skipList=0):
+        self.markers[self.currentEntry.tz].show()
+        self.currentEntry = entry
+        self.markers[self.currentEntry.tz].hide()
+        x, y = self.map2canvas(self.currentEntry.lat, self.currentEntry.long)
+        self.current.set(x=x, y=y)
+
+        if skipList:
+            return
+
+        iter = self.listStore.get_iter_root()
+        next = 1
+        while next:
+            if self.listStore.get_value(iter, self.columns.ENTRY) == self.currentEntry:
+                selection = self.listView.get_selection()
+                selection.unselect_all()
+                selection.select_iter(iter)
+                path = self.listStore.get_path(iter)
+                col = self.listView.get_column(0)
+                self.listView.scroll_to_cell(path, col, gtk.TRUE, 0.5, 0.5)
+                break
+            next = self.listStore.iter_next(iter)
+        
+    def canvasEvent(self, widget, event=None):
+        if event.type == gtk.gdk.LEAVE_NOTIFY:
+            self.arrow.hide()
+        
+    def map2canvas(self, lat, long):
+        x2 = self.mapWidth
+        y2 = self.mapHeight
+        x = x2 / 2.0 + (x2 / 2.0) * long / 180.0
+        y = y2 / 2.0 - (y2 / 2.0) * lat / 90.0
+        return (x, y)
+
+    def canvas2map(self, x, y):
+        x2 = self.mapWidth
+        y2 = self.mapHeight
+        long = (x - x2 / 2.0) / (x2 / 2.0) * 180.0
+        lat = (y2 / 2.0 - y) / (y2 / 2.0) * 90.0
+        return (lat, long)
+
+class ZoneTabEntry:
+    def __init__(self, code=None, lat=0, long=0, tz=None, comments=None):
+        self.code = code
+        self.lat = lat
+        self.long = long
+        self.tz = tz
+        self.comments = comments
+
+class ZoneTab:
+    def __init__(self, fn='/usr/share/zoneinfo/zone.tab'):
+        self.entries = []
+        self.readZoneTab(fn)
+
+    def getEntries(self):
+        return self.entries
+
+    def findEntryByTZ(self, tz):
+        for entry in self.entries:
+            if entry.tz == tz:
+                return entry
+        return None
+
+    def findNearest(self, lat, long):
+        nearestEntry = None
+        min = -1
+        for entry in self.entries:
+            dx = entry.long - long
+            dy = entry.lat - lat
+            dist = (dy * dy) + (dx * dx)
+            if dist < min or min == -1:
+                min = dist
+                nearestEntry = entry
+        return nearestEntry
+
+    def convertCoord(self, coord, type="lat"):
+        if type != "lat" and type != "long":
+            raise TypeError, "invalid coord type"
+        if type == "lat":
+            deg = 3
+        else:
+            deg = 4
+        degrees = string.atoi(coord[0:deg])
+        order = len(coord[deg:])
+        minutes = string.atoi(coord[deg:])
+        if degrees > 0:
+            return degrees + minutes/math.pow(10, order)
+        return degrees - minutes/math.pow(10, order)
+        
+    def readZoneTab(self, fn):
+        f = open(fn, 'r')
+        comment = re.compile("^#")
+        coordre = re.compile("[\+-]")
+        while 1:
+            line = f.readline()
+            if not line:
+                break
+            if comment.search(line):
+                continue
+            fields = string.split(line, '\t')
+            if len(fields) < 3:
+                continue
+            code = fields[0]
+            split = coordre.search(fields[1], 1)
+            lat = self.convertCoord(fields[1][:split.end() - 1], "lat")
+            long = self.convertCoord(fields[1][split.end() - 1:], "long")
+            tz = string.strip(fields[2])
+            if len(fields) > 3:
+                comments = string.strip(fields[3])
+            else:
+                comments = None
+            entry = ZoneTabEntry(code, lat, long, tz, comments)
+            self.entries.append(entry)
+
+if __name__ == "__main__":
+    zonetab = ZoneTab()
+    win = gtk.Window()
+    win.connect('destroy', gtk.mainquit)
+    map = TimezoneMap(zonetab)
+    vbox = gtk.VBox()
+    vbox.pack_start(map)
+    button = gtk.Button("Quit")
+    button.connect("pressed", gtk.mainquit)
+    vbox.pack_start(button, gtk.FALSE, gtk.FALSE)
+    win.add(vbox)
+    win.show_all()
+    gtk.mainloop()
+    
diff --git a/iw/welcome_gui.py b/iw/welcome_gui.py
index e16493e08..f57c2392c 100644
--- a/iw/welcome_gui.py
+++ b/iw/welcome_gui.py
@@ -11,8 +11,7 @@
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 
-from gtk import *
-from gnome.ui import *
+import gtk
 from iw_gui import *
 from translate import _, N_
 
@@ -27,17 +26,15 @@ class WelcomeWindow (InstallWindow):
 
     # WelcomeWindow tag="wel"
     def getScreen (self, configFileData):
-        frame = GtkFrame ()
-        frame.set_shadow_type (SHADOW_IN)
+        frame = gtk.Frame ()
+        frame.set_shadow_type (gtk.SHADOW_IN)
 
         image = configFileData["WelcomeScreen"]
         pix = self.ics.readPixmap(image)
         
         if pix:
-            box = GtkEventBox ()
-            style = box.get_style ().copy ()
-            style.bg[STATE_NORMAL] = style.white
-            box.set_style (style)
+            box = gtk.EventBox ()
+            box.modify_bg(gtk.STATE_NORMAL, box.get_style ().white)
             box.add (pix)
             frame.add (box)
 
@@ -69,42 +66,40 @@ class ReconfigWelcomeWindow (InstallWindow):
     def getScreen (self):
 
 
-	frame = GtkFrame ()
-        frame.set_shadow_type (SHADOW_IN)
+	frame = gtk.Frame ()
+        frame.set_shadow_type (gtk.SHADOW_IN)
 
-        box = GtkVBox (FALSE)
+        box = gtk.VBox (gtk.FALSE)
         box.set_border_width (5)
         frame.add (box)
 
         pix = self.ics.readPixmap ("first-375.png")
         
         if pix:
-            ebox = GtkEventBox ()
-            style = ebox.get_style ().copy ()
-            style.bg[STATE_NORMAL] = style.white
-            ebox.set_style (style)
+            ebox = gtk.EventBox ()
+            ebox.modify_bg(gtk.STATE_NORMAL, ebox.get_style ().white)
             ebox.add (pix)
-            box.pack_start (ebox, FALSE)
+            box.pack_start (ebox, gtk.FALSE)
 
-        label = GtkLabel(_("Would you like to configure your system?"))
-	label.set_line_wrap(TRUE)
+        label = gtk.Label(_("Would you like to configure your system?"))
+	label.set_line_wrap(gtk.TRUE)
 	label.set_alignment(0.0, 0.0)
 	label.set_usize(400, -1)
 
         box.pack_start(label)
         
-        radioBox = GtkVBox (FALSE)
-	self.continueChoice = GtkRadioButton (None, _("Yes"))
-	radioBox.pack_start(self.continueChoice, FALSE)
-	self.cancelChoice = GtkRadioButton(
+        radioBox = gtk.VBox (gtk.FALSE)
+	self.continueChoice = gtk.RadioButton (None, _("Yes"))
+	radioBox.pack_start(self.continueChoice, gtk.FALSE)
+	self.cancelChoice = gtk.RadioButton(
 		self.continueChoice, _("No"))
-	radioBox.pack_start(self.cancelChoice, FALSE)
+	radioBox.pack_start(self.cancelChoice, gtk.FALSE)
 
-	align = GtkAlignment()
+	align = gtk.Alignment()
 	align.add(radioBox)
 	align.set(0.5, 0.5, 0.0, 0.0)
 
-	box.pack_start(align, TRUE, TRUE)
+	box.pack_start(align, gtk.TRUE, gtk.TRUE)
 	box.set_border_width (5)
 	self.beingDisplayed = 1
 
diff --git a/iw/xconfig_gui.py b/iw/xconfig_gui.py
index cd82e8328..3fef65f35 100644
--- a/iw/xconfig_gui.py
+++ b/iw/xconfig_gui.py
@@ -18,9 +18,8 @@ import string
 import sys
 import iutil
 import glob
-import gdkpixbuf
 import gui
-from gtk import *
+import gtk
 from iw_gui import *
 from translate import _, N_
 from monitor import isValidSyncRange
@@ -33,7 +32,7 @@ class XCustomWindow (InstallWindow):
 
     def __init__ (self, ics):
         InstallWindow.__init__ (self, ics)
-        self.ics.setNextEnabled (TRUE)
+        self.ics.setNextEnabled (gtk.TRUE)
         
     def getNext (self):
         newmodes = {}
@@ -102,10 +101,10 @@ class XCustomWindow (InstallWindow):
 
         pix = self.ics.readPixmap (file)
         if pix:
-            self.monitor_align = GtkAlignment ()
+            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, TRUE, TRUE)
+            self.hbox.pack_start (self.monitor_align, gtk.TRUE, gtk.TRUE)
         self.hbox.show_all()
 
     def swap_monitor (self, num):
@@ -133,7 +132,7 @@ class XCustomWindow (InstallWindow):
 
     def display_desktop_pixmap(self, desktop):
         self.vbox4.destroy ()
-        self.vbox4 = GtkVBox ()
+        self.vbox4 = gtk.VBox ()
 
         if desktop == "GNOME":
            pix = self.ics.readPixmap("gnome.png")
@@ -143,10 +142,10 @@ class XCustomWindow (InstallWindow):
             pix = None
 
         if pix:
-            a = GtkAlignment ()
+            a = gtk.Alignment ()
             a.add (pix)
             a.set (0.5, 0.5, 1.0, 1.0)
-            self.vbox4.pack_start (a, TRUE, TRUE)
+            self.vbox4.pack_start (a, gtk.TRUE, gtk.TRUE)
 
         self.hbox4.pack_start (self.vbox4)
         self.hbox4.show_all ()
@@ -165,13 +164,13 @@ class XCustomWindow (InstallWindow):
         self.desktop = desktop
 
         # create toplevel packing structure
-        self.box = GtkVBox (FALSE)
+        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 = GtkHBox (FALSE, 5)
+        self.hbox = gtk.HBox (gtk.FALSE, 5)
         self.monitor_align = None
         self.desktop_align = None
         self.load_monitor_preview_pixmap("monitor.png")
@@ -185,34 +184,34 @@ class XCustomWindow (InstallWindow):
                 availableDepths.append(adepth)
         availableDepths.sort(self.numCompare)
 
-        hbox1 = GtkHBox (FALSE, 5)
-        hbox3 = GtkHBox (FALSE, 5)
-        hbox4 = GtkHBox (FALSE, 5)
+        hbox1 = gtk.HBox (gtk.FALSE, 5)
+        hbox3 = gtk.HBox (gtk.FALSE, 5)
+        hbox4 = gtk.HBox (gtk.FALSE, 5)
 
-        frame1 = GtkFrame (_("Color Depth:"))
+        frame1 = gtk.Frame (_("Color Depth:"))
         frame1.set_shadow_type (SHADOW_NONE)
         frame1.set_border_width (10)
-        hbox1.pack_start(frame1, TRUE, FALSE, 0)
+        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 = GtkCombo ()
-        self.depth_combo.entry.set_editable (FALSE)
+        self.depth_combo = gtk.Combo ()
+        self.depth_combo.entry.set_editable (gtk.FALSE)
         self.depth_combo.set_popdown_strings (self.avail_depths)
 
         frame1.add (self.depth_combo)
-        frame2 = GtkFrame (_("Screen Resolution:"))
+        frame2 = gtk.Frame (_("Screen Resolution:"))
         frame2.set_shadow_type (SHADOW_NONE)
         frame2.set_border_width (10)
-        hbox1.pack_start (frame2, TRUE, FALSE, 2)
+        hbox1.pack_start (frame2, gtk.TRUE, gtk.FALSE, 2)
 
         self.res_list = ["640x480", "800x600", "1024x768", "1152x864",
                          "1280x1024", "1400x1050", "1600x1200"]
 
-        self.res_combo = GtkCombo ()
-        self.res_combo.entry.set_editable (FALSE)
+        self.res_combo = gtk.Combo ()
+        self.res_combo.entry.set_editable (gtk.FALSE)
 
         # determine current selection, or if none exists, pick reasonable
         # defaults.
@@ -278,7 +277,7 @@ class XCustomWindow (InstallWindow):
         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, FALSE)
+        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
@@ -286,11 +285,11 @@ class XCustomWindow (InstallWindow):
         self.cantprobe = not self.videocard.primaryCard().canTestSafely()
 
         if not self.cantprobe:
-            test = GtkAlignment (.9, 0, 0, 0)
-            button = GtkButton (_("   Test Setting   "))
+            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, FALSE)
+            self.box.pack_start (test, gtk.FALSE)
 
         #--If both KDE and GNOME are selected
         if comps:
@@ -306,31 +305,31 @@ class XCustomWindow (InstallWindow):
         self.origDesktop = self.desktop.getDefaultDesktop()
 
         if gnomeSelected or kdeSelected:
-            hsep = GtkHSeparator ()
+            hsep = gtk.HSeparator ()
             self.box.pack_start (hsep)
 
             if gnomeSelected and kdeSelected:
-                frame3 = GtkFrame (_("Please choose your default desktop environment:"))
+                frame3 = gtk.Frame (_("Please choose your default desktop environment:"))
             else:
-                frame3 = GtkFrame (_("Your desktop environment is:"))
+                frame3 = gtk.Frame (_("Your desktop environment is:"))
                 
             frame3.set_shadow_type (SHADOW_NONE)
-            hbox3.pack_start (frame3, TRUE, FALSE, 2)
+            hbox3.pack_start (frame3, gtk.TRUE, gtk.FALSE, 2)
 
-            self.hbox4 = GtkHBox ()
+            self.hbox4 = gtk.HBox ()
             frame3.add (self.hbox4)
 
             # need to have this around so self.display_desktop_pixmap()
             # will work later. (messy)
-            self.vbox4 = GtkVBox()
+            self.vbox4 = gtk.VBox()
 
             if gnomeSelected and kdeSelected:
-                vbox3 = GtkVBox()
+                vbox3 = gtk.VBox()
                 
-                gnome_radio = GtkRadioButton (None, (_("GNOME")))
-                vbox3.pack_start (gnome_radio, TRUE, FALSE, 2)
-                kde_radio = GtkRadioButton(gnome_radio, (_("KDE")))            
-                vbox3.pack_start (kde_radio, TRUE, FALSE, 2)
+                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)
 
@@ -338,47 +337,47 @@ class XCustomWindow (InstallWindow):
                 
                 #--Set the desktop GUI widget to what the user has selected
                 if self.origDesktop == "GNOME":
-                    gnome_radio.set_active (TRUE)
+                    gnome_radio.set_active (gtk.TRUE)
                     self.display_desktop_pixmap("GNOME")
                 elif self.origDesktop == "KDE":
-                    kde_radio.set_active (TRUE)
+                    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(GtkLabel(self.origDesktop))
+                self.hbox4.pack_start(gtk.Label(self.origDesktop))
                 self.display_desktop_pixmap(self.origDesktop)
 
-            self.box.pack_start (hbox3, FALSE, TRUE, 2)
+            self.box.pack_start (hbox3, gtk.FALSE, gtk.TRUE, 2)
         else:
             gnome_radio = None
             kde_radio = None
 
-        hsep = GtkHSeparator ()
+        hsep = gtk.HSeparator ()
         self.box.pack_start (hsep)
 
-        frame4 = GtkFrame (_("Please choose your login type:"))
+        frame4 = gtk.Frame (_("Please choose your login type:"))
         frame4.set_shadow_type (SHADOW_NONE)
-        hbox4.pack_start (frame4, TRUE, FALSE, 2)
+        hbox4.pack_start (frame4, gtk.TRUE, gtk.FALSE, 2)
         
-        self.hbox5 = GtkHBox (TRUE, 2)
+        self.hbox5 = gtk.HBox (gtk.TRUE, 2)
         frame4.add (self.hbox5)
 
-        self.text = GtkRadioButton (None, (_("Text")))
-        self.graphical = GtkRadioButton (self.text, (_("Graphical")))
+        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 (TRUE)
+            self.text.set_active (gtk.TRUE)
         elif self.runLevel == 5:
-            self.graphical.set_active (TRUE)
+            self.graphical.set_active (gtk.TRUE)
 
-        self.hbox5.pack_start (self.graphical, FALSE, 2)
-        self.hbox5.pack_start (self.text, FALSE, 2)
+        self.hbox5.pack_start (self.graphical, gtk.FALSE, 2)
+        self.hbox5.pack_start (self.text, gtk.FALSE, 2)
         
-        self.box.pack_start (hbox4, FALSE, TRUE, 2)
+        self.box.pack_start (hbox4, gtk.FALSE, gtk.TRUE, 2)
 
         return self.box
 
@@ -388,10 +387,10 @@ class MonitorWindow (InstallWindow):
 
     def __init__ (self, ics):
         InstallWindow.__init__ (self, ics)
-        self.ics.setNextEnabled (FALSE)
+        self.ics.setNextEnabled (gtk.FALSE)
 
         # XXX - do not want to go backwards into "Make Bootdisk" screen ever
-        self.ics.setPrevEnabled (FALSE)
+        self.ics.setPrevEnabled (gtk.FALSE)
         
     def selectCb (self, ctree, node, column):
 
@@ -402,16 +401,16 @@ class MonitorWindow (InstallWindow):
 
         if not data:
             # they clicked on a tree tab (a manufacturer node)
-            self.ics.setNextEnabled (FALSE)
+            self.ics.setNextEnabled (gtk.FALSE)
             self.setSyncField(self.hEntry, "")
             self.setSyncField(self.vEntry, "")
-            self.hEntry.set_editable (FALSE)
-            self.vEntry.set_editable (FALSE)
+            self.hEntry.set_editable (gtk.FALSE)
+            self.vEntry.set_editable (gtk.FALSE)
             return
         else:
             (parent, monitor) = data
-            self.hEntry.set_editable (TRUE)
-            self.vEntry.set_editable (TRUE)
+            self.hEntry.set_editable (gtk.TRUE)
+            self.vEntry.set_editable (gtk.TRUE)
 
         if self.currentNode:
             (current_parent, current_monitor) = self.ctree.node_get_row_data (self.currentNode)
@@ -421,8 +420,8 @@ class MonitorWindow (InstallWindow):
         # otherwise fill in sync fields
         self.setSyncField(self.vEntry, monitor[2])
         self.setSyncField(self.hEntry, monitor[3])
-        self.hEntry.set_editable (TRUE)
-        self.vEntry.set_editable (TRUE)
+        self.hEntry.set_editable (gtk.TRUE)
+        self.vEntry.set_editable (gtk.TRUE)
 
         self.enableIfSyncsValid(self.hEntry, self.vEntry)
 
@@ -454,9 +453,9 @@ class MonitorWindow (InstallWindow):
         aval = entry.get_text()
         bval = other.get_text()
         if isValidSyncRange(aval) and isValidSyncRange(bval):
-            self.ics.setNextEnabled (TRUE)
+            self.ics.setNextEnabled (gtk.TRUE)
         else:
-            self.ics.setNextEnabled (FALSE)
+            self.ics.setNextEnabled (gtk.FALSE)
 
     def resetCb (self, data):
         (parent, monitor) = self.ctree.node_get_row_data (self.originalNode)
@@ -512,19 +511,17 @@ class MonitorWindow (InstallWindow):
         self.ignoreEntryChanges = 0
         self.ignoreTreeChanges = 0
 
-        box = GtkVBox (FALSE, 5)
+        box = gtk.VBox (gtk.FALSE, 5)
 
         # Monitor selection tree
-        self.ctree = GtkCTree ()
-        self.ctree.set_selection_mode (SELECTION_BROWSE)
-        self.ctree.set_expander_style(CTREE_EXPANDER_TRIANGLE)
-        self.ctree.set_line_style(CTREE_LINES_NONE)
+        self.ctree = gtk.CTree ()
+        self.ctree.set_selection_mode (gtk.SELECTION_BROWSE)
 
-        self.hEntry = GtkEntry ()
-        self.vEntry = GtkEntry () 
+        self.hEntry = gtk.Entry ()
+        self.vEntry = gtk.Entry () 
 
         fn = self.ics.findPixmap("monitor-small.png")
-        p = gdkpixbuf.new_from_file (fn)
+        p = gtk.gdk.pixbuf_new_from_file (fn)
         if p:
             self.monitor_p, self.monitor_b = p.render_pixmap_and_mask()
 
@@ -549,7 +546,7 @@ class MonitorWindow (InstallWindow):
             parent = self.ctree.insert_node (None, None, (title,), 2,
                                              self.monitor_p, self.monitor_b,
                                              self.monitor_p, self.monitor_b,
-                                             is_leaf = FALSE)
+                                             is_leaf = gtk.FALSE)
             # save location of top of tree
             if first:
                 first_node = parent
@@ -588,7 +585,7 @@ class MonitorWindow (InstallWindow):
                                              (title,),
                                              2, self.monitor_p, self.monitor_b,
                                              self.monitor_p, self.monitor_b,
-                                             is_leaf = FALSE)
+                                             is_leaf = gtk.FALSE)
 
             self.originalNode = self.ctree.insert_node (parent,
                                   None, (self.orig_name,), 2)
@@ -615,13 +612,13 @@ class MonitorWindow (InstallWindow):
             self.ignoreTreeChanges = 1
             self.ctree.select (select)
             self.ctree.expand (selParent)
-            self.ctree.connect ("draw", self.moveto, select)
+            self.ctree.connect ("map-event", self.moveto, select)
             self.ignoreTreeChanges = 0
 
-        sw = GtkScrolledWindow ()
+        sw = gtk.ScrolledWindow ()
         sw.add (self.ctree)
-        sw.set_policy (POLICY_NEVER, POLICY_AUTOMATIC)
-        box.pack_start (sw, TRUE, TRUE)
+        sw.set_policy (gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
+        box.pack_start (sw, gtk.TRUE, gtk.TRUE)
 
         self.hEntry.connect ("insert_text", self.insertCb, (self.hEntry, self.vEntry))
         self.vEntry.connect ("insert_text", self.insertCb, (self.vEntry, self.hEntry))
@@ -629,37 +626,37 @@ class MonitorWindow (InstallWindow):
         self.hEntry.connect ("changed", self.changedCb, (self.hEntry, self.vEntry))
         self.vEntry.connect ("changed", self.changedCb, (self.vEntry, self.hEntry))
 
-        self.reset = GtkButton (_("Restore original values"))
+        self.reset = gtk.Button (_("Restore original values"))
         self.reset.connect ("clicked", self.resetCb)
-        align = GtkAlignment
+        align = gtk.Alignment
 
-        align = GtkAlignment (1, 0.5)
+        align = gtk.Alignment (1, 0.5)
         align.add (self.reset)
         
-        synctable = GtkTable(2, 4, FALSE)
-        hlabel = GtkLabel (_("Horizontal Sync:"))
+        synctable = gtk.Table(2, 4, gtk.FALSE)
+        hlabel = gtk.Label (_("Horizontal Sync:"))
         hlabel.set_alignment (0, 0.5)
-        vlabel = GtkLabel (_("Vertical Sync:"))
+        vlabel = gtk.Label (_("Vertical Sync:"))
         vlabel.set_alignment (0, 0.5)
         
         self.hEntry.set_usize (80, 0)
         self.vEntry.set_usize (80, 0)
         
-        hz = GtkLabel (_("kHz"))
+        hz = gtk.Label (_("kHz"))
         hz.set_alignment (0, 0.5)
 
-        khz = GtkLabel (_("Hz"))
+        khz = gtk.Label (_("Hz"))
         khz.set_alignment (0, 0.5)
         
-        synctable.attach(hlabel, 0, 1, 0, 1, SHRINK, FILL, 5)
-        synctable.attach(self.hEntry, 1, 2, 0, 1, SHRINK)
-        synctable.attach(hz, 2, 3, 0, 1, FILL, FILL, 5)        
-        synctable.attach(vlabel, 0, 1, 1, 2, SHRINK, FILL, 5)
-        synctable.attach(self.vEntry, 1, 2, 1, 2, SHRINK)
-        synctable.attach(khz, 2, 3, 1, 2, FILL, FILL, 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, FALSE, FALSE)
+        box.pack_start (synctable, gtk.FALSE, gtk.FALSE)
         
         return box
 
@@ -807,12 +804,12 @@ class XConfigWindow (InstallWindow):
 
     # XConfigWindow tag="xconf"
     def getScreen (self, dispatch, xconfig, videocard, intf):
-        self.ics.setHelpEnabled (TRUE)
+        self.ics.setHelpEnabled (gtk.TRUE)
 
         def makeFormattedLabel(text):
-            label = GtkLabel (text)
-            label.set_justify (JUSTIFY_LEFT)
-            label.set_line_wrap (TRUE)        
+            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_usize (400, -1)
             return label
@@ -822,45 +819,43 @@ class XConfigWindow (InstallWindow):
         self.xconfig = xconfig
         self.intf = intf
 
-        box = GtkVBox (FALSE, 0)
+        box = gtk.VBox (gtk.FALSE, 0)
         box.set_border_width (0)
 
-        self.autoBox = GtkVBox (FALSE, 5)
+        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, FALSE)
+            box.pack_start (label, gtk.FALSE)
         elif arch == "i386":
             # but we can on everything else
-            self.autoBox = GtkVBox (FALSE, 5)
+            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, FALSE)
+            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, FALSE)
+            self.autoBox.pack_start (label, gtk.FALSE)
 
-            box.pack_start (self.autoBox, FALSE)
+            box.pack_start (self.autoBox, gtk.FALSE)
         else:
             # sparc
             return
             
         # Monitor selection tree
-        self.ctree = GtkCTree ()
-        self.ctree.set_selection_mode (SELECTION_BROWSE)
-        self.ctree.set_expander_style(CTREE_EXPANDER_TRIANGLE)
-        self.ctree.set_line_style(CTREE_LINES_NONE)
+        self.ctree = gtk.CTree ()
+        self.ctree.set_selection_mode (gtk.SELECTION_BROWSE)
 
         fn = self.ics.findPixmap("videocard.png")
-        p = gdkpixbuf.new_from_file (fn)
+        p = gtk.gdk.pixbuf_new_from_file (fn)
         if p:
             self.videocard_p, self.videocard_b = p.render_pixmap_and_mask()
 
@@ -871,19 +866,19 @@ class XConfigWindow (InstallWindow):
                                                                    (_("Generic"),), 2,
                                            self.videocard_p, self.videocard_b,
                                            self.videocard_p, self.videocard_b,
-                                           FALSE)
+                                           gtk.FALSE)
         self.manufacturer_nodes["Other"] = self.ctree.insert_node(None, None,
                                                                    (_("Other"),), 2,
                                            self.videocard_p, self.videocard_b,
                                            self.videocard_p, self.videocard_b,
-                                           FALSE)
+                                           gtk.FALSE)
         
         for man in self.videocard.manufacturerDB():
             self.manufacturer_nodes[man] = self.ctree.insert_node (None, None,
                                                                    (man,), 2,
                                            self.videocard_p, self.videocard_b,
                                            self.videocard_p, self.videocard_b,
-                                           FALSE)
+                                           gtk.FALSE)
 
         self.cards = self.videocard.cardsDB()
         cards = self.cards.keys()
@@ -950,22 +945,22 @@ class XConfigWindow (InstallWindow):
 
         #- Once ctree is realized then expand  branch and select selected item.
         self.ctree.connect ("tree_select_row", self.selectCb_tree)
-        self.ctree.connect ("draw", self.movetree, self.selected_node)
+        self.ctree.connect ("map-event", self.movetree, self.selected_node)
 
-        sw = GtkScrolledWindow ()
-        sw.set_policy (POLICY_NEVER, POLICY_AUTOMATIC)
+        sw = gtk.ScrolledWindow ()
+        sw.set_policy (gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
         sw.add (self.ctree)
-        box.pack_start (sw, TRUE)
+        box.pack_start (sw, gtk.TRUE)
 
         #Memory configuration menu
-        hbox = GtkHBox()
+        hbox = gtk.HBox()
         hbox.set_border_width(3)
             
-        label = GtkLabel (_("Video card RAM: "))
+        label = gtk.Label (_("Video card RAM: "))
 
-        self.ramOption = GtkOptionMenu()
+        self.ramOption = gtk.OptionMenu()
         self.ramOption.set_usize (40, 20)
-        self.ramMenu = GtkMenu()
+        self.ramMenu = gtk.Menu()
 
         for mem in self.videocard.possible_ram_sizes():
             if mem < 1000:
@@ -973,29 +968,29 @@ class XConfigWindow (InstallWindow):
             else:
                 tag = "%d MB" % (mem/1024)
 
-            memitem = GtkMenuItem(tag)
+            memitem = gtk.MenuItem(tag)
             self.ramMenu.add(memitem)
 
         self.selectVideoRamMenu(0)
-        hbox.pack_start(label, FALSE)
-        hbox.pack_start(self.ramOption, TRUE, TRUE, 25)
+        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, FALSE)
+        box.pack_start (hbox, gtk.FALSE)
 
-        restore = GtkButton (_("Restore original values"))
+        restore = gtk.Button (_("Restore original values"))
         restore.connect ("clicked", self.restorePressed)
-        hbox.pack_start(restore, FALSE, 25)
+        hbox.pack_start(restore, gtk.FALSE, 25)
         
-        self.skip = GtkCheckButton (_("Skip X Configuration"))
+        self.skip = gtk.CheckButton (_("Skip X Configuration"))
         self.skip.connect ("toggled", self.skipToggled) 
         
-        hbox = GtkHBox (TRUE, 5)
+        hbox = gtk.HBox (gtk.TRUE, 5)
         
-        self.topbox = GtkVBox (FALSE, 5)
+        self.topbox = gtk.VBox (gtk.FALSE, 5)
         self.topbox.set_border_width (5)
-        self.topbox.pack_start (box, TRUE, TRUE)
-        self.topbox.pack_start (self.skip, FALSE)
+        self.topbox.pack_start (box, gtk.TRUE, gtk.TRUE)
+        self.topbox.pack_start (self.skip, gtk.FALSE)
         
         self.configbox = box
         
diff --git a/lang-table b/lang-table
index 8744f726d..ccab9d72a 100644
--- a/lang-table
+++ b/lang-table
@@ -5,7 +5,7 @@ French		fr	lat0-sun16	iso15		fr_FR 		fr-latin1	Europe/Paris
 German		de      lat0-16         iso09           de_DE           de-latin1-nodeadkeys    Europe/Berlin
 Icelandic	is	lat0-sun16	iso15		is_IS 		is-latin1	Atlantic/Reykjavik
 Italian		it	lat0-sun16	iso15		it_IT		it		Europe/Rome
-Japanese	ja	Kon		None		ja_JP.eucJP	jp106		Asia/Tokyo
+Japanese	ja	Kon		None		ja_JP.UTF8	jp106		Asia/Tokyo
 Korean		ko	None		None		ko_KR.eucKR	us		Asia/Seoul
 Norwegian	no	lat0-sun16	iso15		no_NO		no-latin1	Europe/Oslo
 Russian 	ru 	cyr-sun16 	koi8-r		ru_RU.koi8r	ru		Europe/Moscow
diff --git a/minislang/.cvsignore b/minislang/.cvsignore
index 4671378ae..f26d8311f 100644
--- a/minislang/.cvsignore
+++ b/minislang/.cvsignore
@@ -1 +1,2 @@
 .depend
+*.lo
diff --git a/mouse.py b/mouse.py
index ff4d3bbb9..6ca7cd6c7 100644
--- a/mouse.py
+++ b/mouse.py
@@ -263,7 +263,7 @@ class Mouse (SimpleConfigFile):
 # maybe doesnt belong here - just ask user what mouse they have on
 # startup if kudzu didn't find one
 def mouseWindow(mouse):
-    from snack import *
+    from snack import ButtonChoiceWindow, SnackScreen
     from mouse_text import MouseWindow, MouseDeviceWindow
     from constants_text import INSTALL_BACK, INSTALL_OK
     import string
diff --git a/partitioning.py b/partitioning.py
index ce47c122c..8847194e6 100644
--- a/partitioning.py
+++ b/partitioning.py
@@ -1471,7 +1471,7 @@ class DiskSet:
                         ptype = part.fs_type.name
                     else:
                         ptype = None
-                    rc.append (device, ptype)
+                    rc.append((device, ptype))
                 part = disk.next_partition (part)
       
         return rc
diff --git a/splashscreen.py b/splashscreen.py
index 75b7ddd73..2144be3c1 100644
--- a/splashscreen.py
+++ b/splashscreen.py
@@ -18,11 +18,8 @@ os.environ["PYGTK_DISABLE_THREADS"] = "1"
 os.environ["PYGTK_FATAL_EXCEPTIONS"] = "1"
 os.environ["GNOME_DISABLE_CRASH_DIALOG"] = "1"
 
-from gtk import *
-from gtk import _root_window
+import gtk
 from flags import flags
-import GDK
-import gdkpixbuf
 
 splashwindow = None
 
@@ -32,33 +29,30 @@ def splashScreenShow(configFileData):
         path = ("/usr/X11R6/bin/xsetroot",)
         args = ("-solid", "gray45")
 
-        child = os.fork ()
+        child = os.fork()
         if (child == 0):
-            os.execv (path[0], path + args)
+            os.execv(path[0], path + args)
         try:
             pid, status = os.waitpid(child, 0)
         except OSError, (errno, msg):
             print __name__, "waitpid:", msg
 
-    root = _root_window ()
-    cursor = cursor_new (GDK.LEFT_PTR)
-    root.set_cursor (cursor)
+    root = gtk.gdk.get_default_root_window()
+    cursor = gtk.gdk.Cursor(gtk.gdk.LEFT_PTR)
+    root.set_cursor(cursor)
 
     def load_image(file):
-        try:
-            p = gdkpixbuf.new_from_file("/usr/share/anaconda/" + file)
-        except:
-            try:
-                p = gdkpixbuf.new_from_file("" + file)
-            except:
-                p = None
-                print "Unable to load", file
-
+        p = gtk.Image()
+        pixbuf = gtk.gdk.pixbuf_new_from_file("/usr/share/anaconda/" + file)
+        if pixbuf is None:
+            pixbuf = gtk.gdk.pixbuf_new_from_file(file)
+        if pixbuf:
+            p.set_from_pixbuf(pixbuf)
         return p
 
     global splashwindow
     
-    width = screen_width()
+    width = gtk.gdk.screen_width()
     p = None
 
     # If the xserver is running at 800x600 res or higher, use the
@@ -71,22 +65,19 @@ def splashScreenShow(configFileData):
         p = load_image('pixmaps/first-lowres.png')
                         
     if p:
-        pix = apply (GtkPixmap, p.render_pixmap_and_mask())
-        splashwindow = GtkWindow ()
-        splashwindow.set_position (WIN_POS_CENTER)
-        box = GtkEventBox ()
-        style = box.get_style ().copy ()
-        style.bg[STATE_NORMAL] = style.white
-        box.set_style (style)
-        box.add (pix)
-        splashwindow.add (box)
+        splashwindow = gtk.Window()
+        splashwindow.set_position(gtk.WIN_POS_CENTER)
+        box = gtk.EventBox()
+        box.modify_bg(gtk.STATE_NORMAL, box.get_style().white)
+        box.add(p)
+        splashwindow.add(box)
         box.show_all()
         splashwindow.show_now()
-        gdk_flush ()
-        while events_pending ():
-            mainiteration (FALSE)
+        gtk.gdk.flush()
+        while gtk.events_pending():
+            gtk.main_iteration(gtk.FALSE)
 
 def splashScreenPop():
     global splashwindow
     if splashwindow:
-        splashwindow.destroy ()
+        splashwindow.destroy()
diff --git a/translate.py b/translate.py
index b926adb67..285f47c09 100644
--- a/translate.py
+++ b/translate.py
@@ -13,23 +13,30 @@
 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #
 
-import gettext_rh
+import gettext
+import iconvcodec
 
 class i18n:
     def __init__(self):
-	self.langs = []
-        self.cat = gettext_rh.Catalog ("anaconda", "/usr/share/locale")
+        try:
+            self.cat = gettext.translation("anaconda")
+        except IOError:
+            self.cat = None
 
     def getlangs(self):
 	return self.langs
         
     def setlangs(self, langs):
+        self.__init__()
 	self.langs = langs
-        gettext_rh.setlangs (langs)
-        self.cat = gettext_rh.Catalog ("anaconda", "/usr/share/locale")
 
     def gettext(self, string):
-        return self.cat.gettext(string)
+        if not self.cat:
+            return string
+        try:
+            return self.cat.ugettext(string)
+        except TypeError:
+            return string
 
 def N_(str):
     return str