Merge lp:~ilidrissi.amine/software-center/addons into lp:software-center

[Mohamed Amine Ilidrissi]

This branch introduces add-on handling as described in https://wiki.ubuntu.com/SoftwareCenter#add-ons.
How to test: pick any package that has potential add-ons (like gimp).
Limitations: Descriptions aren't sorted alphabetically.

Feel free to propose any changes - I know my Python skills are pathetic :P.

[lp:~ilidrissi.amine/software-center/addons]

934. By Mohamed Amine Ilidrissi on 2010-08-02

merge with trunk

935. By Mohamed Amine Ilidrissi on 2010-08-02

Modified changelog.

[Matthew Paul Thomas (mpt)]

Mohamed, thanks so much for working on this. I'm impressed.

From a quick test, I see a few interface glitches:

* By default, every software item screen now says "No changes to be done" by default. This text shouldn't ever be necessary.

* The add-ons section appears before the installed state bar. It should instead appear after the item description. <https://wiki.ubuntu.com/SoftwareCenter#software-item-screen>

* There should be a little more vertical space between add-ons. Currently the icon for the first add-on is closer to the icon for the second add-on than it is to its own title. Also, there should be more vertical space after "Choose add-ons:".

* Thunderbird lists 56 add-ons, of which about 50 of them are language/region packs, which should be installed from "System" > "Administration" > "Language Support" instead. Is there an easy way of recognizing language-pack add-ons to avoid showing them in USC?

review: Needs Fixing

[Matthew Paul Thomas (mpt)]

One of Banshee's add-ons is "Media Management and Playback application (debug symbols)". Similarly, one of Evolution's add-ons is "debugging symbols for Evolution". We also need to figure out how to hide those, at least by default.

[lp:~ilidrissi.amine/software-center/addons]

936. By Mohamed Amine IL Idrissi <devildante@devildante-laptop> on 2010-08-04

Fixed a bunch of things at mpt's request.

[Mohamed Amine Ilidrissi (ilidrissi.amine)]

Okay, just fixed these issues. Feel free to request any other fixes.

review: Resubmit

[Michael Vogt (mvo)]

Sorry for the slow reply. I had a look over the code and its pretty good. There are some small issues I would like to see fixed.
- recommended_addons and suggested_addons are almost the same, would be nice to consolidate the bits that are equal into their own function to avoid duplications
- I moved some of the lowlevel stuff into PackageAddonsManager (in lp:~mvo/software-center/addons
- I would love to avoid the extra addons_install, addons_remove to each of the action methods in aptdaemon (as install()/remove() is really a apply() now for complex changes)
- tests are missing
- there are merge conflicts with trunk/ (because of the debfiles branch merge)

There are some design issues (probably more something for mpt):
- moving the install button to the end of the page is not ideal IMO, with the gimp and the default window size its not visible without scrolling
- just showing the summary without a package name or a way to navigate to the app is not that useful for the user to understand what he gets from the addon

[lp:~ilidrissi.amine/software-center/addons]

937. By Mohamed Amine Ilidrissi on 2010-08-11

merge lp:~mvo/software-center/addons, many thanks.

938. By Mohamed Amine Ilidrissi on 2010-08-11

merge with trunk (argh conflicts).

939. By Mohamed Amine Ilidrissi on 2010-08-12

bunch of fixes.

940. By Mohamed Amine Ilidrissi on 2010-08-12

bunch of fixes... again.

941. By Mohamed Amine Ilidrissi on 2010-08-12

merge mvo's branch, many thanks.

942. By Mohamed Amine Ilidrissi on 2010-08-12

Thank you mvo for your efforts :)

943. By Mohamed Amine Ilidrissi on 2010-08-12

Renamed a function.

[Michael Vogt (mvo)]

Thanks, code is good now, I filed a feature-freee-exception for this now https://edge.launchpad.net/ubuntu/+source/software-center/+bug/617297

[lp:~ilidrissi.amine/software-center/addons]

944. By Mohamed Amine Ilidrissi on 2010-08-13

merge with trunk.

945. By Mohamed Amine Ilidrissi on 2010-08-13

Removed useless code and fixed a "big icon" bug.

946. By Mohamed Amine Ilidrissi on 2010-08-13

Disable links to pkgnames until we fix it, and made update_totalsize into a gobject.idle_add() so selecting an add-on feels faster.

947. By Mohamed Amine Ilidrissi on 2010-08-13

software-center will not crash anymore when opening a pkg that does not exist, and it will now check that app_details.icon is not None.

948. By Mohamed Amine Ilidrissi on 2010-08-13

2 fixes for 2 small bugs.

949. By Mohamed Amine Ilidrissi on 2010-08-13

Fixed debian/changelog fail.

950. By Mohamed Amine Ilidrissi on 2010-08-15

merge kiwinote's branch, many thanks :)

951. By Mohamed Amine Ilidrissi on 2010-08-15

Fixed the bar padding, and the total size text.

952. By Mohamed Amine Ilidrissi on 2010-08-15

some fixes.

953. By Mohamed Amine Ilidrissi on 2010-08-16

Polishing.

954. By Mohamed Amine Ilidrissi on 2010-08-16

Fixed padding and added a :

955. By Mohamed Amine Ilidrissi on 2010-08-16

Reduced the add-on image size to 22x22 and made loading the appdetailsview snappier.

956. By Mohamed Amine Ilidrissi on 2010-08-16

Renamed TotalSizeBar to AddonsStateBar.

957. By Mohamed Amine Ilidrissi on 2010-08-16

Fixed padding issues.

958. By Mohamed Amine Ilidrissi on 2010-08-16

Fixed an implementation error.

[Matthew Paul Thomas (mpt)]

Once the vertical spacing above and below the add-ons section is sorted out, I think this is good to merge. Thank you Mohamed.

review: Approve (design)

[lp:~ilidrissi.amine/software-center/addons]

959. By Mohamed Amine Ilidrissi on 2010-08-16

Fixed padding issues.

960. By Mohamed Amine Ilidrissi on 2010-08-16

fixed AddonsStateBar padding issue.

=== modified file 'debian/changelog'
--- debian/changelog	2010-08-13 14:55:27 +0000
+++ debian/changelog	2010-08-16 20:56:42 +0000
@@ -1,3 +1,19 @@
+software-center (2.1.11) UNRELEASED; urgency=low
+  
+  [ Mohamed Amine IL Idrissi ]
+  * (all): Implemented add-on handling.
+
+  [ Kiwinote ]
+  * softwarecenter/view/appdetailsview_gtk.py:
+    - use package info lines rather than package info tables
+      (for devildante to use in the addons branch)
+
+  [ Milo Casagrande ]
+  * softwarecenter/db/application.py:
+    - make 'source available' warning more suitable for translation.
+
+ -- Michael Vogt <[e-mail]>  Fri, 13 Aug 2010 16:46:13 +0200
+
 software-center (2.1.10) maverick; urgency=low
 
   [ Kiwinote ]

=== modified file 'softwarecenter/app.py'
--- softwarecenter/app.py	2010-08-13 10:27:47 +0000
+++ softwarecenter/app.py	2010-08-16 20:56:42 +0000
@@ -206,6 +206,9 @@
                                              self.on_app_selected)
         self.available_pane.app_details.connect("application-request-action", 
                                                 self.on_application_request_action)
+        self.available_pane.app_details.connect("navigation-request", 
+                                                self.on_application_request_navigation,
+                                                self.available_pane)
         self.available_pane.app_view.connect("application-request-action", 
                                              self.on_application_request_action)
         self.available_pane.connect("app-list-changed", 
@@ -248,6 +251,9 @@
                                              self.on_app_selected)
         self.installed_pane.app_details.connect("application-request-action", 
                                                 self.on_application_request_action)
+        self.installed_pane.app_details.connect("navigation-request", 
+                                                self.on_application_request_navigation,
+                                                self.installed_pane)
         self.installed_pane.app_view.connect("application-request-action", 
                                              self.on_application_request_action)
         self.installed_pane.connect("app-list-changed", 
@@ -450,7 +456,10 @@
             channel_display_name, icon=None, query=query)
         self.view_switcher.select_channel_node(channel_display_name, False)
             
-    def on_application_request_action(self, widget, app, action):
+    def on_application_request_navigation(self, widget, pkgname, pane):
+        pane.show_app(Application("", pkgname))
+
+    def on_application_request_action(self, widget, app, addons_install, addons_remove, action):
         """callback when an app action is requested from the appview,
            if action is "remove", must check if other dependencies have to be
            removed as well and show a dialog in that case
@@ -481,7 +490,7 @@
                     self.backend.emit("transaction-stopped")
                     return
             
-        # action_func is one of:  "install", "remove" or "upgrade"
+        # action_func is one of:  "install", "remove", "upgrade", or "apply_changes"
         action_func = getattr(self.backend, action)
         if action == 'install':
             # the package.deb path name is in the request
@@ -489,9 +498,9 @@
                 debfile_name = app.request
             else:
                 debfile_name = None
-            action_func(app.pkgname, app.appname, appdetails.icon, debfile_name)
+            action_func(app.pkgname, app.appname, appdetails.icon, debfile_name, addons_install, addons_remove)
         elif callable(action_func):
-            action_func(app.pkgname, app.appname, appdetails.icon)
+            action_func(app.pkgname, app.appname, appdetails.icon, addons_install=addons_install, addons_remove=addons_remove)
         else:
             logging.error("Not a valid action in AptdaemonBackend: '%s'" % action)
             

=== modified file 'softwarecenter/apt/aptcache.py'
--- softwarecenter/apt/aptcache.py	2010-07-09 03:16:33 +0000
+++ softwarecenter/apt/aptcache.py	2010-08-16 20:56:42 +0000
@@ -32,6 +32,7 @@
 import time
 
 from gettext import gettext as _
+from softwarecenter.enums import *
 
 class GtkMainIterationProgress(apt.progress.base.OpProgress):
     """Progress that just runs the main loop"""
@@ -48,6 +49,8 @@
     DEPENDENCY_TYPES = ("PreDepends", "Depends")
     RECOMMENDS_TYPES = ("Recommends",)
     SUGGESTS_TYPES = ("Suggests",)
+    ENHANCES_TYPES = ("Enhances",)
+    PROVIDES_TYPES = ("Provides",)
 
     # stamp file to monitor (provided by update-notifier via
     # APT::Update::Post-Invoke-Success)
@@ -104,16 +107,16 @@
         return self._cache.__iter__()
     def __contains__(self, k):
         return self._cache.__contains__(k)
-    def _get_installed_rdepends_by_type(self, pkg, type):
-        installed_rdeps = set()
+    def _get_rdepends_by_type(self, pkg, type, onlyInstalled):
+        rdeps = set()
         for rdep in pkg._pkg.rev_depends_list:
             dep_type = rdep.dep_type_untranslated
             if dep_type in type:
                 rdep_name = rdep.parent_pkg.name
-                if (rdep_name in self._cache and
-                    self._cache[rdep_name].is_installed):
-                    installed_rdeps.add(rdep.parent_pkg.name)
-        return installed_rdeps
+                if rdep_name in self._cache and (not onlyInstalled or
+                (onlyInstalled and self._cache[rdep_name].is_installed)):
+                    rdeps.add(rdep.parent_pkg.name)
+        return rdeps
     def _installed_dependencies(self, pkg_name, all_deps=None):
         """ recursively return all installed dependencies of a given pkg """
         #print "_installed_dependencies", pkg_name, all_deps
@@ -168,11 +171,15 @@
                     origins.add(item.origin)
         return origins
     def get_installed_rdepends(self, pkg):
-        return self._get_installed_rdepends_by_type(pkg, self.DEPENDENCY_TYPES)
+        return self._get_rdepends_by_type(pkg, self.DEPENDENCY_TYPES, True)
     def get_installed_rrecommends(self, pkg):
-        return self._get_installed_rdepends_by_type(pkg, self.RECOMMENDS_TYPES)
+        return self._get_rdepends_by_type(pkg, self.RECOMMENDS_TYPES, True)
     def get_installed_rsuggests(self, pkg):
-        return self._get_installed_rdepends_by_type(pkg, self.SUGGESTS_TYPES)
+        return self._get_rdepends_by_type(pkg, self.SUGGESTS_TYPES, True)
+    def get_installed_renhances(self, pkg):
+        return self._get_rdepends_by_type(pkg, self.ENHANCES_TYPES, True)
+    def get_installed_rprovides(self, pkg):
+        return self._get_rdepends_by_type(pkg, self.PROVIDES_TYPES, True)
     def component_available(self, distro_codename, component):
         """ check if the given component is enabled """
         # FIXME: test for more properties here?
@@ -183,6 +190,202 @@
                 it.archive == distro_codename):
                 return True
         return False
+        
+    def _get_depends_by_type(self, pkg, types):
+        version = pkg.installed
+        if version == None:
+            version = max(pkg.versions)
+        return version.get_dependencies(*types)
+    def _get_depends_by_type_str(self, pkg, *types):
+        def not_in_list(list, item):
+            for i in list:
+                if i == item:
+                    return False
+            return True
+        deps = self._get_depends_by_type(pkg, *types)
+        deps_str = []
+        for dep in deps:
+            for dep_ in dep.or_dependencies:
+                if not_in_list(deps_str, dep_.name):
+                    deps_str.append(dep_.name)
+        return deps_str
+    def get_depends(self, pkg):
+        return self._get_depends_by_type_str(pkg, self.DEPENDENCY_TYPES)
+    def get_recommends(self, pkg):
+        return self._get_depends_by_type_str(pkg, self.RECOMMENDS_TYPES)
+    def get_suggests(self, pkg):
+        return self._get_depends_by_type_str(pkg, self.SUGGESTS_TYPES)
+    def get_enhances(self, pkg):
+        return self._get_depends_by_type_str(pkg, self.ENHANCES_TYPES)
+    def get_provides(self, pkg):
+        return self._get_depends_by_type_str(pkg, self.PROVIDES_TYPES)
+        
+    def get_rdepends(self, pkg):
+        return self._get_rdepends_by_type(pkg, self.DEPENDENCY_TYPES, False)
+    def get_rrecommends(self, pkg):
+        return self._get_rdepends_by_type(pkg, self.RECOMMENDS_TYPES, False)
+    def get_rsuggests(self, pkg):
+        return self._get_rdepends_by_type(pkg, self.SUGGESTS_TYPES, False)
+    def get_renhances(self, pkg):
+        return self._get_rdepends_by_type(pkg, self.ENHANCES_TYPES, False)
+    def get_rprovides(self, pkg):
+        return self._get_rdepends_by_type(pkg, self.PROVIDES_TYPES, False)
+        
+    def _get_changes_without_applying(self, pkg):
+        if pkg.installed == None:
+            pkg.mark_install()
+        else:
+            pkg.mark_delete()
+        changes_tmp = self._cache.get_changes()
+        changes = {}
+        for change in changes_tmp:
+            if change.marked_install or change.marked_reinstall:
+                changes[change.name] = PKG_STATE_INSTALLING
+            elif change.marked_delete:
+                changes[change.name] = PKG_STATE_REMOVING
+            elif change.marked_upgrade:
+                changes[change.name] = PKG_STATE_UPGRADING
+            else:
+                changes[change.name] = PKG_STATE_UNKNOWN
+        self._cache.clear()
+        return changes
+    def get_all_deps_installing(self, pkg):
+        """ Return all dependencies of pkg that will be marked for install """
+        changes = self._get_changes_without_applying(pkg)
+        installing_deps = []
+        for change in changes.keys():
+            if change != pkg.name and changes[change] == PKG_STATE_INSTALLING:
+                installing_deps.append(change)
+        return installing_deps
+    def get_all_deps_removing(self, pkg):
+        changes = self._get_changes_without_applying(pkg)
+        removing_deps = []
+        for change in changes.keys():
+            if change != pkg.name and changes[change] == PKG_STATE_REMOVING:
+                removing_deps.append(change)
+        return removing_deps
+    def get_all_deps_upgrading(self, pkg):
+        changes = self._get_changes_without_applying(pkg)
+        upgrading_deps = []
+        for change in changes.keys():
+            if change != pkg.name and changes[change] == PKG_STATE_UPGRADING:
+                upgrading_deps.append(change)
+        return upgrading_deps
+
+class PackageAddonsManager(object):
+    """ class that abstracts the addons handling """
+
+    LANGPACK_PKGDEPENDS = "/usr/share/language-selector/data/pkg_depends"
+    (RECOMMENDED, SUGGESTED) = range(2)
+    
+    def __init__(self, cache):
+        self.cache = cache
+        self._language_packages = self._read_language_pkgs()
+
+    def _remove_important_or_langpack(self, addon_list, app_pkg):
+        """ remove packages that are essential or important
+            or langpacks
+        """
+        for addon in addon_list:
+            try:
+                pkg = self.cache[addon]
+                if pkg.essential or pkg._pkg.important or addon == app_pkg.name:
+                    addon_list.remove(addon)
+                    continue
+                
+                deps = self.cache.get_depends(app_pkg)
+                if addon in deps:
+                    addon_list.remove(addon)
+                    continue
+                
+                rdeps = self.cache.get_installed_rdepends(pkg)
+                if (len(rdeps) > 0 or 
+                    self._is_language_pkg(addon)):
+                    addon_list.remove(addon)
+                    continue
+            except KeyError:
+                addon_list.remove(addon)
+    
+    def _is_language_pkg(self, addon):
+        # a simple "addon in self._language_packages" is not enough
+        for template in self._language_packages:
+            if addon.startswith(template):
+                return True
+        return False
+
+    def _read_language_pkgs(self):
+        language_packages = set()
+        for line in open(self.LANGPACK_PKGDEPENDS):
+            line = line.strip()
+            if line.startswith('#'):
+                continue
+            try:
+                (cat, code, dep_pkg, language_pkg) = line.split(':')
+            except ValueError:
+                continue
+            language_packages.add(language_pkg)
+        return language_packages
+    
+    def _addons_for_pkg(self, pkgname, type):
+        try:
+            pkg = self.cache[pkgname]
+        except KeyError:
+            return []
+        deps = self.cache.get_depends(pkg)
+        addons = []
+        if type == self.RECOMMENDED:
+            recommends = self.cache.get_recommends(pkg)
+            if len(recommends) == 1:
+                addons += recommends
+        elif type == self.SUGGESTED:
+            suggests = self.cache.get_suggests(pkg)
+            if len(suggests) == 1:
+                addons += suggests
+            addons += self.cache.get_renhances(pkg)
+        
+        for dep in deps:
+            try:
+                pkgdep = self.cache[dep]
+                if len(self.cache.get_rdepends(pkgdep)) == 1:
+                    # pkg is the only known package that depends on pkgdep
+                    if type == self.RECOMMENDED:
+                        addons += self.cache.get_recommends(pkgdep)
+                    elif type == self.SUGGESTED:
+                        addons += self.cache.get_suggests(pkgdep)
+                        addons += self.cache.get_renhances(pkgdep)
+            except KeyError:
+                pass # FIXME: should we handle that differently?
+        self._remove_important_or_langpack(addons, pkg)
+        for addon in addons:
+            try:
+                pkg_ = self.cache[addon]
+            except KeyError:
+                addons.remove(addon)
+            else:
+                can_remove = False
+                for addon_ in addons:
+                    try:
+                        if addon in self.cache.get_provides(self.cache[addon_]) \
+                        or addon in self.cache.get_depends(self.cache[addon_]) \
+                        or addon in self.cache.get_recommends(self.cache[addon_]):
+                            can_remove = True
+                            break
+                    except KeyError:
+                        addons.remove(addon_)
+                        break
+                if can_remove or not pkg_.candidate or addons.count(addon) > 1 \
+                or addon == pkg.name or self._is_language_pkg(addon):
+                    addons.remove(addon)
+        # FIXME: figure out why I have to call this function two times to get rid of important packages
+		self._remove_important_or_langpack(addons, pkg)
+        return addons
+    
+    def recommended_addons(self, pkgname):
+        return self._addons_for_pkg(pkgname, self.RECOMMENDED)
+    
+    def suggested_addons(self, pkgname):
+        return self._addons_for_pkg(pkgname, self.SUGGESTED)
+    
 
 if __name__ == "__main__":
     c = AptCache()
@@ -200,3 +403,18 @@
     print c.get_installed_rdepends(pkg)
     print c.get_installed_rrecommends(pkg)
     print c.get_installed_rsuggests(pkg)
+    
+    print "deps of gimp"
+    pkg = c["gimp"]
+    print c.get_depends(pkg)
+    print c.get_recommends(pkg)
+    print c.get_suggests(pkg)
+    print c.get_enhances(pkg)
+    print c.get_provides(pkg)
+    
+    print "rdeps of gimp"
+    print c.get_rdepends(pkg)
+    print c.get_rrecommends(pkg)
+    print c.get_rsuggests(pkg)
+    print c.get_renhances(pkg)
+    print c.get_rprovides(pkg)

=== modified file 'softwarecenter/backend/aptd.py'
--- softwarecenter/backend/aptd.py	2010-08-11 14:00:11 +0000
+++ softwarecenter/backend/aptd.py	2010-08-16 20:56:42 +0000
@@ -126,8 +126,9 @@
         except Exception, error:
             self._on_trans_error(error)
 
+    # FIXME: upgrade add-ons here
     @inline_callbacks
-    def upgrade(self, pkgname, appname, iconname, metadata=None):
+    def upgrade(self, pkgname, appname, iconname, addons_install=None, addons_remove=None, metadata=None):
         """ upgrade a single package """
         self.emit("transaction-started")
         try:
@@ -138,7 +139,7 @@
             self._on_trans_error(error, pkgname)
 
     @inline_callbacks
-    def remove(self, pkgname, appname, iconname, metadata=None):
+    def remove(self, pkgname, appname, iconname, addons_install=None, addons_remove=None, metadata=None):
         """ remove a single package """
         self.emit("transaction-started")
         try:
@@ -149,7 +150,7 @@
             self._on_trans_error(error, pkgname)
 
     @inline_callbacks
-    def remove_multiple(self, pkgnames, appnames, iconnames, metadatas=None):
+    def remove_multiple(self, pkgnames, appnames, iconnames, addons_install=None, addons_remove=None, metadatas=None):
         """ queue a list of packages for removal  """
         if metadatas == None:
             metadatas = []
@@ -159,7 +160,7 @@
             yield self.remove(pkgname, appname, iconname, metadata)
 
     @inline_callbacks
-    def install(self, pkgname, appname, iconname, filename=None, metadata=None):
+    def install(self, pkgname, appname, iconname, filename=None, addons_install=None, addons_remove=None, metadata=None):
         """Install a single package from the archive
            If filename is given a local deb package is installed instead.
         """
@@ -169,21 +170,30 @@
                 trans = yield self.aptd_client.install_file(filename,
                                                             defer=True)
             else:
-                trans = yield self.aptd_client.install_packages([pkgname],
-                                                            defer=True)
+                trans = yield self.aptd_client.commit_packages([pkgname] + addons_install, [], addons_remove, [], [])
             yield self._run_transaction(trans, pkgname, appname, iconname, metadata)
         except Exception, error:
             self._on_trans_error(error, pkgname)
 
     @inline_callbacks
-    def install_multiple(self, pkgnames, appnames, iconnames, metadatas=None):
+    def install_multiple(self, pkgnames, appnames, iconnames, addons_install=None, addons_remove=None, metadatas=None):
         """ queue a list of packages for install  """
         if metadatas == None:
             metadatas = []
             for item in pkgnames:
                 metadatas.append(None)
         for pkgname, appname, iconname, metadata in zip(pkgnames, appnames, iconnames, metadatas):
-            yield self.install(pkgname, appname, iconname, metadata)
+            yield self.install(pkgname, appname, iconname, metadata=metadata)
+            
+    @inline_callbacks
+    def apply_changes(self, pkgname, appname, iconname, addons_install=None, addons_remove=None, metadata=None):
+        """ install and remove add-ons """
+        self.emit("transaction-started")
+        try:
+            trans = yield self.aptd_client.commit_packages(addons_install, [], addons_remove, [], [])
+            yield self._run_transaction(trans, pkgname, appname, iconname)
+        except Exception, error:
+            self._on_trans_error(error)
 
     @inline_callbacks
     def reload(self, metadata=None):

=== modified file 'softwarecenter/db/application.py'
--- softwarecenter/db/application.py	2010-08-13 14:25:11 +0000
+++ softwarecenter/db/application.py	2010-08-16 20:56:42 +0000
@@ -456,11 +456,18 @@
                 source_to_enable = self.component
             if source_to_enable:
                 sources = source_to_enable.split('&')
-                warning = _("Available from the \"%s\"") % sources[0]
-                if len(sources) > 1:
-                    for source in sources[1:]:
-                       warning += _(", or from the \"%s\"") % source
-                warning += _(" source.")
+                sources_length = len(sources)
+                if sources_length == 1:
+                    warning = _("Available from the \"%s\" source.") % sources[0]
+                elif sources_length > 1:
+                    # Translators: the visible string is constructed concatenating 
+                    # the following 3 strings like this: 
+                    # Available from the following sources: %s, ... %s, %s.                
+                    warning = _("Available from the following sources: ")
+                    # Cycle through all, but the last
+                    for source in sources[:-1]:
+                        warning += _("\"%s\", ") % source
+                    warning += _("\"%s\".") % sources[sources_length - 1]
                 return warning
 
     @property

=== modified file 'softwarecenter/enums.py'
--- softwarecenter/enums.py	2010-08-10 08:31:32 +0000
+++ softwarecenter/enums.py	2010-08-16 20:56:42 +0000
@@ -126,6 +126,7 @@
 APP_ACTION_INSTALL = "install"
 APP_ACTION_REMOVE = "remove"
 APP_ACTION_UPGRADE = "upgrade"
+APP_ACTION_APPLY = "apply_changes"
 
 from version import *
 USER_AGENT="Software Center/%s (N;) %s/%s (%s)" % (VERSION, 

=== modified file 'softwarecenter/view/appdetailsview.py'
--- softwarecenter/view/appdetailsview.py	2010-08-09 14:17:41 +0000
+++ softwarecenter/view/appdetailsview.py	2010-08-16 20:56:42 +0000
@@ -22,7 +22,7 @@
 import urllib
 import gobject
 
-from softwarecenter.enums import MISSING_APP_ICON
+from softwarecenter.apt.aptcache import PackageAddonsManager
 from softwarecenter.db.application import AppDetails
 from softwarecenter.backend import get_install_backend
 from softwarecenter.enums import *
@@ -35,8 +35,17 @@
     __gsignals__ = {
         "application-request-action" : (gobject.SIGNAL_RUN_LAST,
                                         gobject.TYPE_NONE,
-                                        (gobject.TYPE_PYOBJECT, str),
+                                        (gobject.TYPE_PYOBJECT, 
+                                         gobject.TYPE_PYOBJECT, 
+                                         gobject.TYPE_PYOBJECT, 
+                                         str),
                                        ),
+        "navigation-request" : ( gobject.SIGNAL_RUN_LAST,
+                                 gobject.TYPE_NONE,
+                                 (str,
+                                 ),
+                                ),
+
     }
 
     def __init__(self, db, distro, icons, cache, history, datadir):
@@ -45,10 +54,13 @@
         self.icons = icons
         self.cache = cache
         self.cache.connect("cache-ready", self._on_cache_ready)
+        self.addons_manager = PackageAddonsManager(cache)
         self.history = history
         self.datadir = datadir
         self.app = None
         self.appdetails = None
+        self.addons_install = []
+        self.addons_remove = []
         # aptdaemon
         self.backend = get_install_backend()
         self._logger = logging.getLogger(__name__)
@@ -58,6 +70,22 @@
             you need to overwrite
         """
         pass
+    
+    # add-on handling
+    def _set_addon_install(self, addon):
+        pkg = self.cache[addon]
+        if addon not in self.addons_install and pkg.installed == None:
+            self.addons_install.append(addon)
+        if addon in self.addons_remove:
+            self.addons_remove.remove(addon)
+    
+    def _set_addon_remove(self, addon):
+        pkg = self.cache[addon]
+        if addon not in self.addons_remove and pkg.installed != None:
+            self.addons_remove.append(addon)
+        if addon in self.addons_install:
+            self.addons_install.remove(addon)
+        
     # public API
     def show_app(self, app):
         """ show the given application """
@@ -75,13 +103,16 @@
         self.backend.reload()
     def install(self):
         """ install the current application, fire an action request """
-        self.emit("application-request-action", self.app, APP_ACTION_INSTALL)
+        self.emit("application-request-action", self.app, self.addons_install, self.addons_remove, APP_ACTION_INSTALL)
     def remove(self):
         """ remove the current application, , fire an action request """
-        self.emit("application-request-action", self.app, APP_ACTION_REMOVE)
+        self.emit("application-request-action", self.app, self.addons_install, self.addons_remove, APP_ACTION_REMOVE)
     def upgrade(self):
         """ upgrade the current application, fire an action request """
-        self.emit("application-request-action", self.app, APP_ACTION_UPGRADE)
+        self.emit("application-request-action", self.app, self.addons_install, self.addons_remove, APP_ACTION_UPGRADE)
+    def apply_changes(self):
+        """ apply changes concerning add-ons """
+        self.emit("application-request-action", self.app, self.addons_install, self.addons_remove, APP_ACTION_APPLY)
 
     def buy_app(self):
         """ initiate the purchase transaction """
@@ -107,10 +138,10 @@
         get_install_backend().add_repo_add_key_and_install_app(deb_line,
                                                                signing_key_id,
                                                                self.app)
-
     # internal callbacks
     def _on_cache_ready(self, cache):
         # re-show the application if the cache changes, it may affect the
         # current application
         self._logger.debug("on_cache_ready")
         self.show_app(self.app)
+        self.addons_manager = PackageAddonsManager(cache)

=== modified file 'softwarecenter/view/appdetailsview_gtk.py'
--- softwarecenter/view/appdetailsview_gtk.py	2010-08-13 14:25:11 +0000
+++ softwarecenter/view/appdetailsview_gtk.py	2010-08-16 20:56:42 +0000
@@ -33,8 +33,10 @@
 import cairo
 
 from gettext import gettext as _
+import apt_pkg
 from softwarecenter.backend import get_install_backend
-from softwarecenter.db.application import AppDetails
+from softwarecenter.db.application import AppDetails, Application
+from softwarecenter.apt.aptcache import AptCache
 from softwarecenter.enums import *
 from softwarecenter.paths import SOFTWARE_CENTER_ICON_CACHE_DIR
 from softwarecenter.utils import ImageDownloader
@@ -150,7 +152,8 @@
         if state in (PKG_STATE_INSTALLING,
                      PKG_STATE_INSTALLING_PURCHASED,
                      PKG_STATE_REMOVING,
-                     PKG_STATE_UPGRADING):
+                     PKG_STATE_UPGRADING,
+                     APP_ACTION_APPLY):
             self.button.hide()
             self.show()
         elif state == PKG_STATE_NOT_FOUND:
@@ -159,8 +162,8 @@
             self.button.set_sensitive(False)
             self.button.show()
             self.show()
-        else:
             state = app_details.pkg_state
+        else:
             self.button.set_sensitive(True)
             self.button.show()
             self.show()
@@ -202,7 +205,7 @@
             if app_details.price:
                 self.set_label(app_details.price)
             else:
-                self.set_label("")
+                self.set_label("Free")
             self.set_button_label(_('Install'))
         elif state == PKG_STATE_REINSTALLABLE:
             if app_details.price:
@@ -213,6 +216,11 @@
         elif state == PKG_STATE_UPGRADABLE:
             self.set_label(_('Upgrade Available'))
             self.set_button_label(_('Upgrade'))
+        elif state == APP_ACTION_APPLY:
+            self.set_label(_('Changing add-ons...'))
+        elif state == PKG_STATE_UNKNOWN:
+            self.set_button_label("")
+            self.set_label(_("Error"))
         elif state == PKG_STATE_ERROR:
             # this is used when the pkg can not be installed
             # we display the error in the description field
@@ -411,78 +419,51 @@
         self.show_all()
         return    
 
-
-class PackageInfoTable(gtk.VBox):
-
-    def __init__(self):
-        gtk.VBox.__init__(self, spacing=mkit.SPACING_MED)
-
-        self.version_label = gtk.Label()
-        self.license_label = gtk.Label()
-        self.support_label = gtk.Label()
-
-        self.version_label.set_selectable(True)
-
+class PackageInfo(gtk.HBox):
+
+    def __init__(self, key):
+        gtk.HBox.__init__(self, spacing=mkit.SPACING_XLARGE)
+        self.key = key
+        self.value_object = gtk.Label()
         self.connect('realize', self._on_realize)
         return
 
     def _on_realize(self, widget):
+        # key
+        k = gtk.Label()
         dark = self.style.dark[self.state].to_string()
         key_markup = '<b><span color="%s">%s</span></b>'
-        max_lw = 0  # max key label width
-
-        for kstr, v in [(_('Version:'), self.version_label),
-                        (_('License:'), self.license_label),
-                        (_('Updates:'), self.support_label)]:
-
-            k = gtk.Label()
-            k.set_markup(key_markup  % (dark, kstr))
-            v.set_line_wrap(True)
-            max_lw = max(max_lw, k.get_layout().get_pixel_extents()[1][2])
-
-            a = gtk.Alignment(1.0, 0.0)
-            a.add(k)
-
-            # we need this extra box to avoid orca repeating itself
-            b = gtk.Alignment(0.0, 0.0)
-            b.add(v)
-
-            row = gtk.HBox(spacing=mkit.SPACING_XLARGE)
-            row.pack_start(a, False)
-            row.pack_start(b, False)
-
-            # a11y stuff
-            row.set_property("can-focus", True)
-            row.a11y = row.get_accessible()
-            row.a11y.set_name(kstr)
-
-            self.pack_start(row, False)
-
-        for row in self.get_children():
-            k, v = row.get_children()
-            k.set_size_request(max_lw+3*mkit.EM, -1)
+        k.set_markup(key_markup  % (dark, self.key))
+        a = gtk.Alignment(1.0, 0.0)
+        # the line below is 'wrong', but in reality it works quite ok
+        a.set_size_request(100, -1)
+        a.add(k)
+        self.pack_start(a, False)
+
+        # value
+        v = self.value_object
+        v.set_line_wrap(True)
+        v.set_selectable(True)
+        b = gtk.Alignment(0.0, 0.0)
+        b.add(v)
+        self.pack_start(b, False)
+
+        # a11y stuff
+        self.set_property("can-focus", True)
+        self.a11y = self.get_accessible()
 
         self.show_all()
         return
 
     def set_width(self, width):
-        for row in self.get_children():
-            k, v = row.get_children()
-            v.set_size_request(width-k.allocation.width-row.get_spacing(), -1)
+        if self.get_children():
+            k, v = self.get_children()
+            v.set_size_request(width-k.allocation.width-self.get_spacing(), -1)
         return
 
-    def configure(self, version, license, updates):
-
-        # set labels
-        self.version_label.set_text(version)
-        self.license_label.set_text(license)
-        self.support_label.set_text(updates)
-
-        # set a11y texts
-        for row in self.get_children():
-            key = row.a11y.get_name().split(":")[0]
-            value = row.get_children()[1].get_children()[0].get_text()
-            row.a11y.set_name(key + ': ' + value)
+    def set_value(self, value):
+        self.value_object.set_text(value)
+        self.a11y.set_name(self.key + ' ' + value)
 
 class ScreenshotView(gtk.Alignment):
 
@@ -784,6 +765,215 @@
             cr.fill()
         return
 
+class AddonCheckButton(gtk.HBox):
+    """ A widget that represents an add-on: 
+    |CheckButton|Icon|Description| """
+    
+    __gsignals__ = {'toggled': (gobject.SIGNAL_RUN_FIRST,
+                                gobject.TYPE_NONE,
+                                ()), 
+                   }
+    
+    def __init__(self, db, icons, pkgname):
+        gtk.HBox.__init__(self, spacing=mkit.SPACING_LARGE)
+        self.app_details = AppDetails(db, 
+                                      application=Application("None", pkgname))
+        # the checkbutton
+        self.checkbutton = gtk.CheckButton()
+        self.checkbutton.connect("toggled", self._on_checkbutton_toggled)
+        self.pack_start(self.checkbutton, False)
+        # the hbox inside the checkbutton that contains the icon and description
+        hbox = gtk.HBox(spacing=mkit.SPACING_MED)
+        image = gtk.Image()
+        icon = self.app_details.icon
+        if not icon or not icons.has_icon(icon):
+            icon = MISSING_APP_ICON
+        try:
+            pixbuf = icons.load_icon(icon, 22, ()).scale_simple(22, 22, gtk.gdk.INTERP_BILINEAR)
+            image.set_from_pixbuf(pixbuf)
+        except TypeError:
+            logging.warning("cant set icon for '%s' " % pkgname)
+        hbox.pack_start(image, False, False)
+        # the display_name
+        display_name = _("%(summary)s (%(pkgname)s)") % {'summary': self.app_details.display_name.capitalize(),
+                                                        'pkgname': pkgname}
+        label = gtk.Label(display_name)
+        hbox.pack_start(label, False)
+        # and put it into the the checkbox
+        self.checkbutton.add(hbox)
+        # this is the addon_pkgname
+        #self.addon_pkgname = gtk.Label(_(" (%(pkgname)s)") % {
+        #        'pkgname' : pkgname } )
+        #hbox.pack_start(self.addon_pkgname, False)
+        
+    
+    def _on_checkbutton_toggled(self, checkbutton):
+        self.emit("toggled")
+    def get_active(self):
+        return self.checkbutton.get_active()
+    def set_active(self, is_active):
+        self.checkbutton.set_active(is_active)
+    def get_addon(self):
+        return self.app_details.pkgname
+    
+
+class AddonView(gtk.VBox):
+    """ A widget that handles the application add-ons """
+    # TODO: sort add-ons in alphabetical order
+    
+    __gsignals__ = {'toggled':(gobject.SIGNAL_RUN_FIRST,
+                                gobject.TYPE_NONE,
+                                (str, gobject.TYPE_PYOBJECT)),
+                    'description-clicked':(gobject.SIGNAL_RUN_FIRST,
+                                           gobject.TYPE_NONE,
+                                           (str, )),
+                   }
+    
+    def __init__(self, cache, db, icons):
+        gtk.VBox.__init__(self, False, mkit.SPACING_MED)
+        self.cache = cache
+        self.db = db
+        self.icons = icons
+        self.recommended_addons = None
+        self.suggested_addons = None
+
+        self.label = gtk.Label(_("<b>Choose add-ons:</b>"))
+        self.label.set_use_markup(True)
+        self.label.set_alignment(0, 0.5)
+        self.pack_start(self.label, False, False)
+    
+    def set_addons(self, app_details, recommended, suggested):
+        if len(recommended) == 0 and len(suggested) == 0:
+            return
+        self.recommended_addons = recommended
+        self.suggested_addons = suggested
+        self.app_details = app_details
+            
+        for widget in self:
+            if widget != self.label:
+                self.remove(widget)
+        
+        for addon in recommended:
+            try:
+                pkg = self.cache[addon]
+            except KeyError:
+                continue
+            checkbutton = AddonCheckButton(self.db, self.icons, addon)
+            #checkbutton.addon_pkgname.connect(
+            #    "clicked", self._on_description_clicked, addon)
+            checkbutton.set_active(pkg.installed != None)
+            checkbutton.connect("toggled", self._on_checkbutton_toggled)
+            self.pack_start(checkbutton, False)
+        for addon in suggested:
+            try:
+                pkg = self.cache[addon]
+            except KeyError:
+                continue
+            checkbutton = AddonCheckButton(self.db, self.icons, addon)
+            #checkbutton.addon_pkgname.connect(
+            #    "clicked", self._on_description_clicked, addon)
+            checkbutton.set_active(pkg.installed != None)
+            checkbutton.connect("toggled", self._on_checkbutton_toggled)
+            self.pack_start(checkbutton, False)
+        self.show_all()
+        return False
+    
+    def _on_checkbutton_toggled(self, checkbutton):
+        addon = checkbutton.get_addon()
+        self.emit("toggled", addon, checkbutton.get_active())
+    
+    def _on_description_clicked(self, label, addon):
+        self.emit("description-clicked", addon)
+
+class AddonsStateBar(gtk.Alignment):
+    __gsignals__ = {'changes-canceled': (gobject.SIGNAL_RUN_FIRST,
+                                         gobject.TYPE_NONE,
+                                         ()),
+                   }
+    
+    def __init__(self, cache, view):
+        gtk.Alignment.__init__(self, xscale=1.0, yscale=1.0)
+        self.set_redraw_on_allocate(False)
+        self.set_padding(mkit.SPACING_LARGE,
+                         mkit.SPACING_LARGE,
+                         mkit.SPACING_SMALL+2,
+                         mkit.SPACING_SMALL)
+        
+        self.hbox = gtk.HBox(spacing=mkit.SPACING_LARGE)
+        self.add(self.hbox)
+        
+        self.cache = cache
+        self.view = view
+        self.applying = False
+        
+        self.label_price = gtk.Label()
+        self.label_price.set_line_wrap(True)
+        self.hbox.pack_start(self.label_price, False, False)
+        
+        self.hbuttonbox = gtk.HButtonBox()
+        self.hbuttonbox.set_layout(gtk.BUTTONBOX_END)
+        self.button_apply = gtk.Button(_("Apply Changes"))
+        self.button_apply.connect("clicked", self._on_button_apply_clicked)
+        self.button_cancel = gtk.Button(_("Cancel"))
+        self.button_cancel.connect("clicked", self._on_button_cancel_clicked)
+        self.hbuttonbox.pack_start(self.button_cancel, False)
+        self.hbuttonbox.pack_start(self.button_apply, False)
+        self.hbox.pack_start(self.hbuttonbox)
+        
+        self.fill_color = COLOR_GREEN_FILL
+        self.line_color = COLOR_GREEN_OUTLINE
+        
+    def configure(self, app_details, addons_install, addons_remove):
+        if not addons_install and not addons_remove:
+            self.hide()
+            return
+        if app_details.price:
+            self.label_price.set_label(app_details.price)
+        else:
+            self.label_price.set_label(_("Free"))
+        self.show()
+            
+    def draw(self, cr, a, expose_area):
+        if mkit.not_overlapping(a, expose_area): return
+
+        cr.save()
+        rr = mkit.ShapeRoundedRectangle()
+        rr.layout(cr,
+                  a.x-1, a.y-1,
+                  a.x+a.width, a.y+a.height,
+                  radius=mkit.CORNER_RADIUS)
+
+        cr.set_source_rgb(*mkit.floats_from_string(self.fill_color))
+#        cr.set_source_rgb(*mkit.floats_from_string(self.line_color))
+        cr.fill()
+
+        cr.set_line_width(1)
+        cr.translate(0.5, 0.5)
+
+        rr.layout(cr,
+                  a.x-1, a.y-1,
+                  a.x+a.width, a.y+a.height,
+                  radius=mkit.CORNER_RADIUS)
+
+        cr.set_source_rgb(*mkit.floats_from_string(self.line_color))
+        cr.stroke()
+        cr.restore()
+        return
+    
+    def get_applying(self):
+        return self.applying
+    def set_applying(self, applying):
+        self.applying = applying
+    
+    def _on_button_apply_clicked(self, button):
+        self.applying = True
+        self.button_apply.set_sensitive(False)
+        self.button_cancel.set_sensitive(False)
+        AppDetailsViewBase.apply_changes(self.view)
+        
+    def _on_button_cancel_clicked(self, button):
+        self.emit("changes-canceled")
+        
 
 class AppDetailsViewGtk(gtk.Viewport, AppDetailsViewBase):
 
@@ -804,8 +994,14 @@
                                 (gobject.TYPE_PYOBJECT,)),
                     'application-request-action' : (gobject.SIGNAL_RUN_LAST,
                                         gobject.TYPE_NONE,
-                                        (gobject.TYPE_PYOBJECT, str),
+                                        (gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, str),
                                        ),
+        "navigation-request" : ( gobject.SIGNAL_RUN_LAST,
+                                 gobject.TYPE_NONE,
+                                 (str,
+                                 ),
+                                ),
+
                     }
 
 
@@ -854,7 +1050,9 @@
         for pt in self.app_desc.points:
             pt.set_size_request(w-7*mkit.EM-166, -1)
 
-        self.info_table.set_width(w-6*mkit.EM)
+        self.version_info.set_width(w-6*mkit.EM)
+        self.license_info.set_width(w-6*mkit.EM)
+        self.support_info.set_width(w-6*mkit.EM)
 
         self._full_redraw()   #  ewww
         return
@@ -886,6 +1084,11 @@
             self.action_bar.draw(cr,
                                  self.action_bar.allocation,
                                  event.area)
+        
+        if self.addons_bar.get_property('visible'):
+            self.addons_bar.draw(cr,
+                                 self.addons_bar.hbox.allocation,
+                                 event.area)
 
         if self.screenshot.get_property('visible'):
             self.screenshot.draw(cr, self.screenshot.allocation, expose_area)
@@ -957,17 +1160,17 @@
 
         # we have our own viewport so we know when the viewport grows/shrinks
         self.vbox.set_redraw_on_allocate(False)
-
+        
         # framed section that contains all app details
         self.app_info = mkit.FramedSection()
         self.app_info.image.set_size_request(84, 84)
-        self.app_info.set_spacing(mkit.SPACING_LARGE)
+        self.app_info.set_spacing(mkit.SPACING_XLARGE)
         self.app_info.header.set_spacing(mkit.SPACING_XLARGE)
         self.app_info.header_alignment.set_padding(mkit.SPACING_SMALL,
                                                    mkit.SPACING_SMALL,
                                                    0, 0)
 
-        self.app_info.body.set_spacing(mkit.SPACING_LARGE)
+        self.app_info.body.set_spacing(mkit.SPACING_MED)
         self.vbox.pack_start(self.app_info, False)
 
         # a11y for name/summary
@@ -977,9 +1180,9 @@
         # controls which are displayed if the app is installed
         self.action_bar = PackageStatusBar(self)
         self.app_info.body.pack_start(self.action_bar, False)
-
+        
         # FramedSection which contains the app description
-        self.desc_section = mkit.FramedSection(xpadding=mkit.SPACING_LARGE)
+        self.desc_section = mkit.FramedSection(xpadding=mkit.SPACING_XLARGE)
         self.desc_section.header_alignment.set_padding(0,0,0,0)
 
         self.app_info.body.pack_start(self.desc_section, False)
@@ -998,7 +1201,7 @@
         # screenshot
         self.screenshot = ScreenshotView(self.distro, self.icons)
         app_desc_hb.pack_end(self.screenshot)
-
+        
         # homepage link button
         self.homepage_btn = mkit.HLinkButton(_('Website'))
         self.homepage_btn.connect('clicked', self._on_homepage_clicked)
@@ -1014,9 +1217,32 @@
         self.share_btn.connect('clicked', self._on_share_clicked)
         self.app_desc.footer.pack_start(self.share_btn, False)
 
-        # package info table
-        self.info_table = PackageInfoTable()
-        self.app_info.body.pack_start(self.info_table, False)
+        alignment = gtk.Alignment()
+        alignment.set_padding(mkit.SPACING_LARGE, 0, 0, 0)
+        self.desc_section.body.pack_start(alignment, False)
+        
+        # add-on handling
+        self.addon_view = AddonView(self.cache, self.db, self.icons)
+        self.addon_view.connect("toggled", self._on_addon_view_toggled)
+        self.addon_view.connect("description-clicked", self._on_addon_view_description_clicked)
+        alignment.add(self.addon_view)
+        
+        self.totalsize_info = PackageInfo(_("Total size:"))
+        self.app_info.body.pack_start(self.totalsize_info, False)
+        
+        self.addons_bar = AddonsStateBar(self.cache, self)
+        self.addons_bar.connect("changes-canceled", self._on_addonsbar_changescanceled)
+        self.app_info.body.pack_start(self.addons_bar, False)
+
+        # package info
+        self.version_info = PackageInfo(_("Version:"))
+        self.app_info.body.pack_start(self.version_info, False)
+
+        self.license_info = PackageInfo(_("License:"))
+        self.app_info.body.pack_start(self.license_info, False)
+
+        self.support_info = PackageInfo(_("Updates:"))
+        self.app_info.body.pack_start(self.support_info, False)
 
         self.show_all()
         return
@@ -1053,12 +1279,16 @@
 
         # if we have an error or if we need to enable a source, then hide everything else
         if app_details.pkg_state in (PKG_STATE_NOT_FOUND, PKG_STATE_NEEDS_SOURCE):
-            self.info_table.hide()
             self.screenshot.hide()
+            self.version_info.hide()
+            self.license_info.hide()
+            self.support_info.hide()
             self.desc_section.hide()
         else:
             self.desc_section.show()
-            self.info_table.show()
+            self.version_info.show()
+            self.license_info.show()
+            self.support_info.show()
             self.screenshot.show()
 
         # depending on pkg install state set action labels
@@ -1075,14 +1305,14 @@
             self.app_desc.body.a11y.set_name("Description: " + description)
 
         # show or hide the homepage button and set uri if homepage specified
-        if app_details.website and self.info_table.get_property('visible'):
+        if app_details.website:
             self.homepage_btn.show()
             self.homepage_btn.set_tooltip_text(app_details.website)
         else:
             self.homepage_btn.hide()
 
         # check if gwibber-poster is available, if so display Share... btn
-        if self._gwibber_is_available and self.info_table.get_property('visible'):
+        if self._gwibber_is_available:
             self.share_btn.show()
         else:
             self.share_btn.hide()
@@ -1107,7 +1337,21 @@
             support = app_details.maintenance_status
         else:
             support = _("Unknown")
-        self.info_table.configure(version, license, support)
+        
+        self.version_info.set_value(version)
+        self.license_info.set_value(license)
+        self.support_info.set_value(support)
+        
+        # Update add-on interface
+        self.addon_view.hide_all()
+        gobject.idle_add(self.addon_view.set_addons, self.app_details, self.recommended, self.suggested)
+        
+        # Update total size label
+        self.totalsize_info.hide_all()
+        gobject.idle_add(self.update_totalsize)
+        
+        # Update addons state bar
+        self.addons_bar.configure(self.app_details, self.addons_install, self.addons_remove)
         return
 
     # public API
@@ -1129,6 +1373,14 @@
         # init data
         self.app = app
         self.app_details = app.get_details(self.db)
+        self.recommended = self.addons_manager.recommended_addons(app.pkgname)
+        self.suggested = self.addons_manager.suggested_addons(app.pkgname)
+        LOG.debug("AppDetailsView.show_app recommended '%s'" % self.recommended)
+        LOG.debug("AppDetailsView.show_app suggested '%s'" % self.suggested)
+        
+        self.addons_install = []
+        self.addons_remove = []
+        
         # for compat with the base class
         self.appdetails = self.app_details
         #print "AppDetailsViewGtk:"
@@ -1150,7 +1402,31 @@
     def _update_interface_on_trans_ended(self, result):
         self.action_bar.button.set_sensitive(True)
         self.action_bar.button.show()
+        self.addons_bar.button_apply.set_sensitive(True)
+        self.addons_bar.button_cancel.set_sensitive(True)
+        state = self.action_bar.pkg_state
+        pkg_state = None
+        if state == PKG_STATE_INSTALLING or state == PKG_STATE_UPGRADING \
+        or self.addons_bar.applying:
+            self.addons_bar.show_all()
+            pkg_state = PKG_STATE_INSTALLED
+        else:
+            self.addons_bar.hide_all()
+            pkg_state = PKG_STATE_UNINSTALLED
 
+        if self.addons_bar.applying:
+            self.action_bar.configure(self.app_details, pkg_state)
+            self.addons_install = []
+            self.addons_remove = []
+            self.addons_bar.configure(self.app_details, self.addons_install, self.addons_remove)
+            self.addons_bar.applying = False
+            
+            for widget in self.addon_view:
+                if widget != self.addon_view.label:
+                    addon = widget.get_addon()
+                    widget.set_active(self.cache[addon].installed != None)
+            return False
+        
         state = self.action_bar.pkg_state
         # handle purchase: install purchased has multiple steps
         if (state == PKG_STATE_INSTALLING_PURCHASED and 
@@ -1164,14 +1440,24 @@
         # normal states
         elif state == PKG_STATE_REMOVING:
             self.action_bar.configure(self.app_details, PKG_STATE_UNINSTALLED)
+            self.addons_install = []
+            self.addons_remove = []
         elif state == PKG_STATE_INSTALLING:
             self.action_bar.configure(self.app_details, PKG_STATE_INSTALLED)
+            self.addons_install = []
+            self.addons_remove = []
+            self.addons_bar.configure(self.app_details, self.addons_install, self.addons_remove)
         elif state == PKG_STATE_UPGRADING:
             self.action_bar.configure(self.app_details, PKG_STATE_INSTALLED)
         return False
 
     def _on_transaction_started(self, backend):
         self.action_bar.button.hide()
+        
+        if self.addons_bar.get_applying():
+            self.action_bar.configure(self.app_details, APP_ACTION_APPLY)
+            return
+        
         state = self.action_bar.pkg_state
         LOG.debug("_on_transaction_stated %s" % state)
         if state == PKG_STATE_NEEDS_PURCHASE:
@@ -1205,6 +1491,8 @@
                 gobject.idle_add(self._show_prog_idle_cb)
             if pkgname in backend.pending_transactions:
                 self.action_bar.progress.set_fraction(progress/100.0)
+            if progress == 100:
+                self.action_bar.progress.set_fraction(1)
         return
 
     def _show_prog_idle_cb(self):
@@ -1293,18 +1581,143 @@
                     return self.icons.load_icon(MISSING_APP_ICON, 84, 0)
             elif app_details.icon_needs_download:
                 self._logger.debug("did not find the icon locally, must download it")
-
-                def on_image_download_complete(downloader, image_file_path):
-                    # when the download is complete, replace the icon in the view with the downloaded one
-                    pb = gtk.gdk.pixbuf_new_from_file(image_file_path)
-                    self.app_info.set_icon_from_pixbuf(pb)
-                    
-                icon_file_path = os.path.join(SOFTWARE_CENTER_ICON_CACHE_DIR, app_details.icon_file_name)
-                image_downloader = ImageDownloader()
-                image_downloader.connect('image-download-complete', on_image_download_complete)
-                image_downloader.download_image(app_details.icon_url, icon_file_path)
+            else:
+                return self.icons.load_icon(MISSING_APP_ICON, 84, 0)
+        else:
+            return self.icons.load_icon(MISSING_APP_ICON, 84, 0)
+
+    def _on_addon_view_description_clicked(self, button, pkgname):
+        self.emit("navigation-request", pkgname)
+        return
+
+    def _on_addon_view_toggled(self, view, addon, isActive):
+        if isActive:
+            self._set_addon_install(addon)
+        else:
+            self._set_addon_remove(addon)
+        if self.app_details.pkg_state == PKG_STATE_INSTALLED:
+            self.addons_bar.configure(self.app_details, self.addons_install, self.addons_remove)
+        gobject.idle_add(self.update_totalsize)
+        
+    def _on_addonsbar_changescanceled(self, widget):
+        self.addons_install = []
+        self.addons_remove = []
+        self.addon_view.set_addons(self.app_details, 
+                                    self.recommended,
+                                    self.suggested)
+        self.addons_bar.configure(self.app_details, self.addons_install, self.addons_remove)
+        gobject.idle_add(self.update_totalsize)
+    
+    def get_icon_filename(self, iconname, iconsize):
+        iconinfo = self.icons.lookup_icon(iconname, iconsize, 0)
+        if not iconinfo:
+            iconinfo = self.icons.lookup_icon(MISSING_APP_ICON, iconsize, 0)
+        return iconinfo.get_filename()
+                
+    def on_image_download_complete(downloader, image_file_path):
+        # when the download is complete, replace the icon in the view with the downloaded one
+        pb = gtk.gdk.pixbuf_new_from_file(image_file_path)
+        self.app_info.set_icon_from_pixbuf(pb)
+            
+        icon_file_path = os.path.join(SOFTWARE_CENTER_ICON_CACHE_DIR, app_details.icon_file_name)
+        image_downloader = ImageDownloader()
+        image_downloader.connect('image-download-complete', on_image_download_complete)
+        image_downloader.download_image(app_details.icon_url, icon_file_path)
                 
         return self.icons.load_icon(MISSING_APP_ICON, 84, 0)
+    
+    def update_totalsize(self):
+        def pkg_downloaded(pkg_version):
+            filename = os.path.basename(pkg_version.filename)
+            # FIXME: use relative path here
+            return os.path.exists("/var/cache/apt/archives/" + filename)
+        
+        while gtk.events_pending():
+            gtk.main_iteration()
+        
+        pkgs_to_install = []
+        pkgs_to_remove = []
+        total_download_size = 0 # in kB
+        total_install_size = 0 # in kB
+        label_string = ""
+        
+        try:
+            pkg = self.cache[self.app_details.pkgname]
+        except KeyError:
+            self.totalsize_info.hide_all()
+            return False
+        version = pkg.installed
+        if version == None:
+            version = max(pkg.versions)
+            pkgs_to_install.append(version)
+            deps_inst = self.cache.get_all_deps_installing(pkg)
+            for dep in deps_inst:
+                if self.cache[dep].installed == None:
+                    version = max(self.cache[dep].versions)
+                    pkgs_to_install.append(version)
+            deps_remove = self.cache.get_all_deps_removing(pkg)
+            for dep in deps_remove:
+                if self.cache[dep].installed != None:
+                    version = self.cache[dep].installed
+                    pkgs_to_remove.append(version)
+        
+        for addon in self.addons_install:
+            version = max(self.cache[addon].versions)
+            pkgs_to_install.append(version)
+            deps_inst = self.cache.get_all_deps_installing(self.cache[addon])
+            for dep in deps_inst:
+                if self.cache[dep].installed == None:
+                    version = max(self.cache[dep].versions)
+                    pkgs_to_install.append(version)
+            deps_remove = self.cache.get_all_deps_removing(self.cache[addon])
+            for dep in deps_remove:
+                if self.cache[dep].installed != None:
+                    version = self.cache[dep].installed
+                    pkgs_to_remove.append(version)
+        for addon in self.addons_remove:
+            version = self.cache[addon].installed
+            pkgs_to_remove.append(version)
+            deps_inst = self.cache.get_all_deps_installing(self.cache[addon])
+            for dep in deps_inst:
+                if self.cache[dep].installed == None:
+                    version = max(self.cache[dep].versions)
+                    pkgs_to_install.append(version)
+            deps_remove = self.cache.get_all_deps_removing(self.cache[addon])
+            for dep in deps_remove:
+                if self.cache[dep].installed != None:
+                    version = self.cache[dep].installed
+                    pkgs_to_remove.append(version)
+        
+        for pkg in pkgs_to_install:
+            if pkgs_to_install.count(pkg) > 1:
+                pkgs_to_install.remove(pkg)
+        for pkg in pkgs_to_remove:
+            if pkgs_to_remove.count(pkg) > 1:
+                pkgs_to_remove.remove(pkg)
+            
+        for pkg in pkgs_to_install:
+            if not pkg_downloaded(pkg):
+                total_download_size += pkg.size
+            total_install_size += pkg.installed_size
+        for pkg in pkgs_to_remove:
+            total_install_size -= pkg.installed_size
+        
+        if total_download_size > 0:
+            download_size = apt_pkg.size_to_str(total_download_size)
+            label_string += _("%sB to download, " % (download_size))
+        if total_install_size > 0:
+            install_size = apt_pkg.size_to_str(total_install_size)
+            label_string += _("%sB when installed" % (install_size))
+        elif total_install_size < 0:
+            remove_size = apt_pkg.size_to_str(-total_install_size)
+            label_string += _("%sB to be freed" % (remove_size))
+        
+        if label_string == "":
+            self.totalsize_info.hide_all()
+        else:
+            self.totalsize_info.set_value(label_string)
+            self.totalsize_info.show_all()
+        return False
 
 
 if __name__ == "__main__":

=== modified file 'test/test_appdetails_view.py'
--- test/test_appdetails_view.py	2010-08-11 19:43:05 +0000
+++ test/test_appdetails_view.py	2010-08-16 20:56:42 +0000
@@ -65,6 +65,27 @@
         for i in range(PKG_STATE_UNKNOWN):
             mock_app_details.pkg_state = i
             self.appdetails.show_app(app)
+    
+    def test_show_app_addons(self):
+        app = Application("Web browser", "firefox")
+        mock_app_details = mock.Mock(AppDetails)
+        mock_app_details.pkgname = "firefox"
+        mock_app_details.appname = "Web browser"
+        mock_app_details.display_name = "display_name"
+        mock_app_details.display_summary = "display_summary"
+        mock_app_details.error = None
+        mock_app_details.warning = None
+        mock_app_details.description = "description"
+        mock_app_details.website = "website"
+        mock_app_details.thumbnail = None
+        mock_app_details.license = "license"
+        mock_app_details.maintenance_status = "support_status"
+        mock_app_details.purchase_date = "purchase_date"
+        mock_app_details.installation_date = "installation_date"
+        mock_app_details.price = "price"
+        mock_app_details._error_not_found = ""
+        app.get_details = lambda db: mock_app_details
+        self.appdetails.show_app(app)
         
 
 if __name__ == "__main__":

=== modified file 'test/test_aptd.py'
--- test/test_aptd.py	2010-07-08 15:13:27 +0000
+++ test/test_aptd.py	2010-08-16 20:56:42 +0000
@@ -41,6 +41,14 @@
         keyserver = "keyserver.ubuntu.com"
         self.aptd.aptd_client.add_vendor_key_from_keyserver = self._monkey_patched_add_vendor_key_from_keyserver
         self.aptd.add_vendor_key_from_keyserver(keyid, keyserver)
+        
+    def test_apply_changes(self):
+        pkgname = "gimp"
+        appname = "The GIMP app"
+        iconname = "icon-gimp"
+        addons_install = ["gimp-data-extras", "gimp-gutenprint"]
+        addons_remove = ["gimp-plugin-registry"]
+        yield self.aptd.apply_changes(pkgname, appname ,iconname, addons_install, addons_remove)
 
 
 if __name__ == "__main__":

=== modified file 'test/test_gui.py'
--- test/test_gui.py	2010-08-10 09:10:35 +0000
+++ test/test_gui.py	2010-08-16 20:56:42 +0000
@@ -166,7 +166,9 @@
         self.app.show_available_packages(["i-dont-exit"])
         self._p()
         self.assertFalse(self.app.available_pane.app_details.screenshot.get_property("visible"))
-        self.assertFalse(self.app.available_pane.app_details.info_table.get_property("visible"))
+        self.assertFalse(self.app.available_pane.app_details.version_info.get_property("visible"))
+        self.assertFalse(self.app.available_pane.app_details.license_info.get_property("visible"))
+        self.assertFalse(self.app.available_pane.app_details.support_info.get_property("visible"))
         self.assertFalse(self.app.available_pane.app_details.desc_section.get_property("visible"))
 
     # helper stuff