Merge lp:~gtg-user/gtg/backends-window into lp:~gtg/gtg/old-trunk

[Luca Invernizzi]

This merge contains all the code relative to the window used to add, remove and edit backends.
All the functions should be documented.

[Marko Kevac (mkevac)]

Backend window works fine. One existing backend (local file) can be added and deleted.

This warning is printed in console after starting GTG:

/home/marko/Projects/gtg/backends-window/GTG/gtk/browser/browser.py:109: GtkWarning: No object called: image4
  self.builder.add_from_file(GnomeConfig.GLADE_FILE)

Should that be fixed?

[Luca Invernizzi (invernizzi)]

Fixed

[lp:~gtg-user/gtg/backends-window]

875. By Luca Invernizzi on 2010-08-20

small fix for marko kevec comment

876. By Luca Invernizzi on 2010-08-21

small fix in the backends tree

[Luca Invernizzi (invernizzi)]

Maybe the "Quit" button to dismiss the window could be better named. Suggestions welcome!

[lp:~gtg-user/gtg/backends-window]

877. By Luca Invernizzi on 2010-08-23

cherrypicking from my development branch

878. By Luca Invernizzi on 2010-08-23

cherrypicking from my development branch

879. By Luca Invernizzi on 2010-08-25

merge w/ trunk

880. By Luca Invernizzi on 2010-08-25

Workaround for arch linux, as for bug #lp 624204

881. By Luca Invernizzi on 2010-08-25

Bugfix for bug lp #624298 by Andrew Starr-Bochicchio
New backends window should have close button not quit

882. By Luca Invernizzi on 2010-08-26

cherrypicking from my development branch

883. By Luca Invernizzi on 2010-08-26

cherrypicking from my development branch

884. By Luca Invernizzi on 2010-09-04

cherrypicking from my development branch

=== modified file 'AUTHORS'
--- AUTHORS	2010-08-15 19:12:35 +0000
+++ AUTHORS	2010-09-04 17:54:43 +0000
@@ -70,3 +70,4 @@
 * Volodymyr Floreskul <[e-mail]>
 * Jeff Oliver <[e-mail]>
 * Thibault Fevry <https://edge.launchpad.net/~thibaultfevry> (no email provided)
+* Andrew Starr-Bochicchio <[e-mail]>
 
=== modified file 'CHANGELOG'
--- CHANGELOG	2010-08-04 00:30:22 +0000
+++ CHANGELOG	2010-09-04 17:54:43 +0000
@@ -4,6 +4,7 @@
     * Fixed bug with data consistency #579189, by Marko Kevac
     * Added samba bugzilla to the bugzilla plugin, by Jelmer Vernoij
     * Fixed bug #532392, a start date is later than a due date, by Volodymyr Floreskul
+    * Added a window to add/delete/edit backends by Luca Invernizzi
 
 2010-03-01 Getting Things GNOME! 0.2.2
     * Autostart on login, by Luca Invernizzi
 
=== added file 'GTG/backends/backendsignals.py'
--- GTG/backends/backendsignals.py	1970-01-01 00:00:00 +0000
+++ GTG/backends/backendsignals.py	2010-09-04 17:54:43 +0000
@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Getting Things Gnome! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2009 - Lionel Dricot & Bertrand Rousseau
+#
+# 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 gobject
+
+from GTG.tools.borg import Borg
+
+
+
+class BackendSignals(Borg):
+    '''
+    This class handles the signals that involve backends. 
+    In particular, it's a wrapper Borg class around a _BackendSignalsGObject
+    class, and all method of the wrapped class can be used as if they were part
+    of this class
+    '''
+    
+    #error codes to send along with the BACKEND_FAILED signal
+    ERRNO_AUTHENTICATION = "authentication failed"
+    ERRNO_NETWORK = "network is down"
+    ERRNO_DBUS = "Dbus interface cannot be connected"
+
+    def __init__(self):
+        '''Checks that this is the only instance, and instantiates the
+        gobject'''
+        super(BackendSignals, self).__init__()
+        if  hasattr(self, "_gobject"):
+            return
+        self._gobject = _BackendSignalsGObject()
+
+    def __getattr__(self, attr):
+        '''
+        From outside the class, there should be no difference between self's
+        attributes and self._gobject's attributes.
+        '''
+        if attr == "_gobject" and not "_gobject" in self.__dict__:
+            raise AttributeError
+        return getattr(self._gobject, attr)
+
+
+def signal_type_factory(*args):
+    '''
+    Simply returns a gobject signal type
+
+    @returns tuple
+    '''
+    return (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, args)
+
+
+
+class _BackendSignalsGObject(gobject.GObject):
+
+    #signal name constants
+    BACKEND_STATE_TOGGLED = 'backend-state-toggled' #emitted when a
+                                                    #backend is
+                                                    #enabled or disabled
+    BACKEND_RENAMED = 'backend-renamed' #emitted when a backend is renamed
+    BACKEND_ADDED = 'backend-added'
+    BACKEND_REMOVED = 'backend-added' #when a backend is deleted
+    DEFAULT_BACKEND_LOADED = 'default-backend-loaded' #emitted after all
+                                                     # tasks have been
+                                                     # loaded from the
+                                                     # default backend
+    BACKEND_FAILED = 'backend-failed' #something went wrong with a backend
+    BACKEND_SYNC_STARTED = 'backend-sync-started'
+    BACKEND_SYNC_ENDED = 'backend-sync-ended'
+    INTERACTION_REQUESTED = 'user-interaction-requested'
+
+    INTERACTION_CONFIRM = 'confirm'
+    INTERACTION_TEXT = 'text'
+
+    __gsignals__ = {BACKEND_STATE_TOGGLED : signal_type_factory(str), \
+                    BACKEND_RENAMED       : signal_type_factory(str), \
+                    BACKEND_ADDED         : signal_type_factory(str), \
+                    BACKEND_REMOVED       : signal_type_factory(str), \
+                    BACKEND_SYNC_STARTED  : signal_type_factory(str), \
+                    BACKEND_SYNC_ENDED    : signal_type_factory(str), \
+                    DEFAULT_BACKEND_LOADED: signal_type_factory(), \
+                    BACKEND_FAILED        : signal_type_factory(str, str), \
+                    INTERACTION_REQUESTED : signal_type_factory(str, str, \
+                                                                str,  str)}
+    
+    def __init__(self):
+        super(_BackendSignalsGObject, self).__init__()
+        self.backends_currently_syncing = []
+
+    ############# Signals #########
+    #connecting to signals is fine, but keep an eye if you should emit them.
+    #As a general rule, signals should only be emitted in the GenericBackend
+    #class
+    
+    def _emit_signal(self, signal, backend_id):
+        gobject.idle_add(self.emit, signal, backend_id)
+
+    def backend_state_changed(self, backend_id):
+        self._emit_signal(self.BACKEND_STATE_TOGGLED, backend_id)
+
+    def backend_renamed(self, backend_id):
+        self._emit_signal(self.BACKEND_RENAMED, backend_id)
+
+    def backend_added(self, backend_id):
+        self._emit_signal(self.BACKEND_ADDED, backend_id)
+
+    def backend_removed(self, backend_id):
+        self._emit_signal(self.BACKEND_REMOVED, backend_id)
+
+    def default_backend_loaded(self):
+        gobject.idle_add(self.emit, self.DEFAULT_BACKEND_LOADED)
+
+    def backend_failed(self, backend_id, error_code):
+        gobject.idle_add(self.emit, self.BACKEND_FAILED, backend_id, \
+                         error_code)
+
+    def interaction_requested(self, backend_id, description, \
+                              interaction_type, callback_str):
+        gobject.idle_add(self.emit, self.INTERACTION_REQUESTED, \
+                         backend_id, description, interaction_type, callback_str)
+
+    def backend_sync_started(self, backend_id):
+        self._emit_signal(self.BACKEND_SYNC_STARTED, backend_id)
+        self.backends_currently_syncing.append(backend_id)
+
+    def backend_sync_ended(self, backend_id):
+        self._emit_signal(self.BACKEND_SYNC_ENDED, backend_id)
+        try:
+            self.backends_currently_syncing.remove(backend_id)
+        except:
+            pass
+    
+    def is_backend_syncing(self, backend_id):
+        return backend_id in self.backends_currently_syncing
+
 
=== removed file 'GTG/backends/backendsignals.py'
--- GTG/backends/backendsignals.py	2010-06-23 12:49:28 +0000
+++ GTG/backends/backendsignals.py	1970-01-01 00:00:00 +0000
@@ -1,127 +0,0 @@
-# -*- coding: utf-8 -*-
-# -----------------------------------------------------------------------------
-# Getting Things Gnome! - a personal organizer for the GNOME desktop
-# Copyright (c) 2008-2009 - Lionel Dricot & Bertrand Rousseau
-#
-# 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 gobject
-
-from GTG.tools.borg import Borg
-
-
-
-class BackendSignals(Borg):
-    '''
-    This class handles the signals that involve backends. 
-    In particular, it's a wrapper Borg class around a _BackendSignalsGObject
-    class, and all method of the wrapped class can be used as if they were part
-    of this class
-    '''
-    
-    #error codes to send along with the BACKEND_FAILED signal
-    ERRNO_AUTHENTICATION = "authentication failed"
-    ERRNO_NETWORK = "network is down"
-    ERRNO_DBUS = "Dbus interface cannot be connected"
-
-    def __init__(self):
-        super(BackendSignals, self).__init__()
-        if  hasattr(self, "_gobject"):
-            return
-        self._gobject = _BackendSignalsGObject()
-
-    def __getattr__(self, attr):
-        if attr == "_gobject" and not "_gobject" in self.__dict__:
-            raise AttributeError
-        return getattr(self._gobject, attr)
-
-
-class _BackendSignalsGObject(gobject.GObject):
-
-    #signal name constants
-    BACKEND_STATE_TOGGLED = 'backend-state-toggled' #emitted when a
-                                                    #backend is
-                                                    #enabled or disabled
-    BACKEND_RENAMED = 'backend-renamed' #emitted when a backend is renamed
-    BACKEND_ADDED = 'backend-added'
-    BACKEND_REMOVED = 'backend-added' #when a backend is deleted
-    DEFAULT_BACKEND_LOADED = 'default-backend-loaded' #emitted after all
-                                                     # tasks have been
-                                                     # loaded from the
-                                                     # default backend
-    BACKEND_FAILED = 'backend-failed' #something went wrong with a backend
-    BACKEND_SYNC_STARTED = 'backend-sync-started'
-    BACKEND_SYNC_ENDED = 'backend-sync-ended'
-
-    __string_signal__ = (gobject.SIGNAL_RUN_FIRST, \
-                     gobject.TYPE_NONE, (str, ))
-    __none_signal__   = (gobject.SIGNAL_RUN_FIRST, \
-                     gobject.TYPE_NONE, ( ))
-    __string_string_signal__ = (gobject.SIGNAL_RUN_FIRST, \
-                    gobject.TYPE_NONE, (str, str, ))
-
-    __gsignals__ = {BACKEND_STATE_TOGGLED : __string_signal__, \
-                    BACKEND_RENAMED       : __string_signal__, \
-                    BACKEND_ADDED         : __string_signal__, \
-                    BACKEND_REMOVED       : __string_signal__, \
-                    BACKEND_SYNC_STARTED  : __string_signal__, \
-                    BACKEND_SYNC_ENDED    : __string_signal__, \
-                    DEFAULT_BACKEND_LOADED: __none_signal__, \
-                    BACKEND_FAILED        : __string_string_signal__}
-
-    def __init__(self):
-        super(_BackendSignalsGObject, self).__init__()
-        self.backends_currently_syncing = []
-
-    ############# Signals #########
-    #connecting to signals is fine, but keep an eye if you should emit them.
-    #As a general rule, signals should only be emitted in the GenericBackend
-    #class
-    
-    def _emit_signal(self, signal, backend_id):
-        gobject.idle_add(self.emit, signal, backend_id)
-
-    def backend_state_changed(self, backend_id):
-        self._emit_signal(self.BACKEND_STATE_TOGGLED, backend_id)
-
-    def backend_renamed(self, backend_id):
-        self._emit_signal(self.BACKEND_RENAMED, backend_id)
-
-    def backend_added(self, backend_id):
-        self._emit_signal(self.BACKEND_ADDED, backend_id)
-
-    def backend_removed(self, backend_id):
-        self._emit_signal(self.BACKEND_REMOVED, backend_id)
-
-    def default_backend_loaded(self):
-        gobject.idle_add(self.emit, self.DEFAULT_BACKEND_LOADED)
-
-    def backend_failed(self, backend_id, error_code):
-        gobject.idle_add(self.emit, self.BACKEND_FAILED, backend_id, \
-                         error_code)
-
-    def backend_sync_started(self, backend_id):
-        self._emit_signal(self.BACKEND_SYNC_STARTED, backend_id)
-        self.backends_currently_syncing.append(backend_id)
-
-    def backend_sync_ended(self, backend_id):
-        self._emit_signal(self.BACKEND_SYNC_ENDED, backend_id)
-        try:
-            self.backends_currently_syncing.remove(backend_id)
-        except:
-            pass
-    
-    def is_backend_syncing(self, backend_id):
-        return backend_id in self.backends_currently_syncing
 
=== modified file 'GTG/core/requester.py'
--- GTG/core/requester.py	2010-06-22 19:55:15 +0000
+++ GTG/core/requester.py	2010-09-04 17:54:43 +0000
@@ -284,3 +284,6 @@
 
     def backend_change_attached_tags(self, backend_id, tags):
         return self.ds.backend_change_attached_tags(backend_id, tags)
+
+    def save_datastore(self):
+        return self.ds.save()
 
=== modified file 'GTG/gtk/__init__.py'
--- GTG/gtk/__init__.py	2010-06-02 18:12:23 +0000
+++ GTG/gtk/__init__.py	2010-09-04 17:54:43 +0000
@@ -28,7 +28,9 @@
 
 
 class ViewConfig:
+
+
     current_rep = os.path.dirname(os.path.abspath(__file__))
     DELETE_GLADE_FILE  = os.path.join(current_rep, "deletion.glade")
     PREFERENCES_GLADE_FILE = os.path.join(current_rep, "preferences.glade")
-
+    BACKENDS_GLADE_FILE = os.path.join(current_rep, "backends_dialog.glade")
 
=== added directory 'GTG/gtk/backends_dialog'
=== added file 'GTG/gtk/backends_dialog.glade'
--- GTG/gtk/backends_dialog.glade	1970-01-01 00:00:00 +0000
+++ GTG/gtk/backends_dialog.glade	2010-09-04 17:54:43 +0000
@@ -0,0 +1,166 @@
+<?xml version="1.0"?>
+<interface>
+  <requires lib="gtk+" version="2.16"/>
+  <!-- interface-naming-policy project-wide -->
+  <object class="GtkWindow" id="backends_dialog">
+    <property name="window_position">mouse</property>
+    <signal name="delete_event" handler="on_BackendsDialog_delete_event"/>
+    <child>
+      <object class="GtkAlignment" id="alignment1">
+        <property name="visible">True</property>
+        <property name="top_padding">10</property>
+        <property name="bottom_padding">10</property>
+        <property name="left_padding">10</property>
+        <property name="right_padding">10</property>
+        <child>
+          <object class="GtkVBox" id="vbox1">
+            <property name="visible">True</property>
+            <property name="spacing">10</property>
+            <child>
+              <object class="GtkHBox" id="big_central_hbox">
+                <property name="visible">True</property>
+                <property name="spacing">10</property>
+                <child>
+                  <object class="GtkVBox" id="vbox2">
+                    <property name="visible">True</property>
+                    <child>
+                      <object class="GtkAlignment" id="treeview_window">
+                        <property name="height_request">400</property>
+                        <property name="visible">True</property>
+                        <child>
+                          <placeholder/>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkAlignment" id="alignment2">
+                        <property name="height_request">30</property>
+                        <property name="visible">True</property>
+                        <property name="yalign">1</property>
+                        <property name="top_padding">20</property>
+                        <property name="bottom_padding">10</property>
+                        <property name="left_padding">10</property>
+                        <property name="right_padding">10</property>
+                        <child>
+                          <object class="GtkHButtonBox" id="hbuttonbox3">
+                            <property name="visible">True</property>
+                            <property name="spacing">10</property>
+                            <property name="homogeneous">True</property>
+                            <child>
+                              <object class="GtkButton" id="add_button">
+                                <property name="label">gtk-add</property>
+                                <property name="visible">True</property>
+                                <property name="can_focus">True</property>
+                                <property name="receives_default">True</property>
+                                <property name="use_stock">True</property>
+                                <signal name="clicked" handler="on_add_button_clicked"/>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">False</property>
+                                <property name="position">0</property>
+                              </packing>
+                            </child>
+                            <child>
+                              <object class="GtkButton" id="remove_button">
+                                <property name="label">gtk-remove</property>
+                                <property name="visible">True</property>
+                                <property name="can_focus">True</property>
+                                <property name="receives_default">True</property>
+                                <property name="use_stock">True</property>
+                                <signal name="clicked" handler="on_remove_button_clicked"/>
+                              </object>
+                              <packing>
+                                <property name="expand">False</property>
+                                <property name="fill">False</property>
+                                <property name="position">1</property>
+                              </packing>
+                            </child>
+                          </object>
+                        </child>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">False</property>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkScrolledWindow" id="central_pane_window">
+                    <property name="width_request">450</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="vadjustment">adjustment1</property>
+                    <property name="hscrollbar_policy">automatic</property>
+                    <property name="vscrollbar_policy">automatic</property>
+                    <child>
+                      <object class="GtkViewport" id="central_pane1">
+                        <property name="visible">True</property>
+                        <property name="resize_mode">queue</property>
+                        <child>
+                          <object class="GtkAlignment" id="central_pane">
+                            <property name="visible">True</property>
+                            <property name="left_padding">10</property>
+                            <property name="right_padding">10</property>
+                            <child>
+                              <placeholder/>
+                            </child>
+                          </object>
+                        </child>
+                      </object>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkHButtonBox" id="hbuttonbox2">
+                <property name="visible">True</property>
+                <property name="layout_style">end</property>
+                <child>
+                  <object class="GtkButton" id="close_button">
+                    <property name="label">gtk-close</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">True</property>
+                    <property name="use_stock">True</property>
+                    <signal name="clicked" handler="on_close_button_clicked"/>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">False</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+        </child>
+      </object>
+    </child>
+  </object>
+  <object class="GtkAdjustment" id="adjustment1">
+    <property name="upper">100</property>
+    <property name="step_increment">1</property>
+    <property name="page_increment">10</property>
+    <property name="page_size">10</property>
+  </object>
+</interface>
 
=== added file 'GTG/gtk/backends_dialog/__init__.py'
--- GTG/gtk/backends_dialog/__init__.py	1970-01-01 00:00:00 +0000
+++ GTG/gtk/backends_dialog/__init__.py	2010-09-04 17:54:43 +0000
@@ -0,0 +1,294 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Getting Things Gnome! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2009 - Lionel Dricot & Bertrand Rousseau
+#
+# 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/>.
+# -----------------------------------------------------------------------------
+
+'''
+This file contains BackendsDialog, a class that manages the window that
+lets you add and configure backends.
+This window is divided in two:
+    - a treeview of the currently loaded backends (the ones added by the user)
+    - a big space, that can be filled by the configuration panel or the add
+    panel (these are called also "views" in this class)
+'''
+
+import gtk
+
+from GTG.gtk                                import ViewConfig
+from GTG.core                               import CoreConfig
+from GTG.gtk.backends_dialog.backendstree   import BackendsTree
+from GTG.gtk.backends_dialog.addpanel       import AddPanel
+from GTG.gtk.backends_dialog.configurepanel import ConfigurePanel
+from GTG.backends                           import BackendFactory
+from GTG.tools.logger                       import Log
+from GTG                                    import _
+from GTG.backends.genericbackend            import GenericBackend
+
+
+
+class BackendsDialog(object):
+    '''
+    BackendsDialog manages a window that lets you manage and configure backends.
+    It can display two "views", or "panels":
+        - the backend configuration view
+        - the backend adding view
+    '''
+
+
+    def __init__(self, req):
+        '''
+        Initializes the gtk objects and signals.
+        @param req: a Requester object
+        '''
+        self.req = req
+        self._configure_icon_theme()
+        builder = gtk.Builder() 
+        self._load_widgets_from_glade(builder)
+        self._create_widgets_for_add_panel()
+        self._create_widgets_for_configure_panel()
+        self._setup_signal_connections(builder)
+        self._create_widgets_for_backends_tree()
+
+########################################
+### INTERFACE WITH THE VIEWMANAGER #####
+########################################
+
+    def activate(self):
+        '''Shows this window, refreshing the current view'''
+        self.config_panel.set_hidden(False)
+        self.dialog.show_all()
+        self.backends_tv.refresh()
+        self.backends_tv.select_backend()
+        self.dialog.present()
+
+    def on_close(self, widget, data = None):
+        '''
+        Hides this window, saving the backends configuration.
+        
+        @param widget: not used, here only for using this as signal callback
+        @param data: same as widget, disregard the content
+        '''
+        self.dialog.hide()
+        self.config_panel.set_hidden(True)
+        self.req.save_datastore()
+
+########################################
+### HELPER FUNCTIONS ###################
+########################################
+
+    def get_requester(self):
+        '''
+        Helper function: returns the requester.
+        It's used by the "views" displayed by this class (backend editing and
+        adding views) to access the requester
+        '''
+        return self.req
+
+    def get_pixbuf_from_icon_name(self, name, height, width):
+        '''
+        Helper function: returns a pixbuf of an icon given its name in the
+        loaded icon theme
+
+        @param name: the name of the icon
+        @param height: the height of the returned pixbuf
+        @param width:  the width of the returned pixbuf
+
+        @returns gtk.gdk.Pixbuf: a pixbuf containing the wanted icon, or None
+        (if the icon is not present)
+        '''
+        #NOTE: loading icons directly from the theme and scaling them results in
+        #      blurry icons. So, instead of doing that, I'm loading them
+        #      directly from file. 
+        icon_info = self.icon_theme.lookup_icon(name, gtk.ICON_SIZE_MENU, 0)
+        if icon_info == None:
+            return None
+        pixbuf =  gtk.gdk.pixbuf_new_from_file(icon_info.get_filename())
+        return pixbuf.scale_simple(width, height, gtk.gdk.INTERP_BILINEAR)
+
+    def _show_panel(self, panel_name):
+        '''
+        Helper function to switch between panels.
+
+        @param panel_name: the name of the wanted panel. Choose between 
+                        "configuration" or "add"
+        '''
+        if panel_name == "configuration":
+            panel_to_remove = self.add_panel
+            panel_to_add = self.config_panel
+            side_is_enabled = True
+        elif panel_name == "add":
+            panel_to_remove = self.config_panel
+            panel_to_add = self.add_panel
+            side_is_enabled = False
+        else:
+            Log.error("panel name unknown")
+            return
+        ##Central pane
+        #NOTE: self.central_pane is the gtk.Container in which we load panels
+        if panel_to_remove in self.central_pane:
+            self.central_pane.remove(panel_to_remove)
+        if not panel_to_add in self.central_pane:
+            self.central_pane.add(panel_to_add)
+        self.central_pane.show_all()
+        #Side treeview
+        # disabled if we're adding a new backend
+        try:
+            #when this is called upon initialization of this class, the
+            # backends_tv object has not been created yet.
+            self.add_button.set_sensitive(side_is_enabled)
+            self.remove_button.set_sensitive(side_is_enabled)
+            self.backends_tv.set_sensitive(side_is_enabled)
+        except AttributeError:
+            pass
+
+########################################
+### WIDGETS AND SIGNALS ################
+########################################
+
+    def _load_widgets_from_glade(self, builder):
+        '''
+        Loads widgets from the glade file
+
+        @param builder: a gtk.Builder
+        '''
+        builder.add_from_file(ViewConfig.BACKENDS_GLADE_FILE)
+        widgets = {
+          'dialog'        : 'backends_dialog',
+          'treeview_window'   : 'treeview_window',
+          'central_pane'  : 'central_pane',
+          'add_button'    : 'add_button',
+          'remove_button' : 'remove_button',
+          }
+        for attr, widget in widgets.iteritems():
+            setattr(self, attr, builder.get_object(widget))
+
+    def _setup_signal_connections(self, builder):
+        '''
+        Creates some GTK signals connections
+
+        @param builder: a gtk.Builder
+        '''
+        signals = {
+         'on_add_button_clicked': self.on_add_button,
+         'on_BackendsDialog_delete_event': self.on_close,
+         'on_close_button_clicked': self.on_close,
+         'on_remove_button_clicked': self.on_remove_button,
+        }
+        builder.connect_signals(signals)
+
+    def _configure_icon_theme(self):
+        '''
+        Inform gtk on the location of the backends icons (which is in
+        the GTG directory tree, and not in the default location for icons
+        '''
+        self.icon_theme = gtk.icon_theme_get_default()
+        for directory in CoreConfig().get_icons_directories():
+            self.icon_theme.prepend_search_path(directory)
+
+    def _create_widgets_for_backends_tree(self):
+        '''
+        Creates the widgets for the lateral treeview displaying the 
+        backends the user has added
+        '''
+        self.backends_tv = BackendsTree(self)
+        self.treeview_window.add(self.backends_tv)
+
+    def _create_widgets_for_configure_panel(self):
+        '''simply creates the panel to configure backends'''
+        self.config_panel = ConfigurePanel(self)
+
+    def _create_widgets_for_add_panel(self):
+        '''simply creates the panel to add backends'''
+        self.add_panel = AddPanel(self)
+
+########################################
+### EVENT HANDLING #####################
+########################################
+
+    def on_backend_selected(self, backend_id):
+        '''
+        When a backend in the treeview gets selected, show
+        its configuration pane
+
+        @param backend_id: the id of the selected backend
+        '''
+        if backend_id:
+            self._show_panel("configuration")
+            self.config_panel.set_backend(backend_id)
+            backend = self.req.get_backend(backend_id)
+            self.remove_button.set_sensitive(not backend.is_default())
+
+    def on_add_button(self, widget = None, data = None):
+        '''
+        When the add button is pressed, the add panel is shown
+
+        @param widget: not used, here only for using this as signal callback
+        @param data: same as widget, disregard the content
+        '''
+        self._show_panel("add")
+        self.add_panel.refresh_backends()
+
+    def on_backend_added(self, backend_name):
+        '''
+        When a backend is added, it is created and registered in the Datastore.
+        Also, the configuration panel is shown.
+
+        @param backend_name: the name of the type of the backend to add
+                             (identified as BACKEND_NAME in the Backend class)
+        '''
+        backend_id = None
+        #Create Backend
+        backend_dic = BackendFactory().get_new_backend_dict(backend_name)
+        if backend_dic:
+            backend_id = backend_dic["backend"].get_id()
+            backend_dic[GenericBackend.KEY_ENABLED] = False
+            self.req.register_backend(backend_dic)
+        #Restore UI
+        self._show_panel("configuration")
+
+    def show_config_for_backend(self, backend_id):
+        '''
+        Selects a backend in the lateral treeview
+
+        @param backend_id: the id of the backend that must be selected
+        '''
+        self.backends_tv.select_backend(backend_id)
+
+    def on_remove_button(self, widget = None, data = None):
+        '''
+        When the remove button is pressed, a confirmation dialog is shown, 
+        and if the answer is positive, the backend is deleted.
+        '''
+        backend_id = self.backends_tv.get_selected_backend_id()
+        if backend_id == None:
+            #no backend selected
+            return
+        backend = self.req.get_backend(backend_id)
+        dialog = gtk.MessageDialog( \
+                    parent = self.dialog,
+                    flags = gtk.DIALOG_DESTROY_WITH_PARENT,
+                    type = gtk.MESSAGE_QUESTION,
+                    buttons = gtk.BUTTONS_YES_NO,
+                    message_format = \
+                     _("Do you really want to remove the backend '%s'?") % \
+                            backend.get_human_name())
+        response = dialog.run() 
+        dialog.destroy()
+        if response == gtk.RESPONSE_YES:
+            #delete the backend and remove it from the lateral treeview
+            self.req.remove_backend(backend_id)
+            self.backends_tv.remove_backend(backend_id)
 
=== added file 'GTG/gtk/backends_dialog/addpanel.py'
--- GTG/gtk/backends_dialog/addpanel.py	1970-01-01 00:00:00 +0000
+++ GTG/gtk/backends_dialog/addpanel.py	2010-09-04 17:54:43 +0000
@@ -0,0 +1,214 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Getting Things Gnome! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2009 - Lionel Dricot & Bertrand Rousseau
+#
+# 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
+
+from GTG.gtk.backends_dialog.backendscombo import BackendsCombo
+from GTG.backends                          import BackendFactory
+from GTG                                   import _, ngettext
+
+#The code for showing the required modules has been disabled since it
+# seems that backends will be packaged separately (as plugins). I'm
+# leaving this here in case we change that decision (invernizzi).
+#from GTG.tools.moduletopackage             import ModuleToPackage
+
+
+
+class AddPanel(gtk.VBox):
+    ''' 
+    A VBox filled with gtk widgets to let the user choose a new backend.
+    '''
+
+
+    def __init__(self, backends_dialog):
+        '''
+        Constructor, just initializes the gtk widgets
+
+        @param backends_dialog: a reference to the dialog in which this is
+        loaded
+        '''
+        super(AddPanel, self).__init__()
+        self.dialog = backends_dialog
+        self._create_widgets()
+
+    def _create_widgets(self):
+        '''
+        gtk widgets initialization
+        '''
+        #Division of the available space in three segments:
+        # top, middle and bottom.
+        top = gtk.HBox()
+        middle = gtk.HBox()
+        bottom = gtk.HBox()
+        self._fill_top_hbox(top)
+        self._fill_middle_hbox(middle)
+        self._fill_bottom_hbox(bottom)
+        self.pack_start(top, False)
+        self.pack_start(middle, True)
+        self.pack_start(bottom, True)
+
+    def _fill_top_hbox(self, hbox):
+        '''
+        Helper function to fill and hbox with a combobox that lists the
+        available backends and a gtk.Label.
+
+        @param hbox: the gtk.HBox to fill
+        '''
+        label = gtk.Label("Select a backend")
+        label.set_size_request(-1, 30)
+        self.combo_types = BackendsCombo(self.dialog)
+        self.combo_types.child.connect('changed', self.on_combo_changed)
+        hbox.pack_start(label, True, True)
+        hbox.pack_start(self.combo_types, False, True)
+
+    def _fill_middle_hbox(self, hbox):
+        '''
+        Helper function to fill an hbox with a label describing the backend
+        and a gtk.Image (that loads the backend image)
+
+        @param hbox: the gtk.HBox to fill
+        '''
+        self.label_name = gtk.Label("name")
+        self.label_name.set_alignment(xalign = 0.5, yalign = 1)
+        self.label_description = gtk.Label()
+        self.label_description.set_justify(gtk.JUSTIFY_FILL)
+        self.label_description.set_line_wrap(True)
+        self.label_description.set_size_request(300, -1)
+        self.label_description.set_alignment(xalign = 0, yalign = 0.5)
+        self.label_author = gtk.Label("")
+        self.label_author.set_line_wrap(True)
+        self.label_author.set_alignment(xalign = 0, yalign = 0)
+        self.label_modules = gtk.Label("")
+        self.label_modules.set_line_wrap(True)
+        self.label_modules.set_alignment(xalign = 0, yalign = 0)
+        self.image_icon = gtk.Image()
+        self.image_icon.set_size_request(100, 100)
+        align_image = gtk.Alignment(xalign = 1, yalign = 0)
+        align_image.add(self.image_icon)
+        labels_vbox = gtk.VBox()
+        labels_vbox.pack_start(self.label_description, True, True)
+        labels_vbox.pack_start(self.label_author, True, True)
+        labels_vbox.pack_start(self.label_modules, True, True)
+        low_hbox = gtk.HBox()
+        low_hbox.pack_start(labels_vbox, True, True)
+        low_hbox.pack_start(align_image, True, True)
+        vbox = gtk.VBox()
+        vbox.pack_start(self.label_name, True, True)
+        vbox.pack_start(low_hbox, True, True)
+        hbox.pack_start(vbox, True, True)
+
+    def _fill_bottom_hbox(self, hbox):
+        '''
+        Helper function to fill and hbox with a buttonbox, featuring 
+        and ok and cancel buttons.
+
+        @param hbox: the gtk.HBox to fill
+        '''
+        cancel_button = gtk.Button(stock = gtk.STOCK_CANCEL)
+        cancel_button.connect('clicked', self.on_cancel)
+        self.ok_button = gtk.Button(stock = gtk.STOCK_OK)
+        self.ok_button.connect('clicked', self.on_confirm)
+        align =gtk.Alignment(xalign = 0.5, \
+                             yalign = 1, \
+                             xscale = 1)
+        align.set_padding(0, 10, 0, 0)
+        buttonbox = gtk.HButtonBox()
+        buttonbox.set_layout(gtk.BUTTONBOX_EDGE)
+        buttonbox.add(cancel_button)
+        buttonbox.set_child_secondary(cancel_button, False)
+        buttonbox.add(self.ok_button)
+        align.add(buttonbox)
+        hbox.pack_start(align, True, True)
+
+    def refresh_backends(self):
+        '''Populates the combo box containing the available backends'''
+        self.combo_types.refresh()
+
+    def on_confirm(self, widget = None):
+        '''
+        Notifies the dialog holding this VBox that a backend has been
+        chosen
+
+        @param widget: just to make this function usable as a signal callback.
+                       Not used.
+        '''
+        backend_name = self.combo_types.get_selected()
+        self.dialog.on_backend_added(backend_name)
+
+    def on_cancel(self, widget = None):
+        '''
+        Aborts the addition of a new backend. Shows the configuration panel
+        previously loaded.
+
+        @param widget: just to make this function usable as a signal callback.
+                       Not used.
+        '''
+        self.dialog.show_config_for_backend(None)
+
+    def on_combo_changed(self, widget = None):
+        '''
+        Updates the backend description and icon.
+
+        @param widget: just to make this function usable as a signal callback.
+                       Not used.
+        '''
+        backend_name = self.combo_types.get_selected()
+        if backend_name == None:
+            return
+        backend = BackendFactory().get_backend(backend_name)
+        self.label_description.set_markup(backend.Backend.get_description())
+
+        label = _('Syncing is <span color="red">disabled</span>')
+        markup = '<big><big><big><b>%s</b></big></big></big>' % \
+                                backend.Backend.get_human_default_name()
+        self.label_name.set_markup(markup)
+        authors = backend.Backend.get_authors()
+        author_txt = '<b>%s</b>:\n   - %s' % \
+                (ngettext("Author", "Authors", len(authors)),
+                 reduce(lambda a, b: a + "\n" + "   - " + b, authors))
+        self.label_author.set_markup(author_txt)
+        #The code for showing the required modules has been disabled since it
+        # seems that backends will be packaged separately (as plugins). I'm
+        # leaving this here in case we change that decision (invernizzi).
+        #self._build_module_list(backend.Backend)
+        pixbuf = self.dialog.get_pixbuf_from_icon_name(backend_name, 100, 100)
+        self.image_icon.set_from_pixbuf(pixbuf)
+        self.show_all()
+
+        #The code for showing the required modules has been disabled since it
+        # seems that backends will be packaged separately (as plugins). I'm
+        # leaving this here in case we change that decision (invernizzi).
+#    def _build_module_list(self, backend):
+#        missing_modules = []
+#        for module in backend.get_required_modules():
+#            try:
+#                __import__(module)
+#            except ImportError:
+#                missing_modules.append(module)
+#        if missing_modules:
+#            text = "<b> Missing modules:</b>\n - "
+#            module2package = ModuleToPackage()
+#            missing_modules = map(lambda a: \
+#                    "<span color='red'>" + \
+#                    module2package.lookup(a) +\
+#                    "</span>", missing_modules)
+#            text += reduce(lambda a, b: a + "\n - " + b, missing_modules)
+#            self.label_modules.set_markup(text)
+#        self.ok_button.set_sensitive(missing_modules == [])
+
 
=== added file 'GTG/gtk/backends_dialog/backendscombo.py'
--- GTG/gtk/backends_dialog/backendscombo.py	1970-01-01 00:00:00 +0000
+++ GTG/gtk/backends_dialog/backendscombo.py	2010-09-04 17:54:43 +0000
@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Getting Things Gnome! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2009 - Lionel Dricot & Bertrand Rousseau
+#
+# 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
+
+from GTG.backends import BackendFactory
+
+
+
+class BackendsCombo(gtk.ComboBoxEntry):
+    '''
+    A combobox listing all the available backends types
+    '''
+    
+
+    COLUMN_NAME = 0         #unique name for the backend type. It's never
+                            # displayed, it's used to find which backend has
+                            # been selected
+    COLUMN_HUMAN_NAME = 1   #human friendly name (which is localized).
+    COLUMN_ICON = 2 
+
+    def __init__(self, backends_dialog):
+        '''
+        Constructor, itializes gtk widgets.
+        @param backends_dialog: reference to the dialog in which this combo is
+                                loaded.
+        '''
+        super(BackendsCombo, self).__init__()
+        self.dialog = backends_dialog
+        self._liststore_init()
+        self._renderers_init()
+        self.set_size_request(-1, 30)
+        self.show_all()
+
+    def _liststore_init(self):
+        '''Setup the gtk.ListStore'''
+        self.liststore = gtk.ListStore(str, str, gtk.gdk.Pixbuf)
+        self.set_model(self.liststore)
+
+    def _renderers_init(self):
+        '''Configure the cell renderers'''
+        #Text renderer
+        text_cell = gtk.CellRendererText()
+        self.pack_start(text_cell, False)
+        self.set_text_column(self.COLUMN_HUMAN_NAME)
+        #Icon renderer
+        pixbuf_cell = gtk.CellRendererPixbuf()
+        self.pack_start(pixbuf_cell, False)
+        self.add_attribute(pixbuf_cell, "pixbuf", self.COLUMN_ICON)
+
+    def refresh(self):
+        '''
+        Populates the combo box with the available backends
+        '''
+        self.liststore.clear()
+        backend_types = BackendFactory().get_all_backends()
+        for name, module in backend_types.iteritems():
+            pixbuf = self.dialog.get_pixbuf_from_icon_name(name, 16, 16)
+            self.liststore.append((name, \
+                                   module.Backend.get_human_default_name(), \
+                                   pixbuf))
+        if backend_types:
+            #triggers a "changed" signal, which is used in the AddPanel to
+            #refresh the backend description and icon
+            self.set_active(0)
+
+    def get_selected(self):
+        '''
+        Returns the name of the selected backend, or None
+        '''
+        selected_iter = self.get_active_iter()
+        if selected_iter:
+            return self.liststore.get_value(selected_iter, \
+                                        BackendsCombo.COLUMN_NAME)
+        else:
+            return None
 
=== added file 'GTG/gtk/backends_dialog/backendstree.py'
--- GTG/gtk/backends_dialog/backendstree.py	1970-01-01 00:00:00 +0000
+++ GTG/gtk/backends_dialog/backendstree.py	2010-09-04 17:54:43 +0000
@@ -0,0 +1,253 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Getting Things Gnome! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2009 - Lionel Dricot & Bertrand Rousseau
+#
+# 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
+
+from GTG.gtk.colors              import get_colored_tags_markup
+from GTG.backends.genericbackend import GenericBackend
+from GTG.backends.backendsignals import BackendSignals
+
+
+
+class BackendsTree(gtk.TreeView):
+    '''
+    gtk.TreeView that shows the currently loaded backends.
+    '''
+
+
+    COLUMN_BACKEND_ID = 0 #never shown, used for internal lookup.
+    COLUMN_ICON = 1
+    COLUMN_TEXT = 2 # holds the backend "human-readable" name
+    COLUMN_TAGS = 3
+
+    def __init__(self, backendsdialog):
+        '''
+        Constructor, just initializes the gtk widgets
+
+        @param backends_dialog: a reference to the dialog in which this is
+        loaded
+        '''
+        super(BackendsTree,self).__init__()
+        self.dialog = backendsdialog
+        self.req = backendsdialog.get_requester()
+        self._init_liststore()
+        self._init_renderers()
+        self._init_signals()
+        self.refresh()
+
+    def refresh(self):
+        '''refreshes the gtk.Liststore'''
+        self.backendid_to_iter = {}
+        self.liststore.clear()
+        for backend in self.req.get_all_backends(disabled = True):
+            self.add_backend(backend)
+            self.on_backend_state_changed(None, backend.get_id())
+
+    def on_backend_added(self, sender, backend_id):
+        '''
+        Signal callback executed when a new backend is loaded
+
+        @param sender: not used, only here to let this function be used as a
+                       callback
+        @param backend_id: the id of the backend to add
+        '''
+        #Add
+        backend = self.req.get_backend(backend_id)
+        if not backend:
+            return
+        self.add_backend(backend)
+        #Select
+        self.select_backend(backend_id)
+        #Update it's enabled state
+        self.on_backend_state_changed(None, backend.get_id())
+
+    def add_backend(self, backend):
+        '''
+        Adds a new backend to the list
+
+        @param backend_id: the id of the backend to add
+        '''
+        if backend:
+            backend_iter = self.liststore.append([ \
+                backend.get_id(), \
+                self.dialog.get_pixbuf_from_icon_name(backend.get_name(), \
+                                                      16, 16), \
+                backend.get_human_name(), \
+                self._get_markup_for_tags(backend.get_attached_tags()), \
+                ])
+            self.backendid_to_iter[backend.get_id()] = backend_iter
+
+
+    def on_backend_state_changed(self, sender, backend_id):
+        '''
+        Signal callback executed when a backend is enabled/disabled.
+
+        @param sender: not used, only here to let this function be used as a
+                       callback
+        @param backend_id: the id of the backend to add
+        '''
+        if backend_id in self.backendid_to_iter:
+            style = self.get_style()
+            b_iter = self.backendid_to_iter[backend_id]
+            b_path = self.liststore.get_path(b_iter)
+            backend = self.req.get_backend(backend_id)
+            backend_name = backend.get_human_name()
+            if backend.is_enabled():
+                text = backend_name
+            else:
+                color = str(style.text[gtk.STATE_INSENSITIVE])
+                text = "<span color='%s'>%s</span>" % \
+                           (color, backend_name)
+            self.liststore[b_path][self.COLUMN_TEXT] = text
+
+    def _get_markup_for_tags(self, tag_names):
+        '''Given a list of tags names, generates the pango markup to render that
+        list with the tag colors used in GTG
+
+        @param tag_names: the list of the tags (strings)
+        @return str: the pango markup string
+        '''
+        if GenericBackend.ALLTASKS_TAG in tag_names:
+            tags_txt = ""
+        else:
+            tags_txt = get_colored_tags_markup(self.req, tag_names)
+        return "<small>" + tags_txt + "</small>"
+
+
+    def remove_backend(self, backend_id):
+        ''' Removes a backend from the treeview, and selects the first (to show
+        something in the configuration panel
+
+        @param backend_id: the id of the backend to remove
+        '''
+        if backend_id in self.backendid_to_iter:
+            self.liststore.remove(self.backendid_to_iter[backend_id])
+            del self.backendid_to_iter[backend_id]
+            self.select_backend()
+
+    def _init_liststore(self):
+        '''Creates the liststore'''
+        self.liststore = gtk.ListStore(object, gtk.gdk.Pixbuf, str, str)
+        self.set_model(self.liststore)
+
+    def _init_renderers(self):
+        '''Initializes the cell renderers'''
+        # We hide the columns headers
+        self.set_headers_visible(False)
+        # For the backend icon
+        pixbuf_cell = gtk.CellRendererPixbuf()
+        tvcolumn_pixbuf = gtk.TreeViewColumn('Icon', pixbuf_cell)
+        tvcolumn_pixbuf.add_attribute(pixbuf_cell, 'pixbuf', self.COLUMN_ICON)
+        self.append_column(tvcolumn_pixbuf)
+        # For the backend name
+        text_cell = gtk.CellRendererText()
+        tvcolumn_text = gtk.TreeViewColumn('Name', text_cell)
+        tvcolumn_text.add_attribute(text_cell, 'markup', self.COLUMN_TEXT)
+        self.append_column(tvcolumn_text)
+        text_cell.connect('edited', self.cell_edited_callback)
+        text_cell.set_property('editable', True)
+        # For the backend tags
+        tags_cell = gtk.CellRendererText()
+        tvcolumn_tags = gtk.TreeViewColumn('Tags', tags_cell)
+        tvcolumn_tags.add_attribute(tags_cell, 'markup', self.COLUMN_TAGS)
+        self.append_column(tvcolumn_tags)
+
+    def cell_edited_callback(self, text_cell, path, new_text):
+        '''If a backend name is changed, it saves the changes in the Backend
+
+        @param text_cell: not used. The gtk.CellRendererText that emitted the
+                          signal. Only here because it's passed by the signal
+        @param path: the gtk.TreePath of the edited cell
+        @param new_text: the new name of the backend
+        '''
+        #we strip everything not permitted in backend names
+        new_text = ''.join(c for c in new_text if (c.isalnum() or\
+                                    c in [" ", "-", "_"]))
+        selected_iter = self.liststore.get_iter(path)
+        # update the backend name
+        backend_id = self.liststore.get_value(selected_iter, \
+                                              self.COLUMN_BACKEND_ID)
+        backend = self.dialog.get_requester().get_backend(backend_id)
+        if backend:
+            backend.set_human_name(new_text)
+            # update the text in the liststore
+            self.liststore.set(selected_iter, self.COLUMN_TEXT, new_text)
+
+    def _init_signals(self):
+        '''Initializes the backends and gtk signals '''
+        self.connect("cursor-changed", self.on_select_row)
+        _signals = BackendSignals()
+        _signals.connect(_signals.BACKEND_ADDED, self.on_backend_added)
+        _signals.connect(_signals.BACKEND_STATE_TOGGLED,
+                         self.on_backend_state_changed)
+
+    def on_select_row(self, treeview = None):
+        '''When a row is selected, displays the corresponding editing panel
+
+        @treeview: not used
+        '''
+        self.dialog.on_backend_selected(self.get_selected_backend_id())
+
+    def _get_selected_path(self):
+        '''
+        Helper function to get the selected path
+
+        @return gtk.TreePath : returns exactly one path for the selected object or
+                               None
+        '''
+        selection = self.get_selection()
+        if selection:
+            model, selected_paths = self.get_selection().get_selected_rows()
+            if selected_paths:
+                return selected_paths[0]
+        return None
+
+    def select_backend(self, backend_id = None):
+        '''
+        Selects the backend corresponding to backend_id.
+        If backend_id is none, refreshes the current configuration panel.
+
+        @param backend_id: the id of the backend to select
+        '''
+        selection = self.get_selection()
+        if backend_id in self.backendid_to_iter:
+            backend_iter = self.backendid_to_iter[backend_id]
+            if selection:
+                selection.select_iter(backend_iter)
+        else:
+            if self._get_selected_path():
+                #We just reselect the currently selected entry
+                self.on_select_row()
+            else:
+                #If nothing is selected, we select the first entry
+                if selection:
+                    selection.select_path("0")
+        self.dialog.on_backend_selected(self.get_selected_backend_id())
+
+    def get_selected_backend_id(self):
+        '''
+        returns the selected backend id, or none
+
+        @return string: the selected backend id (or None)
+        '''
+        selected_path = self._get_selected_path()
+        if not selected_path:
+            return None
+        selected_iter = self.liststore.get_iter(selected_path)
+        return self.liststore.get_value(selected_iter, self.COLUMN_BACKEND_ID)
 
=== added file 'GTG/gtk/backends_dialog/configurepanel.py'
--- GTG/gtk/backends_dialog/configurepanel.py	1970-01-01 00:00:00 +0000
+++ GTG/gtk/backends_dialog/configurepanel.py	2010-09-04 17:54:43 +0000
@@ -0,0 +1,304 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Getting Things Gnome! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2009 - Lionel Dricot & Bertrand Rousseau
+#
+# 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
+
+from GTG.gtk.colors                        import get_colored_tags_markup
+from GTG                                   import _, ngettext
+from GTG.backends.genericbackend           import GenericBackend
+from GTG.gtk.backends_dialog.parameters_ui import ParametersUI
+from GTG.backends.backendsignals           import BackendSignals
+
+
+class ConfigurePanel(gtk.VBox):
+    ''' 
+    A VBox that lets you configure a backend
+    '''
+
+
+    def __init__(self, backends_dialog):
+        '''
+        Constructor, creating all the gtk widgets
+
+        @param backends_dialog: a reference to the dialog in which this is
+        loaded
+        '''
+        super(ConfigurePanel, self).__init__()
+        self.dialog = backends_dialog
+        self.should_spinner_be_shown = False
+        self.task_deleted_handle = None
+        self.task_added_handle = None
+        self.req = backends_dialog.get_requester()
+        self._create_widgets()
+        self._connect_signals()
+
+    def _connect_signals(self):
+        ''' Connects the backends generated signals '''
+        _signals = BackendSignals()
+        _signals.connect(_signals.BACKEND_RENAMED, self.refresh_title)
+        _signals.connect(_signals.BACKEND_STATE_TOGGLED, \
+                         self.refresh_sync_status)
+        _signals.connect(_signals.BACKEND_SYNC_STARTED, self.on_sync_started)
+        _signals.connect(_signals.BACKEND_SYNC_ENDED, self.on_sync_ended)
+    
+    def _create_widgets(self):
+        '''
+        This function fills this Vbox with widgets
+        '''
+        #Division of the available space in three segments:
+        # top, middle and bottom
+        top = gtk.HBox()
+        middle = gtk.HBox()
+        self._fill_top_hbox(top)
+        self._fill_middle_hbox(middle)
+        self.pack_start(top, False)
+        self.pack_start(middle, False)
+        align = gtk.Alignment(xalign = 0, yalign = 0, xscale = 1)
+        align.set_padding(10, 0, 0, 0)
+        self.parameters_ui = ParametersUI(self.req)
+        align.add(self.parameters_ui)
+        self.pack_start(align, False)
+
+    def _fill_top_hbox(self, hbox):
+        '''
+        Helper function to fill an hbox with an image, a spinner and 
+        three labels
+
+        @param hbox: the gtk.HBox to fill
+        '''
+        hbox.set_spacing(10)
+        self.image_icon = gtk.Image()
+        self.image_icon.set_size_request(100, 100)
+        vbox = gtk.VBox()
+        hbox_top = gtk.HBox()
+        self.human_name_label = gtk.Label()
+        self.human_name_label.set_alignment(xalign = 0, yalign = 0.5)
+        try:
+            self.spinner = gtk.Spinner()
+        except AttributeError:
+            #worarkound for archlinux: bug #624204
+            self.spinner = gtk.HBox()
+        self.spinner.connect("show", self.on_spinner_show)
+        self.spinner.set_size_request(32, 32)
+        align_spin = gtk.Alignment(xalign = 1, yalign = 0)
+        align_spin.add(self.spinner)
+        hbox_top.pack_start(self.human_name_label, True)
+        hbox_top.pack_start(align_spin, False)
+        self.sync_desc_label = gtk.Label()
+        self.sync_desc_label.set_alignment(xalign = 0, yalign = 1)
+        self.sync_desc_label.set_line_wrap(True)
+        vbox.pack_start(hbox_top, True)
+        vbox.pack_start(self.sync_desc_label, True)
+        hbox.pack_start(self.image_icon, False)
+        align_vbox = gtk.Alignment(xalign = 0, yalign = 0, xscale = 1)
+        align_vbox.set_padding(10, 0, 20, 0)
+        align_vbox.add(vbox)
+        hbox.pack_start(align_vbox, True)
+
+    def _fill_middle_hbox(self, hbox):
+        '''
+        Helper function to fill an hbox with a label and a button
+
+        @param hbox: the gtk.HBox to fill
+        '''
+        self.sync_status_label = gtk.Label()
+        self.sync_status_label.set_alignment(xalign = 0.8, yalign = 0.5)
+        self.sync_button = gtk.Button()
+        self.sync_button.connect("clicked", self.on_sync_button_clicked)
+        hbox.pack_start(self.sync_status_label, True)
+        hbox.pack_start(self.sync_button, True)
+
+    def set_backend(self, backend_id):
+        '''Changes the backend to configure, refreshing this view.
+        
+        @param backend_id: the id of the backend to configure
+        '''
+        self.backend = self.dialog.get_requester().get_backend(backend_id)
+        self.refresh_title()
+        self.refresh_sync_status()
+        self.parameters_ui.refresh(self.backend)
+        self.image_icon.set_from_pixbuf(self.dialog.get_pixbuf_from_icon_name(\
+                                        self.backend.get_name(), 80, 80))
+
+    def refresh_title(self, sender = None, data = None):
+        '''
+        Callback for the signal that notifies backends name changes. It changes
+        the title of this view
+
+        @param sender: not used, here only for signal callback compatibility
+        @param data: not used, here only for signal callback compatibility
+        '''
+        markup = "<big><big><big><b>%s</b></big></big></big>" % \
+                                        self.backend.get_human_name()
+        self.human_name_label.set_markup(markup)
+    
+    def refresh_number_of_tasks(self):
+        '''refreshes the number of synced tasks by this backend'''
+        #FIXME: disabled for now. I'm not sure that this is nice because the
+        # count is correct only after the backend has synced all the pending
+        # tasks, and this is quite misleading (invernizzi)
+        return
+        #This will have to be changed for import/export..
+        tags = self.backend.get_attached_tags()
+        tasks_number = self.backend.get_number_of_tasks()
+        if GenericBackend.ALLTASKS_TAG in tags:
+            if tasks_number == 0:
+                markup = _("Ready to start syncing")
+            else:
+                markup = ngettext("Syncing your only task", \
+                    "Syncing all %d tasks" % tasks_number, tasks_number)
+        else:
+            tags_txt = get_colored_tags_markup(self.req, tags)
+            if tasks_number == 0:
+                markup = _("There's no task tagged %s") % tags_txt
+            else:
+                markup = ngettext("Syncing a task tagged %s" % tags_txt, \
+                    "Syncing %d tasks tagged %s" % (tasks_number, tags_txt), \
+                              tasks_number) 
+        self.sync_desc_label.set_markup(markup)
+
+    def refresh_sync_button(self):
+        '''
+        Refreshes the state of the button that enables the backend
+        '''
+        self.sync_button.set_sensitive(not self.backend.is_default())
+        if self.backend.is_enabled():
+            label = _("Disable syncing")
+        else:
+            label = _("Enable syncing")
+        self.sync_button.set_label(label)
+
+    def refresh_sync_status_label(self):
+        '''
+        Refreshes the gtk.Label that shows the current state of this backend
+        '''
+        if self.backend.is_default():
+            label = _("This is the default backend")
+        else:
+            if self.backend.is_enabled():
+                label = _("Syncing is enabled")
+            else:
+                label = _('Syncing is <span color="red">disabled</span>')
+        self.sync_status_label.set_markup(label)
+
+    def refresh_sync_status(self, sender = False, data = False):
+        '''Signal callback function, called when a backend state
+        (enabled/disabled) changes. Refreshes this view.
+
+        @param sender: not used, here only for signal callback compatibility
+        @param data: not used, here only for signal callback compatibility
+        '''
+        self.refresh_number_of_tasks()
+        self.refresh_sync_button()
+        self.refresh_sync_status_label()
+    
+    def set_hidden(self, is_hidden):
+        '''
+        Notifies this pane if it's hidden or not. We disconnect signals when
+        hidden, since there is no need to keep the UI updated.
+        Hopefully, this should make GTG faster :)
+
+        @param is_hidden: boolean, True if the window is not visible
+        '''
+        #These is only needed to refresh the number of synced tasks.
+        #since that is disabled for now, there is no need for this
+
+#        if is_hidden:
+#            if self.task_added_handle:
+#                self.req.disconnect(self.task_added_handle)
+#                self.task_added_handle = None
+#            if self.task_deleted_handle:
+#                self.req.disconnect(self.task_deleted_handle)
+#                self.task_deleted_handle = None
+#        else:
+#            self.task_added_handle = self.req.connect("task-added", \
+#                                            self.__on_task_changed)
+#            self.task_added_handle = self.req.connect("task-modified", \
+#                                            self.__on_task_changed)
+#            self.task_deleted_handle = self.req.connect("task-deleted",  \
+#                                            self.__on_task_changed)
+#
+#    def __on_task_changed(self, sender, task_id):
+#        '''
+#        If tasks are added, modified or removed, updates the number of
+#        tasks of the current backend
+#        '''
+#        self.refresh_sync_status()
+
+    def on_sync_button_clicked(self, sender):
+        '''
+        Signal callback when a backend is enabled/disabled via the UI button
+
+        @param sender: not used, here only for signal callback compatibility
+        '''
+        self.parameters_ui.commit_changes()
+        self.req.set_backend_enabled(self.backend.get_id(), \
+                                     not self.backend.is_enabled())
+
+    def on_sync_started(self, sender, backend_id):
+        '''
+        If the backend has started syncing tasks, update the state of the
+        gtk.Spinner
+
+        @param sender: not used, here only for signal callback compatibility
+        @param backend_id: the id of the backend that emitted this signal
+        '''
+        if backend_id == self.backend.get_id():
+            self.spinner_set_active(True)
+
+    def on_sync_ended(self, sender, backend_id):
+        '''
+        If the backend has stopped syncing tasks, update the state of the
+        gtk.Spinner
+
+        @param sender: not used, here only for signal callback compatibility
+        @param backend_id: the id of the backend that emitted this signal
+        '''
+
+        if backend_id == self.backend.get_id():
+            self.spinner_set_active(False)
+
+    def on_spinner_show(self, sender):
+        '''This signal callback hides the spinner if it's not supposed to be
+        seen. It's a workaround to let us call show_all on the whole window
+        while keeping this hidden (it's the only widget that requires special
+        attention)
+
+        @param sender: not used, here only for signal callback compatibility
+        '''
+        if self.should_spinner_be_shown == False:
+            self.spinner.hide()
+
+    def spinner_set_active(self, active):
+        '''
+        Enables/disables the gtk.Spinner, while showing/hiding it at the same
+        time
+        
+        @param active: True if the spinner should spin
+        '''
+        self.should_spinner_be_shown = active
+        if active:
+            if isinstance(self.spinner, gtk.Spinner):
+                self.spinner.start()
+            self.spinner.show()
+        else:
+            self.spinner.hide()
+            if isinstance(self.spinner, gtk.Spinner):
+                self.spinner.stop()
+
 
=== added directory 'GTG/gtk/backends_dialog/parameters_ui'
=== added file 'GTG/gtk/backends_dialog/parameters_ui/__init__.py'
--- GTG/gtk/backends_dialog/parameters_ui/__init__.py	1970-01-01 00:00:00 +0000
+++ GTG/gtk/backends_dialog/parameters_ui/__init__.py	2010-09-04 17:54:43 +0000
@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Getting Things Gnome! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2009 - Lionel Dricot & Bertrand Rousseau
+#
+# 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/>.
+# -----------------------------------------------------------------------------
+'''
+This modules reads a bakcn configuration and generates a series of widgets to
+let the user see the configuration and modify it.
+In this manner, backends do not need to know anything about their UI since it's
+built for them: it should play along the lines of the separation between GTG
+server and client
+'''
+
+import gtk
+import functools
+
+from GTG import _
+from GTG.backends.genericbackend                        import GenericBackend
+from GTG.gtk.backends_dialog.parameters_ui.importtagsui import ImportTagsUI
+from GTG.gtk.backends_dialog.parameters_ui.textui       import TextUI
+from GTG.gtk.backends_dialog.parameters_ui.passwordui   import PasswordUI
+from GTG.gtk.backends_dialog.parameters_ui.periodui     import PeriodUI
+from GTG.gtk.backends_dialog.parameters_ui.checkboxui   import CheckBoxUI
+from GTG.gtk.backends_dialog.parameters_ui.pathui       import PathUI
+
+
+
+class ParametersUI(gtk.VBox):
+    '''
+    Given a bakcend, this gtk.VBox populates itself with all the necessary
+    widgets to view and edit a backend configuration
+    '''
+
+
+    COMMON_WIDTH = 170
+
+    def __init__(self, requester):
+        '''Constructs the list of the possible widgets.
+
+        @param requester: a GTG.core.requester.Requester object
+        '''
+        super(ParametersUI, self).__init__(False)
+        self.req = requester
+        self.set_spacing(10)
+
+        #builds a list of widget generators. More precisely, it's a
+        # list of tuples: (backend_parameter_name, widget_generator)
+        self.parameter_widgets = ( \
+               ("import-tags", self.UI_generator(ImportTagsUI, \
+                            {"title": _("Import tags"), \
+                             "anybox_text": _("All tags"), \
+                             "somebox_text": _("Just these tags"), \
+                             "parameter_name": "import-tags"}) \
+               ),\
+               ("attached-tags", self.UI_generator(ImportTagsUI, \
+                            {"title": _("Tags to sync"), \
+                             "anybox_text": _("All tasks"), \
+                             "somebox_text": _("Tasks with these tags"), \
+                             "parameter_name": "attached-tags"}) \
+               ),\
+               ("path", self.UI_generator(PathUI)), \
+               ("username", self.UI_generator(TextUI, \
+                            {"description": _("Username"),
+                             "parameter_name": "username"})
+               ), \
+               ("password"     , self.UI_generator(PasswordUI)), \
+               ("period"       , self.UI_generator(PeriodUI)), \
+               ("import-from-replies", self.UI_generator(CheckBoxUI, \
+                            {"text": _("Import tasks from @ replies " + \
+                                                         "directed to you"), \
+                             "parameter": "import-from-replies"}) \
+               ),\
+               ("import-from-direct-messages", self.UI_generator(CheckBoxUI,  \
+                            {"text": _("Import tasks from direct messages"), \
+                             "parameter": "import-from-direct-messages"}) \
+               ),\
+               ("import-from-my-tweets", self.UI_generator(CheckBoxUI, \
+                            {"text": _("Import tasks from your tweets"), \
+                             "parameter": "import-from-my-tweets"}) \
+               ),\
+               ("import-bug-tags", self.UI_generator(CheckBoxUI, \
+                            {"text": _("Tag your GTG tasks with the bug tags"), \
+                             "parameter": "import-bug-tags"}) \
+               ),\
+               ("tag-with-project-name", self.UI_generator(CheckBoxUI, \
+                            {"text": _("Tag your GTG tasks with the project "
+                                       "targeted by the bug"), \
+                             "parameter": "tag-with-project-name"}) \
+               ),\
+            ) 
+    def UI_generator(self, param_type, special_arguments = {}):
+        '''A helper function to build a widget type from a template.
+        It passes to the created widget generator a series of common parameters,
+        plus the ones needed to specialize the given template
+
+        @param param_type: the template to specialize
+        @param special_arguments: the arguments used for this particular widget
+                                  generator.
+
+        @return function: return a widget generator, not a widget. the widget can
+                          be obtained by calling widget_generator(backend)
+        '''
+        return lambda backend: param_type(req = self.req, \
+                                          backend = backend, \
+                                          width = self.COMMON_WIDTH, \
+                                          **special_arguments)
+
+    def refresh(self, backend):
+        '''Builds the widgets necessary to configure the backend. If it doesn't
+        know how to render a widget, it simply skips it.
+
+        @param backend: the backend that is being configured
+        '''
+        #remove the old parameters UIs
+        def _remove_child(self, child):
+            self.remove(child)
+        self.foreach(functools.partial(_remove_child, self))
+        #add new widgets
+        backend_parameters = backend.get_parameters()
+        if backend_parameters[GenericBackend.KEY_DEFAULT_BACKEND]:
+            #if it's the default backend, the user should not mess with it
+            return
+        for parameter_name, widget in self.parameter_widgets:
+            if parameter_name in backend_parameters:
+                self.pack_start(widget(backend), True)
+        self.show_all()
+
+    def commit_changes(self):
+        '''
+        Saves all the parameters at their current state (the user may have
+        modified them)
+        '''
+        def _commit_changes(child):
+            child.commit_changes()
+        self.foreach(_commit_changes)
+
 
=== added file 'GTG/gtk/backends_dialog/parameters_ui/checkboxui.py'
--- GTG/gtk/backends_dialog/parameters_ui/checkboxui.py	1970-01-01 00:00:00 +0000
+++ GTG/gtk/backends_dialog/parameters_ui/checkboxui.py	2010-09-04 17:54:43 +0000
@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Getting Things Gnome! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2009 - Lionel Dricot & Bertrand Rousseau
+#
+# 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
+
+
+
+class CheckBoxUI(gtk.HBox):
+    '''
+    It's a widget displaying a simple checkbox, with some text to explain its
+    meaning
+    '''
+    
+
+    def __init__(self, req, backend, width, text, parameter):
+        '''
+        Creates the checkbox and the related label.
+
+        @param req: a Requester
+        @param backend: a backend object
+        @param width: the width of the gtk.Label object
+        @param parameter: the backend parameter this checkbox should display and
+                           modify
+        '''
+        super(CheckBoxUI, self).__init__()
+        self.backend = backend
+        self.req = req
+        self.text = text
+        self.parameter = parameter
+        self._populate_gtk(width)
+
+    def _populate_gtk(self, width):
+        '''Creates the checkbox and the related label
+        
+        @param width: the width of the gtk.Label object
+        '''
+        self.checkbutton =gtk.CheckButton(label = self.text)
+        self.checkbutton.set_active(self.backend.get_parameters()[self.parameter])
+        self.checkbutton.connect("toggled", self.on_modified)
+        self.pack_start(self.checkbutton, False)
+
+    def commit_changes(self):
+        '''Saves the changes to the backend parameter'''
+        self.backend.set_parameter(self.parameter,\
+                        self.checkbutton.get_active())
+
+    def on_modified(self, sender = None):
+        ''' Signal callback, executed when the user clicks on the checkbox.
+        Disables the backend. The user will re-enable it to confirm the changes
+        (s)he made.
+
+        @param sender: not used, only here for signal compatibility
+        '''
+        if self.backend.is_enabled() and not self.backend.is_default():
+            self.req.set_backend_enabled(self.backend.get_id(), False)
+
 
=== added file 'GTG/gtk/backends_dialog/parameters_ui/importtagsui.py'
--- GTG/gtk/backends_dialog/parameters_ui/importtagsui.py	1970-01-01 00:00:00 +0000
+++ GTG/gtk/backends_dialog/parameters_ui/importtagsui.py	2010-09-04 17:54:43 +0000
@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Getting Things Gnome! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2009 - Lionel Dricot & Bertrand Rousseau
+#
+# 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
+
+from GTG.backends.genericbackend import GenericBackend
+
+
+
+class ImportTagsUI(gtk.VBox):
+    '''
+    It's a widget displaying a couple of radio buttons, a label and a textbox
+    to let the user change the attached tags (or imported)
+    '''
+    
+
+    def __init__(self, req, backend, width, title, anybox_text, somebox_text, \
+                 parameter_name):
+        '''Populates the widgets and refresh the tags to display
+
+        @param req: a requester
+        @param backend: the backend to configure
+        @param width: the length of the radio buttons
+        @param title: the text for the label describing what this collection
+                      of gtk widgets is used for
+        @param anybox_text: the text for the "Any tag matches" radio button
+        @param somebox_text: the text for the "only this set of tags matches"
+                             radio button
+        @param parameter_name: the backend parameter this widget should modify
+        '''
+        super(ImportTagsUI, self).__init__()
+        self.backend = backend
+        self.req = req
+        self.title = title
+        self.anybox_text = anybox_text
+        self.somebox_text = somebox_text
+        self.parameter_name = parameter_name
+        self._populate_gtk(width)
+        self._refresh_tags()
+        self._connect_signals()
+
+    def _populate_gtk(self, width):
+        '''
+        Populates the widgets
+
+        @param width: the length of the radio buttons
+        '''
+        title_label = gtk.Label()
+        title_label.set_alignment(xalign = 0, yalign = 0)
+        title_label.set_markup("<big><b>%s</b></big>" % self.title)
+        self.pack_start(title_label, True)
+        align = gtk.Alignment(xalign = 0, yalign = 0, xscale = 1)
+        align.set_padding(0, 0, 10, 0)
+        self.pack_start(align, True)
+        vbox = gtk.VBox()
+        align.add(vbox)
+        self.all_tags_radio = gtk.RadioButton(group = None, \
+                                              label = self.anybox_text)
+        vbox.pack_start(self.all_tags_radio, True)
+        self.some_tags_radio = gtk.RadioButton(group = self.all_tags_radio,
+                                               label = self.somebox_text)
+        self.some_tags_radio.set_size_request(width = width, height = -1)
+        hbox = gtk.HBox()
+        vbox.pack_start(hbox, True)
+        hbox.pack_start(self.some_tags_radio, False)
+        self.tags_entry = gtk.Entry()
+        hbox.pack_start(self.tags_entry, True)
+
+    def on_changed(self, radio, data = None):
+        ''' Signal callback, executed when the user modifies something.
+        Disables the backend. The user will re-enable it to confirm the changes
+        (s)he made.
+
+        @param sender: not used, only here for signal compatibility
+        @param data: not used, only here for signal compatibility
+        '''
+        #every change in the config disables the backend
+        self.req.set_backend_enabled(self.backend.get_id(), False)
+        self._refresh_textbox_state()
+
+    def commit_changes(self):
+        '''Saves the changes to the backend parameter'''
+        if self.all_tags_radio.get_active():
+            tags = [GenericBackend.ALLTASKS_TAG]
+        else:
+            tags = self.tags_entry.get_text().split(",")
+            #stripping spaces
+            tags = map(lambda t: t.strip(), tags)
+            #removing empty tags
+            tags = filter(lambda t: t, tags)
+
+        self.backend.set_parameter(self.parameter_name, tags)
+
+    def _refresh_textbox_state(self):
+        '''Refreshes the content of the textbox'''
+        self.tags_entry.set_sensitive(self.some_tags_radio.get_active())
+
+    def _refresh_tags(self):
+        '''
+        Refreshes the list of tags to display in the textbox, and selects
+        the correct radio button
+        '''
+        tags_list = self.backend.get_parameters()[self.parameter_name]
+        has_all_tasks = GenericBackend.ALLTASKS_TAG in tags_list
+        self.all_tags_radio.set_active(has_all_tasks)
+        self.some_tags_radio.set_active(not has_all_tasks)
+        self._refresh_textbox_state()
+        if not has_all_tasks:
+            tags_text = ""
+            if tags_list:
+                tags_text = reduce(lambda a, b: a + ", " + b, tags_list)
+            self.tags_entry.set_text(tags_text)
+
+    def _connect_signals(self):
+        '''Connects the gtk signals'''
+        self.some_tags_radio.connect("toggled", self.on_changed)
+        self.all_tags_radio.connect("toggled", self.on_changed)
+        self.tags_entry.connect("changed", self.on_changed)
+
 
=== added file 'GTG/gtk/backends_dialog/parameters_ui/passwordui.py'
--- GTG/gtk/backends_dialog/parameters_ui/passwordui.py	1970-01-01 00:00:00 +0000
+++ GTG/gtk/backends_dialog/parameters_ui/passwordui.py	2010-09-04 17:54:43 +0000
@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Getting Things Gnome! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2009 - Lionel Dricot & Bertrand Rousseau
+#
+# 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
+
+from GTG import _
+
+
+
+class PasswordUI(gtk.HBox):
+    '''Widget displaying a gtk.Label and a textbox to input a password'''
+    
+
+    def __init__(self, req, backend, width):
+        '''Creates the gtk widgets and loads the current password in the text
+        field
+
+        @param req: a Requester
+        @param backend: a backend object
+        @param width: the width of the gtk.Label object
+        '''
+        super(PasswordUI, self).__init__()
+        self.backend = backend
+        self.req = req
+        self._populate_gtk(width)
+        self._load_password()
+        self._connect_signals()
+
+    def _populate_gtk(self, width):
+        '''Creates the text box and the related label
+        
+        @param width: the width of the gtk.Label object
+        '''
+        password_label = gtk.Label(_("Password:"))
+        password_label.set_alignment(xalign = 0, yalign = 0.5)
+        password_label.set_size_request(width = width, height = -1)
+        self.pack_start(password_label, False)
+        align = gtk.Alignment(xalign = 0, yalign = 0.5, xscale = 1)
+        align.set_padding(0, 0, 10, 0)
+        self.pack_start(align, True)
+        self.password_textbox = gtk.Entry()
+        align.add(self.password_textbox)
+
+    def _load_password(self):
+        '''Loads the password from the backend'''
+        password = self.backend.get_parameters()['password']
+        self.password_textbox.set_invisible_char('*')
+        self.password_textbox.set_visibility(False)
+        self.password_textbox.set_text(password)
+
+    def _connect_signals(self):
+        '''Connects the gtk signals'''
+        self.password_textbox.connect('changed', self.on_password_modified)
+
+    def commit_changes(self):
+        '''Saves the changes to the backend parameter ('password')'''
+        self.backend.set_parameter('password', self.password_textbox.get_text())
+
+    def on_password_modified(self, sender):
+        ''' Signal callback, executed when the user edits the password.
+        Disables the backend. The user will re-enable it to confirm the changes
+        (s)he made.
+
+        @param sender: not used, only here for signal compatibility
+        '''
+        if self.backend.is_enabled() and not self.backend.is_default():
+            self.req.set_backend_enabled(self.backend.get_id(), False)
+
 
=== added file 'GTG/gtk/backends_dialog/parameters_ui/pathui.py'
--- GTG/gtk/backends_dialog/parameters_ui/pathui.py	1970-01-01 00:00:00 +0000
+++ GTG/gtk/backends_dialog/parameters_ui/pathui.py	2010-09-04 17:54:43 +0000
@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Getting Things Gnome! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2009 - Lionel Dricot & Bertrand Rousseau
+#
+# 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 os.path
+
+from GTG import _
+
+
+
+
+class PathUI(gtk.HBox):
+    '''Gtk widgets to show a path in a textbox, and a button to bring up a
+    filesystem explorer to modify that path (also, a label to describe those)
+    '''
+    
+
+    def __init__(self, req, backend, width):
+        '''
+        Creates the textbox, the button and loads the current path.
+
+        @param req: a Requester
+        @param backend: a backend object
+        @param width: the width of the gtk.Label object
+        '''
+        super(PathUI, self).__init__()
+        self.backend = backend
+        self.req = req
+        self._populate_gtk(width)
+
+    def _populate_gtk(self, width):
+        '''Creates the gtk.Label, the textbox and the button
+        
+        @param width: the width of the gtk.Label object
+        '''
+        label = gtk.Label(_("Filename:"))
+        label.set_line_wrap(True)
+        label.set_alignment(xalign = 0, yalign = 0.5)
+        label.set_size_request(width = width, height = -1)
+        self.pack_start(label, False)
+        align = gtk.Alignment(xalign = 0, yalign = 0.5, xscale = 1)
+        align.set_padding(0, 0, 10, 0)
+        self.pack_start(align, True)
+        self.textbox = gtk.Entry()
+        self.textbox.set_text(self.backend.get_parameters()['path'])
+        self.textbox.connect('changed', self.on_path_modified)
+        align.add(self.textbox)
+        self.button = gtk.Button(stock = gtk.STOCK_EDIT)
+        self.button.connect('clicked', self.on_button_clicked)
+        self.pack_start(self.button, False)
+
+    def commit_changes(self):
+        '''Saves the changes to the backend parameter'''
+        self.backend.set_parameter('path', self.textbox.get_text())
+
+    def on_path_modified(self, sender):
+        ''' Signal callback, executed when the user edits the path.
+        Disables the backend. The user will re-enable it to confirm the changes
+        (s)he made.
+
+        @param sender: not used, only here for signal compatibility
+        '''
+        if self.backend.is_enabled() and not self.backend.is_default():
+            self.req.set_backend_enabled(self.backend.get_id(), False)
+    
+    def on_button_clicked(self, sender):
+        '''Shows the filesystem explorer to choose a new file
+
+        @param sender: not used, only here for signal compatibility
+        '''
+        self.chooser = gtk.FileChooserDialog( \
+                    title=None,
+                    action=gtk.FILE_CHOOSER_ACTION_SAVE,
+                    buttons=(gtk.STOCK_CANCEL,
+                             gtk.RESPONSE_CANCEL, \
+                             gtk.STOCK_OK, \
+                             gtk.RESPONSE_OK))
+        self.chooser.set_default_response(gtk.RESPONSE_OK)
+        #set default file as the current self.path
+        self.chooser.set_current_name(os.path.basename(self.textbox.get_text()))
+        self.chooser.set_current_folder(os.path.dirname(self.textbox.get_text()))
+        
+        #filter files
+        afilter = gtk.FileFilter()
+        afilter.set_name("All files")
+        afilter.add_pattern("*")
+        self.chooser.add_filter(afilter)
+        afilter = gtk.FileFilter()
+        afilter.set_name("XML files")
+        afilter.add_mime_type("text/plain")
+        afilter.add_pattern("*.xml")
+        self.chooser.add_filter(afilter)
+        response = self.chooser.run()
+        if response == gtk.RESPONSE_OK:
+            self.textbox.set_text(self.chooser.get_filename())
+        self.chooser.destroy()
 
=== added file 'GTG/gtk/backends_dialog/parameters_ui/periodui.py'
--- GTG/gtk/backends_dialog/parameters_ui/periodui.py	1970-01-01 00:00:00 +0000
+++ GTG/gtk/backends_dialog/parameters_ui/periodui.py	2010-09-04 17:54:43 +0000
@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Getting Things Gnome! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2009 - Lionel Dricot & Bertrand Rousseau
+#
+# 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
+
+from GTG import _, ngettext
+
+
+
+class PeriodUI(gtk.HBox):
+    '''A widget to change the frequency of a backend synchronization
+    '''
+    
+
+    def __init__(self, req, backend, width):
+        '''
+        Creates the gtk.Adjustment and the related label. Loads the current
+        period.
+
+        @param req: a Requester
+        @param backend: a backend object
+        @param width: the width of the gtk.Label object
+        '''
+        super(PeriodUI, self).__init__()
+        self.backend = backend
+        self.req = req
+        self._populate_gtk(width)
+        self._connect_signals()
+
+    def _populate_gtk(self, width):
+        '''Creates the gtk widgets
+        
+        @param width: the width of the gtk.Label object
+        '''
+        period_label = gtk.Label(_("Check for new tasks every"))
+        period_label.set_alignment(xalign = 0, yalign = 0.5)
+        period_label.set_line_wrap(True)
+        period_label.set_size_request(width = width, height = -1)
+        self.pack_start(period_label, False)
+        align = gtk.Alignment(xalign = 0, yalign = 0.5, xscale = 1)
+        align.set_padding(0, 0, 10, 0)
+        self.pack_start(align, False)
+        period = self.backend.get_parameters()['period']
+        self.adjustment = gtk.Adjustment(value = period,
+                                         lower = 1,
+                                         upper = 120,
+                                         step_incr = 1,
+                                         page_incr = 0,
+                                         page_size = 0)
+        self.period_spin = gtk.SpinButton(adjustment = self.adjustment,
+                                          climb_rate = 0.3,
+                                          digits = 0)
+        self.minutes_label = gtk.Label()
+        self.update_minutes_label()
+        self.minutes_label.set_alignment(xalign = 0, yalign = 0.5)
+        self.pack_start(self.minutes_label, False)
+        align.add(self.period_spin)
+        self.show_all()
+
+    def _connect_signals(self):
+        '''Connects the gtk signals'''
+        self.period_spin.connect('changed', self.on_spin_changed)
+
+    def commit_changes(self):
+        '''Saves the changes to the backend parameter'''
+        self.backend.set_parameter('period', int(self.adjustment.get_value()))
+
+    def on_spin_changed(self, sender):
+        ''' Signal callback, executed when the user changes the period.
+        Disables the backend. The user will re-enable it to confirm the changes
+        (s)he made.
+
+        @param sender: not used, only here for signal compatibility
+        '''
+        self.update_minutes_label()
+        if self.backend.is_enabled() and not self.backend.is_default():
+            self.req.set_backend_enabled(self.backend.get_id(), False)
+
+    def update_minutes_label(self):
+        self.minutes_label.set_markup(ngettext(" minute", " minutes",
+                                           int(self.adjustment.get_value())))
 
=== added file 'GTG/gtk/backends_dialog/parameters_ui/textui.py'
--- GTG/gtk/backends_dialog/parameters_ui/textui.py	1970-01-01 00:00:00 +0000
+++ GTG/gtk/backends_dialog/parameters_ui/textui.py	2010-09-04 17:54:43 +0000
@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Getting Things Gnome! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2009 - Lionel Dricot & Bertrand Rousseau
+#
+# 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
+
+
+
+class TextUI(gtk.HBox):
+    '''A widget to display a simple textbox and a label to describe its content
+    '''
+    
+
+    def __init__(self, req, backend, width, description, parameter_name):
+        '''
+        Creates the textbox and the related label. Loads the current
+        content.
+
+        @param req: a Requester
+        @param backend: a backend object
+        @param width: the width of the gtk.Label object
+        '''
+        super(TextUI, self).__init__()
+        self.backend = backend
+        self.req = req
+        self.parameter_name = parameter_name
+        self.description = description
+        self._populate_gtk(width)
+
+    def _populate_gtk(self, width):
+        '''Creates the gtk widgets
+        
+        @param width: the width of the gtk.Label object
+        '''
+        label = gtk.Label("%s:" % self.description)
+        label.set_line_wrap(True)
+        label.set_alignment(xalign = 0, yalign = 0.5)
+        label.set_size_request(width = width, height = -1)
+        self.pack_start(label, False)
+        align = gtk.Alignment(xalign = 0, yalign = 0.5, xscale = 1)
+        align.set_padding(0, 0, 10, 0)
+        self.pack_start(align, True)
+        self.textbox = gtk.Entry()
+        self.textbox.set_text(\
+                        self.backend.get_parameters()[self.parameter_name])
+        self.textbox.connect('changed', self.on_text_modified)
+        align.add(self.textbox)
+
+    def commit_changes(self):
+        '''Saves the changes to the backend parameter'''
+        self.backend.set_parameter(self.parameter_name,\
+                        self.textbox.get_text())
+
+    def on_text_modified(self, sender):
+        ''' Signal callback, executed when the user changes the text.
+        Disables the backend. The user will re-enable it to confirm the changes
+        (s)he made.
+
+        @param sender: not used, only here for signal compatibility
+        '''
+        if self.backend.is_enabled() and not self.backend.is_default():
+            self.req.set_backend_enabled(self.backend.get_id(), False)
+
 
=== modified file 'GTG/gtk/browser/browser.py'
--- GTG/gtk/browser/browser.py	2010-08-23 01:33:43 +0000
+++ GTG/gtk/browser/browser.py	2010-09-04 17:54:43 +0000
@@ -34,7 +34,9 @@
 
 #our own imports
 import GTG
-from GTG.core                    import CoreConfig
+from GTG.backends.backendsignals import BackendSignals
+from GTG.gtk.browser.custominfobar import CustomInfoBar
+from GTG.core                       import CoreConfig
 from GTG                         import _, info, ngettext
 from GTG.core.task               import Task
 from GTG.gtk.browser             import GnomeConfig, tasktree, tagtree
@@ -207,6 +209,7 @@
         self.sidebar_notebook   = self.builder.get_object("sidebar_notebook")
         self.main_notebook      = self.builder.get_object("main_notebook")
         self.accessory_notebook = self.builder.get_object("accessory_notebook")
+        self.vbox_toolbars      = self.builder.get_object("vbox_toolbars")
         
         self.closed_pane        = None
 
@@ -314,6 +317,8 @@
                 self.on_nonworkviewtag_toggled,
             "on_preferences_activate":
                 self.open_preferences,
+            "on_edit_backends_activate":
+                self.open_edit_backends,
         }
         self.builder.connect_signals(SIGNAL_CONNECTIONS_DIC)
 
@@ -347,6 +352,16 @@
         # Connect requester signals to TreeModels
         self.req.connect("task-added", self.on_task_added) 
         self.req.connect("task-deleted", self.on_task_deleted)
+        #this causes changed be shouwn only on save
+        #tree = self.task_tree_model.get_tree()
+        #tree.connect("task-added-inview", self.on_task_added) 
+        #tree.connect("task-deleted-inview", self.on_task_deleted)
+        b_signals = BackendSignals()
+        b_signals.connect(b_signals.BACKEND_FAILED, self.on_backend_failed)
+        b_signals.connect(b_signals.BACKEND_STATE_TOGGLED, \
+                          self.remove_backend_infobar)
+        b_signals.connect(b_signals.INTERACTION_REQUESTED, \
+                          self.on_backend_needing_interaction)
         
         # Connect signals from models
         self.task_modelsort.connect("row-has-child-toggled",\
@@ -426,9 +441,12 @@
 
 ### HELPER FUNCTIONS ########################################################
 
-    def open_preferences(self,widget):
+    def open_preferences(self, widget):
         self.vmanager.open_preferences(self.priv)
         
+    def open_edit_backends(self, widget):
+        self.vmanager.open_edit_backends()
+
     def quit(self,widget=None):
         self.vmanager.close_browser()
         
@@ -523,7 +541,7 @@
                     col_id,\
                     self.priv["tasklist"]["sort_order"])
             except:
-                print "Invalid configuration for sorting columns"
+                Log.error("Invalid configuration for sorting columns")
 
         if "view" in self.config["browser"]:
             view = self.config["browser"]["view"]
@@ -1513,3 +1531,82 @@
         """ Returns true if window is the currently active window """
         return self.window.get_property("is-active")
 
+## BACKENDS RELATED METHODS ##################################################
+
+    def on_backend_failed(self, sender, backend_id, error_code):
+        '''
+        Signal callback.
+        When a backend fails to work, loads a gtk.Infobar to alert the user
+
+        @param sender: not used, only here for signal compatibility
+        @param backend_id: the id of the failing backend 
+        @param error_code: a backend error code, as specified in BackendsSignals
+        '''
+        infobar = self._new_infobar(backend_id)
+        infobar.set_error_code(error_code)
+
+    def on_backend_needing_interaction(self, sender, backend_id, description, \
+                                       interaction_type, callback):
+        '''
+        Signal callback.
+        When a backend needs some kind of feedback from the user,
+        loads a gtk.Infobar to alert the user.
+        This is used, for example, to request confirmation after authenticating
+        via OAuth.
+
+        @param sender: not used, only here for signal compatibility
+        @param backend_id: the id of the failing backend 
+        @param description: a string describing the interaction needed
+        @param interaction_type: a string describing the type of interaction
+                                 (yes/no, only confirm, ok/cancel...)
+        @param callback: the function to call when the user provides the
+                         feedback
+        '''
+        infobar = self._new_infobar(backend_id)
+        infobar.set_interaction_request(description, interaction_type, callback)
+
+
+    def __remove_backend_infobar(self, child, backend_id):
+        '''
+        Helper function to remove an gtk.Infobar related to a backend
+
+        @param child: a gtk.Infobar
+        @param backend_id: the id of the backend which gtk.Infobar should be
+                            removed.
+        '''
+        if isinstance(child, CustomInfoBar) and\
+            child.get_backend_id() == backend_id:
+            if self.vbox_toolbars:
+                self.vbox_toolbars.remove(child)
+
+    def remove_backend_infobar(self, sender, backend_id):
+        '''
+        Signal callback.
+        Deletes the gtk.Infobars related to a backend
+
+        @param sender: not used, only here for signal compatibility
+        @param backend_id: the id of the backend which gtk.Infobar should be
+                            removed.
+        '''
+        backend = self.req.get_backend(backend_id)
+        if not backend or (backend and backend.is_enabled()):
+            #remove old infobar related to backend_id, if any
+            if self.vbox_toolbars:
+                self.vbox_toolbars.foreach(self.__remove_backend_infobar, \
+                                       backend_id)
+
+    def _new_infobar(self, backend_id):
+        '''
+        Helper function to create a new infobar for a backend
+        
+        @param backend_id: the backend for which we're creating the infobar
+        @returns gtk.Infobar: the created infobar
+        '''
+        #remove old infobar related to backend_id, if any
+        if not self.vbox_toolbars:
+            return
+        self.vbox_toolbars.foreach(self.__remove_backend_infobar, backend_id)
+        #add a new one
+        infobar = CustomInfoBar(self.req, self, self.vmanager, backend_id)
+        self.vbox_toolbars.pack_start(infobar, True)
+        return infobar
 
=== added file 'GTG/gtk/browser/custominfobar.py'
--- GTG/gtk/browser/custominfobar.py	1970-01-01 00:00:00 +0000
+++ GTG/gtk/browser/custominfobar.py	2010-09-04 17:54:43 +0000
@@ -0,0 +1,210 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Getting Things Gnome! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2009 - Lionel Dricot & Bertrand Rousseau
+#
+# 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 threading
+
+from GTG                         import _
+from GTG.backends.backendsignals import BackendSignals
+from GTG.tools.networkmanager    import is_connection_up
+
+
+
+class CustomInfoBar(gtk.InfoBar):
+    '''
+    A gtk.InfoBar specialized for displaying errors and requests for
+    interaction coming from the backends
+    '''
+
+
+    AUTHENTICATION_MESSAGE = _("The <b>%s</b> backend cannot login with the "
+                               "supplied authentication data and has been"
+                               " disabled. To retry the login, re-enable the backend.")
+
+    NETWORK_MESSAGE = _("Due to a network problem, I cannot contact "
+                        "the <b>%s</b> backend.")
+
+    DBUS_MESSAGE = _("Cannot connect to DBUS, I've disabled "
+                        "the <b>%s</b> backend.")
+
+    def __init__(self, req, browser, vmanager, backend_id):
+        '''
+        Constructor, Prepares the infobar.
+
+        @param req: a Requester object
+        @param browser: a TaskBrowser object
+        @param vmanager: a ViewManager object
+        @param backend_id: the id of the backend linked to the infobar
+        '''
+        super(CustomInfoBar, self).__init__()
+        self.req = req
+        self.browser = browser
+        self.vmanager = vmanager
+        self.backend_id = backend_id
+        self.backend = self.req.get_backend(backend_id)
+
+    def get_backend_id(self):
+        '''
+        Getter function to return the id of the backend for which this
+        gtk.InfoBar was created
+        '''
+        return self.backend_id
+
+    def _populate(self):
+        '''Setting up gtk widgets'''
+        content_hbox = self.get_content_area()
+        content_hbox.set_homogeneous(False)
+        self.label = gtk.Label()
+        self.label.set_line_wrap(True)
+        self.label.set_alignment(0.5, 0.5)
+        self.label.set_justify(gtk.JUSTIFY_FILL)
+        content_hbox.pack_start(self.label, True, True)
+
+    def _on_error_response(self, widget, event):
+        '''
+        Signal callback executed when the user acknowledges the error displayed
+        in the infobar
+
+        @param widget: not used, here for compatibility with signals callbacks
+        @param event: the code of the gtk response
+        '''
+        self.hide()
+        if event == gtk.RESPONSE_ACCEPT:
+            self.vmanager.configure_backend(backend_id = self.backend_id)
+
+    def set_error_code(self, error_code):
+        '''
+        Sets this infobar to show an error to the user
+
+        @param error_code: the code of the error to show. Error codes are listed
+                           in BackendSignals
+        '''
+        self._populate()
+        self.connect("response", self._on_error_response)
+        backend_name = self.backend.get_human_name()
+
+        if error_code == BackendSignals.ERRNO_AUTHENTICATION:
+            self.set_message_type(gtk.MESSAGE_ERROR)
+            self.label.set_markup(self.AUTHENTICATION_MESSAGE % backend_name)
+            self.add_button(_('Configure backend'), gtk.RESPONSE_ACCEPT)
+            self.add_button(_('Ignore'), gtk.RESPONSE_CLOSE)
+
+        elif error_code == BackendSignals.ERRNO_NETWORK:
+            if not is_connection_up():
+                return
+            self.set_message_type(gtk.MESSAGE_WARNING)
+            self.label.set_markup(self.NETWORK_MESSAGE % backend_name)
+            #FIXME: use gtk stock button instead
+            self.add_button(_('Ok'), gtk.RESPONSE_CLOSE)
+        
+        elif error_code == BackendSignals.ERRNO_DBUS:
+            self.set_message_type(gtk.MESSAGE_WARNING)
+            self.label.set_markup(self.DBUS_MESSAGE % backend_name)
+            self.add_button(_('Ok'), gtk.RESPONSE_CLOSE)
+
+        self.show_all()
+
+    def set_interaction_request(self, description, interaction_type, callback):
+        '''
+        Sets this infobar to request an interaction from the user
+
+        @param description: a string describing the interaction needed
+        @param interaction_type: a string describing the type of interaction
+                                 (yes/no, only confirm, ok/cancel...)
+        @param callback: the function to call when the user provides the
+                         feedback
+        '''
+        self._populate()
+        self.callback = callback
+        self.set_message_type(gtk.MESSAGE_INFO)
+        self.label.set_markup(description)
+        self.connect("response", self._on_interaction_response)
+        self.interaction_type = interaction_type
+        if interaction_type == BackendSignals().INTERACTION_CONFIRM:
+            self.add_button(_('Confirm'), gtk.RESPONSE_ACCEPT)
+        elif interaction_type == BackendSignals().INTERACTION_TEXT:
+            self.add_button(_('Continue'), gtk.RESPONSE_ACCEPT)
+        self.show_all()
+
+    def _on_interaction_response(self, widget, event):
+        '''
+        Signal callback executed when the user gives the feedback for a
+        requested interaction
+
+        @param widget: not used, here for compatibility with signals callbacks
+        @param event: the code of the gtk response
+        '''
+        if event == gtk.RESPONSE_ACCEPT:
+            if self.interaction_type == BackendSignals().INTERACTION_TEXT:
+                self._prepare_textual_interaction()
+                print "done"
+            elif self.interaction_type == BackendSignals().INTERACTION_CONFIRM:
+                self.hide()
+                threading.Thread(target = getattr(self.backend,
+                                            self.callback)).start()
+
+    def _prepare_textual_interaction(self):
+        '''
+        Helper function. gtk calls to populate the infobar in the case of
+        interaction request
+        '''
+        title, description\
+                = getattr(self.backend, self.callback)("get_title")
+        self.dialog = gtk.Window()#type = gtk.WINDOW_POPUP)
+        self.dialog.set_title(title)
+        self.dialog.set_transient_for(self.browser.window)
+        self.dialog.set_destroy_with_parent(True)
+        self.dialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
+        self.dialog.set_modal(True)
+        #        self.dialog.set_size_request(300,170)
+        vbox = gtk.VBox()
+        self.dialog.add(vbox)
+        description_label = gtk.Label()
+        description_label.set_justify(gtk.JUSTIFY_FILL)
+        description_label.set_line_wrap(True)
+        description_label.set_markup(description)
+        align = gtk.Alignment(0.5, 0.5, 1, 1)
+        align.set_padding(10, 0, 20, 20)
+        align.add(description_label)
+        vbox.pack_start(align)
+        self.text_box = gtk.Entry()
+        self.text_box.set_size_request(-1, 40)
+        align = gtk.Alignment(0.5, 0.5, 1, 1)
+        align.set_padding(20, 20, 20, 20)
+        align.add(self.text_box)
+        vbox.pack_start(align)
+        button = gtk.Button(stock = gtk.STOCK_OK)
+        button.connect("clicked", self._on_text_confirmed)
+        button.set_size_request(-1, 40)
+        vbox.pack_start(button, False)
+        self.dialog.show_all()
+        self.hide()
+
+    def _on_text_confirmed(self, widget):
+        '''
+        Signal callback, used when the interaction needs a textual input to be
+        completed (e.g, the twitter OAuth, requesting a pin)
+
+        @param widget: not used, here for signal callback compatibility
+        '''
+        text = self.text_box.get_text()
+        self.dialog.destroy()
+        threading.Thread(target = getattr(self.backend, self.callback), 
+                          args = ("set_text", text)).start()
+
 
=== modified file 'GTG/gtk/browser/taskbrowser.glade'
--- GTG/gtk/browser/taskbrowser.glade	2010-05-22 22:41:44 +0000
+++ GTG/gtk/browser/taskbrowser.glade	2010-09-04 17:54:43 +0000
@@ -11,7 +11,6 @@
     <child>
       <object class="GtkVBox" id="master_vbox">
         <property name="visible">True</property>
-        <property name="orientation">vertical</property>
         <child>
           <object class="GtkMenuBar" id="browser_menu">
             <property name="visible">True</property>
@@ -154,6 +153,13 @@
                         <signal name="activate" handler="on_preferences_activate"/>
                       </object>
                     </child>
+                    <child>
+                      <object class="GtkMenuItem" id="backends_mi">
+                        <property name="label">Backends</property>
+                        <property name="visible">True</property>
+                        <signal name="activate" handler="on_edit_backends_activate"/>
+                      </object>
+                    </child>
                   </object>
                 </child>
               </object>
@@ -253,6 +259,7 @@
                         <property name="label">gtk-help</property>
                         <property name="visible">True</property>
                         <property name="tooltip_text" translatable="yes">Open GTG documentation in your web browser</property>
+                        <property name="use_underline">True</property>
                         <property name="use_stock">True</property>
                         <property name="accel_group">accelgroup1</property>
                         <signal name="activate" handler="on_documentation_clicked"/>
@@ -279,146 +286,156 @@
           </packing>
         </child>
         <child>
-          <object class="GtkToolbar" id="task_toolbar">
+          <object class="GtkVBox" id="vbox_toolbars">
             <property name="visible">True</property>
             <child>
-              <object class="GtkToolButton" id="new_task_b">
-                <property name="visible">True</property>
-                <property name="is_important">True</property>
-                <property name="label" translatable="yes">New Task</property>
-                <property name="icon_name">gtg-task-new</property>
-                <signal name="clicked" handler="on_add_task"/>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="homogeneous">True</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkToolButton" id="new_subtask_b">
-                <property name="label" translatable="yes">New Subtask</property>
-                <property name="icon_name">gtg-task-new</property>
-                <signal name="clicked" handler="on_add_subtask"/>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="homogeneous">True</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkToolButton" id="edit_b">
-                <property name="visible">True</property>
-                <property name="visible_horizontal">False</property>
-                <property name="visible_vertical">False</property>
-                <property name="label" translatable="yes">Edit</property>
-                <property name="stock_id">gtk-edit</property>
-                <signal name="clicked" handler="on_edit_active_task"/>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="homogeneous">True</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkSeparatorToolItem" id="&lt;separateur&gt;"/>
-              <packing>
-                <property name="expand">False</property>
-                <property name="homogeneous">True</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkToolButton" id="Undo">
-                <property name="label" translatable="yes">Undo</property>
-                <property name="stock_id">gtk-undo</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="homogeneous">True</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkToolButton" id="Redo">
-                <property name="label" translatable="yes">Redo</property>
-                <property name="stock_id">gtk-redo</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="homogeneous">True</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkSeparatorToolItem" id="separator_6">
-                <property name="visible">True</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="homogeneous">True</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkToolButton" id="done_b">
-                <property name="visible">True</property>
-                <property name="sensitive">False</property>
-                <property name="is_important">True</property>
-                <property name="label" translatable="yes">Mark as Done</property>
-                <property name="icon_name">gtg-task-done</property>
-                <signal name="clicked" handler="on_mark_as_done"/>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="homogeneous">True</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkToolButton" id="dismiss_b">
-                <property name="visible">True</property>
-                <property name="sensitive">False</property>
-                <property name="label" translatable="yes">Dismiss</property>
-                <property name="icon_name">gtg-task-dismiss</property>
-                <signal name="clicked" handler="on_dismiss_task"/>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="homogeneous">True</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkToolButton" id="delete_b">
-                <property name="sensitive">False</property>
-                <property name="label" translatable="yes">Delete</property>
-                <property name="icon_name">edit-delete</property>
-                <signal name="clicked" handler="on_delete_task"/>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="homogeneous">True</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkSeparatorToolItem" id="separator_7">
-                <property name="visible">True</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="homogeneous">True</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkToggleToolButton" id="workview_toggle">
-                <property name="visible">True</property>
-                <property name="is_important">True</property>
-                <property name="label" translatable="yes">Work View</property>
-                <property name="stock_id">gtk-index</property>
-                <signal name="toggled" handler="on_workview_toggled"/>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="homogeneous">True</property>
+              <object class="GtkToolbar" id="task_toolbar">
+                <property name="visible">True</property>
+                <child>
+                  <object class="GtkToolButton" id="new_task_b">
+                    <property name="visible">True</property>
+                    <property name="is_important">True</property>
+                    <property name="label" translatable="yes">New Task</property>
+                    <property name="icon_name">gtg-task-new</property>
+                    <signal name="clicked" handler="on_add_task"/>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="homogeneous">True</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkToolButton" id="new_subtask_b">
+                    <property name="label" translatable="yes">New Subtask</property>
+                    <property name="icon_name">gtg-task-new</property>
+                    <signal name="clicked" handler="on_add_subtask"/>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="homogeneous">True</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkToolButton" id="edit_b">
+                    <property name="visible">True</property>
+                    <property name="visible_horizontal">False</property>
+                    <property name="visible_vertical">False</property>
+                    <property name="label" translatable="yes">Edit</property>
+                    <property name="stock_id">gtk-edit</property>
+                    <signal name="clicked" handler="on_edit_active_task"/>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="homogeneous">True</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkSeparatorToolItem" id="&lt;separateur&gt;"/>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="homogeneous">True</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkToolButton" id="Undo">
+                    <property name="label" translatable="yes">Undo</property>
+                    <property name="stock_id">gtk-undo</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="homogeneous">True</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkToolButton" id="Redo">
+                    <property name="label" translatable="yes">Redo</property>
+                    <property name="stock_id">gtk-redo</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="homogeneous">True</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkSeparatorToolItem" id="separator_6">
+                    <property name="visible">True</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="homogeneous">True</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkToolButton" id="done_b">
+                    <property name="visible">True</property>
+                    <property name="sensitive">False</property>
+                    <property name="is_important">True</property>
+                    <property name="label" translatable="yes">Mark as Done</property>
+                    <property name="icon_name">gtg-task-done</property>
+                    <signal name="clicked" handler="on_mark_as_done"/>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="homogeneous">True</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkToolButton" id="dismiss_b">
+                    <property name="visible">True</property>
+                    <property name="sensitive">False</property>
+                    <property name="label" translatable="yes">Dismiss</property>
+                    <property name="icon_name">gtg-task-dismiss</property>
+                    <signal name="clicked" handler="on_dismiss_task"/>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="homogeneous">True</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkToolButton" id="delete_b">
+                    <property name="sensitive">False</property>
+                    <property name="label" translatable="yes">Delete</property>
+                    <property name="icon_name">edit-delete</property>
+                    <signal name="clicked" handler="on_delete_task"/>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="homogeneous">True</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkSeparatorToolItem" id="separator_7">
+                    <property name="visible">True</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="homogeneous">True</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkToggleToolButton" id="workview_toggle">
+                    <property name="visible">True</property>
+                    <property name="is_important">True</property>
+                    <property name="label" translatable="yes">Work View</property>
+                    <property name="stock_id">gtk-index</property>
+                    <signal name="toggled" handler="on_workview_toggled"/>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="homogeneous">True</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="position">0</property>
               </packing>
             </child>
           </object>
           <packing>
             <property name="expand">False</property>
+            <property name="fill">False</property>
             <property name="position">1</property>
           </packing>
         </child>
@@ -429,7 +446,6 @@
             <child>
               <object class="GtkVBox" id="sidebar_vbox">
                 <property name="width_request">75</property>
-                <property name="orientation">vertical</property>
                 <child>
                   <object class="GtkHBox" id="hbox4">
                     <property name="visible">True</property>
@@ -484,9 +500,9 @@
                   <object class="GtkNotebook" id="sidebar_notebook">
                     <property name="visible">True</property>
                     <property name="can_focus">True</property>
+                    <property name="tab_pos">bottom</property>
+                    <property name="show_tabs">False</property>
                     <property name="group_id">1</property>
-                    <property name="show_tabs">False</property>
-                    <property name="tab_pos">bottom</property>
                     <child>
                       <object class="GtkScrolledWindow" id="sidebar-scroll">
                         <property name="visible">True</property>
@@ -507,7 +523,6 @@
                       <packing>
                         <property name="tab_fill">False</property>
                       </packing>
-
                     </child>
                   </object>
                   <packing>
@@ -523,7 +538,6 @@
             <child>
               <object class="GtkVBox" id="main_vbox">
                 <property name="visible">True</property>
-                <property name="orientation">vertical</property>
                 <child>
                   <object class="GtkHBox" id="quickadd_pane">
                     <property name="visible">True</property>
@@ -567,14 +581,13 @@
                   <object class="GtkVPaned" id="vpaned1">
                     <property name="visible">True</property>
                     <property name="can_focus">True</property>
-                    <property name="orientation">vertical</property>
                     <child>
                       <object class="GtkNotebook" id="main_notebook">
                         <property name="visible">True</property>
                         <property name="can_focus">True</property>
+                        <property name="tab_pos">bottom</property>
+                        <property name="show_tabs">False</property>
                         <property name="group_id">2</property>
-                        <property name="show_tabs">False</property>
-                        <property name="tab_pos">bottom</property>
                         <child>
                           <object class="GtkScrolledWindow" id="main_pane">
                             <property name="visible">True</property>
@@ -603,11 +616,10 @@
                     </child>
                     <child>
                       <object class="GtkNotebook" id="accessory_notebook">
-                        <property name="visible">False</property>
                         <property name="can_focus">True</property>
+                        <property name="tab_pos">bottom</property>
+                        <property name="show_tabs">False</property>
                         <property name="group_id">2</property>
-                        <property name="show_tabs">False</property>
-                        <property name="tab_pos">bottom</property>
                         <child>
                           <placeholder/>
                         </child>
@@ -695,7 +707,6 @@
     <child internal-child="vbox">
       <object class="GtkVBox" id="about_dialog_vbox">
         <property name="visible">True</property>
-        <property name="orientation">vertical</property>
         <property name="spacing">2</property>
         <child internal-child="action_area">
           <object class="GtkHButtonBox" id="dialog-action_area2">
@@ -959,7 +970,6 @@
     <child internal-child="vbox">
       <object class="GtkVBox" id="addtag_dialog_vbox">
         <property name="visible">True</property>
-        <property name="orientation">vertical</property>
         <property name="spacing">2</property>
         <child>
           <object class="GtkLabel" id="addtag_label">
@@ -1062,4 +1072,8 @@
     <property name="pixel_size">16</property>
     <property name="icon_name">gtg-tag</property>
   </object>
+  <object class="GtkImage" id="image4">
+    <property name="visible">True</property>
+    <property name="stock">gtk-home</property>
+  </object>
 </interface>
 
=== modified file 'GTG/gtk/colors.py'
--- GTG/gtk/colors.py	2010-06-07 21:14:45 +0000
+++ GTG/gtk/colors.py	2010-09-04 17:54:43 +0000
@@ -20,7 +20,7 @@
 
 #Take list of Tags and give the background color that should be applied
 #The returned color might be None (in which case, the default is used)
-def background_color(tags, bgcolor=None):
+def background_color(tags, bgcolor = None):
     if not bgcolor:
         bgcolor = gtk.gdk.color_parse("#FFFFFF")
     # Compute color
@@ -52,3 +52,29 @@
         my_color = gtk.gdk.Color(red, green, blue).to_string()
     return my_color
 
+def get_colored_tag_markup(req, tag_name):
+    '''
+    Given a tag name, returns a string containing the markup to color the
+    tag name
+    '''
+    tag = req.get_tag(tag_name)
+    if tag is None:
+        #no task loaded with that tag, color cannot be taken
+        return tag_name
+    else:
+        tag_color = tag.get_attribute("color")
+        if tag_color:
+            return '<span color="%s">%s</span>' % (tag_color, tag_name)
+        else:
+            return tag_name
+
+def get_colored_tags_markup(req, tag_names):
+    '''
+    Calls get_colored_tag_markup for each tag_name in tag_names
+    '''
+    tag_markups = map(lambda t: get_colored_tag_markup(req, t), tag_names)
+    tags_txt = ""
+    if tag_markups:
+        #reduce crashes if applied to an empty list
+        tags_txt = reduce(lambda a, b: a + ", " + b, tag_markups)
+    return tags_txt
 
=== modified file 'GTG/gtk/manager.py'
--- GTG/gtk/manager.py	2010-08-03 17:07:31 +0000
+++ GTG/gtk/manager.py	2010-09-04 17:54:43 +0000
@@ -39,10 +39,11 @@
 from GTG.core.plugins.engine import PluginEngine
 from GTG.core.plugins.api    import PluginAPI
 from GTG.tools.logger        import Log
-
-
-
-class Manager:
+from GTG.gtk.backends_dialog import BackendsDialog
+
+
+
+class Manager(object):
     
 
     ############## init #####################################################
@@ -80,6 +81,7 @@
         #Preferences and Backends windows
         # Initialize  dialogs
         self.preferences_dialog = None
+        self.edit_backends_dialog = None
         
         #DBus
         DBusTaskWrapper(self.req, self)
@@ -196,6 +198,16 @@
             
 ################ Others dialog ############################################
 
+    def open_edit_backends(self, sender = None, backend_id = None):
+        if not self.edit_backends_dialog:
+            self.edit_backends_dialog = BackendsDialog(self.req)
+        self.edit_backends_dialog.activate()
+        if backend_id != None:
+            self.edit_backends_dialog.show_config_for_backend(backend_id)
+
+    def configure_backend(self, backend_id):
+        self.open_edit_backends(None, backend_id)
+
     def open_preferences(self, config_priv, sender=None):
         if not hasattr(self, "preferences"):
             self.preferences = PreferencesDialog(self.pengine, self.p_apis, \
@@ -211,7 +223,8 @@
                     self.close_task(t)
             
 ### MAIN ###################################################################
-    def main(self, once_thru=False):
+
+    def main(self, once_thru = False):
         gobject.threads_init()
         if once_thru:
             gtk.main_iteration()
@@ -219,7 +232,6 @@
             gtk.main()
         return 0
         
-        
     def quit(self,sender=None):
         gtk.main_quit()
         #save opened tasks and their positions.
 
=== added file 'GTG/tests/test_interruptible.py'
--- GTG/tests/test_interruptible.py	1970-01-01 00:00:00 +0000
+++ GTG/tests/test_interruptible.py	2010-09-04 17:54:43 +0000
@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Gettings Things Gnome! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2009 - Lionel Dricot & Bertrand Rousseau
+#
+# 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/>.
+# -----------------------------------------------------------------------------
+
+'''
+Tests for interrupting cooperative threads
+'''
+
+import unittest
+import time
+from threading import Thread, Event
+
+from GTG.tools.interruptible import interruptible, _cancellation_point
+
+
+class TestInterruptible(unittest.TestCase):
+    '''
+    Tests for interrupting cooperative threads
+    '''
+
+    def test_interruptible_decorator(self):
+        self.quit_condition = False
+        cancellation_point = lambda: _cancellation_point(\
+                                        lambda: self.quit_condition)
+        self.thread_started = Event()
+        @interruptible
+        def never_ending(cancellation_point):
+            self.thread_started.set()
+            while True:
+                time.sleep(0.1)
+                cancellation_point()
+        thread = Thread(target = never_ending, args = (cancellation_point, ))
+        thread.start()
+        self.thread_started.wait()
+        self.quit_condition = True
+        countdown = 10
+        while thread.is_alive() and countdown > 0:
+            time.sleep(0.1)
+            countdown -= 1
+        self.assertFalse(thread.is_alive())
+
+
+
+
+
+
+
+
+
+    
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(TestInterruptible)
+
 
=== added file 'GTG/tools/networkmanager.py'
--- GTG/tools/networkmanager.py	1970-01-01 00:00:00 +0000
+++ GTG/tools/networkmanager.py	2010-09-04 17:54:43 +0000
@@ -0,0 +1,57 @@
+#!/bin/env python
+#
+# 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 2 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, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Copyright (C) 2010 Red Hat, Inc.
+#
+
+import dbus
+
+
+def is_connection_up():
+    '''
+    Returns True if network-manager reports that at least one connection is up
+
+    @returns bool
+    '''
+    state = False
+    bus = dbus.SystemBus()
+
+    proxy = bus.get_object("org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager")
+    manager = dbus.Interface(proxy, "org.freedesktop.NetworkManager")
+
+    manager_prop_iface = dbus.Interface(proxy, "org.freedesktop.DBus.Properties")
+    active = manager_prop_iface.Get("org.freedesktop.NetworkManager", "ActiveConnections")
+    for a in active:
+        ac_proxy = bus.get_object("org.freedesktop.NetworkManager", a)
+        prop_iface = dbus.Interface(ac_proxy, "org.freedesktop.DBus.Properties")
+        state = prop_iface.Get("org.freedesktop.NetworkManager.ActiveConnection", "State")
+
+        # Connections in NM are a collection of settings that describe everything
+        # needed to connect to a specific network.  Lets get those details so we
+        # can find the user-readable name of the connection.
+        con_path = prop_iface.Get("org.freedesktop.NetworkManager.ActiveConnection", "Connection")
+        con_service = prop_iface.Get("org.freedesktop.NetworkManager.ActiveConnection", "ServiceName")
+
+        # ask the provider of the connection for its details
+        service_proxy = bus.get_object(con_service, con_path)
+        con_iface = dbus.Interface(service_proxy, "org.freedesktop.NetworkManagerSettings.Connection")
+        con_details = con_iface.GetSettings()
+        con_name = con_details['connection']['id']
+
+        if state == 2:   # activated
+            state = True
+    return state
+
 
=== added file 'data/icons/hicolor/scalable/apps/backend_localfile.png'
 Binary files data/icons/hicolor/scalable/apps/backend_localfile.png	1970-01-01 00:00:00 +0000 and data/icons/hicolor/scalable/apps/backend_localfile.png	2010-09-04 17:54:43 +0000 differ