[Sugar-devel] [REVIEW] adding spiral to Home View

[Gary Martin]

Hi Walter,

Wanted to give it a quick run in my vm, but when I tried to apply it using patch, it gave me the error:

   patch: **** malformed patch at line 35: @@ -201,6 +202,11 @@ class RingLayout(FavoritesLayout):

I'm probably doing something dumb, is this the expected way to apply the patch?

--Gary

On 6 Aug 2010, at 13:58, Walter Bender wrote:

> As per http://lists.sugarlabs.org/archive/sugar-devel/2010-August/025874.html
> I have been experimenting with a variant of the Home View in which the
> circle morphs into a spiral when the number of icons grows too large.
> Icons don't shrink until the spiral runs off the screen. With this
> scheme, we can support on the order of 200+ icons on the Home View.
> 
> This is just a first pass. Please review. Thanks.
> 
> 
> From 4ad5ad7e003fdd9eeb703c1287bd9f5c8484e967 Mon Sep 17 00:00:00 2001
> From: Walter Bender <walter at sugarlabs.org>
> Date: Fri, 6 Aug 2010 08:53:10 -0400
> Subject: [PATCH] adding spiral to circle view
> 
> ---
> src/jarabe/desktop/favoriteslayout.py |   92 ++++++++++++++++++++++++++-------
> 1 files changed, 73 insertions(+), 19 deletions(-)
> 
> diff --git a/src/jarabe/desktop/favoriteslayout.py
> b/src/jarabe/desktop/favoriteslayout.py
> index 85e1b59..a945c49 100644
> --- a/src/jarabe/desktop/favoriteslayout.py
> +++ b/src/jarabe/desktop/favoriteslayout.py
> @@ -1,4 +1,5 @@
> # Copyright (C) 2008 One Laptop Per Child
> +# Copyright (C) 2010 Sugar Labs
> #
> # 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
> @@ -201,6 +202,11 @@ class RingLayout(FavoritesLayout):
>     def __init__(self):
>         FavoritesLayout.__init__(self)
>         self._locked_children = {}
> +        self._spiral = False
> +        self._radius = _MINIMUM_RADIUS
> +        self._orientation = math.pi
> +        self._icon_size = style.STANDARD_ICON_SIZE
> +        self._count = -1
> 
>     def append(self, icon, locked=False):
>         FavoritesLayout.append(self, icon, locked)
> @@ -221,31 +227,79 @@ class RingLayout(FavoritesLayout):
>             self._locked_children[child] = (x, y)
> 
>     def _calculate_radius_and_icon_size(self, children_count):
> -        # what's the radius required without downscaling?
> +        """ determine if we are drawing a circle or a spiral """
>         distance = style.STANDARD_ICON_SIZE + style.DEFAULT_SPACING
> -        icon_size = style.STANDARD_ICON_SIZE
> -        # circumference is 2*pi*r; we want this to be at least
> -        # 'children_count * distance'
> +
>         radius = children_count * distance / (2 * math.pi)
> -        # limit computed radius to reasonable bounds.
> -        radius = max(radius, _MINIMUM_RADIUS)
> -        radius = min(radius, _MAXIMUM_RADIUS)
> -        # recompute icon size from limited radius
> -        if children_count > 0:
> -            icon_size = (2 * math.pi * radius / children_count) \
> -                        - style.DEFAULT_SPACING
> -        # limit adjusted icon size.
> -        icon_size = max(icon_size, style.SMALL_ICON_SIZE)
> -        icon_size = min(icon_size, style.MEDIUM_ICON_SIZE)
> -        return radius, icon_size
> +        if radius < _MAXIMUM_RADIUS:
> +            self._spiral = False
> +            self._icon_size = style.STANDARD_ICON_SIZE
> +        else:
> +            self._spiral = True
> +            radius = _MINIMUM_RADIUS
> +
> +        # If there are fewer children, try increasing icon_size.
> +        if self._count > children_count:
> +            logging.debug('resetting count: %d > %d' % (self._count,
> children_count))
> +            if self._icon_size == style.MEDIUM_ICON_SIZE:
> +                self._icon_size = style.STANDARD_ICON_SIZE
> +            elif self._icon_size == style.SMALL_ICON_SIZE:
> +                self._icon_size = style.MEDIUM_ICON_SIZE
> +        self._count = children_count
> +
> +        return radius, self._icon_size
> +
> +    def _calculate_xy(self, icon_size, width, height):
> +        """ Convert r, o to x, y """
> +        x = -math.sin(self._orientation) * self._radius
> +        y = math.cos(self._orientation) * self._radius
> +        self._calculate_new_radius_orientation(icon_size +\
> +                                                   style.DEFAULT_SPACING)
> +
> +        x = int(x) + (width - icon_size) / 2
> +        y = int(y) + (height - icon_size - (style.GRID_CELL_SIZE / 2) ) / 2
> +        return x, y
> +
> +    def _calculate_new_radius_orientation(self, icon_size):
> +        """ Based upon current radius, calculate new increments """
> +        circumference = self._radius * 2 * math.pi
> +        n = circumference / icon_size
> +        self._orientation += 2 * math.pi / n
> +        self._radius += float(icon_size) / n
> 
>     def _calculate_position(self, radius, icon_size, index, children_count,
>                             sin=math.sin, cos=math.cos):
> +        """ Try fitting a circle or a spiral """
> +
>         width, height = self.box.get_allocation()
> -        angle = index * (2 * math.pi / children_count) - math.pi / 2
> -        x = radius * cos(angle) + (width - icon_size) / 2
> -        y = radius * sin(angle) + (height - icon_size -
> -                                   (style.GRID_CELL_SIZE/2) ) / 2
> +        if not self._spiral:
> +            angle = index * (2 * math.pi / children_count) - math.pi / 2
> +            x = radius * cos(angle) + (width - icon_size) / 2
> +            y = radius * sin(angle) + (height - icon_size -
> +                                       (style.GRID_CELL_SIZE/2) ) / 2
> +        else:
> +            min_width_, box_width = self.box.get_width_request()
> +            min_height_, box_height = self.box.get_height_request(box_width)
> +            if index == 0:
> +                self._radius = _MINIMUM_RADIUS
> +                self._orientation = math.pi
> +            x, y = self._calculate_xy(icon_size, width, height)
> +            # If we run off the edge, keep spiraling until we return.
> +            while x < min_width_ or x > box_width - icon_size or \
> +                    y < min_height_ or y > box_height - icon_size:
> +                x, y = self._calculate_xy(icon_size, width, height)
> +                # If we run past a corner, we will never return, so time to
> +                # shrink the icons.
> +                if (x < min_height_ and \
> +                        (y < min_width_ or y > box_height - icon_size)) or \
> +                   (x > box_width - icon_size and \
> +                             (y < min_width_ or y > box_height - icon_size)):
> +                    if self._icon_size == style.STANDARD_ICON_SIZE:
> +                        self._icon_size = style.MEDIUM_ICON_SIZE
> +                    elif self._icon_size == style.MEDIUM_ICON_SIZE:
> +                        self._icon_size = style.SMALL_ICON_SIZE
> +                    else: # give up
> +                        return x, y
>         return x, y
> 
>     def _get_children_in_ring(self):
> -- 
> 1.7.0.4
> 
> -walter
> 
> -- 
> Walter Bender
> Sugar Labs
> http://www.sugarlabs.org
> _______________________________________________
> Sugar-devel mailing list
> Sugar-devel at lists.sugarlabs.org
> http://lists.sugarlabs.org/listinfo/sugar-devel