Viewing file:  firstbootWindow.py (23.36 KB) -rwxr-xr-x
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
## firstbootWindow.py - the main firstboot UI and framework.py
##
## Copyright (C) 2002, 2003 Red Hat, Inc.
## Copyright (C) 2002, 2003 Brent Fox <bfox@redhat.com>
##
## 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.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
import string
import os
import traceback
os.environ["PYGTK_DISABLE_THREADS"] = "1"
os.environ["PYGTK_FATAL_EXCEPTIONS"] = "1"
os.environ["GNOME_DISABLE_CRASH_DIALOG"] = "1"
import sys
import gtk
import functions
import firstbootBackend
from firstboot import Firstboot
from rhpl.translate import cat
from rhpl import ethtool
##
## I18N
##
from rhpl.translate import _, N_
import rhpl.translate as translate
translate.textdomain ("firstboot")
#
# Stuff for screenshots
#
screenshotDir = None
screenshotIndex = 0
class firstbootWindow:
def __init__(self, fb):
self.needsReboot = []
self.xserver_pid = fb.xserver_pid
self.wm_pid = fb.wm_pid
self.doReconfig = fb.doReconfig
self.doDebug = fb.doDebug
self.lowRes = fb.lowRes
self.autoscreenshot = fb.autoscreenshot
self.moduleList = []
self.moduleDict = {}
self.pageHistory = []
self.nextPage = None
# Create the initial window and a vbox to fill it with.
self.win = gtk.Window()
self.win.set_position(gtk.WIN_POS_CENTER)
self.win.set_decorated(False)
if not self.doReconfig:
self.win.set_keep_below(True)
self.x_screen = gtk.gdk.screen_width()
self.y_screen = gtk.gdk.screen_height()
# Create a box that will hold all other widgets.
self.mainHBox = gtk.HBox(False, 10)
# leftVBox holds the labels for the various modules.
self.leftVBox = gtk.VBox()
self.leftVBox.set_border_width(5)
# leftEventBox exists only so we have somewhere to paint an image.
self.leftEventBox = gtk.EventBox()
self.leftEventBox.add(self.leftVBox)
self.leftEventBox.connect("realize", self.leb_realized)
# rightVBox holds the notebook and the button box.
self.rightVBox = gtk.VBox()
self.rightVBox.set_border_width(5)
# If we're in low res mode, grow the right hand box to take up the
# entire window.
if self.x_screen >= 800:
self.leftEventBox.set_size_request(int(0.2*self.x_screen),
self.y_screen)
self.rightVBox.set_size_request(int(0.8*self.x_screen),
self.y_screen)
self.win.fullscreen()
else:
self.rightVBox.set_size_request(self.x_screen, self.y_screen)
self.win.set_size_request(self.x_screen, self.y_screen)
self.lowRes = 1
# Create a button box to handle navigation.
self.buttonBox = gtk.HButtonBox()
self.buttonBox.set_layout(gtk.BUTTONBOX_END)
self.buttonBox.set_spacing(10)
# Create the "go back" button, marking it insensitive by default.
self.backButton = gtk.Button(use_underline=True, stock='gtk-go-back',
label=_("_Back"))
self.backButton.set_sensitive(False)
self.backButton.connect('clicked', self.backClicked)
self.buttonBox.set_border_width(10)
self.buttonBox.pack_start(self.backButton)
# Create the "go forward" button.
self.nextButton = gtk.Button(use_underline=True, stock='gtk-go-forward',
label=_("_Forward"))
self.nextHandler = self.nextButton.connect('clicked', self.nextClicked)
self.buttonBox.pack_start(self.nextButton)
# Create the notebook. We use a ListView to control which page in the
# notebook is displayed.
self.notebook = gtk.Notebook()
if self.doDebug:
#self.modulePath = ('/usr/src/rhn/up2date/firstboot')
self.modulePath = ('/usr/share/firstboot/modules')
self.notebook.set_show_tabs(False)
self.notebook.set_scrollable(True)
self.notebook.set_show_border(False)
else:
self.modulePath = ('/usr/share/firstboot/modules')
self.notebook.set_show_tabs(False)
self.notebook.set_show_border(False)
self.notebook.connect("switch-page", self.switchPage)
sys.path.append(self.modulePath)
self.loadModules()
self.notebook.set_current_page(0)
self.setPointer(0)
# Add the widgets into the right side.
self.rightVBox.pack_start(self.notebook)
self.rightVBox.pack_start(self.buttonBox, expand=False)
# Add the widgets into the main widget.
if not self.lowRes:
self.mainHBox.pack_start(self.leftEventBox)
self.mainHBox.pack_start(self.rightVBox)
self.win.add(self.mainHBox)
self.win.connect("destroy", self.destroy)
self.winHandler = self.win.connect ("key-release-event",
self.keyRelease)
# This should really be in firstboot.py, but something about
# importing all the modules screws the keyboard up only when we
# start from rhgb. So here it is.
if not fb.doDebug:
from rhpl.keyboard import Keyboard
kbd = Keyboard()
kbd.read()
kbd.activate()
self.win.show_all()
self.win.present()
self.nextButton.grab_focus()
gtk.main()
def setPage(self, modulename):
self.nextPage = self.moduleNameToIndex[modulename][0]
def switchPage(self, notebook, page, page_num, *args):
# catch the switch page signal, so we can re poke modules
# that need a signal that they are being shown
try:
module = self.moduleList[page_num]
except:
pass
if hasattr(module, "updatePage"):
module.updatePage()
def destroy(self, *args):
#Exit the GTK loop
gtk.main_quit()
#Kill the window manager
if self.wm_pid and not self.doDebug:
os.kill(self.wm_pid, 15)
if self.xserver_pid and not self.doDebug:
os.kill(self.xserver_pid, 15)
#Exit firstboot. This should take down the X server as well
os._exit(0)
def finishClicked(self, *args):
try:
module = self.moduleList[self.notebook.get_current_page()]
except:
pass
#Call the apply method if it exists
try:
module.apply(self.notebook)
except:
pass
#Call exitFirstboot to do some cleanup before exiting
self.exitFirstboot()
def exitFirstboot(self, *args):
#Write the /etc/sysconfig/firstboot file to make sure firstboot doesn't run again
firstbootBackend.writeSysconfigFile(self.doDebug)
#Exit the GTK loop
gtk.main_quit()
if self.doDebug:
os._exit(0)
if self.wm_pid:
# Kill the window manager
os.kill(self.wm_pid, 15)
if self.doReconfig:
try:
os.unlink("/etc/reconfigSys")
except:
pass
if len(self.needsReboot) > 0:
dlg = gtk.MessageDialog(None, 0, gtk.MESSAGE_INFO, gtk.BUTTONS_OK,
_("The system must now reboot for some of your selections to take effect."))
dlg.set_position(gtk.WIN_POS_CENTER)
dlg.show_all()
dlg.run()
dlg.destroy()
os.system("/sbin/reboot")
if self.xserver_pid:
os.kill(self.xserver_pid, 15)
#Give the X server a second to exit
import time
time.sleep(1)
os._exit(0)
def nextClicked(self, *args):
try:
module = self.moduleList[self.notebook.get_current_page()]
except:
pass
if self.autoscreenshot:
self.takeScreenShot()
result = None
#Call the apply method if it exists
try:
result = module.apply(self.notebook)
except:
import exceptionWindow
(ty, value, tb) = sys.exc_info()
lst = traceback.format_exception(ty, value, tb)
text = string.joinfields(lst, "")
result = exceptionWindow.ExceptionWindow(module, text)
pass
# Store the name of every module that requires a reboot. This allows
# us to remove a single module if the user moves back and forth through
# the UI while still knowing that other modules still require reboot.
if hasattr(module, "needsReboot") and module.needsReboot:
print "adding needsReboot for %s" % module.moduleName
self.needsReboot.append(module.moduleName)
elif hasattr(module, "needsReboot") and not module.needsReboot:
if module.moduleName in self.needsReboot:
print "removing needsReboot for %s" % module.moduleName
self.needsReboot.remove(module.moduleName)
# record the current page as the new previous page
self.prevPage = self.moduleNameToIndex[module.__module__][0]
if result != None:
pgNum = self.moduleNameToIndex[module.__module__][0]
self.pageHistory.append(pgNum)
# print "self.pageHistory: %s" % self.pageHistory
if self.nextPage:
self.notebook.set_current_page(self.nextPage)
module = self.moduleList[self.nextPage]
self.nextPage = None
else:
self.notebook.next_page()
module = self.moduleList[self.notebook.get_current_page()]
#Call setPointer to make the left hand pointer move to the correct pointer
self.setPointer(self.moduleNameToIndex[module.__module__][1])
if "grabFocus" in dir(module):
#If the module needs to grab the focus, let it
module.grabFocus()
else:
#Something went wrong in the module. Don't advance
return
#Check to see if we're on the last page.
tmp = self.notebook.get_nth_page(self.notebook.get_current_page() + 1)
if not tmp:
self.nextButton.disconnect(self.nextHandler)
self.nextHandler = self.nextButton.connect('clicked', self.finishClicked)
self.nextButton.set_label(_("_Finish"))
self.nextButton.set_use_underline(True)
self.win.disconnect(self.winHandler)
self.winHandler = self.win.connect ("key-release-event", self.closeRelease)
self.backButton.set_sensitive(True)
def backClicked(self, *args):
# print "back: %s" % self.pageHistory
if len(self.pageHistory):
self.notebook.set_current_page(self.pageHistory[-1])
del self.pageHistory[-1]
else:
self.notebook.prev_page()
try:
module = self.moduleList[self.notebook.get_current_page()]
except:
pass
#Call setPointer to make the left hand pointer move to the correct pointer
self.setPointer(self.moduleNameToIndex[module.__module__][1])
if self.notebook.get_current_page() == 0:
self.backButton.set_sensitive(False)
self.nextButton.disconnect(self.nextHandler)
self.nextHandler = self.nextButton.connect('clicked', self.nextClicked)
self.nextButton.set_label('gtk-go-forward')
self.nextButton.set_use_stock(True)
self.nextButton.set_use_underline(True)
self.win.disconnect(self.winHandler)
self.winHandler = self.win.connect ("key-release-event", self.keyRelease)
def keyRelease(self, window, event):
if (event.keyval == gtk.keysyms.F12):
self.nextClicked()
if (event.keyval == gtk.keysyms.F11):
self.backClicked()
if (event.keyval == gtk.keysyms.Print and event.state & gtk.gdk.SHIFT_MASK):
self.takeScreenShot()
def closeRelease(self, window, event):
if (event.keyval == gtk.keysyms.F12):
self.finishClicked()
if (event.keyval == gtk.keysyms.F11):
self.backClicked()
def setPointer(self, number):
items = self.leftVBox.get_children()
for i in range(len(items)):
alignment, label = self.leftVBox.get_children()[i].get_children()
pix = alignment.get_children()[0]
if i == number:
pix.set_from_file("/usr/share/firstboot/pixmaps/pointer-white.png")
else:
pix.set_from_file("/usr/share/firstboot/pixmaps/pointer-blank.png")
def leb_realized(self, eb):
self.pixbuf = functions.pixbufFromPath("/usr/share/firstboot/pixmaps/firstboot-left.png")
scaledPixbuf = self.pixbuf.scale_simple(int(0.2*self.x_screen),
self.y_screen,
gtk.gdk.INTERP_BILINEAR)
bgimage = gtk.gdk.Pixmap(eb.window, int(0.2*self.x_screen),
self.y_screen, -1)
bgimage.draw_pixbuf(None, scaledPixbuf, 0, 0, 0, 0)
style = gtk.Style()
style.bg_pixmap[gtk.STATE_NORMAL] = bgimage
eb.set_style(style)
def checkNetwork(self):
# see if we have a non loopback interface up
intfs = ethtool.get_active_devices()
for intf in intfs:
if intf != "lo":
return 1
return 0
def loadModules(self):
self.moduleList = []
self.moduleDict = {}
# Generate a list of all of the module files (which becomes the list of
# all non-hidden files in the directory with extensions other than .py.
files = os.listdir(self.modulePath)
lst = []
for f in files:
if f[0] == '.':
continue
if f[-3:] != ".py":
continue
lst.append(f[:-3])
# Import each module, and filter out those
for module in lst:
cmd = ("import %s\nif %s.__dict__.has_key('childWindow'):"
"obj = %s.childWindow()") % (module, module, module)
try:
exec(cmd)
except:
print _("module import of %s failed: %s") % (module,sys.exc_type)
continue
# if the exec fails, skip this module
try:
obj = obj
except NameError:
continue
# XXX - hack to allow firstboot to pass in the parent class into language
# this will allow the language module to change firstboot's current locale
if module == "language" or hasattr(obj, "needsparent"):
obj.passInParent(self)
# if a module decides not to run, skip it first before trying any
# of the other hooks. bz #158095
if hasattr(obj, "skipme"):
# the module itself has decided for some reason that
# that it should not be shown, so skip it
continue
# if the module needs network access, and we dont have it, skip
# the module
if hasattr(obj, "needsnetwork"):
if not self.checkNetwork():
# we need a way to run some stuff from the modules
# if they have no network
if hasattr(obj, "noNetwork"):
obj.noNetwork()
continue
# If the module defines a moduleClass, it has to match the mode
# we're starting up in, otherwise it's always used. Add it to
# a dictionary keyed by the module's declared priority.
if hasattr(obj, "moduleClass"):
if (self.doReconfig and (obj.moduleClass == "reconfig")):
self.moduleDict[float(obj.runPriority)] = obj
elif (not self.doReconfig and (obj.moduleClass != "reconfig")):
self.moduleDict[float(obj.runPriority)] = obj
else:
self.moduleDict[float(obj.runPriority)] = obj
# Get the list of module priorities, sort them to determine a run
# order, and build a list with the modules in the proper order.
modulePriorityList = self.moduleDict.keys()
modulePriorityList.sort()
# Add the modules to the proper lists.
pages = 0
sidebarIndex = -1
self.moduleNameToIndex = {}
for priority in modulePriorityList:
# Add the module to the list of modules.
module = self.moduleDict[priority]
# Launch the module's GUI.
vbox = None
if self.doDebug:
try:
print "calling", module.moduleName
result = module.launch(self.doDebug)
if result is None:
continue
else:
vbox, pix, title = result
except:
import exceptionWindow
(ty, value, tb) = sys.exc_info()
lst = traceback.format_exception(ty, value, tb)
text = string.joinfields(lst, "")
exceptionWindow.ExceptionWindow(module, text)
pass
else:
try:
result = module.launch()
if result is None:
continue
else:
vbox, pix, title = result
except:
import exceptionWindow
(ty, value, tb) = sys.exc_info()
lst = traceback.format_exception(ty, value, tb)
text = string.joinfields(lst, "")
exceptionWindow.ExceptionWindow(module, text)
pass
continue
if vbox and title:
# If it launched, add it to the module list.
self.moduleList.append(module)
title_label = gtk.Label("")
title_label.set_alignment(0.0, 0.5)
title_label.set_markup("<span foreground='#000000' size='30000' font_family='Helvetica'><b>%s</b></span>" % (_(title)))
titleBox = gtk.HBox()
if pix:
titleBox.pack_start(pix, False)
titleBox.pack_start(title_label, True)
titleBox.set_spacing(8)
vbox.pack_start(titleBox, False)
vbox.reorder_child(titleBox, 0)
if self.lowRes:
# If we're in 640x480 mode, remove the title bars
vbox.remove(vbox.get_children()[0])
# If the module has a name, add it to the list of labels
if hasattr(module, "moduleName"):
if not hasattr(module, "noSidebar") or getattr(module, "noSidebar") == False:
hbox = gtk.HBox(False, 5)
pix = functions.imageFromFile("pointer-blank.png")
label = gtk.Label("")
label.set_markup("<span foreground='#FFFFFF'><b>%s</b></span>" % (_(module.moduleName)))
label.set_alignment(0.0, 0.5)
# Wrap the lines if they're too long
label.set_line_wrap(True)
(w, h) = self.leftEventBox.get_size_request()
label.set_size_request((int)(w*0.8), -1)
# Make sure the arrow is at the top of any wrapped line
alignment = gtk.Alignment(yalign=0.2)
alignment.add(pix)
hbox.pack_start(alignment, False)
hbox.pack_end(label, True)
self.leftVBox.pack_start(hbox, False, True, 3)
sidebarIndex += 1
# we need a non tranlated name for each module so we can
# jump around
self.moduleNameToIndex[module.__module__] = (pages, sidebarIndex)
self.notebook.append_page(vbox, gtk.Label(_(module.moduleName)))
else:
self.notebook.append_page(vbox, gtk.Label(" "))
self.moduleNameToIndex["unamemodule-%s" % pages] = (pages, sidebarIndex)
pages += 1
def clearNotebook(self):
for widget in self.leftVBox.get_children():
self.leftVBox.remove(widget)
pageNum = len(self.notebook.get_children())
for i in range(pageNum):
self.notebook.hide()
self.notebook.remove_page(i)
def changeLocale(self, lang, fullName):
lc, encoding = string.split(lang, ".")
prefix, suffix = string.split(lc, "_")
os.environ["RUNTIMELANG"] = fullName
os.environ["LANG"] = lc
os.environ["LC_NUMERIC"] = "C"
import locale
locale.setlocale(locale.LC_ALL, "")
newlangs = [lang, lc, prefix]
cat.setlangs(newlangs)
self.leftVBox.get_children()[0].get_children()[1].set_text(_("Welcome"))
# Change the locale on the buttons.
self.backButton.set_label('gtk-go-back')
self.backButton.set_use_stock(True)
self.backButton.set_use_underline(True)
self.nextButton.set_label('gtk-go-forward')
self.nextButton.set_use_stock(True)
self.nextButton.set_use_underline(True)
self.clearNotebook()
self.loadModules()
self.leftVBox.show_all()
self.notebook.show_all()
self.notebook.set_current_page(1)
def takeScreenShot(self):
global screenshotIndex
global screenshotDir
#Let's take some screenshots
if screenshotDir is None:
screenshotDir = "/root/firstboot-screenshots"
if not os.access(screenshotDir, os.R_OK):
try:
os.mkdir(screenshotDir)
except:
screenshotDir = None
screen_width = gtk.gdk.screen_width()
screen_height = gtk.gdk.screen_height()
src_x = (screen_width - 800) / 2
src_y = (screen_height - 600) / 2
screenshot = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8,
800, 600)
screenshot.get_from_drawable(gtk.gdk.get_default_root_window(),
gtk.gdk.colormap_get_system(),
src_x, src_y, 0, 0,
800, 600)
if screenshot:
while (1):
sname = "screenshot-%04d.png" % ( screenshotIndex,)
if not os.access(screenshotDir + '/' + sname, os.R_OK):
break
screenshotIndex = screenshotIndex + 1
screenshot.save (screenshotDir + '/' + sname, "png")
screenshotIndex = screenshotIndex + 1
|