Merge lp:~nataliabidart/ubuntuone-control-panel/volumes-reborn into lp:ubuntuone-control-panel

[Natalia Bidart]

Complete redesign of Folders tab, now internally called Volumes since it will cover Shares in a future (LP: #705989).

Folders tab was renamed and improved.

To test, open 2 terminals and run in each:

killall ubuntuone-control-panel-backend; DEBUG=True PYTHONPATH=. ./bin/ubuntuone-control-panel-backend

DEBUG=True PYTHONPATH=. ./bin/ubuntuone-control-panel-gtk

And play with the 'Cloud Storage' panel. Be careful that folder subcription/unsubscription is "real" :-)

[Martin Albisetti (beuno)]

All in all, this is shaping up to be a huge leap forward from what people will see from our service. GREAT job.

A few comments:

- It confused me for a few minutes to have "X of Y used" on top, and "Z available" under "Mine". I had even taken a screenshot to report it as a bug, until I realised what it was. I wonder if we should unify? Screehshot: http://ubuntuone.com/p/ZQL/
- How about moving the non-deletable Ubuntu One folder fixed to the top? It'll make it feel a bit more immutable!
- The icon next to the section "Mine" is of multiple people, which is odd, as I'm only one person :) Maybe the multi-person icon could be used for the "From Others" section, and "Mine" gets a single person?

I don't feel any of the above blocks this branch, they are open questions and suggestions that could be incorporated in future branches.

review: Approve

[Roberto Alsina (ralsina)]

+1

LOVE it. I agree with Martin about the Mine wording being a bit strange and about moving "Ubuntu one" to the top (and marking it somehow? emblem? shading?)

But great job :-)

review: Approve

[lp:~nataliabidart/ubuntuone-control-panel/volumes-reborn]

57. By Natalia Bidart on 2011-01-21

Root folder is on top of others.

[Natalia Bidart (nataliabidart)]

> All in all, this is shaping up to be a huge leap forward from what people will
> see from our service. GREAT job.

Thanks!

> A few comments:
>
> - It confused me for a few minutes to have "X of Y used" on top, and "Z
> available" under "Mine". I had even taken a screenshot to report it as a bug,
> until I realised what it was. I wonder if we should unify? Screehshot:
> http://ubuntuone.com/p/ZQL/

Agreed. Filed bug #706021 to discuss this further.

> - How about moving the non-deletable Ubuntu One folder fixed to the top?
> It'll make it feel a bit more immutable!

Fixed!

> - The icon next to the section "Mine" is of multiple people, which is odd, as
> I'm only one person :) Maybe the multi-person icon could be used for the
> "From Others" section, and "Mine" gets a single person?

Agreed, filed bug #706034.

[lp:~nataliabidart/ubuntuone-control-panel/volumes-reborn]

58. By Natalia Bidart on 2011-01-21

Lint fixes.

=== modified file 'bin/ubuntuone-control-panel-gtk'
--- bin/ubuntuone-control-panel-gtk	2011-01-20 21:27:21 +0000
+++ bin/ubuntuone-control-panel-gtk	2011-01-21 19:25:14 +0000
@@ -34,13 +34,13 @@
 def parser_options():
     """Parse command line parameters."""
     usage = "Usage: %prog [option]"
-    parser = OptionParser(usage=usage)
-    parser.add_option("", "--switch-to", dest="switch_to", type="string",
+    result = OptionParser(usage=usage)
+    result.add_option("", "--switch-to", dest="switch_to", type="string",
                       metavar="PANEL_NAME",
                       help="Start the Ubuntu One Control Panel (GTK) in the "
                            "PANEL_NAME tab. Possible values are: "
-                           "dashboard, folders, devices, applications")
-    return parser
+                           "dashboard, volumes, devices, applications")
+    return result
 
 
 if __name__ == "__main__":

=== modified file 'data/management.ui'
--- data/management.ui	2010-12-20 22:18:01 +0000
+++ data/management.ui	2011-01-21 19:25:14 +0000
@@ -79,8 +79,8 @@
                           </packing>
                         </child>
                         <child>
-                          <object class="GtkRadioButton" id="folders_button">
-                            <property name="label" translatable="yes">Folders</property>
+                          <object class="GtkRadioButton" id="volumes_button">
+                            <property name="label" translatable="yes">Cloud Storage</property>
                             <property name="visible">True</property>
                             <property name="can_focus">True</property>
                             <property name="receives_default">False</property>

=== renamed file 'data/folders.ui' => 'data/volumes.ui'
--- data/folders.ui	2010-12-18 20:16:18 +0000
+++ data/volumes.ui	2011-01-21 19:25:14 +0000
@@ -1,11 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <interface>
-  <requires lib="gtk+" version="2.16"/>
+  <requires lib="gtk+" version="2.22"/>
   <!-- interface-naming-policy project-wide -->
-  <object class="GtkVBox" id="itself">
+  <object class="GtkAlignment" id="itself">
     <property name="visible">True</property>
-    <property name="border_width">10</property>
-    <property name="spacing">10</property>
+    <property name="can_focus">False</property>
     <child>
       <object class="GtkScrolledWindow" id="scrolledwindow1">
         <property name="visible">True</property>
@@ -13,26 +12,83 @@
         <property name="hscrollbar_policy">automatic</property>
         <property name="vscrollbar_policy">automatic</property>
         <child>
-          <object class="GtkViewport" id="viewport1">
+          <object class="GtkTreeView" id="volumes_view">
             <property name="visible">True</property>
-            <property name="resize_mode">queue</property>
-            <property name="shadow_type">none</property>
-            <child>
-              <object class="GtkAlignment" id="folders">
-                <property name="visible">True</property>
-                <property name="xscale">0</property>
-                <property name="yscale">0</property>
-                <child>
-                  <placeholder/>
+            <property name="can_focus">True</property>
+            <property name="model">volumes_store</property>
+            <property name="rules_hint">True</property>
+            <property name="tooltip_column">0</property>
+            <child>
+              <object class="GtkTreeViewColumn" id="treeviewcolumn2">
+                <property name="resizable">True</property>
+                <property name="sizing">autosize</property>
+                <property name="expand">True</property>
+                <child>
+                  <object class="GtkCellRendererPixbuf" id="cellrendererpixbuf1"/>
+                  <attributes>
+                    <attribute name="sensitive">1</attribute>
+                    <attribute name="icon-name">2</attribute>
+                    <attribute name="stock-size">5</attribute>
+                  </attributes>
+                </child>
+                <child>
+                  <object class="GtkCellRendererText" id="text_renderer">
+                    <property name="ellipsize">end</property>
+                    <property name="width_chars">80</property>
+                  </object>
+                  <attributes>
+                    <attribute name="markup">0</attribute>
+                    <attribute name="text">0</attribute>
+                  </attributes>
+                </child>
+              </object>
+            </child>
+            <child>
+              <object class="GtkTreeViewColumn" id="treeviewcolumn3">
+                <property name="sizing">autosize</property>
+                <property name="title">On this device?</property>
+                <child>
+                  <object class="GtkCellRendererToggle" id="cellrenderertoggle1">
+                    <property name="indicator_size">15</property>
+                    <signal name="toggled" handler="on_subscribed_toggled" swapped="no"/>
+                  </object>
+                  <attributes>
+                    <attribute name="sensitive">4</attribute>
+                    <attribute name="visible">3</attribute>
+                    <attribute name="active">1</attribute>
+                  </attributes>
+                </child>
+                <child>
+                  <object class="GtkCellRendererText" id="cellrenderertext1">
+                    <property name="visible">False</property>
+                  </object>
+                  <attributes>
+                    <attribute name="text">6</attribute>
+                  </attributes>
                 </child>
               </object>
             </child>
           </object>
         </child>
       </object>
-      <packing>
-        <property name="position">0</property>
-      </packing>
     </child>
   </object>
+  <object class="GtkTreeStore" id="volumes_store">
+    <columns>
+      <!-- column-name description -->
+      <column type="gchararray"/>
+      <!-- column-name subscribed -->
+      <column type="gboolean"/>
+      <!-- column-name icon-name -->
+      <column type="gchararray"/>
+      <!-- column-name subscribed-visible -->
+      <column type="gboolean"/>
+      <!-- column-name subscribed-sensitive -->
+      <column type="gboolean"/>
+      <!-- column-name icon-size -->
+      <column type="gint"/>
+      <!-- column-name identifier -->
+      <column type="gchararray"/>
+    </columns>
+  </object>
 </interface>

=== modified file 'ubuntuone/controlpanel/gtk/gui.py'
--- ubuntuone/controlpanel/gtk/gui.py	2011-01-20 21:23:11 +0000
+++ ubuntuone/controlpanel/gtk/gui.py	2011-01-21 19:25:14 +0000
@@ -22,6 +22,7 @@
 
 import gettext
 import operator
+import os
 
 from functools import wraps
 
@@ -101,6 +102,11 @@
     return filter_by_app_name_inner
 
 
+def on_size_allocate(widget, allocation, label):
+    """Resize labels according to who 'widget' is being resized."""
+    label.set_size_request(allocation.width - 2, -1)
+
+
 @log_call(logger.info)
 def uri_hook(button, uri, *args, **kwargs):
     """Open an URI or do nothing if URI is not an URL."""
@@ -159,10 +165,6 @@
         label.set_markup(WARNING_MARKUP % message)
         label.show()
 
-    def on_size_allocate(self, label, allocation):
-        """The label can re rezised, embrase it!."""
-        label.set_size_request(allocation.width - 2, -1)
-
 
 class ControlPanelWindow(gtk.Window):
     """The main window for the Ubuntu One control panel."""
@@ -241,8 +243,8 @@
         if self.get_current_page() == 0:
             self.management.load()
             if credentials_are_new:
-                # redirect user to Folders page to review folders subscription
-                self.management.folders_button.clicked()
+                # redirect user to volumes page to review subscription
+                self.management.volumes_button.clicked()
 
             self.next_page()
 
@@ -254,17 +256,38 @@
 
     def __init__(self, title=None):
         gtk.VBox.__init__(self)
+        self._is_processing = False
+
         if title is None:
             title = self.TITLE
 
-        self.title = PanelTitle(markup='<b>' + title + '</b>')
+        title = '<span font_size="large">%s</span>' % title
+        self.title = PanelTitle(markup=title)
         self.pack_start(self.title, expand=False)
 
         self.message = LabelLoading(LOADING)
         self.pack_start(self.message, expand=False)
 
+        self.connect('size-allocate', on_size_allocate, self.title.label)
         self.show_all()
 
+    def _get_is_processing(self):
+        """Is this panel processing a request?"""
+        return self._is_processing
+
+    def _set_is_processing(self, new_value):
+        """Set if this panel is processing a request."""
+        if new_value:
+            self.message.start()
+            self.set_sensitive(False)
+        else:
+            self.message.stop()
+            self.set_sensitive(True)
+
+        self._is_processing = new_value
+
+    is_processing = property(fget=_get_is_processing, fset=_set_is_processing)
+
     @log_call(logger.debug)
     def on_success(self, message=''):
         """Use this callback to stop the Loading and show 'message'."""
@@ -302,7 +325,7 @@
         self.add(self.itself)
         self.warning_label.set_text('')
         self.warning_label.set_property('xalign', 0.5)
-        self.warning_label.connect('size-allocate', self.on_size_allocate)
+        self.connect('size-allocate', on_size_allocate, self.warning_label)
 
         self.connect_button.set_uri(self.CONNECT)
 
@@ -348,7 +371,7 @@
             label.set_markup(self.BULLET + ' ' + msg)
             label.set_property('xalign', 0)
             label.set_property('wrap', True)
-            label.connect('size-allocate', self.on_size_allocate)
+            self.messages.connect('size-allocate', on_size_allocate, label)
 
             self.messages.pack_start(label)
         self.messages.show_all()
@@ -478,16 +501,25 @@
         self.on_error()
 
 
-class FoldersPanel(UbuntuOneBin, ControlPanelMixin):
-    """The folders panel."""
+class VolumesPanel(UbuntuOneBin, ControlPanelMixin):
+    """The volumes panel."""
 
-    TITLE = _('Listed below are the folders available on this machine. '
-              'Subscribed means the folder will receive and send updates.')
+    TITLE = _('Select which folders from your cloud you want synchronized '
+              'on this device.')
+    MY_FOLDERS = _('Mine')
+    ALWAYS_SUBSCRIBED = _('Always in your personal cloud storage!')
+    FREE_SPACE = _('%(free_space)s available storage')
+    CONTACT_ICON_NAME = 'system-users'
+    FOLDER_ICON_NAME = 'folder'
+    SHARE_ICON_NAME = 'folder-remote'
+    ROW_HEADER = '<span font_size="large"><b>%s</b></span> ' \
+                 '<span foreground="grey">%s</span>'
+    ROOT = '%s - <span foreground="%s" font_size="small">%s</span>'
     NO_VOLUMES = _('No folders to show.')
 
     def __init__(self):
         UbuntuOneBin.__init__(self)
-        ControlPanelMixin.__init__(self, filename='folders.ui')
+        ControlPanelMixin.__init__(self, filename='volumes.ui')
         self.add(self.itself)
         self.show_all()
 
@@ -495,66 +527,102 @@
                                        self.on_volumes_info_ready)
         self.backend.connect_to_signal('VolumesInfoError',
                                        self.on_volumes_info_error)
-        self.volumes = None
-        self._subscribed = []
+        self.backend.connect_to_signal('VolumeSettingsChanged',
+                                       self.on_volume_settings_changed)
+        self.backend.connect_to_signal('VolumeSettingsChangeError',
+                                       self.on_volume_settings_change_error)
+
+    def _process_path(self, path):
+        """Trim 'path' so the '~' is removed."""
+        home = os.path.expanduser('~')
+        return path.replace(os.path.join(home, ''), '')
 
     def on_volumes_info_ready(self, info):
         """Backend notifies of volumes info."""
 
-        if self.volumes is not None:
-            self.folders.remove(self.volumes)
-            self.volumes = None
-
+        self.volumes_store.clear()
         if not info:
             self.on_success(self.NO_VOLUMES)
             return
         else:
             self.on_success()
 
-        self.volumes = gtk.Table(rows=len(info) + 1, columns=2)
-
-        header = (gtk.Label(), gtk.Label())
-        header[0].set_markup('<b>' + _('Local path') + '</b>')
-        header[1].set_markup('<b>' + _('Subscribed') + '</b>')
-        self.volumes.attach(header[0], 0, 1, 0, 1)
-        self.volumes.attach(header[1], 1, 2, 0, 1, xoptions=0)
-        self.volumes.show_all()
-
-        info.sort(key=operator.itemgetter('suggested_path'))
-        for i, volume in enumerate(info):
-            path = gtk.Label(volume['suggested_path'])
-            path.set_property('xalign', 0)
-            path.show()
-            self.volumes.attach(path, 0, 1, i + 1, i + 2)
-
-            subscribed = gtk.CheckButton(volume['volume_id'])
-            subscribed.set_active(bool(volume['subscribed']))
-            subscribed.show()
-            subscribed.get_child().hide()
-            subscribed.connect('clicked', self.on_subscribed_clicked)
-            self._subscribed.append(subscribed)
-            self.volumes.attach(subscribed, 1, 2, i + 1, i + 2, xoptions=0)
-
-        self.folders.add(self.volumes)
+        # pylint: disable=W0612
+        # name, subscribed, icon name, show toggle, sensitive, icon size, id
+        empty_row = ('', False, '', False, False, gtk.ICON_SIZE_MENU, None)
+
+        for name, free_bytes, volumes in info:
+            if name:
+                name = name + "'s"
+                icon_name = self.SHARE_ICON_NAME
+            else:
+                name = self.MY_FOLDERS
+                icon_name = self.FOLDER_ICON_NAME
+
+            free_bytes_args = {'free_space': self.humanize(int(free_bytes))}
+            row = (self.ROW_HEADER % (name, self.FREE_SPACE % free_bytes_args),
+                   True, self.CONTACT_ICON_NAME, False, False,
+                   gtk.ICON_SIZE_LARGE_TOOLBAR, None)
+            treeiter = self.volumes_store.append(None, row)
+
+            volumes.sort(key=operator.itemgetter('path'))
+            for volume in volumes:
+                sensitive = True
+                path = self._process_path(volume['path'])
+                if volume['type'] == u'ROOT':
+                    sensitive = False
+                    path = self.ROOT % (path, ORANGE, self.ALWAYS_SUBSCRIBED)
+
+                row = (path, bool(volume['subscribed']), icon_name, True,
+                       sensitive, gtk.ICON_SIZE_MENU, volume['volume_id'])
+
+                if volume['type'] == u'ROOT':  # root should go first!
+                    self.volumes_store.prepend(treeiter, row)
+                else:
+                    self.volumes_store.append(treeiter, row)
+
+            # When we display shares info, we'll need to smartly add
+            # an empty row to the tree view to separate volume groups
+            #treeiter = self.volumes_store.append(None, empty_row)
+
+        self.volumes_view.expand_row(0, True)
+        self.volumes_view.show_all()
+        self.is_processing = False
 
     @log_call(logger.error)
     def on_volumes_info_error(self, error_dict=None):
         """Backend notifies of an error when fetching volumes info."""
         self.on_error()
 
-    def on_subscribed_clicked(self, checkbutton):
-        """The user toggled 'checkbutton'."""
-        volume_id = checkbutton.get_label()
-        subscribed = bool_str(checkbutton.get_active())
+    @log_call(logger.info)
+    def on_volume_settings_changed(self, volume_id):
+        """The settings for 'volume_id' were changed."""
+        self.is_processing = False
+
+    @log_call(logger.error)
+    def on_volume_settings_change_error(self, volume_id, error_dict=None):
+        """The settings for 'volume_id' were not changed."""
+        self.load()
+
+    def on_subscribed_toggled(self, widget, path, *args, **kwargs):
+        """The user toggled 'widget'."""
+        treeiter = self.volumes_store.get_iter(path)
+        volume_id = self.volumes_store.get_value(treeiter, 6)
+        subscribed = not self.volumes_store.get_value(treeiter, 1)
+
+        self.volumes_store.set_value(treeiter, 1, subscribed)
+
         self.backend.change_volume_settings(volume_id,
-            {'subscribed': subscribed},
+            {'subscribed': bool_str(subscribed)},
             reply_handler=NO_OP, error_handler=error_handler)
 
+        self.is_processing = True
+
     def load(self):
         """Load the volume list."""
         self.backend.volumes_info(reply_handler=NO_OP,
                                   error_handler=error_handler)
-        self.message.start()
+        self.is_processing = True
 
 
 class Device(gtk.VBox, ControlPanelMixin):
@@ -1228,7 +1296,7 @@
 class ManagementPanel(gtk.VBox, ControlPanelMixin):
     """The management panel.
 
-    The user can manage dashboard, folders, devices and services.
+    The user can manage dashboard, volumes, devices and services.
 
     """
 
@@ -1255,12 +1323,12 @@
         self.status_box.pack_end(self.status_label, expand=False)
 
         self.dashboard = DashboardPanel()
-        self.folders = FoldersPanel()
+        self.volumes = VolumesPanel()
         self.devices = DevicesPanel()
         self.services = ServicesPanel()
 
         cb = lambda button, page_num: self.notebook.set_current_page(page_num)
-        self.tabs = (u'dashboard', u'folders', u'devices', u'services')
+        self.tabs = (u'dashboard', u'volumes', u'devices', u'services')
         for page_num, tab in enumerate(self.tabs):
             setattr(self, ('%s_page' % tab).upper(), page_num)
             button = getattr(self, '%s_button' % tab)
@@ -1270,7 +1338,7 @@
                                          gtk.gdk.Color(DEFAULT_FG))
             self.notebook.insert_page(getattr(self, tab), position=page_num)
 
-        self.folders_button.connect('clicked', lambda b: self.folders.load())
+        self.volumes_button.connect('clicked', lambda b: self.volumes.load())
         self.devices_button.connect('clicked', lambda b: self.devices.load())
         self.services_button.connect('clicked', lambda b: self.services.load())
         self.devices.connect('local-device-removed',

=== modified file 'ubuntuone/controlpanel/gtk/tests/__init__.py'
--- ubuntuone/controlpanel/gtk/tests/__init__.py	2011-01-10 02:26:22 +0000
+++ ubuntuone/controlpanel/gtk/tests/__init__.py	2011-01-21 19:25:14 +0000
@@ -28,10 +28,35 @@
 FAKE_ACCOUNT_INFO = {'type': 'Payed', 'name': 'Test me',
     'email': 'test.com', 'quota_total': '12345', 'quota_used': '9999'}
 
+USER_HOME = '/home/tester'
+
+ROOT = {
+    u'volume_id': '', u'path': '/home/tester/My Ubuntu',
+    u'subscribed': 'True', u'type': u'ROOT',
+}
+
+FAKE_FOLDERS_INFO = [
+    {u'volume_id': u'0', u'path': u'/home/tester/foo',
+     u'suggested_path': u'~/foo', u'subscribed': u'', u'type': u'UDF'},
+    {u'volume_id': u'1', u'path': u'/home/tester/bar',
+     u'suggested_path': u'~/bar', u'subscribed': u'True', u'type': u'UDF'},
+    {u'volume_id': u'2', u'path': u'/home/tester/baz',
+     u'suggested_path': u'~/baz', u'subscribed': u'True', u'type': u'UDF'},
+]
+
+FAKE_SHARES_INFO = [
+    {u'volume_id': u'1234',
+     u'path': u'/home/tester/.local/share/ubuntuone/shares/do from Other User',
+     u'subscribed': u'', u'type': u'SHARE'},
+
+    {u'volume_id': u'5678',
+     u'path': u'/home/tester/.local/share/ubuntuone/shares/re from Other User',
+     u'subscribed': u'True', u'type': u'SHARE'},
+]
+
 FAKE_VOLUMES_INFO = [
-    {'volume_id': '0', 'suggested_path': '~/foo', 'subscribed': ''},
-    {'volume_id': '1', 'suggested_path': '~/bar', 'subscribed': 'True'},
-    {'volume_id': '2', 'suggested_path': '~/baz', 'subscribed': 'True'},
+    (u'', u'147852369', [ROOT] + FAKE_FOLDERS_INFO),
+    (u'Other User', u'985674', FAKE_SHARES_INFO),
 ]
 
 FAKE_DEVICE_INFO = {

=== modified file 'ubuntuone/controlpanel/gtk/tests/test_gui.py'
--- ubuntuone/controlpanel/gtk/tests/test_gui.py	2011-01-20 21:23:11 +0000
+++ ubuntuone/controlpanel/gtk/tests/test_gui.py	2011-01-21 19:25:14 +0000
@@ -27,7 +27,7 @@
 from ubuntuone.controlpanel.gtk import gui
 from ubuntuone.controlpanel.gtk.tests import (FAKE_ACCOUNT_INFO,
     FAKE_DEVICE_INFO, FAKE_DEVICES_INFO,
-    FAKE_VOLUMES_INFO, FAKE_REPLICATIONS_INFO,
+    FAKE_VOLUMES_INFO, FAKE_REPLICATIONS_INFO, USER_HOME,
     FakedNMState, FakedSSOBackend, FakedSessionBus, FakedInterface,
     FakedPackageManager,
 )
@@ -52,6 +52,8 @@
 
     def setUp(self):
         super(BaseTestCase, self).setUp()
+        self.patch(gui.os.path, 'expanduser',
+                   lambda path: path.replace('~', USER_HOME))
         self.patch(gui.gtk, 'main', lambda: None)
         self.patch(gui.dbus, 'SessionBus', FakedSessionBus)
         self.patch(gui.dbus, 'Interface', FakedInterface)
@@ -279,10 +281,10 @@
                          self.ui.management.DASHBOARD_PAGE)
         self.assertEqual(self._called, ((), {}))
 
-    def test_credentials_found_shows_folders_management_panel(self):
+    def test_credentials_found_shows_volumes_management_panel(self):
         """On 'credentials-found' signal, the management panel is shown.
 
-        If first signal parameter is True, visible tab should be folders.
+        If first signal parameter is True, visible tab should be volumes.
 
         """
         a_token = object()
@@ -290,7 +292,7 @@
 
         self.assert_current_tab_correct(self.ui.management)
         self.assertEqual(self.ui.management.notebook.get_current_page(),
-                         self.ui.management.FOLDERS_PAGE)
+                         self.ui.management.VOLUMES_PAGE)
 
     def test_local_device_removed_shows_overview_panel(self):
         """On 'local-device-removed' signal, the overview panel is shown."""
@@ -362,6 +364,29 @@
         self.assert_warning_correct(self.ui.message, msg)
         self.assertFalse(self.ui.message.active)
 
+    def test_is_processing(self):
+        """The flag 'is_processing' is False on start."""
+        self.assertFalse(self.ui.is_processing)
+        self.assertTrue(self.ui.is_sensitive())
+
+    def test_set_is_processing(self):
+        """When setting 'is_processing', the spinner is shown."""
+        self.ui.is_processing = False
+        self.ui.is_processing = True
+
+        self.assertTrue(self.ui.message.get_visible())
+        self.assertTrue(self.ui.message.active)
+        self.assertFalse(self.ui.is_sensitive())
+
+    def test_unset_is_processing(self):
+        """When unsetting 'is_processing', the spinner is not shown."""
+        self.ui.is_processing = True
+        self.ui.is_processing = False
+
+        self.assertTrue(self.ui.message.get_visible())
+        self.assertFalse(self.ui.message.active)
+        self.assertTrue(self.ui.is_sensitive())
+
 
 class OverwiewPanelTestCase(ControlPanelMixinTestCase):
     """The test suite for the overview panel."""
@@ -716,14 +741,14 @@
         self.assert_warning_correct(self.ui.message, gui.VALUE_ERROR)
 
 
-class FoldersTestCase(ControlPanelMixinTestCase):
-    """The test suite for the folders panel."""
+class VolumesTestCase(ControlPanelMixinTestCase):
+    """The test suite for the volumes panel."""
 
-    klass = gui.FoldersPanel
-    ui_filename = 'folders.ui'
+    klass = gui.VolumesPanel
+    ui_filename = 'volumes.ui'
 
     def setUp(self):
-        super(FoldersTestCase, self).setUp()
+        super(VolumesTestCase, self).setUp()
         self.ui.load()
 
     def test_is_an_ubuntuone_bin(self):
@@ -744,6 +769,10 @@
                          [self.ui.on_volumes_info_ready])
         self.assertEqual(self.ui.backend._signals['VolumesInfoError'],
                          [self.ui.on_volumes_info_error])
+        self.assertEqual(self.ui.backend._signals['VolumeSettingsChanged'],
+                         [self.ui.on_volume_settings_changed])
+        self.assertEqual(self.ui.backend._signals['VolumeSettingsChangeError'],
+                         [self.ui.on_volume_settings_change_error])
 
     def test_volumes_info_is_requested_on_load(self):
         """The volumes info is requested to the backend."""
@@ -753,12 +782,18 @@
 
         self.assert_backend_called('volumes_info', ())
 
-    def test_message_after_load(self):
-        """The volumes label is active when contents are load."""
+    def test_is_processing_after_load(self):
+        """The ui is processing when contents are load."""
         self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
         self.ui.load()
 
-        self.assertTrue(self.ui.message.active)
+        self.assertTrue(self.ui.is_processing)
+
+    def test_is_not_processing_after_volumes_info_ready(self):
+        """The ui is processing when contents are load."""
+        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
+
+        self.assertFalse(self.ui.is_processing)
 
     def test_message_after_non_empty_volumes_info_ready(self):
         """The volumes label is a LabelLoading."""
@@ -777,66 +812,67 @@
         """The volumes info is processed when ready."""
         self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
 
-        self.assertEqual(self.ui.folders.get_children(), [self.ui.volumes])
-
-        volumes = self.ui.volumes.get_children()
-        volumes.reverse()
-
-        header = volumes[:2]  # grab header
-        self.assertEqual(header[0].get_text(), 'Local path')
-        self.assertEqual(header[1].get_text(), 'Subscribed')
-
-        volumes = volumes[2:]  # drop header
-        labels = filter(lambda w: isinstance(w, gui.gtk.Label), volumes)
-        checks = filter(lambda w: isinstance(w, gui.gtk.CheckButton), volumes)
-
-        self.assertEqual(len(checks), len(FAKE_VOLUMES_INFO))
-
-        for label, check, volume in zip(labels, checks, FAKE_VOLUMES_INFO):
-            self.assertEqual(volume['suggested_path'], label.get_text())
-            self.assertEqual(bool(volume['subscribed']), check.get_active())
-            self.assertEqual(volume['volume_id'], check.get_label())
-            self.assertFalse(check.get_child().get_visible())
+        self.assertEqual(len(FAKE_VOLUMES_INFO), len(self.ui.volumes_store))
+        treeiter = self.ui.volumes_store.get_iter_root()
+        for name, free_bytes, volumes in FAKE_VOLUMES_INFO:
+            name = "%s's" % name if name else self.ui.MY_FOLDERS
+            free_bytes = self.ui.humanize(int(free_bytes))
+            header = (name, self.ui.FREE_SPACE % {'free_space': free_bytes})
+
+            # check parent row
+            row = self.ui.volumes_store.get(treeiter, *xrange(7))
+
+            self.assertEqual(row[0], self.ui.ROW_HEADER % header)
+            self.assertTrue(row[1], 'parent will always be subscribed')
+            self.assertEqual(row[2], self.ui.CONTACT_ICON_NAME)
+            self.assertFalse(row[3], 'no toggle should be shown on parent!')
+            self.assertFalse(row[4], 'toggle should be non sensitive.')
+            self.assertEqual(row[5], gui.gtk.ICON_SIZE_LARGE_TOOLBAR)
+            self.assertEqual(row[6], None)
+
+            # check children
+            self.assertEqual(len(volumes),
+                             self.ui.volumes_store.iter_n_children(treeiter))
+            childiter = self.ui.volumes_store.iter_children(treeiter)
+
+            sorted_vols = sorted(volumes, key=gui.operator.itemgetter('path'))
+            for volume in sorted_vols:
+                row = self.ui.volumes_store.get(childiter, *xrange(7))
+
+                sensitive = True
+                path = volume['path'].replace(USER_HOME + '/', '')
+                if volume['type'] == 'ROOT':
+                    sensitive = False
+                    path = self.ui.ROOT % (path, gui.ORANGE,
+                                           self.ui.ALWAYS_SUBSCRIBED)
+
+                self.assertEqual(row[0], path)
+                self.assertEqual(row[1], bool(volume['subscribed']))
+                if volume['type'] != 'SHARE':
+                    self.assertEqual(row[2], self.ui.FOLDER_ICON_NAME)
+                else:
+                    self.assertEqual(row[2], self.ui.SHARE_ICON_NAME)
+                self.assertTrue(row[3], 'toggle should be shown on child!')
+                self.assertEqual(row[4], sensitive)
+                self.assertEqual(row[5], gui.gtk.ICON_SIZE_MENU)
+                self.assertEqual(row[6], volume['volume_id'])
+
+                childiter = self.ui.volumes_store.iter_next(childiter)
+
+            treeiter = self.ui.volumes_store.iter_next(treeiter)
 
     def test_on_volumes_info_ready_clears_the_list(self):
         """The old volumes info is cleared before updated."""
         self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
         self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
 
-        self.assertEqual(len(self.ui.folders.get_children()), 1)
-        child = self.ui.folders.get_children()[0]
-        self.assertEqual(child, self.ui.volumes)
-
-        volumes = filter(lambda w: isinstance(w, gui.gtk.CheckButton),
-                         self.ui.volumes.get_children())
-        self.assertEqual(len(volumes), len(FAKE_VOLUMES_INFO))
+        self.assertEqual(len(self.ui.volumes_store), len(FAKE_VOLUMES_INFO))
 
     def test_on_volumes_info_ready_with_no_volumes(self):
         """When there are no volumes, a notification is shown."""
         self.ui.on_volumes_info_ready([])
-        # no volumes table
-        self.assertEqual(len(self.ui.folders.get_children()), 0)
-        self.assertTrue(self.ui.volumes is None)
-
-    def test_on_subscribed_clicked(self):
-        """Clicking on 'subscribed' updates the folder subscription."""
-        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
-
-        method = 'change_volume_settings'
-        for checkbutton in self.ui._subscribed:
-            checkbutton.clicked()
-            fid = checkbutton.get_label()
-
-            subscribed = gui.bool_str(checkbutton.get_active())
-            self.assert_backend_called(method,
-                                       (fid, {'subscribed': subscribed}))
-            # clean backend calls
-            self.ui.backend._called.pop(method)
-
-            checkbutton.clicked()
-            subscribed = gui.bool_str(checkbutton.get_active())
-            self.assert_backend_called('change_volume_settings',
-                                       (fid, {'subscribed': subscribed}))
+
+        self.assertEqual(len(self.ui.volumes_store), 0)
 
     def test_on_volumes_info_error(self):
         """The volumes info couldn't be retrieved."""
@@ -854,6 +890,57 @@
         self.test_on_volumes_info_error()
         self.test_on_volumes_info_ready_with_no_volumes()
 
+    def test_on_subscribed_toggled(self):
+        """Clicking on 'subscribed' updates the folder subscription."""
+        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
+
+        for parent, (_, _, volumes) in enumerate(FAKE_VOLUMES_INFO):
+
+            sorted_vols = sorted(volumes, key=gui.operator.itemgetter('path'))
+            for child, volume in enumerate(sorted_vols):
+                if volume['type'] == 'ROOT':
+                    continue  # not editable
+
+                path = '%s:%s' % (parent, child)
+                self.ui.on_subscribed_toggled(widget=None, path=path)
+
+                fid = volume['volume_id']
+                subscribed = gui.bool_str(not bool(volume['subscribed']))
+                # backend was called
+                self.assert_backend_called('change_volume_settings',
+                                           (fid, {'subscribed': subscribed}))
+                # store was updated
+                it = self.ui.volumes_store.get_iter(path)
+                value = self.ui.volumes_store.get_value(it, 1)
+                self.assertEqual(value, bool(subscribed))
+
+                # the ui is processing
+                self.assertTrue(self.ui.is_processing, 'ui must be processing')
+
+                # simulate success for setting change
+                self.ui.on_volume_settings_changed(volume_id=fid)
+
+    def test_on_volume_setting_changed(self):
+        """The setting for a volume was successfully changed."""
+        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
+        self.ui.on_subscribed_toggled(None, "0:0")
+
+        self.ui.on_volume_settings_changed(volume_id=None)  # id not used
+
+        # the ui is no longer processing
+        self.assertFalse(self.ui.is_processing, 'ui must not be processing')
+
+    def test_on_volume_setting_change_error(self):
+        """The setting for a volume was not successfully changed."""
+        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
+        self.ui.on_subscribed_toggled(None, "0:0")
+
+        self.patch(self.ui, 'load', self._set_called)
+        self.ui.on_volume_settings_change_error(volume_id=None,
+                                                error_dict=None)  # id not used
+        # reload folders list to sanitize the info in volumes_store
+        self.assertTrue(self._called, ((), {}))
+
 
 class DeviceTestCase(ControlPanelMixinTestCase):
     """The test suite for the device widget."""
@@ -2086,11 +2173,11 @@
         actual = self.ui.notebook.get_nth_page(self.ui.DASHBOARD_PAGE)
         self.assertTrue(self.ui.dashboard is actual)
 
-    def test_folders_panel_is_packed(self):
-        """The folders panel is packed."""
-        self.assertIsInstance(self.ui.folders, gui.FoldersPanel)
-        actual = self.ui.notebook.get_nth_page(self.ui.FOLDERS_PAGE)
-        self.assertTrue(self.ui.folders is actual)
+    def test_volumes_panel_is_packed(self):
+        """The volumes panel is packed."""
+        self.assertIsInstance(self.ui.volumes, gui.VolumesPanel)
+        actual = self.ui.notebook.get_nth_page(self.ui.VOLUMES_PAGE)
+        self.assertTrue(self.ui.volumes is actual)
 
     def test_devices_panel_is_packed(self):
         """The devices panel is packed."""
@@ -2104,11 +2191,11 @@
         actual = self.ui.notebook.get_nth_page(self.ui.SERVICES_PAGE)
         self.assertTrue(self.ui.services is actual)
 
-    def test_entering_folders_tab_loads_content(self):
-        """The volumes info is loaded when entering the Folders tab."""
-        self.patch(self.ui.folders, 'load', self._set_called)
+    def test_entering_volumes_tab_loads_content(self):
+        """The volumes info is loaded when entering the Volumes tab."""
+        self.patch(self.ui.volumes, 'load', self._set_called)
         # clean backend calls
-        self.ui.folders_button.clicked()
+        self.ui.volumes_button.clicked()
 
         self.assertEqual(self._called, ((), {}))
 

=== modified file 'ubuntuone/controlpanel/gtk/tests/test_widgets.py'
--- ubuntuone/controlpanel/gtk/tests/test_widgets.py	2010-12-18 20:16:18 +0000
+++ ubuntuone/controlpanel/gtk/tests/test_widgets.py	2011-01-21 19:25:14 +0000
@@ -156,7 +156,7 @@
 
     def setUp(self):
         super(PanelTitleTestCase, self).setUp()
-        self.widget = widgets.PanelTitle(markup=self.TITLE)
+        self.widget = widgets.PanelTitle(markup=self.TITLE, change_bg=True)
 
         win = widgets.gtk.Window()
         win.add(self.widget)
@@ -196,13 +196,6 @@
         self.assertEqual(self.widget.label.get_line_wrap_mode(),
                          widgets.pango.WRAP_WORD)
 
-    def test_label_size_allocated_is_connected(self):
-        """Label have the size-allocate signal connected."""
-        self.widget.label.emit('size-allocate',
-                                widgets.gtk.gdk.Rectangle(1, 2, 3, 4))
-        self.assertEqual(self.widget.label.get_size_request(), (3 - 2, -1),
-                             'Label must have size-allocate connected.')
-
     def test_label_padding(self):
         """The label padding is correct."""
         self.assertEqual(self.widget.label.get_padding(),

=== modified file 'ubuntuone/controlpanel/gtk/widgets.py'
--- ubuntuone/controlpanel/gtk/widgets.py	2010-12-18 20:16:18 +0000
+++ ubuntuone/controlpanel/gtk/widgets.py	2011-01-21 19:25:14 +0000
@@ -108,27 +108,22 @@
 class PanelTitle(gtk.EventBox):
     """A box with a given color and text."""
 
-    def __init__(self, markup='', *args, **kwargs):
+    def __init__(self, markup='', change_bg=False, *args, **kwargs):
         super(PanelTitle, self).__init__(*args, **kwargs)
-        self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(DEFAULT_BG))
-
         self.label = gtk.Label()
         self.label.set_markup(markup)
         self.label.set_padding(*DEFAULT_PADDING)
-        self.label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.Color(DEFAULT_FG))
         self.label.set_property('xalign', 0.0)
         self.label.set_line_wrap(True)
         self.label.set_line_wrap_mode(pango.WRAP_WORD)
-        self.label.connect('size-allocate', self.on_size_allocate)
+        if change_bg:
+            self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(DEFAULT_BG))
+            self.label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.Color(DEFAULT_FG))
 
         self.add(self.label)
 
         self.show_all()
 
-    def on_size_allocate(self, widget, allocation):
-        """The widget can re rezised, embrase it!."""
-        widget.set_size_request(allocation.width - 2, -1)
-
 
 # Modified from John Stowers' client-side-windows demo.
 class GreyableBin(gtk.Bin):