Merge lp:~gtg-user/gtg/google-tasks-backend into lp:~gtg/gtg/old-trunk

[phiamo]

Added the google tasks api as a backend.

TODO's:
- the client_secrets.json provides a needed api key. Already emailed google to get info on howto manage this in another fashion, no response yet
- under certain circumstances i get duplicates cause sync_engine telle it does not know things
- would like to change the dropdown in the backend properties to an editable listview so you can tell which list to sync and add per list tags (currently in progress local)

[Izidor Matušov (izidor)]

For beginning couple of formal things:

1, get rid of print statements
2, have you written the backend from the beginning or you used
lp:~gtg-contributors/gtg/google_tasks for inspiration? In the later case you need to put credits into Author sections.
3, Your code have to satisfy PEP8 standard and PyFlakes check <use `make check` command>
4, Get rid of _bak.py file

I managed to get some traceback in console during update

Exception in thread Thread-10:
Traceback (most recent call last):
  File "/usr/lib/python2.7/threading.py", line 552, in __bootstrap_inner
    self.run()
  File "/usr/lib/python2.7/threading.py", line 760, in run
    self.function(*self.args, **self.kwargs)
  File "/home/izidor/projects/gtg/trunk/GTG/backends/genericbackend.py", line 653, in launch_setting_thread
    self.set_task(task)
  File "/home/izidor/projects/gtg/trunk/GTG/tools/interruptible.py", line 39, in new
    return fn(*args)
  File "/home/izidor/projects/gtg/trunk/GTG/backends/backend_gtasks.py", line 275, in set_task
    self._populate_gtask(task, gtask)
  File "/home/izidor/projects/gtg/trunk/GTG/backends/backend_gtasks.py", line 452, in _populate_gtask
    self.gtasks_proxy.update(gtask)
  File "/home/izidor/projects/gtg/trunk/GTG/backends/backend_gtasks.py", line 493, in update
    self.gtasks.task_update(gtask.get_tasklist(), gtask.get_id(), body)
  File "/home/izidor/projects/gtg/trunk/GTG/backends/gtasks/gtasks.py", line 169, in task_update
    return self.execute(self.get_service().tasks().update(tasklist=tasklist,task=task, body=body))
  File "/home/izidor/projects/gtg/trunk/GTG/backends/gtasks/gtasks.py", line 113, in execute
    return request.execute(http=self.http)
  File "/usr/local/lib/python2.7/dist-packages/google_api_python_client-1.0-py2.7.egg/oauth2client/util.py", line 120, in positional_wrapper
    return wrapped(*args, **kwargs)
  File "/usr/local/lib/python2.7/dist-packages/google_api_python_client-1.0-py2.7.egg/apiclient/http.py", line 678, in execute
    raise HttpError(resp, content, uri=self.uri)
HttpError: <HttpError 400 when requesting https://www.googleapis.com/tasks/v1/lists/MTM0OTg2OTgwNTUxMDYzOTQ5MTU6MDow/tasks/MTM0OTg2OTgwNTUxMDYzOTQ5MTU6MDoxNzU4ODcwNTY1?alt=json returned "Invalid Value">

Wouldn't it be better to create a list for every tag and then copy tasks to each list?

Please, address those things so we can continue in reviewing your patch.

review: Needs Fixing (code,run)

[phiamo (phiamo)]

Hello Izidor,
Thanks for your comment.

1, get rid of print statements
> yes asap, i was a bit too entouthiastic yesterday evening...

2, have you written the backend from the beginning or you used
lp:~gtg-contributors/gtg/google_tasks for inspiration? In the later case you need to put credits into Author sections.
no i started with the rtm plugin as a base, and the rest was coded either myself, or given by google (sample for gtasks api usage)

3, Your code have to satisfy PEP8 standard and PyFlakes check <use `make check` command>
i am going further with pylint and pep8 lateron this day
4, Get rid of _bak.py file
of course

Wouldn't it be better to create a list for every tag and then copy tasks to each list?

yes, it would and thats exactly what i am working on atm

[lp:~gtg-user/gtg/google-tasks-backend]

1294. By phiamo on 2013-02-26

Removed print statements

1295. By phiamo on 2013-02-26

Removed _bak file

1296. By phiamo on 2013-02-26

Added possibility to save dicts in backend params safely

1297. By phiamo on 2013-02-26

Changed the way howto config the backed to be more userfriendly and configurable

[phiamo (phiamo)]

Hi,
i would like to split up the current development into some more steps and hopefully get the fist one into gtg mainline soon, then go further (i thought i could do these steps in one, but i failed, and dont have too much sparetime to do this now at once):

1.st step:
break down the current solution to only support one list in google tasks, configurable in the backend, (see latest commits, there go into this direction but are not finished yet) via the treeview already implemented, but with a radio toggle to select active list only

the goal would be to have the lists selectable in the backend and just tell the backen, sync gtg with this list and back
this should be a reliable mechanism so my google lists (also updated by some android app) are everywhere in sync.

2.nd step:
add the possibility to manage multiple lists. making the backend treeview as it is currently you select which lists to sync via a checkbox and select the default list where new tasks from gtg should get added

3.rd step:
add a tags field to this backend per list, so you configure tags per lists which should end up with a good solution, that i can create a gtg task with a tag lets say @private and this tag is added to the google tasks lists which is configured in the backend with @private
this config should support multiple tags and probably furthermore there also should be a default option toggable, bt not mandatory, so not every task in gtg ends up in google tasks, but only the ones i configure manually

I am not so familiar with launchpad at all, do i need to revoke the code review, and add this plan somewhere?or would you just say, good idea, try it commit it and we will review it?

review: Needs Resubmitting (plan)

[Izidor Matušov (izidor)]

Hi phiamo,

I'll close this merge request as "Rejected" and feel free to request a merge again.

I think the first step could be just "workable" tasks (those which are showed in WorkView). Also I think you could set 1 tag = 1 list later.

Unmerged revisions

1297. By phiamo on 2013-02-26

Changed the way howto config the backed to be more userfriendly and configurable

1296. By phiamo on 2013-02-26

Added possibility to save dicts in backend params safely

1295. By phiamo on 2013-02-26

Removed _bak file

1294. By phiamo on 2013-02-26

Removed print statements

1293. By phiamo on 2013-02-25

Added google tasks backend

1292. By phiamo on 2013-02-25

Added google tasks backend

=== added file 'GTG/backends/backend_gtasks.py'
--- GTG/backends/backend_gtasks.py	1970-01-01 00:00:00 +0000
+++ GTG/backends/backend_gtasks.py	2013-02-26 14:40:31 +0000
@@ -0,0 +1,815 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Getting Things GNOME! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2012 - 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/>.
+# -----------------------------------------------------------------------------
+
+'''
+google tasks backend
+'''
+
+import os
+import cgi
+import uuid
+import time
+import threading
+import datetime
+import subprocess
+import exceptions
+from dateutil.tz                        import tzutc, tzlocal
+
+from GTG.backends.genericbackend        import GenericBackend
+from GTG                                import _
+from GTG.backends.backendsignals        import BackendSignals
+from GTG.backends.syncengine            import SyncEngine, SyncMeme
+from GTG.backends.gtasks.gtasks         import GTasks, GTasksError, GTasksAPIError
+from GTG.backends.periodicimportbackend import PeriodicImportBackend
+from GTG.tools.dates                    import Date
+from GTG.core.task                      import Task
+from GTG.tools.interruptible            import interruptible
+from GTG.tools.logger                   import Log
+from xdg.BaseDirectory                  import xdg_config_home
+
+
+
+
+
+class Backend(PeriodicImportBackend):
+
+    _general_description = { \
+        GenericBackend.BACKEND_NAME:       "backend_gtasks", \
+        GenericBackend.BACKEND_HUMAN_NAME: _("gTasks Backend"), \
+        GenericBackend.BACKEND_AUTHORS:    ["Philipp A. Mohrenweiser"], \
+        GenericBackend.BACKEND_TYPE:       GenericBackend.TYPE_READWRITE, \
+        GenericBackend.BACKEND_DESCRIPTION: \
+            _("This service synchronizes your tasks with your google online tasks"),\
+        }
+
+    _static_parameters = { 
+        "period": { 
+            GenericBackend.PARAM_TYPE: GenericBackend.TYPE_INT, 
+            GenericBackend.PARAM_DEFAULT_VALUE: 10
+        },
+        "gtask-tag-and-list-selection": { 
+            GenericBackend.PARAM_TYPE: GenericBackend.TYPE_DICT, 
+            GenericBackend.PARAM_DEFAULT_VALUE: {}
+        },
+        "is-first-run": { 
+            GenericBackend.PARAM_TYPE: GenericBackend.TYPE_BOOL, 
+            GenericBackend.PARAM_DEFAULT_VALUE: True
+        }
+    }
+###############################################################################
+### Backend standard methods ##################################################
+###############################################################################
+
+    def __init__(self, parameters):
+        '''
+        See GenericBackend for an explanation of this function.
+        Loads the saved state of the sync, if any
+        '''
+        super(Backend, self).__init__(parameters)
+        #loading the saved state of the synchronization, if any
+        self.sync_engine_path = os.path.join('backends/gtasks/', \
+                                      "sync_engine-" + self.get_id())
+        self.sync_engine = self._load_pickled_file(self.sync_engine_path, \
+                                                   SyncEngine())
+        self._this_is_the_first_loop = True
+        self.gtasks_proxy = GTasksProxy(self)
+    
+    def get_tasklists(self):
+        return self.gtasks_proxy.get_tasklists()
+        
+    def get_liststore_data(self, parameter):
+        """Needed by the combobox ui to supply liststore data"""
+        data = []
+        if "default-list-to-sync-to" == parameter:
+            for k, v in self.gtasks_proxy.get_tasklists().iteritems():
+                data.append((k,v))
+        return data
+        
+    def initialize(self):
+        """
+        See GenericBackend for an explanation of this function.
+        """
+        self._parameters[self.KEY_ENABLED] = self.has_valid_config()
+        self._is_initialized = True
+        # we signal that the backend has been enabled
+        self._signal_manager.backend_state_changed(self.get_id())
+        
+    def has_valid_config(self):
+        d = self.get_parameters()['gtask-tag-and-list-selection']
+        for iid, conf in d.iteritems():
+            if conf.get('sync', False) == True:
+                have_at_least_one_list_to_sync = True
+                if conf.get('default', False) == True:
+                    return True
+        return False
+
+    def save_state(self):
+        """
+        See GenericBackend for an explanation of this function.
+        """
+        self._store_pickled_file(self.sync_engine_path, self.sync_engine)
+
+###############################################################################
+### TWO WAY SYNC ##############################################################
+###############################################################################
+
+    def do_periodic_import(self):
+        """
+        See PeriodicImportBackend for an explanation of this function.
+        """
+
+        #we get the old list of synced tasks, and compare with the new tasks set
+        stored_gtasks_ids = self.sync_engine.get_all_remote()
+        current_gtask_ids = [gtask_id for gtask_id in \
+                            self.gtasks_proxy.get_gtasks_dict().iterkeys()]
+        if self._this_is_the_first_loop:
+            self._on_successful_authentication()
+
+        #If it's the very first time the backend is run, it's possible that the
+        # user already synced his tasks in some way (but we don't know that).
+        # Therefore, we attempt to induce those tasks relationships matching the
+        # titles.
+        if self._parameters["is-first-run"] and False:
+            gtg_titles_dic = {}
+            for tid in self.datastore.get_all_tasks():
+                gtg_task = self.datastore.get_task(tid)
+                if not self._gtg_task_is_syncable_per_attached_tags(gtg_task):
+                    continue
+                gtg_title = gtg_task.get_title()
+                if gtg_titles_dic.has_key(gtg_title):
+                    gtg_titles_dic[gtg_task.get_title()].append(tid)
+                else:
+                    gtg_titles_dic[gtg_task.get_title()] = [tid]
+            for gtask_id in current_gtask_ids:
+                gtask = self.gtasks_proxy.get_task(gtask_id)
+                try:
+                    tids = gtg_titles_dic[gtask.get_title()]
+                    #we remove the tid, so that it can't be linked to two
+                    # different gtasks tasks
+                    tid = tids.pop()
+                    gtg_task = self.datastore.get_task(tid)
+                    meme = SyncMeme(gtg_task.get_modified(),
+                                    gtask.get_modified(),
+                                    "GTG")
+                    self.sync_engine.record_relationship( \
+                         local_id = tid,
+                         remote_id = gtask.get_id(),
+                         meme = meme)
+                except KeyError:
+                    pass
+                except IndexError:
+                    pass
+            #a first run has been completed successfully
+            self._parameters["is-first-run"] = False
+        
+        for gtask_id in current_gtask_ids:
+            self.cancellation_point()
+            #Adding and updating
+            self._process_gtask(gtask_id)
+        
+        for gtask_id in set(stored_gtasks_ids).difference(\
+                                        set(current_gtask_ids)):
+            self.cancellation_point()
+            if not self.please_quit:
+                tid = self.sync_engine.get_local_id(gtask_id)
+                self.datastore.request_task_deletion(tid)
+                try:
+                    self.sync_engine.break_relationship(remote_id = \
+                                                        gtask_id)
+                    self.save_state()
+                except KeyError:
+                    pass
+
+    def _on_successful_authentication(self):
+        '''
+        Saves the token and requests a full flush on first autentication
+        '''
+        self._this_is_the_first_loop = False
+        #we ask the Datastore to flush all the tasks on us
+        threading.Timer(10,
+                        self.datastore.flush_all_tasks,
+                        args =(self.get_id(),)).start()
+
+    @interruptible
+    def remove_task(self, tid):
+        """
+        See GenericBackend for an explanation of this function.
+        """
+        if not self.gtasks_proxy.is_authenticated():
+            return
+        self.cancellation_point()
+        try:
+            gtask_id = self.sync_engine.get_remote_id(tid)
+            if gtask_id not in self.gtasks_proxy.get_gtasks_dict():
+                #we might need to refresh our task cache
+                self.gtasks_proxy.refresh_gtasks_dict()
+            gtask = self.gtasks_proxy.get_task(gtask_id)
+            self.gtasks_proxy.delete(gtask)
+            Log.debug("removing task %s from GTasks" % gtask)
+        except KeyError:
+            try:
+                self.sync_engine.break_relationship(local_id = tid)
+                self.save_state()
+            except:
+                pass
+                
+    def delete(self, gtask):
+        self.remove_task(gtask.get_id())
+
+###############################################################################
+### Process tasks #############################################################
+###############################################################################
+
+    @interruptible
+    def set_task(self, task):
+        """
+        See GenericBackend for an explanation of this function.
+        """
+        if not self.gtasks_proxy.is_authenticated():
+            return
+        self.cancellation_point()
+        tid = task.get_id()
+        is_syncable = self._gtg_task_is_syncable_per_attached_tags(task)
+        action, gtask_id = self.sync_engine.analyze_local_id( \
+                                tid, \
+                                self.datastore.has_task, \
+                                self.gtasks_proxy.has_gtask, \
+                                is_syncable)
+        if action == None:
+            return
+
+        if action == SyncEngine.ADD:
+            Log.debug("GTG->GTasks set task (%s, %s) ADD" % (action, is_syncable))
+            if task.get_status() != Task.STA_ACTIVE:
+                #OPTIMIZATION:
+                #we don't sync tasks that have already been closed before we
+                # even synced them once
+                return
+            gtask = self.gtasks_proxy.create_new_gtask(task.get_title())
+            gtask.set_text("added via set task")
+            try:
+                self._populate_gtask(task, gtask)
+            except:
+                self.gtasks_proxy.delete(gtask)
+                raise
+            meme = SyncMeme(task.get_modified(),
+                            gtask.get_modified(),
+                            "GTG")
+            self.sync_engine.record_relationship( \
+                local_id = tid, remote_id = gtask.get_id(), meme = meme)
+            self.gtasks_proxy.update(gtask)
+
+        elif action == SyncEngine.UPDATE:
+            Log.debug("GTG->GTasks set task (%s, %s) UPDATE" % (action, is_syncable))
+            gtask = self.gtasks_proxy.get_task(gtask_id)
+            with self.datastore.get_backend_mutex():
+                meme = self.sync_engine.get_meme_from_local_id(task.get_id())
+                newest = meme.which_is_newest(task.get_modified(),
+                                              gtask.get_modified())
+                if newest == "local":
+                    self._populate_gtask(task, gtask)
+                    meme.set_remote_last_modified(gtask.get_modified())
+                    meme.set_local_last_modified(task.get_modified())
+                else:
+                    #we skip saving the state
+                    return
+
+        elif action == SyncEngine.REMOVE:
+            Log.debug("GTG->GTasks set task (%s, %s) REMOVE" % (action, is_syncable))
+            self.datastore.request_task_deletion(tid)
+            try:
+                self.sync_engine.break_relationship(local_id = tid)
+            except KeyError:
+                pass
+            gtask = self.gtasks_proxy.get_task(gtask_id)
+            self.gtasks_proxy.task_delete(gtask.get_tasklist(), gtask.get_id())
+
+        elif action == SyncEngine.LOST_SYNCABILITY:
+            try:
+                gtask = self.gtasks_proxy.get_gtasks_dict()[gtask]
+            except KeyError:
+                #in this case, we don't have yet the task in our local cache
+                # of what's on the gtasks website
+                self.gtasks_proxy.refresh_gtasks_dict()
+                gtask = self.gtasks_proxy.get_gtasks_dict()[gtask]
+            self._exec_lost_syncability(tid, gtask)
+
+            self.save_state()
+
+    def _exec_lost_syncability(self, tid, gtask):
+        '''
+        Executed when a relationship between tasks loses its syncability
+        property. See SyncEngine for an explanation of that.
+
+        @param tid: a GTG task tid
+        @param note: a GTasks task
+        '''
+        self.cancellation_point()
+        meme = self.sync_engine.get_meme_from_local_id(tid)
+        #First of all, the relationship is lost
+        self.sync_engine.break_relationship(local_id = tid)
+        if meme.get_origin() == "GTG":
+            self.delete(gtask)
+        else:
+            self.datastore.request_task_deletion(tid)
+            
+    def _process_gtask(self, gtask_id):
+        '''
+        Takes a gtasks task id and carries out the necessary operations to
+        refresh the sync state
+        '''
+        self.cancellation_point()
+        if not self.gtasks_proxy.is_authenticated():
+            return
+        gtask = self.gtasks_proxy.get_task(gtask_id)
+        is_syncable = self._gtask_is_syncable_per_attached_tags(gtask)
+        
+        action, tid = self.sync_engine.analyze_remote_id( \
+                                             gtask_id,
+                                             self.datastore.has_task,
+                                             self.gtasks_proxy.has_gtask,
+                                             is_syncable)
+        
+        if action == None:
+            return        
+        
+        Log.debug("GTG<-GTasks set task (%s, %s)" % (action, is_syncable))
+        
+        if action == SyncEngine.ADD:
+            if gtask.get_status() != Task.STA_ACTIVE:
+                #OPTIMIZATION:
+                #we don't sync tasks that have already been closed before we
+                # even saw them
+                return
+            tid = str(uuid.uuid4())
+            task = self.datastore.task_factory(tid)
+            self._populate_task(task, gtask)
+            meme = SyncMeme(task.get_modified(),
+                            gtask.get_modified(),
+                            "GTasks")
+            self.sync_engine.record_relationship( \
+                    local_id = tid,
+                    remote_id = gtask.get_id(),
+                    meme = meme)
+            self.datastore.push_task(task)
+
+        elif action == SyncEngine.UPDATE:
+            task = self.datastore.get_task(tid)
+            with self.datastore.get_backend_mutex():
+                meme = self.sync_engine.get_meme_from_remote_id(gtask.get_id())
+                newest = meme.which_is_newest(task.get_modified(),
+                                              gtask.get_modified())
+                if newest == "remote":
+                    self._populate_task(task, gtask)
+                    meme.set_remote_last_modified(gtask.get_modified())
+                    meme.set_local_last_modified(task.get_modified())
+                else:
+                    #we skip saving the state
+                    return
+
+        elif action == SyncEngine.REMOVE:
+            try:
+                self.delete(gtask)
+                self.sync_engine.break_relationship(remote_id = gtask.get_id())
+            except KeyError:
+                pass
+
+        elif action == SyncEngine.LOST_SYNCABILITY:
+            self._exec_lost_syncability(tid, gtask)
+
+        self.save_state()
+
+###############################################################################
+### Helper methods ############################################################
+###############################################################################
+
+    def _populate_task(self, task, gtask):
+        '''
+        Copies the content of a GTasksTask in a Task
+        '''
+        task.set_title(gtask.get_title())
+        task.set_text(gtask.get_text())
+        task.set_due_date(gtask.get_due_date())
+        status = gtask.get_status()
+        if GTG_TO_GTasks_STATUS[task.get_status()] != status:
+            task.set_status(gtask.get_status())
+        #tags
+        tags = set(['@%s' % tag for tag in gtask.get_tags()])
+        gtg_tags_lower = set([t.get_name().lower() for t in task.get_tags()])
+        #tags to remove
+        for tag in gtg_tags_lower.difference(tags):
+            task.remove_tag(tag)
+        #tags to add
+        for tag in tags.difference(gtg_tags_lower):
+            gtg_all_tags = self.datastore.get_all_tags()
+            matching_tags = filter(lambda t: t.lower() == tag, gtg_all_tags)
+            if len(matching_tags) !=  0:
+                tag = matching_tags[0]
+            task.add_tag(tag)
+
+    def _populate_gtask(self, task, gtask):
+        '''
+        Copies the content of a Task into a GTasksTask
+
+        @param task: a GTG Task
+        @param gtask: an GTasksTask
+        '''
+        #Get methods of an gtask are fast, set are slow: therefore,
+        # we try to use set as rarely as possible
+
+        #first thing: the status. This way, if we are syncing a completed
+        # task it doesn't linger for ten seconds in the GTasks Inbox
+        status = task.get_status()
+        if gtask.get_status() != status:
+            gtask.set_status(status)
+        title = task.get_title()
+        if gtask.get_title() != title:
+           gtask.set_title(title)
+        text = task.get_excerpt(strip_tags = True, strip_subtasks = True)
+        if gtask.get_text() != text:
+            gtask.set_text(text)
+        tags = task.get_tags_name()
+        gtask_tags = []
+        for tag in gtask.get_tags():
+            if tag[0] != '@':
+                tag = '@' + tag
+            gtask_tags.append(tag)
+        #gtasks tags are lowercase only
+        if gtask_tags != [t.lower() for t in tags]:
+            gtask.set_tags(tags)
+        due_date = task.get_due_date()
+        if gtask.get_due_date() != due_date:
+            gtask.set_due_date(due_date)
+        self.gtasks_proxy.update(gtask)
+
+    def _gtask_is_syncable_per_attached_tags(self, gtask):
+        '''
+        Helper function which checks if the given task satisfies the filtering
+        imposed by the tags attached to the backend.
+        That means, if a user wants a backend to sync only tasks tagged @works,
+        this function should be used to check if that is verified.
+
+        @returns bool: True if the task should be synced
+        '''
+        attached_tags = self.get_attached_tags()
+        if GenericBackend.ALLTASKS_TAG in attached_tags:
+            return True
+        for tag in gtask.get_tags():
+            if "@" + tag in attached_tags:
+                return  True
+        return False
+
+###############################################################################
+### GTasks PROXY #################################################################
+###############################################################################
+
+class GTasksProxy(object):
+    '''
+    The purpose of this class is producing an updated list of GTasksTasks.
+    To do that, it handles:
+        - authentication to GTasks
+        - keeping the list fresh
+        - downloading the list
+    '''
+
+    def __init__(self, backend):
+        self.backend = backend
+        self.authenticated = threading.Event()
+        self.is_not_refreshing = threading.Event()
+        self.is_not_refreshing.set()
+        self.gtasks = GTasks(storage_dir = os.path.join(xdg_config_home, 'gtg/'))
+        
+    ##########################################################################
+    ### AUTHENTICATION #######################################################
+    ##########################################################################
+
+    def start_authentication(self):
+        '''
+        Launches the authentication process
+        '''
+        initialize_thread = threading.Thread(target = self._authenticate)
+        initialize_thread.setDaemon(True)
+        initialize_thread.start()
+    
+    def is_authenticated(self):
+        '''
+        Returns true if we've autheticated to GTasks
+        '''
+        return self.authenticated.isSet()
+
+    def wait_for_authentication(self):
+        '''
+        Inhibits the thread until authentication occours
+        '''
+        self.authenticated.wait()
+
+    def _authenticate(self):
+        '''
+        authentication main function
+        '''
+        self.authenticated.clear()
+        while not self.authenticated.isSet():
+            if not self.gtasks.is_valid():
+                self.gtasks.run_flow()
+            if self.gtasks.is_valid():
+                self.authenticated.set()
+            else:
+                BackendSignals().backend_failed(self.get_id(), \
+                            BackendSignals.ERRNO_NETWORK)
+
+    ##########################################################################
+    ### GTasks Tasklist HANDLING #############################################
+    ##########################################################################
+
+    def get_target_list(self, task):
+        """Find out if we confed one of the lists with tags, 
+        and if the current task has this tag add it to the first list matching
+        otherwise use default list
+        """
+        for iid, conf in self.backend.get_parameters()['gtask-tag-and-list-selection'].iteritems():
+            gtags = self._get_tags_from_string(conf.get('tags', ""))
+            for gtag in gtags:
+                if gtag in task.get_tags():
+                    return iid
+        return self.get_default_tasklist()
+            
+    def _get_tags_from_string(self, string):
+        tags = string.split(",")
+        # stripping spaces
+        tags = map(lambda t: t.strip(), tags)
+        # removing empty tags
+        return filter(lambda t: t, tags)
+        
+    def get_default_tasklist(self):
+        for iid, conf in self.backend.get_parameters()['gtask-tag-and-list-selection'].iteritems():
+            if conf.get('default', False) == True:
+                return iid
+        raise Exception('Could not find a default list')
+        
+    def get_tasklists(self):
+        self.tasklists = {}
+        for item in self.gtasks.tasklists_list().get('items'):
+            self.tasklists[str(item.get('id'))] = str(item.get('title'))
+        return self.tasklists
+        
+    def list_tasks(self, tasklist):
+        return self.gtasks.tasks_list(tasklist).get('items')
+
+    ##########################################################################
+    ### GTasks Task HANDLING #############################################
+    ##########################################################################
+
+    
+    def update(self, gtask):
+        body = gtask.gtask_dict
+        self.gtasks.task_update(gtask.get_tasklist(), gtask.get_id(), body)
+        
+    def get_task(self, gtask_id):
+        try:
+            gtask = self.get_gtasks_dict()[gtask_id]
+        except KeyError:
+            #in this case, we don't have yet the task in our local cache
+            # of what's on the gtasks website
+            self.refresh_gtasks_dict()
+            gtask = self.get_gtasks_dict()[gtask_id]
+        return gtask
+        
+    def get_gtasks_dict(self):
+        '''
+        Returns a dict of GTasksTasks. It will start authentication if necessary.
+        The dict is kept updated automatically.
+        '''
+        if not hasattr(self, '_gtask_dict'):
+            self.refresh_gtasks_dict()
+        else:
+            time_difference = datetime.datetime.now() - \
+                          self.__gtask_dict_timestamp
+            if time_difference.seconds > 60:
+                self.refresh_gtasks_dict()
+        return self._gtask_dict.copy()
+
+    def refresh_gtasks_dict(self):
+        '''
+        Builds a list of GTasksTasks fetched from GTasks
+        '''
+        if not self.is_authenticated():
+            self.start_authentication()
+            self.wait_for_authentication()
+
+        if not self.is_not_refreshing.isSet():
+            #if we're already refreshing, we just wait for that to happen and
+            # then we immediately return
+            self.is_not_refreshing.wait()
+            return
+            
+        self.is_not_refreshing.clear()
+        Log.debug('refreshing gtasks')
+        #our purpose is to fill this with "tasks_id: GTasksTask" items
+        gtasks_dict = {}
+
+        gtasklists_list = self.get_tasklists()
+        #for each gtasks list, we retrieve all the tasks in it
+        for gtasklist in gtasklists_list:
+                gtasks_list = self.list_tasks(gtasklist)
+                for gtask in gtasks_list:
+                    gtasks_dict[gtask.get('id')] = GTasksTask(gtask,
+                                                          gtasklist)
+
+        #we're done: we store the dict in this class and we annotate the time we
+        # got it
+        self._gtask_dict = gtasks_dict
+        self.__gtask_dict_timestamp = datetime.datetime.now()
+        self.is_not_refreshing.set()
+
+    def has_gtask(self, gtask_id):
+        '''
+        Returns True if we have seen that task id
+        '''
+        cache_result = gtask_id in self.get_gtasks_dict()
+        return cache_result
+
+    def create_new_gtask(self, title):
+        '''
+        Creates a new gtasks task
+        '''
+        
+        result = self.gtasks.task_create(tasklist=self.get_default_tasklist(), title=title)
+        gtask = GTasksTask(result,
+                            self.get_default_tasklist())
+        #adding to the dict right away
+        if hasattr(self, '_gtask_dict'):
+            #if the list hasn't been downloaded yet, we do not create a list,
+            # because the fact that the list is created is used to keep track of
+            # list updates
+            self._gtask_dict[gtask.get_id()] = gtask
+        return gtask
+        
+    def delete(self, gtask):
+        self.gtasks.task_delete(gtask.get_tasklist(), gtask.get_id())
+
+###############################################################################
+### GTasks TASK ##################################################################
+###############################################################################
+
+#dictionaries to translate a GTasks status into a GTG one (and back)
+GTG_TO_GTasks_STATUS = {Task.STA_ACTIVE: 'needsAction',
+                     Task.STA_DONE: 'completed',
+                     Task.STA_DISMISSED: 'deleted'}
+
+GTasks_TO_GTG_STATUS = {'needsAction': Task.STA_ACTIVE,
+                     'completed': Task.STA_DONE}
+
+
+
+class GTasksTask(object):
+    '''
+    A proxy object that encapsulates a GTasks task, giving an easier API to access
+    and modify its attributes.
+    This backend already uses a library to interact with GTasks, but that is just a
+    thin proxy for HTML gets and posts.
+    The meaning of all "special words"
+    
+    http://www.rememberthemilk.com/services/api/tasks.gtasks
+    '''
+    
+
+    def __init__(self, gtask, gtasklist):
+        '''
+        sets up the various parameters needed to interact with a task.
+
+        @param task: the task object given by the underlying library
+        @param gtasklist: the gtasks list the task resides in.
+        @param gtasks: a handle of the gtasks object, to be able to speak with gtasks.
+                    Authentication should have already been done.
+        '''
+        self.gtask_dict = gtask
+        self.gtasklist = gtasklist
+        
+    def get_tasklist(self):
+        return self.gtasklist
+        
+    def get_title(self):
+        '''Returns the title of the task, if any'''
+        title = self.gtask_dict.get('title')
+        if "(no title task)" == title:
+            return ""
+        return title
+
+    def set_title(self, title):
+        '''Sets the task title'''
+        title = cgi.escape(title)
+        self.gtask_dict['title'] = title
+
+    def get_id(self):
+        '''Return the task id. The taskseries id is *different*'''
+        return self.gtask_dict.get('id')
+
+    def get_status(self):
+        '''Returns the task status, in GTG terminology'''
+        return GTasks_TO_GTG_STATUS[self.gtask_dict.get('status')]
+
+    def set_status(self, gtg_status):
+        '''Sets the task status, in GTG terminology'''
+        status = GTG_TO_GTasks_STATUS[gtg_status]
+        self.gtask_dict['status'] = status
+        
+    def get_tags(self):
+        '''Returns the task tags 
+        TODO: implement parsing of txt tot get tags... gtasks does not support tags natively'''
+        return []
+        
+    def set_tags(self, tags):
+        '''
+        Sets a new set of tags to a task. Old tags are deleted.
+        TODO: implement parsing of txt tot get tags... gtasks does not support tags natively
+        '''
+        pass
+        
+    def get_text(self):
+        '''
+        Gets the content of GTasks notes, aggregated in a single string
+        '''
+        return self.gtask_dict.get('notes', '')
+
+    def set_text(self, notes):
+        '''
+        deletes all the old notes in a task and sets a single note with the
+        given text
+        '''
+        notes = cgi.escape(notes)
+        self.gtask_dict['notes'] = notes
+
+    def get_due_date(self):
+        '''
+        Gets the task due date
+        '''
+        due = self.gtask_dict.get('due')
+        if not due:
+            return Date.no_date()
+        date = self.__time_gtasks_to_datetime(due).date()
+        return Date(date)
+
+    def set_due_date(self, due):
+        '''
+        Sets the task due date
+        '''
+        due = self.__time_date_to_gtasks(due)
+        self.gtask_dict['due'] = due
+
+    def get_modified(self):
+        '''
+        Gets the task modified time, in local time
+        TODO: #correct
+        '''
+        return self.__time_gtasks_to_datetime(self.gtask_dict.get('updated'))
+
+    def __tz_utc_to_local(self, dt):
+        dt = dt.replace(tzinfo = tzutc())
+        dt = dt.astimezone(tzlocal())
+        return dt.replace(tzinfo = None)
+
+    def __tz_local_to_utc(self, dt):
+        dt = dt.replace(tzinfo = tzlocal())
+        dt = dt.astimezone(tzutc())
+        return dt.replace(tzinfo = None)
+
+    def __time_gtasks_to_datetime(self, string):
+        string = string.split('.')[0].split('Z')[0]
+        dt = datetime.datetime.strptime(string.split(".")[0], \
+                                          "%Y-%m-%dT%H:%M:%S")
+        return self.__tz_utc_to_local(dt)
+        
+    def __time_gtasks_to_date(self, string):
+        string = string.split('.')[0].split('Z')[0]
+        dt = datetime.datetime.strptime(string.split(".")[0], "%Y-%m-%d")
+        return self.__tz_utc_to_local(dt)
+
+    def __time_datetime_to_gtasks(self, timeobject):
+        if not timeobject:
+            return ""
+        timeobject = self.__tz_local_to_utc(timeobject)
+        return timeobject.strftime("%Y-%m-%dT%H:%M:%S")
+
+    def __time_date_to_gtasks(self, timeobject):
+        if not timeobject:
+            return ""
+        return timeobject.strftime("%Y-%m-%dT00:00:00.000Z")
+
+    def __str__(self):
+        return "Task %s (%s)" % (self.get_title(), self.get_id())

=== modified file 'GTG/backends/genericbackend.py'
--- GTG/backends/genericbackend.py	2013-02-25 08:12:02 +0000
+++ GTG/backends/genericbackend.py	2013-02-26 14:40:31 +0000
@@ -25,6 +25,7 @@
 import os
 import errno
 import pickle
+import base64
 import threading
 from collections import deque
 
@@ -195,6 +196,7 @@
                                # keyring
                                # This is just a key to find it there
     TYPE_STRING = "string"  # generic string, nothing fancy is done
+    TYPE_DICT = "dict"  # generic string, nothing fancy is done
     TYPE_INT = "int"  # edit box can contain only integers
     TYPE_BOOL = "bool"  # checkbox is shown
     TYPE_LIST_OF_STRINGS = "liststring"  # list of strings. the "," character
@@ -408,6 +410,8 @@
             if not isinstance(the_list, list):
                 the_list = [the_list]
             return the_list
+        elif param_type == cls.TYPE_DICT:
+            return pickle.loads(base64.b64decode(param_value))
         else:
             raise NotImplemented("I don't know what type is '%s'" %
                                  param_type)
@@ -430,6 +434,8 @@
             if param_value == []:
                 return ""
             return reduce(lambda a, b: a + "," + b, param_value)
+        elif param_type == GenericBackend.TYPE_DICT:
+            return base64.b64encode(pickle.dumps(param_value))
         else:
             return str(param_value)
 

=== added directory 'GTG/backends/gtasks'
=== added file 'GTG/backends/gtasks/__init__.py'
=== added file 'GTG/backends/gtasks/client_secrets.json'
--- GTG/backends/gtasks/client_secrets.json	1970-01-01 00:00:00 +0000
+++ GTG/backends/gtasks/client_secrets.json	2013-02-26 14:40:31 +0000
@@ -0,0 +1,1 @@
+{"installed":{"auth_uri":"https://accounts.google.com/o/oauth2/auth","client_secret":"CTOygFfphbQvJUiC6GiKFXFx","token_uri":"https://accounts.google.com/o/oauth2/token","client_email":"","redirect_uris":["urn:ietf:wg:oauth:2.0:oob","oob"],"client_x509_cert_url":"","client_id":"475130774009-9e3ddktfbfh2retat461nqr9ra4s42ad.apps.googleusercontent.com","auth_provider_x509_cert_url":"https://www.googleapis.com/oauth2/v1/certs"}}

=== added file 'GTG/backends/gtasks/gtasks.py'
--- GTG/backends/gtasks/gtasks.py	1970-01-01 00:00:00 +0000
+++ GTG/backends/gtasks/gtasks.py	2013-02-26 14:40:31 +0000
@@ -0,0 +1,170 @@
+
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Python library for Google Tasks
+# @author: Philipp A. Mohrenweiser
+# <[e-mail]>
+# http://gtasks.mohrenweiserpartner.de
+
+# For more information on the Tasks API API you can visit:
+#
+#   http://code.google.com/apis/tasks/v1/using.html
+#
+# For more information on the Tasks API API python library surface you
+# can visit:
+#
+#   https://google-api-client-libraries.appspot.com/documentation/tasks/v1/python/latest/
+#
+# For information on the Python Client Library visit:
+#
+#   https://developers.google.com/api-client-library/python/start/get_started
+
+import gflags
+import httplib2
+import logging
+import os
+import pprint
+import sys
+
+from apiclient.discovery import build
+from oauth2client.file import Storage
+from oauth2client.client import AccessTokenRefreshError
+from oauth2client.client import flow_from_clientsecrets
+from oauth2client.tools import run
+from xdg.BaseDirectory import xdg_config_home
+
+
+FLAGS = gflags.FLAGS
+
+# support user credentials
+user_credentials = os.path.join(xdg_config_home, 'gtg/backends/gtasks/client_secrets.json')
+if os.path.exists(user_credentials):
+    CLIENT_SECRETS = user_credentials
+else:
+    CLIENT_SECRETS = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'client_secrets.json')
+
+# Set up a Flow object to be used for authentication.
+# Add one or more of the following scopes. PLEASE ONLY ADD THE SCOPES YOU
+# NEED. For more information on using scopes please see
+# <https://developers.google.com/+/best-practices>.
+FLOW = flow_from_clientsecrets(CLIENT_SECRETS,
+    scope=[
+      'https://www.googleapis.com/auth/tasks',
+      'https://www.googleapis.com/auth/tasks.readonly',
+    ],
+    message="""You can add a own credentials file to:
+    %s
+    Get it from https://code.google.com/apis/console/
+    """ % (user_credentials))
+
+# Filename for token
+FILENAME = 'gmail_tags.dat'
+
+class GTasksError(Exception): pass
+
+class GTasksAPIError(GTasksError): pass
+
+class GTasks:
+    service = None
+    
+    def __init__(self, storage_dir=None):
+        if not storage_dir or not os.path.exists(storage_dir):
+            storage_dir = "."
+        path = os.path.join(storage_dir, FILENAME)
+        self.storage = Storage(path)
+        self.credentials = self.storage.get()
+    
+    def get_service(self):        
+        if not self.service:
+            if not self.is_valid():
+                self.run_flow()
+            http = httplib2.Http()
+            self.http = self.credentials.authorize(http)
+            self.service = build('tasks', 'v1', http=self.http)
+        return self.service
+        
+    def is_valid(self):
+        if self.credentials is None or self.credentials.invalid:
+            return False
+        return True
+        
+    def run_flow(self):
+        self.credentials = run(FLOW, self.storage)
+        
+    def refresh(self):
+        self.credentials.refresh()
+    
+    def execute(self, request):
+        try:
+            return request.execute(http=self.http)
+        except AccessTokenRefreshError:
+            self.auth()
+        
+    def tasklists_list(self):
+        return self.execute(self.get_service().tasklists().list())  
+        
+    def task_set_title(self, tasklist, task, title):
+        return self.execute(self.get_service().tasks().patch(tasklist=tasklist,task=task,body={title:title}))  
+    
+    def tasks_list(self, tasklist, showCompleted=None, dueMin=None, dueMax=None, showDeleted=None, updatedMin=None, pageToken=None, completedMax=None, maxResults=None, completedMin=None, showHidden=None):
+        return self.execute(self.get_service().tasks().list(tasklist=tasklist, showCompleted=showCompleted, dueMin=dueMin, dueMax=dueMax, showDeleted=showDeleted, updatedMin=updatedMin, pageToken=pageToken, completedMax=completedMax, maxResults=maxResults, completedMin=completedMin, showHidden=showHidden))
+
+    def task_create(self, tasklist, title, notes=""):
+        body = {
+            "status": "needsAction", # Status of the task. This is either "needsAction" or "completed".
+            "kind": "tasks#task", # Type of the resource. This is always "tasks#task".
+#            "parent": "A String", # Parent task identifier. This field is omitted if it is a top-level task. This field is read-only. Use the "move" method to move the task under a different parent or to the top level.
+            "title": title, # Title of the task.
+            "deleted": False, # Flag indicating whether the task has been deleted. The default if False.
+#            "completed": "A String", # Completion date of the task (as a RFC 3339 timestamp). This field is omitted if the task has not been completed.
+#            "updated": "A String", # Last modification time of the task (as a RFC 3339 timestamp).
+#            "due": "A String", # Due date of the task (as a RFC 3339 timestamp). Optional.
+#            "etag": "A String", # ETag of the resource.
+#            "id": "A String", # Task identifier.
+#            "position": "A String", # String indicating the position of the task among its sibling tasks under the same parent task or at the top level. If this string is greater than another task's corresponding position string according to lexicographical ordering, the task is positioned after the other task under the same parent task (or at the top level). This field is read-only. Use the "move" method to move the task to another position.
+#            "hidden": True or False, # Flag indicating whether the task is hidden. This is the case if the task had been marked completed when the task list was last cleared. The default is False. This field is read-only.
+            "notes": notes, # Notes describing the task. Optional.
+#            "selfLink": "A String", # URL pointing to this task. Used to retrieve, update, or delete this task.
+        }
+        return self.execute(self.get_service().tasks().insert(tasklist=tasklist,body=body))  
+        
+    def task_set_status(self, tasklist, task, status):
+        body = {
+            "status": status, # Status of the task. This is either "needsAction" or "completed".
+        }
+        return self.execute(self.get_service().tasks().patch(tasklist=tasklist,task=task, body=body))  
+        
+    def task_set_notes(self, tasklist, task, notes):
+        body = {
+            "notes": notes, # Status of the task. This is either "needsAction" or "completed".
+        }
+        return self.execute(self.get_service().tasks().patch(tasklist=tasklist,task=task, body=body))  
+        
+
+    def task_delete(self, tasklist, task):
+        return self.execute(self.get_service().tasks().delete(tasklist=tasklist,task=task))  
+        
+    def task_set_due(self, tasklist, task, due):
+        body = {
+            "due": due, # Status of the task. This is either "needsAction" or "completed".
+        }
+        return self.execute(self.get_service().tasks().patch(tasklist=tasklist,task=task, body=body))  
+        
+    def task_update(self, tasklist, task, body):
+        print body
+        return self.execute(self.get_service().tasks().update(tasklist=tasklist,task=task, body=body))  
+        

=== modified file 'GTG/gtk/backends_dialog/parameters_ui/__init__.py'
--- GTG/gtk/backends_dialog/parameters_ui/__init__.py	2013-02-25 07:35:07 +0000
+++ GTG/gtk/backends_dialog/parameters_ui/__init__.py	2013-02-26 14:40:31 +0000
@@ -28,13 +28,15 @@
 import functools
 
 from GTG import _
-from GTG.backends.genericbackend import GenericBackend
+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
+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.comboboxui   import ComboBoxUI
+from GTG.gtk.backends_dialog.parameters_ui.gtasklistsui   import ConfigGtasksUI
+from GTG.gtk.backends_dialog.parameters_ui.pathui       import PathUI
 
 
 class ParametersUI(gtk.VBox):
@@ -43,6 +45,7 @@
     widgets to view and edit a backend configuration
     '''
 
+
     COMMON_WIDTH = 170
 
     def __init__(self, requester):
@@ -54,75 +57,50 @@
         self.req = requester
         self.set_spacing(10)
 
-        # builds a list of widget generators. More precisely, it's a
+        #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)),
-            ("service-url", self.UI_generator(TextUI,
-                                              {"description": _("Service URL"),
-                                               "parameter_name": "service-url"
-                                               })),
-            ("import-from-replies", self.UI_generator(CheckBoxUI,
-                                                      {"text":
-                                                       _("Import tasks\
-                                                         from @ replies " +
+               ("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)),
+               ("service-url", self.UI_generator(TextUI,
+                            {"description": _("Service URL"),
+                             "parameter_name": "service-url"})),
+               ("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"})), )
+                             "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"})), 
+               ("gtask-tag-and-list-selection", self.UI_generator(ConfigGtasksUI,
+                            {"title": _("Please select lists to sync"),
+                             "parameter": "gtask-tag-and-list-selection"})), )
 
-    def UI_generator(self, param_type, special_arguments={}):
+    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
@@ -134,9 +112,9 @@
         @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,
+        return lambda backend: param_type(req = self.req,
+                                          backend = backend,
+                                          width = self.COMMON_WIDTH,
                                           **special_arguments)
 
     def refresh(self, backend):
@@ -145,14 +123,14 @@
 
         @param backend: the backend that is being configured
         '''
-        # remove the old parameters UIs
+        #remove the old parameters UIs
         def _remove_child(self, child):
             self.remove(child)
         self.foreach(functools.partial(_remove_child, self))
-        # add new widgets
+        #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
+            #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:

=== added file 'GTG/gtk/backends_dialog/parameters_ui/comboboxui.py'
--- GTG/gtk/backends_dialog/parameters_ui/comboboxui.py	1970-01-01 00:00:00 +0000
+++ GTG/gtk/backends_dialog/parameters_ui/comboboxui.py	2013-02-26 14:40:31 +0000
@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Getting Things GNOME! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2012 - 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 unicodedata
+
+
+class ComboBoxUI(gtk.HBox):
+    '''
+    It's a widget displaying a simple combobox, with some text to explain its
+    meaning
+    '''
+
+    def __init__(self, req, backend, width, text, parameter):
+        '''
+        Creates the combobox 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 combobox should display
+                           and modify
+        '''
+        super(ComboBoxUI, 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 combobox and the related label
+
+        @param width: the width of the gtk.Label object
+        '''
+        # we expect a list of tuples, formed the same way all!s
+        data = self.backend.get_liststore_data(self.parameter)        
+        types = [type(p) for p in data[0]]
+        name_store = gtk.ListStore(*types)
+        for d in data:
+            name_store.append(d)
+        self.combobox = gtk.ComboBox()
+        self.combobox.set_model(name_store)
+        self.combobox.set_entry_text_column(1)
+        self.combobox.connect("changed", self.on_modified)
+        renderer_text = gtk.CellRendererText()
+        self.combobox.pack_start(renderer_text, True)
+        self.combobox.add_attribute(renderer_text, "text", 1)
+        d_val = self.backend.get_parameters()[self.parameter]
+        if d_val != None:
+            i = 0
+            for mid, name in name_store:
+                if mid == d_val:
+                    self.combobox.set_active(i)
+                i=i+1
+        else:
+            #activate default
+            self.combobox.set_active(0)
+        self.box = gtk.HBox(spacing=6)
+        self.add(self.box)
+        self.label = gtk.Label("Please select a list where to sync gtg tasks to")
+        self.box.pack_start(self.label)
+        self.box.pack_start(self.combobox)
+        self.commit_changes() # have a default value set while asap
+
+    def commit_changes(self):
+        '''Saves the changes to the backend parameter'''
+        
+        tree_iter = self.combobox.get_active_iter()
+        if tree_iter != None:
+            model = self.combobox.get_model()
+            glist = model[tree_iter][0]
+            self.backend.set_parameter(self.parameter,
+                        glist)
+            
+
+    def on_modified(self, sender = None):
+        ''' Signal callback, executed when the user changes on the combobox.
+        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)
+        self.commit_changes()

=== added file 'GTG/gtk/backends_dialog/parameters_ui/gtasklistsui.py'
--- GTG/gtk/backends_dialog/parameters_ui/gtasklistsui.py	1970-01-01 00:00:00 +0000
+++ GTG/gtk/backends_dialog/parameters_ui/gtasklistsui.py	2013-02-26 14:40:31 +0000
@@ -0,0 +1,174 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Getting Things GNOME! - a personal organizer for the GNOME desktop
+# Copyright (c) 2008-2012 - 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 ConfigGtasksUI(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,
+                 parameter):
+        '''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(ConfigGtasksUI, self).__init__()
+        self.backend = backend
+        self.req = req
+        self.title = title
+        self.parameter = parameter
+        self._refresh_tasklists()
+        self._populate_gtk(width)
+        self.check_config()
+
+    def _populate_gtk(self, width):
+        '''
+        Populates the widgets
+
+        @param width: the length of the radio buttons
+        '''
+        self.treeview_tasklists = gtk.TreeView(self.liststore)
+
+        # list names
+        renderer_editabletext = gtk.CellRendererText()
+        renderer_editabletext.set_property("editable", True)
+
+        column_editabletext = gtk.TreeViewColumn("Listname",
+            renderer_editabletext, text=1)
+        self.treeview_tasklists.append_column(column_editabletext)
+
+        renderer_editabletext.connect("edited", self.title_edited)
+        
+        # sync_list
+        sync_toggle = gtk.CellRendererToggle()
+        sync_toggle.connect("toggled", self.on_sync_toggled)
+
+        column_toggle = gtk.TreeViewColumn("Sync", sync_toggle, active=2)
+        self.treeview_tasklists.append_column(column_toggle)
+        
+        # default_list
+        default_toggle = gtk.CellRendererToggle()
+        default_toggle.connect("toggled", self.on_default_toggled)
+        default_toggle.set_radio(True)
+
+        column_toggle = gtk.TreeViewColumn("Default", default_toggle, active=3)
+        self.treeview_tasklists.append_column(column_toggle)
+        
+        ### title
+        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)
+        vbox.pack_start(self.treeview_tasklists, True)
+        # # error label
+        self.error_label = gtk.Label()
+        self.error_label.set_alignment(xalign=0, yalign=0)
+        self.error_label.set_markup('<span color="red">%s</span>' % 'You have to select at least one list to sync\n and make a syncing list the default list\nto add new entrys to')
+        self.error_label.hide()
+        self.pack_start(self.error_label, True)
+        
+    def check_config(self):
+        if self.backend.has_valid_config():
+            self.error_label.hide()
+        else:
+            self.error_label.show()
+            
+    def on_sync_toggled(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
+        '''
+        self.req.set_backend_enabled(self.backend.get_id(), False)
+        self.liststore[data][2] = not self.liststore[data][2]
+        self._set_list_parameters(self.liststore[data][0], 'sync', self.liststore[data][2])
+        
+    def on_default_toggled(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
+        '''
+        self.req.set_backend_enabled(self.backend.get_id(), False)
+        i=0
+        for row in self.liststore:
+            row[3] = (i == int(data))
+            i=i+1
+            print "TYPE", type(row[3])
+            self._set_list_parameters(row[0], 'default', row[3])
+
+    def _set_list_parameters(self, iid, key, value):
+        d = self.backend.get_parameters()[self.parameter]
+        listconfig = d.get(iid, {})
+        listconfig[key] = value
+        d[iid] = listconfig
+        self.backend.set_parameter(self.parameter, d)
+        self.check_config()
+        
+    def title_edited(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'''
+        self.check_config()
+
+    def _refresh_tasklists(self):
+        '''
+        Refreshes the list of tasklists to display
+        '''
+        self.liststore = gtk.ListStore(str,str,bool,bool)
+        for iid, title in self.backend.get_tasklists().iteritems():
+            entry = self.backend.get_parameters()[self.parameter].get(iid, {}) 
+            self.liststore.append([iid, 
+                            title,
+                            entry.get('sync', False),
+                            entry.get('default', False)])