home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / pyshared / DistUpgrade / DistUpgradeViewGtk.py < prev    next >
Encoding:
Python Source  |  2009-04-27  |  26.8 KB  |  680 lines
  1. # DistUpgradeViewGtk.py 
  2. #  
  3. #  Copyright (c) 2004-2006 Canonical
  4. #  
  5. #  Author: Michael Vogt <michael.vogt@ubuntu.com>
  6. # 
  7. #  This program is free software; you can redistribute it and/or 
  8. #  modify it under the terms of the GNU General Public License as 
  9. #  published by the Free Software Foundation; either version 2 of the
  10. #  License, or (at your option) any later version.
  11. # 
  12. #  This program is distributed in the hope that it will be useful,
  13. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. #  GNU General Public License for more details.
  16. # 
  17. #  You should have received a copy of the GNU General Public License
  18. #  along with this program; if not, write to the Free Software
  19. #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20. #  USA
  21.  
  22. import pygtk
  23. pygtk.require('2.0')
  24. import gtk
  25. import gtk.gdk
  26. import gtk.glade
  27. import vte
  28. import gobject
  29. import pango
  30. import sys
  31. import logging
  32. import time
  33. import subprocess
  34.  
  35. import apt
  36. import apt_pkg
  37. import os
  38.  
  39. from DistUpgradeApport import *
  40.  
  41. from DistUpgradeView import DistUpgradeView, FuzzyTimeToStr, InstallProgress, FetchProgress
  42. from SimpleGladeApp import SimpleGladeApp, bindtextdomain
  43.  
  44. import gettext
  45. from DistUpgradeGettext import gettext as _
  46.  
  47. def utf8(str):
  48.   return unicode(str, 'latin1').encode('utf-8')
  49.  
  50.  
  51. class GtkCdromProgressAdapter(apt.progress.CdromProgress):
  52.     """ Report the cdrom add progress
  53.         Subclass this class to implement cdrom add progress reporting
  54.     """
  55.     def __init__(self, parent):
  56.         self.status = parent.label_status
  57.         self.progress = parent.progressbar_cache
  58.         self.parent = parent
  59.     def update(self, text, step):
  60.         """ update is called regularly so that the gui can be redrawn """
  61.         if text:
  62.           self.status.set_text(text)
  63.         self.progress.set_fraction(step/float(self.totalSteps))
  64.         while gtk.events_pending():
  65.           gtk.main_iteration()
  66.     def askCdromName(self):
  67.         return (False, "")
  68.     def changeCdrom(self):
  69.         return False
  70.  
  71. class GtkOpProgress(apt.progress.OpProgress):
  72.   def __init__(self, progressbar):
  73.       self.progressbar = progressbar
  74.       #self.progressbar.set_pulse_step(0.01)
  75.       #self.progressbar.pulse()
  76.  
  77.   def update(self, percent):
  78.       #if percent > 99:
  79.       #    self.progressbar.set_fraction(1)
  80.       #else:
  81.       #    self.progressbar.pulse()
  82.       self.progressbar.set_fraction(percent/100.0)
  83.       while gtk.events_pending():
  84.           gtk.main_iteration()
  85.  
  86.   def done(self):
  87.       self.progressbar.set_text(" ")
  88.  
  89.  
  90. class GtkFetchProgressAdapter(FetchProgress):
  91.     # FIXME: we really should have some sort of "we are at step"
  92.     # xy in the gui
  93.     # FIXME2: we need to thing about mediaCheck here too
  94.     def __init__(self, parent):
  95.         FetchProgress.__init__(self)
  96.         # if this is set to false the download will cancel
  97.         self.status = parent.label_status
  98.         self.progress = parent.progressbar_cache
  99.         self.parent = parent
  100.         self.canceled = False
  101.         self.button_cancel = parent.button_fetch_cancel
  102.         self.button_cancel.connect('clicked', self.cancelClicked)
  103.     def cancelClicked(self, widget):
  104.         logging.debug("cancelClicked")
  105.         self.canceled = True
  106.     def mediaChange(self, medium, drive):
  107.         #print "mediaChange %s %s" % (medium, drive)
  108.         msg = _("Please insert '%s' into the drive '%s'") % (medium,drive)
  109.         dialog = gtk.MessageDialog(parent=self.parent.window_main,
  110.                                    flags=gtk.DIALOG_MODAL,
  111.                                    type=gtk.MESSAGE_QUESTION,
  112.                                    buttons=gtk.BUTTONS_OK_CANCEL)
  113.         dialog.set_markup(msg)
  114.         res = dialog.run()
  115.         dialog.destroy()
  116.         if res == gtk.RESPONSE_OK:
  117.             return True
  118.         return False
  119.     def start(self):
  120.         #logging.debug("start")
  121.         self.progress.set_fraction(0)
  122.         self.status.show()
  123.         self.button_cancel.show()
  124.     def stop(self):
  125.         #logging.debug("stop")
  126.         self.progress.set_text(" ")
  127.         self.status.set_text(_("Fetching is complete"))
  128.         self.button_cancel.hide()
  129.     def pulse(self):
  130.         # FIXME: move the status_str and progress_str into python-apt
  131.         # (python-apt need i18n first for this)
  132.         FetchProgress.pulse(self)
  133.         self.progress.set_fraction(self.percent/100.0)
  134.         currentItem = self.currentItems + 1
  135.         if currentItem > self.totalItems:
  136.             currentItem = self.totalItems
  137.  
  138.         if self.currentCPS > 0:
  139.             self.status.set_text(_("Fetching file %li of %li at %sB/s") % (currentItem, self.totalItems, apt_pkg.SizeToStr(self.currentCPS)))
  140.             self.progress.set_text(_("About %s remaining") % FuzzyTimeToStr(self.eta))
  141.         else:
  142.             self.status.set_text(_("Fetching file %li of %li") % (currentItem, self.totalItems))
  143.             self.progress.set_text("  ")
  144.  
  145.         while gtk.events_pending():
  146.             gtk.main_iteration()
  147.         return (not self.canceled)
  148.  
  149. class GtkInstallProgressAdapter(InstallProgress):
  150.     # timeout with no status change when the terminal is expanded
  151.     # automatically
  152.     TIMEOUT_TERMINAL_ACTIVITY = 240
  153.     
  154.     def __init__(self,parent):
  155.         InstallProgress.__init__(self)
  156.         self._cache = None
  157.         self.label_status = parent.label_status
  158.         self.progress = parent.progressbar_cache
  159.         self.expander = parent.expander_terminal
  160.         self.term = parent._term
  161.         self.parent = parent
  162.         # setup the child waiting
  163.         reaper = vte.reaper_get()
  164.         reaper.connect("child-exited", self.child_exited)
  165.         # some options for dpkg to make it die less easily
  166.         apt_pkg.Config.Set("DPkg::StopOnError","False")
  167.  
  168.     def startUpdate(self):
  169.         InstallProgress.startUpdate(self)
  170.         self.finished = False
  171.         # FIXME: add support for the timeout
  172.         # of the terminal (to display something useful then)
  173.         # -> longer term, move this code into python-apt 
  174.         self.label_status.set_text(_("Applying changes"))
  175.         self.progress.set_fraction(0.0)
  176.         self.progress.set_text(" ")
  177.         self.expander.set_sensitive(True)
  178.         self.term.show()
  179.         # if no libgnome2-perl is installed show the terminal
  180.         frontend= os.environ.get("DEBIAN_FRONTEND") or "gnome"
  181.         if frontend == "gnome" and self._cache:
  182.           if (not self._cache.has_key("libgnome2-perl") or 
  183.               not self._cache["libgnome2-perl"].isInstalled):
  184.             frontend = "dialog"
  185.             self.expander.set_expanded(True)
  186.         self.env = ["VTE_PTY_KEEP_FD=%s"% self.writefd,
  187.                     "APT_LISTCHANGES_FRONTEND=none"]
  188.         if not os.environ.has_key("DEBIAN_FRONTEND"):
  189.           self.env.append("DEBIAN_FRONTEND=%s" % frontend)
  190.         # do a bit of time-keeping
  191.         self.start_time = 0.0
  192.         self.time_ui = 0.0
  193.         self.last_activity = 0.0
  194.         
  195.     def error(self, pkg, errormsg):
  196.         InstallProgress.error(self, pkg, errormsg)
  197.         logging.error("got an error from dpkg for pkg: '%s': '%s'" % (pkg, errormsg))
  198.     # we do not report followup errors from earlier failures
  199.         if gettext.dgettext('dpkg', "dependency problems - leaving unconfigured") in errormsg:
  200.       return False
  201.  
  202.         #self.expander_terminal.set_expanded(True)
  203.         self.parent.dialog_error.set_transient_for(self.parent.window_main)
  204.         summary = _("Could not install '%s'") % pkg
  205.         msg = _("The upgrade will continue but the '%s' package may be "
  206.                 "in a not working state. Please consider submitting a "
  207.                 "bug report about it.") % pkg
  208.         markup="<big><b>%s</b></big>\n\n%s" % (summary, msg)
  209.         self.parent.dialog_error.realize()
  210.         self.parent.dialog_error.window.set_functions(gtk.gdk.FUNC_MOVE)
  211.         self.parent.label_error.set_markup(markup)
  212.         self.parent.textview_error.get_buffer().set_text(utf8(errormsg))
  213.         self.parent.scroll_error.show()
  214.         self.parent.dialog_error.run()
  215.         self.parent.dialog_error.hide()
  216.  
  217.     def conffile(self, current, new):
  218.         logging.debug("got a conffile-prompt from dpkg for file: '%s'" % current)
  219.         start = time.time()
  220.         #self.expander.set_expanded(True)
  221.         prim = _("Replace the customized configuration file\n'%s'?") % current
  222.         sec = _("You will lose any changes you have made to this "
  223.                 "configuration file if you choose to replace it with "
  224.                 "a newer version.")
  225.         markup = "<span weight=\"bold\" size=\"larger\">%s </span> \n\n%s" % (prim, sec)
  226.         self.parent.label_conffile.set_markup(markup)
  227.         self.parent.dialog_conffile.set_transient_for(self.parent.window_main)
  228.  
  229.         # now get the diff
  230.         if os.path.exists("/usr/bin/diff"):
  231.           cmd = ["/usr/bin/diff", "-u", current, new]
  232.           diff = utf8(subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate()[0])
  233.           self.parent.textview_conffile.get_buffer().set_text(diff)
  234.         else:
  235.           self.parent.textview_conffile.get_buffer().set_text(_("The 'diff' command was not found"))
  236.         res = self.parent.dialog_conffile.run()
  237.         self.parent.dialog_conffile.hide()
  238.         self.time_ui += time.time() - start
  239.         # if replace, send this to the terminal
  240.         if res == gtk.RESPONSE_YES:
  241.           self.term.feed_child("y\n")
  242.         else:
  243.           self.term.feed_child("n\n")
  244.         
  245.     def fork(self):
  246.         pid = self.term.forkpty(envv=self.env)
  247.         if pid == 0:
  248.           # WORKAROUND for broken feisty vte where envv does not work)
  249.           for env in self.env:
  250.             (key, value) = env.split("=")
  251.             os.environ[key] = value
  252.           # HACK to work around bug in python/vte and unregister the logging
  253.           #      atexit func in the child
  254.           sys.exitfunc = lambda: True
  255.         return pid
  256.  
  257.     def statusChange(self, pkg, percent, status):
  258.         # start the timer when the first package changes its status
  259.         if self.start_time == 0.0:
  260.           #print "setting start time to %s" % self.start_time
  261.           self.start_time = time.time()
  262.         self.progress.set_fraction(float(percent)/100.0)
  263.         self.label_status.set_text(status.strip())
  264.         # start showing when we gathered some data
  265.         if percent > 1.0:
  266.           self.last_activity = time.time()
  267.           self.activity_timeout_reported = False
  268.           delta = self.last_activity - self.start_time
  269.           # time wasted in conffile questions (or other ui activity)
  270.           delta -= self.time_ui
  271.           time_per_percent = (float(delta)/percent)
  272.           eta = (100.0 - percent) * time_per_percent
  273.           # only show if we have some sensible data (60sec < eta < 2days)
  274.           if eta > 61.0 and eta < (60*60*24*2):
  275.             self.progress.set_text(_("About %s remaining") % FuzzyTimeToStr(eta))
  276.           else:
  277.             self.progress.set_text(" ")
  278.  
  279.     def child_exited(self, term, pid, status):
  280.         self.apt_status = os.WEXITSTATUS(status)
  281.         self.finished = True
  282.  
  283.     def waitChild(self):
  284.         while not self.finished:
  285.             self.updateInterface()
  286.         return self.apt_status
  287.  
  288.     def finishUpdate(self):
  289.         self.label_status.set_text("")
  290.     
  291.     def updateInterface(self):
  292.         try:
  293.           InstallProgress.updateInterface(self)
  294.         except ValueError, e:
  295.           logging.error("got ValueError from InstallProgress.updateInterface. Line was '%s' (%s)" % (self.read, e))
  296.           # reset self.read so that it can continue reading and does not loop
  297.       self.read = ""
  298.         # check if we haven't started yet with packages, pulse then
  299.         if self.start_time == 0.0:
  300.           self.progress.pulse()
  301.           time.sleep(0.2)
  302.         # check about terminal activity
  303.         if self.last_activity > 0 and \
  304.            (self.last_activity + self.TIMEOUT_TERMINAL_ACTIVITY) < time.time():
  305.           if not self.activity_timeout_reported:
  306.             logging.warning("no activity on terminal for %s seconds (%s)" % (self.TIMEOUT_TERMINAL_ACTIVITY, self.label_status.get_text()))
  307.             self.activity_timeout_reported = True
  308.           self.parent.expander_terminal.set_expanded(True)
  309.         while gtk.events_pending():
  310.             gtk.main_iteration()
  311.     time.sleep(0.005)
  312.  
  313. class DistUpgradeVteTerminal(object):
  314.   def __init__(self, parent, term):
  315.     self.term = term
  316.     self.parent = parent
  317.   def call(self, cmd, hidden=False):
  318.     def wait_for_child(widget):
  319.       #print "wait for child finished"
  320.       self.finished=True
  321.     self.term.show()
  322.     self.term.connect("child-exited", wait_for_child)
  323.     self.parent.expander_terminal.set_sensitive(True)
  324.     if hidden==False:
  325.       self.parent.expander_terminal.set_expanded(True)
  326.     self.finished = False
  327.     pid = self.term.fork_command(command=cmd[0],argv=cmd)
  328.     if pid < 0:
  329.       # error
  330.       return 
  331.     while not self.finished:
  332.       while gtk.events_pending():
  333.         gtk.main_iteration()
  334.       time.sleep(0.1)
  335.     del self.finished
  336.  
  337. class DistUpgradeViewGtk(DistUpgradeView,SimpleGladeApp):
  338.     " gtk frontend of the distUpgrade tool "
  339.     def __init__(self, datadir=None, logdir=None):
  340.         self.logdir = logdir
  341.         if not datadir:
  342.           localedir=os.path.join(os.getcwd(),"mo")
  343.           gladedir=os.getcwd()
  344.         else:
  345.           localedir="/usr/share/locale/update-manager"
  346.           gladedir=os.path.join(datadir, "glade")
  347.  
  348.         # FIXME: i18n must be somewhere relative do this dir
  349.         try:
  350.           bindtextdomain("update-manager", localedir)
  351.           gettext.textdomain("update-manager")
  352.         except Exception, e:
  353.           logging.warning("Error setting locales (%s)" % e)
  354.         
  355.         icons = gtk.icon_theme_get_default()
  356.         try:
  357.           gtk.window_set_default_icon(icons.load_icon("update-manager", 32, 0))
  358.         except gobject.GError, e:
  359.           logging.debug("error setting default icon, ignoring (%s)" % e)
  360.           pass
  361.         SimpleGladeApp.__init__(self, gladedir+"/DistUpgrade.glade",
  362.                                 None, domain="update-manager")
  363.         self.prev_step = 0 # keep a record of the latest step
  364.         # we don't use this currently
  365.         #self.window_main.set_keep_above(True)
  366.         self.icontheme = gtk.icon_theme_get_default()
  367.         # we keep a reference pngloader around so that its in memory
  368.         # -> this avoid the issue that during the dapper->edgy upgrade
  369.         #    the loaders move from /usr/lib/gtk/2.4.0/loaders to 2.10.0
  370.         self.pngloader = gtk.gdk.PixbufLoader("png")
  371.         try:
  372.           self.svgloader = gtk.gdk.PixbufLoader("svg")
  373.           self.svgloader.close()
  374.         except gobject.GError, e:
  375.           logging.debug("svg pixbuf loader failed (%s)" % e)
  376.           pass
  377.         
  378.         self.window_main.realize()
  379.         self.window_main.window.set_functions(gtk.gdk.FUNC_MOVE)
  380.         self._opCacheProgress = GtkOpProgress(self.progressbar_cache)
  381.         self._fetchProgress = GtkFetchProgressAdapter(self)
  382.         self._cdromProgress = GtkCdromProgressAdapter(self)
  383.         self._installProgress = GtkInstallProgressAdapter(self)
  384.         # details dialog
  385.         self.details_list = gtk.ListStore(gobject.TYPE_STRING)
  386.         column = gtk.TreeViewColumn("")
  387.         render = gtk.CellRendererText()
  388.         column.pack_start(render, True)
  389.         column.add_attribute(render, "markup", 0)
  390.         self.treeview_details.append_column(column)
  391.         self.treeview_details.set_model(self.details_list)
  392.         self.vscrollbar_terminal.set_adjustment(self._term.get_adjustment())
  393.         # work around bug in VteTerminal here
  394.         self._term.realize()
  395.  
  396.         # Use italic style in the status labels
  397.         attrlist=pango.AttrList()
  398.         #attr = pango.AttrStyle(pango.STYLE_ITALIC, 0, -1)
  399.         attr = pango.AttrScale(pango.SCALE_SMALL, 0, -1)
  400.         attrlist.insert(attr)
  401.         self.label_status.set_property("attributes", attrlist)
  402.         # reasonable fault handler
  403.         sys.excepthook = self._handleException
  404.  
  405.     def _handleException(self, type, value, tb):
  406.       # we handle the exception here, hand it to apport and run the
  407.       # apport gui manually after it because we kill u-m during the upgrade
  408.       # to prevent it from poping up for reboot notifications or FF restart
  409.       # notifications or somesuch
  410.       import traceback
  411.       lines = traceback.format_exception(type, value, tb)
  412.       logging.error("not handled expection:\n%s" % "\n".join(lines))
  413.       # we can't be sure that apport will run in the middle of a upgrade
  414.       # so we still show a error message here
  415.       apport_crash(type, value, tb)
  416.       if not run_apport():
  417.         self.error(_("A fatal error occurred"),
  418.                    _("Please report this as a bug (if you haven't already) and include the "
  419.                      "files /var/log/dist-upgrade/main.log and "
  420.                      "/var/log/dist-upgrade/apt.log "
  421.                      "in your report. The upgrade is now aborted.\n"
  422.                      "Your original sources.list was saved in "
  423.                      "/etc/apt/sources.list.distUpgrade."),
  424.                    "\n".join(lines))
  425.       sys.exit(1)
  426.  
  427.     def getTerminal(self):
  428.         return DistUpgradeVteTerminal(self, self._term)
  429.  
  430.     def _key_press_handler(self, widget, keyev):
  431.       # user pressed ctrl-c
  432.       if len(keyev.string) == 1 and ord(keyev.string) == 3:
  433.         summary = _("Ctrl-c pressed")
  434.         msg = _("This will abort the operation and may leave the system "
  435.                 "in a broken state. Are you sure you want to do that?")
  436.         res = self.askYesNoQuestion(summary, msg)
  437.         logging.warning("ctrl-c press detected, user decided to pass it "
  438.                         "on: %s", res)        
  439.         return not res
  440.       return False
  441.  
  442.     def create_terminal(self, arg1,arg2,arg3,arg4):
  443.         " helper to create a vte terminal "
  444.         self._term = vte.Terminal()
  445.         self._term.connect("key-press-event", self._key_press_handler)
  446.         self._term.set_font_from_string("monospace 10")
  447.         self._term.connect("contents-changed", self._term_content_changed)
  448.         self._terminal_lines = []
  449.         try:
  450.           self._terminal_log = open(os.path.join(self.logdir,"term.log"),"w")
  451.         except Exception, e:
  452.           # if something goes wrong (permission denied etc), use stdout
  453.           self._terminal_log = sys.stdout
  454.         return self._term
  455.  
  456.     def _term_content_changed(self, term):
  457.         " called when the *visible* part of the terminal changes "
  458.         # get the current visible text, 
  459.         current_text = self._term.get_text(lambda a,b,c,d: True)
  460.         # see what we have currently and only print stuff that wasn't
  461.         # visible last time
  462.         new_lines = []
  463.         for line in current_text.split("\n"):
  464.           new_lines.append(line)
  465.           if not line in self._terminal_lines:
  466.             self._terminal_log.write(line+"\n")
  467.             self._terminal_log.flush()
  468.         self._terminal_lines = new_lines
  469.     def getFetchProgress(self):
  470.         return self._fetchProgress
  471.     def getInstallProgress(self, cache):
  472.         self._installProgress._cache = cache
  473.         return self._installProgress
  474.     def getOpCacheProgress(self):
  475.         return self._opCacheProgress
  476.     def getCdromProgress(self):
  477.         return self._cdromProgress
  478.     def updateStatus(self, msg):
  479.         self.label_status.set_text("%s" % msg)
  480.     def hideStep(self, step):
  481.         image = getattr(self,"image_step%i" % step)
  482.         label = getattr(self,"label_step%i" % step)
  483.         arrow = getattr(self,"arrow_step%i" % step)
  484.         image.hide()
  485.         label.hide()
  486.     def showStep(self, step):
  487.         image = getattr(self,"image_step%i" % step)
  488.         label = getattr(self,"label_step%i" % step)
  489.         image.show()
  490.         label.show()
  491.     def abort(self):
  492.         size = gtk.ICON_SIZE_MENU
  493.         step = self.prev_step
  494.         if step > 0:
  495.             image = getattr(self,"image_step%i" % step)
  496.             arrow = getattr(self,"arrow_step%i" % step)
  497.             image.set_from_stock(gtk.STOCK_CANCEL, size)
  498.             image.show()
  499.             arrow.hide()
  500.     def setStep(self, step):
  501.         if self.icontheme.rescan_if_needed():
  502.           logging.debug("icon theme changed, re-reading")
  503.         # first update the "previous" step as completed
  504.         size = gtk.ICON_SIZE_MENU
  505.         attrlist=pango.AttrList()
  506.         if self.prev_step:
  507.             image = getattr(self,"image_step%i" % self.prev_step)
  508.             label = getattr(self,"label_step%i" % self.prev_step)
  509.             arrow = getattr(self,"arrow_step%i" % self.prev_step)
  510.             label.set_property("attributes",attrlist)
  511.             image.set_from_stock(gtk.STOCK_APPLY, size)
  512.             image.show()
  513.             arrow.hide()
  514.         self.prev_step = step
  515.         # show the an arrow for the current step and make the label bold
  516.         image = getattr(self,"image_step%i" % step)
  517.         label = getattr(self,"label_step%i" % step)
  518.         arrow = getattr(self,"arrow_step%i" % step)
  519.         # check if that step was not hidden with hideStep()
  520.         if not label.get_property("visible"):
  521.           return
  522.         arrow.show()
  523.         image.hide()
  524.         attr = pango.AttrWeight(pango.WEIGHT_BOLD, 0, -1)
  525.         attrlist.insert(attr)
  526.         label.set_property("attributes",attrlist)
  527.  
  528.     def information(self, summary, msg, extended_msg=None):
  529.       self.dialog_information.set_transient_for(self.window_main)
  530.       msg = "<big><b>%s</b></big>\n\n%s" % (summary,msg)
  531.       self.label_information.set_markup(msg)
  532.       if extended_msg != None:
  533.         buffer = self.textview_information.get_buffer()
  534.         buffer.set_text(extended_msg)
  535.         self.scroll_information.show()
  536.       else:
  537.         self.scroll_information.hide()
  538.       self.dialog_information.realize()
  539.       self.dialog_information.window.set_functions(gtk.gdk.FUNC_MOVE)
  540.       self.dialog_information.run()
  541.       self.dialog_information.hide()
  542.       while gtk.events_pending():
  543.         gtk.main_iteration()
  544.  
  545.     def error(self, summary, msg, extended_msg=None):
  546.         self.dialog_error.set_transient_for(self.window_main)
  547.         #self.expander_terminal.set_expanded(True)
  548.         msg="<big><b>%s</b></big>\n\n%s" % (summary, msg)
  549.         self.label_error.set_markup(msg)
  550.         if extended_msg != None:
  551.             buffer = self.textview_error.get_buffer()
  552.             buffer.set_text(extended_msg)
  553.             self.scroll_error.show()
  554.         else:
  555.             self.scroll_error.hide()
  556.         self.dialog_error.realize()
  557.         self.dialog_error.window.set_functions(gtk.gdk.FUNC_MOVE)
  558.         self.dialog_error.run()
  559.         self.dialog_error.hide()
  560.         return False
  561.  
  562.     def confirmChanges(self, summary, changes, downloadSize, 
  563.                        actions=None, removal_bold=True):
  564.         # FIXME: add a whitelist here for packages that we expect to be
  565.         # removed (how to calc this automatically?)
  566.         if not DistUpgradeView.confirmChanges(self, summary, changes, downloadSize):
  567.           return False
  568.         # append warning
  569.         self.confirmChangesMessage +=  "\n\n<b>%s</b>" %  \
  570.             _("To prevent data loss close all open "
  571.               "applications and documents.")
  572.  
  573.         if actions != None:
  574.             self.button_cancel_changes.set_use_stock(False)
  575.             self.button_cancel_changes.set_use_underline(True)
  576.             self.button_cancel_changes.set_label(actions[0])
  577.             self.button_confirm_changes.set_label(actions[1])
  578.  
  579.         self.label_summary.set_markup("<big><b>%s</b></big>" % summary)
  580.         self.label_changes.set_markup(self.confirmChangesMessage)
  581.         # fill in the details
  582.         self.details_list.clear()
  583.         for dg in self.toDowngrade:
  584.             self.details_list.append([_("<b>Downgrade %s</b>") % dg])
  585.         for rm in self.toRemove:
  586.             s = _("Remove %s") % rm
  587.             if removal_bold:
  588.               s = "<b>%s</b>" % s
  589.             self.details_list.append([s])
  590.         for inst in self.toInstall:
  591.             self.details_list.append([_("Install %s") % inst])
  592.         for up in self.toUpgrade:
  593.             self.details_list.append([_("Upgrade %s") % up])
  594.         self.dialog_changes.set_transient_for(self.window_main)
  595.         # work around problem that scroll_to() does not 
  596.         # work when it is not realized
  597.         self.dialog_changes.realize()
  598.         self.treeview_details.realize()
  599.         self.treeview_details.set_cursor((0,))
  600.         self.treeview_details.scroll_to_point(0,0)
  601.         self.dialog_changes.window.set_functions(gtk.gdk.FUNC_MOVE)
  602.         res = self.dialog_changes.run()
  603.         self.dialog_changes.hide()
  604.         if res == gtk.RESPONSE_YES:
  605.             return True
  606.         return False
  607.  
  608.     def askYesNoQuestion(self, summary, msg, default='No'):
  609.         msg = "<big><b>%s</b></big>\n\n%s" % (summary,msg)
  610.         dialog = gtk.MessageDialog(parent=self.window_main,
  611.                                    flags=gtk.DIALOG_MODAL,
  612.                                    type=gtk.MESSAGE_QUESTION,
  613.                                    buttons=gtk.BUTTONS_YES_NO)
  614.         if default == 'No':
  615.           dialog.set_default_response(gtk.RESPONSE_NO)
  616.         else:
  617.           dialog.set_default_response(gtk.RESPONSE_YES)
  618.         dialog.set_markup(msg)
  619.         res = dialog.run()
  620.         dialog.destroy()
  621.         if res == gtk.RESPONSE_YES:
  622.             return True
  623.         return False
  624.     
  625.     def confirmRestart(self):
  626.         self.dialog_restart.set_transient_for(self.window_main)
  627.         self.dialog_restart.realize()
  628.         self.dialog_restart.window.set_functions(gtk.gdk.FUNC_MOVE)
  629.         res = self.dialog_restart.run()
  630.         self.dialog_restart.hide()
  631.         if res == gtk.RESPONSE_YES:
  632.             return True
  633.         return False
  634.  
  635.     def processEvents(self):
  636.         while gtk.events_pending():
  637.             gtk.main_iteration()
  638.  
  639.     def on_window_main_delete_event(self, widget, event):
  640.         self.dialog_cancel.set_transient_for(self.window_main)
  641.         self.dialog_cancel.realize()
  642.         self.dialog_cancel.window.set_functions(gtk.gdk.FUNC_MOVE)
  643.         res = self.dialog_cancel.run()
  644.         self.dialog_cancel.hide()
  645.         if res == gtk.RESPONSE_CANCEL:
  646.             sys.exit(1)
  647.         return True
  648.  
  649. if __name__ == "__main__":
  650.   
  651.   view = DistUpgradeViewGtk()
  652.   fp = GtkFetchProgressAdapter(view)
  653.   ip = GtkInstallProgressAdapter(view)
  654.  
  655.   cache = apt.Cache()
  656.   for pkg in sys.argv[1:]:
  657.     if cache[pkg].isInstalled:
  658.       cache[pkg].markDelete()
  659.     else:
  660.       cache[pkg].markInstall()
  661.   cache.commit(fp,ip)
  662.   gtk.main()
  663.   sys.exit(0)
  664.   
  665.   #sys.exit(0)
  666.   ip.conffile("TODO","TODO~")
  667.   view.getTerminal().call(["dpkg","--configure","-a"])
  668.   #view.getTerminal().call(["ls","-R","/usr"])
  669.   view.error("short","long",
  670.              "asfds afsdj af asdf asdf asf dsa fadsf asdf as fasf sextended\n"
  671.              "asfds afsdj af asdf asdf asf dsa fadsf asdf as fasf sextended\n"
  672.              "asfds afsdj af asdf asdf asf dsa fadsf asdf as fasf sextended\n"
  673.              "asfds afsdj af asdf asdf asf dsa fadsf asdf as fasf sextended\n"
  674.              "asfds afsdj af asdf asdf asf dsa fadsf asdf as fasf sextended\n"
  675.              "asfds afsdj af asdf asdf asf dsa fadsf asdf as fasf sextended\n"
  676.              "asfds afsdj af asdf asdf asf dsa fadsf asdf as fasf sextended\n"
  677.              )
  678.   view.confirmChanges("xx",[], 100)
  679.   
  680.