Merge lp:~mterry/update-manager/dialogs into lp:update-manager

[Michael Terry]

This branch implements a lot of the special purpose dialogs in the Software Updates spec.
https://wiki.ubuntu.com/SoftwareUpdates

Specifically, the new release, unsupported release, errors, and no updates dialogs.

Unmerged revisions

=== modified file 'UpdateManager/Core/MetaRelease.py'
--- UpdateManager/Core/MetaRelease.py	2012-06-12 01:40:26 +0000
+++ UpdateManager/Core/MetaRelease.py	2012-06-18 20:03:27 +0000
@@ -42,7 +42,7 @@
 except ImportError:
     from urllib2 import HTTPError, Request, URLError, urlopen
 
-from .utils import get_lang, get_dist, get_dist_description, get_ubuntu_flavor
+from .utils import get_lang, get_dist, get_dist_version, get_ubuntu_flavor, get_ubuntu_flavor_name
 
 class Dist(object):
     def __init__(self, name, version, date, supported):
@@ -79,9 +79,11 @@
         self.forceDownload = forceDownload
         # information about the available dists
         self.downloading = True
+        self.upgradable_to = None
         self.new_dist = None
+        self.flavor_name = get_ubuntu_flavor_name()
         self.current_dist_name = get_dist()
-        self.current_dist_description = get_dist_description()
+        self.current_dist_version = get_dist_version()
         self.no_longer_supported = None
 
         # default (if the conf file is missing)
@@ -248,8 +250,10 @@
         # only warn if unsupported and a new dist is available (because 
         # the development version is also unsupported)
         if upgradable_to != "" and not current_dist.supported:
+            self.upgradable_to = upgradable_to
             self.dist_no_longer_supported(current_dist)
         if upgradable_to != "":
+            self.upgradable_to = upgradable_to
             self.new_dist_available(upgradable_to)
 
         # parsing done and sucessfully

=== modified file 'UpdateManager/Core/utils.py'
--- UpdateManager/Core/utils.py	2012-06-13 11:40:17 +0000
+++ UpdateManager/Core/utils.py	2012-06-18 20:03:27 +0000
@@ -210,16 +210,16 @@
   p.stdout.close()
   return dist
 
-def get_dist_description():
-  " return the description of the current runing distro "
+def get_dist_version():
+  " return the version of the current running distro "
   # support debug overwrite
-  desc = os.environ.get("META_RELEASE_FAKE_DESCRIPTION")
+  desc = os.environ.get("META_RELEASE_FAKE_VERSION")
   if desc:
-      logging.warn("using fake release description '%s' (because of META_RELEASE_FAKE_DESCRIPTION environment) " % desc)
+      logging.warn("using fake release version '%s' (because of META_RELEASE_FAKE_VERSION environment) " % desc)
       return desc
   # then check the real one
   from subprocess import Popen, PIPE
-  p = Popen(["lsb_release","-d","-s"], stdout=PIPE, universal_newlines=True)
+  p = Popen(["lsb_release","-r","-s"], stdout=PIPE, universal_newlines=True)
   res = p.wait()
   if res != 0:
     sys.stderr.write("lsb_release returned exitcode: %i\n" % res)
@@ -395,6 +395,8 @@
     # this will (of course) not work in a server environment, 
     # but the main use case for this is to show the right
     # release notes
+    # TODO: actually examine which meta packages are installed, like
+    # DistUpgrade/DistUpgradeCache.py does and use that to choose a flavor.
     denv = os.environ.get("DESKTOP_SESSION", "")
     if "gnome" in denv:
         return "ubuntu"
@@ -407,6 +409,17 @@
     # default to ubuntu if nothing more specific is found
     return "ubuntu"
 
+def get_ubuntu_flavor_name():
+    flavor = get_ubuntu_flavor()
+    if flavor == "kubuntu":
+        return "Kubuntu"
+    elif flavor == "xubuntu":
+        return "Xubuntu"
+    elif flavor == "lubuntu":
+        return "Lubuntu"
+    else:
+        return "Ubuntu"
+
 def error(parent, summary, message):
   from gi.repository import Gtk, Gdk
   d = Gtk.MessageDialog(parent=parent,

=== added file 'UpdateManager/Dialogs.py'
--- UpdateManager/Dialogs.py	1970-01-01 00:00:00 +0000
+++ UpdateManager/Dialogs.py	2012-06-18 20:03:27 +0000
@@ -0,0 +1,237 @@
+# Dialogs.py
+# -*- coding: utf-8 -*-
+#  
+#  Copyright (c) 2012 Canonical
+#  
+#  Author: Michael Terry <[e-mail]>
+# 
+#  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+#  USA
+
+from __future__ import absolute_import, print_function
+
+from gi.repository import Gtk
+from gi.repository import GObject
+GObject.threads_init()
+
+import warnings
+warnings.filterwarnings("ignore", "Accessed deprecated property", DeprecationWarning)
+
+import dbus
+import os
+import subprocess
+import sys
+import time
+from .SimpleGtk3builderApp import SimpleGtkbuilderApp
+from .DistUpgradeFetcher import DistUpgradeFetcherGtk
+from .GtkProgress import GtkAcquireProgress
+
+from gettext import gettext as _
+
+class Dialog(SimpleGtkbuilderApp):
+  def __init__(self, window_main):
+    self.window_main = window_main
+    self.focus_button = None
+    SimpleGtkbuilderApp.__init__(self, self.window_main.datadir+"/gtkbuilder/Dialog.ui",
+                                 "update-manager")
+
+  def main(self):
+    self.window_main.push(self.pane_dialog, self)
+    if self.focus_button:
+      self.focus_button.grab_focus()
+
+  def run(self, parent=None):
+    if self.focus_button:
+      self.focus_button.grab_focus()
+    if parent:
+      self.window_dialog.set_transient_for(parent)
+      self.window_dialog.set_modal(True)
+    self.window_dialog.run()
+
+  def close(self):
+    sys.exit(0) # By default, exit the app
+
+  def add_button(self, label, callback, secondary=False):
+    # from_stock tries stock first and falls back to mnemonic
+    button = Gtk.Button.new_from_stock(label)
+    button.connect("clicked", lambda x: callback())
+    button.show()
+    self.buttonbox.add(button)
+    self.buttonbox.set_child_secondary(button, secondary)
+    return button
+
+  def add_settings_button(self):
+    if os.path.exists("/usr/bin/software-properties-gtk"):
+      return self.add_button(_("Settings…"), self.on_settings_button_clicked, secondary=True)
+    else:
+      return None
+
+  def on_settings_button_clicked(self):
+    cmd = ["/usr/bin/software-properties-gtk",
+           "--open-tab","2",
+           # FIXME: once get_xid() is available via introspections, add 
+           #        this back
+           #"--toplevel", "%s" % self.window_main.get_window().get_xid() 
+          ]
+    self.window_main.set_sensitive(False)
+    p = subprocess.Popen(cmd)
+    while p.poll() is None:
+        while Gtk.events_pending():
+            Gtk.main_iteration()
+        time.sleep(0.05)
+    self.window_main.set_sensitive(True)
+
+  def set_header(self, label):
+    self.label_header.set_label(label)
+
+  def set_desc(self, label):
+    self.label_desc.set_label(label)
+    self.label_desc.set_visible(bool(label))
+
+
+class NoUpdatesDialog(Dialog):
+  def __init__(self, window_main):
+    Dialog.__init__(self, window_main)
+    self.set_header(_("The software on this computer is up to date."))
+    self.add_settings_button()
+    self.focus_button = self.add_button(Gtk.STOCK_OK, self.close)
+
+
+class DistUpgradeDialog(Dialog):
+  def __init__(self, window_main, meta_release):
+    Dialog.__init__(self, window_main)
+    self.meta_release = meta_release
+    self.set_header(_("The software on this computer is up to date."))
+    # Translators: these are Ubuntu version names like "Ubuntu 12.04"
+    self.set_desc(_("However, %s %s is now available (you have %s).") % (
+                  meta_release.flavor_name,
+                  meta_release.upgradable_to.version,
+                  meta_release.current_dist_version))
+    self.add_settings_button()
+    self.add_button(_("Upgrade…"), self.upgrade)
+    self.focus_button = self.add_button(Gtk.STOCK_OK, self.close)
+
+  def upgrade(self):
+    progress = GtkAcquireProgress(self.window_main, self.window_main.datadir,
+                                  _("Downloading the release upgrade tool"))
+    fetcher = DistUpgradeFetcherGtk(new_dist=self.meta_release.upgradable_to,
+                                    parent=self.window_main,
+                                    progress=progress,
+                                    datadir=self.window_main.datadir)
+    if self.window_main.options.sandbox:
+      fetcher.run_options.append("--sandbox")
+    fetcher.run()
+
+
+class UnsupportedDialog(DistUpgradeDialog):
+  def __init__(self, window_main, meta_release):
+    DistUpgradeDialog.__init__(self, window_main, meta_release)
+    # Translators: this is an Ubuntu version name like "Ubuntu 12.04"
+    self.set_header(_("Software updates are no longer provided for %s %s.") % (
+                    meta_release.flavor_name,
+                    meta_release.current_dist_version))
+    # Translators: this is an Ubuntu version name like "Ubuntu 12.04"
+    self.set_desc(_("To stay secure, you should upgrade to %s %s.") % (
+                  meta_release.flavor_name,
+                  meta_release.upgradable_to.version))
+    print("Hello!")
+
+  def run(self, parent):
+    # This field is used in tests/test_end_of_life.py
+    print("Hello2!", self.window_main)
+    self.window_main.no_longer_supported_nag = self.window_dialog
+    DistUpgradeDialog.run(self, parent)
+
+
+class PartialUpgradeDialog(Dialog):
+  def __init__(self, window_main):
+    Dialog.__init__(self, window_main)
+    self.set_header(_("Not all updates can be installed"))
+    self.set_desc(_("""Run a partial upgrade, to install as many updates as possible. 
+
+This can be caused by:
+ * A previous upgrade which didn't complete
+ * Problems with some of the installed software
+ * Unofficial software packages not provided by Ubuntu
+ * Normal changes of a pre-release version of Ubuntu"""))
+    self.add_settings_button()
+    self.add_button(_("_Partial Upgrade"), self.upgrade)
+    self.focus_button = self.add_button(_("_Continue"), Gtk.main_quit)
+
+  def upgrade(self):
+    os.execl("/usr/bin/gksu",
+             "/usr/bin/gksu", "--desktop",
+             "/usr/share/applications/update-manager.desktop",
+             "--", "/usr/bin/update-manager", "--dist-upgrade")
+
+  def main(self):
+    Dialog.main(self)
+    # Block progress until user has answered this question
+    Gtk.main()
+
+
+class ErrorDialog(Dialog):
+  def __init__(self, window_main, header, desc=None):
+    Dialog.__init__(self, window_main)
+    self.set_header(header)
+    if desc:
+      self.set_desc(desc)
+      self.label_desc.set_selectable(True)
+    self.add_settings_button()
+    self.focus_button = self.add_button(Gtk.STOCK_OK, self.close)
+
+  def main(self):
+    Dialog.main(self)
+    # The label likes to start selecting everything (b/c it got focus before
+    # we switched to our default button).
+    self.label_desc.select_region(0, 0)
+    # Since errors usually are outside the normal flow, we'll guarantee that
+    # we don't continue with normal code flow by running our own loop here.
+    # We won't screw anything up because the only thing this dialog will do
+    # is exit.
+    Gtk.main()
+
+
+class NeedRestartDialog(Dialog):
+  def __init__(self, window_main):
+    Dialog.__init__(self, window_main)
+    self.set_header(_("The computer needs to restart to finish installing updates."))
+    self.focus_button = self.add_button(_("_Restart"), self.restart)
+
+  def restart(self, *args, **kwargs):
+    self._request_reboot_via_session_manager()
+
+  def _request_reboot_via_session_manager(self):
+    try:
+        bus = dbus.SessionBus()
+        proxy_obj = bus.get_object("org.gnome.SessionManager",
+                                   "/org/gnome/SessionManager")
+        iface = dbus.Interface(proxy_obj, "org.gnome.SessionManager")
+        iface.RequestReboot()
+    except dbus.DBusException:
+        self._request_reboot_via_consolekit()
+    except:
+        pass
+
+  def _request_reboot_via_consolekit(self):
+    try:
+        bus = dbus.SystemBus()
+        proxy_obj = bus.get_object("org.freedesktop.ConsoleKit",
+                                   "/org/freedesktop/ConsoleKit/Manager")
+        iface = dbus.Interface(proxy_obj, "org.freedesktop.ConsoleKit.Manager")
+        iface.Restart()
+    except dbus.DBusException:
+        pass
+

=== modified file 'UpdateManager/DistUpgradeFetcher.py'
--- UpdateManager/DistUpgradeFetcher.py	2012-06-12 01:40:26 +0000
+++ UpdateManager/DistUpgradeFetcher.py	2012-06-18 20:03:27 +0000
@@ -26,6 +26,7 @@
 from .ReleaseNotesViewer import ReleaseNotesViewer
 from .Core.utils import error, inhibit_sleep, allow_sleep
 from .Core.DistUpgradeFetcherCore import DistUpgradeFetcherCore
+from .SimpleGtk3builderApp import SimpleGtkbuilderApp
 from gettext import gettext as _
 try:
     from urllib.request import urlopen
@@ -38,10 +39,11 @@
 
 class DistUpgradeFetcherGtk(DistUpgradeFetcherCore):
 
-    def __init__(self, new_dist, progress, parent):
+    def __init__(self, new_dist, progress, parent, datadir):
         DistUpgradeFetcherCore.__init__(self,new_dist,progress)
-        self.parent = parent
-        self.window_main = parent.window_main
+        uifile = datadir + "gtkbuilder/ReleaseNotes.ui"
+        self.widgets = SimpleGtkbuilderApp(uifile, "update-manager")
+        self.window_main = parent
 
     def error(self, summary, message):
         return error(self.window_main, summary, message)
@@ -76,9 +78,9 @@
               from .ReleaseNotesViewerWebkit import ReleaseNotesViewerWebkit
               webkit_release_notes = ReleaseNotesViewerWebkit(self.new_dist.releaseNotesHtmlUri)
               webkit_release_notes.show()
-              self.parent.scrolled_notes.add(webkit_release_notes)
-              res = self.parent.dialog_release_notes.run()
-              self.parent.dialog_release_notes.hide()
+              self.widgets.scrolled_notes.add(webkit_release_notes)
+              res = self.widgets.dialog_release_notes.run()
+              self.widgets.dialog_release_notes.hide()
               if res == Gtk.ResponseType.OK:
                   return True
               return False
@@ -105,10 +107,10 @@
               notes = release_notes.read().decode("UTF-8", "replace")
               textview_release_notes = ReleaseNotesViewer(notes)
               textview_release_notes.show()
-              self.parent.scrolled_notes.add(textview_release_notes)
-              self.parent.dialog_release_notes.set_transient_for(self.window_main)
-              res = self.parent.dialog_release_notes.run()
-              self.parent.dialog_release_notes.hide()
+              self.widgets.scrolled_notes.add(textview_release_notes)
+              self.widgets.dialog_release_notes.set_transient_for(self.window_main)
+              res = self.widgets.dialog_release_notes.run()
+              self.widgets.dialog_release_notes.hide()
           except HTTPError:
               primary = "<span weight=\"bold\" size=\"larger\">%s</span>" % \
                         _("Could not find the release notes")
@@ -139,8 +141,3 @@
               return True
       return False
 
-if __name__ == "__main__":
-    error(None, "summary","message")
-    d = DistUpgradeFetcherGtk(None,None)
-    print(d.authenticate('/tmp/Release','/tmp/Release.gpg'))
-

=== modified file 'UpdateManager/GtkProgress.py'
--- UpdateManager/GtkProgress.py	2012-06-12 11:50:29 +0000
+++ UpdateManager/GtkProgress.py	2012-06-18 20:03:27 +0000
@@ -23,123 +23,27 @@
 
 from gi.repository import Gtk, Gdk
 import apt
-import apt_pkg
 from gettext import gettext as _
 from .Core.utils import humanize_size
-
-# intervals of the start up progress
-# 3x caching and menu creation
-STEPS_UPDATE_CACHE = [33, 66, 100]
-#STEPS_UPDATE_CACHE = [25, 50, 75, 100]
-
-class GtkOpProgressInline(apt.progress.base.OpProgress):
-    def __init__(self, progressbar, parent,                  
-                 steps=STEPS_UPDATE_CACHE):
-        # steps
-        self.all_steps = steps
-        self._init_steps()
-        # the progressbar to use
-        self._progressbar = progressbar
-        self._parent = parent
-        self._window = None
-    def _init_steps(self):
-        self.steps = self.all_steps[:]
-        self.base = 0
-        self.old = 0
-        self.next = int(self.steps.pop(0))
-    def update(self, percent=None):
-        super(GtkOpProgressInline, self).update(percent)
-        self._progressbar.show()
-        self._parent.set_sensitive(False)
-        # if the old percent was higher, a new progress was started
-        if self.old > self.percent:
-            # set the borders to the next interval
-            self.base = self.next
-            try:
-                self.next = int(self.steps.pop(0))
-            except:
-                pass
-        progress = self.base + self.percent/100 * (self.next - self.base)
-        self.old = self.percent
-        if abs(self.percent-self._progressbar.get_fraction()*100.0) > 0.5:
-            self._progressbar.set_text("%s" % self.op)
-            self._progressbar.set_fraction(progress/100.0)
-        while Gtk.events_pending():
-            Gtk.main_iteration()
-    def done(self):
-        """ one sub-step is done """
-        pass
-    def all_done(self):
-        """ all steps are completed (called by the parent) """
-        self._parent.set_sensitive(True)
-        self._progressbar.hide()
-        self._init_steps()
-
-class GtkOpProgressWindow(apt.progress.base.OpProgress):
-    def __init__(self, host_window, progressbar, status, parent,
-                 steps=STEPS_UPDATE_CACHE):
-        # used for the "one run progressbar"
-        self.steps = steps[:]
-        self.base = 0
-        self.old = 0
-        self.next = int(self.steps.pop(0))
-
-        self._parent = parent
-        self._window = host_window
-        self._status = status
-        self._progressbar = progressbar
-        # Do not show the close button 
-        self._window.realize()
-        self._window.set_title("")
-        host_window.get_window().set_functions(Gdk.WMFunction.MOVE)
-        self._window.set_transient_for(parent)
-
-    def update(self, percent=None):
-        super(GtkOpProgressWindow, self).update(percent)
-        #print(self.percent)
-        #print(self.Op)
-        #print(self.SubOp)
-        # only show progress bar if the parent is not iconified (#353195)
-        state = self._parent.window.get_state()
-        if not (state  & Gdk.WINDOW_STATE_ICONIFIED):
-            self._window.show()
-        self._parent.set_sensitive(False)
-        # if the old percent was higher, a new progress was started
-        if self.old > self.percent:
-            # set the borders to the next interval
-            self.base = self.next
-            try:
-                self.next = int(self.steps.pop(0))
-            except:
-                pass
-        progress = self.base + self.percent/100 * (self.next - self.base)
-        self.old = self.percent
-        if abs(self.percent-self._progressbar.get_fraction()*100.0) > 0.1:
-            self._status.set_markup("<i>%s</i>" % self.op)
-            self._progressbar.set_fraction(progress/100.0)
-        while Gtk.events_pending():
-            Gtk.main_iteration()
-
-    def done(self):
-        self._parent.set_sensitive(True)
-    def hide(self):
-        self._window.hide()
+from .SimpleGtk3builderApp import SimpleGtkbuilderApp
 
 class GtkAcquireProgress(apt.progress.base.AcquireProgress):
-    def __init__(self, parent, summary="", descr=""):
+    def __init__(self, parent, datadir, summary="", descr=""):
+        uifile = datadir + "gtkbuilder/AcquireProgress.ui"
+        self.widgets = SimpleGtkbuilderApp(uifile, "update-manager")
         # if this is set to false the download will cancel
         self._continue = True
         # init vars here
         # FIXME: find a more elegant way, this sucks
-        self.summary = parent.label_fetch_summary
-        self.status = parent.label_fetch_status
+        self.summary = self.widgets.label_fetch_summary
+        self.status = self.widgets.label_fetch_status
         # we need to connect the signal manual here, it won't work
         # from the main window auto-connect
-        parent.button_fetch_cancel.connect(
+        self.widgets.button_fetch_cancel.connect(
             "clicked", self.on_button_fetch_cancel_clicked)
-        self.progress = parent.progressbar_fetch
-        self.window_fetch = parent.window_fetch
-        self.window_fetch.set_transient_for(parent.window_main)
+        self.progress = self.widgets.progressbar_fetch
+        self.window_fetch = self.widgets.window_fetch
+        self.window_fetch.set_transient_for(parent)
         self.window_fetch.realize()
         self.window_fetch.get_window().set_functions(Gdk.WMFunction.MOVE)
         # set summary
@@ -183,28 +87,3 @@
             Gtk.main_iteration()
         return self._continue
 
-if __name__ == "__main__":
-    import apt
-    from .SimpleGtkbuilderApp import SimpleGtkbuilderApp
-
-    class MockParent(SimpleGtkbuilderApp):
-        """Mock parent for the fetcher that just loads the UI file"""
-        def __init__(self):
-            SimpleGtkbuilderApp.__init__(self, "../data/gtkbuilder/UpdateManager.ui", "update-manager")
-
-    # create mock parent and fetcher
-    parent = MockParent()
-    acquire_progress = GtkAcquireProgress(parent, "summary", "long detailed description")
-    #acquire_progress = GtkAcquireProgress(parent)
-
-    # download lists
-    cache = apt.Cache()
-    res = cache.update(acquire_progress)
-    # generate a dist-upgrade (to feed data to the fetcher) and get it
-    cache.upgrade()
-    pm = apt_pkg.PackageManager(cache._depcache)
-    fetcher = apt_pkg.Acquire(acquire_progress)
-    res = cache._fetch_archives(fetcher, pm)
-    print(res)
-    
-    

=== added file 'UpdateManager/InstallProgress.py'
--- UpdateManager/InstallProgress.py	1970-01-01 00:00:00 +0000
+++ UpdateManager/InstallProgress.py	2012-06-18 20:03:27 +0000
@@ -0,0 +1,93 @@
+# InstallProgress.py
+#  
+#  Copyright (c) 2004-2012 Canonical
+#                2004 Michiel Sikkes
+#                2005 Martin Willemoes Hansen
+#                2010 Mohamed Amine IL Idrissi
+#  
+#  Author: Michiel Sikkes <[e-mail]>
+#          Michael Vogt <[e-mail]>
+#          Martin Willemoes Hansen <[e-mail]>
+#          Mohamed Amine IL Idrissi <[e-mail]>
+#          Alex Launi <[e-mail]>
+#          Michael Terry <[e-mail]>
+# 
+#  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+#  USA
+
+from __future__ import absolute_import, print_function
+
+import warnings
+warnings.filterwarnings("ignore", "Accessed deprecated property", DeprecationWarning)
+
+import os
+import sys
+
+from .backend import get_backend
+
+from .Core.utils import (inhibit_sleep,
+                         allow_sleep)
+
+class InstallProgress(object):
+
+  def __init__(self, app):
+    self.window_main = app
+    self.datadir = app.datadir
+    self.options = app.options
+
+    # Used for inhibiting power management
+    self.sleep_cookie = None
+    self.sleep_dev = None
+
+    # get the install backend
+    self.install_backend = get_backend(self.datadir, self.window_main)
+    self.install_backend.connect("action-done", self._on_backend_done)
+
+  def invoke_manager(self):
+    # don't display apt-listchanges, we already showed the changelog
+    os.environ["APT_LISTCHANGES_FRONTEND"]="none"
+
+    # Do not suspend during the update process
+    (self.sleep_dev, self.sleep_cookie) = inhibit_sleep()
+
+    # If the progress dialog should be closed automatically afterwards
+    #settings = Gio.Settings("com.ubuntu.update-manager")
+    #close_on_done = settings.get_boolean("autoclose-install-window")
+    close_on_done = False # FIXME: confirm with mpt whether this should still be a setting
+
+    # Get the packages which should be installed and update
+    pkgs_install = []
+    pkgs_upgrade = []
+    for pkg in self.window_main.cache:
+        if pkg.marked_install:
+            pkgs_install.append(pkg.name)
+        elif pkg.marked_upgrade:
+            pkgs_upgrade.append(pkg.name)
+    self.install_backend.commit(pkgs_install, pkgs_upgrade, close_on_done)
+
+  def _on_backend_done(self, backend, action, authorized, success):
+    # Allow suspend after synaptic is finished
+    if self.sleep_cookie:
+        allow_sleep(self.sleep_dev, self.sleep_cookie)
+        self.sleep_cookie = self.sleep_dev = None
+
+    # Either launch main dialog and continue or quit altogether
+    if success:
+      self.window_main.start_available(allow_restart=True)
+    else:
+      sys.exit(0)
+
+  def main(self):
+    self.invoke_manager()

=== modified file 'UpdateManager/MetaReleaseGObject.py'
--- UpdateManager/MetaReleaseGObject.py	2012-05-01 14:01:29 +0000
+++ UpdateManager/MetaReleaseGObject.py	2012-06-18 20:03:27 +0000
@@ -30,8 +30,10 @@
                                 (GObject.TYPE_PYOBJECT,)),
         'dist_no_longer_supported' : (GObject.SignalFlags.RUN_LAST,
                                       None,
-                                      ())
-
+                                      ()),
+        'done_downloading' : (GObject.SignalFlags.RUN_LAST,
+                              None,
+                              ())
         }
 
     def __init__(self, useDevelopmentRelease=False, useProposed=False):
@@ -43,13 +45,13 @@
 
     def check(self):
         # check if we have a metarelease_information file
-        keepRuning = True
         if self.no_longer_supported is not None:
-            keepRuning = False
             self.emit("dist_no_longer_supported")
         if self.new_dist is not None:
-            keepRuning = False
-            self.emit("new_dist_available", self.new_dist)            
-        return keepRuning
-
+            self.emit("new_dist_available", self.new_dist)
+        if self.downloading:
+            return True
+        else:
+            self.emit("done_downloading")
+            return False
 

=== modified file 'UpdateManager/UnitySupport.py'
--- UpdateManager/UnitySupport.py	2011-08-11 11:47:34 +0000
+++ UpdateManager/UnitySupport.py	2012-06-18 20:03:27 +0000
@@ -51,15 +51,6 @@
 
     def _add_quicklist(self, parent):
             quicklist = Dbusmenu.Menuitem.new()
-            # update
-            update_dbusmenuitem = Dbusmenu.Menuitem.new()
-            update_dbusmenuitem.property_set(
-                Dbusmenu.MENUITEM_PROP_LABEL, _("Check for Updates"))
-            update_dbusmenuitem.property_set_bool(
-                Dbusmenu.MENUITEM_PROP_VISIBLE, True)
-            update_dbusmenuitem.connect (
-                "item-activated", parent.on_button_reload_clicked, None)
-            quicklist.child_append(update_dbusmenuitem)
             # install 
             self.install_dbusmenuitem = Dbusmenu.Menuitem.new()
             self.install_dbusmenuitem.property_set (Dbusmenu.MENUITEM_PROP_LABEL,

=== added file 'UpdateManager/UpdateManager.py'
--- UpdateManager/UpdateManager.py	1970-01-01 00:00:00 +0000
+++ UpdateManager/UpdateManager.py	2012-06-18 20:03:27 +0000
@@ -0,0 +1,335 @@
+# UpdateManager.py
+# -*- Mode: Python; indent-tabs-mode: nil; tab-width: 2; coding: utf-8 -*-
+#  
+#  Copyright (c) 2012 Canonical
+#  
+#  Author: Michael Terry <[e-mail]>
+# 
+#  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+#  USA
+
+from __future__ import absolute_import, print_function
+
+from gi.repository import Gtk
+from gi.repository import Gdk
+from gi.repository import Gio
+from gi.repository import GLib
+
+import warnings
+warnings.filterwarnings("ignore", "Accessed deprecated property", DeprecationWarning)
+
+import apt_pkg
+import os
+import sys
+from gettext import gettext as _
+
+import dbus
+import dbus.service
+from dbus.mainloop.glib import DBusGMainLoop
+DBusGMainLoop(set_as_default=True)
+
+from .UnitySupport import UnitySupport
+from .Dialogs import (DistUpgradeDialog,
+                      ErrorDialog,
+                      NeedRestartDialog,
+                      NoUpdatesDialog,
+                      PartialUpgradeDialog,
+                      UnsupportedDialog)
+from .InstallProgress import InstallProgress
+from .MetaReleaseGObject import MetaRelease
+from .UpdateProgress import UpdateProgress
+from .UpdatesAvailable import UpdatesAvailable
+from .Core.AlertWatcher import AlertWatcher
+from .Core.MyCache import MyCache
+from .Core.roam import NetworkManagerHelper
+from .Core.UpdateList import UpdateList
+
+# file that signals if we need to reboot
+REBOOT_REQUIRED_FILE = "/var/run/reboot-required"
+
+class UpdateManager(Gtk.Window):
+  """ This class is the main window and work flow controller.  Panes will add
+      themselves to the main window and it will morph between them."""
+
+  def __init__(self, datadir, options):
+    Gtk.Window.__init__(self)
+
+    # Public members
+    self.datadir = datadir
+    self.options = options
+    self.unity = UnitySupport()
+    self.controller = None
+    self.cache = None
+    self.update_list = None
+    self.meta_release = None
+
+    # Basic GTK+ parameters
+    self.set_title(_("Software Updater"))
+    self.set_icon_name("system-software-update")
+    self.set_resizable(False)
+    self.set_position(Gtk.WindowPosition.CENTER)
+    self.set_size_request(500,-1)
+
+    # Signals
+    self.connect("delete-event", self.close)
+
+    self._setup_dbus()
+
+    # deal with no-focus-on-map
+    if self.options and self.options.no_focus_on_map:
+        self.set_focus_on_map(False)
+        self.iconify()
+        self.stick()
+        self.set_urgency_hint(True)
+        self.unity.set_urgency(True)
+        self.initial_focus_id = self.connect(
+            "focus-in-event", self.on_initial_focus_in)
+
+    # Look for a new release in a thread
+    self.meta_release = MetaRelease(self.options and self.options.devel_release,
+                                    self.options and self.options.use_proposed)
+
+
+  def on_initial_focus_in(self, widget, event):
+      """callback run on initial focus-in (if started unmapped)"""
+      self.unstick()
+      self.set_urgency_hint(False)
+      self.unity.set_urgency(False)
+      self.disconnect(self.initial_focus_id)
+      return False
+
+  def push(self, pane, controller):
+    child = self.get_child()
+    if child is not None:
+      if self.controller and hasattr(self.controller, "save_state"):
+        self.controller.save_state()
+      child.destroy()
+
+    if pane is None:
+      self.controller = None
+      return
+
+    pane.reparent(self)
+    self.controller = controller
+
+    # Reset state
+    self.set_resizable(False)
+    self.set_sensitive(True)
+    if self.get_window() is not None:
+      self.get_window().set_cursor(None)
+      self.get_window().set_functions(Gdk.WMFunction.ALL)
+
+    if self.controller and hasattr(self.controller, "restore_state"):
+      self.controller.restore_state()
+
+    pane.show()
+    self.show()
+
+  def close(self, widget, data=None):
+    if not self.get_sensitive():
+      return True
+
+    if self.controller and hasattr(self.controller, "close"):
+      if self.controller.close(): # let controller handle it as they will
+        return
+
+    self.exit()
+
+  def exit(self):
+    """ exit the application, save the state """
+    self.push(None, None)
+    sys.exit(0)
+
+  def start_update(self):
+    if self.options.no_update:
+      self.start_available()
+      return
+
+    self._start_pane(UpdateProgress(self))
+
+  def start_available(self, allow_restart=False):
+    # If restart is needed, show that.  Else show no-update-needed.  Else
+    # actually show the available updates.
+    if allow_restart and os.path.exists(REBOOT_REQUIRED_FILE):
+        self._start_pane(NeedRestartDialog(self))
+        return
+
+    self._look_busy()
+    self.refresh_cache()
+
+    if self.cache.install_count == 0:
+      if not self._check_meta_release():
+        self._start_pane(NoUpdatesDialog(self))
+    else:
+      self._start_pane(UpdatesAvailable(self))
+
+  def start_install(self):
+    self._start_pane(InstallProgress(self))
+
+  def start_error(self, header, desc):
+    self._start_pane(ErrorDialog(self, header, desc))
+
+  def _start_pane(self, pane):
+    self._look_busy()
+    pane.main()
+
+  def _look_busy(self):
+    self.set_sensitive(False)
+    if self.get_window() is not None:
+      self.get_window().set_cursor(Gdk.Cursor.new(Gdk.CursorType.WATCH))
+
+  def _check_meta_release(self):
+    if self.meta_release is None:
+      return False
+
+    if self.meta_release.downloading:
+      # Block until we get an answer
+      GLib.idle_add(self._meta_release_wait_idle)
+      Gtk.main()
+
+    # Check if there is anything to upgrade to or a known-broken upgrade
+    next = self.meta_release.upgradable_to
+    if not next or next.upgrade_broken:
+      return False
+
+    # Check for end-of-life
+    if self.meta_release.no_longer_supported:
+      self._start_pane(UnsupportedDialog(self, self.meta_release))
+      return True
+
+    # Check for new fresh release
+    settings = Gio.Settings("com.ubuntu.update-manager")
+    if (self.meta_release.new_dist and
+        (self.options.check_dist_upgrades or
+         settings.get_boolean("check-dist-upgrades"))):
+      self._start_pane(DistUpgradeDialog(self, self.meta_release))
+      return True
+
+    return False
+
+  def _meta_release_wait_idle(self):
+    # 'downloading' is changed in a thread, but the signal 'done_downloading'
+    # is done in our thread's event loop.  So we know that it won't fire while
+    # we're in this function.
+    if not self.meta_release.downloading:
+      Gtk.main_quit()
+    else:
+      self.meta_release.connect("done_downloading", Gtk.main_quit)
+    return False
+
+  # fixme: we should probably abstract away all the stuff from libapt
+  def refresh_cache(self):
+    # get the lock
+    try:
+      apt_pkg.pkgsystem_lock()
+    except SystemError:
+      pass
+
+    try:
+      if self.cache is None:
+        self.cache = MyCache(None)
+      else:
+        self.cache.open(None)
+        self.cache._initDepCache()
+    except AssertionError:
+      # if the cache could not be opened for some reason,
+      # let the release upgrader handle it, it deals
+      # a lot better with this
+      self._start_pane(PartialUpgradeDialog(self))
+      # we assert a clean cache
+      header = _("Software index is broken")
+      desc = _("It is impossible to install or remove any software. "
+               "Please use the package manager \"Synaptic\" or run "
+               "\"sudo apt-get install -f\" in a terminal to fix "
+               "this issue at first.")
+      self.start_error(header, desc)
+    except SystemError as e:
+      header = _("Could not initialize the package information")
+      desc = _("An unresolvable problem occurred while "
+               "initializing the package information.\n\n"
+               "Please report this bug against the 'update-manager' "
+               "package and include the following error message:\n") + e
+      self.start_error(header, desc)
+
+    # Let the Gtk event loop breath if it hasn't had a chance.
+    while Gtk.events_pending():
+      Gtk.main_iteration()
+
+    self.update_list = UpdateList(self)
+    try:
+      self.update_list.update(self.cache)
+    except SystemError as e:
+      header = _("Could not calculate the upgrade")
+      desc = _("An unresolvable problem occurred while "
+               "calculating the upgrade.\n\n"
+               "Please report this bug against the 'update-manager' "
+               "package and include the following error message:\n") + e
+      self.start_error(header, desc)
+
+    self.unity.set_updates_count(self.cache.install_count)
+
+    if self.update_list.distUpgradeWouldDelete > 0:
+      self._start_pane(PartialUpgradeDialog(self))
+
+  def _setup_dbus(self):
+    """ this sets up a dbus listener if none is installed alread """
+    # check if there is another g-a-i already and if not setup one
+    # listening on dbus
+    try:
+        bus = dbus.SessionBus()
+    except:
+        print("warning: could not initiate dbus")
+        return
+    try:
+        proxy_obj = bus.get_object('org.freedesktop.UpdateManager', 
+                                   '/org/freedesktop/UpdateManagerObject')
+        iface = dbus.Interface(proxy_obj, 'org.freedesktop.UpdateManagerIFace')
+        iface.bringToFront()
+        #print("send bringToFront")
+        sys.exit(0)
+    except dbus.DBusException:
+         #print("no listening object (%s) " % e)
+         bus_name = dbus.service.BusName('org.freedesktop.UpdateManager',bus)
+         self.dbusController = UpdateManagerDbusController(self, bus_name)
+
+
+class UpdateManagerDbusController(dbus.service.Object):
+    """ this is a helper to provide the UpdateManagerIFace """
+    def __init__(self, parent, bus_name,
+                 object_path='/org/freedesktop/UpdateManagerObject'):
+        dbus.service.Object.__init__(self, bus_name, object_path)
+        self.parent = parent
+        self.alert_watcher = AlertWatcher ()
+        self.alert_watcher.connect("network-alert", self._on_network_alert)
+        self.connected = False
+
+    @dbus.service.method('org.freedesktop.UpdateManagerIFace')
+    def bringToFront(self):
+        self.parent.present()
+        return True
+
+    @dbus.service.method('org.freedesktop.UpdateManagerIFace')
+    def upgrade(self):
+        try:
+            self.parent.start_install()
+            return True
+        except:
+            return False
+
+    def _on_network_alert(self, watcher, state):
+        if state in NetworkManagerHelper.NM_STATE_CONNECTED_LIST:
+            self.connected = True
+        else:
+            self.connected = False

=== added file 'UpdateManager/UpdateProgress.py'
--- UpdateManager/UpdateProgress.py	1970-01-01 00:00:00 +0000
+++ UpdateManager/UpdateProgress.py	2012-06-18 20:03:27 +0000
@@ -0,0 +1,80 @@
+# UpdateProgress.py
+#  
+#  Copyright (c) 2004-2012 Canonical
+#                2004 Michiel Sikkes
+#                2005 Martin Willemoes Hansen
+#                2010 Mohamed Amine IL Idrissi
+#  
+#  Author: Michiel Sikkes <[e-mail]>
+#          Michael Vogt <[e-mail]>
+#          Martin Willemoes Hansen <[e-mail]>
+#          Mohamed Amine IL Idrissi <[e-mail]>
+#          Alex Launi <[e-mail]>
+#          Michael Terry <[e-mail]>
+# 
+#  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., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+#  USA
+
+from __future__ import absolute_import, print_function
+
+import warnings
+warnings.filterwarnings("ignore", "Accessed deprecated property", DeprecationWarning)
+
+import os
+import sys
+
+from .backend import get_backend
+
+from .Core.utils import (inhibit_sleep,
+                         allow_sleep)
+
+class UpdateProgress(object):
+
+  def __init__(self, app):
+    self.window_main = app
+    self.datadir = app.datadir
+    self.options = app.options
+
+    # Used for inhibiting power management
+    self.sleep_cookie = None
+    self.sleep_dev = None
+
+    # get the install backend
+    self.install_backend = get_backend(self.datadir, self.window_main)
+    self.install_backend.connect("action-done", self._on_backend_done)
+
+  def invoke_manager(self):
+    # don't display apt-listchanges
+    os.environ["APT_LISTCHANGES_FRONTEND"]="none"
+
+    # Do not suspend during the update process
+    (self.sleep_dev, self.sleep_cookie) = inhibit_sleep()
+
+    self.install_backend.update()
+
+  def _on_backend_done(self, backend, action, authorized, success):
+    # Allow suspend after synaptic is finished
+    if self.sleep_cookie:
+      allow_sleep(self.sleep_dev, self.sleep_cookie)
+      self.sleep_cookie = self.sleep_dev = None
+
+    # Either launch main dialog and continue or quit altogether
+    if success:
+      self.window_main.start_available()
+    else:
+      sys.exit(0)
+
+  def main(self):
+    self.invoke_manager()

=== renamed file 'UpdateManager/UpdateManager.py' => 'UpdateManager/UpdatesAvailable.py'
--- UpdateManager/UpdateManager.py	2012-06-12 13:17:46 +0000
+++ UpdateManager/UpdatesAvailable.py	2012-06-18 20:03:27 +0000
@@ -1,6 +1,6 @@
-# UpdateManager.py
+# UpdatesAvailable.py
 #  
-#  Copyright (c) 2004-2010 Canonical
+#  Copyright (c) 2004-2012 Canonical
 #                2004 Michiel Sikkes
 #                2005 Martin Willemoes Hansen
 #                2010 Mohamed Amine IL Idrissi
@@ -10,6 +10,7 @@
 #          Martin Willemoes Hansen <[e-mail]>
 #          Mohamed Amine IL Idrissi <[e-mail]>
 #          Alex Launi <[e-mail]>
+#          Michael Terry <[e-mail]>
 # 
 #  This program is free software; you can redistribute it and/or 
 #  modify it under the terms of the GNU General Public License as 
@@ -40,12 +41,8 @@
 
 import apt_pkg
 
-import gettext
-import sys
 import os
-import stat
 import re
-import locale
 import logging
 import operator
 import subprocess
@@ -53,33 +50,17 @@
 import threading
 import xml.sax.saxutils
 
-import dbus
-import dbus.service
-from dbus.mainloop.glib import DBusGMainLoop
-DBusGMainLoop(set_as_default=True)
-
-from .GtkProgress import GtkAcquireProgress, GtkOpProgressInline
-from .backend import get_backend
-
 from gettext import gettext as _
 from gettext import ngettext
 
 
-from .Core.utils import (humanize_size,
-                         init_proxy,
-                         on_battery,
-                         inhibit_sleep,
-                         allow_sleep)
-from .Core.UpdateList import UpdateList
-from .Core.MyCache import MyCache
+from .Core.utils import humanize_size
 from .Core.AlertWatcher import AlertWatcher
 
 from DistUpgrade.DistUpgradeCache import NotEnoughFreeSpaceError
-from .DistUpgradeFetcher import DistUpgradeFetcherGtk
 
 from .ChangelogViewer import ChangelogViewer
 from .SimpleGtk3builderApp import SimpleGtkbuilderApp
-from .MetaReleaseGObject import MetaRelease
 from .UnitySupport import UnitySupport
 
 
@@ -91,99 +72,19 @@
 # list constants
 (LIST_CONTENTS, LIST_NAME, LIST_PKG, LIST_ORIGIN, LIST_TOGGLE_CHECKED) = range(5)
 
-# actions for "invoke_manager"
-(INSTALL, UPDATE) = range(2)
-
-# file that signals if we need to reboot
-REBOOT_REQUIRED_FILE = "/var/run/reboot-required"
-
 # NetworkManager enums
 from .Core.roam import NetworkManagerHelper
 
-def show_dist_no_longer_supported_dialog(parent=None):
-    """ show a no-longer-supported dialog """
-    msg = "<big><b>%s</b></big>\n\n%s" % (
-        _("Your Ubuntu release is not supported anymore."),
-        _("You will not get any further security fixes or critical "
-          "updates. "
-          "Please upgrade to a later version of Ubuntu."))
-    dialog = Gtk.MessageDialog(parent, 0, Gtk.MessageType.WARNING,
-                               Gtk.ButtonsType.CLOSE,"")
-    dialog.set_title("")
-    dialog.set_markup(msg)
-    button = Gtk.LinkButton(uri="http://www.ubuntu.com/releaseendoflife",
-                            label=_("Upgrade information"))
-    button.show()
-    dialog.get_content_area().pack_end(button, True, True, 0)
-    # this data used in the test to get the dialog
-    if parent:
-        parent.no_longer_supported_nag = dialog
-    dialog.run()
-    dialog.destroy()
-    if parent:
-        del parent.no_longer_supported_nag
-
-
-class UpdateManagerDbusController(dbus.service.Object):
-    """ this is a helper to provide the UpdateManagerIFace """
-    def __init__(self, parent, bus_name,
-                 object_path='/org/freedesktop/UpdateManagerObject'):
-        dbus.service.Object.__init__(self, bus_name, object_path)
-        self.parent = parent
-        self.alert_watcher = AlertWatcher ()
-        self.alert_watcher.connect("network-alert", self._on_network_alert)
-        self.connected = False
-
-    @dbus.service.method('org.freedesktop.UpdateManagerIFace')
-    def bringToFront(self):
-        self.parent.window_main.present()
-        return True
-
-    @dbus.service.method('org.freedesktop.UpdateManagerIFace')
-    def update(self):
-        try:
-            self.alert_watcher.check_alert_state ()
-            self.parent.invoke_manager(UPDATE)
-            return self.connected
-        except:
-            return False
-
-    @dbus.service.method('org.freedesktop.UpdateManagerIFace')
-    def upgrade(self):
-        try:
-            self.parent.cache.checkFreeSpace()
-            self.parent.invoke_manager(INSTALL)
-            return True
-        except:
-            return False
-
-    @dbus.service.signal('org.freedesktop.UpdateManagerIFace', 'b')
-    def updated(self, success):
-        pass
-
-    def _on_network_alert(self, watcher, state):
-        if state in NetworkManagerHelper.NM_STATE_CONNECTED_LIST:
-            self.connected = True
-        else:
-            self.connected = False
-
-class UpdateManager(SimpleGtkbuilderApp):
-
-  # how many days until u-m warns about manual pressing "check"
-  NO_UPDATE_WARNING_DAYS = 7
-
-  def __init__(self, datadir, options):
-    self.setupDbus()
-    Gtk.Window.set_default_icon_name("system-software-update")
-    self.datadir = datadir
-    SimpleGtkbuilderApp.__init__(self, datadir+"gtkbuilder/UpdateManager.ui",
+class UpdatesAvailable(SimpleGtkbuilderApp):
+
+  def __init__(self, app):
+    self.window_main = app
+    self.datadir = app.datadir
+    self.options = app.options
+    self.cache = app.cache
+    self.list = app.update_list
+    SimpleGtkbuilderApp.__init__(self, self.datadir+"/gtkbuilder/UpdateManager.ui",
                                  "update-manager")
-    gettext.bindtextdomain("update-manager", "/usr/share/locale")
-    gettext.textdomain("update-manager")
-    try:
-        locale.setlocale(locale.LC_ALL, "")
-    except:
-        logging.exception("setlocale failed")
 
     # Used for inhibiting power management
     self.sleep_cookie = None
@@ -192,13 +93,12 @@
     # workaround for LP: #945536
     self.clearing_store = False
 
-    self.image_logo.set_from_icon_name("system-software-update", Gtk.IconSize.DIALOG)
-    self.window_main.set_sensitive(False)
-    self.window_main.grab_focus()
     self.button_close.grab_focus()
     self.dl_size = 0
     self.connected = True
 
+    self.settings =  Gio.Settings("com.ubuntu.update-manager")
+
     # create text view
     self.textview_changes = ChangelogViewer()
     self.textview_changes.show()
@@ -207,13 +107,13 @@
     changes_buffer.create_tag("versiontag", weight=Pango.Weight.BOLD)
 
     # expander
+    self.expander_details.set_expanded(self.settings.get_boolean("show-details"))
     self.expander_details.connect("activate", self.pre_activate_details)
     self.expander_details.connect("notify::expanded", self.activate_details)
     self.expander_desc.connect("notify::expanded", self.activate_desc)
 
     # useful exit stuff
-    self.window_main.connect("delete_event", self.close)
-    self.button_close.connect("clicked", lambda w: self.exit())
+    self.button_close.connect("clicked", lambda w: self.window_main.exit())
 
     # the treeview (move into it's own code!)
     self.store = Gtk.ListStore(str, str, GObject.TYPE_PYOBJECT, 
@@ -256,47 +156,14 @@
     if not os.path.exists("/usr/bin/software-properties-gtk"):
         self.button_settings.set_sensitive(False)
 
-    self.settings =  Gio.Settings("com.ubuntu.update-manager")
-    init_proxy(self.settings)
     # init show version
     self.show_versions = self.settings.get_boolean("show-versions")
     # init summary_before_name
     self.summary_before_name = self.settings.get_boolean("summary-before-name")
-    # keep track when we run (for update-notifier)
-    self.settings.set_int("launch-time", int(time.time()))
-
-    # get progress object
-    self.progress = GtkOpProgressInline(
-        self.progressbar_cache_inline, self.window_main)
-
-    #set minimum size to prevent the headline label blocking the resize process
-    self.window_main.set_size_request(500,-1) 
-    # restore details state, which will trigger a resize if necessary
-    self.expander_details.set_expanded(self.settings.get_boolean("show-details"))
-    # deal with no-focus-on-map
-    if options.no_focus_on_map:
-        self.window_main.set_focus_on_map(False)
-        if self.progress._window:
-            self.progress._window.set_focus_on_map(False)
-    # show the main window
-    self.window_main.show()
-    # get the install backend
-    self.install_backend = get_backend(self.window_main)
-    self.install_backend.connect("action-done", self._on_backend_done)
 
     # Create Unity launcher quicklist
     # FIXME: instead of passing parent we really should just send signals
     self.unity = UnitySupport(parent=self)
-
-    # it can only the iconified *after* it is shown (even if the docs
-    # claim otherwise)
-    if options.no_focus_on_map:
-        self.window_main.iconify()
-        self.window_main.stick()
-        self.window_main.set_urgency_hint(True)
-        self.unity.set_urgency(True)
-        self.initial_focus_id = self.window_main.connect(
-            "focus-in-event", self.on_initial_focus_in)
     
     # Alert watcher
     self.alert_watcher = AlertWatcher()
@@ -304,29 +171,10 @@
     self.alert_watcher.connect("battery-alert", self._on_battery_alert)
     self.alert_watcher.connect("network-3g-alert", self._on_network_3g_alert)
 
-
   def install_all_updates (self, menu, menuitem, data):
     self.select_all_updgrades (None)
     self.on_button_install_clicked (None)
 
-  def on_initial_focus_in(self, widget, event):
-      """callback run on initial focus-in (if started unmapped)"""
-      widget.unstick()
-      widget.set_urgency_hint(False)
-      self.unity.set_urgency(False)
-      self.window_main.disconnect(self.initial_focus_id)
-      return False
-
-  def warn_on_battery(self):
-      """check and warn if on battery"""
-      if on_battery():
-          self.dialog_on_battery.set_transient_for(self.window_main)
-          self.dialog_on_battery.set_title("")
-          res = self.dialog_on_battery.run()
-          self.dialog_on_battery.hide()
-          if res != Gtk.ResponseType.YES:
-              sys.exit()
-
   def install_column_view_func(self, cell_layout, renderer, model, iter, data):
     pkg = model.get_value(iter, LIST_PKG)
     if pkg is None:
@@ -344,39 +192,6 @@
     else: 
         renderer.set_property("activatable", True)
 
-  def setupDbus(self):
-    """ this sets up a dbus listener if none is installed alread """
-    # check if there is another g-a-i already and if not setup one
-    # listening on dbus
-    try:
-        bus = dbus.SessionBus()
-    except:
-        print("warning: could not initiate dbus")
-        return
-    try:
-        proxy_obj = bus.get_object('org.freedesktop.UpdateManager', 
-                                   '/org/freedesktop/UpdateManagerObject')
-        iface = dbus.Interface(proxy_obj, 'org.freedesktop.UpdateManagerIFace')
-        iface.bringToFront()
-        #print("send bringToFront")
-        sys.exit(0)
-    except dbus.DBusException:
-         #print("no listening object (%s) " % e)
-         bus_name = dbus.service.BusName('org.freedesktop.UpdateManager',bus)
-         self.dbusController = UpdateManagerDbusController(self, bus_name)
-
-
-  def on_checkbutton_reminder_toggled(self, checkbutton):
-    self.settings.set_boolean("remind-reload",
-                              not checkbutton.get_active())
-
-  def close(self, widget, data=None):
-    if self.window_main.get_property("sensitive") is False:
-        return True
-    else:
-        self.exit()
-
-  
   def set_changes_buffer(self, changes_buffer, text, name, srcpkg):
     changes_buffer.set_text("")
     lines = text.split("\n")
@@ -600,77 +415,11 @@
           self.hbox_downsize.show()
           self.vbox_alerts.show()
 
-  def _get_last_apt_get_update_minutes(self):
-      """
-      Return the number of minutes since the last successful apt-get update
-      
-      If the date is unknown, return "None"
-      """
-      if not os.path.exists("/var/lib/apt/periodic/update-success-stamp"):
-          return None
-      # calculate when the last apt-get update (or similar operation)
-      # was performed
-      mtime = os.stat("/var/lib/apt/periodic/update-success-stamp")[stat.ST_MTIME]
-      ago_minutes = int((time.time() - mtime) / 60 )
-      return ago_minutes
-
-  def _get_last_apt_get_update_text(self):
-      """
-      return a human readable string with the information when
-      the last apt-get update was run
-      """
-      ago_minutes = self._get_last_apt_get_update_minutes()
-      if ago_minutes is None:
-          return _("It is unknown when the package information was "
-                   "updated last. Please click the 'Check' "
-                   "button to update the information.")
-      ago_hours = int( ago_minutes / 60 )
-      ago_days = int( ago_hours / 24 )
-      if ago_days > self.NO_UPDATE_WARNING_DAYS:
-          return _("The package information was last updated %(days_ago)s "
-                   "days ago.\n"
-                   "Press the 'Check' button below to check for new software "
-                   "updates.") % { "days_ago" : ago_days, }
-      elif ago_days > 0:
-          return ngettext("The package information was last updated %(days_ago)s day ago.",
-                          "The package information was last updated %(days_ago)s days ago.",
-                          ago_days) % { "days_ago" : ago_days, }
-      elif ago_hours > 0:
-          return ngettext("The package information was last updated %(hours_ago)s hour ago.",
-                          "The package information was last updated %(hours_ago)s hours ago.",
-                          ago_hours) % { "hours_ago" : ago_hours, }
-      elif ago_minutes >= 45:
-          # TRANSLATORS: only in plural form, as %s minutes ago is one of 15, 30, 45 minutes ago
-          return _("The package information was last updated about %s minutes ago.")%45
-      elif ago_minutes >= 30:
-          return _("The package information was last updated about %s minutes ago.")%30
-      elif ago_minutes >= 15:
-          return _("The package information was last updated about %s minutes ago.")%15
-      else:
-          return _("The package information was just updated.")
-      return None
-
-  def update_last_updated_text(self, user_data):
-      """timer that updates the last updated text """
-      #print("update_last_updated_text")
-      num_updates = self.cache.install_count
-      if num_updates == 0:
-          if self._get_last_apt_get_update_text() is not None:
-              text_label_main = self._get_last_apt_get_update_text()
-              self.label_main_details.set_text(text_label_main)
-          return True
-      # stop the timer if there are upgrades now
-      return False
-
   def update_count(self):
       """activate or disable widgets and show dialog texts correspoding to
          the number of available updates"""
       self.refresh_updates_count()
       num_updates = self.cache.install_count
-      text_label_main = ""
-
-      # setup unity stuff
-      self.unity.set_updates_count(num_updates)
 
       if num_updates == 0:
           text_header= _("The software on this computer is up to date.")
@@ -683,18 +432,13 @@
           self.button_close.grab_default()
           self.textview_changes.get_buffer().set_text("")
           self.textview_descr.get_buffer().set_text("")
-          if self._get_last_apt_get_update_text() is not None:
-              text_label_main = self._get_last_apt_get_update_text()
-              if self._get_last_apt_get_update_minutes()> self.NO_UPDATE_WARNING_DAYS*24*60:
-                  text_header = _("Software updates may be available for your computer.")
-          # add timer to ensure we update the information when the 
-          # last package count update was performed
-          GObject.timeout_add_seconds(10, self.update_last_updated_text, None)
       else:
           # show different text on first run (UX team suggestion)
           firstrun = self.settings.get_boolean("first-run")
           if firstrun:
-              text_header = _("Updated software has been issued since %s was released. Do you want to install it now?") % self.meta.current_dist_description
+              flavor = self.window_main.meta_release.flavor_name
+              version = self.window_main.meta_release.current_dist_version
+              text_header = _("Updated software has been issued since %s %s was released. Do you want to install it now?") % (flavor, version)
               self.settings.set_boolean("first-run", False)
           else:
               text_header = _("Updated software is available for this computer. Do you want to install it now?")
@@ -703,7 +447,6 @@
           self.button_install.grab_default()
           self.treeview_update.set_cursor(Gtk.TreePath.new_from_string("1"), None, False)
       self.label_header.set_markup(text_header)
-      self.label_main_details.set_text(text_label_main)
       return True
 
   # Before we shrink the window, capture the size
@@ -717,18 +460,12 @@
     self.settings.set_boolean("show-details",expanded)
     if expanded:
       self.on_treeview_update_cursor_changed(self.treeview_update)
-      self.restore_state()
-    self.window_main.set_resizable(expanded)
+    self.restore_state()
 
   def activate_desc(self, expander, data):
     expanded = self.expander_desc.get_expanded()
     self.expander_desc.set_vexpand(expanded)
 
-  def on_button_reload_clicked(self, widget, menuitem = None, data = None):
-    #print("on_button_reload_clicked")
-    self.check_metarelease()
-    self.invoke_manager(UPDATE)
-
   #def on_button_help_clicked(self, widget):
   #  self.help_viewer.run()
 
@@ -750,6 +487,7 @@
         while Gtk.events_pending():
             Gtk.main_iteration()
         time.sleep(0.05)
+    self.window_main.refresh_cache()
     self.fillstore()
 
   def on_button_install_clicked(self, widget):
@@ -766,101 +504,20 @@
         self.cache.checkFreeSpace()
     except NotEnoughFreeSpaceError as e:
         for req in e.free_space_required_list:
-            self.error(err_sum, err_long % (req.size_total,
-                                            req.dir,
-                                            req.size_needed,
-                                            req.dir))
+            self.window_main.start_error(err_sum, err_long % (req.size_total,
+                                                              req.dir,
+                                                              req.size_needed,
+                                                              req.dir))
         return
     except SystemError as e:
         logging.exception("free space check failed")
-    self.invoke_manager(INSTALL)
-    
-  def on_button_restart_required_clicked(self, button=None):
-      self._request_reboot_via_session_manager()
-
-  def show_reboot_required_info(self):
-    self.frame_restart_required.show()
-    self.label_restart_required.set_text(_("The computer needs to restart to "
-                                       "finish installing updates. Please "
-                                       "save your work before continuing."))
-
-  def _request_reboot_via_session_manager(self):
-    try:
-        bus = dbus.SessionBus()
-        proxy_obj = bus.get_object("org.gnome.SessionManager",
-                                   "/org/gnome/SessionManager")
-        iface = dbus.Interface(proxy_obj, "org.gnome.SessionManager")
-        iface.RequestReboot()
-    except dbus.DBusException:
-        self._request_reboot_via_consolekit()
-    except:
-        pass
-
-  def _request_reboot_via_consolekit(self):
-    try:
-        bus = dbus.SystemBus()
-        proxy_obj = bus.get_object("org.freedesktop.ConsoleKit",
-                                   "/org/freedesktop/ConsoleKit/Manager")
-        iface = dbus.Interface(proxy_obj, "org.freedesktop.ConsoleKit.Manager")
-        iface.Restart()
-    except dbus.DBusException:
-        pass
-
-  def invoke_manager(self, action):
-    # check first if no other package manager is runing
-
-    # don't display apt-listchanges, we already showed the changelog
-    os.environ["APT_LISTCHANGES_FRONTEND"]="none"
-
-    # Do not suspend during the update process
-    (self.sleep_dev, self.sleep_cookie) = inhibit_sleep()
-
-    # set window to insensitive
-    self.window_main.set_sensitive(False)
-    self.window_main.get_window().set_cursor(Gdk.Cursor.new(Gdk.CursorType.WATCH))
-#
-    # do it
-    if action == UPDATE:
-        self.install_backend.update()
-    elif action == INSTALL:
-        # If the progress dialog should be closed automatically afterwards
-        settings = Gio.Settings("com.ubuntu.update-manager")
-        close_on_done = settings.get_boolean("autoclose-install-window")
-        # Get the packages which should be installed and update
-        pkgs_install = []
-        pkgs_upgrade = []
-        for pkg in self.cache:
-            if pkg.marked_install:
-                pkgs_install.append(pkg.name)
-            elif pkg.marked_upgrade:
-                pkgs_upgrade.append(pkg.name)
-        self.install_backend.commit(pkgs_install, pkgs_upgrade, close_on_done)
-
-  def _on_backend_done(self, backend, action, authorized, success):
-    if (action == UPDATE):
-        self.dbusController.updated(success)
-    # check if there is a new reboot required notification
-    if (action == INSTALL and
-        os.path.exists(REBOOT_REQUIRED_FILE)):
-        self.show_reboot_required_info()
-    if authorized:
-        msg = _("Reading package information")
-        self.label_cache_progress_title.set_label("<b><big>%s</big></b>" % msg)
-        self.fillstore()
-
-    # Allow suspend after synaptic is finished
-    if self.sleep_cookie:
-        allow_sleep(self.sleep_dev, self.sleep_cookie)
-        self.sleep_cookie = self.sleep_dev = None
-    self.window_main.set_sensitive(True)
-    self.window_main.get_window().set_cursor(None)
+    self.window_main.start_install()
 
   def _on_network_alert(self, watcher, state):
       # do not set the buttons to sensitive/insensitive until NM
       # can deal with dialup connections properly
       if state in NetworkManagerHelper.NM_STATE_CONNECTING_LIST:
           self.label_offline.set_text(_("Connecting..."))
-          #self.button_reload.set_sensitive(False)
           self.refresh_updates_count()
           self.hbox_offline.show()
           self.vbox_alerts.show()
@@ -868,7 +525,6 @@
       # in doubt (STATE_UNKNOWN), assume connected
       elif (state in NetworkManagerHelper.NM_STATE_CONNECTED_LIST or 
            state == NetworkManagerHelper.NM_STATE_UNKNOWN):
-          #self.button_reload.set_sensitive(True)
           self.refresh_updates_count()
           self.hbox_offline.hide()
           self.connected = True
@@ -877,7 +533,6 @@
       else:
           self.connected = False
           self.label_offline.set_text(_("You may not be able to check for updates or download new updates."))
-          #self.button_reload.set_sensitive(False)
           self.refresh_updates_count()
           self.hbox_offline.show()
           self.vbox_alerts.show()
@@ -965,12 +620,6 @@
     """
     self.toggled(None, path)
 
-  def exit(self):
-    """ exit the application, save the state """
-    self.save_state()
-    #Gtk.main_quit()
-    sys.exit(0)
-
   def save_state(self):
     """ save the state  (window-size for now) """
     if self.expander_details.get_expanded():
@@ -982,7 +631,9 @@
     """ restore the state (window-size for now) """
     w = self.settings.get_int("window-width")
     h = self.settings.get_int("window-height")
-    if w > 0 and h > 0 and self.expander_details.get_expanded():
+    expanded = self.expander_details.get_expanded()
+    self.window_main.set_resizable(expanded)
+    if w > 0 and h > 0 and expanded:
       self.window_main.resize(w, h)
     return False
 
@@ -992,237 +643,48 @@
     # disconnect the view first
     self.treeview_update.set_model(None)
     self.store.clear()
-    
     # clean most objects
     self.dl_size = 0
-    try:
-        self.initCache()
-    except SystemError as e:
-        msg = ("<big><b>%s</b></big>\n\n%s\n'%s'" %
-               (_("Could not initialize the package information"),
-                _("An unresolvable problem occurred while "
-                  "initializing the package information.\n\n"
-                  "Please report this bug against the 'update-manager' "
-                  "package and include the following error message:\n"),
-                e)
-               )
-        dialog = Gtk.MessageDialog(self.window_main,
-                                   0, Gtk.MessageType.ERROR,
-                                   Gtk.ButtonsType.CLOSE,"")
-        dialog.set_markup(msg)
-        dialog.get_content_area().set_spacing(6)
-        dialog.run()
-        dialog.destroy()
-        sys.exit(1)
-    self.list = UpdateList(self)
-    
-    while Gtk.events_pending():
-        Gtk.main_iteration()
 
-    # fill them again
-    try:
-        # This is  a quite nasty hack to stop the initial update 
-        if not self.options.no_update:
-            self.list.update(self.cache)
-        else:
-            self.options.no_update = False
-    except SystemError as e:
-        msg = ("<big><b>%s</b></big>\n\n%s\n'%s'" %
-               (_("Could not calculate the upgrade"),
-                _("An unresolvable problem occurred while "
-                  "calculating the upgrade.\n\n"
-                  "Please report this bug against the 'update-manager' "
-                  "package and include the following error message:"),
-                e)
-               )
-        dialog = Gtk.MessageDialog(self.window_main,
-                                   0, Gtk.MessageType.ERROR,
-                                   Gtk.ButtonsType.CLOSE,"")
-        dialog.set_markup(msg)
-        dialog.get_content_area().set_spacing(6)
-        dialog.run()
-        dialog.destroy()
-    if self.list.num_updates > 0:
-      #self.treeview_update.set_model(None)
-      self.scrolledwindow_update.show()
-      origin_list = sorted(
-        self.list.pkgs, key=operator.attrgetter("importance"), reverse=True)
-      for origin in origin_list:
-        self.store.append(['<b><big>%s</big></b>' % origin.description,
-                           origin.description, None, origin,True])
-        for pkg in self.list.pkgs[origin]:
-          name = xml.sax.saxutils.escape(pkg.name)
-          if not pkg.is_installed:
-              name += _(" (New install)")
-          summary = xml.sax.saxutils.escape(getattr(pkg.candidate, "summary", None))
-          if self.summary_before_name:
-              contents = "%s\n<small>%s</small>" % (summary, name)
-          else:
-              contents = "<b>%s</b>\n<small>%s</small>" % (name, summary)
-          #TRANSLATORS: the b stands for Bytes
-          size = _("(Size: %s)") % humanize_size(getattr(pkg.candidate, "size", 0))
-          installed_version = getattr(pkg.installed, "version", None)
-          candidate_version = getattr(pkg.candidate, "version", None)
-          if installed_version is not None:
-              version = _("From version %(old_version)s to %(new_version)s") %\
-                  {"old_version" : installed_version,
-                   "new_version" : candidate_version}
-          else:
-              version = _("Version %s") % candidate_version
-          if self.show_versions:
-              contents = "%s\n<small>%s %s</small>" % (contents, version, size)
-          else:
-              contents = "%s <small>%s</small>" % (contents, size)
-          self.store.append([contents, pkg.name, pkg, None, True])
-      self.treeview_update.set_model(self.store)
+    self.scrolledwindow_update.show()
+    origin_list = sorted(
+      self.list.pkgs, key=operator.attrgetter("importance"), reverse=True)
+    for origin in origin_list:
+      self.store.append(['<b><big>%s</big></b>' % origin.description,
+                         origin.description, None, origin,True])
+      for pkg in self.list.pkgs[origin]:
+        name = xml.sax.saxutils.escape(pkg.name)
+        if not pkg.is_installed:
+            name += _(" (New install)")
+        summary = xml.sax.saxutils.escape(getattr(pkg.candidate, "summary", None))
+        if self.summary_before_name:
+            contents = "%s\n<small>%s</small>" % (summary, name)
+        else:
+            contents = "<b>%s</b>\n<small>%s</small>" % (name, summary)
+        #TRANSLATORS: the b stands for Bytes
+        size = _("(Size: %s)") % humanize_size(getattr(pkg.candidate, "size", 0))
+        installed_version = getattr(pkg.installed, "version", None)
+        candidate_version = getattr(pkg.candidate, "version", None)
+        if installed_version is not None:
+            version = _("From version %(old_version)s to %(new_version)s") %\
+                {"old_version" : installed_version,
+                 "new_version" : candidate_version}
+        else:
+            version = _("Version %s") % candidate_version
+        if self.show_versions:
+            contents = "%s\n<small>%s %s</small>" % (contents, version, size)
+        else:
+            contents = "%s <small>%s</small>" % (contents, size)
+        self.store.append([contents, pkg.name, pkg, None, True])
+    self.treeview_update.set_model(self.store)
     self.update_count()
     self.setBusy(False)
     while Gtk.events_pending():
       Gtk.main_iteration()
-    self.check_all_updates_installable()
     self.refresh_updates_count()
     return False
 
-  def dist_no_longer_supported(self, meta_release):
-    show_dist_no_longer_supported_dialog(self.window_main)
-
-  def error(self, summary, details):
-      " helper function to display a error message "
-      msg = ("<big><b>%s</b></big>\n\n%s\n" % (summary, details) )
-      dialog = Gtk.MessageDialog(self.window_main,
-                                 0, Gtk.MessageType.ERROR,
-                                 Gtk.ButtonsType.CLOSE,"")
-      dialog.set_markup(msg)
-      dialog.get_content_area().set_spacing(6)
-      dialog.run()
-      dialog.destroy()
-
-  def on_button_dist_upgrade_clicked(self, button):
-      #print("on_button_dist_upgrade_clicked")
-      if self.new_dist.upgrade_broken:
-          return self.error(
-              _("Release upgrade not possible right now"),
-              _("The release upgrade can not be performed currently, "
-                "please try again later. The server reported: '%s'") % self.new_dist.upgrade_broken)
-      fetcher = DistUpgradeFetcherGtk(new_dist=self.new_dist, parent=self, progress=GtkAcquireProgress(self, _("Downloading the release upgrade tool")))
-      if self.options.sandbox:
-          fetcher.run_options.append("--sandbox")
-      fetcher.run()
-      
-  def new_dist_available(self, meta_release, upgradable_to):
-    self.frame_new_release.show()
-    self.label_new_release.set_markup(_("<b>New Ubuntu release '%s' is available</b>") % upgradable_to.version)
-    self.new_dist = upgradable_to
-    
-
-  # fixme: we should probably abstract away all the stuff from libapt
-  def initCache(self): 
-    # get the lock
-    try:
-        apt_pkg.pkgsystem_lock()
-    except SystemError:
-        pass
-        #d = Gtk.MessageDialog(parent=self.window_main,
-        #                      flags=Gtk.DialogFlags.MODAL,
-        #                      type=Gtk.MessageType.ERROR,
-        #                      buttons=Gtk.ButtonsType.CLOSE)
-        #d.set_markup("<big><b>%s</b></big>\n\n%s" % (
-        #    _("Only one software management tool is allowed to "
-        #      "run at the same time"),
-        #    _("Please close the other application e.g. 'aptitude' "
-        #      "or 'Synaptic' first.")))
-        #print("error from apt: '%s'" % e)
-        #d.set_title("")
-        #res = d.run()
-        #d.destroy()
-        #sys.exit()
-
-    try:
-        if hasattr(self, "cache"):
-            self.cache.open(self.progress)
-            self.cache._initDepCache()
-        else:
-            self.cache = MyCache(self.progress)
-    except AssertionError:
-        # if the cache could not be opened for some reason,
-        # let the release upgrader handle it, it deals
-        # a lot better with this
-        self.ask_run_partial_upgrade()
-        # we assert a clean cache
-        msg=("<big><b>%s</b></big>\n\n%s"% \
-             (_("Software index is broken"),
-              _("It is impossible to install or remove any software. "
-                "Please use the package manager \"Synaptic\" or run "
-                "\"sudo apt-get install -f\" in a terminal to fix "
-                "this issue at first.")))
-        dialog = Gtk.MessageDialog(self.window_main,
-                                   0, Gtk.MessageType.ERROR,
-                                   Gtk.ButtonsType.CLOSE,"")
-        dialog.set_markup(msg)
-        dialog.get_content_area().set_spacing(6)
-        dialog.run()
-        dialog.destroy()
-        sys.exit(1)
-    else:
-        self.progress.all_done()
-
-  def check_auto_update(self):
-      # Check if automatic update is enabled. If not show a dialog to inform
-      # the user about the need of manual "reloads"
-      remind = self.settings.get_boolean("remind-reload")
-      if remind == False:
-          return
-
-      update_days = apt_pkg.config.find_i("APT::Periodic::Update-Package-Lists")
-      if update_days < 1:
-          self.dialog_manual_update.set_transient_for(self.window_main)
-          self.dialog_manual_update.set_title("")
-          res = self.dialog_manual_update.run()
-          self.dialog_manual_update.hide()
-          if res == Gtk.ResponseType.YES:
-              self.on_button_reload_clicked(None)
-
-  def check_all_updates_installable(self):
-    """ Check if all available updates can be installed and suggest
-        to run a distribution upgrade if not """
-    if self.list.distUpgradeWouldDelete > 0:
-        self.ask_run_partial_upgrade()
-
-  def ask_run_partial_upgrade(self):
-      self.dialog_dist_upgrade.set_transient_for(self.window_main)
-      self.dialog_dist_upgrade.set_title("")
-      res = self.dialog_dist_upgrade.run()
-      self.dialog_dist_upgrade.hide()
-      if res == Gtk.ResponseType.YES:
-          os.execl("/usr/bin/gksu",
-                   "/usr/bin/gksu", "--desktop",
-                   "/usr/share/applications/update-manager.desktop",
-                   "--", "/usr/bin/update-manager", "--dist-upgrade")
-      return False
-
-  def check_metarelease(self):
-      " check for new meta-release information "
-      settings = Gio.Settings("com.ubuntu.update-manager")
-      self.meta = MetaRelease(self.options.devel_release,
-                              self.options.use_proposed)
-      self.meta.connect("dist_no_longer_supported",self.dist_no_longer_supported)
-      # check if we are interessted in dist-upgrade information
-      # (we are not by default on dapper)
-      if (self.options.check_dist_upgrades or
-          settings.get_boolean("check-dist-upgrades")):
-          self.meta.connect("new_dist_available",self.new_dist_available)
-      
-
-  def main(self, options):
-    self.options = options
-
-    # check for new distributin information
-    self.check_metarelease()
-
-    while Gtk.events_pending():
-      Gtk.main_iteration()
-
+  def main(self):
+    self.window_main.push(self.pane_updates_available, self)
     self.fillstore()
-    self.check_auto_update()
     self.alert_watcher.check_alert_state()
-    Gtk.main()

=== modified file 'UpdateManager/backend/InstallBackendAptdaemon.py'
--- UpdateManager/backend/InstallBackendAptdaemon.py	2012-05-01 00:29:04 +0000
+++ UpdateManager/backend/InstallBackendAptdaemon.py	2012-06-18 20:03:27 +0000
@@ -1,28 +1,52 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-# (c) 2005-2009 Canonical, GPL
+# (c) 2005-2012 Canonical, GPL
+# (C) 2008-2009 Sebastian Heinlein <[e-mail]>
 
 from __future__ import print_function
 
+from gi.repository import Gtk
+from gi.repository import Gdk
+
 from aptdaemon import client, errors
 from defer import inline_callbacks
-from aptdaemon.gtk3widgets import AptProgressDialog
-from aptdaemon.enums import EXIT_SUCCESS
+from aptdaemon.gtk3widgets import (AptCancelButton,
+                                   AptConfigFileConflictDialog, 
+                                   AptDetailsExpander,
+                                   AptErrorDialog,
+                                   AptMediumRequiredDialog,
+                                   AptProgressBar)
+from aptdaemon.enums import (EXIT_SUCCESS,
+                             EXIT_FAILED,
+                             STATUS_COMMITTING,
+                             get_status_string_from_enum)
 
 from UpdateManager.backend import InstallBackend
 from UpdateManager.UnitySupport import UnitySupport
 
+from gettext import gettext as _
+
 import apt
 import dbus
+import sys
 
 class InstallBackendAptdaemon(InstallBackend):
 
     """Makes use of aptdaemon to refresh the cache and to install updates."""
 
-    def __init__(self, window_main):
-        InstallBackend.__init__(self, window_main)
+    def __init__(self, datadir, window_main):
+        InstallBackend.__init__(self, datadir, window_main)
         self.client = client.AptClient()
         self.unity = UnitySupport()
+        self._expanded_size = None
+        self.button_cancel = None
+
+    def close(self):
+        if self.button_cancel:
+            self.button_cancel.clicked()
+            return True
+        else:
+            return False
 
     @inline_callbacks
     def update(self):
@@ -33,7 +57,9 @@
             pass
         try:
             trans = yield self.client.update_cache(defer=True)
-            yield self._run_in_dialog(trans, self.UPDATE)
+            yield self._run_in_dialog(trans, self.UPDATE,
+                                      _("Checking for updates…"),
+                                      False, False)
         except errors.NotAuthorizedError:
             self.emit("action-done", self.UPDATE, False, False)
         except:
@@ -53,7 +79,9 @@
                 pkgs_install, reinstall, remove, purge, pkgs_upgrade, 
                 downgrade, defer=True)
             trans.connect("progress-changed", self._on_progress_changed)
-            yield self._run_in_dialog(trans, self.INSTALL)
+            yield self._run_in_dialog(trans, self.INSTALL,
+                                      _("Installing updates…"),
+                                      True, close_on_done)
         except errors.NotAuthorizedError as e:
             self.emit("action-done", self.INSTALL, False, False)
         except dbus.DBusException as e:
@@ -69,23 +97,134 @@
         #print("_on_progress_changed", progress)
         self.unity.set_progress(progress)
 
+    def _on_details_changed(self, trans, details, label_details):
+        label_details.set_label(details)
+
+    def _on_status_changed(self, trans, status, label_details, expander):
+        label_details.set_label(get_status_string_from_enum(status))
+        # Also resize the window if we switch from download details to
+        # the terminal window
+        if status == STATUS_COMMITTING and expander and expander.terminal.get_visible():
+            self._resize_to_show_details(expander)
+
     @inline_callbacks
-    def _run_in_dialog(self, trans, action):
-        dia = AptProgressDialog(trans, parent=self.window_main)
-        dia.set_icon_name("system-software-update")
-        dia.connect("finished", self._on_finished, action)
-        yield dia.run()
-
-    def _on_finished(self, dialog, action):
-        dialog.hide()
+    def _run_in_dialog(self, trans, action, header, show_details, close_on_done):
+        builder = Gtk.Builder()
+        builder.set_translation_domain("update-manager")
+        builder.add_from_file(self.datadir+"/gtkbuilder/UpdateProgress.ui")
+
+        label_header = builder.get_object("label_header")
+        label_header.set_label(header)
+
+        progressbar = AptProgressBar(trans)
+        progressbar.show()
+        progressbar_slot = builder.get_object("progressbar_slot")
+        progressbar_slot.add(progressbar)
+
+        self.button_cancel = AptCancelButton(trans)
+        self.button_cancel.show()
+        button_cancel_slot = builder.get_object("button_cancel_slot")
+        button_cancel_slot.add(self.button_cancel)
+
+        label_details = builder.get_object("label_details")
+
+        if show_details:
+            expander = AptDetailsExpander(trans)
+            expander.set_vexpand(True)
+            expander.set_hexpand(True)
+            expander.show_all()
+            expander.connect("notify::expanded", self._on_expanded)
+            expander_slot = builder.get_object("expander_slot")
+            expander_slot.add(expander)
+            expander_slot.show()
+        else:
+            expander = None
+
+        trans.connect("status-details-changed", self._on_details_changed, label_details)
+        trans.connect("status-changed", self._on_status_changed, label_details, expander)
+        trans.connect("finished", self._on_finished, action, close_on_done)
+        trans.connect("medium-required", self._on_medium_required)
+        trans.connect("config-file-conflict", self._on_config_file_conflict)
+
+        yield trans.run()
+
+        self.window_main.push(builder.get_object("pane_update_progress"), self)
+
+        functions = Gdk.WMFunction.MOVE|Gdk.WMFunction.RESIZE|Gdk.WMFunction.MINIMIZE
+        self.window_main.get_window().set_functions(functions)
+
+    def _on_expanded(self, expander, param):
+        # Make the dialog resizable if the expander is expanded
+        # try to restore a previous size
+        if not expander.get_expanded():
+            self._expanded_size = (expander.terminal.get_visible(),
+                                   self.window_main.get_size())
+            self.window_main.set_resizable(False)
+        elif self._expanded_size:
+            self.window_main.set_resizable(True)
+            term_visible, (stored_width, stored_height) = self._expanded_size
+            # Check if the stored size was for the download details or
+            # the terminal widget
+            if term_visible != expander.terminal.get_visible():
+                # The stored size was for the download details, so we need
+                # get a new size for the terminal widget
+                self._resize_to_show_details(expander)
+            else:
+                self.window_main.resize(stored_width, stored_height)
+        else:
+            self.window_main.set_resizable(True)
+            self._resize_to_show_details(expander)
+
+    def _resize_to_show_details(self, expander):
+        """Resize the window to show the expanded details.
+
+        Unfortunately the expander only expands to the preferred size of the
+        child widget (e.g showing all 80x24 chars of the Vte terminal) if
+        the window is rendered the first time and the terminal is also visible.
+        If the expander is expanded afterwards the window won't change its
+        size anymore. So we have to do this manually. See LP#840942
+        """
+        win_width, win_height = self.window_main.get_size()
+        exp_width = expander.get_allocation().width
+        exp_height = expander.get_allocation().height
+        if expander.terminal.get_visible():
+            terminal_width = expander.terminal.get_char_width() * 80
+            terminal_height = expander.terminal.get_char_height() * 24
+            self.window_main.resize(terminal_width - exp_width + win_width,
+                                    terminal_height - exp_height + win_height)
+        else:
+            self.window_main.resize(win_width + 100, win_height + 200)
+
+    def _on_medium_required(self, transaction, medium, drive):
+        dialog = AptMediumRequiredDialog(medium, drive, self.window_main)
+        res = dialog.run()
+        dialog.hide()
+        if res == Gtk.ResponseType.OK:
+            transaction.provide_medium(medium)
+        else:
+            transaction.cancel()
+
+    def _on_config_file_conflict(self, transaction, old, new):
+        dialog = AptConfigFileConflictDialog(old, new, self.window_main)
+        res = dialog.run()
+        dialog.hide()
+        if res == Gtk.ResponseType.YES:
+            transaction.resolve_config_file_conflict(old, "replace")
+        else:
+            transaction.resolve_config_file_conflict(old, "keep")
+
+    def _on_finished(self, trans, status, action, close_on_done):
+        if status == EXIT_FAILED:
+            err_dia = AptErrorDialog(trans.error, self.window_main)
+            err_dia.run()
+            err_dia.hide()
+        elif status == EXIT_SUCCESS and close_on_done:
+            sys.exit(0)
         # tell unity to hide the progress again
         self.unity.set_progress(-1)
-        self.emit("action-done", action, 
-                  True, dialog._transaction.exit == EXIT_SUCCESS)
+        self.emit("action-done", action, True, status == EXIT_SUCCESS)
 
 if __name__ == "__main__":
     b = InstallBackendAptdaemon(None)
     b.commit(["2vcard"], [], False)
-
-    from gi.repository import Gtk
     Gtk.main()

=== modified file 'UpdateManager/backend/__init__.py'
--- UpdateManager/backend/__init__.py	2012-05-01 14:01:29 +0000
+++ UpdateManager/backend/__init__.py	2012-06-18 20:03:27 +0000
@@ -23,11 +23,12 @@
 
     (INSTALL, UPDATE) = range(2)
 
-    def __init__(self, window_main):
+    def __init__(self, datadir, window_main):
         """init backend
         takes a gtk main window as parameter
         """
         GObject.GObject.__init__(self)
+        self.datadir = datadir
         self.window_main = window_main
 
     def commit(self, pkgs_install, pkgs_upgrade, close_on_done):

=== modified file 'check-new-release-gtk'
--- check-new-release-gtk	2012-06-13 22:45:57 +0000
+++ check-new-release-gtk	2012-06-18 20:03:27 +0000
@@ -72,7 +72,9 @@
   FETCH_TIMEOUT = 20
 
   def __init__(self, options):
-    SimpleGtkbuilderApp.__init__(self, options.datadir+"/gtkbuilder/UpgradePromptDialog.ui", "update-manager")
+    self.options = options
+    self.datadir = options.datadir
+    SimpleGtkbuilderApp.__init__(self, self.datadir+"/gtkbuilder/UpgradePromptDialog.ui", "update-manager")
     self.new_dist = None
     logging.debug("running with devel=%s proposed=%s" % (
             options.devel_release, options.proposed_release))
@@ -107,9 +109,9 @@
     self.show_uri(html_uri)
     # show alert on unsupported distros
     if meta_release.no_longer_supported is not None:
-        from UpdateManager.UpdateManager import show_dist_no_longer_supported_dialog
-        self.window_main.realize()
-        show_dist_no_longer_supported_dialog(self.window_main)
+        from UpdateManager.Dialogs import UnsupportedDialog
+        dialog = UnsupportedDialog(self, meta_release)
+        dialog.run(self.window_main)
   
   def build_ui(self):
     from gi.repository import WebKit
@@ -123,9 +125,11 @@
 
   def on_button_upgrade_now_clicked(self, button):
     logging.debug("upgrade now")
-    progress=UpdateManager.GtkProgress.GtkAcquireProgress(self, _("Downloading the release upgrade tool"))
+    progress=UpdateManager.GtkProgress.GtkAcquireProgress(self, self.datadir,
+                                                          _("Downloading the release upgrade tool"))
     fetcher = DistUpgradeFetcher(new_dist=self.new_dist, 
                                  parent=self,
+                                 datadir=self.datadir,
                                  progress=progress)
     res = fetcher.run()
     res # pyflakes

=== modified file 'data/com.ubuntu.update-manager.gschema.xml.in'
--- data/com.ubuntu.update-manager.gschema.xml.in	2012-05-31 22:18:33 +0000
+++ data/com.ubuntu.update-manager.gschema.xml.in	2012-06-18 20:03:27 +0000
@@ -1,10 +1,5 @@
 <schemalist>
   <schema id="com.ubuntu.update-manager" path="/apps/update-manager/">
-    <key name="remind-reload" type="b">
-      <default>true</default>
-      <summary>Remind to reload the channel list</summary>
-      <description>If automatic checking for updates is disabled, you have to reload the channel list manually. This option allows to hide the reminder shown in this case.</description>
-    </key>
     <key name="show-details" type="b">
       <default>false</default>
       <summary>Show details of an update</summary>

=== added file 'data/gtkbuilder/AcquireProgress.ui'
--- data/gtkbuilder/AcquireProgress.ui	1970-01-01 00:00:00 +0000
+++ data/gtkbuilder/AcquireProgress.ui	2012-06-18 20:03:27 +0000
@@ -0,0 +1,161 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <!-- interface-requires gtk+ 3.0 -->
+  <object class="GtkWindow" id="window_fetch">
+    <property name="can_focus">False</property>
+    <property name="border_width">6</property>
+    <property name="modal">True</property>
+    <property name="window_position">center-on-parent</property>
+    <property name="default_width">400</property>
+    <property name="type_hint">dialog</property>
+    <property name="skip_taskbar_hint">True</property>
+    <property name="skip_pager_hint">True</property>
+    <child>
+      <object class="GtkVBox" id="pane_fetch">
+        <property name="visible">True</property>
+        <property name="can_focus">False</property>
+        <property name="spacing">6</property>
+        <child>
+          <object class="GtkVBox" id="vbox7">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="border_width">6</property>
+            <property name="spacing">12</property>
+            <child>
+              <object class="GtkLabel" id="label_fetch_summary">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="xalign">0</property>
+                <property name="use_markup">True</property>
+                <property name="wrap">True</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">False</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkVBox" id="vbox8">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="spacing">6</property>
+                <child>
+                  <object class="GtkProgressBar" id="progressbar_fetch">
+                    <property name="visible">True</property>
+                    <property name="can_focus">False</property>
+                    <property name="pulse_step">0.10000000149</property>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">False</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkLabel" id="label_fetch_status">
+                    <property name="visible">True</property>
+                    <property name="can_focus">False</property>
+                    <property name="xalign">0</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">False</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">False</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkExpander" id="expander1">
+                <property name="can_focus">True</property>
+                <property name="spacing">6</property>
+                <child>
+                  <object class="GtkVBox" id="vbox9">
+                    <property name="visible">True</property>
+                    <property name="can_focus">False</property>
+                    <property name="spacing">6</property>
+                    <child>
+                      <object class="GtkScrolledWindow" id="scrolledwindow6">
+                        <property name="height_request">200</property>
+                        <property name="visible">True</property>
+                        <property name="can_focus">True</property>
+                        <property name="shadow_type">in</property>
+                        <child>
+                          <object class="GtkTreeView" id="treeview1">
+                            <property name="visible">True</property>
+                            <property name="can_focus">True</property>
+                            <property name="enable_search">False</property>
+                            <child internal-child="selection">
+                              <object class="GtkTreeSelection" id="treeview-selection"/>
+                            </child>
+                          </object>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="expand">True</property>
+                        <property name="fill">True</property>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                  </object>
+                </child>
+                <child type="label">
+                  <object class="GtkLabel" id="label19">
+                    <property name="visible">True</property>
+                    <property name="can_focus">False</property>
+                    <property name="label" translatable="yes">Show progress of individual files</property>
+                  </object>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">2</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">True</property>
+            <property name="fill">True</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkHButtonBox" id="hbuttonbox7">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="layout_style">end</property>
+            <child>
+              <object class="GtkButton" id="button_fetch_cancel">
+                <property name="label">gtk-cancel</property>
+                <property name="use_action_appearance">False</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="border_width">5</property>
+                <property name="use_action_appearance">False</property>
+                <property name="use_stock">True</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">False</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+  </object>
+</interface>

=== added file 'data/gtkbuilder/Dialog.ui'
--- data/gtkbuilder/Dialog.ui	1970-01-01 00:00:00 +0000
+++ data/gtkbuilder/Dialog.ui	2012-06-18 20:03:27 +0000
@@ -0,0 +1,123 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <!-- interface-requires gtk+ 3.0 -->
+  <object class="GtkDialog" id="window_dialog">
+    <property name="can_focus">False</property>
+    <property name="type_hint">dialog</property>
+    <child internal-child="vbox">
+      <object class="GtkBox" id="dialog-vbox1">
+        <property name="can_focus">False</property>
+        <property name="orientation">vertical</property>
+        <child internal-child="action_area">
+          <object class="GtkButtonBox" id="dialog-action_area1">
+            <property name="can_focus">False</property>
+            <property name="layout_style">end</property>
+            <child>
+              <placeholder/>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="pack_type">end</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkGrid" id="pane_dialog">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="hexpand">True</property>
+            <property name="vexpand">True</property>
+            <property name="border_width">12</property>
+            <property name="row_spacing">12</property>
+            <property name="column_spacing">12</property>
+            <child>
+              <object class="GtkImage" id="image_logo">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="yalign">0</property>
+                <property name="pixel_size">48</property>
+                <property name="icon_name">system-software-update</property>
+              </object>
+              <packing>
+                <property name="left_attach">0</property>
+                <property name="top_attach">0</property>
+                <property name="width">1</property>
+                <property name="height">1</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLabel" id="label_header">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="margin_top">6</property>
+                <property name="hexpand">True</property>
+                <property name="xalign">0</property>
+                <property name="yalign">0</property>
+                <property name="wrap">True</property>
+                <property name="width_chars">40</property>
+                <property name="max_width_chars">40</property>
+                <attributes>
+                  <attribute name="weight" value="bold"/>
+                  <attribute name="scale" value="1.25"/>
+                </attributes>
+              </object>
+              <packing>
+                <property name="left_attach">1</property>
+                <property name="top_attach">0</property>
+                <property name="width">1</property>
+                <property name="height">1</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLabel" id="label_desc">
+                <property name="can_focus">False</property>
+                <property name="no_show_all">True</property>
+                <property name="hexpand">True</property>
+                <property name="vexpand">True</property>
+                <property name="xalign">0</property>
+                <property name="yalign">0</property>
+                <property name="wrap">True</property>
+                <property name="max_width_chars">40</property>
+              </object>
+              <packing>
+                <property name="left_attach">1</property>
+                <property name="top_attach">1</property>
+                <property name="width">1</property>
+                <property name="height">1</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkButtonBox" id="buttonbox">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="hexpand">True</property>
+                <property name="spacing">6</property>
+                <property name="homogeneous">True</property>
+                <property name="layout_style">end</property>
+                <child>
+                  <placeholder/>
+                </child>
+              </object>
+              <packing>
+                <property name="left_attach">0</property>
+                <property name="top_attach">2</property>
+                <property name="width">2</property>
+                <property name="height">1</property>
+              </packing>
+            </child>
+            <child>
+              <placeholder/>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+  </object>
+</interface>

=== added file 'data/gtkbuilder/ReleaseNotes.ui'
--- data/gtkbuilder/ReleaseNotes.ui	1970-01-01 00:00:00 +0000
+++ data/gtkbuilder/ReleaseNotes.ui	2012-06-18 20:03:27 +0000
@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <!-- interface-requires gtk+ 3.0 -->
+  <object class="GtkDialog" id="dialog_release_notes">
+    <property name="can_focus">False</property>
+    <property name="border_width">6</property>
+    <property name="title" translatable="yes">Release Notes</property>
+    <property name="modal">True</property>
+    <property name="window_position">center-on-parent</property>
+    <property name="default_width">600</property>
+    <property name="default_height">500</property>
+    <property name="type_hint">dialog</property>
+    <child internal-child="vbox">
+      <object class="GtkBox" id="dialog-vbox">
+        <property name="visible">True</property>
+        <property name="can_focus">False</property>
+        <property name="orientation">vertical</property>
+        <property name="spacing">6</property>
+        <child internal-child="action_area">
+          <object class="GtkButtonBox" id="dialog-action_area">
+            <property name="can_focus">False</property>
+            <child>
+              <object class="GtkButton" id="okbutton1">
+                <property name="label">gtk-cancel</property>
+                <property name="use_action_appearance">False</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="can_default">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_action_appearance">False</property>
+                <property name="use_stock">True</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">False</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkButton" id="button2">
+                <property name="label" translatable="yes">_Upgrade</property>
+                <property name="use_action_appearance">False</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="can_default">True</property>
+                <property name="has_default">True</property>
+                <property name="receives_default">True</property>
+                <property name="use_action_appearance">False</property>
+                <property name="use_underline">True</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">False</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="pack_type">end</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkScrolledWindow" id="scrolled_notes">
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="border_width">6</property>
+            <property name="shadow_type">in</property>
+            <child>
+              <placeholder/>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">True</property>
+            <property name="fill">True</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+    <action-widgets>
+      <action-widget response="-6">okbutton1</action-widget>
+      <action-widget response="-5">button2</action-widget>
+    </action-widgets>
+  </object>
+</interface>

=== modified file 'data/gtkbuilder/UpdateManager.ui'
--- data/gtkbuilder/UpdateManager.ui	2012-05-31 22:18:33 +0000
+++ data/gtkbuilder/UpdateManager.ui	2012-06-18 20:03:27 +0000
@@ -1,781 +1,15 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <interface>
   <!-- interface-requires gtk+ 3.0 -->
-  <object class="GtkWindow" id="dialog_cacheprogress">
-    <property name="can_focus">False</property>
-    <property name="border_width">6</property>
-    <property name="resizable">False</property>
-    <property name="modal">True</property>
-    <property name="window_position">center-on-parent</property>
-    <property name="type_hint">dialog</property>
-    <property name="skip_taskbar_hint">True</property>
-    <property name="skip_pager_hint">True</property>
-    <child>
-      <object class="GtkVBox" id="vbox14">
-        <property name="visible">True</property>
-        <property name="can_focus">False</property>
-        <property name="border_width">6</property>
-        <property name="spacing">12</property>
-        <child>
-          <object class="GtkLabel" id="label_cache_progress_title">
-            <property name="visible">True</property>
-            <property name="can_focus">False</property>
-            <property name="xalign">0</property>
-            <property name="yalign">0</property>
-            <property name="label" translatable="yes">&lt;big&gt;&lt;b&gt;Starting Software Updater&lt;/b&gt;&lt;/big&gt;</property>
-            <property name="use_markup">True</property>
-          </object>
-          <packing>
-            <property name="expand">False</property>
-            <property name="fill">False</property>
-            <property name="position">0</property>
-          </packing>
-        </child>
-        <child>
-          <object class="GtkLabel" id="label22">
-            <property name="can_focus">False</property>
-            <property name="xalign">0</property>
-            <property name="label" translatable="yes">Software updates correct errors, eliminate security vulnerabilities and provide new features.</property>
-            <property name="use_markup">True</property>
-            <property name="wrap">True</property>
-          </object>
-          <packing>
-            <property name="expand">False</property>
-            <property name="fill">False</property>
-            <property name="position">1</property>
-          </packing>
-        </child>
-        <child>
-          <object class="GtkVBox" id="vbox16">
-            <property name="visible">True</property>
-            <property name="can_focus">False</property>
-            <property name="spacing">6</property>
-            <child>
-              <object class="GtkProgressBar" id="progressbar_cache">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="pulse_step">0.10000000149</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-                <property name="position">0</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkLabel" id="label_cache">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="xalign">0</property>
-                <property name="ellipsize">end</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-                <property name="position">1</property>
-              </packing>
-            </child>
-          </object>
-          <packing>
-            <property name="expand">False</property>
-            <property name="fill">False</property>
-            <property name="position">2</property>
-          </packing>
-        </child>
-      </object>
-    </child>
-  </object>
-  <object class="GtkDialog" id="dialog_dist_upgrade">
-    <property name="can_focus">False</property>
-    <property name="border_width">6</property>
-    <property name="resizable">False</property>
-    <property name="modal">True</property>
-    <property name="window_position">center-on-parent</property>
-    <property name="type_hint">dialog</property>
-    <property name="skip_taskbar_hint">True</property>
-    <property name="skip_pager_hint">True</property>
-    <property name="urgency_hint">True</property>
-    <child internal-child="vbox">
-      <object class="GtkBox" id="dialog-vbox5">
-        <property name="visible">True</property>
-        <property name="can_focus">False</property>
-        <property name="spacing">12</property>
-        <child internal-child="action_area">
-          <object class="GtkButtonBox" id="dialog-action_area5">
-            <property name="visible">True</property>
-            <property name="can_focus">False</property>
-            <property name="layout_style">end</property>
-            <child>
-              <object class="GtkButton" id="cancelbutton2">
-                <property name="label" translatable="yes">_Partial Upgrade</property>
-                <property name="use_action_appearance">False</property>
-                <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="can_default">True</property>
-                <property name="receives_default">False</property>
-                <property name="use_action_appearance">False</property>
-                <property name="use_underline">True</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-                <property name="position">0</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkButton" id="okbutton3">
-                <property name="label">gtk-close</property>
-                <property name="use_action_appearance">False</property>
-                <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="can_default">True</property>
-                <property name="has_default">True</property>
-                <property name="receives_default">False</property>
-                <property name="use_action_appearance">False</property>
-                <property name="use_stock">True</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-                <property name="position">1</property>
-              </packing>
-            </child>
-          </object>
-          <packing>
-            <property name="expand">False</property>
-            <property name="fill">True</property>
-            <property name="pack_type">end</property>
-            <property name="position">0</property>
-          </packing>
-        </child>
-        <child>
-          <object class="GtkHBox" id="hbox20">
-            <property name="visible">True</property>
-            <property name="can_focus">False</property>
-            <property name="border_width">6</property>
-            <property name="spacing">12</property>
-            <child>
-              <object class="GtkImage" id="image15">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="xalign">0</property>
-                <property name="yalign">0</property>
-                <property name="stock">gtk-dialog-warning</property>
-                <property name="icon-size">6</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">True</property>
-                <property name="position">0</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkVBox" id="vbox18">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="spacing">12</property>
-                <child>
-                  <object class="GtkLabel" id="label30">
-                    <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="xalign">0</property>
-                    <property name="label" translatable="yes">&lt;big&gt;&lt;b&gt;Not all updates can be installed&lt;/b&gt;&lt;/big&gt;</property>
-                    <property name="use_markup">True</property>
-                    <property name="selectable">True</property>
-                  </object>
-                  <packing>
-                    <property name="expand">False</property>
-                    <property name="fill">False</property>
-                    <property name="position">0</property>
-                  </packing>
-                </child>
-                <child>
-                  <object class="GtkLabel" id="label31">
-                    <property name="visible">True</property>
-                    <property name="can_focus">False</property>
-                    <property name="xalign">0</property>
-                    <property name="label" translatable="yes">Run a partial upgrade, to install as many updates as possible. 
-
-This can be caused by:
- * A previous upgrade which didn't complete
- * Problems with some of the installed software
- * Unofficial software packages not provided by Ubuntu
- * Normal changes of a pre-release version of Ubuntu</property>
-                    <property name="wrap">True</property>
-                  </object>
-                  <packing>
-                    <property name="expand">False</property>
-                    <property name="fill">False</property>
-                    <property name="position">1</property>
-                  </packing>
-                </child>
-              </object>
-              <packing>
-                <property name="expand">True</property>
-                <property name="fill">True</property>
-                <property name="position">1</property>
-              </packing>
-            </child>
-          </object>
-          <packing>
-            <property name="expand">True</property>
-            <property name="fill">True</property>
-            <property name="position">1</property>
-          </packing>
-        </child>
-      </object>
-    </child>
-    <action-widgets>
-      <action-widget response="-8">cancelbutton2</action-widget>
-      <action-widget response="-7">okbutton3</action-widget>
-    </action-widgets>
-  </object>
-  <object class="GtkDialog" id="dialog_manual_update">
-    <property name="can_focus">False</property>
-    <property name="border_width">6</property>
-    <property name="resizable">False</property>
-    <property name="modal">True</property>
-    <property name="window_position">center-on-parent</property>
-    <property name="type_hint">dialog</property>
-    <property name="skip_taskbar_hint">True</property>
-    <property name="skip_pager_hint">True</property>
-    <child internal-child="vbox">
-      <object class="GtkBox" id="dialog-vbox4">
-        <property name="visible">True</property>
-        <property name="can_focus">False</property>
-        <property name="spacing">12</property>
-        <child internal-child="action_area">
-          <object class="GtkButtonBox" id="dialog-action_area4">
-            <property name="visible">True</property>
-            <property name="can_focus">False</property>
-            <property name="layout_style">end</property>
-            <child>
-              <object class="GtkButton" id="cancelbutton1">
-                <property name="label" translatable="yes">Chec_k</property>
-                <property name="use_action_appearance">False</property>
-                <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="can_default">True</property>
-                <property name="receives_default">False</property>
-                <property name="use_action_appearance">False</property>
-                <property name="image">image-refresh</property>
-                <property name="use_underline">True</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-                <property name="position">0</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkButton" id="okbutton2">
-                <property name="label">gtk-close</property>
-                <property name="use_action_appearance">False</property>
-                <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="can_default">True</property>
-                <property name="receives_default">False</property>
-                <property name="use_action_appearance">False</property>
-                <property name="use_stock">True</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-                <property name="position">1</property>
-              </packing>
-            </child>
-          </object>
-          <packing>
-            <property name="expand">False</property>
-            <property name="fill">True</property>
-            <property name="pack_type">end</property>
-            <property name="position">0</property>
-          </packing>
-        </child>
-        <child>
-          <object class="GtkHBox" id="hbox16">
-            <property name="visible">True</property>
-            <property name="can_focus">False</property>
-            <property name="border_width">6</property>
-            <property name="spacing">11</property>
-            <child>
-              <object class="GtkImage" id="image12">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="xalign">0</property>
-                <property name="yalign">0</property>
-                <property name="stock">gtk-dialog-info</property>
-                <property name="icon-size">6</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">True</property>
-                <property name="position">0</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkVBox" id="vbox17">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="spacing">12</property>
-                <child>
-                  <object class="GtkLabel" id="label27">
-                    <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="xalign">0</property>
-                    <property name="yalign">0</property>
-                    <property name="label" translatable="yes">&lt;b&gt;&lt;big&gt;You must check for updates manually&lt;/big&gt;&lt;/b&gt;
-
-Your system does not check for updates automatically. You can configure this behavior in &lt;i&gt;Software Sources&lt;/i&gt; on the &lt;i&gt;Updates&lt;/i&gt; tab.</property>
-                    <property name="use_markup">True</property>
-                    <property name="wrap">True</property>
-                    <property name="selectable">True</property>
-                  </object>
-                  <packing>
-                    <property name="expand">False</property>
-                    <property name="fill">False</property>
-                    <property name="position">0</property>
-                  </packing>
-                </child>
-                <child>
-                  <object class="GtkCheckButton" id="checkbutton_reminder">
-                    <property name="label" translatable="yes">_Hide this information in the future</property>
-                    <property name="use_action_appearance">False</property>
-                    <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="receives_default">False</property>
-                    <property name="use_action_appearance">False</property>
-                    <property name="use_underline">True</property>
-                    <property name="xalign">0.5</property>
-                    <property name="draw_indicator">True</property>
-                    <signal name="toggled" handler="on_checkbutton_reminder_toggled" swapped="no"/>
-                  </object>
-                  <packing>
-                    <property name="expand">False</property>
-                    <property name="fill">False</property>
-                    <property name="position">1</property>
-                  </packing>
-                </child>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-                <property name="position">1</property>
-              </packing>
-            </child>
-          </object>
-          <packing>
-            <property name="expand">True</property>
-            <property name="fill">True</property>
-            <property name="position">1</property>
-          </packing>
-        </child>
-      </object>
-    </child>
-    <action-widgets>
-      <action-widget response="-8">cancelbutton1</action-widget>
-      <action-widget response="-7">okbutton2</action-widget>
-    </action-widgets>
-  </object>
-  <object class="GtkDialog" id="dialog_on_battery">
-    <property name="can_focus">False</property>
-    <property name="border_width">6</property>
-    <property name="resizable">False</property>
-    <property name="modal">True</property>
-    <property name="window_position">center-on-parent</property>
-    <property name="type_hint">dialog</property>
-    <property name="skip_taskbar_hint">True</property>
-    <property name="skip_pager_hint">True</property>
-    <property name="urgency_hint">True</property>
-    <child internal-child="vbox">
-      <object class="GtkBox" id="dialog-vbox6">
-        <property name="visible">True</property>
-        <property name="can_focus">False</property>
-        <property name="spacing">12</property>
-        <child internal-child="action_area">
-          <object class="GtkButtonBox" id="dialog-action_area6">
-            <property name="visible">True</property>
-            <property name="can_focus">False</property>
-            <property name="layout_style">end</property>
-            <child>
-              <object class="GtkButton" id="button_on_battery_close">
-                <property name="label">gtk-cancel</property>
-                <property name="use_action_appearance">False</property>
-                <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="can_default">True</property>
-                <property name="has_default">True</property>
-                <property name="receives_default">True</property>
-                <property name="use_action_appearance">False</property>
-                <property name="use_stock">True</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-                <property name="position">0</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkButton" id="button_on_battery_continue">
-                <property name="label" translatable="yes">Co_ntinue</property>
-                <property name="use_action_appearance">False</property>
-                <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="can_default">True</property>
-                <property name="receives_default">True</property>
-                <property name="use_action_appearance">False</property>
-                <property name="use_underline">True</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-                <property name="position">1</property>
-              </packing>
-            </child>
-          </object>
-          <packing>
-            <property name="expand">False</property>
-            <property name="fill">True</property>
-            <property name="pack_type">end</property>
-            <property name="position">0</property>
-          </packing>
-        </child>
-        <child>
-          <object class="GtkHBox" id="hbox201">
-            <property name="visible">True</property>
-            <property name="can_focus">False</property>
-            <property name="border_width">6</property>
-            <property name="spacing">12</property>
-            <child>
-              <object class="GtkImage" id="image16">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="xalign">0</property>
-                <property name="yalign">0</property>
-                <property name="stock">gtk-dialog-warning</property>
-                <property name="icon-size">6</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">True</property>
-                <property name="position">0</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkVBox" id="vbox19">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="spacing">12</property>
-                <child>
-                  <object class="GtkLabel" id="label35">
-                    <property name="visible">True</property>
-                    <property name="can_focus">True</property>
-                    <property name="xalign">0</property>
-                    <property name="label" translatable="yes">&lt;big&gt;&lt;b&gt;Running on battery&lt;/b&gt;&lt;/big&gt;</property>
-                    <property name="use_markup">True</property>
-                    <property name="selectable">True</property>
-                  </object>
-                  <packing>
-                    <property name="expand">False</property>
-                    <property name="fill">False</property>
-                    <property name="position">0</property>
-                  </packing>
-                </child>
-                <child>
-                  <object class="GtkLabel" id="label36">
-                    <property name="visible">True</property>
-                    <property name="can_focus">False</property>
-                    <property name="xalign">0</property>
-                    <property name="label" translatable="yes">Your system is running on battery. Are you sure you want to continue?</property>
-                    <property name="wrap">True</property>
-                  </object>
-                  <packing>
-                    <property name="expand">False</property>
-                    <property name="fill">False</property>
-                    <property name="position">1</property>
-                  </packing>
-                </child>
-              </object>
-              <packing>
-                <property name="expand">True</property>
-                <property name="fill">True</property>
-                <property name="position">1</property>
-              </packing>
-            </child>
-          </object>
-          <packing>
-            <property name="expand">True</property>
-            <property name="fill">True</property>
-            <property name="position">1</property>
-          </packing>
-        </child>
-      </object>
-    </child>
-    <action-widgets>
-      <action-widget response="-7">button_on_battery_close</action-widget>
-      <action-widget response="-8">button_on_battery_continue</action-widget>
-    </action-widgets>
-  </object>
-  <object class="GtkDialog" id="dialog_release_notes">
-    <property name="can_focus">False</property>
-    <property name="border_width">6</property>
-    <property name="title" translatable="yes">Release Notes</property>
-    <property name="modal">True</property>
-    <property name="window_position">center-on-parent</property>
-    <property name="default_width">600</property>
-    <property name="default_height">500</property>
-    <property name="type_hint">dialog</property>
-    <child internal-child="vbox">
-      <object class="GtkBox" id="dialog-vbox33">
-        <property name="visible">True</property>
-        <property name="can_focus">False</property>
-        <property name="spacing">6</property>
-        <child internal-child="action_area">
-          <object class="GtkButtonBox" id="dialog-action_area33">
-            <property name="visible">True</property>
-            <property name="can_focus">False</property>
-            <property name="layout_style">end</property>
-            <child>
-              <object class="GtkButton" id="okbutton1">
-                <property name="label">gtk-cancel</property>
-                <property name="use_action_appearance">False</property>
-                <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="can_default">True</property>
-                <property name="receives_default">False</property>
-                <property name="use_action_appearance">False</property>
-                <property name="use_stock">True</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-                <property name="position">0</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkButton" id="button2">
-                <property name="label" translatable="yes">_Upgrade</property>
-                <property name="use_action_appearance">False</property>
-                <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="has_focus">True</property>
-                <property name="can_default">True</property>
-                <property name="has_default">True</property>
-                <property name="receives_default">False</property>
-                <property name="use_action_appearance">False</property>
-                <property name="use_underline">True</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-                <property name="position">1</property>
-              </packing>
-            </child>
-          </object>
-          <packing>
-            <property name="expand">False</property>
-            <property name="fill">True</property>
-            <property name="pack_type">end</property>
-            <property name="position">0</property>
-          </packing>
-        </child>
-        <child>
-          <object class="GtkScrolledWindow" id="scrolled_notes">
-            <property name="visible">True</property>
-            <property name="can_focus">True</property>
-            <property name="border_width">6</property>
-            <property name="shadow_type">in</property>
-            <child>
-              <placeholder/>
-            </child>
-          </object>
-          <packing>
-            <property name="expand">True</property>
-            <property name="fill">True</property>
-            <property name="position">1</property>
-          </packing>
-        </child>
-      </object>
-    </child>
-    <action-widgets>
-      <action-widget response="-6">okbutton1</action-widget>
-      <action-widget response="-5">button2</action-widget>
-    </action-widgets>
-  </object>
   <object class="GtkImage" id="image-apply">
     <property name="visible">True</property>
     <property name="can_focus">False</property>
     <property name="stock">gtk-apply</property>
   </object>
-  <object class="GtkImage" id="image-refresh">
-    <property name="visible">True</property>
-    <property name="can_focus">False</property>
-    <property name="stock">gtk-refresh</property>
-  </object>
-  <object class="GtkWindow" id="window_fetch">
-    <property name="can_focus">False</property>
-    <property name="border_width">6</property>
-    <property name="modal">True</property>
-    <property name="window_position">center-on-parent</property>
-    <property name="default_width">400</property>
-    <property name="type_hint">dialog</property>
-    <property name="skip_taskbar_hint">True</property>
-    <property name="skip_pager_hint">True</property>
-    <child>
-      <object class="GtkVBox" id="vbox6">
-        <property name="visible">True</property>
-        <property name="can_focus">False</property>
-        <property name="spacing">6</property>
-        <child>
-          <object class="GtkVBox" id="vbox7">
-            <property name="visible">True</property>
-            <property name="can_focus">False</property>
-            <property name="border_width">6</property>
-            <property name="spacing">12</property>
-            <child>
-              <object class="GtkLabel" id="label_fetch_summary">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="xalign">0</property>
-                <property name="use_markup">True</property>
-                <property name="wrap">True</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-                <property name="position">0</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkVBox" id="vbox8">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="spacing">6</property>
-                <child>
-                  <object class="GtkProgressBar" id="progressbar_fetch">
-                    <property name="visible">True</property>
-                    <property name="can_focus">False</property>
-                    <property name="pulse_step">0.10000000149</property>
-                  </object>
-                  <packing>
-                    <property name="expand">True</property>
-                    <property name="fill">False</property>
-                    <property name="position">0</property>
-                  </packing>
-                </child>
-                <child>
-                  <object class="GtkLabel" id="label_fetch_status">
-                    <property name="visible">True</property>
-                    <property name="can_focus">False</property>
-                    <property name="xalign">0</property>
-                  </object>
-                  <packing>
-                    <property name="expand">False</property>
-                    <property name="fill">False</property>
-                    <property name="position">1</property>
-                  </packing>
-                </child>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-                <property name="position">1</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkExpander" id="expander1">
-                <property name="can_focus">True</property>
-                <property name="spacing">6</property>
-                <child>
-                  <object class="GtkVBox" id="vbox9">
-                    <property name="visible">True</property>
-                    <property name="can_focus">False</property>
-                    <property name="spacing">6</property>
-                    <child>
-                      <object class="GtkScrolledWindow" id="scrolledwindow6">
-                        <property name="height_request">200</property>
-                        <property name="visible">True</property>
-                        <property name="can_focus">True</property>
-                        <property name="shadow_type">in</property>
-                        <child>
-                          <object class="GtkTreeView" id="treeview1">
-                            <property name="visible">True</property>
-                            <property name="can_focus">True</property>
-                            <property name="enable_search">False</property>
-                            <child internal-child="selection">
-                              <object class="GtkTreeSelection" id="treeview-selection1"/>
-                            </child>
-                          </object>
-                        </child>
-                      </object>
-                      <packing>
-                        <property name="expand">True</property>
-                        <property name="fill">True</property>
-                        <property name="position">0</property>
-                      </packing>
-                    </child>
-                  </object>
-                </child>
-                <child type="label">
-                  <object class="GtkLabel" id="label19">
-                    <property name="visible">True</property>
-                    <property name="can_focus">False</property>
-                    <property name="label" translatable="yes">Show progress of individual files</property>
-                  </object>
-                </child>
-              </object>
-              <packing>
-                <property name="expand">True</property>
-                <property name="fill">True</property>
-                <property name="position">2</property>
-              </packing>
-            </child>
-          </object>
-          <packing>
-            <property name="expand">True</property>
-            <property name="fill">True</property>
-            <property name="position">0</property>
-          </packing>
-        </child>
-        <child>
-          <object class="GtkHButtonBox" id="hbuttonbox7">
-            <property name="visible">True</property>
-            <property name="can_focus">False</property>
-            <property name="layout_style">end</property>
-            <child>
-              <object class="GtkButton" id="button_fetch_cancel">
-                <property name="label">gtk-cancel</property>
-                <property name="use_action_appearance">False</property>
-                <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="receives_default">False</property>
-                <property name="border_width">5</property>
-                <property name="use_action_appearance">False</property>
-                <property name="use_stock">True</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-                <property name="position">0</property>
-              </packing>
-            </child>
-          </object>
-          <packing>
-            <property name="expand">False</property>
-            <property name="fill">True</property>
-            <property name="position">1</property>
-          </packing>
-        </child>
-      </object>
-    </child>
-  </object>
-  <object class="GtkWindow" id="window_main">
-    <property name="can_focus">False</property>
-    <property name="title" translatable="yes">Software Updater</property>
-    <property name="resizable">False</property>
-    <property name="window_position">center</property>
-    <child>
-      <object class="GtkVBox" id="vbox_main">
+  <object class="GtkWindow" id="window_updates_available">
+    <property name="can_focus">False</property>
+    <child>
+      <object class="GtkVBox" id="pane_updates_available">
         <property name="visible">True</property>
         <property name="can_focus">False</property>
         <property name="border_width">6</property>
@@ -796,6 +30,8 @@
                     <property name="visible">True</property>
                     <property name="can_focus">False</property>
                     <property name="yalign">0</property>
+                    <property name="pixel_size">48</property>
+                    <property name="icon_name">system-software-update</property>
                   </object>
                   <packing>
                     <property name="expand">False</property>
@@ -804,46 +40,19 @@
                   </packing>
                 </child>
                 <child>
-                  <object class="GtkVBox" id="vbox_label_main">
+                  <object class="GtkLabel" id="label_header">
                     <property name="visible">True</property>
                     <property name="can_focus">False</property>
-                    <property name="spacing">6</property>
-                    <child>
-                      <object class="GtkLabel" id="label_header">
-                        <property name="visible">True</property>
-                        <property name="can_focus">False</property>
-                        <property name="xalign">0</property>
-                        <property name="yalign">0</property>
-                        <property name="label" translatable="yes">Starting Software Updater</property>
-                        <property name="use_underline">True</property>
-                        <property name="wrap">True</property>
-                        <attributes>
-                          <attribute name="weight" value="bold"/>
-                          <attribute name="scale" value="1.25"/>
-                        </attributes>
-                      </object>
-                      <packing>
-                        <property name="expand">False</property>
-                        <property name="fill">False</property>
-                        <property name="position">0</property>
-                      </packing>
-                    </child>
-                    <child>
-                      <object class="GtkLabel" id="label_main_details">
-                        <property name="visible">True</property>
-                        <property name="can_focus">False</property>
-                        <property name="xalign">0</property>
-                        <property name="wrap">True</property>
-                      </object>
-                      <packing>
-                        <property name="expand">False</property>
-                        <property name="fill">False</property>
-                        <property name="position">1</property>
-                      </packing>
-                    </child>
+                    <property name="xalign">0</property>
+                    <property name="use_underline">True</property>
+                    <property name="wrap">True</property>
+                    <attributes>
+                      <attribute name="weight" value="bold"/>
+                      <attribute name="scale" value="1.25"/>
+                    </attributes>
                   </object>
                   <packing>
-                    <property name="expand">True</property>
+                    <property name="expand">False</property>
                     <property name="fill">True</property>
                     <property name="position">1</property>
                   </packing>
@@ -856,120 +65,6 @@
               </packing>
             </child>
             <child>
-              <object class="GtkFrame" id="frame_new_release">
-                <property name="can_focus">False</property>
-                <property name="label_xalign">0</property>
-                <property name="shadow_type">in</property>
-                <child>
-                  <object class="GtkAlignment" id="alignment5">
-                    <property name="visible">True</property>
-                    <property name="can_focus">False</property>
-                    <child>
-                      <object class="GtkHBox" id="hbox_new_release">
-                        <property name="visible">True</property>
-                        <property name="can_focus">False</property>
-                        <property name="border_width">6</property>
-                        <property name="spacing">6</property>
-                        <child>
-                          <object class="GtkLabel" id="label_new_release">
-                            <property name="visible">True</property>
-                            <property name="can_focus">False</property>
-                            <property name="xalign">0</property>
-                            <property name="use_markup">True</property>
-                          </object>
-                          <packing>
-                            <property name="expand">True</property>
-                            <property name="fill">True</property>
-                            <property name="position">0</property>
-                          </packing>
-                        </child>
-                        <child>
-                          <object class="GtkButton" id="button_dist_upgrade">
-                            <property name="label" translatable="yes">U_pgrade</property>
-                            <property name="use_action_appearance">False</property>
-                            <property name="visible">True</property>
-                            <property name="can_focus">True</property>
-                            <property name="receives_default">True</property>
-                            <property name="use_action_appearance">False</property>
-                            <property name="use_underline">True</property>
-                            <signal name="clicked" handler="on_button_dist_upgrade_clicked" swapped="no"/>
-                          </object>
-                          <packing>
-                            <property name="expand">False</property>
-                            <property name="fill">False</property>
-                            <property name="position">1</property>
-                          </packing>
-                        </child>
-                      </object>
-                    </child>
-                  </object>
-                </child>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">True</property>
-                <property name="position">1</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkFrame" id="frame_restart_required">
-                <property name="can_focus">False</property>
-                <property name="label_xalign">0</property>
-                <property name="shadow_type">in</property>
-                <child>
-                  <object class="GtkAlignment" id="alignment11">
-                    <property name="visible">True</property>
-                    <property name="can_focus">False</property>
-                    <child>
-                      <object class="GtkHBox" id="hbox_reboot">
-                        <property name="visible">True</property>
-                        <property name="can_focus">False</property>
-                        <property name="border_width">6</property>
-                        <property name="spacing">6</property>
-                        <child>
-                          <object class="GtkLabel" id="label_restart_required">
-                            <property name="visible">True</property>
-                            <property name="can_focus">False</property>
-                            <property name="xalign">0</property>
-                            <property name="use_markup">True</property>
-                            <property name="wrap">True</property>
-                            <property name="selectable">True</property>
-                          </object>
-                          <packing>
-                            <property name="expand">True</property>
-                            <property name="fill">True</property>
-                            <property name="position">0</property>
-                          </packing>
-                        </child>
-                        <child>
-                          <object class="GtkButton" id="button_restart_required">
-                            <property name="label" translatable="yes">_Restart Now</property>
-                            <property name="use_action_appearance">False</property>
-                            <property name="visible">True</property>
-                            <property name="can_focus">True</property>
-                            <property name="receives_default">True</property>
-                            <property name="use_action_appearance">False</property>
-                            <property name="use_underline">True</property>
-                            <signal name="clicked" handler="on_button_restart_required_clicked" swapped="no"/>
-                          </object>
-                          <packing>
-                            <property name="expand">False</property>
-                            <property name="fill">False</property>
-                            <property name="position">1</property>
-                          </packing>
-                        </child>
-                      </object>
-                    </child>
-                  </object>
-                </child>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">True</property>
-                <property name="position">2</property>
-              </packing>
-            </child>
-            <child>
               <object class="GtkExpander" id="expander_details">
                 <property name="visible">True</property>
                 <property name="can_focus">True</property>
@@ -998,6 +93,9 @@
                             </child>
                             <signal name="cursor-changed" handler="on_treeview_update_cursor_changed" swapped="no"/>
                             <signal name="row-activated" handler="on_treeview_update_row_activated" swapped="no"/>
+                            <child internal-child="selection">
+                              <object class="GtkTreeSelection" id="treeview-selection"/>
+                            </child>
                           </object>
                         </child>
                       </object>
@@ -1124,7 +222,7 @@
               <packing>
                 <property name="expand">True</property>
                 <property name="fill">True</property>
-                <property name="position">3</property>
+                <property name="position">2</property>
               </packing>
             </child>
             <child>
@@ -1320,17 +418,7 @@
               <packing>
                 <property name="expand">False</property>
                 <property name="fill">True</property>
-                <property name="position">4</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkProgressBar" id="progressbar_cache_inline">
-                <property name="can_focus">False</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">False</property>
-                <property name="position">5</property>
+                <property name="position">3</property>
               </packing>
             </child>
           </object>
@@ -1365,24 +453,6 @@
               </packing>
             </child>
             <child>
-              <object class="GtkButton" id="button_reload">
-                <property name="label" translatable="yes">Chec_k</property>
-                <property name="use_action_appearance">False</property>
-                <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="receives_default">True</property>
-                <property name="use_action_appearance">False</property>
-                <property name="image">image-refresh</property>
-                <property name="use_underline">True</property>
-                <signal name="clicked" handler="on_button_reload_clicked" swapped="no"/>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">True</property>
-                <property name="position">1</property>
-              </packing>
-            </child>
-            <child>
               <object class="GtkButton" id="button_close">
                 <property name="label">gtk-close</property>
                 <property name="use_action_appearance">False</property>

=== added file 'data/gtkbuilder/UpdateProgress.ui'
--- data/gtkbuilder/UpdateProgress.ui	1970-01-01 00:00:00 +0000
+++ data/gtkbuilder/UpdateProgress.ui	2012-06-18 20:03:27 +0000
@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <!-- interface-requires gtk+ 3.0 -->
+  <object class="GtkWindow" id="window_update_progress">
+    <property name="can_focus">False</property>
+    <child>
+      <object class="GtkGrid" id="pane_update_progress">
+        <property name="visible">True</property>
+        <property name="can_focus">False</property>
+        <property name="border_width">12</property>
+        <property name="row_spacing">6</property>
+        <property name="column_spacing">6</property>
+        <child>
+          <object class="GtkLabel" id="label_header">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="xalign">0</property>
+          </object>
+          <packing>
+            <property name="left_attach">0</property>
+            <property name="top_attach">0</property>
+            <property name="width">2</property>
+            <property name="height">1</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkLabel" id="label_details">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="xalign">0</property>
+            <property name="ellipsize">end</property>
+            <property name="max_width_chars">15</property>
+            <attributes>
+              <attribute name="scale" value="0.90000000000000002"/>
+            </attributes>
+          </object>
+          <packing>
+            <property name="left_attach">0</property>
+            <property name="top_attach">2</property>
+            <property name="width">2</property>
+            <property name="height">1</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkAlignment" id="progressbar_slot">
+            <property name="width_request">350</property>
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="hexpand">True</property>
+            <property name="yscale">0.5</property>
+            <child>
+              <placeholder/>
+            </child>
+          </object>
+          <packing>
+            <property name="left_attach">0</property>
+            <property name="top_attach">1</property>
+            <property name="width">1</property>
+            <property name="height">1</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkGrid" id="button_cancel_slot">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <child>
+              <placeholder/>
+            </child>
+          </object>
+          <packing>
+            <property name="left_attach">1</property>
+            <property name="top_attach">1</property>
+            <property name="width">1</property>
+            <property name="height">1</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkGrid" id="expander_slot">
+            <property name="can_focus">False</property>
+            <property name="hexpand">True</property>
+            <property name="vexpand">True</property>
+            <child>
+              <placeholder/>
+            </child>
+          </object>
+          <packing>
+            <property name="left_attach">0</property>
+            <property name="top_attach">3</property>
+            <property name="width">2</property>
+            <property name="height">1</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+  </object>
+</interface>

=== modified file 'data/update-manager.convert'
--- data/update-manager.convert	2012-05-31 22:18:33 +0000
+++ data/update-manager.convert	2012-06-18 20:03:27 +0000
@@ -1,5 +1,4 @@
 [com.ubuntu.update-manager]
-remind-reload = /apps/update-manager/remind_reload
 show-details = /apps/update-manager/show_details
 check-dist-upgrades = /apps/update-manager/check_dist_upgrades
 autoclose-install-window = /apps/update-manager/autoclose_install_window

=== modified file 'tests/interactive_fetch_release_upgrader.py'
--- tests/interactive_fetch_release_upgrader.py	2012-05-01 23:20:42 +0000
+++ tests/interactive_fetch_release_upgrader.py	2012-06-18 20:03:27 +0000
@@ -64,14 +64,17 @@
         self.assertTrue(self.new_dist is not None)
         
     def testdownloading(self):
-        parent = UpdateManager("/usr/share/update-manager/")
+        parent = UpdateManager("/usr/share/update-manager/", None)
         progress = GtkAcquireProgress(parent,
+                                      "/usr/share/update-manager/",
                                       _("Downloading the upgrade "
                                         "tool"),
                                       _("The upgrade tool will "
                                         "guide you through the "
                                         "upgrade process."))
-        fetcher = DistUpgradeFetcherGtk(self.new_dist, parent=parent, progress=progress)
+        fetcher = DistUpgradeFetcherGtk(self.new_dist, parent=parent,
+                                        progress=progress,
+                                        datadir="/usr/share/update-manager/")
         self.assertTrue(fetcher.showReleaseNotes())
         self.assertTrue(fetcher.fetchDistUpgrader())
         self.assertTrue(fetcher.extractDistUpgrader())

=== modified file 'tests/test_end_of_life.py'
--- tests/test_end_of_life.py	2012-06-11 16:17:31 +0000
+++ tests/test_end_of_life.py	2012-06-18 20:03:27 +0000
@@ -23,7 +23,8 @@
         def _nag_dialog_close_helper(checker):
             # this helper is called to verify that the nag dialog appears
             # and that it 
-            dialog = getattr(checker.window_main, "no_longer_supported_nag", None)
+            dialog = getattr(checker, "no_longer_supported_nag", None)
+            print("testing", checker, dialog)
             self.assertNotEqual(dialog, None)
             dialog.response(Gtk.ResponseType.DELETE_EVENT)
             self.dialog_called = True

=== modified file 'update-manager'
--- update-manager	2012-06-13 22:45:57 +0000
+++ update-manager	2012-06-18 20:03:27 +0000
@@ -26,13 +26,16 @@
 from __future__ import print_function
 
 from gi.repository import Gtk
+from gi.repository import Gio
 import gi
 gi.require_version("Gtk", "3.0")
 
 import os
 import sys
+import time
 
 from UpdateManager.UpdateManager import UpdateManager
+from UpdateManager.Core.utils import init_proxy
 from DistUpgrade.DistUpgradeVersion import VERSION
 import locale
 import gettext
@@ -42,7 +45,8 @@
 if __name__ == "__main__":
 
   Gtk.init_check(sys.argv)
-  
+  Gtk.Window.set_default_icon_name("system-software-update")
+
   #FIXME: Workaround a bug in optparser which doesn't handle unicode/str
   #       correctly, see http://bugs.python.org/issue4391
   #       Should be resolved by Python3
@@ -117,5 +121,11 @@
     controller = DistUpgradeController(view, datadir=data_dir)
     controller.doPartialUpgrade()
   else:
+    # keep track when we run (for update-notifier)
+    settings =  Gio.Settings("com.ubuntu.update-manager")
+    settings.set_int("launch-time", int(time.time()))
+    init_proxy(settings)
+
     app = UpdateManager(data_dir, options)
-    app.main(options)
+    app.start_update()
+    Gtk.main()