Merge lp:~mvo/software-center/app-treeview-buy-plus-refactor into lp:software-center

[Michael Vogt]

This is based on the great work of Matthew McGowan, I just added a bit of extra tests and tweaking. All tests pass for me.

[Gary Lasker (gary-lasker)]

This all looks great. All tests pass for me as well, and I tried out the new capabilities myself in various views, etc., some corner cases like canceling purchases and such, and everything works as I expected. Very nice!

The only thing that I wonder is whether we might want to move the location of the price in the list view. It seems like we have consolidated the useful info about an app to the left-hand side, and to me it feels like the price should be there too. But, that's something we can think about (and check with mpt too) and it would be an easy thing to tweak later. So, I'll mark this one approved and I'll merge it now.

Thanks so much! Very nice work, Matt and mvo!

review: Approve

=== removed file 'softwarecenter/drawing.py'
--- softwarecenter/drawing.py	2011-08-09 08:47:43 +0000
+++ softwarecenter/drawing.py	1970-01-01 00:00:00 +0000
@@ -1,86 +0,0 @@
-import math
-
-from gtk.gdk import Color
-
-PI = math.pi
-PI_OVER_180 = PI/180
-
-
-def alpha_composite(fgcolor, bgcolor):
-    """ Creates a composite rgb of a foreground rgba and a background rgb.
-
-         - fgcolor: an rgba of floats
-         - bgcolor: an rgb of floats
-    """
-
-    src_r, src_g, src_b, src_a = fgcolor
-    bg_r, bg_g, bg_b = bgcolor
-
-    # Source: http://en.wikipedia.org/wiki/Alpha_compositing
-    r = ((1 - src_a) * bg_r) + (src_a * src_r)
-    g = ((1 - src_a) * bg_g) + (src_a * src_g)
-    b = ((1 - src_a) * bg_b) + (src_a * src_b)
-    return r, g, b
-
-def color_floats(color):
-    if isinstance(color, Color):
-        c = color
-    elif isinstance(color, str):
-        c = Color(color)
-    elif isinstance(color, (list, tuple)) and len(color) >= 3:
-        # assume that a list or tuple of floats has been set as arg, do nothing
-        if isinstance(color[0], float):
-            return color
-        if isinstance(color, int):
-            r,g,b = color
-            c = Color(red=r, green=g, blue=b)
-    else:
-        raise TypeError('Expected gtk.gdk.Color, hash or list of integers.  Received: %s' % color)
-    return c.red_float, c.green_float, c.blue_float
-
-def rounded_rect(cr, x, y, w, h, r):
-    cr.new_sub_path()
-    cr.arc(r+x, r+y, r, PI, 270*PI_OVER_180)
-    cr.arc(x+w-r, r+y, r, 270*PI_OVER_180, 0)
-    cr.arc(x+w-r, y+h-r, r, 0, 90*PI_OVER_180)
-    cr.arc(r+x, y+h-r, r, 90*PI_OVER_180, PI)
-    cr.close_path()
-    return
-
-def rounded_rect2(cr, x, y, w, h, radii):
-    nw, ne, se, sw = radii
-
-    cr.save()
-    cr.translate(x, y)
-    if nw:
-        cr.new_sub_path()
-        cr.arc(nw, nw, nw, PI, 270 * PI_OVER_180)
-    else:
-        cr.move_to(0, 0)
-    if ne:
-        cr.arc(w-ne, ne, ne, 270 * PI_OVER_180, 0)
-    else:
-        cr.rel_line_to(w-nw, 0)
-    if se:
-        cr.arc(w-se, h-se, se, 0, 90 * PI_OVER_180)
-    else:
-        cr.rel_line_to(0, h-ne)
-    if sw:
-        cr.arc(sw, h-sw, sw, 90 * PI_OVER_180, PI)
-    else:
-        cr.rel_line_to(-(w-se), 0)
-
-    cr.close_path()
-    cr.restore()
-    return
-
-def circle(cr, x, y, w, h):
-    cr.new_path()
-
-    r = min(w, h)*0.5
-    x += int((w-2*r)/2)
-    y += int((h-2*r)/2)
-
-    cr.arc(r+x, r+y, r, 0, 360*PI_OVER_180)
-    cr.close_path()
-    return

=== modified file 'softwarecenter/enums.py'
--- softwarecenter/enums.py	2011-10-20 16:08:23 +0000
+++ softwarecenter/enums.py	2011-11-09 10:56:38 +0000
@@ -181,6 +181,7 @@
     REMOVE = "remove"
     UPGRADE = "upgrade"
     APPLY = "apply_changes"
+    PURCHASE = "purchase"
 
 # transaction types
 class TransactionTypes:

=== modified file 'softwarecenter/testutils.py'
--- softwarecenter/testutils.py	2011-10-07 10:44:12 +0000
+++ softwarecenter/testutils.py	2011-11-09 10:56:38 +0000
@@ -77,6 +77,11 @@
     db.open()
     return db
 
+def get_test_install_backend():
+    from softwarecenter.backend.installbackend import get_install_backend
+    backend = get_install_backend()
+    return backend
+
 def get_test_gtk3_icon_cache():
     from softwarecenter.ui.gtk3.utils import get_sc_icon_theme
     import softwarecenter.paths
@@ -104,3 +109,9 @@
                        limit=limit,
                        nonblocking_load=False)
     return enquirer.matches
+
+def do_events():
+    from gi.repository import GObject
+    main_loop = GObject.main_context_default()
+    while main_loop.pending():
+        main_loop.iteration()

=== modified file 'softwarecenter/ui/gtk3/app.py'
--- softwarecenter/ui/gtk3/app.py	2011-11-04 16:35:55 +0000
+++ softwarecenter/ui/gtk3/app.py	2011-11-09 10:56:38 +0000
@@ -66,7 +66,6 @@
                                           init_sc_css_provider)
 from softwarecenter.version import VERSION
 from softwarecenter.db.database import StoreDatabase
-from softwarecenter.backend.transactionswatcher import TransactionFinishedResult
 try:
     from aptd_gtk3 import InstallBackendUI
     InstallBackendUI # pyflakes
@@ -74,7 +73,6 @@
     from softwarecenter.backend.installbackend import InstallBackendUI
 
 # ui imports
-import softwarecenter.ui.gtk3.dialogs.dependency_dialogs as dependency_dialogs
 import softwarecenter.ui.gtk3.dialogs.deauthorize_dialog as deauthorize_dialog
 import softwarecenter.ui.gtk3.dialogs as dialogs
 
@@ -84,7 +82,9 @@
 from softwarecenter.ui.gtk3.panes.historypane import HistoryPane
 from softwarecenter.ui.gtk3.panes.globalpane import GlobalPane
 from softwarecenter.ui.gtk3.panes.pendingpane import PendingPane
-from softwarecenter.ui.gtk3.session.viewmanager import ViewManager, get_viewmanager
+from softwarecenter.ui.gtk3.session.appmanager import ApplicationManager
+from softwarecenter.ui.gtk3.session.viewmanager import (
+    ViewManager, get_viewmanager)
 
 from softwarecenter.config import get_config
 from softwarecenter.backend import get_install_backend
@@ -240,12 +240,18 @@
             # FIXME: force rebuild by providing a dbus service for this
             sys.exit(1)
 
+        # additional icons come from app-install-data
+        self.icons = get_sc_icon_theme(self.datadir)
+
         # backend
         self.backend = get_install_backend()
         self.backend.ui = InstallBackendUI()
         self.backend.connect("transaction-finished", self._on_transaction_finished)
         self.backend.connect("channels-changed", self.on_channels_changed)
 
+        # high level app management
+        self.app_manager = ApplicationManager(self.db, self.backend, self.icons)
+
         # misc state
         self._block_menuitem_view = False
         
@@ -254,8 +260,6 @@
         self.sso = None
         self.available_for_me_query = None
 
-        # additional icons come from app-install-data
-        self.icons = get_sc_icon_theme(self.datadir)
         Gtk.Window.set_default_icon_name("softwarecenter")
 
         # inhibit the error-bell, Bug #846138...
@@ -294,7 +298,7 @@
                                             self.distro,
                                             self.icons,
                                             self.datadir)
-        self.installed_pane.connect("installed-pane-created", self.on_installed_pane_created)
+        #~ self.installed_pane.connect("installed-pane-created", self.on_installed_pane_created)
         self.view_manager.register(self.installed_pane, ViewPages.INSTALLED)
 
         # history pane (not fully loaded at this point)
@@ -420,39 +424,10 @@
         return
 
     def on_available_pane_created(self, widget):
-        # connect signals
-        self.available_pane.app_details_view.connect("application-request-action", 
-                                                     self.on_application_request_action)
-        self.available_pane.app_view.connect("application-request-action", 
-                                             self.on_application_request_action)
-        # FIXME
-        #~ self.available_pane.app_view.connect("mouse-nav-requested", 
-                                             #~ self.on_window_main_button_press_event)
         self.available_pane.searchentry.grab_focus()
     
-    def on_channel_pane_created(self, widget):
-        #~ channel_section = SoftwareSection()
-        # note that the view_id for each channel's section is set later
-        # depending on whether the channel view will display available or
-        # installed items
-        #~ self.channel_pane.set_section(channel_section)
-
-        # connect signals
-        self.channel_pane.app_details_view.connect("application-request-action", 
-                                                   self.on_application_request_action)
-        self.channel_pane.app_view.connect("application-request-action", 
-                                           self.on_application_request_action)
-                                           
-    def on_installed_pane_created(self, widget):
-        #~ installed_section = SoftwareSection()
-        #~ installed_section.set_view_id(ViewPages.INSTALLED)
-        #~ self.installed_pane.set_section(installed_section)
-        
-        # connect signals
-        self.installed_pane.app_details_view.connect("application-request-action", 
-                                                     self.on_application_request_action)
-        self.installed_pane.app_view.connect("application-request-action", 
-                                             self.on_application_request_action)
+    #~ def on_installed_pane_created(self, widget):
+        #~ pass
     
     def _on_update_software_center_agent_finished(self, pid, condition):
         LOG.info("software-center-agent finished with status %i" % os.WEXITSTATUS(condition))
@@ -592,54 +567,7 @@
         self.available_for_me_query = add_from_purchased_but_needs_reinstall_data(
             result_list, self.db, self.cache)
         self.available_pane.on_previous_purchases_activated(self.available_for_me_query) 
-        
-    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
-        """
-        LOG.debug("on_application_action_requested: '%s' %s" % (app, action))
-        appdetails = app.get_details(self.db)
-        if action == "remove":
-            if not dependency_dialogs.confirm_remove(None, self.datadir, app,
-                                                     self.db, self.icons):
-                    # craft an instance of TransactionFinishedResult to send with the
-                    # transaction-stopped signal
-                    result = TransactionFinishedResult(None, False)
-                    result.pkgname = app.pkgname
-                    self.backend.emit("transaction-stopped", result)
-                    return
-        elif action == "install":
-            # If we are installing a package, check for dependencies that will 
-            # also be removed and show a dialog for confirmation
-            # generic removal text (fixing LP bug #554319)
-            if not dependency_dialogs.confirm_install(None, self.datadir, app, 
-                                                      self.db, self.icons):
-                    # craft an instance of TransactionFinishedResult to send with the
-                    # transaction-stopped signal
-                    result = TransactionFinishedResult(None, False)
-                    result.pkgname = app.pkgname
-                    self.backend.emit("transaction-stopped", result)
-                    return
 
-        # this allows us to 'upgrade' deb files
-        if action == 'upgrade' and app.request and type(app) == DebFileApplication:
-            action = 'install'
- 
-        # action_func is one of:  "install", "remove", "upgrade", "apply_changes"
-        action_func = getattr(self.backend, action)
-        if action == 'install':
-            # the package.deb path name is in the request
-            if app.request and type(app) == DebFileApplication:
-                debfile_name = app.request
-            else:
-                debfile_name = None
-            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, addons_install=addons_install, addons_remove=addons_remove)
-        else:
-            LOG.error("Not a valid action in AptdaemonBackend: '%s'" % action)
-            
     def get_icon_filename(self, iconname, iconsize):
         iconinfo = self.icons.lookup_icon(iconname, iconsize, 0)
         if not iconinfo:

=== modified file 'softwarecenter/ui/gtk3/models/appstore2.py'
--- softwarecenter/ui/gtk3/models/appstore2.py	2011-11-01 22:44:33 +0000
+++ softwarecenter/ui/gtk3/models/appstore2.py	2011-11-09 10:56:38 +0000
@@ -44,6 +44,7 @@
 
 
 LOG = logging.getLogger(__name__)
+_FREE_AS_IN_BEER = ("0.00", "")
 
 class CategoryRowReference:
     """ A simple container for Category properties to be 
@@ -100,23 +101,29 @@
     def update_availability(self, doc):
         doc.available = None
         doc.installed = None
+        doc.purchasable = None
         self.is_installed(doc)
         return
 
     def is_available(self, doc):
         if doc.available is None:
             pkgname = self.get_pkgname(doc)
-            doc.available = pkgname in self.cache
+            doc.available = (pkgname in self.cache or
+                             self.is_purchasable(doc))
         return doc.available
 
     def is_installed(self, doc):
         if doc.installed is None:
             pkgname = self.get_pkgname(doc)
-            if doc.available is None:
-                doc.available = pkgname in self.cache
-            doc.installed = doc.available and self.cache[pkgname].is_installed
+            doc.installed = (self.is_available(doc) and
+                             self.cache[pkgname].is_installed)
         return doc.installed
 
+    def is_purchasable(self, doc):
+        if doc.purchasable is None:
+            doc.purchasable = doc.get_value(XapianValues.PRICE) not in _FREE_AS_IN_BEER
+        return doc.purchasable
+
     def get_pkgname(self, doc):
         return self.db.get_pkgname(doc)
 
@@ -151,6 +158,9 @@
                  GObject.markup_escape_text(appname),
                  GObject.markup_escape_text(summary))
 
+    def get_price(self, doc):
+        return doc.get_value(XapianValues.PRICE)
+
     def get_icon(self, doc):
         try:
             icon_file_name = split_icon_ext(self.db.get_iconname(doc))
@@ -411,7 +421,7 @@
 
         with ExecutionTime("store.append_initial"):
             for doc in [m.document for m in matches][:extent]:
-                doc.available = doc.installed = None
+                doc.available = doc.installed = doc.purchasable = None
                 self.append((doc,))
 
         if n_matches == extent: 
@@ -445,7 +455,7 @@
 
             if row_content: continue
             doc = db.get_document(matches[i].docid)
-            doc.available = doc.installed = None
+            doc.available = doc.installed = doc.purchasable = None
             self[(i,)][0] = doc
         return
 
@@ -471,7 +481,7 @@
 
     def set_documents(self, parent, documents):
         for doc in documents:
-            doc.available = None; doc.installed = None
+            doc.available = None; doc.installed = doc.purchasable = None
             self.append(parent, (doc,))
 
         self.transaction_path_map = {}

=== modified file 'softwarecenter/ui/gtk3/panes/availablepane.py'
--- softwarecenter/ui/gtk3/panes/availablepane.py	2011-10-16 16:21:39 +0000
+++ softwarecenter/ui/gtk3/panes/availablepane.py	2011-11-09 10:56:38 +0000
@@ -41,6 +41,7 @@
                                                       SubCategoryViewGtk)
 from softwarepane import SoftwarePane
 from softwarecenter.ui.gtk3.session.viewmanager import get_viewmanager
+from softwarecenter.ui.gtk3.session.appmanager import get_appmanager
 
 LOG = logging.getLogger(__name__)
 
@@ -114,11 +115,10 @@
             #~ self.app_view._append_appcount(appcount)
         #~ liststore.connect('appcount-changed', on_appcount_changed)
         self.app_view.set_model(liststore)
-        # setup purchase stuff
-        self.app_details_view.connect("purchase-requested",
-                                      self.on_purchase_requested)
         # purchase view
         self.purchase_view = PurchaseView()
+        app_manager = get_appmanager()
+        app_manager.connect("purchase-requested", self.on_purchase_requested)
         self.purchase_view.connect("purchase-succeeded", self.on_purchase_succeeded)
         self.purchase_view.connect("purchase-failed", self.on_purchase_failed)
         self.purchase_view.connect("purchase-cancelled-by-user", self.on_purchase_cancelled_by_user)
@@ -198,14 +198,14 @@
         if window is not None:
             window.set_cursor(None)
 
-    def on_purchase_requested(self, widget, app, url):
-
-        self.appdetails = app.get_details(self.db)
-        iconname = self.appdetails.icon
+    def on_purchase_requested(self, appmanager, app, iconname, url):
         self.purchase_view.initiate_purchase(app, iconname, url)
         vm = get_viewmanager()
-        vm.display_page(self, AvailablePane.Pages.PURCHASE, self.state, self.display_purchase)
-        
+        vm.display_page(
+            self, AvailablePane.Pages.PURCHASE, self.state,
+            self.display_purchase)
+        return
+
     def on_purchase_succeeded(self, widget):
         # switch to the details page to display the transaction is in progress
         self._return_to_appdetails_view()
@@ -604,7 +604,7 @@
 
     def on_show_category_applist(self, widget):
         self._show_hide_subcategories(show_category_applist=True)
-        
+
     def on_previous_purchases_activated(self, query):
         """ called to activate the previous purchases view """
         #print cat_view, name, query
@@ -667,6 +667,7 @@
 def get_test_window():
     from softwarecenter.testutils import (get_test_db,
                                           get_test_datadir,
+                                          get_test_install_backend,
                                           get_test_gtk3_viewmanager,
                                           get_test_pkg_info,
                                           get_test_gtk3_icon_cache,
@@ -678,6 +679,11 @@
     cache = get_test_pkg_info()
     datadir = get_test_datadir()
     icons = get_test_gtk3_icon_cache()
+    backend = get_test_install_backend()
+
+    # create global AppManager instance
+    from softwarecenter.ui.gtk3.session.appmanager import ApplicationManager
+    ApplicationManager(db, backend, icons)
 
     navhistory_back_action = Gtk.Action("navhistory_back_action", "Back", "Back", None)
     navhistory_forward_action = Gtk.Action("navhistory_forward_action", "Forward", "Forward", None)

=== added file 'softwarecenter/ui/gtk3/session/appmanager.py'
--- softwarecenter/ui/gtk3/session/appmanager.py	1970-01-01 00:00:00 +0000
+++ softwarecenter/ui/gtk3/session/appmanager.py	2011-11-09 10:56:38 +0000
@@ -0,0 +1,180 @@
+# Copyright (C) 2011 Canonical
+#
+# Authors:
+#  Matthew McGowan
+#
+# 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; version 3.
+#
+# 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.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+try:
+    from urllib.parse import urlencode
+    urlencode  # pyflakes
+except ImportError:
+    from urllib import urlencode
+
+from gi.repository import GObject
+
+from softwarecenter.enums import AppActions
+from softwarecenter.db import DebFileApplication
+from softwarecenter.distro import get_current_arch, get_distro
+from softwarecenter.i18n import get_language
+from softwarecenter.ui.gtk3.dialogs import dependency_dialogs
+from softwarecenter.backend.transactionswatcher import TransactionFinishedResult
+import softwarecenter.paths
+
+_appmanager = None  # the global AppManager instance
+def get_appmanager():
+    """ get a existing appmanager instance (or None if none is created yet) """
+    return _appmanager
+
+
+class ApplicationManager(GObject.GObject):
+
+    __gsignals__ = {
+         "purchase-requested" : (GObject.SignalFlags.RUN_LAST,
+                                 None,
+                                 (GObject.TYPE_PYOBJECT, str, str,)
+                                ),
+    }
+
+    def __init__(self, db, backend, icons):
+        GObject.GObject.__init__(self)
+        self._globalise_instance()
+        self.db = db
+        self.backend = backend
+        self.distro = get_distro()
+        self.datadir = softwarecenter.paths.datadir
+        self.icons = icons
+
+    def _globalise_instance(self):
+        global _appmanager
+        if _appmanager is not None:
+            msg = "Only one instance of ApplicationManager is allowed!"
+            raise ValueError(msg)
+        else:
+            _appmanager = self
+
+    def request_action(self, 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
+        """
+        #~ LOG.debug("on_application_action_requested: '%s' %s" % (app, action))
+        appdetails = app.get_details(self.db)
+        if action == AppActions.REMOVE:
+            if not dependency_dialogs.confirm_remove(
+                        None, self.datadir, app, self.db, self.icons):
+                    # craft an instance of TransactionFinishedResult to send with the
+                    # transaction-stopped signal
+                    result = TransactionFinishedResult(None, False)
+                    result.pkgname = app.pkgname
+                    self.backend.emit("transaction-stopped", result)
+                    return
+        elif action == AppActions.INSTALL:
+            # If we are installing a package, check for dependencies that will 
+            # also be removed and show a dialog for confirmation
+            # generic removal text (fixing LP bug #554319)
+            if not dependency_dialogs.confirm_install(
+                        None, self.datadir, app, self.db, self.icons):
+                    # craft an instance of TransactionFinishedResult to send with the
+                    # transaction-stopped signal
+                    result = TransactionFinishedResult(None, False)
+                    result.pkgname = app.pkgname
+                    self.backend.emit("transaction-stopped", result)
+                    return
+
+        # this allows us to 'upgrade' deb files
+        if (action == AppActions.UPGRADE and app.request and
+            isinstance(app, DebFileApplication)):
+            action = AppActions.INSTALL
+ 
+        # action_func is one of:  "install", "remove", "upgrade", "apply_changes"
+        action_func = getattr(self.backend, action)
+        if action == AppActions.INSTALL:
+            # the package.deb path name is in the request
+            if app.request and isinstance(app, DebFileApplication):
+                debfile_name = app.request
+            else:
+                debfile_name = None
+
+            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,
+                        addons_install=addons_install,
+                        addons_remove=addons_remove)
+        #~ else:
+            #~ LOG.error("Not a valid action in AptdaemonBackend: '%s'" % action)
+
+    # public interface
+    def reload(self):
+        """ reload the package cache, this goes straight to the backend """
+        self.backend.reload()
+
+    def install(self, app, addons_to_install, addons_to_remove):
+        """ install the current application, fire an action request """
+        self.request_action(
+            app, addons_to_install, addons_to_remove, AppActions.INSTALL)
+
+    def remove(self, app, addons_to_install, addons_to_remove):
+        """ remove the current application, , fire an action request """
+        self.request_action(
+            app, addons_to_install, addons_to_remove, AppActions.REMOVE)
+
+    def upgrade(self, app, addons_to_install, addons_to_remove):
+        """ upgrade the current application, fire an action request """
+        self.request_action(
+            app, addons_to_install, addons_to_remove, AppActions.UPGRADE)
+
+    def apply_changes(self, app, addons_to_install, addons_to_remove):
+        """ apply changes concerning add-ons """
+        self.request_action(
+            app, addons_to_install, addons_to_remove, AppActions.APPLY)
+
+    def buy_app(self, app):
+        """ initiate the purchase transaction """
+        lang = get_language()
+        appdetails = app.get_details(self.db)
+        url = self.distro.PURCHASE_APP_URL % (
+            lang, self.distro.get_codename(), urlencode(
+                {'archive_id' : appdetails.ppaname, 
+                'arch' : get_current_arch(),}
+            )
+        )
+        self.emit("purchase-requested", app, appdetails.icon, url)
+
+    def reinstall_purchased(self, app):
+        """ reinstall a purchased app """
+        #~ LOG.debug("reinstall_purchased %s" % self.app)
+        appdetails = app.get_details(self.db)
+        iconname = appdetails.icon
+        deb_line = appdetails.deb_line
+        license_key = appdetails.license_key
+        license_key_path = appdetails.license_key_path
+        signing_key_id = appdetails.signing_key_id
+        self.backend.add_repo_add_key_and_install_app(deb_line,
+                                                      signing_key_id,
+                                                      app,
+                                                      iconname,
+                                                      license_key,
+                                                      license_key_path)
+
+    def enable_software_source(self, app):
+        """ enable the software source for the given app """
+        appdetails = app.get_details(self.db)
+        if appdetails.channelfile and appdetails._unavailable_channel():
+            self.backend.enable_channel(appdetails.channelfile)
+        elif appdetails.component:
+            components = appdetails.component.split('&')
+            for component in components:
+                self.backend.enable_component(component)

=== modified file 'softwarecenter/ui/gtk3/session/viewmanager.py'
--- softwarecenter/ui/gtk3/session/viewmanager.py	2011-09-27 04:06:46 +0000
+++ softwarecenter/ui/gtk3/session/viewmanager.py	2011-11-09 10:56:38 +0000
@@ -58,7 +58,7 @@
         global _viewmanager
         if _viewmanager is not None:
             msg = "Only one instance of ViewManager is allowed!"
-            raise SystemExit(msg)
+            raise ValueError(msg)
         else:
             _viewmanager = self
 

=== modified file 'softwarecenter/ui/gtk3/views/appdetailsview.py'
--- softwarecenter/ui/gtk3/views/appdetailsview.py	2011-10-13 13:29:14 +0000
+++ softwarecenter/ui/gtk3/views/appdetailsview.py	2011-11-09 10:56:38 +0000
@@ -16,48 +16,26 @@
 # this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
-from gi.repository import GObject
-
 import logging
 import softwarecenter.ui.gtk3.dialogs as dialogs
 
-try:
-    from urllib.parse import urlencode
-    urlencode # pyflakes
-except ImportError:
-    from urllib import urlencode
-
 from gettext import gettext as _
 
 from softwarecenter.db.application import AppDetails
 from softwarecenter.backend.reviews import get_review_loader
 from softwarecenter.backend import get_install_backend
-from softwarecenter.enums import AppActions
-from softwarecenter.distro import get_current_arch
-from softwarecenter.i18n import get_language
+
 
 LOG=logging.getLogger(__name__)
 
 class AppDetailsViewBase(object):
 
-    __gsignals__ = {
-        "application-request-action" : (GObject.SignalFlags.RUN_LAST,
-                                        None,
-                                        (GObject.TYPE_PYOBJECT, 
-                                         GObject.TYPE_PYOBJECT, 
-                                         GObject.TYPE_PYOBJECT, 
-                                         str,)),
-         "purchase-requested" : (GObject.SignalFlags.RUN_LAST,
-                                 None,
-                                 (GObject.TYPE_PYOBJECT,
-                                  str,)),
-    }
-
     def __init__(self, db, distro, icons, cache, datadir):
         self.db = db
         self.distro = distro
         self.icons = icons
         self.cache = cache
+        self.backend = get_install_backend()
         self.cache.connect("cache-ready", self._on_cache_ready)
         self.datadir = datadir
         self.app = None
@@ -67,13 +45,13 @@
         # reviews
         self.review_loader = get_review_loader(self.cache, self.db)
         # aptdaemon
-        self.backend = get_install_backend()
-        
+
     def _draw(self):
         """ draw the current app into the window, maybe the function
             you need to overwrite
         """
         pass
+
     # public API
     def show_app(self, app):
         """ show the given application """
@@ -86,6 +64,7 @@
         self._draw()
         self._check_for_reviews()
         self.emit("selected", self.app)
+
     def refresh_app(self):
         self.show_app(self.app)
 
@@ -150,52 +129,6 @@
         self.review_loader.spawn_delete_review_ui(
             review_id, parent_xid, self.datadir, self._reviews_ready_callback)
 
-    # public interface
-    def reload(self):
-        """ reload the package cache, this goes straight to the backend """
-        self.backend.reload()
-    def install(self):
-        """ install the current application, fire an action request """
-        self.emit("application-request-action", self.app, self.addons_to_install, self.addons_to_remove, AppActions.INSTALL)
-    def remove(self):
-        """ remove the current application, , fire an action request """
-        self.emit("application-request-action", self.app, self.addons_to_install, self.addons_to_remove, AppActions.REMOVE)
-    def upgrade(self):
-        """ upgrade the current application, fire an action request """
-        self.emit("application-request-action", self.app, self.addons_to_install, self.addons_to_remove, AppActions.UPGRADE)
-    def apply_changes(self):
-        """ apply changes concerning add-ons """
-        self.emit("application-request-action", self.app, self.addons_to_install, self.addons_to_remove, AppActions.APPLY)
-
-    def buy_app(self):
-        """ initiate the purchase transaction """
-        lang = get_language()
-        distro = self.distro.get_codename()
-        url = self.distro.PURCHASE_APP_URL % (lang, distro, urlencode({
-                    'archive_id' : self.appdetails.ppaname, 
-                    'arch' : get_current_arch() ,
-                    }))
-        
-        self.emit("purchase-requested", self.app, url)
-
-    def reinstall_purchased(self):
-        """ reinstall a purchased app """
-        LOG.debug("reinstall_purchased %s" % self.app)
-        appdetails = self.app.get_details(self.db)
-        iconname = appdetails.icon
-        deb_line = appdetails.deb_line
-        license_key = appdetails.license_key
-        license_key_path = appdetails.license_key_path
-        signing_key_id = appdetails.signing_key_id
-        backend = get_install_backend()
-        backend.add_repo_add_key_and_install_app(deb_line,
-                                                 signing_key_id,
-                                                 self.app,
-                                                 iconname,
-                                                 license_key,
-                                                 license_key_path)
-        
-
     # internal callbacks
     def _on_cache_ready(self, cache):
         # re-show the application if the cache changes, it may affect the

=== modified file 'softwarecenter/ui/gtk3/views/appdetailsview_gtk.py'
--- softwarecenter/ui/gtk3/views/appdetailsview_gtk.py	2011-11-04 14:19:54 +0000
+++ softwarecenter/ui/gtk3/views/appdetailsview_gtk.py	2011-11-09 10:56:38 +0000
@@ -53,6 +53,7 @@
 
 from softwarecenter.ui.gtk3.em import StockEms, em
 from softwarecenter.ui.gtk3.drawing import color_to_hex
+from softwarecenter.ui.gtk3.session.appmanager import get_appmanager
 from softwarecenter.ui.gtk3.widgets.separators import HBar
 from softwarecenter.ui.gtk3.widgets.viewport import Viewport
 from softwarecenter.ui.gtk3.widgets.reviews import UIReviewsList
@@ -150,23 +151,28 @@
     def _on_button_clicked(self, button):
         button.set_sensitive(False)
         state = self.pkg_state
-        self.view.addons_to_install = self.view.addons_manager.addons_to_install
-        self.view.addons_to_remove = self.view.addons_manager.addons_to_remove
+        app = self.view.app
+        app_manager = get_appmanager()
+        addons_to_install = self.view.addons_manager.addons_to_install
+        addons_to_remove = self.view.addons_manager.addons_to_remove
         if state == PkgStates.INSTALLED:
-            AppDetailsViewBase.remove(self.view)
+            app_manager.remove(
+                app, addons_to_install, addons_to_remove)
         elif state == PkgStates.PURCHASED_BUT_REPO_MUST_BE_ENABLED:
-            AppDetailsViewBase.reinstall_purchased(self.view)
+            app_manager.reinstall_purchased(app)
         elif state == PkgStates.NEEDS_PURCHASE:
-            AppDetailsViewBase.buy_app(self.view)
+            app_manager.buy_app(app)
         elif state == PkgStates.UNINSTALLED:
-            AppDetailsViewBase.install(self.view)
+            app_manager.install(
+                app, addons_to_install, addons_to_remove)
         elif state == PkgStates.REINSTALLABLE:
-            AppDetailsViewBase.install(self.view)
+            app_manager.install(
+                app, addons_to_install, addons_to_remove)
         elif state == PkgStates.UPGRADABLE:
-            AppDetailsViewBase.upgrade(self.view)
+            app_manager.upgrade(
+                app, addons_to_install, addons_to_remove)
         elif state == PkgStates.NEEDS_SOURCE:
-            # FIXME:  This should be in AppDetailsViewBase
-            self.view.use_this_source()
+            app_manager.enable_software_source(app)
         return
 
     def set_label(self, label):
@@ -639,14 +645,6 @@
                     "application-selected" : (GObject.SignalFlags.RUN_LAST,
                                    None,
                                    (GObject.TYPE_PYOBJECT, )),
-                    'application-request-action' : (GObject.SignalFlags.RUN_LAST,
-                                        None,
-                                        (GObject.TYPE_PYOBJECT, GObject.TYPE_PYOBJECT, GObject.TYPE_PYOBJECT, str),
-                                       ),
-                    'purchase-requested' : (GObject.SignalFlags.RUN_LAST,
-                                            None,
-                                            (GObject.TYPE_PYOBJECT,
-                                             str,)),
                     }
 
 
@@ -1431,15 +1429,6 @@
         self.emit("selected", self.app)
         return
 
-    # public interface
-    def use_this_source(self):
-        if self.app_details.channelfile and self.app_details._unavailable_channel():
-            self.backend.enable_channel(self.app_details.channelfile)
-        elif self.app_details.component:
-            components = self.app_details.component.split('&')
-            for component in components:
-                self.backend.enable_component(component)
-
     # internal callback
     def _update_interface_on_trans_ended(self, result):
         state = self.pkg_statusbar.pkg_state

=== modified file 'softwarecenter/ui/gtk3/views/appview.py'
--- softwarecenter/ui/gtk3/views/appview.py	2011-10-11 12:39:31 +0000
+++ softwarecenter/ui/gtk3/views/appview.py	2011-11-09 10:56:38 +0000
@@ -36,9 +36,9 @@
 
     __gsignals__ = {
         "sort-method-changed": (GObject.SignalFlags.RUN_LAST,
-                                   None,
-                                   (GObject.TYPE_PYOBJECT, ),
-                                  ),
+                                None,
+                                (GObject.TYPE_PYOBJECT, ),
+                                ),
         "application-activated" : (GObject.SignalFlags.RUN_LAST,
                                    None,
                                    (GObject.TYPE_PYOBJECT, ),
@@ -47,14 +47,7 @@
                                    None,
                                    (GObject.TYPE_PYOBJECT, ),
                                   ),
-        "application-request-action" : (GObject.SignalFlags.RUN_LAST,
-                                        None,
-                                        (GObject.TYPE_PYOBJECT,
-                                         GObject.TYPE_PYOBJECT, 
-                                         GObject.TYPE_PYOBJECT,
-                                         str),
-                                       ),
-    }
+        }
     
     (INSTALLED_MODE, AVAILABLE_MODE, DIFF_MODE) = range(3)
 
@@ -71,7 +64,7 @@
 
     def __init__(self, db, cache, icons, show_ratings):
         Gtk.VBox.__init__(self)
-        self.set_name("app-view")
+        #~ self.set_name("app-view")
         # app properties helper
         self.helper = AppPropertiesHelper(db, cache, icons)
         # misc internal containers
@@ -94,7 +87,7 @@
         self.header_hbox.pack_end(combo_alignment, False, False, 0)
 
         # content views
-        self.tree_view = AppTreeView(self, icons,
+        self.tree_view = AppTreeView(self, db, icons,
                                      show_ratings, store=None)
         self.tree_view_scroll.add(self.tree_view)
 

=== modified file 'softwarecenter/ui/gtk3/views/purchaseview.py'
--- softwarecenter/ui/gtk3/views/purchaseview.py	2011-10-13 13:29:14 +0000
+++ softwarecenter/ui/gtk3/views/purchaseview.py	2011-11-09 10:56:38 +0000
@@ -52,6 +52,7 @@
         #    print name, value
         #headers.foreach(_show_header, None)
 
+
 class ScrolledWebkitWindow(Gtk.ScrolledWindow):
 
     def __init__(self):
@@ -64,6 +65,7 @@
         self.add(self.webkit)
         self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
 
+
 class PurchaseView(Gtk.VBox):
     """ 
     View that displays the webkit-based UI for purchasing an item. 

=== modified file 'softwarecenter/ui/gtk3/widgets/apptreeview.py'
--- softwarecenter/ui/gtk3/widgets/apptreeview.py	2011-10-07 12:27:48 +0000
+++ softwarecenter/ui/gtk3/widgets/apptreeview.py	2011-11-09 10:56:38 +0000
@@ -5,6 +5,9 @@
 
 from gettext import gettext as _
 
+from softwarecenter.ui.gtk3.session.appmanager import get_appmanager
+
+
 from cellrenderers import (CellRendererAppView,
                            CellButtonRenderer,
                            CellButtonIDs)
@@ -26,14 +29,16 @@
     VARIANT_INFO = 0
     VARIANT_REMOVE = 1
     VARIANT_INSTALL = 2
-
-    ACTION_BTNS = (VARIANT_REMOVE, VARIANT_INSTALL)
-
-    def __init__(self, app_view, icons, show_ratings, store=None):
+    VARIANT_PURCHASE = 3
+
+    ACTION_BTNS = (VARIANT_REMOVE, VARIANT_INSTALL, VARIANT_PURCHASE)
+
+    def __init__(self, app_view, db, icons, show_ratings, store=None):
         Gtk.TreeView.__init__(self)
         self._logger = logging.getLogger("softwarecenter.view.appview")
 
         self.app_view = app_view
+        self.db = db
 
         self.pressed = False
         self.focal_btn = None
@@ -57,6 +62,7 @@
         # it needs to be the first one, because that is what the tools look
         # at by default
         tr = CellRendererAppView(icons,
+                                 self.create_pango_layout(''),
                                  show_ratings,
                                  Icons.INSTALLED_OVERLAY)
         tr.set_pixbuf_width(32)
@@ -70,9 +76,11 @@
 
         action = CellButtonRenderer(self,
                                     name=CellButtonIDs.ACTION)
+
         action.set_markup_variants(
                 {self.VARIANT_INSTALL: _('Install'),
-                 self.VARIANT_REMOVE: _('Remove')})
+                 self.VARIANT_REMOVE: _('Remove'),
+                 self.VARIANT_PURCHASE: _(u'Buy\u2026')})
 
         tr.button_pack_start(info)
         tr.button_pack_end(action)
@@ -141,17 +149,6 @@
         model.row_changed(path, model.get_iter(path))
         return
 
-#    def is_action_in_progress_for_selected_app(self):
-#        """
-#        return True if an install or remove of the current package
-#        is in progress
-#        """
-#        (path, column) = self.get_cursor()
-#        if path:
-#            model = self.get_model()
-#            return (model[path][AppGenericStore.COL_ROW_DATA].transaction_progress != -1)
-#        return False
-
     def get_scrolled_window_vadjustment(self):
         ancestor = self.get_ancestor(Gtk.ScrolledWindow)
         if ancestor:
@@ -289,9 +286,14 @@
             action_btn.set_sensitive(True)
             action_btn.show()
         elif self.appmodel.is_available(app):
-            action_btn.set_variant(self.VARIANT_INSTALL)
+            if self.appmodel.is_purchasable(app):
+                action_btn.set_variant(self.VARIANT_PURCHASE)
+            else:
+                action_btn.set_variant(self.VARIANT_INSTALL)
+
             action_btn.set_sensitive(True)
             action_btn.show()
+
             if not network_state_is_connected():
                 action_btn.set_sensitive(False)
                 self.app_view.emit("application-selected",
@@ -318,16 +320,19 @@
     def _on_row_activated(self, view, path, column, tr):
         rowref = self.get_rowref(view.get_model(), path)
 
-        if not rowref: return
-
-        if self.rowref_is_category(rowref): return
+        if not rowref:
+            return
+        elif self.rowref_is_category(rowref):
+            return
 
         x, y = self.get_pointer()
         for btn in tr.get_buttons():
             if btn.point_in(x, y): 
                 return
 
-        self.app_view.emit("application-activated", self.appmodel.get_application(rowref))
+        app = self.appmodel.get_application(rowref)
+        if app:
+            self.app_view.emit("application-activated", app)
         return
 
     def _on_button_event_get_path(self, view, event):
@@ -468,25 +473,33 @@
         pkgname = self.appmodel.get_pkgname(app)
 
         if btn_id == CellButtonIDs.INFO:
-            self.app_view.emit("application-activated", self.appmodel.get_application(app))
+            self.app_view.emit("application-activated",
+                               self.appmodel.get_application(app))
         elif btn_id == CellButtonIDs.ACTION:
             btn.set_sensitive(False)
             store.row_changed(path, store.get_iter(path))
-            # be sure we dont request an action for a pkg with pre-existing actions
+            app_manager = get_appmanager()
+            # be sure we dont request an action for a pkg with
+            # pre-existing actions
             if pkgname in self._action_block_list:
-                logging.debug("Action already in progress for package: '%s'" % pkgname)
+                logging.debug("Action already in progress for package:"
+                              " '%s'" % pkgname)
                 return False
             self._action_block_list.append(pkgname)
             if self.appmodel.is_installed(app):
-                perform_action = AppActions.REMOVE
+                action = AppActions.REMOVE
+            elif self.appmodel.is_purchasable(app):
+                app_manager.buy_app(self.appmodel.get_application(app))
+                store.notify_action_request(app, path)
+                return
             else:
-                perform_action = AppActions.INSTALL
+                action = AppActions.INSTALL
 
             store.notify_action_request(app, path)
-
-            self.app_view.emit("application-request-action",
-                      self.appmodel.get_application(app),
-                      [], [], perform_action)
+            
+            app_manager.request_action(
+                self.appmodel.get_application(app), [], [],
+                action)
         return False
 
     def _set_cursor(self, btn, cursor):

=== modified file 'softwarecenter/ui/gtk3/widgets/buttons.py'
--- softwarecenter/ui/gtk3/widgets/buttons.py	2011-11-01 23:00:08 +0000
+++ softwarecenter/ui/gtk3/widgets/buttons.py	2011-11-09 10:56:38 +0000
@@ -182,7 +182,7 @@
         label = helper.get_appname(doc)
         icon = helper.get_icon_at_size(doc, icon_size, icon_size)
         stats = helper.get_review_stats(doc)
-        doc.installed = doc.available = None
+        helper.update_availability(doc)
         self.is_installed = helper.is_installed(doc)
         self._overlay = helper.icons.load_icon(Icons.INSTALLED_OVERLAY,
                                                self.INSTALLED_OVERLAY_SIZE,

=== modified file 'softwarecenter/ui/gtk3/widgets/cellrenderers.py'
--- softwarecenter/ui/gtk3/widgets/cellrenderers.py	2011-09-21 06:54:58 +0000
+++ softwarecenter/ui/gtk3/widgets/cellrenderers.py	2011-11-09 10:56:38 +0000
@@ -19,6 +19,7 @@
 
 from gi.repository import Gtk, Gdk, GObject, Pango
 
+from softwarecenter.utils import utf8
 from softwarecenter.ui.gtk3.em import EM
 from softwarecenter.ui.gtk3.models.appstore2 import CategoryRowReference
 
@@ -53,7 +54,7 @@
                      }
 
 
-    def __init__(self, icons, show_ratings, overlay_icon_name):
+    def __init__(self, icons, layout, show_ratings, overlay_icon_name):
         GObject.GObject.__init__(self)
 
         # geometry-state values
@@ -71,7 +72,7 @@
         self._all_buttons = {}
 
         # cache a layout
-        self._layout = None
+        self._layout = layout
         # star painter, paints stars
         self._stars = StarRenderer()
         self._stars.size = StarSize.SMALL
@@ -106,12 +107,23 @@
         else:
             x = cell_area.x + cell_area.width - lw
         y = cell_area.y + (cell_area.height - lh)/2
-        #w = cell_area.width
-        #h = cell_area.height
 
         Gtk.render_layout(context, cr, x, y, layout)
         return
 
+    def _render_price(self, context, cr, app, layout, cell_area, xpad, ypad, is_rtl):
+        layout.set_markup("US$ %s" % self.model.get_price(app), -1)
+
+        if is_rtl:
+            x = cell_area.x + xpad
+        else:
+            x = (cell_area.x + cell_area.width - xpad -
+                 self._layout_get_pixel_width(layout))
+
+        Gtk.render_layout(context, cr,
+                          x, ypad + cell_area.y, layout)
+        return
+
     def _render_icon(self, cr, app, cell_area, xpad, ypad, is_rtl):
         # calc offsets so icon is nicely centered
         icon = self.model.get_icon(app)
@@ -185,13 +197,15 @@
 
         stats = self.model.get_review_stats(app)
         if not stats: return
+
         sr = self._stars
 
         if not is_rtl:
-            x = cell_area.x+3*xpad+self.pixbuf_width+self.apptitle_width
+            x = (cell_area.x + 3 * xpad + self.pixbuf_width +
+                 self.apptitle_width)
         else:
             x = (cell_area.x + cell_area.width
-                 - 3*xpad
+                 - 3 * xpad
                  - self.pixbuf_width
                  - self.apptitle_width 
                  - star_width)
@@ -207,12 +221,10 @@
 
         layout.set_markup("<small>%s</small>" % s, -1)
 
-        lw = self._layout_get_pixel_width(layout)
-        w = star_width
         if not is_rtl:
-            x += xpad+w
+            x += xpad+star_width
         else:
-            x -= xpad+lw
+            x -= xpad+self._layout_get_pixel_width(layout)
 
         context.save()
         context.add_class("cellrenderer-avgrating-label")
@@ -250,9 +262,8 @@
         context.restore ()
         return
 
-    def _render_buttons(self,
-            context, cr, cell_area, layout, xpad, ypad,
-            is_rtl, is_available):
+    def _render_buttons(
+            self, context, cr, cell_area, layout, xpad, ypad, is_rtl):
 
         # layout buttons and paint
         y = cell_area.y+cell_area.height-ypad
@@ -261,13 +272,13 @@
         if not is_rtl:
             start = Gtk.PackType.START
             end = Gtk.PackType.END
-            xs = cell_area.x + 2*xpad + self.pixbuf_width
+            xs = cell_area.x + 2 * xpad + self.pixbuf_width
             xb = cell_area.x + cell_area.width - xpad
         else:
             start = Gtk.PackType.END
             end = Gtk.PackType.START
             xs = cell_area.x + xpad
-            xb = cell_area.x + cell_area.width - 2*xpad - self.pixbuf_width
+            xb = cell_area.x + cell_area.width - 2 * xpad - self.pixbuf_width
 
         for btn in self._buttons[start]:
             btn.set_position(xs, y-btn.height)
@@ -277,8 +288,6 @@
         for btn in self._buttons[end]:
             xb -= btn.width
             btn.set_position(xb, y-btn.height)
-            #~ if not is_available:
-                #~ btn.set_sensitive(False)
             btn.render(context, cr, layout)
 
             xb -= spacing
@@ -334,15 +343,12 @@
         if not app: return
 
         self.model = widget.appmodel
+
         context = widget.get_style_context()
         xpad = self.get_property('xpad')
         ypad = self.get_property('ypad')
         star_width, star_height = self._stars.get_visible_size(context)
         is_rtl = widget.get_direction() == Gtk.TextDirection.RTL
-
-        if not self._layout:
-            self._layout = widget.create_pango_layout('')
-
         layout = self._layout
 
         # important! ensures correct text rendering, esp. when using hicolor theme
@@ -389,30 +395,31 @@
                                 is_rtl)
 
         progress = self.model.get_transaction_progress(app)
-        #~ print progress
         if progress > 0:
             self._render_progress(context, cr, progress,
                                   cell_area,
                                   ypad,
                                   is_rtl)
 
+        elif self.model.is_purchasable(app):
+            self._render_price(context, cr, app, layout,
+                               cell_area, xpad, ypad, is_rtl)
+
         # below is the stuff that is only done for the active cell
         if not self.props.isactive:
             return
 
-        is_available = self.model.is_available(app)
         self._render_buttons(context, cr,
                              cell_area,
                              layout,
                              xpad, ypad,
-                             is_rtl,
-                             is_available)
+                             is_rtl)
 
         context.restore()
         return
 
 
-class CellButtonRenderer:
+class CellButtonRenderer(object):
 
     def __init__(self, widget, name, use_max_variant_width=True):
         # use_max_variant_width is currently ignored. assumed to be True
@@ -453,7 +460,8 @@
         max_size = (0,0)
 
         for k, variant in self.markup_variants.items():
-            layout.set_markup(GObject.markup_escape_text(variant), -1)
+            safe_markup = GObject.markup_escape_text(utf8(variant))
+            layout.set_markup(safe_markup, -1)
             size = layout.get_size()
             max_size = max(max_size, size)
 
@@ -548,14 +556,16 @@
         context.restore()
 
         if self.has_focus:
-            Gtk.render_focus(context, cr, x+3, y+3, width-6, height-6)
+            Gtk.render_focus(context, cr,
+                             x + 3, y + 3,
+                             width - 6, height - 6)
 
         # position and render layout markup
         context.save()
         context.add_class(Gtk.STYLE_CLASS_BUTTON)
         layout.set_markup(self.markup_variants[self.current_variant], -1)
         layout_width = layout.get_pixel_extents()[1].width
-        x = x + (width - layout_width)/2
+        x = x + (width - layout_width) / 2
         y += self.ypad
         Gtk.render_layout(context, cr, x, y, layout)
         context.restore()

=== added file 'test/gtk3/test_appmanager.py'
--- test/gtk3/test_appmanager.py	1970-01-01 00:00:00 +0000
+++ test/gtk3/test_appmanager.py	2011-11-09 10:56:38 +0000
@@ -0,0 +1,79 @@
+#!/usr/bin/python
+
+from mock import Mock
+import unittest
+
+import sys
+sys.path.insert(0,"../")
+
+import softwarecenter.paths
+from softwarecenter.db.application import Application
+from softwarecenter.distro import get_distro
+from softwarecenter.testutils import (
+    get_test_db, get_test_gtk3_icon_cache, do_events)
+from softwarecenter.ui.gtk3.session.appmanager import (
+    ApplicationManager, get_appmanager)
+
+class TestAppManager(unittest.TestCase):
+    """ tests the appmanager  """
+
+    def setUp(self):
+        # get required test stuff
+        self.db = get_test_db()
+        self.backend = Mock()
+        self.distro = get_distro()
+        self.datadir = softwarecenter.paths.datadir
+        self.icons = get_test_gtk3_icon_cache()
+        # create it once, it becomes global instance
+        if get_appmanager() is None:
+            ApplicationManager(
+                self.db, self.backend, self.icons)
+
+    def test_get_appmanager(self):
+        app_manager = get_appmanager()
+        self.assertNotEqual(app_manager, None)
+        # test singleton
+        app_manager2 = get_appmanager()
+        self.assertEqual(app_manager, app_manager2)
+        # test creating it twice raises a error
+        self.assertRaises(
+            ValueError, ApplicationManager, self.db, self.backend, self.icons)
+        
+    def test_appmanager(self):
+        app_manager = get_appmanager()
+        self.assertNotEqual(app_manager, None)
+        # test interface
+        app_manager.reload()
+        app = Application("", "2vcard")
+        # call and ensure the stuff is passed to the backend
+        app_manager.install(app, [], [])
+        self.assertTrue(self.backend.install.called)
+
+        app_manager.remove(app, [], [])
+        self.assertTrue(self.backend.remove.called)
+
+        app_manager.upgrade(app, [], [])
+        self.assertTrue(self.backend.upgrade.called)
+
+        app_manager.apply_changes(app, [], [])
+        self.assertTrue(self.backend.apply_changes.called)
+
+        app_manager.enable_software_source(app)
+        self.assertTrue(self.backend.enable_component.called)
+
+        app_manager.reinstall_purchased(app)
+        self.assertTrue(self.backend.add_repo_add_key_and_install_app.called)
+
+        # buy is special as it needs help from the purchase view
+        app_manager.connect("purchase-requested", self._on_purchase_requested)
+        app_manager.buy_app(app)
+        self.assertTrue(self._purchase_requested_signal)
+        do_events()
+
+    def _on_purchase_requested(self, *args):
+        self._purchase_requested_signal = True
+
+if __name__ == "__main__":
+    import logging
+    logging.basicConfig(level=logging.DEBUG)
+    unittest.main()