Merge lp:~kiwinote/software-center/less-is-more2 into lp:software-center

[Kiwinote]

this is the second part of less-is-more which is an initial run through the softwarecenter/ folder

[Michael Vogt (mvo)]

Thanks, looks fantastic!

review: Approve

=== modified file 'debian/control'
--- debian/control	2012-02-07 15:19:12 +0000
+++ debian/control	2012-03-19 22:53:18 +0000
@@ -52,7 +52,6 @@
             update-notifier, 
             software-properties-gtk,
             sessioninstaller, 
-            zeitgeist-core,
             lzma
 Conflicts: gnome-app-install (<< 1), oneconf (<< 0.2.6.1)
 Replaces: gnome-app-install

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2012-03-19 21:01:41 +0000
+++ po/POTFILES.in	2012-03-19 22:53:18 +0000
@@ -48,7 +48,6 @@
 softwarecenter/ui/gtk3/panes/installedpane.py
 softwarecenter/ui/gtk3/panes/pendingpane.py
 softwarecenter/ui/gtk3/panes/softwarepane.py
-softwarecenter/ui/gtk3/panes/unused__channelpane.py
 softwarecenter/ui/gtk3/panes/viewswitcher.py
 softwarecenter/ui/gtk3/views/appdetailsview.py
 softwarecenter/ui/gtk3/views/appview.py
@@ -65,7 +64,6 @@
 softwarecenter/ui/gtk3/widgets/searchentry.py
 softwarecenter/ui/gtk3/widgets/stars.py
 softwarecenter/ui/gtk3/widgets/thumbnail.py
-softwarecenter/ui/gtk3/widgets/unused__pathbar.py
 softwarecenter/ui/gtk3/widgets/videoplayer.py
 softwarecenter/ui/gtk3/widgets/weblivedialog.py
 softwarecenter/ui/gtk3/widgets/recommendations.py

=== removed file 'softwarecenter/backend/installbackend_impl/packagekit_enums.py'
--- softwarecenter/backend/installbackend_impl/packagekit_enums.py	2012-03-16 20:12:57 +0000
+++ softwarecenter/backend/installbackend_impl/packagekit_enums.py	1970-01-01 00:00:00 +0000
@@ -1,28 +0,0 @@
-# Copyright (C) 2007-2008 Richard Hughes <[e-mail]>
-#               2011 Giovanni Campagna <[e-mail]>
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation; 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
-
-# stolen from gnome-packagekit, which is GPL2+
-
-from gi.repository import PackageKitGlib as packagekit
-
-
-# this requires packagekit 0.7.2 or better
-def status_enum_to_localised_text(status):
-    return packagekit.info_enum_to_localised_present(status)
-
-
-def role_enum_to_localised_present(role):
-    return packagekit.role_enum_to_localised_present(role)

=== modified file 'softwarecenter/backend/installbackend_impl/packagekitd.py'
--- softwarecenter/backend/installbackend_impl/packagekitd.py	2012-03-16 20:12:57 +0000
+++ softwarecenter/backend/installbackend_impl/packagekitd.py	2012-03-19 22:53:18 +0000
@@ -31,7 +31,6 @@
     TransactionProgress
 )
 from softwarecenter.backend.installbackend import InstallBackend
-from softwarecenter.backend.installbackend_impl import packagekit_enums
 
 # temporary, must think of better solution
 from softwarecenter.db.pkginfo import get_pkg_info
@@ -100,13 +99,13 @@
     def get_role_description(self, role=None):
         role = role if role is not None else self._trans.get_property('role')
         return self.meta_data.get('sc_appname',
-            packagekit_enums.role_enum_to_localised_present(role))
+            packagekit.role_enum_to_localised_present(role))
 
     def get_status_description(self, status=None):
         if status is None:
             status = self._trans.get_property('status')
 
-        return packagekit_enums.status_enum_to_localised_text(status)
+        return packagekit.info_enum_to_localised_present(status)
 
     def is_waiting(self):
         """ return true if a time consuming task is taking place """

=== removed file 'softwarecenter/backend/zeitgeist_simple.py'
--- softwarecenter/backend/zeitgeist_simple.py	2012-03-19 13:35:47 +0000
+++ softwarecenter/backend/zeitgeist_simple.py	1970-01-01 00:00:00 +0000
@@ -1,139 +0,0 @@
-# Copyright (C) 2009-2010 Canonical
-#
-# Authors:
-#  Seif Lotfy
-#  Michael Vogt
-#
-# 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
-
-import logging
-import time
-LOG = logging.getLogger("sofwarecenter.zeitgeist")
-
-try:
-    from zeitgeist.client import ZeitgeistClient
-    from zeitgeist.datamodel import Event, Interpretation, ResultType
-except ImportError:
-    LOG.exception("zeitgeist import failed")
-    ZEITGEIST_AVAILABLE = False
-else:
-    ZEITGEIST_AVAILABLE = True
-
-
-class SoftwareCenterZeitgeist():
-    """ simple wrapper around zeitgeist """
-
-    def __init__(self):
-        try:
-            self.zg_client = ZeitgeistClient()
-        except Exception as e:
-            logging.warn("can not get zeitgeist client: '%s'" % e)
-            self.zg_client = None
-
-    def get_usage_counter(self, application, callback, timerange=None):
-        """Request the usage count as integer for the given application.
-           When the request is there, "callback" is called. A optional
-           timerange like [time.time(), time.time() - 30*24*60*60] can
-           also be specified
-        """
-        # helper
-        def _callback(event_ids):
-            callback(len(event_ids))
-        # no client or empty query -> empty result
-        if not self.zg_client or not application:
-            callback(0)
-            return
-        # the app we are looking for
-        application = "application://" + application.split("/")[-1]
-        # the event_templates
-        e1 = Event.new_for_values(
-            actor=application, interpretation=Interpretation.MODIFY_EVENT.uri)
-        e2 = Event.new_for_values(
-            actor=application, interpretation=Interpretation.CREATE_EVENT.uri)
-        # run it
-        self.zg_client.find_event_ids_for_templates(
-            [e1, e2], _callback, timerange=timerange, num_events=0)
-
-    def get_popular_mimetypes(self, callback, num=3):
-        """ get the "num" (default to 3) most popular mimetypes based
-            on the last 1000 events that zeitgeist recorded and
-            call "callback" with [(count1, "mime1"), (count2, "mime2"), ...]
-            as arguement
-        """
-        def _callback(events):
-            # gather
-            mimetypes = {}
-            for event in events:
-                if event.subjects is None:
-                    continue
-                mimetype = event.subjects[0].mimetype
-                if not mimetype in mimetypes:
-                    mimetypes[mimetype] = 0
-                mimetypes[mimetype] += 1
-            # return early if empty
-            results = []
-            if not mimetypes:
-                callback([])
-            # convert to result and sort
-            for k, v in mimetypes.items():
-                results.append([v, k])
-            results.sort(reverse=True)
-            # tell the client about it
-            callback(results[:num])
-        # no zeitgeist
-        if not self.zg_client:
-            return
-        # trigger event (actual processing is done in _callback)
-        # FIXME: investigate how result_type MostRecentEvents or
-        #        MostRecentSubjects would affect the results
-        self.zg_client.find_events_for_templates(
-            [], _callback, num_events=1000,
-            result_type=ResultType.MostRecentEvents)
-
-
-class SoftwareCenterZeitgeistDummy():
-    def get_usage_counter(self, application, callback, timerange=None):
-        callback(0)
-
-    def get_popular_mimetypes(self, callback):
-        callback([])
-
-# singleton
-if ZEITGEIST_AVAILABLE:
-    zeitgeist_singleton = SoftwareCenterZeitgeist()
-else:
-    zeitgeist_singleton = SoftwareCenterZeitgeistDummy()
-
-if __name__ == "__main__":
-
-    def _callback_counter(events):
-        print("test _callback: %s" % events)
-    # all time gedit
-    zeitgeist_singleton.get_usage_counter("gedit.desktop", _callback_counter)
-
-    # yesterday gedit
-    end = time.time()
-    start = end - 24 * 60 * 60
-    zeitgeist_singleton.get_usage_counter("gedit.desktop", _callback_counter,
-                                          timerange=[start, end])
-
-    # most popular
-    def _callback_popular(mimetypes):
-        print("test _callback: ")
-        for tuple in mimetypes:
-            print(tuple)
-    zeitgeist_singleton.get_popular_mimetypes(_callback_popular)
-
-    from gi.repository import Gtk
-    Gtk.main()

=== modified file 'softwarecenter/paths.py'
--- softwarecenter/paths.py	2012-03-15 22:36:31 +0000
+++ softwarecenter/paths.py	2012-03-19 22:53:18 +0000
@@ -34,8 +34,6 @@
 #                 xdg_cache_home=os.path.expanduser("~/.cache"))
 from xdg import BaseDirectory as xdg
 
-from softwarecenter.toolkit import CURRENT_TOOLKIT, UIToolkits
-
 # global datadir, this maybe overriden at startup
 datadir = "/usr/share/software-center/"
 
@@ -70,18 +68,11 @@
 # ratings&review
 # relative to datadir
 class RNRApps:
-    if CURRENT_TOOLKIT is UIToolkits.GTK2:
-        SUBMIT_REVIEW = "submit_review.py"
-        REPORT_REVIEW = "report_review.py"
-        SUBMIT_USEFULNESS = "submit_usefulness.py"
-        MODIFY_REVIEW = "modify_review.py"
-        DELETE_REVIEW = "delete_review.py"
-    elif CURRENT_TOOLKIT is UIToolkits.GTK3:
-        SUBMIT_REVIEW = "submit_review_gtk3.py"
-        REPORT_REVIEW = "report_review_gtk3.py"
-        SUBMIT_USEFULNESS = "submit_usefulness_gtk3.py"
-        MODIFY_REVIEW = "modify_review_gtk3.py"
-        DELETE_REVIEW = "delete_review_gtk3.py"
+    SUBMIT_REVIEW = "submit_review_gtk3.py"
+    REPORT_REVIEW = "report_review_gtk3.py"
+    SUBMIT_USEFULNESS = "submit_usefulness_gtk3.py"
+    MODIFY_REVIEW = "modify_review_gtk3.py"
+    DELETE_REVIEW = "delete_review_gtk3.py"
 
 
 # piston helpers

=== removed file 'softwarecenter/toolkit.py'
--- softwarecenter/toolkit.py	2012-03-15 10:43:13 +0000
+++ softwarecenter/toolkit.py	1970-01-01 00:00:00 +0000
@@ -1,18 +0,0 @@
-import sys
-
-
-class UIToolkits:
-    GTK2 = 0
-    GTK3 = 1
-    QML = 2
-    FALLBACK = GTK3
-
-
-if 'software-center' in sys.argv[0]:
-    CURRENT_TOOLKIT = UIToolkits.GTK3
-elif 'software-center-gtk2' in sys.argv[0]:
-    CURRENT_TOOLKIT = UIToolkits.GTK2
-elif 'software-center-qml' in sys.argv[0]:
-    CURRENT_TOOLKIT = UIToolkits.QML
-else:
-    CURRENT_TOOLKIT = UIToolkits.FALLBACK

=== removed file 'softwarecenter/ui/gtk3/models/navlogstore.py'
=== removed file 'softwarecenter/ui/gtk3/panes/unused__channelpane.py'
--- softwarecenter/ui/gtk3/panes/unused__channelpane.py	2012-03-15 00:16:03 +0000
+++ softwarecenter/ui/gtk3/panes/unused__channelpane.py	1970-01-01 00:00:00 +0000
@@ -1,316 +0,0 @@
-# Copyright (C) 2010 Canonical
-#
-# Authors:
-#  Michael Vogt
-#  Gary Lasker
-#
-# 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
-
-import gettext
-from gi.repository import Gtk
-import logging
-import os
-import sys
-import xapian
-from gi.repository import GObject
-
-from gettext import gettext as _
-
-from softwarecenter.backend import get_install_backend
-from softwarecenter.distro import get_distro
-from softwarecenter.enums import NavButtons, NonAppVisibility
-from softwarecenter.paths import XAPIAN_BASE_PATH
-from softwarepane import SoftwarePane
-from softwarecenter.ui.gtk3.views.appview import AppViewFilter
-import softwarecenter.ui.gtk3.dialogs as dialogs
-
-LOG = logging.getLogger(__name__)
-
-
-class ChannelPane(SoftwarePane):
-    """Widget that represents the channel pane for display of
-       individual channels (PPAs, partner repositories, etc.)
-       in software-center.
-       It contains a search entry and navigation buttons.
-    """
-
-    (PAGE_APPLIST,
-     PAGE_APP_DETAILS,
-     PAGE_APP_PURCHASE) = range(3)
-
-    __gsignals__ = {'channel-pane-created': (GObject.SignalFlags.RUN_FIRST,
-                                             None,
-                                             ())}
-
-    def __init__(self, cache, db, distro, icons, datadir):
-        # parent
-        SoftwarePane.__init__(self, cache, db, distro, icons, datadir,
-                              show_ratings=False)
-        self.channel = None
-        self.apps_filter = None
-        self.apps_search_term = ""
-        self.current_appview_selection = None
-        self.distro = get_distro()
-        self.pane_name = _("Software Channels")
-
-    def init_view(self):
-        if not self.view_initialized:
-            SoftwarePane.init_view(self)
-            self.notebook.append_page(self.box_app_list,
-                Gtk.Label(label="channel"))
-            # details
-            self.notebook.append_page(self.scroll_details,
-                Gtk.Label(label="details"))
-            # purchase view
-            self.notebook.append_page(self.purchase_view,
-                Gtk.Label(label="purchase"))
-            # now we are initialized
-            self.emit("channel-pane-created")
-            self.show_all()
-            self.view_initialized = True
-
-    def _show_channel_overview(self):
-        " helper that goes back to the overview page "
-        self.navigation_bar.remove_ids(NavButtons.DETAILS)
-        self.navigation_bar.remove_ids(NavButtons.PURCHASE)
-        self.notebook.set_current_page(self.PAGE_APPLIST)
-        self.searchentry.show()
-
-    def _clear_search(self):
-        # remove the details and clear the search
-        self.searchentry.clear()
-        self.navigation_bar.remove_ids(NavButtons.SEARCH)
-
-    def set_channel(self, channel):
-        """
-        set the current software channel object for display in the channel pane
-        and set up the AppViewFilter if required
-        """
-        self.channel = channel
-        # check to see if there is any section info that needs to be applied
-        # FIXME
-        #~ if channel._channel_color:
-            #~ self.section.set_color(channel._channel_color)
-        #~ if channel._channel_view_id:
-            #~ self.section.set_view_id(channel._channel_view_id)
-        #~ self.section_sync()
-
-        # check if the channel needs to added
-        if channel.needs_adding and channel._source_entry:
-            dialog = Gtk.MessageDialog(flags=Gtk.DialogFlags.MODAL,
-                                       type=Gtk.MessageType.QUESTION)
-            dialog.set_title("")
-            dialog.set_markup("<big><b>%s</b></big>" % _("Add channel"))
-            dialog.format_secondary_text(_("The selected channel is not yet "
-                "added. Do you want to add it now?"))
-            dialog.add_buttons(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
-                               Gtk.STOCK_ADD, Gtk.ResponseType.YES)
-            res = dialog.run()
-            dialog.destroy()
-            if res == Gtk.ResponseType.YES:
-                channel.needs_adding = False
-                backend = get_install_backend()
-                backend.add_sources_list_entry(channel._source_entry)
-                backend.emit("channels-changed", True)
-                backend.reload()
-            return
-        # normal operation
-        self.nonapps_visible = NonAppVisibility.MAYBE_VISIBLE
-        self.apps_filter = None
-        if self.channel.installed_only:
-            if self.apps_filter is None:
-                self.apps_filter = AppViewFilter(self.db, self.cache)
-            self.apps_filter.set_installed_only(True)
-        # switch to applist, this will clear searches too
-        self.display_list()
-
-    def on_search_terms_changed(self, searchentry, terms):
-        """callback when the search entry widget changes"""
-        LOG.debug("on_search_terms_changed: '%s'" % terms)
-        self.apps_search_term = terms
-        if not self.apps_search_term:
-            self._clear_search()
-        self.refresh_apps()
-        self.notebook.set_current_page(self.PAGE_APPLIST)
-
-    def on_db_reopen(self, db):
-        LOG.debug("got db-reopen signal")
-        self.refresh_apps()
-        self.app_details_view.refresh_app()
-
-    def on_navigation_search(self, button, part):
-        """ callback when the navigation button with id 'search' is clicked"""
-        self.display_search()
-
-    def on_navigation_list(self, button, part):
-        """callback when the navigation button with id 'list' is clicked"""
-        if not button.get_active():
-            return
-        self.display_list()
-
-    def display_list(self):
-        self._clear_search()
-        self._show_channel_overview()
-        # only emit something if the model is there
-        model = self.app_view.get_model()
-        if model:
-            self.emit("app-list-changed", len(model))
-
-    def on_navigation_details(self, button, part):
-        """callback when the navigation button with id 'details' is clicked"""
-        if not button.get_active():
-            return
-        self.display_details()
-
-    def display_details(self):
-        self.navigation_bar.remove_ids(NavButtons.PURCHASE)
-        self.notebook.set_current_page(self.PAGE_APP_DETAILS)
-        self.searchentry.hide()
-        self.action_bar.clear()
-        # we want to re-enable the buy button if this is an app for purchase
-        # FIXME:  hacky, find a better approach
-        button = self.app_details_view.pkg_statusbar.button
-        if button.get_label() == _(u'Buy\u2026'):
-            button.set_sensitive(True)
-
-    def on_navigation_purchase(self, button, part):
-        """callback when the navigation button with id 'purchase' is clicked"""
-        if not button.get_active():
-            return
-        self.display_purchase()
-
-    def display_purchase(self):
-        self.notebook.set_current_page(self.PAGE_APP_PURCHASE)
-        self.searchentry.hide()
-        self.action_bar.clear()
-
-    def on_application_selected(self, appview, app):
-        """callback when an app is selected"""
-        LOG.debug("on_application_selected: '%s'" % app)
-        self.current_appview_selection = app
-
-    def display_search(self):
-        self.navigation_bar.remove_ids(NavButtons.DETAILS)
-        self.navigation_bar.remove_ids(NavButtons.PURCHASE)
-        self.notebook.set_current_page(self.PAGE_APPLIST)
-        model = self.app_view.get_model()
-        if model:
-            length = len(self.app_view.get_model())
-            self.emit("app-list-changed", length)
-        self.searchentry.show()
-
-    def get_status_text(self):
-        """return user readable status text suitable for a status bar"""
-        # no status text in the details page
-        if self.notebook.get_current_page() == self.PAGE_APP_DETAILS:
-            return ""
-        # otherwise, show status based on search or not
-        model = self.app_view.get_model()
-        if not model:
-            return ""
-        length = len(self.app_view.get_model())
-        if self.channel.installed_only:
-            if len(self.searchentry.get_text()) > 0:
-                return gettext.ngettext("%(amount)s matching item",
-                                        "%(amount)s matching items",
-                                        length) % {'amount': length}
-            else:
-                return gettext.ngettext("%(amount)s item installed",
-                                        "%(amount)s items installed",
-                                        length) % {'amount': length}
-        else:
-            if len(self.searchentry.get_text()) > 0:
-                return gettext.ngettext("%(amount)s matching item",
-                                        "%(amount)s matching items",
-                                        length) % {'amount': length}
-            else:
-                return gettext.ngettext("%(amount)s item available",
-                                        "%(amount)s items available",
-                                        length) % {'amount': length}
-
-    def get_current_app(self):
-        """return the current active application object applicable
-           to the context"""
-        return self.current_appview_selection
-
-    def is_category_view_showing(self):
-        # there is no category view in the channel pane
-        return False
-
-    def is_applist_view_showing(self):
-        """Return True if we are in the applist view """
-        return self.notebook.get_current_page() == self.PAGE_APPLIST
-
-    def is_app_details_view_showing(self):
-        """Return True if we are in the app_details view """
-        return self.notebook.get_current_page() == self.PAGE_APP_DETAILS
-
-if __name__ == "__main__":
-    #logging.basicConfig(level=logging.DEBUG)
-
-    if len(sys.argv) > 1:
-        datadir = sys.argv[1]
-    elif os.path.exists("./data"):
-        datadir = "./data"
-    else:
-        datadir = "/usr/share/software-center"
-
-    from softwarecenter.ui.gtk3.utils import get_sc_icon_theme
-    icons = get_sc_icon_theme(datadir)
-
-    from softwarecenter.db.database import StoreDatabase
-    from softwarecenter.db.pkginfo import get_pkg_info
-    cache = get_pkg_info()
-    cache.open()
-
-    # xapian
-    xapian_base_path = XAPIAN_BASE_PATH
-    pathname = os.path.join(xapian_base_path, "xapian")
-    try:
-        db = StoreDatabase(pathname, cache)
-        db.open()
-    except xapian.DatabaseOpeningError:
-        # Couldn't use that folder as a database
-        # This may be because we are in a bzr checkout and that
-        #   folder is empty. If the folder is empty, and we can find the
-        # script that does population, populate a database in it.
-        if os.path.isdir(pathname) and not os.listdir(pathname):
-            from softwarecenter.db.update import rebuild_database
-            logging.info("building local database")
-            rebuild_database(pathname)
-            db = StoreDatabase(pathname, cache)
-            db.open()
-    except xapian.DatabaseCorruptError as e:
-        logging.exception("xapian open failed")
-        dialogs.error(None,
-                      _("Sorry, can not open the software database"),
-                      _("Please re-install the 'software-center' "
-                        "package."))
-        # FIXME: force rebuild by providing a dbus service for this
-        sys.exit(1)
-
-    import softwarecenter.distro
-    distro = softwarecenter.distro.get_distro()
-
-    w = ChannelPane(cache, db, distro, icons, datadir)
-    w.show()
-
-    win = Gtk.Window()
-    win.add(w)
-    w.init_view()
-    win.set_size_request(400, 600)
-    win.show_all()
-    win.connect("destroy", Gtk.main_quit)
-
-    Gtk.main()

=== removed file 'softwarecenter/ui/gtk3/shapes.py'
--- softwarecenter/ui/gtk3/shapes.py	2012-03-15 09:32:18 +0000
+++ softwarecenter/ui/gtk3/shapes.py	1970-01-01 00:00:00 +0000
@@ -1,257 +0,0 @@
-import gi
-gi.require_version("Gtk", "3.0")
-from gi.repository import Gtk
-
-
-from math import sin, cos
-
-# pi constants
-from math import pi as PI
-PI_OVER_180 = PI / 180
-
-
-def radian(deg):
-    return PI_OVER_180 * deg
-
-# directional shapes
-
-
-class Shape:
-
-    """ Base class for a Shape implementation.
-
-        Currently implements a single method <layout> which is called
-        to layout the shape using cairo paths.  It can also store the
-        'direction' of the shape which should be on of the Gtk.TEXT_DIR
-        constants.  Default 'direction' is Gtk.TextDirection.LTR.
-
-        When implementing a Shape, there are two options available.
-
-        If the Shape is direction dependent, the Shape MUST
-        implement <_layout_ltr> and <_layout_rtl> methods.
-
-        If the Shape is not direction dependent, then it simply can
-        override the <layout> method.
-
-        <layout> methods must take the following as arguments:
-
-        cr :    a CairoContext
-        x  :    x coordinate
-        y  :    y coordinate
-        w  :    width value
-        h  :    height value
-
-        <layout> methods can then be passed Shape specific
-        keyword arguments which can be used as draw-time modifiers.
-    """
-
-    def __init__(self, direction):
-        self.direction = direction
-
-    def layout(self, cr, x, y, w, h, *args, **kwargs):
-        if self.direction != Gtk.TextDirection.RTL:
-            self._layout_ltr(cr, x, y, w, h, *args, **kwargs)
-        else:
-            self._layout_rtl(cr, x, y, w, h, *args, **kwargs)
-
-
-class ShapeRoundedRectangle(Shape):
-
-    """
-        RoundedRectangle lays out a rectangle with all four corners
-        rounded as specified at the layout call by the keyword argument:
-
-        radius :    an integer or float specifying the corner radius.
-                    The radius must be > 0.
-
-        RoundedRectangle is not direction sensitive.
-    """
-
-    def __init__(self, direction=Gtk.TextDirection.LTR):
-        Shape.__init__(self, direction)
-
-    def layout(self, cr, x, y, w, h, *args, **kwargs):
-        r = kwargs['radius']
-
-        cr.new_sub_path()
-        cr.arc(r + x, r + y, r, PI, 270 * PI_OVER_180)
-        cr.arc(w - r, r + y, r, 270 * PI_OVER_180, 0)
-        cr.arc(w - r, h - r, r, 0, 90 * PI_OVER_180)
-        cr.arc(r + x, h - r, r, 90 * PI_OVER_180, PI)
-        cr.close_path()
-
-
-class ShapeRoundedRectangleIrregular(Shape):
-
-    """
-        RoundedRectangleIrregular lays out a rectangle for which each
-        individual corner can be rounded by a specific radius,
-        as specified at the layout call by the keyword argument:
-
-        radii : a 4-tuple of ints or floats specifying the radius for
-                each corner.  A value of 0 is acceptable as a radius, it
-                will result in a squared corner.
-
-        RoundedRectangleIrregular is not direction sensitive.
-    """
-
-    def __init__(self, direction=Gtk.TextDirection.LTR):
-        Shape.__init__(self, direction)
-
-    def layout(self, cr, x, y, w, h, *args, **kwargs):
-        nw, ne, se, sw = kwargs['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()
-
-
-class ShapeStartArrow(Shape):
-
-    def __init__(self, direction=Gtk.TextDirection.LTR):
-        Shape.__init__(self, direction)
-
-    def _layout_ltr(self, cr, x, y, w, h, *args, **kwargs):
-        aw = kwargs['arrow_width']
-        r = kwargs['radius']
-
-        cr.new_sub_path()
-        cr.arc(r + x, r + y, r, PI, 270 * PI_OVER_180)
-        # arrow head
-        cr.line_to(w - aw, y)
-        cr.line_to(w - x + 1, (h + y) / 2)
-        cr.line_to(w - aw, h)
-        cr.arc(r + x, h - r, r, 90 * PI_OVER_180, PI)
-        cr.close_path()
-
-    def _layout_rtl(self, cr, x, y, w, h, *args, **kwargs):
-        aw = kwargs['arrow_width']
-        r = kwargs['radius']
-
-        cr.new_sub_path()
-        cr.move_to(x, (h + y) / 2)
-        cr.line_to(aw, y)
-        cr.arc(w - r, r + y, r, 270 * PI_OVER_180, 0)
-        cr.arc(w - r, h - r, r, 0, 90 * PI_OVER_180)
-        cr.line_to(aw, h)
-        cr.close_path()
-
-
-class ShapeMidArrow(Shape):
-
-    def __init__(self, direction=Gtk.TextDirection.LTR):
-        Shape.__init__(self, direction)
-
-    def _layout_ltr(self, cr, x, y, w, h, *args, **kwargs):
-        aw = kwargs['arrow_width']
-
-        cr.move_to(x, y)
-        # arrow head
-        cr.line_to(w - aw, y)
-        cr.line_to(w - x + 1, (h + y) / 2)
-        cr.line_to(w - aw, h)
-        cr.line_to(x, h)
-        cr.close_path()
-
-    def _layout_rtl(self, cr, x, y, w, h, *args, **kwargs):
-        aw = kwargs['arrow_width']
-
-        cr.move_to(x, (h + y) / 2)
-        cr.line_to(aw, y)
-        cr.line_to(w, y)
-        cr.line_to(w, h)
-        cr.line_to(aw, h)
-        cr.close_path()
-
-
-class ShapeEndCap(Shape):
-
-    def __init__(self, direction=Gtk.TextDirection.LTR):
-        Shape.__init__(self, direction)
-
-    def _layout_ltr(self, cr, x, y, w, h, *args, **kwargs):
-        r = kwargs['radius']
-        aw = kwargs['arrow_width']
-
-        cr.move_to(x - 1, y)
-        cr.arc(w - r, r + y, r, 270 * PI_OVER_180, 0)
-        cr.arc(w - r, h - r, r, 0, 90 * PI_OVER_180)
-        cr.line_to(x - 1, h)
-        cr.line_to(x + aw, (h + y) / 2)
-        cr.close_path()
-
-    def _layout_rtl(self, cr, x, y, w, h, *args, **kwargs):
-        r = kwargs['radius']
-
-        cr.arc(r + x, r + y, r, PI, 270 * PI_OVER_180)
-        cr.line_to(w, y)
-        cr.line_to(w, h)
-        cr.arc(r + x, h - r, r, 90 * PI_OVER_180, PI)
-        cr.close_path()
-
-
-class Circle(Shape):
-
-    def __init__(self, direction=Gtk.TextDirection.LTR):
-        Shape.__init__(self, direction)
-
-    @staticmethod
-    def layout(cr, x, y, w, h, *args, **kwargs):
-        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()
-
-
-class ShapeStar(Shape):
-
-    def __init__(self, points, indent=0.61, direction=Gtk.TextDirection.LTR):
-        self.coords = self._calc_coords(points, 1 - indent)
-
-    def _calc_coords(self, points, indent):
-        coords = []
-        step = radian(180.0 / points)
-
-        for i in range(2 * points):
-            if i % 2:
-                x = (sin(step * i) + 1) * 0.5
-                y = (cos(step * i) + 1) * 0.5
-            else:
-                x = (sin(step * i) * indent + 1) * 0.5
-                y = (cos(step * i) * indent + 1) * 0.5
-
-            coords.append((x, y))
-        return coords
-
-    def layout(self, cr, x, y, w, h):
-        points = [(sx_sy[0] * w + x, sx_sy[1] * h + y)
-            for sx_sy in self.coords]
-        cr.move_to(*points[0])
-
-        for p in points[1:]:
-            cr.line_to(*p)
-
-        cr.close_path()

=== modified file 'softwarecenter/ui/gtk3/views/appdetailsview.py'
--- softwarecenter/ui/gtk3/views/appdetailsview.py	2012-03-15 21:47:29 +0000
+++ softwarecenter/ui/gtk3/views/appdetailsview.py	2012-03-19 22:53:18 +0000
@@ -37,7 +37,6 @@
 from softwarecenter.db.application import Application
 from softwarecenter.db import DebFileApplication
 from softwarecenter.backend.reviews import ReviewStats
-#from softwarecenter.backend.zeitgeist_simple import zeitgeist_singleton
 from softwarecenter.enums import (AppActions,
                                   PkgStates,
                                   Icons,
@@ -1165,10 +1164,6 @@
         vb_inner.pack_start(self.title, False, False, 0)
         vb_inner.pack_start(self.subtitle, False, False, 0)
 
-        # usage
-        #~ self.usage = mkit.BubbleLabel()
-        #~ vb_inner.pack_start(self.usage, True, True, 0)
-
         # star rating box/widget
         self.review_stats_widget = StarRatingsWidget()
         self.review_stats = Gtk.HBox()
@@ -1539,9 +1534,6 @@
         if not summary:
             summary = ""
 
-        # hide stuff
-        #~ self.usage.hide()
-
         # depending on pkg install state set action labels
         self.pkg_statusbar.configure(app_details, app_details.pkg_state)
 
@@ -1570,9 +1562,6 @@
         # show where it is
         self._configure_where_is_it()
 
-        # async query zeitgeist and rnr
-        self._update_usage_counter()
-
     def _update_minimal(self, app_details):
         self._update_app_icon(app_details)
         self._update_pkg_info_table(app_details)
@@ -2045,35 +2034,6 @@
     def set_section(self, section):
         self.section = section
 
-    def _update_usage_counter(self):
-        """ try to get the usage counter from zeitgeist """
-        def _zeitgeist_callback(counter):
-            LOG.debug("zeitgeist usage: %s" % counter)
-            if counter == 0:
-                # this probably means we just have no idea about it,
-                # so instead of saying "Used: never" we just return
-                # this can go away when zeitgeist captures more events
-                # --there are still cases when we really do want to hide this
-                self.usage.hide()
-                return
-            if counter <= 100:
-                label_string = gettext.ngettext("Used: one time",
-                                                "Used: %(amount)s times",
-                                                counter) % {'amount': counter}
-            else:
-                label_string = _("Used: over 100 times")
-            self.usage.set_text('<small>%s</small>' % label_string)
-            self.usage.show()
-
-        # try to get it
-        # FIXME
-        # try:
-        #     zeitgeist_singleton.get_usage_counter(
-        #         self.app_details.desktop_file, _zeitgeist_callback)
-        # except Exception, e:
-        #     LOG.warning("could not update the usage counter: %s " % e)
-        #     self.usage.hide()
-
 
 def get_test_window_appdetails():
 

=== modified file 'softwarecenter/ui/gtk3/widgets/exhibits.py'
--- softwarecenter/ui/gtk3/widgets/exhibits.py	2012-03-09 12:50:38 +0000
+++ softwarecenter/ui/gtk3/widgets/exhibits.py	2012-03-19 22:53:18 +0000
@@ -32,7 +32,6 @@
 
 from softwarecenter.utils import SimpleFileDownloader
 from softwarecenter.ui.gtk3.em import StockEms
-from softwarecenter.ui.gtk3.shapes import Circle
 from softwarecenter.ui.gtk3.drawing import rounded_rect
 from softwarecenter.ui.gtk3.utils import point_in
 import softwarecenter.paths
@@ -197,9 +196,20 @@
         y = (a.height - ds_h) / 2
         Gdk.cairo_set_source_pixbuf(cr, self._dropshadow, 0, y)
         cr.paint()
-        Circle.layout(cr, self._margin, (a.height - ds_h) / 2 + self._margin,
-                      a.width - 2 * self._margin,
-                      a.width - 2 * self._margin)
+
+        # layout circle
+        x = self._margin
+        y = (a.height - ds_h) / 2 + self._margin
+        w = a.width - 2 * self._margin
+        h = a.width - 2 * self._margin
+        cr.new_path()
+        r = min(w, h) * 0.5
+        x += int((w - 2 * r) / 2)
+        y += int((h - 2 * r) / 2)
+        from math import pi
+        cr.arc(r + x, r + y, r, 0, 2 * pi)
+        cr.close_path()
+
         if self.is_active:
             color = context.get_background_color(Gtk.StateFlags.SELECTED)
         else:

=== modified file 'softwarecenter/ui/gtk3/widgets/stars.py'
--- softwarecenter/ui/gtk3/widgets/stars.py	2012-03-08 17:42:36 +0000
+++ softwarecenter/ui/gtk3/widgets/stars.py	2012-03-19 22:53:18 +0000
@@ -24,7 +24,6 @@
 
 from gi.repository import Gtk, Gdk, GObject
 
-from softwarecenter.ui.gtk3.shapes import ShapeStar
 from softwarecenter.ui.gtk3.em import StockEms, em, small_em, big_em
 
 
@@ -50,6 +49,38 @@
     REACTIVE = -1
 
 
+class ShapeStar():
+    def __init__(self, points, indent=0.61):
+        self.coords = self._calc_coords(points, 1 - indent)
+
+    def _calc_coords(self, points, indent):
+        coords = []
+
+        from math import cos, pi, sin
+        step = pi / points
+
+        for i in range(2 * points):
+            if i % 2:
+                x = (sin(step * i) + 1) * 0.5
+                y = (cos(step * i) + 1) * 0.5
+            else:
+                x = (sin(step * i) * indent + 1) * 0.5
+                y = (cos(step * i) * indent + 1) * 0.5
+
+            coords.append((x, y))
+        return coords
+
+    def layout(self, cr, x, y, w, h):
+        points = [(sx_sy[0] * w + x, sx_sy[1] * h + y)
+            for sx_sy in self.coords]
+        cr.move_to(*points[0])
+
+        for p in points[1:]:
+            cr.line_to(*p)
+
+        cr.close_path()
+
+
 class StarRenderer(ShapeStar):
 
     def __init__(self):

=== removed file 'softwarecenter/ui/gtk3/widgets/unused__pathbar.py'
--- softwarecenter/ui/gtk3/widgets/unused__pathbar.py	2012-03-08 14:09:41 +0000
+++ softwarecenter/ui/gtk3/widgets/unused__pathbar.py	1970-01-01 00:00:00 +0000
@@ -1,1235 +0,0 @@
-from gi.repository import Atk
-from gi.repository import Gtk, Gdk
-from gi.repository import GObject
-from gi.repository import Pango
-
-from softwarecenter.ui.gtk3.em import em
-
-from gettext import gettext as _
-
-import logging
-LOG = logging.getLogger("softwarecenter.view.widgets.NavigationBar")
-
-# pi constants
-from math import pi
-
-PI = pi
-PI_OVER_180 = pi / 180
-
-
-class Shape:
-
-    """ Base class for a Shape implementation.
-
-        Currently implements a single method <layout> which is called
-        to layout the shape using cairo paths.  It can also store the
-        'direction' of the shape which should be on of the Gtk.TEXT_DIR
-        constants.  Default 'direction' is Gtk.TextDirection.LTR.
-
-        When implementing a Shape, there are two options available.
-
-        If the Shape is direction dependent, the Shape MUST
-        implement <_layout_ltr> and <_layout_rtl> methods.
-
-        If the Shape is not direction dependent, then it simply can
-        override the <layout> method.
-
-        <layout> methods must take the following as arguments:
-
-        cr :    a CairoContext
-        x  :    x coordinate
-        y  :    y coordinate
-        w  :    width value
-        h  :    height value
-
-        <layout> methods can then be passed Shape specific
-        keyword arguments which can be used as paint-time modifiers.
-    """
-
-    def __init__(self, direction):
-        self.direction = direction
-        self.name = 'Shapeless'
-        self.hadjustment = 0
-        self._color = 1, 0, 0
-
-    def __eq__(self, other):
-        return self.name == other.name
-
-    def layout(self, cr, x, y, w, h, r, aw):
-        if self.direction != Gtk.TextDirection.RTL:
-            self._layout_ltr(cr, x, y, w, h, r, aw)
-        else:
-            self._layout_rtl(cr, x, y, w, h, r, aw)
-
-
-class ShapeRoundedRect(Shape):
-
-    """
-        RoundedRect lays out a rectangle with all four corners
-        rounded as specified at the layout call by the keyword argument:
-
-        radius :    an integer or float specifying the corner radius.
-                    The radius must be > 0.
-
-        RoundedRectangle is not direction sensitive.
-    """
-
-    def __init__(self, direction=Gtk.TextDirection.LTR):
-        Shape.__init__(self, direction)
-        self.name = 'RoundedRect'
-
-    def layout(self, cr, x, y, w, h, r, aw):
-        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()
-
-
-class ShapeStartArrow(Shape):
-
-    def __init__(self, direction=Gtk.TextDirection.LTR):
-        Shape.__init__(self, direction)
-        self.name = 'StartArrow'
-
-    def _layout_ltr(self, cr, x, y, w, h, r, aw):
-        haw = aw / 2
-
-        cr.new_sub_path()
-        cr.arc(r + x, r + y, r, PI, 270 * PI_OVER_180)
-
-        # arrow head
-        cr.line_to(x + w - haw, y)
-        cr.line_to(x + w + haw, y + (h / 2))
-        cr.line_to(x + w - haw, y + h)
-
-        cr.arc(r + x, y + h - r, r, 90 * PI_OVER_180, PI)
-        cr.close_path()
-
-    def _layout_rtl(self, cr, x, y, w, h, r, aw):
-        haw = aw / 2
-
-        cr.new_sub_path()
-        cr.move_to(x - haw, (y + h) / 2)
-        cr.line_to(x + aw - haw, y)
-        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.line_to(x + aw - haw, y + h)
-        cr.close_path()
-
-
-class ShapeMidArrow(Shape):
-
-    def __init__(self, direction=Gtk.TextDirection.LTR):
-        Shape.__init__(self, direction)
-        #~ self.draw_xoffset = -2
-        self._color = 0, 1, 0
-        self.name = 'MidArrow'
-
-    def _layout_ltr(self, cr, x, y, w, h, r, aw):
-        self.hadjustment = haw = aw / 2
-        cr.move_to(x - haw - 1, y)
-        # arrow head
-        cr.line_to(x + w - haw, y)
-        cr.line_to(x + w + haw, y + (h / 2))
-        cr.line_to(x + w - haw, y + h)
-        cr.line_to(x - haw - 1, y + h)
-
-        cr.line_to(x + haw - 1, y + (h / 2))
-
-        cr.close_path()
-
-    def _layout_rtl(self, cr, x, y, w, h, r, aw):
-        self.hadjustment = haw = -aw / 2
-
-        cr.move_to(x + haw, (h + y) / 2)
-        cr.line_to(x + aw + haw, y)
-        cr.line_to(x + w - haw + 1, y)
-        cr.line_to(x + w - aw - haw + 1, (y + h) / 2)
-        cr.line_to(x + w - haw + 1, y + h)
-        cr.line_to(x + aw + haw, y + h)
-        cr.close_path()
-
-
-class ShapeEndCap(Shape):
-
-    def __init__(self, direction=Gtk.TextDirection.LTR):
-        Shape.__init__(self, direction)
-        #~ self.draw_xoffset = -2
-        self._color = 0, 0, 1
-        self.name = 'EndCap'
-
-    def _layout_ltr(self, cr, x, y, w, h, r, aw):
-        self.hadjustment = haw = aw / 2
-
-        cr.move_to(x - haw - 1, y)
-        # rounded end
-        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)
-        # arrow
-        cr.line_to(x - haw - 1, y + h)
-        cr.line_to(x + haw - 1, y + (h / 2))
-        cr.close_path()
-
-    def _layout_rtl(self, cr, x, y, w, h, r, aw):
-        self.hadjustment = haw = -aw / 2
-
-        cr.arc(r + x, r + y, r, PI, 270 * PI_OVER_180)
-        cr.line_to(x + w - haw + 1, y)
-        cr.line_to(x + w - haw - aw + 1, (y + h) / 2)
-        cr.line_to(x + w - haw + 1, y + h)
-        cr.arc(r + x, y + h - r, r, 90 * PI_OVER_180, PI)
-        cr.close_path()
-
-
-class AnimationClock(GObject.GObject):
-    _1SECOND = 1000
-    __gsignals__ = {
-        "animation-frame": (GObject.SignalFlags.RUN_LAST,
-                                None,
-                                (float,),),
-
-        "animation-finished": (GObject.SignalFlags.RUN_FIRST,
-                                None,
-                                (bool,),),
-                    }
-
-    def __init__(self, fps, duration):
-        GObject.GObject.__init__(self)
-
-        self.fps = fps
-        self.in_progress = False
-        self.set_duration(duration)
-
-        self._clock = None
-        self._progress = 0  # progress as an msec offset
-
-    def _get_timstep(self):
-        d = self.duration
-        return max(10, int(d / ((d / AnimationClock._1SECOND) * self.fps)))
-
-    def _schedule_animation_frame(self):
-        if self._progress > self.duration:
-            self._clock = None
-            self.in_progress = False
-            self.emit('animation-finished', False)
-            return False
-
-        self._progress += self._timestep
-        self.emit('animation-frame', self.progress)
-        return True
-
-    @property
-    def progress(self):
-        return min(1.0, self._progress / self.duration)
-
-    def set_duration(self, duration):
-        self.duration = float(duration)
-        self._timestep = self._get_timstep()
-
-    def stop(self, who_called='?'):
-
-        if self._clock:
-            #~ print who_called+'.Stop'
-            GObject.source_remove(self._clock)
-            self.emit('animation-finished', True)
-
-        self._clock = None
-        self._progress = 0
-        self.in_progress = False
-
-    def start(self):
-        self.stop(who_called='start')
-        if not self.sequence:
-            return
-
-        self._clock = GObject.timeout_add(self._timestep,
-                                          self._schedule_animation_frame,
-                                          priority=100)
-        self.in_progress = True
-
-
-class PathBarAnimator(AnimationClock):
-    # animation display constants
-    FPS = 50
-    DURATION = 150  # spec says 150ms
-
-    # animation modes
-    NONE = 'animation-none'
-    OUT = 'animation-out'
-    IN = 'animation-in'
-    WIDTH_CHANGE = 'animation-width-change'
-
-    def __init__(self, pathbar):
-        AnimationClock.__init__(self, self.FPS, self.DURATION)
-
-        self.pathbar = pathbar
-        self.sequence = []
-
-        self.connect('animation-frame', self._on_animation_frame)
-        self.connect('animation-finished', self._on_animation_finished)
-
-    def _animate_out(self, part, progress, kwargs):
-        real_alloc = part.get_allocation()
-        xo = real_alloc.width - int(real_alloc.width * progress)
-
-        if self.pathbar.get_direction() == Gtk.TextDirection.RTL:
-            xo *= -1
-
-        anim_alloc = Gdk.Rectangle()
-        anim_alloc.x = real_alloc.x - xo
-        anim_alloc.y = real_alloc.y
-        anim_alloc.width = real_alloc.width
-        anim_alloc.height = real_alloc.height
-
-        part.new_frame(anim_alloc)
-
-    def _animate_in(self, part, progress, kwargs):
-        real_alloc = part.get_allocation()
-        xo = int(real_alloc.width * progress)
-
-        if self.pathbar.get_direction() == Gtk.TextDirection.RTL:
-            xo *= -1
-
-        anim_alloc = Gdk.Rectangle()
-        anim_alloc.x = real_alloc.x - xo
-        anim_alloc.y = real_alloc.y
-        anim_alloc.width = real_alloc.width
-        anim_alloc.height = real_alloc.height
-
-        part.new_frame(anim_alloc)
-
-    def _animate_width_change(self, part, progress, kwargs):
-        start_w = kwargs['start_width']
-        end_w = kwargs['end_width']
-
-        width = int(round(start_w + (end_w - start_w) * progress))
-        part.set_size_request(width, part.get_height_request())
-
-    def _on_animation_frame(self, clock, progress):
-        if not self.sequence:
-            return
-
-        for actor, animation, kwargs in self.sequence:
-            if animation == PathBarAnimator.NONE:
-                continue
-
-            if animation == PathBarAnimator.OUT:
-                self._animate_out(actor, progress, kwargs)
-
-            elif animation == PathBarAnimator.IN:
-                self._animate_in(actor, progress, kwargs)
-
-            elif animation == PathBarAnimator.WIDTH_CHANGE:
-                self._animate_width_change(actor, progress, kwargs)
-
-    def _on_animation_finished(self, clock, interrupted):
-        for actor, animation, kwargs in self.sequence:
-            actor.animation_finished()
-
-        self.sequence = []
-        self.pathbar.psuedo_parts = []
-        self.pathbar.queue_draw()
-
-    def append_animation(self, actor, animation, **kwargs):
-        self.sequence.append((actor, animation, kwargs))
-
-    def reset(self, who_called='?'):
-        AnimationClock.stop(self, who_called=who_called + '.reset')
-        self.sequence = []
-
-
-class PathBar(Gtk.HBox):
-
-    MIN_PART_WIDTH = 25  # pixels
-
-    def __init__(self):
-        GObject.GObject.__init__(self)
-        self.set_redraw_on_allocate(False)
-        self.set_size_request(-1, em(1.75))
-        self._allocation = None
-
-        # Accessibility info
-        atk_desc = self.get_accessible()
-        atk_desc.set_name(_("You are here:"))
-        atk_desc.set_role(Atk.Role.PANEL)
-
-        self.use_animations = True
-        self.animator = PathBarAnimator(self)
-
-        self.out_of_width = False
-        self.psuedo_parts = []
-
-        # used for certain button press logic
-        self._press_origin = None
-        # tracks the id of the revealer timeout
-        self._revealer = None
-
-        # values derived from the gtk settings
-        s = Gtk.Settings.get_default()
-        # time to wait before revealing a part on enter event in ms
-        self._timeout_reveal = s.get_property("gtk-tooltip-timeout")
-        # time to wait until emitting click event in ms
-        self._timeout_initial = s.get_property("gtk-timeout-initial")
-
-        # les signales!
-        self.connect('size-allocate', self._on_allocate)
-        self.connect('draw', self._on_draw)
-
-    # sugar
-    def __len__(self):
-        return len(self.get_children())
-
-    def __getitem__(self, index):
-        return self.get_children()[index]
-
-    # signal handlers
-    def _on_allocate(self, widget, _):
-        allocation = self.get_allocation()
-
-        if self._allocation == allocation:
-            return True
-
-        # prevent vertical bobby when the searchentry is shown/hidden
-        if allocation.height > self.get_property('height-request'):
-            self.set_property('height-request', allocation.height)
-
-        if not self._allocation:
-            self._allocation = allocation
-            self.queue_draw()
-            return True
-
-        pthbr_width = allocation.width
-        parts_width = self.get_parts_width()
-
-        #~ print parts_width, pthbr_width
-
-        #~ self.animator.reset('on_allocate')
-        self.set_use_animations(True)
-
-        if pthbr_width > parts_width and self.out_of_width:
-            dw = pthbr_width - parts_width
-            self._grow_parts(dw)
-
-        elif pthbr_width < parts_width:
-            overhang = parts_width - pthbr_width
-            if overhang > 0:
-                self.set_use_animations(False)
-                self._shrink_parts(overhang)
-
-        self._allocation = allocation
-        if self.use_animations and self.animator.sequence and not \
-            self.animator.in_progress:
-            self.animator.start()
-        else:
-            self.queue_draw()
-
-    def _on_draw(self, widget, cr):
-        # always paint psuedo parts first
-        a = self.get_allocation()
-        context = self.get_style_context()
-        context.save()
-        context.add_class("button")
-
-        self._paint_psuedo_parts(cr, context, a.x, a.y)
-
-        # paint a frame around the entire pathbar
-        width = self.get_parts_width()
-        Gtk.render_background(context, cr, 1, 1, width - 2, a.height - 2)
-
-        self._paint_widget_parts(cr, context, a.x, a.y)
-
-        Gtk.render_frame(context, cr, 0, 0, width, a.height)
-        context.restore()
-        return True
-
-    # private methods
-    def _paint_widget_parts(self, cr, context, xo, yo):
-        parts = self.get_children()
-        # paint in reverse order, so we get correct overlapping during
-        # animation
-        parts.reverse()
-        for part in parts:
-            part.paint(cr,
-                       part.animation_allocation or part.get_allocation(),
-                       context,
-                       xo, yo)
-
-    def _paint_psuedo_parts(self, cr, context, xo, yo):
-        # a special case: paint psuedo parts paint first,
-        # i.e those parts animating 'in' on their removal
-        for part in self.psuedo_parts:
-            part.paint(cr,
-                       part.animation_allocation or part.get_allocation(),
-                       context,
-                       xo, yo)
-
-    def _shrink_parts(self, overhang):
-        self.out_of_width = True
-
-        for part in self:
-            old_width = part.get_width_request()
-            new_width = max(self.MIN_PART_WIDTH, old_width - overhang)
-
-            if False:  # self.use_animations:
-                self.animator.append_animation(part,
-                                               PathBarAnimator.WIDTH_CHANGE,
-                                               start_width=old_width,
-                                               end_width=new_width)
-            else:
-                part.set_size_request(new_width,
-                                      part.get_height_request())
-
-            overhang -= old_width - new_width
-            if overhang <= 0:
-                break
-
-    def _grow_parts(self, claim):
-        children = self.get_children()
-        children.reverse()
-
-        for part in children:
-
-            if part.get_allocation().width == part.get_natural_width():
-                continue
-
-            growth = min(claim, (part.get_natural_width() - part.width))
-            if growth <= 0:
-                break
-
-            claim -= growth
-
-            if self.use_animations:
-                self.animator.append_animation(part,
-                                               PathBarAnimator.WIDTH_CHANGE,
-                                               start_width=part.width,
-                                               end_width=part.width + growth)
-            else:
-                part.set_size_request(part.width + growth,
-                                      part.get_height_request())
-
-    def _make_space(self, part):
-        children = self.get_children()
-        if not children:
-            return
-
-        cur_width = self.get_parts_width()
-        incomming_width = cur_width + part.get_width_request()
-        overhang = incomming_width - self.get_allocation().width
-
-        if overhang > 0:
-            print 'shrink parts by:', overhang
-            self._shrink_parts(overhang)
-
-    def _reclaim_space(self, part):
-        if not self.out_of_width:
-            return
-
-        claim = part.get_width_request()
-        self._grow_parts(claim)
-
-    def _append_compose_parts(self, new_part):
-        d = self.get_direction()
-        children = self.get_children()
-        n_parts = len(children)
-
-        if n_parts > 0:
-            new_part.set_shape(ShapeEndCap(d))
-            first_part = children[0]
-            first_part.set_shape(ShapeStartArrow(d))
-        else:
-            new_part.set_shape(ShapeRoundedRect(d))
-
-        if not n_parts > 1:
-            return
-
-        new_mid = children[-1]
-        new_mid.set_shape(ShapeMidArrow(d))
-
-    def _remove_compose_parts(self):
-        d = self.get_direction()
-        children = self.get_children()
-        n_parts = len(children)
-
-        if n_parts == 0:
-            return
-
-        elif n_parts == 1:
-            children[0].set_shape(ShapeRoundedRect(d))
-            return
-
-        last = children[-1]
-        last.set_shape(ShapeEndCap(d))
-        self.queue_draw()
-
-    def _cleanup_revealer(self):
-        if not self._revealer:
-            return
-        GObject.source_remove(self._revealer)
-        self._revealer = None
-
-    def _theme(self, part):
-        #~ part.set_padding(self.theme['xpad'], self.theme['ypad'])
-        part.set_padding(12, 4)
-
-    # public methods
-    @property
-    def first_part(self):
-        children = self.get_children()
-        if children:
-            return children[0]
-
-    @property
-    def last_part(self):
-        children = self.get_children()
-        if children:
-            return children[-1]
-
-    def reveal_part(self, part, animate=True):
-        # do not do here:
-        #~ self.animator.reset(who_called='reveal_animation')
-        self.set_use_animations(animate)
-
-        part_old_width = part.get_width_request()
-        part_new_width = part.get_natural_width()
-
-        if part_new_width == part_old_width:
-            return
-
-        change_amount = part_new_width - part_old_width
-
-        for p in self.get_children():
-
-            if p == part:
-                old_width = part_old_width
-                new_width = part_new_width
-            else:
-                if change_amount <= 0:
-                    continue
-
-                old_width = p.get_width_request()
-                new_width = max(self.MIN_PART_WIDTH, old_width - change_amount)
-                change_amount -= old_width - new_width
-
-            if self.use_animations:
-                self.animator.append_animation(p,
-                                               PathBarAnimator.WIDTH_CHANGE,
-                                               start_width=old_width,
-                                               end_width=new_width)
-            else:
-                p.set_size_request(new_width,
-                                   p.get_height_request())
-
-        self.animator.start()
-
-    def queue_reveal_part(self, part):
-
-        def reveal_part_cb(part):
-            self.reveal_part(part)
-            return
-
-        self._cleanup_revealer()
-        self._revealer = GObject.timeout_add(self._timeout_reveal,
-                                             reveal_part_cb,
-                                             part)
-
-    def get_parts_width(self):
-        last = self.last_part
-        if not last:
-            return 0
-
-        if self.get_direction() != Gtk.TextDirection.RTL:
-            return last.x + last.width - self.first_part.x
-
-        first = self.first_part
-        return first.x + first.width - last.x
-
-    def get_visual_width(self):
-        last = self.last_part
-        first = self.first_part
-        if not last:
-            return 0
-
-        la = last.animation_allocation or last.get_allocation()
-        fa = first.animation_allocation or first.get_allocation()
-
-        if self.get_direction() != Gtk.TextDirection.RTL:
-            return la.x + la.width - fa.x
-
-        return fa.x + fa.width - la.x
-
-    def set_use_animations(self, use_animations):
-        self.use_animations = use_animations
-        if not use_animations and self.animator.in_progress:
-            self.animator.reset()
-
-    def append(self, part):
-        print 'append', part
-        print
-        part.set_nopaint(True)
-        self.animator.reset('append')
-
-        self._theme(part)
-        self._append_compose_parts(part)
-        self._make_space(part)
-
-        self.pack_start(part, False, False, 0)
-        part.show()
-
-        if self.use_animations:
-            # XXX: please note that animations also get queued up
-            #      within _shrink_parts()
-            self.animator.append_animation(part, PathBarAnimator.OUT)
-            #~ print self.animator.sequence
-            self.animator.start()
-        else:
-            part.set_nopaint(False)
-            part.queue_draw()
-
-    def pop(self):
-        children = self.get_children()
-        if not children:
-            return
-
-        self.animator.reset('pop')
-
-        last = children[-1]
-        if self.use_animations:
-            # because we remove the real part immediately we need to
-            # replicate just enough attributes to preform the slide in
-            # animation
-            part = PsuedoPathPart(self, last)
-            self.psuedo_parts.append(part)
-
-        self.remove(last)
-
-        self._remove_compose_parts()
-        self._reclaim_space(last)
-
-        last.destroy()
-
-        if not self.use_animations:
-            return
-
-        self.animator.append_animation(part, PathBarAnimator.IN)
-        self.animator.start()
-
-    def navigate_up(self):
-        """ just another name for pop() """
-        self.pop()
-
-
-class PathPartCommon:
-
-    def __init__(self):
-        self.animation_in_progress = False
-        self.animation_allocation = None
-
-    @property
-    def x(self):
-        return self.get_allocation().x
-
-    @property
-    def y(self):
-        return self.get_allocation().y
-
-    @property
-    def width(self):
-        return self.get_allocation().width
-
-    @property
-    def height(self):
-        return self.get_allocation().height
-
-    def new_frame(self, allocation):
-        if self.is_nopaint:
-            self.is_nopaint = False
-        if not self.animation_in_progress:
-            self.animation_in_progress = True
-
-        self.animation_allocation = allocation
-        self.queue_draw()
-
-    def animation_finished(self):
-        self.animation_in_progress = False
-        self.animation_allocation = None
-        if self.get_parent():
-            self.get_parent().queue_draw()
-
-    def paint(self, cr, a, context, xo, yo):
-        if self.is_nopaint:
-            return
-
-        cr.save()
-
-        x, y = 0, 0
-        w, h = a.width, a.height
-        arrow_width = 12  # theme['arrow-width']
-
-        if isinstance(self, PathPart):
-            _a = self.get_allocation()
-            self.shape.layout(cr,
-                              _a.x - xo + 1, _a.y - yo,
-                              w, h, 3, arrow_width)
-            cr.clip()
-        else:
-            Gtk.render_background(context, cr,
-                                  a.x - xo - 10, a.y - yo,
-                                  a.width + 10, a.height)
-
-        cr.translate(a.x - xo, a.y - yo)
-
-        if self.shape.name.find('Arrow') != -1:
-            # draw arrow head
-            cr.move_to(w - arrow_width / 2, 2)
-            cr.line_to(w + 5, h / 2)
-            cr.line_to(w - arrow_width / 2, h - 2)
-            # fetch the line color and stroke
-            rgba = context.get_border_color(Gtk.StateFlags.NORMAL)
-            cr.set_source_rgb(rgba.red, rgba.green, rgba.blue)
-            cr.set_line_width(1)
-            cr.stroke()
-
-        # render the layout
-        e = self.layout.get_pixel_extents()[1]
-        lw, lh = e.width, e.height
-        pw, ph = a.width, a.height
-
-        x = min(self.xpadding, (pw - lw) / 2)
-        y = (ph - lh) / 2
-
-        # layout area
-        Gtk.render_layout(context,
-                          cr,
-                          int(x),
-                          int(y),
-                          self.layout)
-
-        # paint the focus frame if need be
-        if isinstance(self, PathPart) and self.has_focus():
-            # layout area
-            x, w, h = x - 2, lw + 4, lh + 1
-            Gtk.render_focus(context, cr, x, y, w, h)
-
-        cr.restore()
-
-
-class PsuedoPathPart(PathPartCommon):
-
-    def __init__(self, pathbar, real_part):
-        PathPartCommon.__init__(self)
-        self.parent = pathbar
-        self.style = pathbar.get_style()
-        self.state = real_part.get_state()
-        self.allocation = real_part.get_allocation()
-        self.size_request = real_part.get_size_request()
-        self.xpadding = real_part.xpadding
-        self.ypadding = real_part.ypadding
-
-        # PsuedoPathParts are only used during the remove animation
-        # sequence, so the shape is always a ShapeEndCap
-        self.shape = ShapeEndCap(pathbar.get_direction())
-
-        self.label = real_part.label
-        self.layout = real_part.create_pango_layout(self.label)
-
-        self.is_nopaint = False
-
-    def get_allocation(self):
-        return self.allocation
-
-    def get_state(self):
-        return self.state
-
-    def get_width_request(self):
-        return self.size_request[0]
-
-    def get_height_request(self):
-        return self.size_request[1]
-
-    def animation_finished(self):
-        pass
-
-    def queue_draw(self):
-        a = self.allocation
-        aw = 12
-        self.parent.queue_draw_area(a.x - aw / 2, a.y,
-                                    a.width + aw, a.height)
-
-
-class PathPart(Gtk.EventBox, PathPartCommon):
-
-    __gsignals__ = {
-        "clicked": (GObject.SignalFlags.RUN_LAST,
-                     None,
-                     (),),
-        }
-
-    def __init__(self, label):
-        Gtk.EventBox.__init__(self)
-        PathPartCommon.__init__(self)
-        self.set_visible_window(False)
-
-        self.atk = self.get_accessible()
-        self.atk.set_role(Atk.Role.PUSH_BUTTON)
-
-        self.layout = self.create_pango_layout(label)
-        self.layout.set_ellipsize(Pango.EllipsizeMode.END)
-
-        self.xpadding = 6
-        self.ypadding = 3
-
-        self.shape = ShapeRoundedRect(self.get_direction())
-        self.is_nopaint = False
-
-        self.set_label(label)
-        self._init_event_handling()
-
-    def __repr__(self):
-        return "PathPart: '%s'" % self.label
-
-    def __str__(self):
-        return "PathPart: '%s'" % self.label
-
-    # signal handlers
-    def _on_enter_notify(self, part, event):
-        self.pathbar.queue_reveal_part(self)
-        if self.pathbar._press_origin == part:
-            part.set_state(Gtk.StateFlags.ACTIVE)
-        else:
-            part.set_state(Gtk.StateFlags.PRELIGHT)
-        self.queue_draw()
-
-    def _on_leave_notify(self, part, event):
-        self.pathbar.queue_reveal_part(self.pathbar.last_part)
-        part.set_state(Gtk.StateFlags.NORMAL)
-        self.queue_draw()
-
-    def _on_button_press(self, part, event):
-        if event.button != 1:
-            return
-        self.pathbar._press_origin = part
-        part.set_state(Gtk.StateFlags.ACTIVE)
-        self.queue_draw()
-
-    def _on_button_release(self, part, event):
-        if event.button != 1:
-            return
-
-        if self.pathbar._press_origin != part:
-            self.pathbar._press_origin = None
-            return
-
-        self.pathbar._press_origin = None
-
-        state = part.get_state()
-        if state == Gtk.StateFlags.ACTIVE:
-            part.set_state(Gtk.StateFlags.PRELIGHT)
-            GObject.timeout_add(self.pathbar._timeout_initial,
-                                self.emit, 'clicked')
-
-        self.queue_draw()
-
-    def _on_key_press(self, part, event):
-        if event.keyval in (Gdk.KEY_space, Gdk.KEY_Return, Gdk.KEY_KP_Enter):
-            part.set_state(Gtk.StateFlags.ACTIVE)
-        self.queue_draw()
-
-    def _on_key_release(self, part, event):
-        if event.keyval in (Gdk.KEY_space, Gdk.KEY_Return, Gdk.KEY_KP_Enter):
-            part.set_state(Gtk.StateFlags.NORMAL)
-            GObject.timeout_add(self.pathbar._timeout_initial,
-                                self.emit, 'clicked')
-        self.queue_draw()
-
-    def _on_focus_in(self, part, event):
-        self.pathbar.reveal_part(self)
-
-    def _on_focus_out(self, part, event):
-        self.queue_draw()
-
-    # private methods
-    def _init_event_handling(self):
-        self.set_property("can-focus", True)
-        self.set_events(Gdk.EventMask.BUTTON_PRESS_MASK |
-                        Gdk.EventMask.BUTTON_RELEASE_MASK |
-                        Gdk.EventMask.KEY_RELEASE_MASK |
-                        Gdk.EventMask.KEY_PRESS_MASK |
-                        Gdk.EventMask.ENTER_NOTIFY_MASK |
-                        Gdk.EventMask.LEAVE_NOTIFY_MASK)
-
-        self.connect("enter-notify-event", self._on_enter_notify)
-        self.connect("leave-notify-event", self._on_leave_notify)
-        self.connect("button-press-event", self._on_button_press)
-        self.connect("button-release-event", self._on_button_release)
-        self.connect("key-press-event", self._on_key_press)
-        self.connect("key-release-event", self._on_key_release)
-        self.connect("focus-in-event", self._on_focus_in)
-        self.connect("focus-out-event", self._on_focus_out)
-
-    def _calc_natural_size(self, who_called='?'):
-        ne = self.natural_extents
-        nw, nh = ne.width, ne.height
-
-        nw += self.shape.hadjustment + 2 * self.xpadding
-        nh += 2 * self.ypadding
-
-        self.natural_size = nw, nh
-        self.set_size_request(nw, nh)
-
-    # public methods
-    @property
-    def pathbar(self):
-        return self.get_parent()
-
-    def set_padding(self, xpadding, ypadding):
-        self.xpadding = xpadding
-        self.ypadding = ypadding
-        self._calc_natural_size()
-
-    def set_size_request(self, width, height):
-        width = max(2 * self.xpadding + 1, width)
-        height = max(2 * self.ypadding + 1, height)
-        self.layout.set_width(Pango.SCALE * (width - 2 * self.xpadding))
-        Gtk.Widget.set_size_request(self, width, height)
-
-    def set_nopaint(self, is_nopaint):
-        self.is_nopaint = is_nopaint
-        self.queue_draw()
-
-    def set_shape(self, shape):
-        if shape == self.shape:
-            return
-        self.shape = shape
-        self._calc_natural_size()
-        self.queue_draw()
-
-    def set_label(self, label):
-        self.label = label
-
-        self.atk.set_name(label)
-        self.atk.set_description(_('Navigates to the %s page.') % label)
-
-        self.layout.set_markup(label, -1)
-        self.layout.set_width(-1)
-        self.natural_extents = self.layout.get_pixel_extents()[1]
-
-        self._calc_natural_size()
-        self.queue_draw()
-
-    def get_natural_size(self):
-        return self.natural_size
-
-    def get_natural_width(self):
-        return self.natural_size[0]
-
-    def get_natural_height(self):
-        return self.natural_size[1]
-
-    def get_width_request(self):
-        return self.get_property("width-request")
-
-    def get_height_request(self):
-        return self.get_property("height-request")
-
-    def queue_draw(self):
-        a = self.get_allocation()
-        parent = self.get_parent()
-        if parent:
-            aw = 12
-        else:
-            aw = 0
-        self.queue_draw_area(a.x - aw / 2, a.y,
-                             a.width + aw, a.height)
-
-
-class NavigationBar(PathBar):
-
-    def __init__(self, group=None):
-        PathBar.__init__(self)
-        self.id_to_part = {}
-        self._callback_id = None
-
-    def _on_part_clicked(self, part):
-        part.callback(self, part)
-
-    def add_with_id(self, label, callback, id, do_callback=True, animate=True):
-        """
-        Add a new button with the given label/callback
-
-        If there is the same id already, replace the existing one
-        with the new one
-        """
-        LOG.debug("add_with_id label='%s' callback='%s' id='%s' "
-                  "do_callback=%s animate=%s" % (label, callback, id,
-                                                 do_callback, animate))
-
-        label = GObject.markup_escape_text(label)
-
-        if not self.id_to_part:
-            self.set_use_animations(False)
-        else:
-            self.set_use_animations(animate)
-
-        # check if we have the button of that id or need a new one
-        if id in self.id_to_part:
-            part = self.id_to_part[id]
-            if part.label == label:
-                return
-
-            part.set_label(label)
-        else:
-            part = PathPart(label)
-            part.connect('clicked', self._on_part_clicked)
-
-            part.set_name(id)
-            self.id_to_part[id] = part
-
-            part.callback = callback
-            if do_callback:
-                # cleanup any superceeded idle callback
-                if self._callback_id:
-                    GObject.source_remove(self._callback_id)
-                    self._callback_id = None
-
-                # if i do not have call the callback in an idle,
-                # all hell breaks loose
-                self._callback_id = GObject.idle_add(callback,
-                                                     self,      # pathbar
-                                                     part)
-
-            self.append(part)
-
-    def remove_ids(self, *ids, **kwargs):
-        parts = self.get_parts()
-
-        print 'remove ids', ids
-
-        # it would seem parts can become stale within the id_to_part dict,
-        # so we clean these up ...
-        cleanup_ids = []
-        # the index of the first part to be clipped
-        index = len(parts)
-
-        for id, part in self.id_to_part.iteritems():
-            if id not in ids:
-                continue
-            if part not in parts:
-                cleanup_ids.append(id)
-                part.destroy()
-            else:
-                index = min(index, parts.index(part))
-
-        if index == len(parts):
-            return
-
-        # cleanup any stale id:part pairs in the id_to_part dict
-        for id in cleanup_ids:
-            del self.id_to_part[id]
-
-        # remove id:part pairs from the id_to_part dict, for whom removal
-        # has been requested
-        for id in ids:
-            if id in self.id_to_part:
-                del self.id_to_part[id]
-
-        #~ print index, self.id_to_part.keys()
-
-        # the index is used to remove all parts after the index but we
-        # keep one part around to animate its removal
-        for part in parts[index + 1:]:
-            part.destroy()
-
-        animate = True
-        if 'animate' in kwargs:
-            animate = kwargs['animate']
-
-        # animate the removal of the final part, or not
-        self.set_use_animations(animate)
-        self.pop()
-
-        # check if we should call the new tail parts callback
-        if 'do_callback' in kwargs and kwargs['do_callback']:
-            part = self[-1]
-            part.callback(self, part)
-
-    def remove_all(self, **kwargs):
-        if len(self) <= 1:
-            return
-        ids = filter(lambda k: k != 'category',
-                     self.id_to_part.keys())
-        self.remove_ids(*ids, **kwargs)
-
-    def has_id(self, id):
-        return id in self.id_to_part
-
-    def get_parts(self):
-        return self.get_children()
-
-    def get_active(self):
-        parts = self.get_parts()
-        if parts:
-            return parts[-1]
-
-    def get_button_from_id(self, id):
-        """
-        return the button for the given id (or None)
-        """
-        return self.id_to_part.get(id)
-
-    def set_active_no_callback(self, part):
-        pass
-
-
-class TestIt:
-
-    def __init__(self):
-
-        def append(button, entry, pathbar):
-            t = entry.get_text() or 'no label %s' % len(pathbar)
-            part = PathPart(t)
-            pathbar.append(part)
-
-        def remove(button, entry, pathbar):
-            pathbar.pop()
-
-        win = Gtk.Window()
-        win.set_border_width(30)
-        win.set_size_request(600, 300)
-
-        vb = Gtk.VBox(spacing=6)
-        win.add(vb)
-
-        pb = PathBar()
-        pb.set_size_request(-1, 30)
-
-        vb.pack_start(pb, False, False, 0)
-        part = PathPart('Get Software')
-        pb.append(part)
-
-        entry = Gtk.Entry()
-        vb.pack_start(entry, False, False, 0)
-
-        b = Gtk.Button('Append')
-        vb.pack_start(b, True, True, 0)
-        b.connect('clicked', append, entry, pb)
-
-        b = Gtk.Button('Remove')
-        vb.pack_start(b, True, True, 0)
-        b.connect('clicked', remove, entry, pb)
-
-        win.show_all()
-
-        win.connect('destroy', Gtk.main_quit)
-        self.win = win
-        self.win.pb = pb
-
-
-def get_test_pathbar_window():
-    t = TestIt()
-    return t.win
-
-if __name__ == '__main__':
-    win = get_test_pathbar_window()
-    Gtk.main()