Merge lp:~mmcg069/software-center/pathbar-atk into lp:software-center

[Matthew McGowan]

most notable:
* Modify PathBar to now use gtk.EventBox's for PathPart's
* Enable atk accessibility support
* Pathbar now provides for keyboard navigation, complete with focus box drawing
* Improve theme coverage
* All features of old PathBar retained in shift to new PathBar design

other:
* Tweak navhistory behaviour to better work with new Pathbar
* Other minor tweaks

=== modified file 'softwarecenter/app.py'
--- softwarecenter/app.py	2010-04-01 19:48:40 +0000
+++ softwarecenter/app.py	2010-04-04 06:00:32 +0000
@@ -214,7 +214,8 @@
 
         # default focus
         self.available_pane.searchentry.grab_focus()
-        
+        self.window_main.set_size_request(600, 400)
+
         # restore state
         self.config = get_config()
         self.restore_state()
@@ -561,7 +562,7 @@
     def restore_state(self):
         if self.config.has_option("general", "size"):
             (x, y) = self.config.get("general", "size").split(",")
-            self.window_main.resize(int(x), int(y))
+            self.window_main.set_default_size(int(x), int(y))
         if (self.config.has_option("general", "maximized") and
             self.config.getboolean("general", "maximized")):
             self.window_main.maximize()
 
=== modified file 'softwarecenter/view/appview.py'
--- softwarecenter/view/appview.py	2010-04-01 19:48:40 +0000
+++ softwarecenter/view/appview.py	2010-04-04 06:00:32 +0000
@@ -96,6 +96,7 @@
                     data further. A python function that gets a pkgname
         """
         gtk.GenericTreeModel.__init__(self)
+        self.search_query = search_query
         self.cache = cache
         self.db = db
         self.icons = icons
@@ -258,7 +259,7 @@
                 summary = app.pkgname
             if self.db.is_appname_duplicated(appname):
                 appname = "%s (%s)" % (appname, app.pkgname)
-            s = "%s\n<small>%s</small>" % (
+            s = "<b>%s</b>\n<small>%s</small>" % (
                 gobject.markup_escape_text(appname),
                 gobject.markup_escape_text(summary))
             return s
@@ -900,7 +901,9 @@
         """
         (path, column) = self.get_cursor()
         model = self.get_model()
-        action_in_progress = (model[path][AppStore.COL_ACTION_IN_PROGRESS] != -1)
+        action_in_progress = False
+        if path:
+            action_in_progress = (model[path][AppStore.COL_ACTION_IN_PROGRESS] != -1)
         return action_in_progress
 
     def _on_realize(self, widget, tr):
@@ -948,7 +951,9 @@
     def _on_cursor_changed(self, view):
         # trigger callback, if we do it here get_selection() returns
         # the previous selected row for some reason
-        gobject.timeout_add(10, self._app_selected_timeout_cb, view)
+
+        # mvo: can we make this timeout 1? The AppView is much nicer this way...
+        gobject.timeout_add(1, self._app_selected_timeout_cb, view)
 
     def _app_selected_timeout_cb(self, view):
         selection = view.get_selection()
 
=== modified file 'softwarecenter/view/availablepane.py'
--- softwarecenter/view/availablepane.py	2010-03-05 15:53:27 +0000
+++ softwarecenter/view/availablepane.py	2010-04-04 06:00:32 +0000
@@ -48,7 +48,7 @@
     (PAGE_CATEGORY,
      PAGE_APPLIST,
      PAGE_APP_DETAILS) = range(3)
-     
+
     # define ID values for the various buttons found in the navigation bar
     NAV_BUTTON_ID_CATEGORY = "category"
     NAV_BUTTON_ID_LIST     = "list"
@@ -73,14 +73,14 @@
         self.connect("app-list-changed", self._on_app_list_changed)
         self.current_app_by_category = {}
         self.current_app_by_subcategory = {}
+        # track navigation history
+        self.nav_history = NavigationHistory(self)
         # UI
         self._build_ui()
-        # track navigation history
-        self.nav_history = NavigationHistory(self)
 
     def _build_ui(self):
         # categories, appview and details into the notebook in the bottom
-        self.cat_view = CategoriesView(self.datadir, APP_INSTALL_PATH, 
+        self.cat_view = CategoriesView(self.datadir, APP_INSTALL_PATH,
                                        self.db,
                                        self.icons)
         scroll_categories = gtk.ScrolledWindow()
@@ -88,8 +88,8 @@
         scroll_categories.add(self.cat_view)
         self.notebook.append_page(scroll_categories, gtk.Label("categories"))
         # sub-categories view
-        self.subcategories_view = CategoriesView(self.datadir, 
-                                                 APP_INSTALL_PATH, 
+        self.subcategories_view = CategoriesView(self.datadir,
+                                                 APP_INSTALL_PATH,
                                                  self.db,
                                                  self.icons,
                                                  self.cat_view.categories[0])
@@ -108,7 +108,7 @@
         self.top_hbox.pack_start(self.back_forward, expand=False, padding=self.PADDING)
         # nav buttons first in the panel
         self.top_hbox.reorder_child(self.back_forward, 0)
-        # now a vbox for subcategories and applist 
+        # now a vbox for subcategories and applist
         apps_vbox = gtk.VPaned()
         apps_vbox.pack1(self.scroll_subcategories, resize=True)
         apps_vbox.pack2(self.scroll_app_list)
@@ -120,9 +120,10 @@
         # set status text
         self._update_status_text(len(self.db))
         # home button
-        self.navigation_bar.add_with_id(_("Get Software"), 
+        self.navigation_bar.add_with_id(_("Get Software"),
                                         self.on_navigation_category,
                                         self.NAV_BUTTON_ID_CATEGORY,
+                                        do_callback=True,
                                         animate=False)
 
     def _get_query(self):
@@ -137,7 +138,7 @@
         elif self.apps_category:
             cat_query = self.apps_category.query
         # mix category with the search terms and return query
-        return self.db.get_query_list_from_search_entry(self.apps_search_term, 
+        return self.db.get_query_list_from_search_entry(self.apps_search_term,
                                                         cat_query)
 
     def _in_no_display_category(self):
@@ -150,7 +151,7 @@
     def _show_hide_subcategories(self):
         # check if have subcategories and are not in a subcategory
         # view - if so, show it
-        if (self.apps_category and 
+        if (self.apps_category and
             self.apps_category.subcategories and
             not (self.apps_search_term or self.apps_subcategory)):
             self.scroll_subcategories.show()
@@ -163,16 +164,16 @@
         # not hide it
         model = self.app_view.get_model()
         if (model and
-            len(model) == 0 and 
+            len(model) == 0 and
             self.apps_category and
-            self.apps_category.subcategories and 
+            self.apps_category.subcategories and
             not self.apps_subcategory):
             self.scroll_app_list.hide()
         else:
             self.scroll_app_list.show()
 
     def refresh_apps(self):
-        """refresh the applist after search changes and update the 
+        """refresh the applist after search changes and update the
            navigation bar
         """
         logging.debug("refresh_apps")
@@ -185,18 +186,28 @@
     def _refresh_apps_with_apt_cache(self):
         # build query
         query = self._get_query()
-        logging.debug("availablepane query: %s" % query)
-        # *ugh* deactivate the old model because otherwise it keeps
-        # getting progress_changed events and eats CPU time until its
-        # garbage collected
+
         old_model = self.app_view.get_model()
         if old_model is not None:
-            old_model.active = False
+            # check if new AppStore query == old query.  if yes, do nothing
+            if isinstance(old_model, AppStore) and \
+                str(old_model.search_query) == str(query):
+                # check if we show subcategoriy
+                self._show_hide_applist()
+                self.emit("app-list-changed", len(old_model))
+                return
+            else:
+                # *ugh* deactivate the old model because otherwise it keeps
+                # getting progress_changed events and eats CPU time until its
+                # garbage collected
+                old_model.active = False
+
+        logging.debug("availablepane query: %s" % query)
         # create new model and attach it
         new_model = AppStore(self.cache,
-                             self.db, 
-                             self.icons, 
-                             query, 
+                             self.db,
+                             self.icons,
+                             query,
                              limit=self.apps_limit,
                              sort=self.apps_sorted,
                              filter=self.apps_filter)
@@ -210,15 +221,14 @@
         """Update the navigation button"""
         if self.apps_category and not self.apps_search_term:
             cat =  self.apps_category.name
-            self.navigation_bar.add_with_id(cat, 
+            self.navigation_bar.add_with_id(cat,
                                             self.on_navigation_list,
-                                            self.NAV_BUTTON_ID_LIST,
-                                            None)
+                                            self.NAV_BUTTON_ID_LIST, True)
+
         elif self.apps_search_term:
             self.navigation_bar.add_with_id(_("Search Results"),
-                                            self.on_navigation_search, 
-                                            self.NAV_BUTTON_ID_SEARCH,
-                                            None)
+                                            self.on_navigation_search,
+                                            self.NAV_BUTTON_ID_SEARCH, True)
 
     # status text woo
     def get_status_text(self):
@@ -228,7 +238,7 @@
             self._in_no_display_category()):
             return ""
         return self._status_text
-        
+
     def get_current_app(self):
         """return the current active application object"""
         if self.is_category_view_showing():
@@ -238,13 +248,13 @@
                 return self.current_app_by_subcategory.get(self.apps_subcategory)
             else:
                 return self.current_app_by_category.get(self.apps_category)
-    
+
     def _on_app_list_changed(self, pane, length):
         """internal helper that keeps the status text up-to-date by
            keeping track of the app-list-changed signals
         """
         self._update_status_text(length)
-                                                 
+
     def _update_status_text(self, length):
         """
         update the text in the status bar
@@ -280,11 +290,17 @@
         self.apps_search_term = ""
         self.navigation_bar.remove_id(self.NAV_BUTTON_ID_SEARCH)
 
+    def _check_nav_history(self, display_cb):
+        if self.navigation_bar.get_last().label != self.nav_history.get_last_label():
+            nav_item = NavigationItem(self, display_cb)
+            self.nav_history.navigate_no_cursor_step(nav_item)
+        return
+
     # callbacks
     def on_cache_ready(self, cache):
         """ refresh the application list when the cache is re-opened """
-        # just re-draw in the available pane, nothing but the 
-        # "is-installed" overlay icon will change when something 
+        # just re-draw in the available pane, nothing but the
+        # "is-installed" overlay icon will change when something
         # is installed or removed in the available pane
         self.app_view.queue_draw()
 
@@ -322,67 +338,89 @@
         self.refresh_apps()
         self._show_category_overview()
 
+    def display_category(self):
+        self._clear_search()
+        self._show_category_overview()
+        return
+
+    def display_search(self):
+        self.navigation_bar.remove_id(self.NAV_BUTTON_ID_DETAILS)
+        self.notebook.set_current_page(self.PAGE_APPLIST)
+        self.emit("app-list-changed", len(self.app_view.get_model()))
+        self.searchentry.show()
+        return
+
+    def display_list(self):
+        self.navigation_bar.remove_id(self.NAV_BUTTON_ID_SUBCAT)
+        self.navigation_bar.remove_id(self.NAV_BUTTON_ID_DETAILS)
+
+        if self.apps_subcategory:
+            self.apps_subcategory = None
+        self.set_category(self.apps_category)
+        if self.apps_search_term:
+            self._clear_search()
+            self.refresh_apps()
+
+        self.notebook.set_current_page(self.PAGE_APPLIST)
+        model = self.app_view.get_model()
+        self.emit("app-list-changed", len(model))
+        self.searchentry.show()
+        return
+
+    def display_list_subcat(self):
+        if self.apps_search_term:
+            self._clear_search()
+            self.refresh_apps()
+        self.set_category(self.apps_subcategory)
+        self.navigation_bar.remove_id(self.NAV_BUTTON_ID_DETAILS)
+        self.notebook.set_current_page(self.PAGE_APPLIST)
+        self.emit("app-list-changed", len(self.app_view.get_model()))
+        self.searchentry.show()
+        return
+
+    def display_details(self):
+        self.notebook.set_current_page(self.PAGE_APP_DETAILS)
+        self.searchentry.hide()
+        return
+
     def on_navigation_category(self, pathbar, part):
         """callback when the navigation button with id 'category' is clicked"""
-        if pathbar and not pathbar.get_active():
-            return
         # clear the search
-        self._clear_search()
-        self._show_category_overview()
-        self.nav_history.navigate(CategoryViewNavigationItem(self))
+        self.display_category()
+        nav_item = NavigationItem(self, self.display_category)
+        self.nav_history.navigate(nav_item)
 
     def on_navigation_search(self, pathbar, part):
         """ callback when the navigation button with id 'search' is clicked"""
-        self.navigation_bar.remove_id(self.NAV_BUTTON_ID_DETAILS)
-        self.notebook.set_current_page(self.PAGE_APPLIST)
-        self.emit("app-list-changed", len(self.app_view.get_model()))
-        self.nav_history.navigate(SearchNavigationItem(self))
-        self.searchentry.show()
+        self.display_search()
+        nav_item = NavigationItem(self, self.display_search)
+        self.nav_history.navigate(nav_item)
 
     def on_navigation_list(self, pathbar, part):
         """callback when the navigation button with id 'list' is clicked"""
-        if pathbar and not pathbar.get_active():
-            return
-        self.navigation_bar.remove_id(self.NAV_BUTTON_ID_SUBCAT)
-        self.navigation_bar.remove_id(self.NAV_BUTTON_ID_DETAILS)
-        if self.apps_subcategory:
-            self.apps_subcategory = None
-        self.set_category(self.apps_category)
-        if self.apps_search_term:
-            self._clear_search()
-            self.refresh_apps()
-        self.notebook.set_current_page(self.PAGE_APPLIST)
-        model = self.app_view.get_model()
-        self.emit("app-list-changed", len(model))
-        self.searchentry.show()
-        self.nav_history.navigate(AppListNavigationItem(self))
+        self.display_list()
+        nav_item = NavigationItem(self, self.display_list)
+        self.nav_history.navigate(nav_item)
 
     def on_navigation_list_subcategory(self, pathbar, part):
-        if pathbar and not pathbar.get_active():
-            return
-        if self.apps_search_term:
-            self._clear_search()
-            self.refresh_apps()
-        self.set_category(self.apps_subcategory)
-        self.navigation_bar.remove_id(self.NAV_BUTTON_ID_DETAILS)
-        self.notebook.set_current_page(self.PAGE_APPLIST)
-        self.emit("app-list-changed", len(self.app_view.get_model()))
-        self.searchentry.show()
-        self.nav_history.navigate(AppListSubcategoryNavigationItem(self))
+        self.display_list_subcat()
+        nav_item = NavigationItem(self, self.display_list_subcat)
+        self.nav_history.navigate(nav_item)
 
     def on_navigation_details(self, pathbar, part):
         """callback when the navigation button with id 'details' is clicked"""
-        if pathbar and not pathbar.get_active():
-            return
-        self.notebook.set_current_page(self.PAGE_APP_DETAILS)
-        self.searchentry.hide()
-        self.nav_history.navigate(AppDetailsNavigationItem(self))
+        self.display_details()
+        nav_item = NavigationItem(self, self.display_details)
+        self.nav_history.navigate(nav_item)
 
     def on_subcategory_activated(self, cat_view, category):
         #print cat_view, name, query
         logging.debug("on_subcategory_activated: %s %s" % (
                 category.name, category))
         self.apps_subcategory = category
+
+        #self._check_nav_history(self.display_list)
+
         self.navigation_bar.add_with_id(
             category.name, self.on_navigation_list_subcategory, self.NAV_BUTTON_ID_SUBCAT)
 
@@ -392,21 +430,24 @@
                 category.name, category))
         self.apps_category = category
         self.set_category(category)
-        
+
     def on_application_selected(self, appview, app):
         """callback when an app is selected"""
         logging.debug("on_application_selected: '%s'" % app)
+
         if self.apps_subcategory:
+            #self._check_nav_history(self.display_list_subcat)
             self.current_app_by_subcategory[self.apps_subcategory] = app
         else:
+            #self._check_nav_history(self.display_list)
             self.current_app_by_category[self.apps_category] = app
-            
+
     def on_nav_back_clicked(self, widget, event):
         self.nav_history.nav_back()
 
     def on_nav_forward_clicked(self, widget, event):
         self.nav_history.nav_forward()
-        
+
     def is_category_view_showing(self):
         # check if we are in the category page or if we display a
         # sub-category page that has no visible applications
@@ -414,9 +455,13 @@
                 not self.scroll_app_list.props.visible)
 
     def set_category(self, category):
+        def _cb():
+            self.refresh_apps()
+            self.notebook.set_current_page(self.PAGE_APPLIST)
+            return False
+
         self.update_navigation_button()
-        self.refresh_apps()
-        self.notebook.set_current_page(self.PAGE_APPLIST)
+        gobject.idle_add(_cb)
 
 if __name__ == "__main__":
     #logging.basicConfig(level=logging.DEBUG)
 
=== modified file 'softwarecenter/view/channelpane.py'
--- softwarecenter/view/channelpane.py	2010-03-23 16:50:23 +0000
+++ softwarecenter/view/channelpane.py	2010-04-04 06:00:32 +0000
@@ -23,6 +23,7 @@
 import os
 import sys
 import xapian
+import gobject
 
 from gettext import gettext as _
 
@@ -99,6 +100,10 @@
         old_model = self.app_view.get_model()
         if old_model is not None:
             old_model.active = False
+        gobject.idle_add(self._make_new_model, query)
+        return False
+
+    def _make_new_model(self, query):
         # get a new store and attach it to the view
         new_model = AppStore(self.cache,
                              self.db, 
@@ -110,7 +115,7 @@
         self.app_view.set_model(new_model)
         self.emit("app-list-changed", len(new_model))
         return False
-        
+
     def set_channel(self, channel):
         """
         set the current software channel object for display in the channel pane
 
=== modified file 'softwarecenter/view/installedpane.py'
--- softwarecenter/view/installedpane.py	2010-03-03 15:39:40 +0000
+++ softwarecenter/view/installedpane.py	2010-04-04 06:00:32 +0000
@@ -50,6 +50,7 @@
         # UI
         self._build_ui()
     def _build_ui(self):
+        self.navigation_bar.set_size_request(26, -1)
         self.notebook.append_page(self.scroll_app_list, gtk.Label("installed"))
         # details
         self.notebook.append_page(self.scroll_details, gtk.Label("details"))
@@ -82,7 +83,8 @@
             query = None
         self.navigation_bar.add_with_id(_("Installed Software"), 
                                         self.on_navigation_list,
-                                        "list")
+                                        "list",
+                                        animate=False)
         # *ugh* deactivate the old model because otherwise it keeps
         # getting progress_changed events and eats CPU time until it's
         # garbage collected
 
=== modified file 'softwarecenter/view/navhistory.py'
--- softwarecenter/view/navhistory.py	2010-03-19 21:27:31 +0000
+++ softwarecenter/view/navhistory.py	2010-04-04 06:00:32 +0000
@@ -15,7 +15,8 @@
 # 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 copy
+
+import gobject
 import logging
 
 from softwarecenter.utils import unescape
@@ -28,94 +29,117 @@
     class to manage navigation history in the "Get Software" section (the
     available pane).
     """
-    
+
+    MAX_NAV_ITEMS = 10  # limit number of NavItems allowed in the NavStack
+
+
     def __init__(self, available_pane):
         self.available_pane = available_pane
-        # always start at main category view
-        self._current_nav_item = CategoryViewNavigationItem(available_pane)
         # use stacks to track navigation history
-        self._nav_back_stack = []
-        self._nav_forward_stack = []
-        
-    def navigate(self, dest_nav_item):
+        self._nav_stack = NavigationStack(self.MAX_NAV_ITEMS)
+
+    def navigate(self, nav_item):
         """
         append a new NavigationItem to the history stack
         """
         if in_replay_history_mode:
             return
-        logging.debug("submit navitem for history: %s" % dest_nav_item)
-        # TODO: Detect multiple clicks on the same nav button and filter
-        #       them out - we don't want them in the history
-        dest_nav_item.parent = self
-        self._nav_back_stack.append(self._current_nav_item)
-        self._current_nav_item = dest_nav_item
-        # reset navigation forward stack on a direct navigation
-        self._nav_forward_stack = []
-        # update buttons
-        self.available_pane.back_forward.left.set_sensitive(True)
+
+        nav_item.parent = self
+        self._nav_stack.append(nav_item)
+
+        if self._nav_stack.cursor > 0:
+            self.available_pane.back_forward.left.set_sensitive(True)
         self.available_pane.back_forward.right.set_sensitive(False)
-        
+
+    def navigate_no_cursor_step(self, nav_item):
+        if in_replay_history_mode:
+            return
+
+        nav_item.parent = self
+        self._nav_stack.append_no_cursor_step(nav_item)
+        return
+
     def nav_forward(self):
         """
         navigate forward one item in the history stack
         """
+        nav_item = self._nav_stack.step_forward()
+        nav_item.navigate_to()
+
         self.available_pane.back_forward.left.set_sensitive(True)
-        if len(self._nav_forward_stack) <= 1:
+        if self._nav_stack.at_end():
+            if self.available_pane.back_forward.right.has_focus():
+                self.available_pane.back_forward.left.grab_focus()
             self.available_pane.back_forward.right.set_sensitive(False)
-        nav_item = self._nav_forward_stack.pop()
-        self._nav_back_stack.append(self._current_nav_item)
-        self._current_nav_item = nav_item
-        nav_item.navigate_to()
-    
+
     def nav_back(self):
         """
         navigate back one item in the history stack
         """
+        nav_item = self._nav_stack.step_back()
+        nav_item.navigate_to()
+
         self.available_pane.back_forward.right.set_sensitive(True)
-        if len(self._nav_back_stack) <= 1:
+        if self._nav_stack.at_start():
+            if self.available_pane.back_forward.left.has_focus():
+                self.available_pane.back_forward.right.grab_focus()
             self.available_pane.back_forward.left.set_sensitive(False)
-        nav_item = self._nav_back_stack.pop()
-        logging.debug("nav_back: %s" % nav_item)
-        self._nav_forward_stack.append(self._current_nav_item)
-        self._current_nav_item = nav_item
-        nav_item.navigate_to()
-        
+
+    def get_last_label(self):
+        if self._nav_stack.stack:
+            if self._nav_stack[-1].parts:
+                return self._nav_stack[-1].parts[-1].label
+        return None
+
+
 class NavigationItem(object):
     """
     class to implement navigation points to be managed in the history queues
     """
 
-    def __init__(self, available_pane):
+    def __init__(self, available_pane, update_available_pane_cb):
         self.available_pane = available_pane
+        self.update_available_pane = update_available_pane_cb
         self.apps_category = available_pane.apps_category
         self.apps_subcategory = available_pane.apps_subcategory
         self.apps_search_term = available_pane.apps_search_term
         self.current_app = available_pane.get_current_app()
-        self.parts = self.available_pane.navigation_bar.get_parts()[:]
-    
+        self.parts = self.available_pane.navigation_bar.get_parts()
+
     def navigate_to(self):
         """
         navigate to the view that corresponds to this NavigationItem
         """
         global in_replay_history_mode
         in_replay_history_mode = True
-        self.available_pane.apps_category = self.apps_category
-        self.available_pane.apps_subcategory = self.apps_subcategory
-        self.available_pane.apps_search_term = self.apps_search_term
-        self.available_pane.searchentry.set_text(self.apps_search_term)
-        self.available_pane.searchentry.set_position(-1)
-        self.available_pane.app_details.show_app(self.current_app)
-        # first part is special and kept in remove_all
-        self.available_pane.navigation_bar.remove_all()
+        available_pane = self.available_pane
+        available_pane.apps_category = self.apps_category
+        available_pane.apps_subcategory = self.apps_subcategory
+        available_pane.apps_search_term = self.apps_search_term
+        available_pane.searchentry.set_text(self.apps_search_term)
+        available_pane.searchentry.set_position(-1)
+        available_pane.app_details.show_app(self.current_app)
+
+        nav_bar = self.available_pane.navigation_bar
+        nav_bar.remove_all(do_callback=False)
+
         for part in self.parts[1:]:
-            self.available_pane.navigation_bar.add_with_id(unescape(part.label),
-                                                           part.callback,
-                                                           part.id,
-                                                           do_callback=False,
-                                                           animate=False)
-        self.parts[-1].activate()
+            nav_bar.add_with_id(unescape(part.label),
+                                part.callback,
+                                part.get_name(),
+                                do_callback=False,
+                                animate=False)
+
+        gobject.idle_add(self._update_available_pane_cb, nav_bar)
         in_replay_history_mode = False
-        
+
+    def _update_available_pane_cb(self, nav_bar):
+        last_part = nav_bar.get_parts()[-1]
+        nav_bar.set_active_no_callback(last_part)
+        self.update_available_pane()
+        return False
+
     def __str__(self):
         details = []
         details.append("\n%s" % type(self))
@@ -130,41 +154,76 @@
         details.append("  current_app: %s" % self.current_app)
         details.append("  apps_search_term: %s" % self.apps_search_term)
         return '\n'.join(details)
-        
-class CategoryViewNavigationItem(NavigationItem):
-    """
-    navigation item that corresponds to the main category view
-    Note: all subclasses of NavigationItem are for debug use only and
-          can be collapsed to the NavigationItem class if desired
-    """
-        
-class AppListNavigationItem(NavigationItem):
-    """
-    navigation item that corresponds to the application list for the
-    specified category
-    Note: all subclasses of NavigationItem are for debug use only and
-          can be collapsed to the NavigationItem class if desired
-    """
-            
-class AppListSubcategoryNavigationItem(NavigationItem):
-    """
-    navigation item that corresponds to the application list for the
-    specified category and subcategory
-    Note: all subclasses of NavigationItem are for debug use only and
-          can be collapsed to the NavigationItem class if desired
-    """
-        
-class AppDetailsNavigationItem(NavigationItem):
-    """
-    navigation item that corresponds to the details view for the
-    specified application
-    Note: all subclasses of NavigationItem are for debug use only and
-          can be collapsed to the NavigationItem class if desired
-    """
-        
-class SearchNavigationItem(NavigationItem):
-    """
-    navigation item that corresponds to a search in progress
-    Note: all subclasses of NavigationItem are for debug use only and
-          can be collapsed to the NavigationItem class if desired
-    """
+
+
+class NavigationStack(object):
+
+    def __init__(self, max_length):
+        self.max_length = max_length
+        self.stack = []
+        self.cursor = 0
+        return
+
+    def __len__(self):
+        return len(self.stack)
+
+    def __repr__(self):
+        BOLD = "\033[1m"
+        RESET = "\033[0;0m"
+        s = '['
+        for i, item in enumerate(self.stack):
+            if i != self.cursor:
+                s += str(item.parts[-1].label) + ', '
+            else:
+                s += BOLD + str(item.parts[-1].label) + RESET + ', '
+        return s + ']'
+
+    def __getitem__(self, item):
+        return self.stack[item]
+
+    def _isok(self, item):
+        if len(self.stack) == 0: return True
+        pre_item = self.stack[-1]
+        if pre_item.parts[-1].label == item.parts[-1].label:
+            if pre_item.apps_search_term != item.apps_search_term:
+                return True
+            return False
+        return True
+
+    def append(self, item):
+        if not self._isok(item):
+            self.cursor = len(self.stack)-1
+            print 'A:', repr(self)
+            return
+        if len(self.stack) + 1 > self.max_length:
+            self.stack.pop(0)
+        self.stack.append(item)
+        self.cursor = len(self.stack)-1
+        print 'A:', repr(self)
+        return
+
+    def append_no_cursor_step(self, item):
+        if not self._isok(item):
+            print 'a:', repr(self)
+            return
+        if len(self.stack) + 1 > self.max_length:
+            self.stack.pop(0)
+        self.stack.append(item)
+        print 'a:', repr(self)
+        return
+
+    def step_back(self):
+        self.cursor -= 1
+        print 'B:', repr(self)
+        return self.stack[self.cursor]
+
+    def step_forward(self):
+        self.cursor += 1
+        print 'B:', repr(self)
+        return self.stack[self.cursor]
+
+    def at_end(self):
+        return self.cursor == len(self.stack)-1
+
+    def at_start(self):
+        return self.cursor == 0
 
=== modified file 'softwarecenter/view/softwarepane.py'
--- softwarecenter/view/softwarepane.py	2010-03-29 20:40:17 +0000
+++ softwarecenter/view/softwarepane.py	2010-04-04 06:00:32 +0000
@@ -29,7 +29,7 @@
 if "SOFTWARE_CENTER_OLD_PATHBAR" in os.environ:
     from widgets.navigationbar import NavigationBar
 else:
-    from widgets.pathbar2 import NavigationBar
+    from widgets.pathbar_gtk_atk import NavigationBar
 
 from widgets.searchentry import SearchEntry
 
 
=== modified file 'softwarecenter/view/widgets/backforward.py'
--- softwarecenter/view/widgets/backforward.py	2010-02-15 02:53:26 +0000
+++ softwarecenter/view/widgets/backforward.py	2010-04-04 06:00:32 +0000
@@ -17,14 +17,14 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
-
-import rgb
+import atk
 import gtk
 import cairo
 import gobject
-import pathbar2
-
-from rgb import to_float as f
+import pathbar_common
+
+from gettext import gettext as _
+
 
 # pi constants
 M_PI = 3.1415926535897931
@@ -43,72 +43,132 @@
 
     def __init__(self):
         gtk.HBox.__init__(self)
+        self.theme = pathbar_common.PathBarStyle(self)
         sep = SeparatorPart()
 
         if self.get_direction() != gtk.TEXT_DIR_RTL:
+            # ltr
             self.left = ButtonPartLeft('left-clicked')
             self.right = ButtonPartRight('right-clicked')
+            self.set_button_atk_info_ltr()
         else:
+            # rtl
             self.left = ButtonPartRight('left-clicked')
             self.right = ButtonPartLeft('right-clicked')
+            self.set_button_atk_info_rtl()
+
+        atk_obj = self.get_accessible()
+        atk_obj.set_name(_('History Navigation'))
+        atk_obj.set_description(_('Navigate forwards and backwards.'))
+        atk_obj.set_role(atk.ROLE_PANEL)
 
         self.pack_start(self.left)
         self.pack_start(sep, False)
         self.pack_end(self.right)
 
-        self.theme = self._pick_theme()
-        self.connect("realize", self._on_realize)
-        return
-
-    def _pick_theme(self, name=None):
-        name = name or gtk.settings_get_default().get_property("gtk-theme-name")
-        themes = pathbar2.PathBarThemes.DICT
-        if themes.has_key(name):
-            return themes[name]()
-        print "No styling hints for %s are available" % name
-        return pathbar2.PathBarThemeHuman()
-
-    def _on_realize(self, widget):
-        self.theme.load(self.style)
-        return
-
+        sep.connect_after("style-set", self._on_style_set)
+        return
+
+    def set_button_atk_info_ltr(self):
+        # left button
+        atk_obj = self.left.get_accessible()
+        atk_obj.set_name(_('Back Button'))
+        atk_obj.set_description(_('Navigates back.'))
+        atk_obj.set_role(atk.ROLE_PUSH_BUTTON)
+
+        # right button
+        atk_obj = self.right.get_accessible()
+        atk_obj.set_name(_('Forward Button'))
+        atk_obj.set_description(_('Navigates forward.'))
+        atk_obj.set_role(atk.ROLE_PUSH_BUTTON)
+        return
+
+    def set_button_atk_info_rtl(self):
+        # right button
+        atk_obj = self.right.get_accessible()
+        atk_obj.set_name(_('Back Button'))
+        atk_obj.set_description(_('Navigates back.'))
+        atk_obj.set_role(atk.ROLE_PUSH_BUTTON)
+
+        # left button
+        atk_obj = self.left.get_accessible()
+        atk_obj.set_name(_('Forward Button'))
+        atk_obj.set_description(_('Navigates forward.'))
+        atk_obj.set_role(atk.ROLE_PUSH_BUTTON)
+        return
+
+    def _on_style_set(self, widget, oldstyle):
+        # when alloc.width == 1, this is typical of an unallocated widget,
+        # lets not break a sweat for nothing...
+        if self.allocation.width == 1:
+            return
+
+        old_xthickness = self.theme['xthickness']
+        self.theme = pathbar_common.PathBarStyle(self)
+        if old_xthickness > self.theme['xthickness']:
+            a = self.allocation
+            self.queue_draw_area(a.x, a.y,
+                                 a.width+self.theme['xthickness'], a.height)
+        else:
+            self.queue_draw()
+        return
 
 class SeparatorPart(gtk.DrawingArea):
 
     def __init__(self):
         gtk.DrawingArea.__init__(self)
-        self.set_size_request(1, -1)
+        self.theme = pathbar_common.PathBarStyle(self)
+        self.set_size_request(self.theme['xthickness'], -1)
+
+        atk_obj = self.get_accessible()
+        atk_obj.set_role(atk.ROLE_SEPARATOR)
+
         self.connect("expose-event", self._on_expose)
+        self.connect("style-set", self._on_style_set)
         return
 
     def _on_expose(self, widget, event):
+        parent = self.get_parent()
+        if not parent: return
         cr = widget.window.cairo_create()
-        a = event.area
-        cr.rectangle(a.x, a.y+1, a.width, a.height-2)
-        cr.set_source_rgba(0, 0, 0, 0.45)
+        cr.rectangle(event.area)
+        cr.set_source_rgb(*self.theme.dark_line[self.state].tofloats())
         cr.fill()
         del cr
         return
 
+    def _on_style_set(self, widget, old_style):
+        self.theme = pathbar_common.PathBarStyle(self)
+        self.set_size_request(self.theme['xthickness'], -1)
+        return
+
 
 class ButtonPart(gtk.DrawingArea):
 
     ARROW_SIZE = (12,12)
-    DEFAULT_SIZE = (30, 28)
+    DEFAULT_SIZE = (31, 27)
 
     def __init__(self, arrow_type, signal_name):
         gtk.DrawingArea.__init__(self)
         self.set_size_request(*self.DEFAULT_SIZE)
+        self.shape = pathbar_common.SHAPE_RECTANGLE
         self.button_down = False
         self.shadow_type = gtk.SHADOW_OUT
         self.arrow_type = arrow_type
+
+        self.set_flags(gtk.CAN_FOCUS)
         self.set_events(gtk.gdk.ENTER_NOTIFY_MASK|
                         gtk.gdk.LEAVE_NOTIFY_MASK|
                         gtk.gdk.BUTTON_PRESS_MASK|
                         gtk.gdk.BUTTON_RELEASE_MASK)
+
         self.connect("enter-notify-event", self._on_enter)
         self.connect("leave-notify-event", self._on_leave)
         self.connect("button-press-event", self._on_press)
+        self.connect("key-press-event", self._on_key_press)
+        self.connect("key-release-event", self._on_key_release, signal_name)
+        self.connect('focus-in-event', self._on_focus_in)
+        self.connect('focus-out-event', self._on_focus_out)
         self.connect("button-release-event", self._on_release, signal_name)
         return
 
@@ -135,11 +195,32 @@
             self.set_active(True)
         return
 
+    def _on_key_press(self, widget, event):
+        # react to spacebar, enter, numpad-enter
+        if event.keyval in (32, 65293, 65421):
+            self.set_state(gtk.STATE_ACTIVE)
+        return
+
+    def _on_key_release(self, widget, event, signal_name):
+        # react to spacebar, enter, numpad-enter
+        if event.keyval in (32, 65293, 65421):
+            self.set_state(gtk.STATE_SELECTED)
+            self.get_parent().emit(signal_name, event)
+        return
+
     def _on_leave(self, widget, event):
         if self.state == gtk.STATE_INSENSITIVE: return
         self.set_active(False)
         return
 
+    def _on_focus_in(self, widget, event):
+        self.queue_draw()
+        return
+
+    def _on_focus_out(self, widget, event):
+        self.queue_draw()
+        return
+
     def _on_press(self, widget, event):
         if self.state == gtk.STATE_INSENSITIVE: return
         self.button_down = True
@@ -160,117 +241,41 @@
             self.set_state(gtk.STATE_NORMAL)
         return
 
-#    def expose_gtk(self, widget, area, x, y, width, height):
-#        # button background
-#        widget.style.paint_box(widget.window,
-#                               self.state,
-#                               self.shadow_type,
-#                               area,
-#                               widget,
-#                               "button",
-#                               x,
-#                               y,
-#                               width,
-#                               height)
-
-#        # arrow
-#        aw, ah = self.ARROW_SIZE
-#        widget.style.paint_arrow(widget.window,
-#                                 self.state,
-#                                 self.shadow_type,
-#                                 area,
-#                                 widget,
-#                                 "button",
-#                                 self.arrow_type,
-#                                 True,
-#                                 (area.width - aw)/2,
-#                                 (area.height - ah)/2,
-#                                 aw,
-#                                 ah)
-#        return
-
-    def expose_pathbar(self, widget, area, x, y, width, height):
+    def expose_pathbar(self, widget, area, x, y, w, h, xo=0, wo=0):
+        if not self.parent: return
         # background
         cr = widget.window.cairo_create()
         cr.rectangle(area)
         cr.clip()
 
-        cr.translate(x, y)
-
-        self._draw_bg(cr,
-                      width,
-                      height,
-                      self.state,
-                      self.style,
-                      self.get_parent().theme,
-                      self.get_parent().theme.curvature)
+        self.parent.theme.paint_bg(cr,
+                                   self,
+                                   x, y, w, h)
         del cr
 
         # arrow
+        if self.has_focus():
+            self.style.paint_focus(self.window,
+                                   self.state,
+                                   (x+4+xo, y+4, w-8+wo, h-8),
+                                   self,
+                                   'button',
+                                   x+4+xo, y+4,
+                                   w-8+wo, h-8)
+
         aw, ah = self.ARROW_SIZE
-        widget.style.paint_arrow(widget.window,
-                                 self.state,
-                                 self.shadow_type,
-                                 area,
-                                 widget,
-                                 "button",
-                                 self.arrow_type,
-                                 True,
-                                 (area.width - aw)/2,
-                                 (area.height - ah)/2,
-                                 aw,
-                                 ah)
-        return
-
-    def _draw_bg(self, cr, w, h, state, style, theme, r):
-        # outer slight bevel or focal highlight
-        self._draw_rect(cr, 0, 0, w, h, r)
-        cr.set_source_rgba(0, 0, 0, 0.055)
-        cr.fill()
-        
-        # colour scheme dicts
-        bg = theme.bg_colors
-        outer = theme.dark_line_colors
-        inner = theme.light_line_colors
-        
-        # bg linear vertical gradient
-        if state != gtk.STATE_PRELIGHT:
-            color1, color2 = bg[state]
-        else:
-            if self.state == gtk.STATE_ACTIVE:
-                color1, color2 = bg[theme.PRELIT_NORMAL]
-            else:
-                color1, color2 = bg[theme.PRELIT_ACTIVE]
-
-        self._draw_rect(cr, 1, 1, w-1, h-1, r)
-        lin = cairo.LinearGradient(0, 0, 0, h-1)
-        lin.add_color_stop_rgb(0.0, *color1)
-        lin.add_color_stop_rgb(1.0, *color2)
-        cr.set_source(lin)
-        cr.fill()
-
-        cr.set_line_width(1.0)
-        # strong outline
-        self._draw_rect(cr, 1.5, 1.5, w-1.5, h-1.5, r)
-        cr.set_source_rgb(*outer[state])
-        cr.stroke()
-
-        # inner bevel/highlight
-        if theme.light_line_colors[state]:
-            self._draw_rect(cr, 2.5, 2.5, w-2.5, h-2.5, r)
-            r, g, b = inner[state]
-            cr.set_source_rgba(r, g, b, 0.6)
-            cr.stroke()
-        return
-
-    def _draw_rect(self, cr, x, y, w, h, r):
-        global M_PI, PI_OVER_180
-        cr.new_sub_path()
-        cr.arc(r+x, r+y, r, M_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, M_PI)
-        cr.close_path()
+        ax, ay = (area.width - aw)/2, (area.height - ah)/2,
+
+        self.style.paint_arrow(self.window,
+                               self.state,
+                               self.shadow_type,
+                               (ax, ay, aw, ah),
+                               self,
+                               "button",
+                               self.arrow_type,
+                               True,
+                               ax, ay,
+                               aw, ah)
         return
 
 
@@ -288,7 +293,8 @@
                     area.x,
                     area.y,
                     area.width + 10,
-                    area.height)
+                    area.height,
+                    wo=-10)
         return
 
 
@@ -303,8 +309,10 @@
         area = event.area
         expose_func(widget,
                     area,
-                    area.x - 10,
+                    area.x-10,
                     area.y,
-                    area.width + 10,
-                    area.height)
+                    area.width+10,
+                    area.height,
+                    xo=10,
+                    wo=-10)
         return
 
=== removed file 'softwarecenter/view/widgets/pathbar2.py'
--- softwarecenter/view/widgets/pathbar2.py	2010-03-03 09:18:00 +0000
+++ softwarecenter/view/widgets/pathbar2.py	1970-01-01 00:00:00 +0000
@@ -1,1605 +0,0 @@
-# Copyright (C) 2009 Matthew McGowan
-#
-# 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, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-import atk
-import cairo
-import gobject
-import gtk
-import pango
-import rgb
-
-from rgb import to_float as f
-
-# pi constants
-M_PI = 3.1415926535897931
-PI_OVER_180 = 0.017453292519943295
-
-from gettext import gettext as _
-
-class PathBar(gtk.DrawingArea):
-
-    # shapes
-    SHAPE_RECTANGLE = 0
-    SHAPE_START_ARROW = 1
-    SHAPE_MID_ARROW = 2
-    SHAPE_END_CAP = 3
-
-    def __init__(self, group=None):
-        gtk.DrawingArea.__init__(self)
-        self.__init_drawing()
-        self.set_redraw_on_allocate(False)
-
-        self.__parts = []
-        self.__active_part = None
-        self.__focal_part = None
-        self.__button_down = False, None
-
-        self.__scroller = None
-        self.__scroll_xO = 0
-
-        self.theme = self.__pick_theme()
-
-        atk_desc = self.get_accessible()
-        # Accessibility name for the pathbar
-        atk_desc.set_name(_("You are here:"))
-        atk_desc.set_role(atk.ROLE_PANEL)
-
-        # setup event handling
-        self.set_flags(gtk.CAN_FOCUS)
-        self.set_events(gtk.gdk.POINTER_MOTION_MASK|
-                        gtk.gdk.BUTTON_PRESS_MASK|
-                        gtk.gdk.BUTTON_RELEASE_MASK|
-                        gtk.gdk.KEY_RELEASE_MASK|
-                        gtk.gdk.KEY_PRESS_MASK|
-                        gtk.gdk.ENTER_NOTIFY_MASK|
-                        gtk.gdk.LEAVE_NOTIFY_MASK)
-
-        self.connect("motion-notify-event", self.__motion_notify_cb)
-        self.connect("enter-notify-event", self.__enter_notify_cb)
-        self.connect("leave-notify-event", self.__leave_notify_cb)
-        self.connect("button-press-event", self.__button_press_cb)
-        self.connect("button-release-event", self.__button_release_cb)
-#        self.connect("key-release-event", self.__key_release_cb)
-
-        self.connect("realize", self.__realize_cb)
-        self.connect("expose-event", self.__expose_cb)
-        self.connect("style-set", self.__style_change_cb)
-        self.connect("size-allocate", self.__allocation_change_cb)
-        return
-
-    def get_parts(self):
-        return self.__parts
-
-    def set_active(self, part, do_callback=True):
-        part.set_state(gtk.STATE_ACTIVE)
-        prev, redraw = self.__set_active(part, do_callback)
-        if redraw:
-            self.queue_draw_area(*prev.get_allocation_tuple())
-            self.queue_draw_area(*part.get_allocation_tuple())
-        return
-
-    def get_active(self):
-        return self.__active_part
-
-#    def get_left_part(self):
-#        active = self.get_active()
-#        if not active:
-#            return self.__parts[0]
-
-#        i = self.__parts.index(active)+1
-#        if i > len(self.__parts)-1:
-#            i = 0
-#        return self.__parts[i]
-
-#    def get_right_part(self):
-#        active = self.get_active()
-#        if not active:
-#            return self.__parts[0]
-
-#        i = self.__parts.index(active)-1
-#        if i < 0:
-#            i = len(self.__parts)-1
-#        return self.__parts[i]
-
-    def append(self, part, do_callback=True, animate=True):
-        prev, did_shrink = self.__append(part, do_callback)
-        if not self.get_property("visible"):
-            return False
-
-        if animate and self.theme.animate and len(self.__parts) > 1:
-            aw = self.theme.arrow_width
-
-            # calc draw_area
-            x,y,w,h = part.get_allocation_tuple()
-            w += aw
-
-            # begin scroll animation
-            self.__hscroll_out_init(
-                part.get_width(),
-                gtk.gdk.Rectangle(x,y,w,h),
-                self.theme.scroll_duration_ms,
-                self.theme.scroll_fps
-                )
-        else:
-            self.queue_draw_area(*part.get_allocation_tuple())
-        return False
-        
-    def append_no_callback(self, part):
-        self.append(part, do_callback=False)
-
-    def remove(self, part):
-        if len(self.__parts)-1 < 1:
-            print 'The first part is sacred ;)'
-            return
-
-        old_w = self.__draw_width()
-
-        # remove part from interal part list
-        try:
-            del self.__parts[self.__parts.index(part)]
-        except:
-            print 'part not in list!'
-            return
-        self.__compose_parts(self.__parts[-1], False)
-
-        if old_w >= self.allocation.width:
-            self.__grow_check(old_w, self.allocation)
-            self.queue_draw()
-
-        else:
-            self.queue_draw_area(*part.get_allocation_tuple())
-            self.queue_draw_area(*self.__parts[-1].get_allocation_tuple())
-        return
-
-    def remove_all(self, keep_first_part=True):
-        """remove all elements"""
-        if keep_first_part:
-            self.__parts = [self.__parts[0],]  # keep first part though!
-            self.__compose_parts(self.__parts[-1], False)
-        else:
-            self.__parts = []
-        self.id_to_part = {}
-        self.queue_draw()
-        return
-        
-    def navigate_up(self):
-        if len(self.__parts) > 1:
-            nav_part = self.__parts[len(self.__parts) - 2]
-            self.set_active(nav_part)
-        return
-
-#    def navigate_up(self, remove_pathparts=False):
-#        index = self.__parts.index(self.__active_part)
-#        if index-1 == -1: return None, index-1, len(self.__parts)
-#        self.set_active(self.__parts[index-1], remove_pathparts)
-#        return self.__parts[index-1], index-1, len(self.__parts)
-
-#    def navigate_down(self):
-#        index = self.__parts.index(self.__active_part)
-#        if self.__parts[index] == self.__parts[-1]: return None, index+1, len(self.__parts)
-#        self.set_active(self.__parts[index+1], False)
-#        return self.__parts[index+1], index+1, len(self.__parts)
-
-    def __set_active(self, part, do_callback):
-        prev_active = self.__active_part
-        redraw = False
-        if part.callback and do_callback:
-            part.callback(self, part)
-        if prev_active and prev_active != part:
-            prev_active.set_state(gtk.STATE_NORMAL)
-            redraw = True
-
-        self.__active_part = part
-        return prev_active, redraw
-
-    def __append(self, part, do_callback=True):
-        # clean up any exisitng scroll callbacks
-        if self.__scroller:
-            gobject.source_remove(self.__scroller)
-        self.__scroll_xO = 0
-
-        # the basics
-        x = self.__draw_width()
-        self.__parts.append(part)
-        part.set_pathbar(self)
-
-        self.set_active(part, do_callback)
-
-        # determin part shapes, and calc modified parts widths
-        prev = self.__compose_parts(part, True)
-        # set the position of new part
-        part.set_x(x)
-
-        # check parts fit to widgets allocated width
-        if x + part.get_width() > self.allocation.width  and \
-            self.allocation.width != 1:
-            self.__shrink_check(self.allocation)
-            return prev, True
-
-        return prev, False
-
-#    def __shorten(self, n):
-#        n = int(n)
-#        old_w = self.__draw_width()
-#        end_active = self.get_active() == self.__parts[-1]
-
-#        if len(self.__parts)-n < 1:
-#            print WARNING + 'The first part is sacred ;)' + ENDC
-#            return old_w, False
-
-#        del self.__parts[-n:]
-#        self.__compose_parts(self.__parts[-1], False)
-
-#        if end_active:
-#            self.set_active(self.__parts[-1])
-
-#        if old_w >= self.allocation.width:
-#            self.__grow_check(old_w, self.allocation)
-#            return old_w, True
-
-#        return old_w, False
-
-    def __shrink_check(self, allocation):
-        path_w = self.__draw_width()
-        shrinkage = path_w - allocation.width
-        mpw = self.theme.min_part_width
-        xO = 0
-
-        for part in self.__parts[:-1]:
-            w = part.get_width()
-            dw = 0
-
-            if w - shrinkage <= mpw:
-                dw = w - mpw
-                shrinkage -= dw
-                part.set_size(mpw, -1)
-                part.set_x(part.get_x() - xO)
-
-            else:
-                part.set_size(w - shrinkage, -1)
-                part.set_x(part.get_x() - xO)
-                dw = shrinkage
-                shrinkage = 0
-
-            xO += dw
-
-        last = self.__parts[-1]
-        last.set_x(last.get_x() - xO)
-        return
-
-    def __grow_check(self, old_width, allocation):
-        parts = self.__parts
-        if len(parts) == 0:
-            return
-
-        growth = old_width - self.__draw_width()
-        parts.reverse()
-
-        for part in parts:
-            bw = part.get_size_requisition()[0]
-            w = part.get_width()
-
-            if w < bw:
-                dw = bw - w
-
-                if dw <= growth:
-                    growth -= dw
-                    part.set_size(bw, -1)
-                    part.set_x(part.get_x() + growth)
-
-                else:
-                    part.set_size(w + growth, -1)
-                    growth = 0
-
-            else:
-                part.set_x(part.get_x() + growth)
-
-        parts.reverse()
-        shift =  parts[0].get_x()
-
-        # left align parts
-        if shift > 0:
-            for part in parts: part.set_x(part.get_x() - shift)
-        return
-
-    def __compose_parts(self, last, prev_set_size):
-        parts = self.__parts
-
-        if len(parts) == 1:
-            last.set_shape(self.SHAPE_RECTANGLE)
-            last.set_size(*last.calc_size_requisition())
-            prev = None
-
-        elif len(parts) == 2:
-            prev = parts[0]
-            prev.set_shape(self.SHAPE_START_ARROW)
-            prev.calc_size_requisition()
-
-            last.set_shape(self.SHAPE_END_CAP)
-            last.set_size(*last.calc_size_requisition())
-
-        else:
-            prev = parts[-2]
-            prev.set_shape(self.SHAPE_MID_ARROW)
-            prev.calc_size_requisition()
-
-            last.set_shape(self.SHAPE_END_CAP)
-            last.set_size(*last.calc_size_requisition())
-
-        if prev and prev_set_size:
-            prev.set_size(*prev.get_size_requisition())
-        return prev
-
-    def __draw_width(self):
-        l = len(self.__parts)
-        if l == 0:
-            return 0
-        a = self.__parts[-1].allocation
-        return a[0] + a[2]
-
-    def __hscroll_out_init(self, distance, draw_area, duration, fps):
-        self.__scroller = gobject.timeout_add(
-            int(1000.0 / fps),  # interval
-            self.__hscroll_out_cb,
-            distance,
-            duration*0.001,   # 1 over duration (converted to seconds)
-            gobject.get_current_time(),
-            draw_area.x,
-            draw_area.y,
-            draw_area.width,
-            draw_area.height)
-        return
-
-    def __hscroll_out_cb(self, distance, duration, start_t, x, y, w, h):
-        cur_t = gobject.get_current_time()
-        xO = distance - distance*((cur_t - start_t) / duration)
-
-        if xO > 0:
-            self.__scroll_xO = xO
-            self.queue_draw_area(x, y, w, h)
-        else:   # final frame
-            self.__scroll_xO = 0
-            # redraw the entire widget
-            # incase some timeouts are skipped due to high system load
-            self.queue_draw()
-            self.__scroller = None
-            return False
-        return True
-
-    def __part_at_xy(self, x, y):
-        for part in self.__parts:
-            a = part.get_allocation()
-            region = gtk.gdk.region_rectangle(a)
-
-            if region.point_in(int(x), int(y)):
-                return part
-        return None
-
-    def __draw_hscroll(self, cr):
-        if len(self.__parts) < 2:
-            return
-
-        # draw the last two parts
-        prev, last = self.__parts[-2:]
-
-        # style theme stuff
-        style, r, aw, shapes = self.style, self.theme.curvature, \
-            self.theme.arrow_width, self.__shapes
-
-        # draw part that need scrolling
-        self.__draw_part(cr,
-                         last,
-                         style,
-                         r,
-                         aw,
-                         shapes,
-                         self.__scroll_xO)
-
-        # draw the last part that does not scroll
-        self.__draw_part(cr,
-                         prev,
-                         style,
-                         r,
-                         aw,
-                         shapes)
-        return
-
-    def __draw_all(self, cr, event_area):
-        style = self.style
-        r = self.theme.curvature
-        aw = self.theme.arrow_width
-        shapes = self.__shapes
-        region = gtk.gdk.region_rectangle(event_area)
-
-        # if a scroll is pending we want to not draw the final part,
-        # as we don't want to prematurely reveal the part befor the
-        # scroll animation has had a chance to start
-        if self.__scroller:
-            parts = self.__parts[:-1]
-        else:
-            parts = self.__parts
-
-        parts.reverse()
-        for part in parts:
-            if region.rect_in(part.get_allocation()) != gtk.gdk.OVERLAP_RECTANGLE_OUT:
-                self.__draw_part(cr, part, style, r, aw, shapes)
-        parts.reverse()
-        return
-
-    def __draw_part_ltr(self, cr, part, style, r, aw, shapes, sxO=0):
-        x, y, w, h = part.get_allocation()
-        shape = part.shape
-        state = part.state
-        icon_pb = part.icon.pixbuf
-
-        cr.save()
-        cr.translate(x-sxO, y)
-
-        # draw bg
-        self.__draw_part_bg(cr, part, w, h, state, shape, style,r, aw, shapes)
-
-        # determine left margin.  left margin depends on part shape
-        # and whether there exists an icon or not
-        if shape == self.SHAPE_MID_ARROW or shape == self.SHAPE_END_CAP:
-            margin = int(0.75*self.theme.arrow_width + self.theme.xpadding)
-        else:
-            margin = self.theme.xpadding
-
-        # draw icon
-        if icon_pb:
-            cr.set_source_pixbuf(
-                icon_pb,
-                self.theme.xpadding-sxO,
-                (alloc.height - icon_pb.get_height())/2)
-            cr.paint()
-            margin += icon_pb.get_width() + self.theme.spacing
-
-        # if space is limited and an icon is set, dont draw label
-        # otherwise, draw label
-        if w == self.theme.min_part_width and icon_pb:
-            pass
-
-        else:
-            layout = part.get_layout()
-            lw, lh = layout.get_pixel_size()
-            dst_x = x + margin - int(sxO)
-            dst_y = (self.allocation.height - lh)/2+1
-            style.paint_layout(
-                self.window,
-                self.theme.text_state[state],
-                False,
-                (dst_x, dst_y, lw+4, lh),   # clip area
-                self,
-                None,
-                dst_x,
-                dst_y,
-                layout)
-
-        cr.restore()
-        return
-
-    def __draw_part_rtl(self, cr, part, style, r, aw, shapes, sxO=0):
-        x, y, w, h = part.get_allocation()
-        shape = part.shape
-        state = part.state
-        icon_pb = part.icon.pixbuf
-
-        cr.save()
-        cr.translate(x+sxO, y)
-
-        # draw bg
-        self.__draw_part_bg(cr, part, w, h, state, shape, style,r, aw, shapes)
-
-        # determine left margin.  left margin depends on part shape
-        # and whether there exists an icon or not
-        if shape == self.SHAPE_MID_ARROW or shape == self.SHAPE_END_CAP:
-            margin = self.theme.arrow_width + self.theme.xpadding
-        else:
-            margin = self.theme.xpadding
-
-        # draw icon
-        if icon_pb:
-            margin += icon_pb.get_width()
-            cr.set_source_pixbuf(
-                icon_pb,
-                w - margin + sxO,
-                (h - icon_pb.get_height())/2)
-            cr.paint()
-            margin += self.spacing
-
-        # if space is limited and an icon is set, dont draw label
-        # otherwise, draw label
-        if w == self.theme.min_part_width and icon_pb:
-            pass
-
-        else:
-            layout = part.get_layout()
-            lw, lh = layout.get_pixel_size()
-            dst_x = x + part.get_width() - margin - lw + int(sxO)
-            dst_y = (self.allocation.height - lh)/2+1
-            style.paint_layout(
-                self.window,
-                self.theme.text_state[state],
-                False,
-                None,
-                self,
-                None,
-                dst_x,
-                dst_y,
-                layout)
-
-        cr.restore()
-        return
-
-    def __draw_part_bg(self, cr, part, w, h, state, shape, style, r, aw, shapes):
-        # outer slight bevel or focal highlight
-        shapes[shape](cr, 0, 0, w, h, r, aw)
-        cr.set_source_rgba(0, 0, 0, 0.055)
-        cr.fill()
-
-        # colour scheme dicts
-        bg = self.theme.bg_colors
-        outer = self.theme.dark_line_colors
-        inner = self.theme.light_line_colors
-
-        # bg linear vertical gradient
-        if state != gtk.STATE_PRELIGHT:
-            color1, color2 = bg[state]
-        else:
-            if part != self.get_active():
-                color1, color2 = bg[self.theme.PRELIT_NORMAL]
-            else:
-                color1, color2 = bg[self.theme.PRELIT_ACTIVE]
-
-        shapes[shape](cr, 1, 1, w-1, h-1, r, aw)
-        lin = cairo.LinearGradient(0, 0, 0, h-1)
-        lin.add_color_stop_rgb(0.0, *color1)
-        lin.add_color_stop_rgb(1.0, *color2)
-        cr.set_source(lin)
-        cr.fill()
-
-        cr.set_line_width(1.0)
-        # strong outline
-        shapes[shape](cr, 1.5, 1.5, w-1.5, h-1.5, r, aw)
-        cr.set_source_rgb(*outer[state])
-        cr.stroke()
-
-        # inner bevel/highlight
-        if self.theme.light_line_colors[state]:
-            shapes[shape](cr, 2.5, 2.5, w-2.5, h-2.5, r, aw)
-            r, g, b = inner[state]
-            cr.set_source_rgba(r, g, b, 0.6)
-            cr.stroke()
-        return
-
-    def __shape_rect(self, cr, x, y, w, h, r, aw):
-        global M_PI, PI_OVER_180
-        cr.new_sub_path()
-        cr.arc(r+x, r+y, r, M_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, M_PI)
-        cr.close_path()
-        return
-
-    def __shape_start_arrow_ltr(self, cr, x, y, w, h, r, aw):
-        global M_PI, PI_OVER_180
-        cr.new_sub_path()
-        cr.arc(r+x, r+y, r, M_PI, 270*PI_OVER_180)
-        # arrow head
-        cr.line_to(w-aw+1, y)
-        cr.line_to(w, (h+y)*0.5)
-        cr.line_to(w-aw+1, h)
-        cr.arc(r+x, h-r, r, 90*PI_OVER_180, M_PI)
-        cr.close_path()
-        return
-
-    def __shape_mid_arrow_ltr(self, cr, x, y, w, h, r, aw):
-        cr.move_to(-1, y)
-        # arrow head
-        cr.line_to(w-aw+1, y)
-        cr.line_to(w, (h+y)*0.5)
-        cr.line_to(w-aw+1, h)
-        cr.line_to(-1, h)
-        cr.close_path()
-        return
-
-    def __shape_end_cap_ltr(self, cr, x, y, w, h, r, aw):
-        global M_PI, PI_OVER_180
-        cr.move_to(-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(-1, h)
-        cr.close_path()
-        return
-
-    def __shape_start_arrow_rtl(self, cr, x, y, w, h, r, aw):
-        global M_PI, PI_OVER_180
-        cr.new_sub_path()
-        cr.move_to(x, (h+y)*0.5)
-        cr.line_to(aw-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(aw-1, h)
-        cr.close_path()
-        return
-
-    def __shape_mid_arrow_rtl(self, cr, x, y, w, h, r, aw):
-        cr.move_to(x, (h+y)*0.5)
-        cr.line_to(aw-1, y)
-        cr.line_to(w+1, y)
-        cr.line_to(w+1, h)
-        cr.line_to(aw-1, h)
-        cr.close_path()
-        return
-
-    def __shape_end_cap_rtl(self, cr, x, y, w, h, r, aw):
-        global M_PI, PI_OVER_180
-        cr.arc(r+x, r+y, r, M_PI, 270*PI_OVER_180)
-        cr.line_to(w+1, y)
-        cr.line_to(w+1, h)
-        cr.arc(r+x, h-r, r, 90*PI_OVER_180, M_PI)
-        cr.close_path()
-        return
-
-    def __state(self, part):
-        # returns the idle state of the part depending on
-        # whether part is active or not.
-        if part == self.__active_part:
-            return gtk.STATE_ACTIVE
-        return gtk.STATE_NORMAL
-
-    def __tooltip_check(self, part):
-        # only show a tooltip if part is truncated, i.e. not all label text is
-        # visible.
-        if part.is_truncated():
-            self.set_has_tooltip(False)
-            gobject.timeout_add(50, self.__set_tooltip_cb, part.label)
-        else:
-            self.set_has_tooltip(False)
-        return
-
-    def __set_tooltip_cb(self, text):
-        # callback allows the tooltip position to be updated as pointer moves
-        # accross different parts
-        self.set_has_tooltip(True)
-        self.set_tooltip_markup(text)
-        return False
-
-    def __pick_theme(self, name=None):
-        name = name or gtk.settings_get_default().get_property("gtk-theme-name")
-        themes = PathBarThemes.DICT
-        if themes.has_key(name):
-            return themes[name]()
-        print "No styling hints for %s are available" % name
-        return PathBarThemeHuman()
-
-    def __init_drawing(self):
-        if self.get_direction() != gtk.TEXT_DIR_RTL:
-            self.__draw_part = self.__draw_part_ltr
-            self.__shapes = {
-                self.SHAPE_RECTANGLE : self.__shape_rect,
-                self.SHAPE_START_ARROW : self.__shape_start_arrow_ltr,
-                self.SHAPE_MID_ARROW : self.__shape_mid_arrow_ltr,
-                self.SHAPE_END_CAP : self.__shape_end_cap_ltr}
-        else:
-            self.__draw_part = self.__draw_part_rtl
-            self.__shapes = {
-                self.SHAPE_RECTANGLE : self.__shape_rect,
-                self.SHAPE_START_ARROW : self.__shape_start_arrow_rtl,
-                self.SHAPE_MID_ARROW : self.__shape_mid_arrow_rtl,
-                self.SHAPE_END_CAP : self.__shape_end_cap_rtl}
-        return
-
-    def __motion_notify_cb(self, widget, event):
-        if self.__scroll_xO > 0:
-            return
-
-        part = self.__part_at_xy(event.x, event.y)
-        prev_focal = self.__focal_part
-
-        if self.__button_down[0]:
-            if part and prev_focal and part != prev_focal:
-                if self.__button_down[1] == part:
-                    part.set_state(gtk.STATE_SELECTED)
-                else:
-                    part.set_state(gtk.STATE_PRELIGHT)
-
-                prev_focal.set_state(self.__state(prev_focal))
-                self.queue_draw_area(*prev_focal.get_allocation_tuple())
-                self.queue_draw_area(*part.get_allocation_tuple())
-                self.__focal_part = part
-            return
-
-        if part and part.state != gtk.STATE_PRELIGHT:
-            self.__tooltip_check(part)
-            part.set_state(gtk.STATE_PRELIGHT)
-
-            if prev_focal:
-                prev_focal.set_state(self.__state(prev_focal))
-                self.queue_draw_area(*prev_focal.get_allocation_tuple())
-
-            self.__focal_part = part
-            self.queue_draw_area(*part.get_allocation_tuple())
-
-        elif not part and prev_focal != None and \
-            not widget.window.get_pointer()[2] & gtk.gdk.BUTTON1_MASK:
-            prev_focal.set_state(self.__state(prev_focal))
-            self.queue_draw_area(*prev_focal.get_allocation_tuple())
-            self.__focal_part = None
-        return
-
-    def __enter_notify_cb(self, widget, event):
-        if not self.__button_down[0] and not widget.window.get_pointer()[2] & gtk.gdk.BUTTON1_MASK:
-            return
-
-        part = self.__part_at_xy(event.x, event.y)
-        prev_focal = self.__focal_part
-
-        if part and prev_focal == part:
-            part.set_state(gtk.STATE_SELECTED)
-            self.queue_draw_area(*part.get_allocation_tuple())
-        return
-
-    def __leave_notify_cb(self, widget, event):
-        prev_focal = self.__focal_part
-        if prev_focal:
-            prev_focal.set_state(self.__state(prev_focal))
-            self.queue_draw_area(*prev_focal.get_allocation_tuple())
-
-        if not widget.window.get_pointer()[2] & gtk.gdk.BUTTON1_MASK:
-            self.__focal_part = None
-        return
-
-    def __button_press_cb(self, widget, event):
-        part = self.__part_at_xy(event.x, event.y)
-        self.__button_down = True, part
-        if part:
-            part.set_state(gtk.STATE_SELECTED)
-            self.queue_draw_area(*part.get_allocation_tuple())
-            self.__focal_part = part
-        return
-
-    def __button_release_cb(self, widget, event):
-        part = self.__part_at_xy(event.x, event.y)
-        if self.__focal_part and self.__focal_part != part:
-            pass
-        elif part and self.__button_down[0]:
-            prev_active, redraw = self.__set_active(part, True)
-            part.set_state(gtk.STATE_PRELIGHT)
-            self.queue_draw_area(*part.get_allocation_tuple())
-
-            if redraw:
-                self.queue_draw_area(*prev_active.get_allocation_tuple())
-        self.__button_down = False, None
-        return
-
-#    def __key_release_cb(self, widget, event):
-#        part = None
-
-#        # left key pressed
-#        if event.keyval == 65363:
-#            part = self.get_left_part()
-
-#        # right key pressed
-#        elif event.keyval == 65361:
-#            part = self.get_right_part()
-
-#        if not part: return
-
-#        prev_active = self.set_active(part)
-#        self.queue_draw_area(*part.allocation)
-#        if prev_active:
-#            self.queue_draw_area(*prev_active.allocation)
-
-#        part.emit("clicked", event.copy())
-#        return
-
-    def __realize_cb(self, widget):
-        self.theme.load(widget.style)
-        return
-
-    def __expose_cb(self, widget, event):
-        cr = widget.window.cairo_create()
-
-        if self.theme.base_hack:
-            cr.set_source_rgb(*self.theme.base_hack)
-            cr.paint()
-
-        if self.__scroll_xO:
-            self.__draw_hscroll(cr)
-        else:
-            self.__draw_all(cr, event.area)
-
-        del cr
-        return
-
-    def __style_change_cb(self, widget, old_style):
-        # when alloc.width == 1, this is typical of an unallocated widget,
-        # lets not break a sweat for nothing...
-        if self.allocation.width == 1:
-            return
-
-        self.theme = self.__pick_theme()
-        self.theme.load(widget.style)
-        # set height to 0 so that if part height has been reduced the widget will
-        # shrink to an appropriate new height based on new font size
-        self.set_size_request(-1, 28)
-
-        parts = self.__parts
-        self.__parts = []
-
-        # recalc best fits, re-append then draw all
-        for part in parts:
-
-            if part.icon.pixbuf:
-                part.icon.load_pixbuf()
-
-            part.calc_size_requisition()
-            self.__append(part)
-
-        self.queue_draw()
-        return
-
-    def __allocation_change_cb(self, widget, allocation):
-        if allocation.width == 1:
-            return
-
-        path_w = self.__draw_width()
-        if path_w == allocation.width:
-            return
-        elif path_w > allocation.width:
-            self.__shrink_check(allocation)
-        else:
-            self.__grow_check(allocation.width, allocation)
-
-        self.queue_draw()
-        return
-
-# FIXME: stubs currently and not working
-class IAtkComponent(atk.Component):
-    # atk --------------------------------------------------------
-    def contains(x, y, coord_type):
-        # atk stub
-        return False
-    def ref_accessible_at_point(x, y, coord_type):
-        # atk stub
-        pass
-    def get_extents(coord_type):
-        # atk stub
-        (0, 0, 0, 0)
-    def get_position(coord_type):
-        # atk stub
-        (0, 0)
-    def get_size(self):
-        # atk stub
-        (0, 0)
-    def grab_focus(self):
-        # atk stub
-        return False
-    def remove_focus_handler(self, handler_id):
-        # atk stub
-        pass
-    def set_extents(self, x, y, width, height, coord_type):
-        # atk stub
-        return False
-    def set_position(self, x, y, coord_type):
-        # atk stub
-        return False
-    def set_size(self, width, height):
-        # atk stub
-        return False
-    def get_layer(self):
-        # atk stub
-        return atk.LAYER_WIDGET
-    def get_mdi_zorder(self):
-        # atk stub
-        return 1
-    #--------------------------------
-
-
-class PathPart(atk.Object, IAtkComponent):
-
-    def __init__(self, parent, label=None, callback=None):
-        atk.Object.__init__(self)
-        self.__requisition = (0,0)
-        self.__layout = None
-        self.__pbar = None
-
-        # self.set_name() would work as well, *but* we have that
-        # function already for a different purpose, so we need to
-        # explicitely call
-        parent_atk = parent.get_accessible()
-        atk.Object.set_name(self, label)
-        atk.Object.set_role(self, atk.ROLE_PUSH_BUTTON)
-        atk.Object.add_relationship(self, atk.RELATION_MEMBER_OF, parent_atk)
-        atk.Object.set_parent(self, parent_atk)
-        #print parent_atk
-        #print parent_atk.get_n_accessible_children()
-
-        self.allocation = [0, 0, 0, 0]
-        self.state = gtk.STATE_NORMAL
-        self.shape = PathBar.SHAPE_RECTANGLE
-
-        self.name = None
-        self.callback = callback
-        self.set_label(label or "")
-        self.icon = PathBarIcon()
-        return
-
-    def set_callback(self, cb):
-        self.callback = cb
-        return
-
-    def set_name(self, name):
-        self.name = name
-        return
-
-    def set_label(self, label):
-        # escape special characters
-        label = gobject.markup_escape_text(label.strip())
-        # some hackery to preserve italics markup
-        label = label.replace('&lt;i&gt;', '<i>').replace('&lt;/i&gt;', '</i>')
-        self.label = label
-        atk.Object.set_name(self, label)
-        return
-
-    def set_icon(self, stock_icon, size=gtk.ICON_SIZE_BUTTON):
-        self.icon.specify(stock_icon, size)
-        self.icon.load_pixbuf()
-        return
-
-    def set_state(self, gtk_state):
-        self.state = gtk_state
-        return
-
-    def set_shape(self, shape):
-        self.shape = shape
-        return
-
-    def set_x(self, x):
-        self.allocation[0] = int(x)
-        return
-
-    def set_size(self, w, h):
-        if w != -1: self.allocation[2] = int(w)
-        if h != -1: self.allocation[3] = int(h)
-        self.__calc_layout_width(self.__layout, self.shape, self.__pbar)
-        return
-
-    def set_pathbar(self, path_bar):
-        self.__pbar = path_bar
-        return
-
-    def get_x(self):
-        return self.allocation[0]
-
-    def get_width(self):
-        return self.allocation[2]
-
-    def get_height(self):
-        return self.allocation[3]
-
-    def get_label(self):
-        return self.label
-
-    def get_allocation(self):
-        return gtk.gdk.Rectangle(*self.get_allocation_tuple())
-
-    def get_allocation_tuple(self):
-        if self.__pbar.get_direction() != gtk.TEXT_DIR_RTL:
-            return self.allocation
-        x, y, w, h = self.allocation
-        x = self.__pbar.allocation[2]-x-w
-        return x, y, w, h
-
-    def get_size_requisition(self):
-        return self.__requisition
-
-    def get_layout(self):
-        return self.__layout
-
-    def activate(self, do_callback=True):
-        self.__pbar.set_active(self, do_callback)
-        return
-
-    def calc_size_requisition(self):
-        pbar = self.__pbar
-
-        # determine widget size base on label width
-        self.__layout = self.__layout_text(self.label, pbar.get_pango_context())
-        extents = self.__layout.get_pixel_extents()
-
-        # calc text width + 2 * padding, text height + 2 * ypadding
-        w = extents[1][2] + 2*pbar.theme.xpadding
-        h = max(extents[1][3] + 2*pbar.theme.ypadding, pbar.get_size_request()[1])
-
-        # if has icon add some more pixels on
-        if self.icon.pixbuf:
-            w += self.icon.pixbuf.get_width() + pbar.theme.spacing
-            h = max(self.icon.pixbuf.get_height() + 2*pbar.theme.ypadding, h)
-
-        # extend width depending on part shape  ...
-        if self.shape == PathBar.SHAPE_START_ARROW or \
-            self.shape == PathBar.SHAPE_END_CAP:
-            w += pbar.theme.arrow_width
-
-        elif self.shape == PathBar.SHAPE_MID_ARROW:
-            w += 2*pbar.theme.arrow_width
-
-        # if height greater than current height request,
-        # reset height request to higher value
-        # i get the feeling this should be in set_size_request(), but meh
-        if h > pbar.get_size_request()[1]:
-            pbar.set_size_request(-1, h)
-
-        self.__requisition = (w,h)
-        return w, h
-
-    def is_truncated(self):
-        return self.__requisition[0] != self.allocation[2]
-
-    def __layout_text(self, text, pango_context):
-        layout = pango.Layout(pango_context)
-        layout.set_markup('%s' % text)
-        layout.set_ellipsize(pango.ELLIPSIZE_END)
-        return layout
-
-    def __calc_layout_width(self, layout, shape, pbar):
-        # set layout width
-        if self.icon.pixbuf:
-            icon_w = self.icon.pixbuf.get_width() + pbar.theme.spacing
-        else:
-            icon_w = 0
-
-        w = self.allocation[2]
-        if shape == PathBar.SHAPE_MID_ARROW:
-            layout.set_width((w - 2*pbar.theme.arrow_width -
-                2*pbar.theme.xpadding - icon_w)*pango.SCALE)
-
-        elif shape == PathBar.SHAPE_START_ARROW or \
-            shape == PathBar.SHAPE_END_CAP:
-            layout.set_width((w - pbar.theme.arrow_width - 2*pbar.theme.xpadding -
-                icon_w)*pango.SCALE)
-        else:
-            layout.set_width((w - 2*pbar.theme.xpadding - icon_w)*pango.SCALE)
-        return
-
-
-class PathBarIcon:
-
-    def __init__(self, name=None, size=None):
-        self.name = name
-        self.size = size
-        self.pixbuf = None
-        return
-
-    def specify(self, name, size):
-        self.name = name
-        self.size = size
-        return
-
-    def load_pixbuf(self):
-        if not self.name:
-            print 'Error: No icon specified.'
-            return
-        if not self.size:
-            print 'Note: No icon size specified.'
-
-        def render_icon(icon_set, name, size):
-            self.pixbuf = icon_set.render_icon(
-                style,
-                gtk.TEXT_DIR_NONE,
-                gtk.STATE_NORMAL,
-                self.size or gtk.ICON_SIZE_BUTTON,
-                gtk.Image(),
-                None)
-            return
-
-        style = gtk.Style()
-        icon_set = style.lookup_icon_set(self.name)
-
-        if not icon_set:
-            t = gtk.icon_theme_get_default()
-            self.pixbuf = t.lookup_icon(self.name, self.size, 0).load_icon()
-        else:
-            icon_set = style.lookup_icon_set(self.name)
-            render_icon(icon_set, self.name, self.size)
-
-        if not self.pixbuf:
-            print 'Error: No name failed to match any installed icon set.'
-            self.name = gtk.STOCK_MISSING_IMAGE
-            icon_set = style.lookup_icon_set(self.name)
-            render_icon(icon_set, self.name, self.size)
-        return
-
-
-class PathBarThemeHuman:
-
-    PRELIT_NORMAL = 10
-    PRELIT_ACTIVE = 11
-
-    curvature = 2.5
-    min_part_width = 56
-    xpadding = 8
-    ypadding = 2
-    spacing = 4
-    arrow_width = 13
-    scroll_duration_ms = 150
-    scroll_fps = 50
-    animate = gtk.settings_get_default().get_property("gtk-enable-animations")
-
-    def __init__(self):
-        return
-
-    def load(self, style):
-        mid = style.mid
-        dark = style.dark
-        light = style.light
-        text = style.text
-        active = rgb.mix_color(mid[gtk.STATE_NORMAL],
-                               mid[gtk.STATE_SELECTED], 0.25)
-
-        self.bg_colors = {
-            gtk.STATE_NORMAL: (f(rgb.shade(mid[gtk.STATE_NORMAL], 1.2)),
-                                f(mid[gtk.STATE_NORMAL])),
-
-            gtk.STATE_ACTIVE: (f(rgb.shade(active, 1.2)),
-                               f(active)),
-
-            gtk.STATE_SELECTED: (f(mid[gtk.STATE_ACTIVE]),
-                                 f(mid[gtk.STATE_ACTIVE])),
-
-             gtk.STATE_INSENSITIVE: (f(mid[gtk.STATE_INSENSITIVE]),
-                                     f(mid[gtk.STATE_INSENSITIVE])),
-
-            self.PRELIT_NORMAL: (f(rgb.shade(mid[gtk.STATE_NORMAL], 1.25)),
-                                 f(rgb.shade(mid[gtk.STATE_NORMAL], 1.05))),
-
-            self.PRELIT_ACTIVE: (f(rgb.shade(active, 1.25)),
-                                 f(rgb.shade(active, 1.05)))
-            }
-
-        self.dark_line_colors = {
-            gtk.STATE_NORMAL: f(dark[gtk.STATE_NORMAL]),
-            gtk.STATE_ACTIVE: f(dark[gtk.STATE_ACTIVE]),
-            gtk.STATE_SELECTED: f(rgb.shade(dark[gtk.STATE_ACTIVE], 0.9)),
-            gtk.STATE_PRELIGHT: f(dark[gtk.STATE_PRELIGHT]),
-            gtk.STATE_INSENSITIVE: f(dark[gtk.STATE_PRELIGHT])
-            }
-
-        self.light_line_colors = {
-            gtk.STATE_NORMAL: f(light[gtk.STATE_NORMAL]),
-            gtk.STATE_ACTIVE: f(light[gtk.STATE_ACTIVE]),
-            gtk.STATE_SELECTED: None,
-            gtk.STATE_PRELIGHT: f(light[gtk.STATE_PRELIGHT]),
-            gtk.STATE_INSENSITIVE: f(mid[gtk.STATE_PRELIGHT])
-            }
-
-        self.text_state = {
-            gtk.STATE_NORMAL: gtk.STATE_NORMAL,
-            gtk.STATE_ACTIVE: gtk.STATE_ACTIVE,
-            gtk.STATE_SELECTED: gtk.STATE_ACTIVE,
-            gtk.STATE_PRELIGHT: gtk.STATE_PRELIGHT,
-            gtk.STATE_INSENSITIVE: gtk.STATE_INSENSITIVE
-            }
-
-        self.base_hack = None
-        return
-
-
-class PathBarThemeInHuman(PathBarThemeHuman):
-
-    def __init__(self):
-        PathBarThemeHuman.__init__(self)
-        return
-
-    def load(self, style):
-        mid = style.mid
-        dark = style.dark
-        light = style.light
-        text = style.text
-        active = rgb.mix_color(mid[gtk.STATE_NORMAL],
-                               mid[gtk.STATE_SELECTED], 0.25)
-
-        self.bg_colors = {
-            gtk.STATE_NORMAL: (f(rgb.shade(mid[gtk.STATE_NORMAL], 1.175)),
-                                f(mid[gtk.STATE_NORMAL])),
-
-            gtk.STATE_ACTIVE: (f(rgb.shade(active, 1.2)),
-                               f(active)),
-
-            gtk.STATE_SELECTED: (f(mid[gtk.STATE_ACTIVE]),
-                                 f(mid[gtk.STATE_ACTIVE])),
-
-             gtk.STATE_INSENSITIVE: (f(rgb.shade(mid[gtk.STATE_INSENSITIVE], 1.15)),
-                                     f(rgb.shade(mid[gtk.STATE_INSENSITIVE], 1.1))),
-
-            self.PRELIT_NORMAL: (f(rgb.shade(mid[gtk.STATE_NORMAL], 1.25)),
-                                 f(rgb.shade(mid[gtk.STATE_NORMAL], 1.05))),
-
-            self.PRELIT_ACTIVE: (f(rgb.shade(active, 1.25)),
-                                 f(rgb.shade(active, 1.05)))
-            }
-
-        self.dark_line_colors = {
-            gtk.STATE_NORMAL: f(dark[gtk.STATE_NORMAL]),
-            gtk.STATE_ACTIVE: f(dark[gtk.STATE_ACTIVE]),
-            gtk.STATE_SELECTED: f(rgb.shade(dark[gtk.STATE_ACTIVE], 0.9)),
-            gtk.STATE_PRELIGHT: f(dark[gtk.STATE_PRELIGHT]),
-            gtk.STATE_INSENSITIVE: f(dark[gtk.STATE_PRELIGHT])
-            }
-
-        self.light_line_colors = {
-            gtk.STATE_NORMAL: f(light[gtk.STATE_NORMAL]),
-            gtk.STATE_ACTIVE: f(light[gtk.STATE_ACTIVE]),
-            gtk.STATE_SELECTED: None,
-            gtk.STATE_PRELIGHT: f(light[gtk.STATE_PRELIGHT]),
-            gtk.STATE_INSENSITIVE: f(light[gtk.STATE_PRELIGHT])
-            }
-
-        self.text_state = {
-            gtk.STATE_NORMAL: gtk.STATE_NORMAL,
-            gtk.STATE_ACTIVE: gtk.STATE_ACTIVE,
-            gtk.STATE_SELECTED: gtk.STATE_ACTIVE,
-            gtk.STATE_PRELIGHT: gtk.STATE_PRELIGHT,
-            gtk.STATE_INSENSITIVE: gtk.STATE_INSENSITIVE
-            }
-
-        self.base_hack = None
-        return
-
-
-class PathBarThemeHumanClearlooks(PathBarThemeHuman):
-
-    def __init__(self):
-        PathBarThemeHuman.__init__(self)
-        return
-
-    def load(self, style):
-        mid = style.mid
-        dark = style.dark
-        light = style.light
-        text = style.text
-        active = rgb.mix_color(mid[gtk.STATE_NORMAL],
-                               mid[gtk.STATE_SELECTED], 0.25)
-
-        self.bg_colors = {
-            gtk.STATE_NORMAL: (f(rgb.shade(mid[gtk.STATE_NORMAL], 1.20)),
-                                f(rgb.shade(mid[gtk.STATE_NORMAL], 1.05))),
-
-            gtk.STATE_ACTIVE: (f(rgb.shade(active, 1.20)),
-                               f(rgb.shade(active, 1.05))),
-
-            gtk.STATE_SELECTED: (f(rgb.shade(mid[gtk.STATE_ACTIVE], 1.15)),
-                                f(mid[gtk.STATE_ACTIVE])),
-
-            gtk.STATE_INSENSITIVE: (f(mid[gtk.STATE_INSENSITIVE]),
-                                     f(mid[gtk.STATE_INSENSITIVE])),
-
-            self.PRELIT_NORMAL: (f(rgb.shade(mid[gtk.STATE_NORMAL], 1.35)),
-                                 f(rgb.shade(mid[gtk.STATE_NORMAL], 1.15))),
-
-            self.PRELIT_ACTIVE: (f(rgb.shade(active, 1.35)),
-                                 f(rgb.shade(active, 1.15)))
-            }
-
-        self.dark_line_colors = {
-            gtk.STATE_NORMAL: f(rgb.shade(dark[gtk.STATE_ACTIVE], 0.975)),
-            gtk.STATE_ACTIVE: f(rgb.shade(dark[gtk.STATE_ACTIVE], 0.975)),
-            gtk.STATE_SELECTED: f(rgb.shade(dark[gtk.STATE_ACTIVE], 0.95)),
-            gtk.STATE_PRELIGHT: f(dark[gtk.STATE_PRELIGHT]),
-            gtk.STATE_INSENSITIVE: f(dark[gtk.STATE_INSENSITIVE])
-            }
-
-        self.light_line_colors = {
-            gtk.STATE_NORMAL: None,
-            gtk.STATE_ACTIVE: None,
-            gtk.STATE_SELECTED: f(mid[gtk.STATE_ACTIVE]),
-            gtk.STATE_PRELIGHT: f(light[gtk.STATE_PRELIGHT]),
-            gtk.STATE_INSENSITIVE: f(light[gtk.STATE_INSENSITIVE])
-            }
-
-        self.text_state = {
-            gtk.STATE_NORMAL: gtk.STATE_NORMAL,
-            gtk.STATE_ACTIVE: gtk.STATE_ACTIVE,
-            gtk.STATE_SELECTED: gtk.STATE_NORMAL,
-            gtk.STATE_PRELIGHT: gtk.STATE_PRELIGHT,
-            gtk.STATE_INSENSITIVE: gtk.STATE_INSENSITIVE
-            }
-
-        self.base_hack = None
-        return
-
-
-class PathBarThemeDust(PathBarThemeHuman):
-
-    def __init__(self):
-        PathBarThemeHuman.__init__(self)
-        return
-
-    def load(self, style):
-        mid = style.mid
-        dark = style.dark
-        light = style.light
-        text = style.text
-        active = rgb.mix_color(mid[gtk.STATE_NORMAL],
-                               light[gtk.STATE_SELECTED], 0.3)
-
-        self.bg_colors = {
-            gtk.STATE_NORMAL: (f(rgb.shade(mid[gtk.STATE_NORMAL], 1.3)),
-                                f(mid[gtk.STATE_NORMAL])),
-
-            gtk.STATE_ACTIVE: (f(rgb.shade(active, 1.3)),
-                               f(active)),
-
-            gtk.STATE_SELECTED: (f(rgb.shade(mid[gtk.STATE_NORMAL], 0.95)),
-                                 f(rgb.shade(mid[gtk.STATE_NORMAL], 0.95))),
-
-            self.PRELIT_NORMAL: (f(rgb.shade(mid[gtk.STATE_NORMAL], 1.35)),
-                                 f(rgb.shade(mid[gtk.STATE_NORMAL], 1.15))),
-
-            gtk.STATE_INSENSITIVE: (f(rgb.shade(mid[gtk.STATE_INSENSITIVE], 1.09)),
-                                    f(rgb.shade(mid[gtk.STATE_INSENSITIVE], 1.08))),
-
-            self.PRELIT_ACTIVE: (f(rgb.shade(active, 1.35)),
-                                 f(rgb.shade(active, 1.15)))
-            }
-
-        self.dark_line_colors = {
-            gtk.STATE_NORMAL: f(dark[gtk.STATE_ACTIVE]),
-            gtk.STATE_ACTIVE: f(dark[gtk.STATE_ACTIVE]),
-            gtk.STATE_SELECTED: f(rgb.shade(dark[gtk.STATE_ACTIVE], 0.95)),
-            gtk.STATE_PRELIGHT: f(dark[gtk.STATE_PRELIGHT]),
-            gtk.STATE_INSENSITIVE: f(dark[gtk.STATE_INSENSITIVE])
-            }
-
-        self.light_line_colors = {
-            gtk.STATE_NORMAL: f(light[gtk.STATE_NORMAL]),
-            gtk.STATE_ACTIVE: f(light[gtk.STATE_NORMAL]),
-            gtk.STATE_SELECTED: None,
-            gtk.STATE_PRELIGHT: f(light[gtk.STATE_PRELIGHT]),
-            gtk.STATE_INSENSITIVE: f(rgb.shade(light[gtk.STATE_INSENSITIVE], 0.96))
-            }
-
-        self.text_state = {
-            gtk.STATE_NORMAL: gtk.STATE_NORMAL,
-            gtk.STATE_ACTIVE: gtk.STATE_ACTIVE,
-            gtk.STATE_SELECTED: gtk.STATE_NORMAL,
-            gtk.STATE_PRELIGHT: gtk.STATE_PRELIGHT,
-            gtk.STATE_INSENSITIVE: gtk.STATE_INSENSITIVE
-            }
-
-        self.base_hack = None
-        return
-
-
-class PathBarThemeNewWave(PathBarThemeHuman):
-
-    curvature = 1.5
-
-    def __init__(self):
-        PathBarThemeHuman.__init__(self)
-        return
-
-    def load(self, style):
-        mid = style.mid
-        dark = style.dark
-        light = style.light
-        text = style.text
-        active = rgb.mix_color(mid[gtk.STATE_NORMAL],
-                               light[gtk.STATE_SELECTED], 0.5)
-        top_step = gtk.gdk.color_parse('#FDCF9D')
-        btm_step = gtk.gdk.color_parse('#FCAE87')
-
-        self.bg_colors = {
-            gtk.STATE_NORMAL: (f(rgb.shade(mid[gtk.STATE_NORMAL], 1.01)),
-                                f(mid[gtk.STATE_NORMAL])),
-
-            gtk.STATE_ACTIVE: (f(top_step),
-                                 f(btm_step)),
-
-            gtk.STATE_SELECTED: (f(top_step),
-                                 f(btm_step)),
-
-            gtk.STATE_INSENSITIVE: (f(rgb.shade(mid[gtk.STATE_INSENSITIVE], 1.075)),
-                                    f(rgb.shade(mid[gtk.STATE_INSENSITIVE], 1.075))),
-
-            self.PRELIT_NORMAL: (f(rgb.shade(mid[gtk.STATE_NORMAL], 1.2)),
-                                 f(rgb.shade(mid[gtk.STATE_NORMAL], 1.15))),
-
-            self.PRELIT_ACTIVE: (f(rgb.shade(top_step, 1.11)),
-                                 f(rgb.shade(btm_step, 1.06))),
-            }
-
-        self.dark_line_colors = {
-            gtk.STATE_NORMAL: f(rgb.shade(dark[gtk.STATE_ACTIVE], 0.95)),
-            gtk.STATE_ACTIVE: f(rgb.shade(dark[gtk.STATE_ACTIVE], 0.95)),
-            gtk.STATE_SELECTED: f(rgb.shade(dark[gtk.STATE_ACTIVE], 0.95)),
-            gtk.STATE_PRELIGHT: f(dark[gtk.STATE_PRELIGHT]),
-            gtk.STATE_INSENSITIVE: f(dark[gtk.STATE_INSENSITIVE])
-            }
-
-        self.light_line_colors = {
-            gtk.STATE_NORMAL: f(rgb.shade(light[gtk.STATE_NORMAL], 1.2)),
-            gtk.STATE_ACTIVE: f(rgb.shade(light[gtk.STATE_NORMAL], 1.2)),
-            gtk.STATE_SELECTED: None,
-            gtk.STATE_PRELIGHT: f(rgb.shade(light[gtk.STATE_PRELIGHT], 1.2)),
-            gtk.STATE_INSENSITIVE: f(light[gtk.STATE_INSENSITIVE])
-            }
-
-        self.text_state = {
-            gtk.STATE_NORMAL: gtk.STATE_NORMAL,
-            gtk.STATE_ACTIVE: gtk.STATE_ACTIVE,
-            gtk.STATE_SELECTED: gtk.STATE_NORMAL,
-            gtk.STATE_PRELIGHT: gtk.STATE_PRELIGHT,
-            gtk.STATE_INSENSITIVE: gtk.STATE_INSENSITIVE
-            }
-
-        self.base_hack = f(gtk.gdk.color_parse("#F2F2F2"))
-        return
-
-
-class PathBarThemeHicolor:
-
-    PRELIT_NORMAL = 10
-    PRELIT_ACTIVE = 11
-
-    curvature = 0.5
-    min_part_width = 56
-    xpadding = 15
-    ypadding = 10
-    spacing = 10
-    arrow_width = 15
-    scroll_duration_ms = 150
-    scroll_fps = 50
-    animate = gtk.settings_get_default().get_property("gtk-enable-animations")
-
-    def __init__(self):
-        return
-
-    def load(self, style):
-        mid = style.mid
-        dark = style.dark
-        light = style.light
-        text = style.text
-
-        self.bg_colors = {
-            gtk.STATE_NORMAL: (f(mid[gtk.STATE_NORMAL]),
-                               f(mid[gtk.STATE_NORMAL])),
-
-            gtk.STATE_ACTIVE: (f(mid[gtk.STATE_ACTIVE]),
-                               f(mid[gtk.STATE_ACTIVE])),
-
-            gtk.STATE_SELECTED: (f(mid[gtk.STATE_SELECTED]),
-                                 f(mid[gtk.STATE_SELECTED])),
-
-            gtk.STATE_INSENSITIVE: (f(mid[gtk.STATE_INSENSITIVE]),
-                                     f(mid[gtk.STATE_INSENSITIVE])),
-
-            self.PRELIT_NORMAL: (f(mid[gtk.STATE_PRELIGHT]),
-                                 f(mid[gtk.STATE_PRELIGHT])),
-
-            self.PRELIT_ACTIVE: (f(mid[gtk.STATE_PRELIGHT]),
-                                 f(mid[gtk.STATE_PRELIGHT]))
-            }
-
-        self.dark_line_colors = {
-            gtk.STATE_NORMAL: f(dark[gtk.STATE_NORMAL]),
-            gtk.STATE_ACTIVE: f(dark[gtk.STATE_ACTIVE]),
-            gtk.STATE_SELECTED: f(dark[gtk.STATE_SELECTED]),
-            gtk.STATE_PRELIGHT: f(dark[gtk.STATE_PRELIGHT]),
-            gtk.STATE_INSENSITIVE: f(dark[gtk.STATE_INSENSITIVE])
-            }
-
-        self.light_line_colors = {
-            gtk.STATE_NORMAL: f(light[gtk.STATE_NORMAL]),
-            gtk.STATE_ACTIVE: f(light[gtk.STATE_ACTIVE]),
-            gtk.STATE_SELECTED: None,
-            gtk.STATE_PRELIGHT: f(light[gtk.STATE_PRELIGHT]),
-            gtk.STATE_INSENSITIVE: f(light[gtk.STATE_INSENSITIVE])
-            }
-
-        self.text_state = {
-            gtk.STATE_NORMAL: gtk.STATE_NORMAL,
-            gtk.STATE_ACTIVE: gtk.STATE_ACTIVE,
-            gtk.STATE_SELECTED: gtk.STATE_SELECTED,
-            gtk.STATE_PRELIGHT: gtk.STATE_PRELIGHT,
-            gtk.STATE_INSENSITIVE: gtk.STATE_INSENSITIVE
-            }
-
-        self.base_hack = None
-        return
-
-
-class PathBarThemes:
-
-    DICT = {
-        "Human": PathBarThemeHuman,
-        "Human-Clearlooks": PathBarThemeHumanClearlooks,
-        "InHuman": PathBarThemeInHuman,
-        "HighContrastInverse": PathBarThemeHicolor,
-        "HighContrastLargePrintInverse": PathBarThemeHicolor,
-        "Dust": PathBarThemeDust,
-        "Dust Sand": PathBarThemeDust,
-        "New Wave": PathBarThemeNewWave
-        }
-
-
-class NavigationBar(PathBar):
-    def __init__(self, group=None):
-        PathBar.__init__(self)
-        self.set_size_request(-1, 28)
-        self.id_to_part = {}
-        return
-
-    def add_with_id(self, label, callback, id, icon=None, 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
-        """
-
-        # 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]
-            part.set_label(label)
-        else:
-            part = PathPart(parent=self, label=label, callback=callback)
-            part.set_name(id)
-            part.set_pathbar(self)
-            part.id = id
-            self.id_to_part[id] = part
-            # check if animation should be used
-            if animate:
-                if do_callback:
-                    gobject.timeout_add(150, self.append, part)
-                else:
-                    gobject.timeout_add(150, self.append_no_callback, part)
-            else:
-                self.append(part, do_callback, animate=False)
-
-        if icon: 
-            part.set_icon(icon)
-        return
-
-    def remove_id(self, id):
-        if not id in self.id_to_part:
-            return
-
-        part = self.id_to_part[id]
-        del self.id_to_part[id]
-        self.remove(part)
-        return
-
-    def get_button_from_id(self, id):
-        """
-        return the button for the given id (or None)
-        """
-        if not id in self.id_to_part:
-            return None
-        return self.id_to_part[id]
-
-    def get_label(self, id):
-        """
-        Return the label of the navigation button with the given id
-        """
-        if not id in self.id_to_part:
-            return
-
 
=== added file 'softwarecenter/view/widgets/pathbar_common.py'
--- softwarecenter/view/widgets/pathbar_common.py	1970-01-01 00:00:00 +0000
+++ softwarecenter/view/widgets/pathbar_common.py	2010-04-04 06:00:32 +0000
@@ -0,0 +1,827 @@
+# Copyright (C) 2010 Matthew McGowan
+#
+# 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, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+import gtk
+import cairo
+import colorsys
+
+
+# pi constants
+M_PI = 3.1415926535897931
+PI_OVER_180 = 0.017453292519943295
+
+SHAPE_RECTANGLE = 0
+SHAPE_START_ARROW = 1
+SHAPE_MID_ARROW = 2
+SHAPE_END_CAP = 3
+
+
+class PathBarStyle:
+
+    def __init__(self, pathbar):
+        self.shape_map = self._load_shape_map(pathbar)
+
+        gtk_settings = gtk.settings_get_default()
+        self.theme = self._load_theme(gtk_settings)
+        self.theme.build_palette(gtk_settings)
+        self.properties = self.theme.get_properties(gtk_settings)
+        self.gradients = self.theme.get_grad_palette()
+        self.dark_line = self.theme.get_dark_line_palette()
+        self.light_line = self.theme.get_light_line_palette()
+        self.text = self.theme.get_text_palette()
+        self.text_states = self.theme.get_text_states()
+        self.base_color = None
+        return
+
+    def __getitem__(self, item):
+        if self.properties.has_key(item):
+            return self.properties[item]
+        print 'Key does not exist in the style profile:', item
+        return None
+
+    def _load_shape_map(self, pathbar):
+        if pathbar.get_direction() != gtk.TEXT_DIR_RTL:
+            shmap = {SHAPE_RECTANGLE:   self._shape_rectangle,
+                     SHAPE_START_ARROW: self._shape_start_arrow_ltr,
+                     SHAPE_MID_ARROW:   self._shape_mid_arrow_ltr,
+                     SHAPE_END_CAP:     self._shape_end_cap_ltr}
+        else:
+            shmap = {SHAPE_RECTANGLE:   self._shape_rectangle,
+                     SHAPE_START_ARROW: self._shape_start_arrow_rtl,
+                     SHAPE_MID_ARROW:   self._shape_mid_arrow_rtl,
+                     SHAPE_END_CAP:     self._shape_end_cap_rtl}
+        return shmap
+
+    def _load_theme(self, gtksettings):
+        name = gtksettings.get_property("gtk-theme-name")
+        r = ThemeRegistry()
+        return r.retrieve(name)
+
+    def _shape_rectangle(self, cr, x, y, w, h, r, aw):
+        global M_PI, PI_OVER_180
+        cr.new_sub_path()
+        cr.arc(r+x, r+y, r, M_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, M_PI)
+        cr.close_path()
+        return
+
+    def _shape_start_arrow_ltr(self, cr, x, y, w, h, r, aw):
+        global M_PI, PI_OVER_180
+        cr.new_sub_path()
+        cr.arc(r+x, r+y, r, M_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, M_PI)
+        cr.close_path()
+        return
+
+    def _shape_mid_arrow_ltr(self, cr, x, y, w, h, r, aw):
+        cr.move_to(0, 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(0, h)
+        cr.close_path()
+        return
+
+    def _shape_end_cap_ltr(self, cr, x, y, w, h, r, aw):
+        global M_PI, PI_OVER_180
+        cr.move_to(0, 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(0, h)
+        cr.close_path()
+        return
+
+    def _shape_start_arrow_rtl(self, cr, x, y, w, h, r, aw):
+        global M_PI, PI_OVER_180
+        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()
+        return
+
+    def _shape_mid_arrow_rtl(self, cr, x, y, w, h, r, aw):
+        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()
+        return
+
+    def _shape_end_cap_rtl(self, cr, x, y, w, h, r, aw):
+        global M_PI, PI_OVER_180
+        cr.arc(r+x, r+y, r, M_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, M_PI)
+        cr.close_path()
+        return
+
+    def set_direction(self, direction):
+        if direction != gtk.TEXT_DIR_RTL:
+            self.shape_map = {SHAPE_RECTANGLE:   self._shape_rectangle,
+                              SHAPE_START_ARROW: self._shape_start_arrow_ltr,
+                              SHAPE_MID_ARROW:   self._shape_mid_arrow_ltr,
+                              SHAPE_END_CAP:     self._shape_end_cap_ltr}
+        else:
+            self.shape_map = {SHAPE_RECTANGLE:   self._shape_rectangle,
+                              SHAPE_START_ARROW: self._shape_start_arrow_rtl,
+                              SHAPE_MID_ARROW:   self._shape_mid_arrow_rtl,
+                              SHAPE_END_CAP:     self._shape_end_cap_rtl}
+        return
+
+    def paint_bg(self, cr, part, x, y, w, h, sxO=0):
+        shape = self.shape_map[part.shape]
+        state = part.state
+        r = self["curvature"]
+        aw = self["arrow_width"]
+
+        cr.save()
+        cr.rectangle(x, y, w+1, h)
+        cr.clip()
+        cr.translate(x+0.5-sxO, y+0.5)
+
+        w -= 1
+        h -= 1
+
+        # bg linear vertical gradient
+        color1, color2 = self.gradients[state]
+
+        shape(cr, 0, 0, w, h, r, aw)
+        lin = cairo.LinearGradient(0, 0, 0, h)
+        lin.add_color_stop_rgb(0.0, *color1.tofloats())
+        lin.add_color_stop_rgb(1.0, *color2.tofloats())
+        cr.set_source(lin)
+        cr.fill()
+
+        cr.set_line_width(1.0)
+        # strong outline
+        shape(cr, 0, 0, w, h, r, aw)
+        cr.set_source_rgb(*self.dark_line[state].tofloats())
+        cr.stroke()
+
+        # inner bevel/highlight
+        if r == 0: w += 1
+        shape(cr, 1, 1, w-1, h-1, r, aw)
+        cr.set_source_rgb(*self.light_line[state].tofloats())
+        cr.stroke()
+        cr.restore()
+        return
+
+    def paint_layout(self, widget, part, x, y, sxO=0):
+        # draw layout
+        layout = part.get_layout()
+        widget.style.paint_layout(widget.window,
+                                  self.text_states[part.state],
+                                  False,
+                                  None,   # clip area
+                                  widget,
+                                  None,
+                                  x, y,
+                                  layout)
+        return
+
+    def paint_focus(self, cr, x, y, w, h):
+        self._shape_rectangle(cr, 4, 4, w-4, h-4, self["curvature"], 0)
+        cr.set_source_rgb(*self.theme.bg[gtk.STATE_SELECTED].tofloats())
+        cr.stroke()
+        return
+
+
+class PathBarColorArray:
+
+    def __init__(self, color_array):
+        self.color_array = {}
+        for state in (gtk.STATE_NORMAL, gtk.STATE_ACTIVE, gtk.STATE_SELECTED, \
+            gtk.STATE_PRELIGHT, gtk.STATE_INSENSITIVE):
+            self.color_array[state] = color_from_gdkcolor(color_array[state])
+        return
+
+    def __getitem__(self, state):
+        return self.color_array[state]
+
+
+class PathBarColor:
+
+    def __init__(self, red, green, blue):
+        self.red = red
+        self.green = green
+        self.blue = blue
+        return
+
+    def set_alpha(self, value):
+        self.alpha = value
+        return
+
+    def tofloats(self):
+        return self.red, self.green, self.blue
+
+    def toclutter(self):
+        try:
+            from clutter import Color
+        except Exception, e:
+            print 'Error parsing color:', e
+            raise SystemExit
+        r,g,b = self.tofloats()
+        return Color(int(r*255), int(g*255), int(b*255))
+
+    def togtkgdk(self):
+        r,g,b = self.tofloats()
+        return gtk.gdk.Color(int(r*65535), int(g*65535), int(b*65535))
+
+    def lighten(self):
+        return self.shade(1.3)
+
+    def darken(self):
+        return self.shade(0.7)
+
+    def shade(self, factor):
+        # as seen in clutter-color.c
+        h,l,s = colorsys.rgb_to_hls(*self.tofloats())
+
+        l *= factor
+        if l > 1.0:
+            l = 1.0
+        elif l < 0:
+            l = 0
+
+        s *= factor
+        if s > 1.0:
+            s = 1.0
+        elif s < 0:
+            s = 0
+
+        r,g,b = colorsys.hls_to_rgb(h,l,s)
+        return PathBarColor(r,g,b)
+
+    def mix(self, color2, mix_factor):
+        # as seen in Murrine's cairo-support.c
+        r1, g1, b1 = self.tofloats()
+        r2, g2, b2 = color2.tofloats()
+        r = r1*(1-mix_factor)+r2*mix_factor
+        g = g1*(1-mix_factor)+g2*mix_factor
+        b = b1*(1-mix_factor)+b2*mix_factor
+        return PathBarColor(r,g,b)
+
+
+class Theme:
+
+    def build_palette(self, gtksettings):
+        style = gtk.rc_get_style_by_paths(gtksettings,
+                                          'GtkWindow',
+                                          'GtkWindow',
+                                          gtk.Window)
+
+        style = style or gtk.widget_get_default_style()
+
+        # build pathbar color palette
+        self.fg =    PathBarColorArray(style.fg)
+        self.bg =    PathBarColorArray(style.bg)
+        self.text =  PathBarColorArray(style.text)
+        self.base =  PathBarColorArray(style.base)
+        self.light = PathBarColorArray(style.base)
+        self.mid =   PathBarColorArray(style.base)
+        self.dark =  PathBarColorArray(style.base)
+        return
+
+
+class Human(Theme):
+
+    def get_properties(self, gtksettings):
+        props = {
+            'curvature': 2.5,
+            'min_part_width': 48,
+            'xpad': 8,
+            'ypad': 4,
+            'xthickness': 1,
+            'ythickness': 1,
+            'spacing': 5,
+            'arrow_width': 13,
+            'scroll_duration': 150,
+            'enable-animations': gtksettings.get_property("gtk-enable-animations"),
+            'override_base': False
+            }
+        return props
+
+    def get_grad_palette(self):
+        # provide two colours per state for background vertical linear gradients
+        palette = {gtk.STATE_NORMAL:  (self.bg[gtk.STATE_NORMAL].shade(1.1),
+                                       self.bg[gtk.STATE_NORMAL].shade(0.95)),
+
+                  gtk.STATE_ACTIVE:   (self.bg[gtk.STATE_NORMAL].shade(1.00),
+                                       self.bg[gtk.STATE_NORMAL].shade(0.75)),
+
+                  gtk.STATE_SELECTED: (self.bg[gtk.STATE_NORMAL].shade(1.11),
+                                       self.bg[gtk.STATE_NORMAL]),
+
+                  gtk.STATE_PRELIGHT: (self.bg[gtk.STATE_NORMAL].shade(0.96),
+                                       self.bg[gtk.STATE_NORMAL].shade(0.91)),
+
+                  gtk.STATE_INSENSITIVE: (self.bg[gtk.STATE_INSENSITIVE],
+                                          self.bg[gtk.STATE_INSENSITIVE])
+                  }
+        return palette
+
+    def get_text_palette(self):
+        palette = {gtk.STATE_NORMAL:   self.fg[gtk.STATE_NORMAL],
+                   gtk.STATE_ACTIVE:   self.fg[gtk.STATE_NORMAL],
+                   gtk.STATE_SELECTED: self.fg[gtk.STATE_NORMAL],
+                   gtk.STATE_PRELIGHT: self.fg[gtk.STATE_NORMAL],
+                   gtk.STATE_INSENSITIVE: self.text[gtk.STATE_INSENSITIVE]}
+        return palette
+
+    def get_dark_line_palette(self):
+        palette = {gtk.STATE_NORMAL:   self.bg[gtk.STATE_NORMAL].darken(),
+                   gtk.STATE_ACTIVE:   self.bg[gtk.STATE_NORMAL].darken(),
+                   gtk.STATE_PRELIGHT: self.bg[gtk.STATE_NORMAL].darken(),
+                   gtk.STATE_SELECTED: self.bg[gtk.STATE_NORMAL].darken(),
+                   gtk.STATE_INSENSITIVE: self.bg[gtk.STATE_INSENSITIVE].darken()}
+        return palette
+
+    def get_light_line_palette(self):
+        palette = {gtk.STATE_NORMAL:   self.bg[gtk.STATE_NORMAL].lighten(),
+                   gtk.STATE_ACTIVE:   self.fg[gtk.STATE_NORMAL],
+                   gtk.STATE_PRELIGHT: self.bg[gtk.STATE_NORMAL].lighten(),
+                   gtk.STATE_SELECTED: self.bg[gtk.STATE_NORMAL].lighten(),
+                   gtk.STATE_INSENSITIVE: self.light[gtk.STATE_INSENSITIVE]}
+        return palette
+
+    def get_text_states(self):
+        states = {gtk.STATE_NORMAL:   gtk.STATE_NORMAL,
+                  gtk.STATE_ACTIVE:   gtk.STATE_NORMAL,
+                  gtk.STATE_PRELIGHT: gtk.STATE_NORMAL,
+                  gtk.STATE_SELECTED: gtk.STATE_NORMAL,
+                  gtk.STATE_INSENSITIVE: gtk.STATE_INSENSITIVE}
+        return states
+
+
+class Clearlooks(Human):
+
+    def get_properties(self, gtksettings):
+        props = Human.get_properties(self, gtksettings)
+        props['curvature'] = 3.5
+        return props
+
+    def get_grad_palette(self):
+        # provide two colours per state for background vertical linear gradients
+
+        selected_color = self.bg[gtk.STATE_NORMAL].mix(self.bg[gtk.STATE_SELECTED],
+                                                       0.2)
+
+        palette = {gtk.STATE_NORMAL:  (self.bg[gtk.STATE_NORMAL].shade(1.15),
+                                       self.bg[gtk.STATE_NORMAL].shade(0.95)),
+
+                  gtk.STATE_ACTIVE:   (self.bg[gtk.STATE_ACTIVE],
+                                       self.bg[gtk.STATE_ACTIVE]),
+
+                  gtk.STATE_SELECTED: (selected_color.shade(1.175),
+                                       selected_color),
+
+                  gtk.STATE_PRELIGHT: (self.bg[gtk.STATE_NORMAL].shade(1.3),
+                                       selected_color.shade(1.1)),
+
+                  gtk.STATE_INSENSITIVE: (self.bg[gtk.STATE_INSENSITIVE],
+                                          self.bg[gtk.STATE_INSENSITIVE])
+                  }
+        return palette
+
+    def get_light_line_palette(self):
+        palette = Human.get_light_line_palette(self)
+        palette[gtk.STATE_ACTIVE] = self.bg[gtk.STATE_ACTIVE]
+        return palette
+
+
+class InHuman(Theme):
+
+    def get_properties(self, gtksettings):
+        props = {
+            'curvature': 2.5,
+            'min_part_width': 48,
+            'xpad': 8,
+            'ypad': 4,
+            'xthickness': 1,
+            'ythickness': 1,
+            'spacing': 5,
+            'arrow_width': 13,
+            'scroll_duration': 150,
+            'enable-animations': gtksettings.get_property("gtk-enable-animations"),
+            'override_base': False
+            }
+        return props
+
+    def get_grad_palette(self):
+        # provide two colours per state for background vertical linear gradients
+        palette = {gtk.STATE_NORMAL:  (self.bg[gtk.STATE_NORMAL].shade(1.1),
+                                       self.bg[gtk.STATE_NORMAL].shade(0.95)),
+
+                  gtk.STATE_ACTIVE:   (self.bg[gtk.STATE_NORMAL].shade(1.00),
+                                       self.bg[gtk.STATE_NORMAL].shade(0.75)),
+
+                  gtk.STATE_SELECTED: (self.bg[gtk.STATE_NORMAL].shade(1.09),
+                                       self.bg),
+
+                  gtk.STATE_PRELIGHT: (self.bg[gtk.STATE_SELECTED].shade(1.35),
+                                       self.bg[gtk.STATE_SELECTED].shade(1.1)),
+
+                  gtk.STATE_INSENSITIVE: (self.bg[gtk.STATE_INSENSITIVE],
+                                          self.bg[gtk.STATE_INSENSITIVE])
+                  }
+        return palette
+
+    def get_text_palette(self):
+        palette = {gtk.STATE_NORMAL:   self.text[gtk.STATE_NORMAL],
+                   gtk.STATE_ACTIVE:   self.text[gtk.STATE_NORMAL],
+                   gtk.STATE_SELECTED: self.text[gtk.STATE_NORMAL],
+                   gtk.STATE_PRELIGHT: self.text[gtk.STATE_PRELIGHT],
+                   gtk.STATE_INSENSITIVE: self.text[gtk.STATE_INSENSITIVE]}
+        return palette
+
+    def get_dark_line_palette(self):
+        palette = {gtk.STATE_NORMAL:   self.bg[gtk.STATE_NORMAL].darken(),
+                   gtk.STATE_ACTIVE:   self.bg[gtk.STATE_NORMAL].darken(),
+                   gtk.STATE_PRELIGHT: self.bg[gtk.STATE_NORMAL].darken(),
+                   gtk.STATE_SELECTED: self.bg[gtk.STATE_NORMAL].darken(),
+                   gtk.STATE_INSENSITIVE: self.bg[gtk.STATE_INSENSITIVE].darken()}
+        return palette
+
+    def get_light_line_palette(self):
+        palette = {gtk.STATE_NORMAL:   self.bg[gtk.STATE_NORMAL].lighten(),
+                   gtk.STATE_ACTIVE:   self.bg[gtk.STATE_ACTIVE].lighten(),
+                   gtk.STATE_PRELIGHT: self.bg[gtk.STATE_NORMAL].lighten(),
+                   gtk.STATE_SELECTED: self.bg[gtk.STATE_NORMAL].lighten(),
+                   gtk.STATE_INSENSITIVE: self.bg[gtk.STATE_INSENSITIVE]}
+        return palette
+
+    def get_text_states(self):
+        states = {gtk.STATE_NORMAL:   gtk.STATE_NORMAL,
+                  gtk.STATE_ACTIVE:   gtk.STATE_NORMAL,
+                  gtk.STATE_PRELIGHT: gtk.STATE_NORMAL,
+                  gtk.STATE_SELECTED: gtk.STATE_NORMAL,
+                  gtk.STATE_INSENSITIVE: gtk.STATE_INSENSITIVE}
+        return states
+
+
+class DustSand(Theme):
+
+    def get_properties(self, gtksettings):
+        props = {
+            'curvature': 2.5,
+            'min_part_width': 48,
+            'xpad': 8,
+            'ypad': 4,
+            'xthickness': 1,
+            'ythickness': 1,
+            'spacing': 5,
+            'arrow_width': 13,
+            'scroll_duration': 150,
+            'enable-animations': gtksettings.get_property("gtk-enable-animations"),
+            'override_base': False
+            }
+        return props
+
+    def get_grad_palette(self):
+
+        selected_color = self.bg[gtk.STATE_NORMAL].mix(self.bg[gtk.STATE_SELECTED],
+                                                       0.4)
+
+        prelight_color = self.bg[gtk.STATE_NORMAL].mix(self.bg[gtk.STATE_SELECTED],
+                                                       0.175)
+
+        # provide two colours per state for background vertical linear gradients
+        palette = {gtk.STATE_NORMAL:  (self.bg[gtk.STATE_NORMAL].shade(1.42),
+                                       self.bg[gtk.STATE_NORMAL].shade(1.1)),
+
+                  gtk.STATE_ACTIVE:      (prelight_color,
+                                          prelight_color.shade(1.07)),
+
+                  gtk.STATE_SELECTED:    (selected_color.shade(1.35),
+                                          selected_color.shade(1.1)),
+
+                  gtk.STATE_PRELIGHT:    (prelight_color.shade(1.74),
+                                          prelight_color.shade(1.42)),
+
+                  gtk.STATE_INSENSITIVE: (self.bg[gtk.STATE_INSENSITIVE],
+                                          self.bg[gtk.STATE_INSENSITIVE])
+                  }
+        return palette
+
+    def get_text_palette(self):
+        palette = {gtk.STATE_NORMAL:      self.text[gtk.STATE_NORMAL],
+                   gtk.STATE_ACTIVE:      self.text[gtk.STATE_ACTIVE],
+                   gtk.STATE_SELECTED:    self.text[gtk.STATE_SELECTED],
+                   gtk.STATE_PRELIGHT:    self.text[gtk.STATE_PRELIGHT],
+                   gtk.STATE_INSENSITIVE: self.text[gtk.STATE_INSENSITIVE]}
+        return palette
+
+    def get_dark_line_palette(self):
+        palette = {gtk.STATE_NORMAL:      self.bg[gtk.STATE_NORMAL].shade(0.575),
+                   gtk.STATE_ACTIVE:      self.bg[gtk.STATE_ACTIVE].shade(0.5),
+                   gtk.STATE_PRELIGHT:    self.bg[gtk.STATE_PRELIGHT].shade(0.575),
+                   gtk.STATE_SELECTED:    self.bg[gtk.STATE_SELECTED].shade(0.575),
+                   gtk.STATE_INSENSITIVE: self.bg[gtk.STATE_NORMAL].darken()}
+        return palette
+
+    def get_light_line_palette(self):
+        palette = {gtk.STATE_NORMAL:      self.bg[gtk.STATE_NORMAL].lighten(),
+                   gtk.STATE_ACTIVE:      self.bg[gtk.STATE_ACTIVE].shade(0.95),
+                   gtk.STATE_PRELIGHT:    self.bg[gtk.STATE_PRELIGHT].lighten(),
+                   gtk.STATE_SELECTED:    self.bg[gtk.STATE_NORMAL].lighten(),
+                   gtk.STATE_INSENSITIVE: self.bg[gtk.STATE_INSENSITIVE]}
+        return palette
+
+    def get_text_states(self):
+        states = {gtk.STATE_NORMAL:      gtk.STATE_NORMAL,
+                  gtk.STATE_ACTIVE:      gtk.STATE_NORMAL,
+                  gtk.STATE_PRELIGHT:    gtk.STATE_NORMAL,
+                  gtk.STATE_SELECTED:    gtk.STATE_NORMAL,
+                  gtk.STATE_INSENSITIVE: gtk.STATE_INSENSITIVE}
+        return states
+
+
+class Dust(DustSand):
+
+    def get_grad_palette(self):
+
+        selected_color = self.bg[gtk.STATE_NORMAL].mix(self.bg[gtk.STATE_SELECTED],
+                                                       0.5)
+
+        prelight_color = self.bg[gtk.STATE_NORMAL].mix(self.bg[gtk.STATE_SELECTED],
+                                                       0.175)
+
+        # provide two colours per state for background vertical linear gradients
+        palette = {gtk.STATE_NORMAL:  (self.bg[gtk.STATE_NORMAL].shade(1.4),
+                                       self.bg[gtk.STATE_NORMAL].shade(1.1)),
+
+                  gtk.STATE_ACTIVE:      (self.bg[gtk.STATE_ACTIVE].shade(1.2),
+                                          self.bg[gtk.STATE_ACTIVE]),
+
+                  gtk.STATE_SELECTED:    (selected_color.shade(1.5),
+                                          selected_color.shade(1.2)),
+
+                  gtk.STATE_PRELIGHT:    (prelight_color.shade(1.74),
+                                          prelight_color.shade(1.42)),
+
+                  gtk.STATE_INSENSITIVE: (self.bg[gtk.STATE_INSENSITIVE],
+                                          self.bg[gtk.STATE_INSENSITIVE])
+                  }
+        return palette
+
+    def get_dark_line_palette(self):
+        palette = DustSand.get_dark_line_palette(self)
+        palette[gtk.STATE_SELECTED] = self.bg[gtk.STATE_NORMAL].shade(0.575)
+        return palette
+
+    def get_light_line_palette(self):
+        palette = DustSand.get_light_line_palette(self)
+        palette[gtk.STATE_SELECTED] = self.bg[gtk.STATE_NORMAL].shade(1.15)
+        return palette
+
+
+class Ambiance(DustSand):
+
+    def get_properties(self, gtksettings):
+        props = DustSand.get_properties(self, gtksettings)
+        props['curvature'] = 4.5
+        return props
+
+    def get_grad_palette(self):
+        focus_color = color_from_string('#FE765E')
+        selected_color = self.bg[gtk.STATE_NORMAL].mix(focus_color,
+                                                       0.07)
+        prelight_color = self.bg[gtk.STATE_NORMAL].mix(focus_color,
+                                                       0.33)
+
+        # provide two colours per state for background vertical linear gradients
+        palette = {gtk.STATE_NORMAL:  (self.bg[gtk.STATE_NORMAL].shade(1.2),
+                                       self.bg[gtk.STATE_NORMAL].shade(0.85)),
+
+                  gtk.STATE_ACTIVE:   (self.bg[gtk.STATE_NORMAL].shade(0.96),
+                                       self.bg[gtk.STATE_NORMAL].shade(0.65)),
+
+                  gtk.STATE_SELECTED: (selected_color.shade(1.075),
+                                       selected_color.shade(0.875)),
+
+                  gtk.STATE_PRELIGHT: (prelight_color.shade(1.35),
+                                       prelight_color.shade(1.1)),
+
+                  gtk.STATE_INSENSITIVE: (self.bg[gtk.STATE_INSENSITIVE],
+                                          self.bg[gtk.STATE_INSENSITIVE])
+                  }
+        return palette
+
+
+class Radiance(Ambiance):
+
+    def get_grad_palette(self):
+        palette = Ambiance.get_grad_palette(self)
+        palette[gtk.STATE_NORMAL] =  (self.mid[gtk.STATE_NORMAL].shade(1.25),
+                                      self.bg[gtk.STATE_NORMAL].shade(0.9))
+        return palette
+
+
+class NewWave(Theme):
+
+    def get_properties(self, gtksettings):
+        props = {
+            'curvature': 2,
+            'min_part_width': 48,
+            'xpad': 8,
+            'ypad': 4,
+            'xthickness': 1,
+            'ythickness': 1,
+            'spacing': 4,
+            'arrow_width': 13,
+            'scroll_duration': 150,
+            'enable-animations': gtksettings.get_property("gtk-enable-animations"),
+            'override_base': True
+            }
+        return props
+
+    def get_grad_palette(self):
+        # provide two colours per state for background vertical linear gradients
+
+        active_color = self.bg[gtk.STATE_ACTIVE].mix(color_from_string('#FDCF9D'),
+                                                     0.45)
+
+        selected_color = self.bg[gtk.STATE_NORMAL].mix(color_from_string('#FDCF9D'),
+                                                       0.2)
+
+        palette = {gtk.STATE_NORMAL:  (self.bg[gtk.STATE_NORMAL].shade(1.1),
+                                       self.bg[gtk.STATE_NORMAL].shade(0.95)),
+
+                  gtk.STATE_ACTIVE:   (active_color.shade(1.1),
+                                       self.bg[gtk.STATE_ACTIVE].shade(0.95)),
+
+                  gtk.STATE_PRELIGHT: (color_from_string('#FDCF9D'),
+                                       color_from_string('#FCAE87')),
+
+                  gtk.STATE_SELECTED: (selected_color.shade(1.2),
+                                       selected_color),
+
+                  gtk.STATE_INSENSITIVE: (self.bg[gtk.STATE_INSENSITIVE],
+                                          self.bg[gtk.STATE_INSENSITIVE])
+                  }
+        return palette
+
+    def get_text_palette(self):
+        palette = {gtk.STATE_NORMAL:   self.text[gtk.STATE_NORMAL],
+                   gtk.STATE_ACTIVE:   self.text[gtk.STATE_NORMAL],
+                   gtk.STATE_PRELIGHT: self.text[gtk.STATE_NORMAL],
+                   gtk.STATE_SELECTED: self.text[gtk.STATE_SELECTED],
+                   gtk.STATE_INSENSITIVE: self.text[gtk.STATE_INSENSITIVE]}
+        return palette
+
+    def get_dark_line_palette(self):
+        palette = {gtk.STATE_NORMAL:   self.bg[gtk.STATE_NORMAL].darken(),
+                   gtk.STATE_ACTIVE:   self.bg[gtk.STATE_NORMAL].darken(),
+                   gtk.STATE_PRELIGHT: self.bg[gtk.STATE_NORMAL].darken(),
+                   gtk.STATE_SELECTED: self.bg[gtk.STATE_NORMAL].darken(),
+                   gtk.STATE_INSENSITIVE: self.bg[gtk.STATE_INSENSITIVE].darken()}
+        return palette
+
+    def get_light_line_palette(self):
+        palette = {gtk.STATE_NORMAL:   self.bg[gtk.STATE_NORMAL].lighten(),
+                   gtk.STATE_ACTIVE:   self.bg[gtk.STATE_ACTIVE].shade(0.97),
+                   gtk.STATE_PRELIGHT: color_from_string('#FDCF9D'),
+                   gtk.STATE_SELECTED: self.bg[gtk.STATE_SELECTED].lighten(),
+                   gtk.STATE_INSENSITIVE: self.bg[gtk.STATE_INSENSITIVE]}
+        return palette
+
+    def get_text_states(self):
+        states = {gtk.STATE_NORMAL:   gtk.STATE_NORMAL,
+                  gtk.STATE_ACTIVE:   gtk.STATE_NORMAL,
+                  gtk.STATE_PRELIGHT: gtk.STATE_NORMAL,
+                  gtk.STATE_SELECTED: gtk.STATE_NORMAL,
+                  gtk.STATE_INSENSITIVE: gtk.STATE_INSENSITIVE}
+        return states
+
+
+class Hicolor(Theme):
+
+    def get_properties(self, gtksettings):
+        props = {
+            'curvature': 0,
+            'min_part_width': 48,
+            'xpad': 15,
+            'ypad': 10,
+            'xthickness': 2,
+            'ythickness': 2,
+            'spacing': 10,
+            'arrow_width': 15,
+            'scroll_duration': 150,
+            'enable-animations': gtksettings.get_property("gtk-enable-animations"),
+            'override_base': False
+            }
+        return props
+
+    def get_grad_palette(self):
+        # provide two colours per state for background vertical linear gradients
+        palette = {gtk.STATE_NORMAL:     (self.mid[gtk.STATE_NORMAL],
+                                          self.mid[gtk.STATE_NORMAL]),
+
+                  gtk.STATE_ACTIVE:      (self.mid[gtk.STATE_ACTIVE],
+                                          self.mid[gtk.STATE_ACTIVE]),
+
+                  gtk.STATE_SELECTED:    (self.mid[gtk.STATE_SELECTED],
+                                          self.mid[gtk.STATE_SELECTED]),
+
+                  gtk.STATE_PRELIGHT:    (self.mid[gtk.STATE_PRELIGHT],
+                                          self.mid[gtk.STATE_PRELIGHT]),
+
+                  gtk.STATE_INSENSITIVE: (self.bg[gtk.STATE_INSENSITIVE],
+                                          self.bg[gtk.STATE_INSENSITIVE])
+                  }
+        return palette
+
+    def get_text_palette(self):
+        palette = {gtk.STATE_NORMAL:      self.text[gtk.STATE_NORMAL],
+                   gtk.STATE_ACTIVE:      self.text[gtk.STATE_ACTIVE],
+                   gtk.STATE_SELECTED:    self.text[gtk.STATE_SELECTED],
+                   gtk.STATE_PRELIGHT:    self.text[gtk.STATE_PRELIGHT],
+                   gtk.STATE_INSENSITIVE: self.text[gtk.STATE_INSENSITIVE]}
+        return palette
+
+    def get_dark_line_palette(self):
+        palette = {gtk.STATE_NORMAL:      self.bg[gtk.STATE_SELECTED],
+                   gtk.STATE_ACTIVE:      self.dark[gtk.STATE_ACTIVE],
+                   gtk.STATE_PRELIGHT:    self.dark[gtk.STATE_PRELIGHT],
+                   gtk.STATE_SELECTED:    self.dark[gtk.STATE_SELECTED],
+                   gtk.STATE_INSENSITIVE: self.dark[gtk.STATE_INSENSITIVE]}
+        return palette
+
+    def get_light_line_palette(self):
+        palette = {gtk.STATE_NORMAL:      self.bg[gtk.STATE_SELECTED],
+                   gtk.STATE_ACTIVE:      self.light[gtk.STATE_ACTIVE],
+                   gtk.STATE_PRELIGHT:    self.light[gtk.STATE_PRELIGHT],
+                   gtk.STATE_SELECTED:    self.light[gtk.STATE_SELECTED],
+                   gtk.STATE_INSENSITIVE: self.light[gtk.STATE_INSENSITIVE]}
+        return palette
+
+    def get_text_states(self):
+        states = {gtk.STATE_NORMAL:      gtk.STATE_NORMAL,
+                  gtk.STATE_ACTIVE:      gtk.STATE_ACTIVE,
+                  gtk.STATE_PRELIGHT:    gtk.STATE_PRELIGHT,
+                  gtk.STATE_SELECTED:    gtk.STATE_SELECTED,
+                  gtk.STATE_INSENSITIVE: gtk.STATE_INSENSITIVE}
+        return states
+
+
+class ThemeRegistry:
+
+    REGISTRY = {"Human": Human,
+                "Human-Clearlooks": Clearlooks,
+                "Clearlooks": Clearlooks,
+                "InHuman": InHuman,
+                "HighContrastInverse": Hicolor,
+                "HighContrastLargePrintInverse": Hicolor,
+                "Dust": Dust,
+                "Dust Sand": DustSand,
+                "New Wave": NewWave,
+                "Ambiance": Ambiance,
+                "Radiance": Radiance}
+
+    def retrieve(self, theme_name):
+        if self.REGISTRY.has_key(theme_name):
+            print 'Styling hints found for %s...' % theme_name
+            return self.REGISTRY[theme_name]()
+        print "No styling hints for %s were found... using Human hints." % theme_name
+        return Clearlooks()
+
+
+def color_from_gdkcolor(gdkcolor):
+    return PathBarColor(gdkcolor.red_float, gdkcolor.green_float, gdkcolor.blue_float)
+
+
+def color_from_string(spec):
+    color = gtk.gdk.color_parse(spec)
+    return PathBarColor(color.red_float, color.green_float, color.blue_float)
+
+
+
+
 
=== added file 'softwarecenter/view/widgets/pathbar_gtk_atk.py'
--- softwarecenter/view/widgets/pathbar_gtk_atk.py	1970-01-01 00:00:00 +0000
+++ softwarecenter/view/widgets/pathbar_gtk_atk.py	2010-04-04 06:00:32 +0000
@@ -0,0 +1,703 @@
+# Copyright (C) 2010 Matthew McGowan
+#
+# 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, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import atk
+import cairo
+import gobject
+import gtk
+import pango
+import pathbar_common
+
+from gettext import gettext as _
+
+
+class PathBar(gtk.HBox):
+
+    ANIMATE_FPS = 50
+    ANIMATE_DELAY = 150
+    ANIMATE_DURATION = 150
+
+    def __init__(self, group=None):
+        gtk.HBox.__init__(self)
+        self.set_redraw_on_allocate(False)
+
+        self._width = 0
+        self._queue = []
+        self._active_part = None
+        self._out_of_width = False
+        self._button_press_origin = None
+
+        self._animate = False, None
+        self._scroll_xO = 0
+        self._no_draw = False
+        self._scroller = None
+
+        self.theme = pathbar_common.PathBarStyle(self)
+
+        # Accessibility info
+        atk_desc = self.get_accessible()
+        atk_desc.set_name(_("You are here:"))
+        atk_desc.set_role(atk.ROLE_PANEL)
+
+        self.set_events(gtk.gdk.EXPOSURE_MASK)
+        self.connect('expose-event', self._on_expose_event)
+        self.connect('size-allocate', self._on_size_allocate)
+        self.connect('style-set', self._on_style_set)
+        self.connect('realize', self._append_on_realize)
+        return
+
+    def _shrink_check(self, allocation):
+        path_w = self._width
+        overhang = path_w - allocation.width
+        self._width -= overhang
+        mpw = self.theme['min_part_width']
+        for part in self.get_children():
+            w = part.get_size_request()[0]
+            dw = 0
+            if w - overhang <= mpw:
+                overhang -= w-mpw
+                part.set_width(mpw)
+            else:
+                part.set_width(w-overhang)
+                break
+        self._out_of_width = True
+        self.queue_draw()
+        return
+
+    def _grow_check(self, allocation):
+        w_freed = allocation.width - self._width
+        parts = self.get_children()
+        parts.reverse()
+        for part in parts:
+            bw = part.get_best_width()
+            w = part.get_size_request()[0]
+            if w < bw:
+                dw = bw - w
+                if dw <= w_freed:
+                    w_freed -= dw
+                    part.restore_best_width()
+                else:
+                    part.set_width(w + w_freed)
+                    w_freed = 0
+                    break
+
+        self._width = allocation.width - w_freed
+        if self._width < allocation.width:
+            self._out_of_width = False
+        self.queue_draw()
+        return
+
+    def _compose_on_append(self, last_part):
+        parts = self.get_children()
+        if len(parts) == 0:
+            last_part.set_shape(pathbar_common.SHAPE_RECTANGLE)
+        elif len(parts) == 1:
+            root_part = parts[0]
+            root_part.set_shape(pathbar_common.SHAPE_START_ARROW)
+            last_part.set_shape(pathbar_common.SHAPE_END_CAP)
+        else:
+            tail_part = parts[-1]
+            tail_part.set_shape(pathbar_common.SHAPE_MID_ARROW)
+            last_part.set_shape(pathbar_common.SHAPE_END_CAP)
+        return
+
+    def _compose_on_remove(self, last_part):
+        parts = self.get_children()
+        if len(parts) == 1:
+            last_part.set_shape(pathbar_common.SHAPE_RECTANGLE)
+        elif len(parts) == 2:
+            root_part = parts[0]
+            root_part.set_shape(pathbar_common.SHAPE_START_ARROW)
+            last_part.set_shape(pathbar_common.SHAPE_END_CAP)
+        else:
+            tail_part = parts[-1]
+            tail_part.set_shape(pathbar_common.SHAPE_MID_ARROW)
+            last_part.set_shape(pathbar_common.SHAPE_END_CAP)
+        return
+
+    def _part_enter_notify(self, part, event):
+        if part == self._button_press_origin:
+            part.set_state(gtk.STATE_ACTIVE)
+        else:
+            part.set_state(gtk.STATE_PRELIGHT)
+        self._part_queue_draw(part)
+        return
+
+    def _part_leave_notify(self, part, event):
+        if part == self._active_part:
+            part.set_state(gtk.STATE_SELECTED)
+        else:
+            part.set_state(gtk.STATE_NORMAL)
+        self._part_queue_draw(part)
+        return
+
+    def _part_button_press(self, part, event):
+        if event.button != 1: return
+        self._button_press_origin = part
+        part.set_state(gtk.STATE_ACTIVE)
+        self._part_queue_draw(part)
+        return
+
+    def _part_button_release(self, part, event):
+        if event.button != 1: return
+
+        part_region = gtk.gdk.region_rectangle(part.allocation)
+        if not part_region.point_in(*self.window.get_pointer()[:2]):
+            self._button_press_origin = None
+            return
+        if part != self._button_press_origin: return
+        if self._active_part:
+            self._active_part.set_state(gtk.STATE_NORMAL)
+            self._part_queue_draw(self._active_part)
+
+        self.set_active(part)
+        part.set_state(gtk.STATE_PRELIGHT)
+        self._button_press_origin = None
+        self._part_queue_draw(part)
+        return
+
+    def _part_key_press(self, part, event):
+        # react to spacebar, enter, numpad-enter
+        if event.keyval in (32, 65293, 65421):
+            part.set_state(gtk.STATE_ACTIVE)
+            self._part_queue_draw(part)
+        return
+
+    def _part_key_release(self, part, event):
+        # react to spacebar, enter, numpad-enter
+        if event.keyval in (32, 65293, 65421):
+            self.set_active(part)
+            part.set_state(gtk.STATE_SELECTED)
+            self._part_queue_draw(part)
+        return
+
+    def _part_focus_in(self, part, event):
+        self._part_queue_draw(part)
+        return
+
+    def _part_focus_out(self, part, event):
+        self._part_queue_draw(part)
+        return
+
+    def _part_connect_signals(self, part):
+        part.connect('enter-notify-event', self._part_enter_notify)
+        part.connect('leave-notify-event', self._part_leave_notify)
+        part.connect("button-press-event", self._part_button_press)
+        part.connect("button-release-event", self._part_button_release)
+        part.connect("key-press-event", self._part_key_press)
+        part.connect("key-release-event", self._part_key_release)
+        part.connect('focus-in-event', self._part_focus_in)
+        part.connect('focus-out-event', self._part_focus_out)
+        return
+
+    def _part_queue_draw(self, part):
+        a = part.get_allocation()
+        x, y, h = a.x, a.y, a.height
+        w = part.get_draw_width()
+        xo = part.get_draw_xoffset()
+        self.queue_draw_area(x+xo, y, w, h)
+        return
+
+    def _on_expose_event(self, widget, event):
+        if self._scroll_xO:
+            self._expose_scroll(widget, event)
+        else:
+            self._expose_normal(widget, event)
+        return
+
+    def _expose_normal(self, widget, event):
+        theme = self.theme
+        parts = self.get_children()
+        parts.reverse()
+        region = gtk.gdk.region_rectangle(event.area)
+
+        cr = widget.window.cairo_create()
+        cr.rectangle(event.area)
+        cr.clip()
+
+        for part in parts:
+            if not part.invisible:
+                a = part.get_allocation()
+                xo = part.get_draw_xoffset()
+                x, y, w, h = a.x, a.y, a.width, a.height
+                w = part.get_draw_width()
+                theme.paint_bg(cr, part, x+xo, y, w, h)
+
+                x, y, w, h = part.get_layout_points()
+
+                if part.has_focus():
+                    self.style.paint_focus(self.window,
+                                           part.state,
+                                           (a.x+x-4, a.y+y-2, w+8, h+4),
+                                           self,
+                                           'button',
+                                           a.x+x-4, a.y+y-2, w+8, h+4)
+
+                theme.paint_layout(widget, part, a.x+x, a.y+y)
+            else:
+                part.invisible = False
+        del cr
+        return
+
+    def _expose_scroll(self, widget, event):
+        parts = self.get_children()
+        if len(parts) < 2: return
+        static_tail, scroller = parts[-2:]
+
+        if self.get_direction() != gtk.TEXT_DIR_RTL:
+            sxO = self._scroll_xO
+        else:
+            sxO = -self._scroll_xO
+
+        theme = self.theme
+
+        cr = widget.window.cairo_create()
+        cr.rectangle(event.area)
+        cr.clip()
+
+        a = scroller.get_allocation()
+        x, y, w, h = a.x, a.y, a.width, a.height
+        w = scroller.get_draw_width()
+        xo = scroller.get_draw_xoffset()
+        theme.paint_bg(cr, scroller, x+xo-sxO, y, w, h)
+        x, y, w, h = scroller.get_layout_points()
+        theme.paint_layout(widget, scroller, a.x+x-int(sxO), a.y+y)
+
+        a = static_tail.get_allocation()
+        x, y, w, h = a.x, a.y, a.width, a.height
+        w = static_tail.get_draw_width()
+        xo = static_tail.get_draw_xoffset()
+        theme.paint_bg(cr, static_tail, x+xo, y, w, h)
+        del cr
+        return
+
+    def _on_size_allocate(self, widget, allocation):
+        if self._width < allocation.width and self._out_of_width:
+            self._grow_check(allocation)
+        elif self._width >= allocation.width:
+            self._shrink_check(allocation)
+
+        if self._animate[0] and self.theme['enable-animations']:
+            part = self._animate[1]
+            part.invisible = True
+            self._animate = False, None
+            gobject.timeout_add(self.ANIMATE_DELAY, self._scroll_out_init, part)
+        else:
+            self.queue_draw()
+        return
+
+    def _on_style_set(self, widget, old_style):
+        self.theme = pathbar_common.PathBarStyle(self)
+        for part in self.get_children():
+            part.recalc_dimensions()
+        self.queue_draw()
+        return
+
+    def _append_on_realize(self, widget):
+        for part, do_callback, animate in self._queue:
+            self.append(part, do_callback, animate)
+        return
+
+    def _scroll_out_init(self, part):
+        draw_area = part.get_allocation()
+        self._scroller = gobject.timeout_add(
+            max(int(1000.0 / self.ANIMATE_FPS), 10),  # interval
+            self._scroll_out_cb,
+            part.get_size_request()[0],
+            self.ANIMATE_DURATION*0.001,   # 1 over duration (converted to seconds)
+            gobject.get_current_time(),
+            (draw_area.x, draw_area.y,
+            draw_area.width, draw_area.height))
+        return False
+
+    def _scroll_out_cb(self, distance, duration, start_t, draw_area):
+        cur_t = gobject.get_current_time()
+        xO = distance - distance*((cur_t - start_t) / duration)
+
+        if xO > 0:
+            self._scroll_xO = xO
+            self.queue_draw_area(*draw_area)
+
+        else:   # final frame
+            self._scroll_xO = 0
+            # redraw the entire widget
+            # incase some timeouts are skipped due to high system load
+            self.queue_draw_area(*draw_area)
+            self._scroller = None
+            return False
+        return True
+
+    def has_parts(self):
+        return self.get_children() == True
+
+    def get_parts(self):
+        return self.get_children()
+
+    def get_last(self):
+        if self.get_children():
+            return self.get_children()[-1]
+        return None
+
+    def set_active(self, part, do_callback=True):
+        if part == self._active_part: return
+        if self._active_part:
+            self._active_part.set_state(gtk.STATE_NORMAL)
+            self._part_queue_draw(self._active_part)
+
+        part.set_state(gtk.STATE_SELECTED)
+        self._part_queue_draw(part)
+        self._active_part = part
+        if do_callback and part.callback:
+            part.callback(self, part)
+        return
+
+    def get_active(self):
+        return self._active_part
+
+    def set_active_no_callback(self, part):
+        self.set_active(part, False)
+        return
+
+    def append(self, part, do_callback=True, animate=True):
+        if not self.get_property('visible'):
+            self._queue.append([part, do_callback, animate])
+            return
+
+        if self._scroller:
+            gobject.source_remove(self._scroller)
+        self._scroll_xO = 0
+
+        self._compose_on_append(part)
+        self._width += part.get_size_request()[0]
+
+        self.pack_start(part, False)
+        self._part_connect_signals(part)
+        self._animate = animate, part
+        part.show()
+
+        if do_callback:
+            self.set_active(part)
+        else:
+            self.set_active_no_callback(part)
+        return
+
+    def append_no_callback(self, part):
+        self.append(part, do_callback=False)
+
+    def remove(self, part):
+        parts = self.get_children()
+        if len(parts) <= 1: return  # protect last part
+        self._width -= part.get_size_request()[0]
+        part.destroy()
+        self._compose_on_remove(parts[-2])
+        return
+
+    def remove_all(self, keep_first_part=True, do_callback=True):
+        parts = self.get_children()
+        if len(parts) < 1: return
+        if keep_first_part:
+            if len(parts) <= 1: return
+            parts = parts[1:]
+        for part in parts:
+            part.destroy()
+
+        self._width = 0
+        if keep_first_part:
+            root = self.get_parts()[0]
+            root.set_shape(pathbar_common.SHAPE_RECTANGLE)
+            self._width = root.get_size_request()[0]
+            if do_callback: root.callback(self, root)
+        return
+
+    def navigate_up(self):
+        parts = self.get_children()
+        if len(parts) > 1:
+            nav_part = parts[len(parts) - 2]
+            self.set_active(nav_part)
+        return
+
+
+class PathPart(gtk.EventBox):
+
+    def __init__(self, parent, label, callback=None):
+        gtk.EventBox.__init__(self)
+        self.set_redraw_on_allocate(False)
+        self.set_visible_window(False)
+
+        part_atk = self.get_accessible()
+        part_atk.set_name(label)
+        part_atk.set_description(_('Navigates to the %s page.' % label))
+        part_atk.set_role(atk.ROLE_PUSH_BUTTON)
+
+        self.invisible = False
+        self._parent = parent
+        self._draw_shift = 0
+        self._draw_width = 0
+        self._best_width = 0
+        self._layout_points = 0,0,0,0
+        self._size_requisition = 0,0
+
+        self.label = None
+        self.shape = pathbar_common.SHAPE_RECTANGLE
+        self.layout = None
+        self.callback = callback
+        self.set_label(label)
+
+        self.set_flags(gtk.CAN_FOCUS)
+        self.set_events(gtk.gdk.BUTTON_PRESS_MASK|
+                        gtk.gdk.BUTTON_RELEASE_MASK|
+                        gtk.gdk.KEY_RELEASE_MASK|
+                        gtk.gdk.KEY_PRESS_MASK|
+                        gtk.gdk.ENTER_NOTIFY_MASK|
+                        gtk.gdk.LEAVE_NOTIFY_MASK)
+        return
+
+    def __repr__(self):
+        return self.label
+
+    def _make_layout(self):
+        pc = self._parent.get_pango_context()
+        layout = pango.Layout(pc)
+        layout.set_markup(self.label)
+        layout.set_ellipsize(pango.ELLIPSIZE_END)
+        self.layout = layout
+        return
+
+    def _set_best_width(self, best_width):
+        self._best_width = best_width
+        return
+
+    def _calc_layout_points(self):
+        if not self.layout: self._make_layout()
+        x = self._parent.theme['xpad']
+        y = self._parent.theme['ypad']
+        w, h = self.layout.get_pixel_extents()[1][2:]
+        self._layout_points = [x, y, w, h]
+        return
+
+    def _adjust_width(self, shape, w):
+        self._draw_xoffset = 0
+        self._draw_width = w
+
+        arrow_width = self._parent.theme['arrow_width']
+        if shape == pathbar_common.SHAPE_RECTANGLE:
+            return w
+
+        elif shape == pathbar_common.SHAPE_START_ARROW:
+            self._draw_width += arrow_width
+            if self.get_direction() == gtk.TEXT_DIR_RTL:
+                self._draw_xoffset -= arrow_width
+
+        elif shape == pathbar_common.SHAPE_END_CAP:
+            w += arrow_width
+            self._draw_width += arrow_width
+            if self.get_direction() != gtk.TEXT_DIR_RTL:
+                self._layout_points[0] += arrow_width
+
+        elif shape == pathbar_common.SHAPE_MID_ARROW:
+            w += arrow_width
+            self._draw_width += 2*arrow_width
+            if self.get_direction() == gtk.TEXT_DIR_RTL:
+                self._draw_xoffset -= arrow_width
+            else:
+                self._layout_points[0] += arrow_width
+        return w
+
+    def _calc_size(self, shape):
+        lx, ly, w, h = self.layout.get_pixel_extents()[1]
+        w += 2*self._parent.theme['xpad']
+        h += 2*self._parent.theme['ypad']
+
+        w = self._adjust_width(shape, w)
+        if not self.get_best_width():
+            self._set_best_width(w)
+        self.set_size_request(w, h)
+        return
+
+    def do_callback(self):
+        self.callback(self._parent, self)
+        return
+
+    def set_label(self, label):
+        if label == self.label: return
+        self.label = gobject.markup_escape_text(label.strip())
+        if not self.layout:
+            self._make_layout()
+        else:
+            self.layout.set_markup(self.label)
+
+        self._calc_layout_points()
+        self._calc_size(self.shape)
+        return
+
+    def set_shape(self, shape):
+        self.shape = shape
+        self._calc_layout_points()
+        self._calc_size(shape)
+        return
+
+    def set_width(self, w):
+        theme = self._parent.theme
+        lw = w-theme['arrow_width']
+        if self.shape != pathbar_common.SHAPE_START_ARROW:
+            lw -= theme['xpad']
+        if self.shape == pathbar_common.SHAPE_MID_ARROW:
+            lw -= theme['arrow_width']
+        self.layout.set_width(lw*pango.SCALE)
+
+        self._draw_width = w+theme['arrow_width']
+        self.set_size_request(w, -1)
+        return
+
+    def restore_best_width(self):
+        w = self.get_best_width()
+        arrow_width = self._parent.theme['arrow_width']
+
+        if self.shape == pathbar_common.SHAPE_MID_ARROW:
+            w += arrow_width
+        if self.shape == pathbar_common.SHAPE_END_CAP and \
+            self.get_direction() == gtk.TEXT_DIR_RTL:
+            self._draw_xoffset -= arrow_width
+            self._layout_points[0] -= arrow_width
+
+        self.layout.set_width(-1)
+        self._draw_width = w+arrow_width
+        self.set_size_request(w, -1)
+        return
+
+    def get_draw_width(self):
+        return self._draw_width
+
+    def get_draw_xoffset(self):
+        return self._draw_xoffset
+
+    def get_best_width(self):
+        return self._best_width
+
+    def get_layout_points(self):
+        x, y, w, h = self._layout_points
+        y = int(max((self.allocation.height-h)*0.5+0.5, y))
+        return x, y, w, h
+
+    def get_layout(self):
+        return self.layout
+
+    def recalc_dimensions(self):
+        self.layout = None
+        self._calc_layout_points()
+        self._calc_size(self.shape)
+        return
+
+class NavigationBar(PathBar):
+
+    APPEND_DELAY = 150
+
+    def __init__(self, group=None):
+        PathBar.__init__(self)
+        self.id_to_part = {}
+        return
+
+    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
+        """
+
+        # 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]
+            part.set_label(label)
+        else:
+            part = PathPart(parent=self, label=label, callback=callback)
+            part.set_name(id)
+            self.id_to_part[id] = part
+            self.append(part, do_callback, animate)
+        return
+
+    def remove_id(self, id):
+        if not id in self.id_to_part:
+            return
+        part = self.id_to_part[id]
+        del self.id_to_part[id]
+        self.remove(part)
+        return
+
+    def remove_all(self, keep_first_part=True, do_callback=True):
+        if len(self.get_parts()) <= 1: return
+        root = self.get_children()[0]
+        self.id_to_part = {root.get_name(): root}
+        PathBar.remove_all(self, do_callback=do_callback)
+        return
+
+    def get_button_from_id(self, id):
+        """
+        return the button for the given id (or None)
+        """
+        if not id in self.id_to_part:
+            return None
+        return self.id_to_part[id]
+
+
+class Test:
+
+    def __init__(self):
+        self.counter = 0
+        w = gtk.Window()
+        w.connect("destroy", gtk.main_quit)
+        w.set_size_request(384, -1)
+        w.set_default_size(512, -1)
+        w.set_border_width(3)
+
+        vb = gtk.VBox()
+        w.add(vb)
+
+        pb = PathBar()
+        vb.pack_start(pb, False)
+        part = PathPart(pb, 'Get Free Software?')
+        pb.append(part)
+
+        add = gtk.Button(stock=gtk.STOCK_ADD)
+        rem = gtk.Button(stock=gtk.STOCK_REMOVE)
+        self.entry = gtk.Entry()
+
+        vb.pack_start(add, False)
+        vb.pack_start(self.entry, False)
+        vb.pack_start(rem, False)
+        add.connect('clicked', self.add_cb, pb)
+        rem.connect('clicked', self.rem_cb, pb)
+
+        w.show_all()
+        gtk.main()
+        return
+
+    def add_cb(self, widget, pb):
+        text = self.entry.get_text() or ('unnammed%s' % self.counter)
+        part = PathPart(pb, text)
+        pb.append(part)
+        self.counter += 1
+        return
+
+    def rem_cb(self, widget, pb):
+        last = pb.get_children()[-1]
+        pb.remove(last)
+        return
+
+if __name__ == '__main__':
+    Test()
 
=== removed file 'softwarecenter/view/widgets/rgb.py'
--- softwarecenter/view/widgets/rgb.py	2009-10-09 13:44:41 +0000
+++ softwarecenter/view/widgets/rgb.py	1970-01-01 00:00:00 +0000
@@ -1,67 +0,0 @@
-# Copyright (C) 2009 Matthew McGowan
-#
-# 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, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-import colorsys
-from gtk.gdk import Color
-
-
-def parse_colour_scheme(colour_scheme_str):
-    scheme_dict = {}
-    for ln in colour_scheme_str.splitlines():
-        k, v = ln.split(':')
-        scheme_dict[k.strip()] = gtk.gdk.color_parse(v.strip())
-    return scheme_dict
-
-
-def shade(color, k):
-    # as seen in Murrine's cairo-support.c
-    r = color.red_float
-    g = color.green_float
-    b = color.blue_float
-
-    if (k == 1.0):
-        return color
-
-    h,l,s = colorsys.rgb_to_hls(r,g,b)
-
-    l *= k
-    if (l > 1.0):
-        l = 1.0
-    elif (l < 0.0):
-        l = 0.0
-
-    s *= k
-    if (s > 1.0):
-        s = 1.0
-    elif (s < 0.0):
-        s = 0.0
-
-    r, g, b = colorsys.hls_to_rgb(h,l,s)
-
-    return Color(int(r*65535), int(g*65535), int(b*65535))
-
-def mix_color(color1, color2, mix_factor):
-    # as seen in Murrine's cairo-support.c
-    r = color1.red_float*(1-mix_factor)+color2.red_float*mix_factor
-    g = color1.green_float*(1-mix_factor)+color2.green_float*mix_factor
-    b = color1.blue_float*(1-mix_factor)+color2.blue_float*mix_factor
-    return Color(int(r*65535), int(g*65535), int(b*65535))
-
-def to_float(color):
-    return color.red_float, color.green_float, color.blue_float