Merge lp:~dylanmccall/update-manager/refactored-cellareapackage into lp:update-manager

[Dylan McCall]

While playing with the package column (and pkg_area) in UpdatesAvailable.py, I noticed I was needing to perform shotgun surgery in order to make some small changes: there was a bunch of code in CellAreaPackage that depended on specifics of UpdatesAvailable's tree view. This branch contains a more generalized CellAreaPackage. It isn't exactly _portable_ at this stage, but I think it's a step in the right direction. The assumptions it continues to make are documented, and innocent changes in other parts of the program are less likely to break it. The output should be identical to the existing cell area.

[lp:~dylanmccall/update-manager/refactored-cellareapackage]

2589. By Dylan McCall on 2013-01-25

In CellAreaPackage, fixed indent for cells at depth 3 to be consistent with current results.

[Barry Warsaw (barry)]

A few comments:

Line 51: s/not cell_number in/cell_number not in/

Line 104: I factored out the "len(cells) - 1" into a local variable outside the loop for readability and (possibly) improved performance.

Lines 105-108 can be better written as:
    cell_size = self.cached_cell_size.get(cell_number, 0)

Line 110: Removed unnecessary parens.

I'll fix those and sponsor this into trunk (and upload) along with your LP: #1105363 fix.

review: Approve

[Dylan McCall (dylanmccall)]

Great! Thanks, Barry :)
(Somehow got all this way without noticing dict.get can return a default value. Exciting!)

=== modified file 'UpdateManager/UpdatesAvailable.py'
--- UpdateManager/UpdatesAvailable.py	2013-01-25 15:41:59 +0000
+++ UpdateManager/UpdatesAvailable.py	2013-01-25 23:21:21 +0000
@@ -91,75 +91,89 @@
 class CellAreaPackage(Gtk.CellAreaBox):
     """This CellArea lays our package cells side by side, without allocating
        width for a cell if it isn't present (like icons for header labels).
+       We assume that the last cell should be expanded to fill remaining space,
+       and other cells have a fixed width.
     """
 
     def __init__(self, indent_toplevel=False):
         Gtk.CellAreaBox.__init__(self)
         self.indent_toplevel = indent_toplevel
         self.column = None
-        self.toggle_size = None
-        self.pixbuf_size = None
-        self.cached_cell_start = {}
+        self.cached_cell_size = {}
 
     def do_foreach_alloc(self, context, widget, cell_area_in, bg_area_in,
                          callback):
-        # First, gather cell renderers and make sure they are what we expect
         cells = []
         def gather(cell, data):
             cells.append(cell)
         self.foreach(gather, None)
-        if (len(cells) != 3 or
-                not isinstance(cells[0], Gtk.CellRendererToggle) or
-                not isinstance(cells[1], Gtk.CellRendererPixbuf) or
-                not isinstance(cells[2], Gtk.CellRendererText)):
-            return
-        toggle = cells[0]
-        pixbuf = cells[1]
-        text = cells[2]
-
-        # Now just grab some size info
+
+        cell_is_hidden = {}
+
+        # Record the space required by each cell
+        for cell_number, cell in enumerate(cells):
+            # Detect if this cell should be allocated space
+            if isinstance(cell, Gtk.CellRendererPixbuf):
+                gicon = cell.get_property("gicon")
+                hide_cell = gicon is None
+            else:
+                hide_cell = False
+            cell_is_hidden[cell_number] = hide_cell
+
+            if not hide_cell and not cell_number in self.cached_cell_size:
+                min_size, natural_size = cell.get_preferred_width(widget)
+                self.cached_cell_size[cell_number] = natural_size
+
         cell_area = cell_area_in.copy()
         bg_area = bg_area_in.copy()
         spacing = self.get_property("spacing")
-        gicon = pixbuf.get_property("gicon")
         cell_start = self.get_cell_start(widget)
         orig_end = cell_area.width + cell_area.x
-        if self.toggle_size is None:
-            toggle_min, self.toggle_size = toggle.get_preferred_width(widget)
-        if gicon and self.pixbuf_size is None:
-            pixbuf_min, self.pixbuf_size = pixbuf.get_preferred_width(widget)
-
-        # And finally, start handling each cell        
-
         cur_path = self.get_current_path_string()
         depth = Gtk.TreePath.new_from_string(cur_path).get_depth()
-        if gicon is not None and self.indent_toplevel:
-            # if not a header, align with header rows
-            depth = depth + 1
-        if depth == 1:
-            cell_area.x = cell_start
-        elif depth == 2:
-            cell_area.x = cell_start + self.toggle_size + spacing
-        elif depth == 3:
-            # Oddly, cells don't line up if we simply use spacing * 2
-            cell_area.x = cell_start + self.toggle_size * 2 + spacing + 1
-        cell_area.width = self.toggle_size
-        if callback(cells[0], cell_area.copy(), bg_area.copy()):
-            return
-
-        cell_area.x = cell_area.x + cell_area.width + spacing
-        if gicon is None:
-            cell_area.width = 0
-        else:
-            cell_area.width = self.pixbuf_size
-        if callback(cells[1], cell_area.copy(), bg_area.copy()):
-            return
-
-        if gicon is not None:
-            cell_area.x = cell_area.x + cell_area.width + spacing
-        cell_area.width = orig_end - cell_area.x
-        if callback(cells[2], cell_area.copy(), bg_area.copy()):
-            return
+
+        # And finally, start handling each cell
+        extra_cell_width = 0
+        cell_area.x = cell_start
+        cell_area.width = 0
+
+        for cell_number, cell in enumerate(cells):
+            is_last_cell = cell_number == len(cells)-1
+            if cell_number in self.cached_cell_size:
+                cell_size = self.cached_cell_size[cell_number]
+            else:
+                cell_size = 0
+
+            if (cell_area.width > 0 and extra_cell_width == 0):
+                cell_area.x += cell_area.width + spacing
+
+            if cell_number == 0:
+                # The first cell is affected by its depth in the tree
+                if not cell_is_hidden[1] and self.indent_toplevel:
+                    # if not a header, align with header rows
+                    depth += 1
+                if depth > 1:
+                    indent = max(0, depth - 1)
+                    indent_size = cell_size * indent
+                    if depth == 2:
+                        indent_extra = spacing
+                    elif depth == 3:
+                        indent_extra = spacing + 1
+                    else:
+                        indent_extra = spacing * indent
+                    cell_area.x += indent_size + indent_extra
+
+            if is_last_cell:
+                cell_size = max(cell_size, orig_end - cell_area.x)
+            if not cell_is_hidden[cell_number]:
+                cell_area.width = cell_size + extra_cell_width
+                extra_cell_width = 0
+            else:
+                cell_area.width = 0
+                extra_cell_width = cell_size + spacing
+
+            if callback(cell, cell_area.copy(), bg_area.copy()):
+                return
 
     def do_event(self, context, widget, event, cell_area, flags):
         # This override is just to trick our parent implementation into