Merge lp:~cjohnston/gtg/bugfix-lp-531053 into lp:gtg/0.2

[Chris Johnston]

[Chris Johnston (cjohnston)]

Needs to be fixed in 0.2.2 as well.

=== modified file 'GTG/__init__.py'
--- GTG/__init__.py	2009-12-28 14:08:19 +0000
+++ GTG/__init__.py	2010-03-03 02:01:18 +0000
@@ -16,6 +16,10 @@
 # You should have received a copy of the GNU General Public License along with
 # this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------
+"""
+Getting Things Gnome!  A personal organizer for the GNOME desktop
+"""
+
 import os
 import locale
 #Fallback to LANG C if unsupported locale

=== modified file 'GTG/backends/__init__.py'
--- GTG/backends/__init__.py	2009-09-24 13:15:17 +0000
+++ GTG/backends/__init__.py	2010-03-03 02:01:18 +0000
@@ -18,10 +18,11 @@
 # -----------------------------------------------------------------------------
 
 
-#This is the backends package.
-#Backends are a way to store permanently a project on a medium
-# (like on the hard disk or on the internet)
-#and to read projects from this medium
+"""
+Backends are a way to store permanently a project on a medium
+(like on the hard disk or on the internet)
+and to read projects from this medium
+"""
 #
 #Current backends are :
 #

=== modified file 'GTG/backends/localfile.py'
--- GTG/backends/localfile.py	2009-12-03 09:47:09 +0000
+++ GTG/backends/localfile.py	2010-03-03 02:01:18 +0000
@@ -35,7 +35,7 @@
 def get_description():
     return "Your tasks are saved in an XML file located in your HOME folder"
 
-#Return a dictionnary of parameters. Keys should be strings and
+#Return a dictionary of parameters. Keys should be strings and
 #are the name of the parameter.
 #Value are string with value : string, password, int, bool
 #and are an information about the type of the parameter
@@ -48,17 +48,19 @@
 def get_features():
     return {}
 
-#Types is one of : readwrite, readonly,import,export
+#Types is one of : readwrite, readonly, import, export
 def get_type():
     return "readwrite"
 
-#The parameters dictionnary should match the dictionnary returned in
+#The parameters dictionary should match the dictionary returned in
 #get_parameters. Anyway, the backend should care if one expected value is
-#None or do not exist in the dictionnary.
+#None or do not exist in the dictionary.
 #firstrun is only needed for the default backend. You can ignore it.
 class Backend:
 
     def __init__(self, parameters, firstrunxml=None):
+        self.tids = []
+        self.pid = 1
         if "filename" in parameters:
             zefile = parameters["filename"]
         #If zefile is None, we create a new file
@@ -73,36 +75,39 @@
         else:
             self.zefile = zefile
             self.filename = zefile
-        #Create the defaut tasks for the first run.
+        #Create the default tasks for the first run.
         #We write the XML object in a file
         if firstrunxml and not os.path.exists(zefile):
             #shutil.copy(firstrunfile,self.zefile)
             cleanxml.savexml(self.zefile, firstrunxml)
         self.doc, self.xmlproj = cleanxml.openxmlfile(self.zefile, "project")
 
-    #Return the list of the task ID available in this backend
-    def get_tasks_list(self):
-        #time.sleep(2)
+    #Once this function is launched, the backend can start pushing tasks to gtg
+    #parameters : 
+    #1) push_task_func, a function that takes a Task as parameter and push it
+    #   into GTG.
+    #2) task_factory_func, a function that takes a tid as parameter and returns
+    #   a Task object with the given pid. 
+    #
+    # starst_get_tasks() might not return or finish
+    def start_get_tasks(self,push_task_func,task_factory_func):
         tid_list = []
         for node in self.xmlproj.childNodes:
-            tid_list.append(node.getAttribute("id"))
-        return tid_list
-
-
-    #Fill the task "task_to_fill" with the information of the task TID
-    #Return True if successful, False otherwhise
-    def get_task(self, task_to_fill, tid):
-#        import time
-#        time.sleep(1)
-        for node in self.xmlproj.childNodes:
-            if node.getAttribute("id") == tid:
-                return taskxml.task_from_xml(task_to_fill, node)
-        return task_to_fill
+            #time.sleep(2)
+            tid = node.getAttribute("id")
+            if tid not in self.tids:
+                self.tids.append(tid)
+            task = task_factory_func(tid)
+            task = taskxml.task_from_xml(task,node)
+            push_task_func(task)
+        #print "#### finishing pushing tasks"
 
     #Save the task in the backend
     def set_task(self, task):
         #time.sleep(4)
         tid = task.get_id()
+        if tid not in self.tids:
+            self.tids.append(tid)
         existing = None
         #First, we find the existing task from the treenode
         for node in self.xmlproj.childNodes:
@@ -132,6 +137,8 @@
         for node in self.xmlproj.childNodes:
             if node.getAttribute("id") == tid:
                 self.xmlproj.removeChild(node)
+                if tid in self.tids:
+                    self.tids.remove(tid)
         cleanxml.savexml(self.zefile, self.doc)
 
     #Return an available ID for a new task so that a task with this ID
@@ -139,7 +146,14 @@
     #If None, then GTG will create a new ID by itself
     #The ID cannot contain the character "@"
     def new_task_id(self):
-        return None
+        k = 0
+        pid = self.pid
+        newid = "%s@%s" %(k, pid)
+        while str(newid) in self.tids:
+            k += 1
+            newid = "%s@%s" %(k, pid)
+        self.tids.append(newid)
+        return newid
 
     #Called when GTG quit or disconnect the backend
     #You might pass here.

=== modified file 'GTG/core/__init__.py'
--- GTG/core/__init__.py	2009-12-28 15:30:05 +0000
+++ GTG/core/__init__.py	2010-03-03 02:01:18 +0000
@@ -18,30 +18,25 @@
 # -----------------------------------------------------------------------------
 
 
-#This is the core package. It contains the core of GTG.
-
-#Current files are :
-
-#datastore.py
-#------------
-#datastore is the heart of GTG. It contains a list of "TagSource".
-#Each TagSource is a proxy between a backend and the datastore itself
-#
-#tagstore.py
-#-----------
-#Tagstore is to tag as datastore is to task. Of course, the tagstore is easier
-#The Tag object is also provided in this file.
-#
-#task.py
-#-------
-#task.py contains the Task. A task represent, guess what,a task. 
-#
-#requester.py
-#---------
-#In order to not interact directly with the datastore, we provide "requesters"
-#The requester is only an interface and there can be as many requester as 
-#you want as long as they are all from the same datastore.
-#Requester also provides an interface for the tagstore
+"""
+The core functionality GTG.
+
+In order to not interact directly with the datastore, we provide
+"requesters".  The requester is only an interface and there can be as
+many requester as you want as long as they are all from the same
+datastore.  Requester also provides an interface for the tagstore
+
+If you want to display only a subset of tasks, you can either:
+
+ - have access to the main FilteredTree (the one displayed in the main
+   window) and apply filters on it.  (You can create your own)
+
+ - get your own personal FilteredTree and apply on it the filters you
+   want without interfering with the main view. (This is how the closed
+   tasks pane is built currently)
+
+"""
+
 
 #=== IMPORT ====================================================================
 import os

=== modified file 'GTG/core/datastore.py'
--- GTG/core/datastore.py	2010-02-22 08:32:54 +0000
+++ GTG/core/datastore.py	2010-03-03 02:01:18 +0000
@@ -17,13 +17,17 @@
 # this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------
 
+"""
+datastore contains a list of "TagSource", which are proxies between a backend and the datastore itself
+"""
+
 import threading
 import gobject
 import time
-import sys
 
 from GTG.core      import tagstore, requester
 from GTG.core.task import Task
+from GTG.core.tree import Tree
 
 
 #Only the datastore should access to the backend
@@ -37,105 +41,89 @@
 
     def __init__(self):
         self.backends = {}
-        self.tasks = {}
+        self.open_tasks = Tree()
+        self.closed_tasks = Tree()
         self.requester = requester.Requester(self)
         self.tagstore = tagstore.TagStore(self.requester)
 
     def all_tasks(self):
-        all_tasks = []
-        #We also add tasks that are still not in a backend (because of threads)
-        tlist = self.tasks.keys()
-        for t in tlist:
-            #NOTE: Sometimes tids are not found in the datastore, therefore
-            # the command "task = self.tasks[t]" fails. This is a temporary
-            # fix until the problem is understood  (Luca Invernizzi)
-            if not self.tasks.has_key(t):
-                sys.stderr.write('Tid does not exist in backend, skipping')
-                continue
-            task = self.tasks[t]
-            if task.is_loaded():
-                all_tasks.append(t)
-            else:
-                if task.get_status() == "Active":
-#                    print "task %s is not loaded" %task.get_id()
-#                    print task.get_title()
-                    self.get_task(task.get_id())
-        #print "%s tasks but we return %s" %(len(tlist),len(all_tasks))
-        return all_tasks
+        return self.open_tasks.get_all_keys()
 
     def has_task(self, tid):
-        return tid in self.tasks
+        return self.open_tasks.has_node(tid) or self.closed_tasks.has_node(tid)
 
     def get_task(self, tid):
-#        if tid == "46@1":
-#            print "getting 46@1"
-        if tid in self.tasks:
-            empty_task = self.tasks[tid]
-        else:
-            empty_task = self.new_task(tid, newtask=False)
-        if tid and not empty_task.is_loaded():
-            uid, pid = tid.split('@') #pylint: disable-msg=W0612
-            back = self.backends[pid]
-            task = back.get_task(empty_task, tid)
-        else:
-            task = empty_task
-        #If the task doesn't exist, we create it with a forced pid
-#        if not self.tasks[tid].is_loaded():
-#            print "tid %s - %s" %(tid,self.tasks[tid].get_title())
-#            for t in self.tasks:
-#                print self.tasks[t]
-#                print "----------------"
-#            print "###########################"
+        uid, pid = tid.split('@')
+        if self.has_task(tid):
+            task = self.__internal_get_task(tid)
+        else:
+            #print "no task %s" %tid
+            task = None
         return task
+        
+    def __internal_get_task(self, tid):
+        toreturn = self.open_tasks.get_node(tid)
+        if toreturn == None:
+            self.closed_tasks.get_node(tid)
+        #else:
+            #print "error : this task doesn't exist in either tree"
+            #pass
+        #we return None if the task doesn't exist
+        return toreturn
 
     def delete_task(self, tid):
-        if tid and tid in self.tasks:
-            self.tasks[tid].delete()
+        if tid and self.has_task(tid):
+            self.__internal_get_task(tid).delete()
             uid, pid = tid.split('@') #pylint: disable-msg=W0612
             back = self.backends[pid]
             #Check that the task still exist. It might have been deleted
             #by its parent a few line earlier :
-            if tid in self.tasks:
-                self.tasks.pop(tid)
+            if self.has_task(tid):
+                self.open_tasks.remove_node(tid)
+                self.closed_tasks.remove_node(tid)
             back.remove_task(tid)
-
-    #Create a new task and return it.
-    #newtask should be True if you create a task
-    #it should be False if you are importing an existing Task
-    def new_task(self, tid=None, pid=None, newtask=False):
-        #If we don't have anything, we use the default PID
+            return True
+            
+            
+    def new_task(self,pid=None):
         if not pid:
             pid = DEFAULT_BACKEND
-        #If tid, we force that tid and create a real new task
-        if tid and tid not in self.tasks:
-            task = Task(tid, self.requester, newtask=newtask)
-            bundle = tid.split('@') 
-            if not bundle:
-                sys.stderr.write('Tid does not exist in backend')
-                return None
-            uid, pid = bundle 
-            self.tasks[tid] = task
-            toreturn = task
-        #Else we create a new task in the given pid
-        elif not tid and pid and pid in self.backends:
+        newtid = self.backends[pid].new_task_id()
+        while self.has_task(newtid):
+            print "error : tid already exists"
             newtid = self.backends[pid].new_task_id()
-            task = Task(newtid, self.requester, newtask=newtask)
-            self.tasks[newtid] = task
-            task = self.backends[pid].get_task(task, newtid)
-            toreturn = task
-            tid = newtid
-        elif tid:
-            toreturn = self.tasks[tid]
-        else:
-            print "not possible to build the task = bug"
-            toreturn = None
-        return toreturn
+        task = Task(newtid, self.requester,newtask=True)
+        self.open_tasks.add_node(task)
+        task.set_sync_func(self.backends[pid].set_task,callsync=False)
+        return task
 
     def get_tagstore(self):
         return self.tagstore
 
     def get_requester(self):
         return self.requester
+        
+    def get_tasks_tree(self):
+        return self.open_tasks
+        
+    def push_task(self,task):
+        tid = task.get_id()
+        if self.has_task(tid):
+            print "pushing an existing task. We should care about modifications"
+        else:
+            uid, pid = tid.split('@')
+            self.open_tasks.add_node(task)
+            task.set_loaded()
+            task.set_sync_func(self.backends[pid].set_task,callsync=False)
+    
+    def task_factory(self,tid):
+        task = None
+        if self.has_task(tid):
+            print "error : tid already exists"
+        else:
+            task = Task(tid, self.requester, newtask=False)
+        return task
+            
 
     def register_backend(self, dic):
         if "backend" in dic:
@@ -146,7 +134,7 @@
             #Filling the backend
             #Doing this at start is more efficient than
             #after the GUI is launched
-            source.get_tasks_list(func=self.refresh_tasklist)
+            source.start_get_tasks(self.push_task,self.task_factory)
         else:
             print "Register a dic without backend key:  BUG"
 
@@ -159,12 +147,6 @@
             l.append(self.backends[key])
         return l
 
-    def refresh_tasklist(self, task_list):
-        for tid in task_list:
-            #Just calling new_task then get_task is enough
-            self.new_task(tid=tid)
-            self.get_task(tid)
-
 #Task source is an transparent interface between the real backend and datastore
 #Task source has also more functionnalities
 
@@ -173,223 +155,57 @@
     def __init__(self, backend, parameters):
         self.backend = backend
         self.dic = parameters
-        self.tasks = {}
-        self.time = time.time()
-        self.locks = lockslibrary()
-        self.tosleep = 0
-        self.backend_lock = threading.Lock()
-        self.removed = []
-        self.to_write = []
-        self.writing_lock = threading.Lock()
-        self.to_get = []
-        self.getting_lock = threading.Lock()
-
-##### The Backend interface ###############
-##########################################
-# All functions here are proxied from the backend itself
-
-    #Then test by putting some articial sleeps in the localfile.py
-    def get_tasks_list(self, func):
-
-        def getall():
-            #print "acquiring lock to getall"
-            self.backend_lock.acquire()
-            try:
-                #print "acquired lock to getall"
-                tlist = self.backend.get_tasks_list()
-                for t in tlist:
-                    self.locks.create_lock(t)
-            finally:
-                self.backend_lock.release()
-            #print "releasing lock  to getall"
-            func(tlist)
-        if THREADING:
-            t = threading.Thread(target=getall)
-            t.start()
-#            gobject.idle_add(getall)
-        else:
-            getall()
-        return None
-
-    def get_task(self, empty_task, tid):
-        #Our thread
-        def getting():
-            #self.locks.acquire(tid)
-            try:
-                while len(self.to_get) > 0:
-                    tid, empty_task = self.to_get.pop()
-                    #if self.locks.ifnotblocked(tid):
-                    self.backend.get_task(empty_task, tid)
-                    #calling sync in a thread might cause a segfault
-                    #thus callsync to false
-                    empty_task.set_sync_func(self.set_task, callsync=False)
-                    #set_loaded is a function that emits a signal.
-                    #Emiting a signal in a thread is likely to segfault
-                    #by wrapping it in idle_add, we ensure that gobject
-                    #mainloop handles the signal and not the tread itself.
-                    #it's not a problem to not know when it is executed
-                    #since it's the last instruction of the tread
-                    gobject.idle_add(empty_task.set_loaded)
-            finally:
-                #self.locks.release(tid)
-                self.getting_lock.release()
-        ##########
-        task = None
-        if tid in self.tasks:
-            task = self.tasks[tid]
-            if task:
-#                print "already existing"
-                empty_task = task
-            #this might not be needed
-                #gobject.idle_add(empty_task.set_loaded)
-        #We will not try to get a removed task
-        elif tid not in self.removed:
-            #By putting the task in the dic, we say:
-            #"This task is already fetched (or at least in fetching process)
-            self.tasks[tid] = False
-            self.to_get.append([tid, empty_task])
-            if self.getting_lock.acquire(False):
-# Disabling this to circumvent Bug #411420
-#                if THREADING:
-#                    self.locks.create_lock(tid)
-#                    gobject.idle_add(getting,empty_task,tid)
-#                    t = threading.Thread(target=getting)
-#                    t.start()
-#                else:
-#                    self.locks.create_lock(tid)
-#                    #getting(empty_task,tid)
-#                    getting()
-                getting()
-            self.tasks[tid] = empty_task
-        return empty_task
-
-    #only one thread is used to write the task
-    #if this thread is not started, we start it.
+        self.to_set = []
+        self.to_remove = []
+        self.lock = threading.Lock()
+        self.count_set = 0
+        
+    ### TaskSource/bakcend mapping
+    def start_get_tasks(self,push_task,task_factory):
+        func = self.backend.start_get_tasks
+        t = threading.Thread(target=func,args=(push_task,task_factory))
+        t.start()
+    
     def set_task(self, task):
-        self.to_write.append(task)
-        if self.writing_lock.acquire(False):
-            if THREADING:
-#               gobject.idle_add(self.__write,task)
-                t = threading.Thread(target=self.__write)
-                t.start()
-            else:
-                self.__write()
-        return None
-
-    #This function, called in a thread, write to the backend.
-    #It acquires a lock to avoid multiple thread writing at the same time
-    #the lock is writing_lock
-    def __write(self):
+        tid = task.get_id()
+        if task not in self.to_set and tid not in self.to_remove:
+            self.to_set.append(task)
+        if self.lock.acquire(False):
+            func = self.setting_thread
+            t = threading.Thread(target=func)
+            t.start()
+#        else:
+#            print "cannot acquire lock : not a problem, just for debug purpose"
+            
+    def setting_thread(self):
         try:
-            while len(self.to_write) > 0:
-                task = self.to_write.pop()
-                tid = task.get_id()
-                if tid not in self.removed:
-#                    self.locks.acquire(tid)
-#                    try:
-#                    print self.locks.acquire(tid)
-                    self.backend.set_task(task)
-#                    finally:
-#                    self.locks.release(tid)
+            while len(self.to_set) > 0:
+                t = self.to_set.pop(0)
+                tid = t.get_id()
+                if tid not in self.to_remove:
+                    self.count_set += 1
+                    #print "saving task %s (%s saves)" %(tid,self.count_set)
+                    self.backend.set_task(t)
+            while len(self.to_remove) > 0:
+                tid = self.to_remove.pop(0)
+                self.backend.remove_task(tid)
         finally:
-            self.writing_lock.release()
-
-    #TODO : This has to be threaded too
+            self.lock.release()
+    
     def remove_task(self, tid):
-        self.backend_lock.acquire()
-        try:
-            if tid not in self.removed:
-                self.removed.append(tid)
-            if self.locks.acquire(tid):
-                toreturn = self.backend.remove_task(tid)
-                self.tasks.pop(tid)
-                self.locks.remove_lock(tid)
-            else:
-                toreturn = False
-        finally:
-            self.backend_lock.release()
-        return toreturn
-
-    #TODO: This has to be threaded too
+        if tid not in self.to_remove:
+            self.to_remove.append(tid)
+        if self.lock.acquire(False):
+            func = self.setting_thread
+            t = threading.Thread(target=func)
+            t.start()
+    
     def new_task_id(self):
-        newid = self.backend.new_task_id()
-        if not newid:
-            k = 0
-            pid = self.dic["pid"]
-            newid = "%s@%s" %(k, pid)
-            while str(newid) in self.tasks:
-                k += 1
-                newid = "%s@%s" %(k, pid)
-        if newid in self.removed:
-            self.removed.remove(newid)
-        self.locks.create_lock(newid)
-        return newid
-
-    #TODO : This has to be threaded too
+        return self.backend.new_task_id()
+    
     def quit(self):
-        return self.backend.quit()
-
-########## End of Backend interface ###########
-###############################################
-
-#Those functions are only for TaskSource
+        self.backend.quit()
+        
+    #Those functions are only for TaskSource
     def get_parameters(self):
         return self.dic
-
-#This is the lock library. Each task has a lock to avoir concurrency
-#on the same task when writing/reading on/from the backend
-
-class lockslibrary:
-
-    def __init__(self):
-        self.locks = {}
-        #The lock library itself is protected by a lock to avoid deadlock
-        self.glob = threading.Lock()
-
-    def create_lock(self, tid):
-        self.glob.acquire()
-        try:
-            if tid not in self.locks:
-                self.locks[tid] = threading.Lock()
-        finally:
-            self.glob.release()
-
-    #To be removed, a lock should be acquired before !
-    #So acquire the lock before calling this function !
-    def remove_lock(self, tid):
-        if self.glob.acquire(False):
-            if tid in self.locks:
-                zelock = self.locks[tid]
-                self.locks.pop(tid)
-                zelock.release()
-            self.glob.release()
-        #else:
-        #print "This is a very rare bug : we were unable to remove the lock"
-        #But this not really a problem because the lock alone does do anything
-    def ifnotblocked(self, tid):
-        self.glob.acquire()
-        try:
-            if tid in self.locks:
-                return self.locks[tid].acquire(False)
-            else:
-                print "ifnotblock on non-existing lock %s = BUG" %tid
-        finally:
-            self.glob.release()
-
-    def acquire(self, tid):
-        self.glob.acquire()
-        try:
-            if tid in self.locks:
-                self.locks[tid].acquire()
-                toreturn = True
-            else:
-                toreturn = False
-        finally:
-            self.glob.release()
-        return toreturn
-
-    def release(self, tid):
-        if tid in self.locks:
-            self.locks[tid].release()
-#        else:
-#            print "removing non-existing lock = BUG"

=== removed file 'GTG/core/dbuswrapper.py'
--- GTG/core/dbuswrapper.py	2010-02-27 03:45:52 +0000
+++ GTG/core/dbuswrapper.py	1970-01-01 00:00:00 +0000
@@ -1,168 +0,0 @@
-import dbus
-import dbus.glib
-import dbus.service
-import unicodedata
-
-from GTG.core import CoreConfig
-from GTG.tools import dates
-
-BUSNAME = CoreConfig.BUSNAME
-BUSFACE = CoreConfig.BUSINTERFACE
-
-
-def dsanitize(data):
-    # Clean up a dict so that it can be transmitted through D-Bus
-    for k, v in data.items():
-        # Manually specify an arbitrary content type for empty Python arrays
-        # because D-Bus can't handle the type conversion for empty arrays
-        if not v and isinstance(v, list):
-            data[k] = dbus.Array([], "s")
-        # D-Bus has no concept of a null or empty value so we have to convert
-        # None types to something else. I use an empty string because it has
-        # the same behavior as None in a Python conditional expression
-        elif v == None:
-            data[k] = ""
-
-    return data
-
-
-def task_to_dict(task):
-    # Translate a task object into a D-Bus dictionary
-    return dbus.Dictionary(dsanitize({
-          "id": task.get_id(),
-          "status": task.get_status(),
-          "title": task.get_title(),
-          "duedate": str(task.get_due_date()),
-          "startdate": str(task.get_start_date()),
-          "donedate": str(task.get_closed_date()),
-          "tags": task.get_tags_name(),
-          "text": task.get_text(),
-          "subtask": task.get_subtask_tids(),
-          }), signature="sv")
-
-
-class DBusTaskWrapper(dbus.service.Object):
-
-    # D-Bus service object that exposes GTG's task store to third-party apps
-    def __init__(self, req, ui):
-        # Attach the object to D-Bus
-        self.bus = dbus.SessionBus()
-        bus_name = dbus.service.BusName(BUSNAME, bus=self.bus)
-        dbus.service.Object.__init__(self, bus_name, BUSFACE)
-        self.req = req
-        self.ui = ui
-
-
-    @dbus.service.method(BUSNAME,in_signature="s")
-    def get_task_ids(self, status_string):
-        # Retrieve a list of task ID values
-        status = [s.strip() for s in status_string.split(',')]
-        #need to convert the statuses to ascii (these are given in unicode)
-        status = [unicodedata.normalize('NFKD', s).encode('ascii','ignore') \
-                  for s in status]
-        return self.req.get_tasks_list(status = status)
-
-    @dbus.service.method(BUSNAME)
-    def get_task(self, tid):
-        # Retrieve a specific task by ID and return the data
-        toret = task_to_dict(self.req.get_task(tid))
-        return toret
-
-    @dbus.service.method(BUSNAME)
-    def get_tasks(self):
-        # Retrieve a list of task data dicts
-        return [self.get_task(id) for id in self.get_task_ids(u"Active")]
-
-    @dbus.service.method(BUSNAME, in_signature="asasbb")
-    def get_task_ids_filtered(self, tags, status, started_only, is_root):
-        # Retrieve a list of task IDs filtered by specified parameters
-        tags_obj = []
-        for t in tags:
-            zetag = self.req.get_tag(t)
-            if zetag:
-                tags_obj.append(zetag)
-        ids = self.req.get_tasks_list(
-            tags_obj, status, False, started_only, is_root)
-        # If there are no matching tasks, return an empty D-Bus array
-        return ids if ids else dbus.Array([], "s")
-
-    @dbus.service.method(BUSNAME, in_signature="asasbb")
-    def get_tasks_filtered(self, tags, status, started_only, is_root):
-        # Retrieve a list of task data dicts filtered by specificed parameters
-        tasks = self.get_task_ids_filtered(
-            tags, status, started_only, is_root)
-        # If no tasks match the filter, return an empty D-Bus array
-        if tasks:
-            return [self.get_task(id) for id in tasks]
-        else:
-            return dbus.Array([], "s")
-
-    @dbus.service.method(BUSNAME)
-    def has_task(self, tid):
-        return self.req.has_task(tid)
-
-    @dbus.service.method(BUSNAME)
-    def delete_task(self, tid):
-        self.req.delete_task(tid)
-
-    @dbus.service.method(BUSNAME, in_signature="sssssassas")
-    def new_task(self, status, title, duedate, startdate, donedate, tags,
-                 text, subtasks):
-        # Generate a new task object and return the task data as a dict
-        tags_objects = []
-        for t in tags:
-            #we have to create the tag objects if we don't have them
-            tag_object = self.req.get_tag(t)
-            if tag_object == None:
-                tag_object = self.req.new_tag(t)
-            tags_objects.append(tag_object)
-        nt = self.req.new_task(tags=tags_objects)
-        for sub in subtasks:
-            nt.add_subtask(sub)
-        nt.set_status(status, donedate=dates.strtodate(donedate))
-        nt.set_title(title)
-        nt.set_due_date(dates.strtodate(duedate))
-        nt.set_start_date(dates.strtodate(startdate))
-        nt.set_text(text)
-        return task_to_dict(nt)
-
-    @dbus.service.method(BUSNAME)
-    def modify_task(self, tid, task_data):
-        # Apply supplied task data to the task object with the specified ID
-        task = self.req.get_task(tid)
-        task.set_status(task_data["status"], donedate=task_data["donedate"])
-        task.set_title(task_data["title"])
-        task.set_due_date(dates.strtodate(task_data["duedate"]))
-        task.set_start_date(dates.strtodate(task_data["startdate"]))
-        task.set_text(task_data["text"])
-
-        for tag in task_data["tags"]:
-            task.add_tag(tag)
-        for sub in task_data["subtask"]:
-            task.add_subtask(sub)
-        return task_to_dict(task)
-
-    @dbus.service.method(BUSNAME)
-    def open_task_editor(self, tid):
-        self.ui.open_task(tid)
-        
-    @dbus.service.method(BUSNAME, in_signature="ss")
-    def open_new_task(self, title, description):
-        nt = self.req.new_task(newtask=True)
-        nt.set_title(title)
-        if description != "":
-            nt.set_text(description)
-        uid = nt.get_id()
-        self.ui.open_task(uid,thisisnew=True)
-
-    @dbus.service.method(BUSNAME)
-    def hide_task_browser(self):
-        self.ui.window.hide()
-
-    @dbus.service.method(BUSNAME)
-    def show_task_browser(self):
-        self.ui.window.present()
-        self.ui.window.move(
-          self.ui.priv["window_xpos"], self.ui.priv["window_ypos"])
-        gdk_window = self.ui.window
-        gdk_window.show()

=== added file 'GTG/core/filteredtree.py'
--- GTG/core/filteredtree.py	1970-01-01 00:00:00 +0000
+++ GTG/core/filteredtree.py	2010-03-03 02:01:18 +0000
@@ -0,0 +1,594 @@
+# -*- 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/>.
+# -----------------------------------------------------------------------------
+#
+"""
+FilteredTree provides a filtered view (subset) of tasks
+
+FilteredTree
+============
+The problem we have is that, sometimes, we don't want to display all tasks.
+We want tasks to be filtered (workview, tags, …)
+
+The expected approach would be to put a gtk.TreeModelFilter above our
+TaskTree. Unfortunatly, this doesn't work because TreeModelFilter hides
+all children of hidden nodes (not what we want!)
+
+The solution we have found is to insert a fake tree between Tree and
+TaskTree.  This fake tree is called FilteredTree and will map path and
+node methods to a result corresponding to the filtered tree.
+
+Note that the nodes are not aware that they are in a filtered tree.
+Use the FilteredTree methods, not the node methods directly.
+If you believe a function would be useful in a filtered tree, don't 
+hesitate to make a proposal.
+
+To be more efficient, a quick way to optimize the FilteredTree is to cache
+all answers in a dictionary so we don't have to compute the answer 
+all the time. This is not done yet.
+
+B{Warning}: this is very fragile. Calls to any GTK registered view should be
+perfecly in sync with changes in the underlying model.
+We definitely should develop some unit tests for this class.
+
+Structure of the source:
+
+ 1. Standard tree functions mapping (get_node, get_all_nodes, get_all_keys)
+ 2. Receiving signal functions ( task-added,task-modified,task-deleted)
+ 3. Treemodel helper functions. To make it easy to build a treemodel on top.
+ 4. Filtering : is_displayed() and refilter()
+ 5. Changing the filters (not for the main FilteredTree)
+ 6. Private helpers.
+
+There's one main FilteredTree that you can get through the requester. This
+main FilteredTree does use the filters applied throught the requester. This
+allow plugin writers to easily get the current displayed tree (main View).
+
+For custom views, the plugin writers are able to get their own
+FilteredTree and apply on it the filters they want. (this is not finished
+yet but in good shape).
+
+"""
+
+import gobject
+
+class FilteredTree(gobject.GObject):
+
+    #Those are the three signals you want to catch if displaying
+    #a filteredtree. The argument of all signals is the tid of the task
+    __gsignals__ = {'task-added-inview': (gobject.SIGNAL_RUN_FIRST, \
+                                          gobject.TYPE_NONE, (str, )),
+                    'task-deleted-inview': (gobject.SIGNAL_RUN_FIRST, \
+                                            gobject.TYPE_NONE, (str, )),
+                    'task-modified-inview': (gobject.SIGNAL_RUN_FIRST, \
+                                            gobject.TYPE_NONE, (str, )),}
+
+    def __init__(self,req,tree,maintree=False):
+        """
+        Construct a FilteredTree object on top of an existing task tree.
+        @param req: The requestor object
+        @param tree: The tree to filter from
+        @param maintree: Whether this tree is the main tree.  The requester
+        must be used to change filters against the main tree.
+        """
+        gobject.GObject.__init__(self)
+        self.is_main = maintree
+        self.applied_filters = []
+        self.req = req
+        self.tree = tree
+        self.update_count = 0
+        self.add_count = 0
+        self.remove_count = 0
+        #virtual root is the list of root nodes
+        #initially, they are the root nodes of the original tree
+        self.virtual_root = []
+        self.displayed_nodes = []
+        #useful for temp storage :
+        self.node_to_add = []
+        #it looks like an initial refilter is not needed.
+        #self.refilter()
+        self.__reset_cache()
+        #connecting
+        self.req.connect("task-added", self.__task_added)
+        self.req.connect("task-modified", self.__task_modified)
+        self.req.connect("task-deleted", self.__task_deleted)
+
+    def __reset_cache(self):
+        self.path_for_node_cache = {}
+
+    #### Standard tree functions
+    def get_node(self,id):
+        """
+        Retrieves the given node
+        @param id: The tid of the task node
+        @return: Node from the underlying tree
+        """
+        return self.tree.get_node(id)
+    
+    def get_root(self):
+        """
+        returns the root node
+        """
+        return self.tree.get_root()
+        
+    def get_all_keys(self):
+        """
+        returns list of all displayed node keys
+        """
+        return list(self.displayed_nodes)
+        
+    def get_all_nodes(self):
+        """
+        returns list of all nodes
+        """
+        k = []
+        for n in self.get_all_nodes():
+            k.append(self.get_node(n))
+        return k
+        
+    def get_n_nodes(self):
+        """
+        returns quantity of displayed nodes in this tree
+        """
+        return len(self.displayed_nodes)
+        
+    ### signals functions
+    def __task_added(self,sender,tid):
+        todis = self.__is_displayed(tid)
+        curdis = self.is_displayed(tid)
+        if todis and not curdis:
+            self.__add_node(tid)
+        
+    def __task_modified(self,sender,tid):
+        todis = self.__is_displayed(tid)
+        curdis = self.is_displayed(tid)
+        if todis:
+            #if the task was not displayed previously but now should
+            #we add it.
+            if not curdis:
+                self.__add_node(tid)
+            #There doesn't seem to be a need for calling the update_node
+#            else:
+#                task = self.get_node(tid)
+#                inroot = self.__is_root(task)
+#                self.__update_node(tid,inroot)
+        else:
+            #if the task was displayed previously but shouldn't be anymore
+            #we remove it
+            if curdis:
+                self.__remove_node(tid)
+        
+    def __task_deleted(self,sender,tid):
+        self.__remove_node(tid)
+        
+    ####TreeModel functions ##############################
+
+    #The path received is only for tasks that are displayed
+    #We have to find the good node.
+    def get_node_for_path(self, path):
+        """
+        Returns node for the given path.
+        """
+        #We should convert the path to the base.path
+        if str(path) == '()':
+            print "WE SHOULD RETURN ROOT NODE"
+        p0 = path[0]
+        if len(self.virtual_root) > p0:
+            n1id = self.virtual_root[p0]
+            n1 = self.get_node(n1id)
+            pa = path[1:]
+            toreturn = self.__node_for_path(n1,pa)
+        else:
+            toreturn = None
+        return toreturn
+
+    def __node_for_path(self,basenode,path):
+        if len(path) == 0:
+            return basenode
+        elif path[0] < self.node_n_children(basenode):
+            if len(path) == 1:
+                return self.node_nth_child(basenode,path[0])
+            else:
+                node = self.node_nth_child(basenode,path[0])
+                path = path[1:]
+                return self.__node_for_path(node, path)
+        else:
+            return None
+
+    def get_path_for_node(self, node):
+        """
+        Return a path for a given node
+        """
+        #For that node, we should convert the base_path to path
+        if not node or not self.is_displayed(node.get_id()):
+            return None
+        #This is the cache so we don't compute it all the time
+        elif self.path_for_node_cache.has_key(node):
+            return self.path_for_node_cache[node]
+        elif node == self.get_root():
+            toreturn = ()
+        elif node.get_id() in self.virtual_root:
+            ind = self.virtual_root.index(node.get_id())
+            toreturn = (ind,)
+        #The node is not a virtual root
+        else:
+            pos = 0
+            par = self.node_parent(node)
+            max = self.node_n_children(par)
+            child = self.node_children(par)
+            while pos < max and node != child:
+                pos += 1
+                child = self.node_nth_child(par,pos)
+            par_path = self.get_path_for_node(par)
+            if par_path:
+                toreturn = par_path + (pos,)
+            else:
+                print "*** Node %s not in vr and no path for parent" %(node.get_id())
+                print "*** please report a bug against FilteredTree"
+                toreturn = None
+        #print "get_path_for_node %s is %s" %(node.get_id(),str(toreturn))
+#        self.path_for_node_cache[node] = toreturn
+        return toreturn
+
+    #Done
+    def next_node(self, node):
+        """
+        Returns the next sibling node, or None if there are no other siblings
+        """
+        #print "on_iter_next for node %s" %node
+        #We should take the next good node, not the next base node
+        if node:
+            tid = node.get_id()
+            if tid in self.virtual_root:
+                i = self.virtual_root.index(tid) + 1
+                if len(self.virtual_root) > i:
+                    nextnode_id = self.virtual_root[i]
+                    nextnode = self.get_node(nextnode_id)
+                else:
+                    nextnode = None
+            else:
+                parent_node = self.node_parent(node)
+                if parent_node:
+                    next_idx = parent_node.get_child_index(node.get_id()) + 1
+                    total = parent_node.get_n_children()-1
+                    if total < next_idx:
+                        nextnode = None
+                    else:
+                        nextnode = parent_node.get_nth_child(next_idx)
+                        while next_idx < total and not self.is_displayed(nextnode.get_id()):
+                            next_idx += 1
+                            nextnode = parent_node.get_nth_child(next_idx)
+                else:
+                    nextnode = None
+        else:
+            nextnode = None
+        return nextnode
+
+    #Done
+    def node_children(self, parent):
+        """
+        Returns the first child node of the given parent, or None
+        if the parent has no children.
+        @param parent: The parent node or None to retrieve the children
+        of the virtual root.
+        """
+        #print "on_iter_children for parent %s" %parent.get_id()
+        #here, we should return only good childrens
+        if parent:
+            if self.node_has_child(parent):
+                 child = self.node_nth_child(parent,0)
+            else:
+                #The spec says that the child can be None
+                child = None
+        else:
+            child = self.virtual_root[0]
+        return child
+
+    #Done
+    def node_has_child(self, node):
+        """
+        Returns true if the given node has any children
+        """
+        #print "on_iter_has_child for node %s" %node
+        #we should say "has_good_child"
+        if node and self.node_n_children(node)>0:
+            return True
+        else:
+            if not node:
+                print "NODE IS NULL, we should maybe return True"
+            return False
+
+    #Done
+    def node_n_children(self, node):
+        """
+        Returns number of children for the given node
+        """
+        #we should return the number of "good" children
+        if not node:
+            toreturn = len(self.virtual_root)
+            id = 'root'
+        else:
+            n = 0
+            for cid in node.get_children():
+                if self.is_displayed(cid):
+                    n+= 1
+            toreturn = n
+        return toreturn
+
+    #Done
+    def node_nth_child(self, node, n):
+        """
+        Retrieves the nth child of the node.
+        @param node: The parent node, or None to look at children of the
+        virtual_root.
+        """
+        #we return the nth good children !
+        if not node:
+            if len(self.virtual_root) > n:
+                to_id = self.virtual_root[n]
+                toreturn = self.get_node(to_id)
+            else:
+                toreturn = None
+        else:
+            total = node.get_n_children()
+            cur = 0
+            good = 0
+            toreturn = None
+            while good <= n and cur < total:
+                curn = node.get_nth_child(cur)
+                if curn and self.is_displayed(curn.get_id()):
+                    if good == n:
+                        toreturn = curn
+                    good += 1
+                cur += 1
+        return toreturn
+
+    #Done
+    def node_parent(self, node):
+        """
+        Returns parent of the given node, or None if there is no 
+        parent (such as if the node is a child of the virtual root),
+        or if the parent is not displayable.
+        """
+        #return None if we are at a Virtual root
+        tid = node.get_id()
+        if node and tid in self.virtual_root:
+            return None
+        elif node and node.has_parent():
+            parent_id = node.get_parent()
+            parent = self.tree.get_node(parent_id)
+            if parent == self.tree.get_root():
+                return None
+            elif self.is_displayed(parent_id):
+                return parent
+            else:
+                return None
+        else:
+            return None
+
+
+    #### Filtering methods #########
+    
+    def is_displayed(self,tid):
+        """
+        This is a public method that return True if the task is
+        currently displayed in the tree
+        """
+        if tid:
+            return tid in self.displayed_nodes
+        else:
+            toreturn = False
+        return toreturn
+    
+    def __is_displayed(self, tid):
+        """
+        This is a private method that return True if the task *should*
+        be displayed in the tree, regardless of its current status
+        """
+        if tid:
+            result = True
+            for f in self.applied_filters:
+                filt = self.req.get_filter(f)
+                if filt:
+                    result = result and filt.is_displayed(tid)
+            return result
+        else:
+            return False
+        
+    def refilter(self):
+        """
+        rebuilds the tree from scratch. It should be called only when 
+        the filter is changed (i.e. only filters_bank should call it).
+        """
+        self.update_count = 0
+        self.add_count = 0
+        self.remove_count = 0
+        virtual_root2 = []
+        to_add = []
+        #First things, we list the nodes that will be
+        #ultimately displayed
+        for n in self.tree.get_all_nodes():
+            tid = n.get_id()
+            is_root = False
+            if self.__is_displayed(tid):
+                to_add.append(tid)
+                is_root = self.__is_root(n)
+            #and we care about those who will be virtual roots
+            #(their parents are not displayed)
+            if is_root and tid not in virtual_root2:
+                virtual_root2.append(tid)
+        
+        #Second step, we empty the current tree as we will rebuild it
+        #from scratch
+        for rid in list(self.virtual_root):
+            n = self.get_node(rid)
+            self.__clean_from_node(n)
+        self.__reset_cache()
+
+        #Here, we reconstruct our filtered trees. It  cannot be random
+        # Parents should be added before their children
+        #First, we start we the nodes in the virtual root
+        for nid in list(to_add):
+            isroot = nid in virtual_root2
+            self.__add_node(nid,isroot)
+        #end of refiltering
+
+    ####### Change filters #################
+    def apply_filter(self,filter_name,parameters=None,imtherequester=False):
+        """
+        Applies a new filter to the tree.  Can't be called on the main tree.
+        @param filter_name: The name of an already registered filter to apply
+        @param parameters: Optional parameters to pass to the filter
+        @param imtherequester: If true enables adding filters to the main tree
+        """
+        if self.is_main and not imtherequester:
+            print "Error : use the requester to apply a filter to the main tree"
+            print "We don't do that automatically on purpose"
+        else:
+            if parameters:
+                filt = self.req.get_filter(filter_name)
+                if filt:
+                    filt.set_parameters(parameters)
+            if filter_name not in self.applied_filters:
+                self.applied_filters.append(filter_name)
+                self.refilter()
+                return True
+        return False
+    
+    def unapply_filter(self,filter_name,imtherequester=False):
+        """
+        Removes a filter from the tree.  Can't be called on the main tree.
+        @param filter_name: The name of an already added filter to remove
+        @param imtherequester: If true enables removing filters from the main tree
+        """
+        if self.is_main and not imtherequester:
+            print "Error : use the requester to remove a filter to the main tree"
+            print "We don't do that automatically on purpose"
+        elif filter_name in self.applied_filters:
+            self.applied_filters.remove(filter_name)
+            self.refilter()
+            return True
+        return False
+
+    def reset_filters(self,imtherequester=False):
+        """
+        Clears all filters currently set on the tree.  Can't be called on 
+        the main tree.
+        @param imtherequester: If true enables clearing filters from the main tree
+        """
+        if self.is_main and not imtherequester:
+            print "Error : use the requester to remove a filter to the main tree"
+            print "We don't do that automatically on purpose"
+        else:
+            self.applied_filters = []
+            self.refilter()
+
+    def reset_tag_filters(self,refilter=True,imtherequester=False):
+        """
+        Clears all filters currently set on the tree.  Can't be called on 
+        the main tree.
+        @param imtherequester: If true enables clearing filters from the main tree
+        """
+        if self.is_main and not imtherequester:
+            print "Error : use the requester to remove a filter to the main tree"
+            print "We don't do that automatically on purpose"
+        else:
+            if "notag" in self.applied_filters:
+                self.applied_filters.remove('notag')
+            for f in self.applied_filters:
+                if f.startswith('@'):
+                    self.applied_filters.remove(f)
+            if refilter:
+                self.refilter()
+
+    ####### Private methods #################
+
+    # Return True if the node should be a virtual root node
+    # regardless of the current state
+    def __is_root(self,n):
+        is_root = True
+        if n.has_parent():
+            for par in n.get_parents():
+                if self.__is_displayed(par):
+                    is_root = False
+        return is_root
+    
+    # Put or remove a node from the virtual root
+    def __root_update(self,tid,inroot):
+        if inroot:
+            if tid not in self.virtual_root:
+                self.virtual_root.append(tid)
+        else:
+            if tid in self.virtual_root:
+                self.virtual_root.remove(tid)
+    
+    def __update_node(self,tid,inroot):
+        self.update_count += 1
+        self.__root_update(tid,inroot)
+        self.emit("task-modified-inview", tid)
+    
+    def __add_node(self,tid,inroot=None):
+        self.add_count += 1
+        if not self.is_displayed(tid):
+            node = self.get_node(tid)
+            if inroot == None:
+                inroot = self.__is_root(node)
+            #If the parent's node is not already displayed, we wait
+            if not inroot and not self.node_parent(node):
+                self.node_to_add.append(tid)
+            else:
+                self.__root_update(tid,inroot)
+                self.displayed_nodes.append(tid)
+                self.emit("task-added-inview", tid)
+                #We added a new node so we can check with those waiting
+                if len(self.node_to_add) > 0:
+                    n = self.node_to_add.pop(0)
+                    #node still to add cannot be root
+                    self.__add_node(n,False)
+    
+    def __remove_node(self,tid):
+        self.remove_count += 1
+        self.emit('task-deleted-inview',tid)
+        self.__root_update(tid,False)
+        if tid in self.displayed_nodes:
+            self.displayed_nodes.remove(tid)
+        self.__reset_cache()
+        #Test if this is necessary
+        parent = self.node_parent(self.get_node(tid))
+        if parent:
+            inroot = self.__is_root(parent)
+            self.__update_node(parent.get_id(),inroot)
+        
+    #This function print the actual tree. Useful for debugging
+    def __print_from_node(self, node, prefix=""):
+        print prefix + node.get_id()
+        prefix = prefix + "->"
+        if self.node_has_child(node):
+            child = self.node_children(node)
+            while child:
+                self._print_from_node(child,prefix)
+                child = self.next_node(child)
+    
+    #This function removes all the nodes, leaves first.
+    def __clean_from_node(self, node):
+        if self.node_has_child(node):
+            child = self.node_children(node)
+            while child:
+                self.__clean_from_node(child)
+                child = self.next_node(child)
+        self.__remove_node(node.get_id())

=== added file 'GTG/core/filters_bank.py'
--- GTG/core/filters_bank.py	1970-01-01 00:00:00 +0000
+++ GTG/core/filters_bank.py	2010-03-03 02:01:18 +0000
@@ -0,0 +1,158 @@
+# -*- 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/>.
+# 
+
+"""
+filters_bank stores all of GTG's filters in centralized place
+"""
+
+class Filter:
+    def __init__(self,func,req):
+        self.func = func
+        self.dic = None
+        self.req = req
+        
+    def set_parameters(self,dic):
+        self.dic = dic
+    
+    def is_displayed(self,tid):
+        task = self.req.get_task(tid)
+        if not task:
+            return False
+        elif self.dic:
+            return self.func(task,parameters=self.dic)
+        else:
+            return self.func(task)
+            
+class SimpleTagFilter:
+    def __init__(self,tagname,req):
+        self.req = req
+        self.tname = tagname
+        
+    def is_displayed(self,tid):
+        task = self.req.get_task(tid)
+        if not task:
+            return False
+        else:
+            return task.has_tags([self.tname])
+    
+
+class FiltersBank:
+    """
+    Stores filter objects in a centralized place.
+    """
+
+    #FIXME : put those 3 constants and those in Task.py in one place
+    STA_ACTIVE    = "Active"
+    STA_DISMISSED = "Dismiss"
+    STA_DONE      = "Done"
+
+    def __init__(self,req,tree=None):
+        self.tree = tree
+        self.req = req
+        self.available_filters = {}
+        self.custom_filters = {}
+        #Workview
+        filt_obj = Filter(self.workview,self.req)
+        self.available_filters['workview'] = filt_obj
+        #Active
+        filt_obj = Filter(self.active,self.req)
+        self.available_filters['active'] = filt_obj
+        #closed
+        filt_obj = Filter(self.closed,self.req)
+        self.available_filters['closed'] = filt_obj
+        #notag
+        filt_obj = Filter(self.notag,self.req)
+        self.available_filters['notag'] = filt_obj
+
+    ######### hardcoded filters #############
+    def notag(self,task):
+        """ Filter of tasks without tags """
+        return task.has_tags(notag_only=True)
+        
+    def is_leaf(self,task):
+        """ Filter of tasks which have no children """
+        return not task.has_child()
+    
+    def is_workable(self,task):
+        """ Filter of tasks that can be worked """
+        return task.is_workable()
+            
+    def workview(self,task):
+        wv = self.active(task) and\
+             task.is_started() and\
+             self.is_workable(task)
+        return wv
+        
+    def active(self,task):
+        """ Filter of tasks which are active """
+        #FIXME: we should also handle unactive tags
+        return task.get_status() == self.STA_ACTIVE
+        
+    def closed(self,task):
+        """ Filter of tasks which are closed """
+        return task.get_status() in [self.STA_DISMISSED,self.STA_DONE]
+        
+    ##########################################
+        
+    def get_filter(self,filter_name):
+        """ Get the filter object for a given name """
+        if self.available_filters.has_key(filter_name):
+            return self.available_filters[filter_name]
+        elif self.custom_filters.has_key(filter_name):
+            return self.custom_filters[filter_name]
+        else:
+            return None
+    
+    def list_filters(self):
+        """ List, by name, all available filters """
+        liste = self.available_filters.keys()
+        liste += self.custom_filters.keys()
+        return liste
+    
+    def add_filter(self,filter_name,filter_func):
+        """
+        Adds a filter to the filter bank 
+        Return True if the filter was added
+        Return False if the filter_name was already in the bank
+        """
+        if filter_name not in self.list_filters():
+            if filter_name.startswith('@'):
+                filter_obj = SimpleTagFilter(filter_name,self.req)
+            else:
+                filter_obj = Filter(filter_func,self.req)
+            self.custom_filters[filter_name] = filter_obj
+            return True
+        else:
+            return False
+        
+    def remove_filter(self,filter_name):
+        """
+        Remove a filter from the bank.
+        Only custom filters that were added here can be removed
+        Return False if the filter was not removed
+        """
+        if not self.available_filters.has_key(filter_name):
+            if self.custom_filters.has_key(filter_name):
+                self.unapply_filter(filter_name)
+                self.custom_filters.pop(filter_name)
+                return True
+            else:
+                return False
+        else:
+            return False

=== modified file 'GTG/core/firstrun_tasks.py'
--- GTG/core/firstrun_tasks.py	2010-02-09 22:38:05 +0000
+++ GTG/core/firstrun_tasks.py	2010-03-03 02:01:18 +0000
@@ -89,7 +89,7 @@
     text5 += "\n\n"
     text5 += _("Some examples of the current plugins are Syncing with Remember the Milk and Evolution, Tomboy/Gnote integration and Geolocalized Tasks.")
     text5 += "\n"
-    text5 += _("You can find the Plugin Manager by selecting Plugins > Plugin Preferences on the menu.")
+    text5 += _("You can find the Plugin Manager by selecting Edit in the Menu Bar, then clicking Preferences. You will then see a tab labeled Plugins.")
     
     t5 = addtask(doc, "4@1", title5, text5, [])
     root.appendChild(t5)

=== modified file 'GTG/core/plugins/api.py'
--- GTG/core/plugins/api.py	2010-02-16 01:39:41 +0000
+++ GTG/core/plugins/api.py	2010-03-03 02:01:18 +0000
@@ -16,13 +16,13 @@
 # You should have received a copy of the GNU General Public License along with
 # this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------
-
 from __future__ import with_statement
 
 import os
 import pickle
 from xdg.BaseDirectory import xdg_config_home
 
+
 class PluginAPI:
     """The plugin engine's API.
 
@@ -40,18 +40,12 @@
                  data_dir,
                  builder,
                  requester,
-                 taskview,
-                 ctask_modelsort,
-                 ctaskview,
-                 task_modelsort,
-                 filter_cbs,
                  tagpopup,
                  tagview,
                  browser,
                  task=None,
                  texteditor=None,
-                 quick_add_cbs=[],
-                 logger = None):
+                 quick_add_cbs=[]):
         """Construct a L{PluginAPI} object.
         
         @param window: The window where the plugin API object is being 
@@ -60,15 +54,11 @@
         @param data_dir: The data dir path.
         @param builder: The window's gtkBuilder object.
         @param requester: The requester.
-        @param taskview: The task view object.
-        @param filter_cbs: The filter callback list.
         @param tagpopup: The tag popoup menu of the tag view.
         @param tagview: The tag view object.
         @param task: The current task (Only works with the task editor).
         @param textview: The task editor's text view (Only works with the task editor).  
-        @param ctextview: The task editor's closed tasks text view (Only works with the task editor).  
-        @param task_modelsort: The browser's active task model.  
-        @param ctask_modelsort: The browser's closed task model.  
+        @param ctextview: The task editor's closed tasks text view (Only works with the task editor)
         """
         self.__window = window
         self.config = config
@@ -76,16 +66,8 @@
         self.__builder = builder
         self.__requester = requester
         
-        self.taskview = taskview
-        self.task_modelsort = task_modelsort
-
-        self.ctaskview = taskview
-        self.ctask_modelsort = ctask_modelsort
-        
         self.__tagpopup = tagpopup
         self.tagview = tagview
-        
-        self.__filter_cbs = filter_cbs
         self.__quick_add_cbs = quick_add_cbs
         
         #those are added widgets dictionaries
@@ -93,7 +75,6 @@
         self.tasktoolbar_widg = {}
         self.taskwidget_id = 0
         self.taskwidget_widg = {}
-        self.logger = logger
         self.browser = browser
         
         if task:
@@ -115,10 +96,7 @@
             return False
             
     def is_browser(self):
-        if self.taskview:
-            return True
-        else:
-            return False
+        print "is_browser method in plugin/api should be updated"
 
     def get_browser(self):
         return self.browser
@@ -130,7 +108,7 @@
 
         @param item: The gtk.MenuItem that is going to be added.  
         """
-        widget = self.__builder.get_object('menu_plugin')
+        widget = self.__builder.get_object('plugin_mi')
         if widget:
             widget.show_all()
             widget.get_submenu().append(item)
@@ -145,7 +123,7 @@
         fails.  
         """
         try:
-            wi = self.__builder.get_object('menu_plugin')
+            wi = self.__builder.get_object('plugin_mi')
             if wi:
                 menu = wi.get_submenu()
                 menu.remove(item)
@@ -290,14 +268,15 @@
         """
         self.__requester.connect(action, func)
             
-    def change_task_tree_store(self, treestore):
-        """Changes the TreeStore in the task browser's task view. 
-        
-        @param treestore: The new gtk.TreeStore model. 
-        """
-        task_tview = self.__builder.get_object("task_tview")
-        if task_tview:
-            task_tview.set_model(treestore)
+#    #This is definitely not allowed anymore !!
+#    def change_task_tree_store(self, treestore):
+#        """Changes the TreeStore in the task browser's task view. 
+#        
+#        @param treestore: The new gtk.TreeStore model. 
+#        """
+#        task_tview = self.__builder.get_object("task_tview")
+#        if task_tview:
+#            task_tview.set_model(treestore)
     
     def set_parent_window(self, child):
         """Sets the plugin dialog as a child of it's parent window, 
@@ -308,49 +287,54 @@
         """
         child.set_transient_for(self.__window) 
     
-    def get_taskview(self):
-        """Returns the task view object. 
-        
-        @return: The gtk.TreeView task view object.
-        """
-        return self.taskview
-
-    def get_task_modelsort(self):
-        """Returns the current Active task browser view. 
-        
-        @return: The gtk.TreeModelSort task object for visible active tasks.
-        """
-        return self.task_modelsort
-    
-    def get_closed_taskview(self):
-        """Returns the closed task view object. 
-        
-        @return: The gtk.TreeView task view object.
-        """
-        return self.ctaskview
-
-    def get_ctask_modelsort(self):
-        """Returns the current Done task browser view. 
-        
-        @return: The gtk.TreeModelSort task object for visible closed tasks.
-        """
-        return self.ctask_modelsort
-    
+#    # Not allowed anymore
+#    def get_taskview(self):
+#        """Returns the task view object. 
+#        
+#        @return: The gtk.TreeView task view object.
+#        """
+#        return self.taskview
+
+##    # Not allowed anymore
+#    def get_task_modelsort(self):
+#        """Returns the current Active task browser view. 
+#        
+#        @return: The gtk.TreeModelSort task object for visible active tasks.
+#        """
+#        return self.task_modelsort
+
+##    # Not allowed anymore
+#    def get_closed_taskview(self):
+#        """Returns the closed task view object. 
+#        
+#        @return: The gtk.TreeView task view object.
+#        """
+#        return self.ctaskview
+
+##    # Not allowed anymore
+#    def get_ctask_modelsort(self):
+#        """Returns the current Done task browser view. 
+#        
+#        @return: The gtk.TreeModelSort task object for visible closed tasks.
+#        """
+#        return self.ctask_modelsort
+
     def get_selected_task(self):
         """Returns the selected task in the task view.
         
         @return: A task. 
         """
+        print "get_selected_task in plugins/api should be updated"
         if self.is_editor():
             return self.task
-        elif self.is_browser():
-            selection = self.taskview.get_selection()
-            model, paths = selection.get_selected_rows()
-            iters = [model.get_iter(path) for path in paths]
-            if len(iters) > 0 and iters[0]:
-                return self.__requester.get_task(model.get_value(iters[0], 0))
-            else:
-                return None
+#        elif self.is_browser():
+#            selection = self.taskview.get_selection()
+#            model, paths = selection.get_selected_rows()
+#            iters = [model.get_iter(path) for path in paths]
+#            if len(iters) > 0 and iters[0]:
+#                return self.__requester.get_task(model.get_value(iters[0], 0))
+#            else:
+#                return None
         else:
             return None
         
@@ -366,7 +350,7 @@
         
         @return: The about dialog.
         """
-        wi = self.__builder.get_object("aboutdialog1")
+        wi = self.__builder.get_object("about_dialog")
         if wi:
             return wi
         else:
@@ -391,10 +375,6 @@
         """Returns the window for which the plug-in has been created"""
         return self.__window
 
-    def get_logger(self):
-        """Returns the logger, used for debug output""" 
-        return self.logger
-
 #=== General Methods ==========================================================
 
 
@@ -570,22 +550,23 @@
         """
         self.__requester.remove_tag_from_filter(tag)
       
-    def register_filter_cb(self, func):
-        """Registers a callback filter function with the callback filter. 
-        
-        @param func: The function that is going to be registered. 
-        
-        """
-        if func not in self.__filter_cbs:
-            self.__filter_cbs.append(func)
-    
-    def unregister_filter_cb(self, func):
-        """Unregisters a previously registered callback filter function. 
-        
-        @param func: The function that is going to be unregistered. 
-        """
-        if func in self.__filter_cbs:
-            self.__filter_cbs.remove(func)    
+#    #Those functions are not relevant anymore with the new requester
+#    def register_filter_cb(self, func):
+#        """Registers a callback filter function with the callback filter. 
+#        
+#        @param func: The function that is going to be registered. 
+#        
+#        """
+#        if func not in self.__filter_cbs:
+#            self.__filter_cbs.append(func)
+#    
+#    def unregister_filter_cb(self, func):
+#        """Unregisters a previously registered callback filter function. 
+#        
+#        @param func: The function that is going to be unregistered. 
+#        """
+#        if func in self.__filter_cbs:
+#            self.__filter_cbs.remove(func)    
 #=== Filtering methods ========================================================
 
     def register_quick_add_cb(self, func):

=== modified file 'GTG/core/requester.py'
--- GTG/core/requester.py	2010-02-08 08:32:44 +0000
+++ GTG/core/requester.py	2010-03-03 02:01:18 +0000
@@ -17,8 +17,14 @@
 # this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------
 
+"""
+A nice general purpose interface for the datastore and tagstore
+"""
+
 import gobject
 
+from GTG.core.filteredtree import FilteredTree
+from GTG.core.filters_bank import FiltersBank
 
 class Requester(gobject.GObject):
     """A view on a GTG datastore.
@@ -34,18 +40,23 @@
                     'task-deleted': (gobject.SIGNAL_RUN_FIRST, \
                                     gobject.TYPE_NONE, (str, )),
                     'task-modified': (gobject.SIGNAL_RUN_FIRST, \
+                                    gobject.TYPE_NONE, (str, )),
+                    'tag-added': (gobject.SIGNAL_RUN_FIRST, \
+                                    gobject.TYPE_NONE, (str, )),
+                    'tag-deleted': (gobject.SIGNAL_RUN_FIRST, \
+                                    gobject.TYPE_NONE, (str, )),
+                    'tag-modified': (gobject.SIGNAL_RUN_FIRST, \
                                     gobject.TYPE_NONE, (str, ))}
 
     def __init__(self, datastore):
         """Construct a L{Requester}."""
+        gobject.GObject.__init__(self)
         self.ds = datastore
-
-        #filter
-        self.filter = {}
-        self.filter["tasks"] = []
-        self.filter["tags"] = []
-
-        gobject.GObject.__init__(self)
+        self.basetree = self.ds.get_tasks_tree()
+        self.main_tree = FilteredTree(self,self.basetree,maintree=True)
+        
+        self.filters = FiltersBank(self,tree=self.main_tree)
+        self.counter_call = 0
 
     ############# Signals #########################
     #Used by the tasks to emit the task added/modified signal
@@ -54,7 +65,74 @@
         gobject.idle_add(self.emit, "task-added", tid)
 
     def _task_modified(self, tid):
+        self.counter_call += 1
+        #print "signal task_modified %s (%s modifications)" %(tid,self.counter_call)
         gobject.idle_add(self.emit, "task-modified", tid)
+        
+    def _tag_added(self,tagname):
+        gobject.idle_add(self.emit, "tag-added", tagname)
+        
+    ############ Tasks Tree ######################
+    # This is the main FilteredTree. You cannot apply filters
+    # directly to it, you have to pass them through the requester.
+    # This is the tree as it is displayed in the main window
+    def get_main_tasks_tree(self):
+        return self.main_tree
+        
+    # This is a FilteredTree that you have to handle yourself.
+    # You can apply/unapply filters on it as you wich.
+    def get_custom_tasks_tree(self):
+        return FilteredTree(self,self.basetree,maintree=False)
+        
+    def get_main_tasks_list(self):
+        return self.main_tree.get_all_keys()
+        
+    def get_main_n_tasks(self):
+        return self.main_tree.get_n_nodes()
+    
+    def get_all_tasks_list(self):
+        return self.basetree.get_all_keys()
+        
+    # Apply a given filter to the main FilteredTree
+    def apply_filter(self,filter_name,parameters=None):
+        r = self.main_tree.apply_filter(filter_name,parameters=parameters,imtherequester=True)
+        return r
+            
+    # Unapply a filter from the main FilteredTree.
+    # Does nothing if the filter was not previously applied.
+    def unapply_filter(self,filter_name):
+        r = self.main_tree.unapply_filter(filter_name,imtherequester=True)
+        return r
+
+    def reset_filters(self):
+        self.main_tree.reset_filters(imtherequester=True)
+        
+    def reset_tag_filters(self,refilter=True):
+        self.main_tree.reset_tag_filters(refilter=refilter,imtherequester=True)
+        
+    def is_displayed(self,task):
+        return self.main_tree.is_displayed(task)
+
+    ######### Filters bank #######################
+    # Get the filter object for a given name
+    def get_filter(self,filter_name):
+        return self.filters.get_filter(filter_name)
+    
+    # List, by name, all available filters
+    def list_filters(self):
+        return self.filters.list_filters()
+    
+    # Add a filter to the filter bank
+    # Return True if the filter was added
+    # Return False if the filter_name was already in the bank
+    def add_filter(self,filter_name,filter_func):
+        return self.filters.add_filter(filter_name,filter_func)
+        
+    # Remove a filter from the bank.
+    # Only custom filters that were added here can be removed
+    # Return False if the filter was not removed
+    def remove_filter(self,filter_name):
+        return self.filters.remove_filter(filter_name)
 
     ############## Tasks ##########################
     ###############################################
@@ -85,7 +163,7 @@
             existed, C{False} if importing an existing task from a backend.
         @return: A task.
         """
-        task = self.ds.new_task(pid=pid, newtask=newtask)
+        task = self.ds.new_task(pid=pid)
         if tags:
             for t in tags:
                 task.tag_added(t.get_name())
@@ -98,225 +176,14 @@
 
         @param tid: The id of the task to be deleted.
         """
-        self.ds.delete_task(tid)
-        gobject.idle_add(self.emit, "task-deleted", tid)
-
-    def get_tasks_list(self, tags=None, status=["Active"], notag_only=False,
-                       started_only=True, is_root=False):
-        """Return a list of tids of tasks.
-
-        By default, returns a list of all the tids of all active tasks.
-
-        @param tags: A list of tags. If provided, restricts the list of
-            returned tasks to those that have one or more of these tags.
-        @param status: A list of statuses. If provided, restricts the list of
-            returned tasks to those that are in one of these states.
-        @param notag_only: If True, only include tasks without tags. Defaults
-            to C{False}.
-        @param started_only: If True, only include tasks that have been
-            started. That is, tasks that have an already-passed start date or
-            tasks with no startdate. Defaults to C{True}.
-        @param is_root: If True, only include tasks that have no parent in the
-            current selection. Defaults to False.
-
-        @return: A list of task ids (tids).
-        """
-        l_tasks = []
-        temp_list = []
-        if tags:
-            for t in tags:
-                for tid in t.get_tasks():
-                    if tid not in temp_list:
-                        temp_list.append(tid)
-        else:
-            temp_list = self.ds.all_tasks()
-        for tid in temp_list:
-            task = self.get_task(tid)
-            if task and not task.is_loaded():
-                task = None
-            # This is status filtering.
-            if task and not task.get_status() in status:
-                task = None
-            # This is tag filtering.
-            # If we still have a task and we need to filter tags
-            # (if tags is None, this test is skipped)
-#            if task and tags:
-#                if not task.has_tags(tags):
-#                    task = None
-#                # Checking here the is_root because it has sense only with
-#                # tags.
-#                elif is_root and task.has_parents(tag=tags):
-#                    task = None
-            if task and tags and is_root and task.has_parents(tag=tags):
-                task = None
-            #If tags = [], we still check the is_root.
-            elif task and is_root:
-                if task.has_parents():
-                    # We accept children of a note.
-                    for p in task.get_parents():
-                        pp = self.get_task(p)
-                        if pp.get_status() != "Note":
-                            task = None
-            # Now checking if it has no tag.
-            if task and notag_only:
-                if not task.has_tags(notag_only=notag_only):
-                    task = None
-            # This is started filtering.
-            if task and started_only:
-                if not task.is_started():
-                    task = None
-
-            # If we still have a task, we return it.
-            if task:
-                l_tasks.append(tid)
-        return l_tasks
-
-    ############# Filters #########################
-    def set_filter(self, filter):
-        """Set a filter for the tasks.
-
-        @param filter: A dictionary with two keys, 'tags' and 'tasks'.
-            The 'tags' key corresponds to a list of tag names and the 'tasks'
-            corresponds to a list of tids.
-        """
-        self.filter = filter
-
-    def get_filter(self):
-        """Return the current task filter.
-
-        @return: The filter object.
-        """
-        return self.filter
-
-    def add_task_to_filter(self, tid):
-        """Adds (appends) a task to the filter (task list).
-
-        @param tid: A task id.
-        """
-        if tid not in self.filter["tasks"]:
-            self.filter["tasks"].append(tid)
-
-    def remove_task_from_filter(self, tid):
-        """Removes a task from the filter (task list).
-
-        @param tid: A task id.
-        """
-        if tid in self.filter["tasks"]:
-            self.filter["tasks"].remove(tid)
-
-    def add_tag_to_filter(self, tag):
-        """Adds (appends) a tag to the filter (tag list).
-
-        @param tag: A tag name.
-        """
-        if tag not in self.filter["tags"]:
-            self.filter["tags"].append(tag)
-
-    def remove_tag_from_filter(self, tag):
-        """Removes a tag from the filter (tag list).
-
-        @param tag: A tag name.
-        """
-        if tag in self.filter["tags"]:
-            self.filter["tags"].remove(tag)
-
-    ############# Filters #########################
-    def get_active_tasks_list(self, tags=None, notag_only=False,
-                              started_only=True, is_root=False,
-                              workable=False):
-        """Return a list of task ids for all active tasks.
-
-        See L{get_tasks_list} for more information about the parameters.
-
-        @param workable: If C{True}, then only include tasks with no pending
-            subtasks and that can be done directly and exclude any tasks that
-            have a C{nonworkview} tag which is not explicitly provided in the
-            C{tags} parameter. Defaults to C{False}.
-        """
-        l_tasks = []
-        if workable:
-            nonwork_tag = self.ds.get_tagstore().get_all_tags(
-                attname="nonworkview", attvalue="True")
-            # We build the list of tags we will skip.
-            #for nwtag in nonwork_tag:
-                # If the tag is explicitly selected, it doesn't go in the
-                # nonwork_tag.
-                #if tags and nwtag in tags:
-                #    nonwork_tag.remove(nwtag)
-            # We build the task list.
-            temp_tasks = self.get_active_tasks_list(
-                tags=tags, notag_only=notag_only, started_only=True,
-                is_root=False, workable=False)
-
-            #remove from temp_tasks the filtered out tasks
-            #for tid in temp_tasks:
-            #    if tid in self.filter["tasks"]:
-            #        temp_tasks.remove(tid)
-            #    else:
-            #        for filter_tag in self.get_task(tid).get_tags():
-            #            if filter_tag.get_attribute("name") in \
-            #                    self.filter["tags"]:
-            #                print self.get_task(tid).get_title()
-            #                temp_tasks.remove(tid)
-            #                break
-
-            # Now we verify that the tasks are workable and don't have a
-            # nonwork_tag.
-            for tid in temp_tasks:
-                filtered_tag = False
-                t = self.get_task(tid)
-                if t and t.is_workable() and (tid not in self.filter["tasks"]):
-                    for filter_tag in t.get_tags():
-                        if filter_tag.get_attribute("name") in \
-                                self.filter["tags"]:
-                            #print t.get_title()
-                            temp_tasks.remove(tid)
-                            filtered_tag = True
-
-                    if not filtered_tag:
-                        if len(nonwork_tag) == 0:
-                            #print t.get_title()
-                            l_tasks.append(tid)
-                        elif not t.has_tags(nonwork_tag):
-                            #print t.get_title()
-                            l_tasks.append(tid)
-            return l_tasks
-        else:
-            active = ["Active"]
-            temp_tasks = self.get_tasks_list(
-                tags=tags, status=active, notag_only=notag_only,
-                started_only=started_only, is_root=is_root)
-            for t in temp_tasks:
-                l_tasks.append(t)
-            return l_tasks
-
-    def get_closed_tasks_list(self, tags=None, notag_only=False,
-                              started_only=False, is_root=False):
-        """Return a list of task ids for closed tasks.
-
-        "Closed" means either "done", "dismissed" or "deleted".
-
-        See L{get_tasks_list} for more information about the parameters.
-        """
-        closed = ["Done", "Dismiss", "Deleted"]
-        return self.get_tasks_list(
-            tags=tags, status=closed, notag_only=notag_only,
-            started_only=started_only, is_root=is_root)
-
-    def get_notes_list(self, tags=None, notag_only=False):
-        """Return a list of task ids for notes.
-
-        See `get_tasks_list` for more information about the parameters.
-        """
-        note = ["Note"]
-        return self.get_tasks_list(
-            tags=tags, status=note, notag_only=notag_only, started_only=False,
-            is_root=False)
+        #send the signal before actually deleting the task !
+        self.emit('task-deleted', tid)
+        return self.ds.delete_task(tid)
 
     ############### Tags ##########################
     ###############################################
     def get_tag_tree(self):
-        return self.ds.get_tagstore().get_tree()
+        return self.ds.get_tagstore()
 
     def new_tag(self, tagname):
         """Create a new tag called 'tagname'.
@@ -357,12 +224,11 @@
     def get_used_tags(self):
         """Return tags currently used by a task.
 
-        @return: A list of tags used by a task.
+        @return: A list of tag names used by a task.
         """
         l = []
         for t in self.ds.get_tagstore().get_all_tags():
             if t.is_actively_used() and t not in l:
-                l.append(t)
-        l.sort(cmp=lambda x, y: cmp(x.get_name().lower(),\
-            y.get_name().lower()))
+                l.append(t.get_name())
+        l.sort(cmp=lambda x, y: cmp(x.lower(),y.lower()))
         return l

=== modified file 'GTG/core/tagstore.py'
--- GTG/core/tagstore.py	2010-01-07 16:27:06 +0000
+++ GTG/core/tagstore.py	2010-03-03 02:01:18 +0000
@@ -17,12 +17,17 @@
 # this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------
 
-#The tagstore is where the tag objects are handled. See the end of the file for
-#the tag object implementation
+"""
+tagstore is where the tag objects are handled.  Also defines the Tag object.
+
+Tagstore is to tag as datastore is to task. Of course, the tagstore is
+easier.  See the end of this file for the Tag object implementation.
+"""
 
 import os
 import xml.sax.saxutils as saxutils
 
+from GTG import _
 from GTG.core      import CoreConfig
 from GTG.core.tree import Tree, TreeNode
 from GTG.tools     import cleanxml
@@ -33,13 +38,32 @@
 
 # There's only one Tag store by user. It will store all the tag used
 # and their attribute.
-class TagStore:
+class TagStore(Tree):
     
     def __init__(self,requester):
+        Tree.__init__(self)
         self.req = requester
-        self.tree = Tree()
-        self.tags={}
-        self.root = self.tree.get_root()
+        
+        ### building the initial tags
+        # Build the "all tags tag"
+        self.alltag_tag = self.new_tag("gtg-tags-all")
+        self.alltag_tag.set_attribute("special","all")
+        self.alltag_tag.set_attribute("label","<span weight='bold'>%s</span>"\
+                                             % _("All tasks"))
+        self.alltag_tag.set_attribute("icon","gtg-tags-all")
+        self.alltag_tag.set_attribute("order",0)
+        # Build the "without tag tag"
+        self.notag_tag = self.new_tag("gtg-tags-none")
+        self.notag_tag.set_attribute("special","notag")
+        self.notag_tag.set_attribute("label","<span weight='bold'>%s</span>"\
+                                             % _("Tasks with no tags"))
+        self.notag_tag.set_attribute("icon","gtg-tags-none")
+        self.notag_tag.set_attribute("order",1)
+        # Build the separator
+        self.sep_tag = self.new_tag("gtg-tags-sep")
+        self.sep_tag.set_attribute("special","sep")
+        self.sep_tag.set_attribute("order",2)
+
         self.filename = os.path.join(CoreConfig.DATA_DIR, XMLFILE)
         doc, self.xmlstore = cleanxml.openxmlfile(self.filename,
             XMLROOT) #pylint: disable-msg=W0612
@@ -55,70 +79,80 @@
                 at_val = t.getAttribute(at_name)
                 tag.set_attribute(at_name, at_val)
                 i += 1
-            parent = tag.get_attribute('parent')
-            if parent:
-                pnode=self.new_tag(parent)
-                tag.reparent(pnode, update_attr=False)
-
-        #Now we build special tags. Special tags are not
-        #in the traditional tag list
-        #Their name doesn't begin with "@"
-#        #Build the "all tags tag"
-#        self.alltag_tag = Tag("alltags_tag",save_cllbk=self.save)
-#        self.alltag_tag.set_attribute("special","all")
-#        self.alltag_tag.set_attribute("icon","gtg-tags-all")
-#        #Build the "without tag tag"
-#        self.notag_tag = Tag("notag_tag",save_cllbk=self.save)
-#        self.notag_tag.set_attribute("special","notag")
-#        self.notag_tag.set_attribute("icon","gtg-tags-none")
-    def get_tree(self):
-        return self.tree
+#            parent = tag.get_attribute('parent')
+#            if parent:
+#                pnode=self.new_tag(parent)
+#                tag.reparent(pnode, update_attr=False)
 
     def new_tag(self, tagname):
         """Create a new tag and return it or return the existing one
         with corresponding name"""
         #we create a new tag from a name
         tname = tagname.encode("UTF-8")
-        if tname not in self.tags:
+        #if tname not in self.tags:
+        if not self.has_node(tname):
             tag = Tag(tname, save_cllbk=self.save, req=self.req)
-            tag.reparent(self.root)
-            self.tags[tname] = tag
-            return tag
-        else:
-            return self.tags[tname]
+            self.add_node(tag)
+            self.req._tag_added(tname)
+            self.req.add_filter(tname,None)
+            #self.tags[tname] = tag
+#        print "********* tag added *******"
+#        self.print_tree()
+        return self.get_node(tname)
 
+#   Is this thing used ? What does it do ?
     def add_tag(self, tag):
-        name = tag.get_name()
-        #If tag does not exist in the store, we add it
-        if name not in self.tags:
-            tag.reparent(self.root)
-            self.tags[name] = tag
-        #else, we just take the attributes of the new tag
-        #This allow us to keep attributes of the old tag
-        #that might be not set in the new one
-        else:
-            atts = tag.get_all_attributes()
-            for att_name in atts:
-                val = tag.get_attribute(att_name)
-                if att_name != 'name' and val:
-                    self.tags[name].set_attribute(att_name, val)
+        print "add_tag %s ***************** it is used !!!" %tag
+#        name = tag.get_name()
+#        #If tag does not exist in the store, we add it
+#        if not self.has_node(name):
+#            self.add_node(name,tag)
+#            #self.tags[name] = tag
+#        #else, we just take the attributes of the new tag
+#        #This allow us to keep attributes of the old tag
+#        #that might be not set in the new one
+#        else:
+#            atts = tag.get_all_attributes()
+#            oldtag = self.get_node(name)
+#            for att_name in atts:
+#                val = tag.get_attribute(att_name)
+#                if att_name != 'name' and val:
+#                    #self.tags[name].set_attribute(att_name, val)
+#                    oldtag.set_attribute(att_name, val)
 
     def get_tag(self, tagname):
         if tagname[0] != "@":
             tagname = "@" + tagname
-        return self.tags.get(tagname, None)
+        return self.get_node(tagname)
         
+    #FIXME : also add a new filter
     def rename_tag(self, oldname, newname):
         if len(newname) > 0 and \
                             oldname not in ['gtg-tags-none','gtg-tags-all']:
             if newname[0] != "@":
                 newname = "@" + newname
             if newname != oldname and newname != None \
-                                  and newname not in self.tags:
-                self.tags[newname] = self.tags[oldname]
-                self.tags[newname].rename(newname)
-                del self.tags[oldname]
-
+                                  and not self.has_node(newname):
+                                  
+                ntag = self.new_tag(newname)
+                otag = self.get_node(oldname)
+                #copy attributes
+                for att in otag.get_all_attributes(butname=True):
+                    ntag.set_attribute(att,otag.get_attribute(att))
+                #restore position in tree
+                if otag.has_parent():
+                    opar = otag.get_parent()
+                    ntag.set_parent(opar)
+                for ch in otag.get_children():
+                    tagchild = self.get_tag(ch)
+                    tagchild.set_parent(ntag)
+                #copy tasks
+                for tid in otag.get_tasks():
+                    tas = self.req.get_task(tid)
+                    tas.rename_tag(oldname,newname)
+                #remove the old one
+                self.remove_node(oldname,otag)
+                
     def get_all_tags_name(self, attname=None, attvalue=None):
         """Return the name of all tags
         Optionally, if you pass the attname and attvalue argument, it will
@@ -126,7 +160,7 @@
         excluding tags that don't have this attribute
         (except if attvalue is None)"""
         l = []
-        for t in self.tags.values():
+        for t in self.get_all_nodes():
             if not attname:
                 l.append(t.get_name())
             elif t.get_attribute(attname) == attvalue:
@@ -135,7 +169,7 @@
 
     def get_all_tags(self, attname=None, attvalue=None):
         l = []
-        for t in self.tags.values():
+        for t in self.get_all_nodes():
             if not attname:
                 l.append(t)
             elif t.get_attribute(attname) == attvalue:
@@ -197,18 +231,8 @@
     def get_name(self):
         """Return the name of the tag."""
         return self.get_attribute("name")
-        
-    def rename(self,newname):
-        old = self.get_name()
-        newname = saxutils.unescape(newname)
-        self.set_attribute("name",newname,internalrename=True)
-        for t in self.get_tasks():
-            ta = self.req.get_task(t)
-            ta.rename_tag(old,newname)
-            ta.sync()
-    
 
-    def set_attribute(self, att_name, att_value, internalrename=False):
+    def set_attribute(self, att_name, att_value):
         """Set an arbitrary attribute.
 
         This will call the C{save_cllbk} callback passed to the constructor.
@@ -217,33 +241,50 @@
         @param att_value: The value of the attribute. Will be converted to a
             string.
         """
-        if att_name == "name" and not internalrename:
+        if att_name == "name":
             # Warning : only the constructor can set the "name".
             #or the internalrename
-            #
-            # XXX: This should actually raise an exception, or warn, or
-            # something. The Zen of Python says "Errors should never pass
-            # silently." -- jml, 2009-07-17
-            return
-        # Attributes should all be strings.
-        val = unicode(str(att_value), "UTF-8")
-        self._attributes[att_name] = val
-        if self._save:
-            self._save()
+            #This should raise an exception : FIXME
+            #print "Error : The name of a tag cannot be manually set"
+            pass
+        elif att_name == "parent":
+            tree = self.get_tree()
+            par = tree.get_node(att_value)
+            if par:
+                self.add_parent(par.get_id())
+                self._attributes['parent'] = "We don't care about that value"
+        else:
+            # Attributes should all be strings.
+            val = unicode(str(att_value), "UTF-8")
+            self._attributes[att_name] = val
+            if self._save:
+                self._save()
 
     def get_attribute(self, att_name):
         """Get the attribute C{att_name}.
 
         Returns C{None} if there is no attribute matching C{att_name}.
         """
-        return self._attributes.get(att_name, None)
+        to_return = None
+        if att_name == 'parent':
+            if self.has_parent():
+                parlist = self.get_parents()
+                to_return = parlist.pop()
+                while len(parlist) > 0:
+                    to_return += ",%s" % parlist.pop()
+        else:
+            to_return = self._attributes.get(att_name, None)
+        return to_return
         
     def del_attribute(self, att_name):
         """Deletes the attribute C{att_name}.
         """
         if not att_name in self._attributes:
             return
-        del self._attributes[att_name]
+        elif att_name in ['name','parent']:
+            return
+        else:
+            del self._attributes[att_name]
         if self._save:
             self._save()            
 
@@ -258,20 +299,6 @@
             attributes.remove('name')
         return attributes
 
-    def reparent(self, parent, update_attr=True):
-        if update_attr:
-            if isinstance(parent, Tag):
-                self.set_attribute('parent', parent.get_name())
-            elif 'parent' in self._attributes:
-                del self._attributes['parent']
-        TreeNode.reparent(self, parent)
-        
-    def all_children(self):
-        l = [self]
-        for i in self.get_children_objs():
-            l += i.all_children()
-        return l
-
     ### TASK relation ####      
     def add_task(self, tid):
         if tid not in self.tasks:
@@ -283,8 +310,9 @@
         #return a copy of the list
         toreturn = self.tasks[:]
         tmplist = []
-        for c in self.get_children_objs():
-            tmplist.extend(c.get_tasks())
+        for c in self.get_children():
+            node = self.tree.get_node(c)
+            tmplist.extend(node.get_tasks())
         for ti in tmplist:
             if ti not in toreturn:
                 toreturn.append(ti)
@@ -308,7 +336,7 @@
         else:
             for t in tasks:
                 ta = self.req.get_task(t)
-                if ta.get_status() == "Active" and t not in temp_list:
+                if ta and ta.get_status() == "Active" and t not in temp_list:
                     temp_list.append(t)
         toreturn = len(temp_list)
         return toreturn

=== modified file 'GTG/core/task.py'
--- GTG/core/task.py	2010-02-12 14:19:29 +0000
+++ GTG/core/task.py	2010-03-03 02:01:18 +0000
@@ -17,6 +17,10 @@
 # this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------
 
+"""
+task.py contains the Task class which represents (guess what) a task
+"""
+
 import xml.dom.minidom
 import uuid
 import xml.sax.saxutils as saxutils
@@ -24,9 +28,10 @@
 from GTG import _
 from GTG.tools.dates import date_today, no_date, Date
 from datetime import datetime
-
-
-class Task:
+from GTG.core.tree import TreeNode
+
+
+class Task(TreeNode):
     """ This class represent a task in GTG.
     You should never create a Task directly. Use the datastore.new_task()
     function."""
@@ -36,6 +41,7 @@
     STA_DONE      = "Done"
 
     def __init__(self, ze_id, requester, newtask=False):
+        TreeNode.__init__(self, ze_id)
         #the id of this task in the project should be set
         #tid is a string ! (we have to choose a type and stick to it)
         self.tid = str(ze_id)
@@ -50,9 +56,6 @@
         self.closed_date = no_date
         self.due_date = no_date
         self.start_date = no_date
-        self.parents = []
-        #The list of children tid
-        self.children = []
         self.can_be_deleted = newtask
         # tags
         self.tags = []
@@ -73,7 +76,8 @@
             self.loaded = True
             if signal:
                 self.req._task_loaded(self.tid)
-                self.call_modified()
+                #not sure the following is necessary
+                #self.req._task_modified(self.tid)
 
     def set_to_keep(self):
         self.can_be_deleted = False
@@ -159,8 +163,9 @@
     def is_workable(self):
         workable = True
         for c in self.get_subtasks():
-            if c.get_status() == self.STA_ACTIVE:
+            if c and c.get_status() == self.STA_ACTIVE:
                 workable = False
+#        print "task %s workable : %s" %(self.get_id(),workable)
         return workable
 
     #A task is in the workview if it is workable, started, active and
@@ -321,65 +326,60 @@
         """
         uid, pid = self.get_id().split('@') #pylint: disable-msg=W0612
         subt     = self.req.new_task(pid=pid, newtask=True)
-        self.add_subtask(subt.get_id())
+        #we use the inherited childrens
+        self.add_child(subt.get_id())
         return subt
-
-    def add_subtask(self, tid):
+        
+    def add_child(self, tid):
         """Add a subtask to this task
 
-        @param tid: the ID of the added task
+        @param child: the added task
         """
         self.can_be_deleted = False
-        #The if prevent an infinite loop
-        if tid not in self.children and tid not in self.parents and\
-                                                tid != self.get_id():
-            self.children.append(tid)
-            task = self.req.get_task(tid)
-            task.add_parent(self.get_id())
+        #the core of the method is in the TreeNode object
+        if TreeNode.add_child(self,tid):
             #now we set inherited attributes only if it's a new task
-            if task.can_be_deleted:
-                task.set_start_date(self.get_start_date())
+            child = self.req.get_task(tid)
+            if child.can_be_deleted:
+                child.set_start_date(self.get_start_date())
                 for t in self.get_tags():
-                    task.tag_added(t.get_name())
-
-    def remove_subtask(self, tid):
+                    child.tag_added(t.get_name())
+            return True
+        else:
+            return False
+            
+    def remove_child(self,tid):
         """Removed a subtask from the task.
 
         @param tid: the ID of the task to remove
         """
-        if tid in self.children:
-            self.children.remove(tid)
+        if TreeNode.remove_child(self,tid):
             task = self.req.get_task(tid)
             if task.can_be_deleted:
                 self.req.delete_task(tid)
-            else:
-                task.remove_parent(self.get_id())
             self.sync()
-
-    def has_subtasks(self):
-        """Returns True if task has subtasks.
-        """
-        return len(self.children) != 0
-
-    def get_n_subtasks(self):
-        """Return the number of subtasks of a task.
-        """
-        return len(self.children)
-
+            return True
+        else:
+            return False
+
+    #FIXME : remove this method
     def get_subtasks(self):
-        """Return the list of subtasks.
-        """
+#        print "Deprecation Warning : use get_children instead of get_subtasks"
         #XXX: is this useful?
         zelist = []
-        for i in self.children:
-            zelist.append(self.req.get_task(i))
+        for i in self.get_children():
+            t = self.req.get_task(i)
+            if t:
+                zelist.append(t)
         return zelist
         
     def get_self_and_all_subtasks(self, active_only=False, tasks=[]):
         tasks.append(self)
-        for i in self.get_subtasks():
-            if not active_only or i.status == self.STA_ACTIVE:
-                i.get_self_and_all_subtasks(active_only, tasks)
+        for tid in self.get_children():
+            i = self.req.get_task(tid)
+            if i:
+                if not active_only or i.status == self.STA_ACTIVE:
+                    i.get_self_and_all_subtasks(active_only, tasks)
         return tasks
 
     def get_subtask(self, tid):
@@ -389,69 +389,41 @@
         """
         return self.req.get_task(tid)
 
-    def get_subtask_tids(self):
-        """Return the list of subtasks. Return a list of IDs.
-        """
-        return list(self.children)
-
-    def get_nth_subtask(self, index):
-        """Return the task ID stored at a given index.
-
-        @param index: the index of the task to return.
-        """
-        try:
-            return self.children[index]
-        except(IndexError):
-            raise ValueError("Index is not in task list")
-
-    def get_subtask_index(self, tid):
-        """Return the index of a given subtask.
-
-        @param tid: the tid of the task whose index must be returned.
-        """
-        return self.children.index(tid)
-
-    #add and remove parents are private
-    #Only the task itself can play with it's parent
-
     ### PARENTS ##############################################################
 
     #Take a tid object as parameter
-    def add_parent(self, tid):
-        #The if prevent a loop
-        if tid and tid not in self.children and tid not in self.parents:
-            self.parents.append(tid)
+    def add_parent(self, parent_tid):
+        added = TreeNode.add_parent(self, parent_tid)
+        if added:
+            #print "add_parent %s to %s" %(parent.get_id(),self.get_id())
             self.sync()
-            task = self.req.get_task(tid)
-            task.add_subtask(self.get_id())
-            task.sync()
+            parent.sync()
+            return True
+        else:
+            return False
 
     #Take a tid as parameter
     def remove_parent(self, tid):
-        if tid and tid in self.parents:
-            self.parents.remove(tid)
-            self.sync()
-            parent = self.req.get_task(tid)
-            if parent:
-                parent.remove_subtask(self.get_id())
-                parent.sync()
-
-    def get_parents(self):
-        return list(self.parents)
+        TreeNode.remove_parent(self,tid)
+        self.sync()
+        parent = self.req.get_task(tid)
+        if parent:
+            parent.sync()
 
     #Return true is the task has parent
     #If tag is provided, return True only
     #if the parent has this particular tag
     def has_parents(self, tag=None):
+        has_par = TreeNode.has_parent(self)
         #The "all tag" argument
-        if tag and len(self.parents)!=0:
+        if tag and has_par:
             a = 0
-            for tid in self.parents:
+            for tid in self.get_parents():
                 p = self.req.get_task(tid)
                 a += p.has_tags(tag)
             to_return = a
         else:
-            to_return = len(self.parents)!=0
+            to_return = has_par
         return to_return
 
     def set_attribute(self, att_name, att_value, namespace=""):
@@ -482,8 +454,9 @@
             self.req.delete_task(task.get_id())
         for i in self.get_parents():
             task = self.req.get_task(i)
-            task.remove_subtask(self.get_id())
-        for tag in self.tags:
+            task.remove_child(self.get_id())
+        for tagname in self.tags:
+            tag = self.req.get_tag(tagname)
             tag.remove_task(self.get_id())
         #then we remove effectively the task
         #self.req.delete_task(self.get_id())
@@ -506,7 +479,7 @@
     def call_modified(self):
         self.req._task_modified(self.tid)
         #we also modify parents and children
-        for s in self.get_subtask_tids():
+        for s in self.get_children():
             self.req._task_modified(s)
         for p in self.get_parents():
             self.req._task_modified(p)
@@ -520,15 +493,14 @@
 #
     def get_tags_name(self):
         #Return a copy of the list of tags. Not the original object.
+        return list(self.tags)
+
+    #return a copy of the list of tag objects
+    def get_tags(self):
         l = []
-        for t in self.tags:
-            name = t.get_name().encode("UTF-8")
-            l.append(name)
+        for tname in self.tags:
+            l.append(self.req.get_tag(tname))
         return l
-
-    #return a copy of the list of tag objects
-    def get_tags(self):
-        return list(self.tags)
         
     def rename_tag(self, old, new):
         eold = saxutils.escape(saxutils.unescape(old))
@@ -538,15 +510,19 @@
         self.tag_added(new)
 
     def tag_added(self, tagname):
+        #print "tag %s added to task %s" %(tagname,self.get_id())
         "Add a tag. Does not add '@tag' to the contents. See insert_tag"
-        t = self.req.new_tag(tagname.encode("UTF-8"))
-        t.add_task(self.get_id())
+        t = tagname.encode("UTF-8")
+        tag = self.req.get_tag(t)
+        if not tag:
+            tag = self.req.new_tag(t)
+        tag.add_task(self.get_id())
         #Do not add the same tag twice
         if not t in self.tags:
             self.tags.append(t)
             for child in self.get_subtasks():
                 if child.can_be_deleted:
-                    child.add_tag(tagname)
+                    child.add_tag(t)
             return True
     
     def add_tag(self, tagname):
@@ -577,8 +553,8 @@
     def remove_tag(self, tagname):
         t = self.req.get_tag(tagname)
         t.remove_task(self.get_id())
-        if t in self.tags:
-            self.tags.remove(t)
+        if tagname in self.tags:
+            self.tags.remove(tagname)
             for child in self.get_subtasks():
                 if child.can_be_deleted:
                     child.remove_tag(tagname)
@@ -596,7 +572,7 @@
                )
      
 
-    #tag_list is a list of tags object
+    #tag_list is a list of tags names
     #return true if at least one of the list is in the task
     def has_tags(self, tag_list=None, notag_only=False):
         #We want to see if the task has no tags

=== modified file 'GTG/core/tree.py'
--- GTG/core/tree.py	2009-12-26 20:59:06 +0000
+++ GTG/core/tree.py	2010-03-03 02:01:18 +0000
@@ -1,26 +1,39 @@
+# -*- 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/>.
+# -----------------------------------------------------------------------------
+
 class Tree():
 
     def __init__(self, root=None):
+        self.root_id = 'root'
         self.nodes = {}
+        self.pending_relationships = []
         if root:
             self.root = root
         else:
-            self.root = TreeNode(id="root")
+            self.root = TreeNode(id=self.root_id)
+        self.root.set_tree(self)
 
     def __str__(self):
         return "<Tree: root = '%s'>" % (str(self.root))
 
-    def get_rowref_for_path(self, path):
-        return self._rowref_for_path(self.root, path)
-
-    def get_path_for_rowref(self, rowref):
-        return self._path_for_rowref(self.root, rowref)
-
-    def get_node_for_rowref(self, rowref):
-        return self._node_for_rowref(self.root, rowref)
-
-    def get_rowref_for_node(self, node):
-        return self._rowref_for_node(node)
+    def get_node_for_path(self, path):
+        return self._node_for_path(self.root,path)
 
     def get_path_for_node(self, node):
         return self._path_for_node(node)
@@ -30,38 +43,122 @@
 
     def set_root(self, root):
         self.root = root
-
-    def add_node(self, id, node, parent):
-        if parent:
-            node.set_parent(parent)
-            parent.add_child(id, node)
-        else:
-            node.set_parent(self.root)
-            self.root.add_child(id, node)
-        node_list = self.nodes.get(id)
-        if node_list:
-            node_list.append(node)
-        else:
-            self.nodes[id] = [node]
-
-    def remove_node(self, id, node):
-        if node.has_child():
-            for c_id in node.get_children():
-                self.remove_node(c_id, node.get_child(c_id))
-        if node.has_parent():
-            par = node.get_parent()
-            par.remove_child(node.get_id())
-        node_list = self.nodes.get(id)
-        node_list.remove(node)
-
-    def get_nodes(self, id):
-        if id in self.nodes:
-            return list(self.nodes[id])
-        else:
-            return []
+        self.root.set_tree(self)
+
+    #We add a node. By default, it's a child of the root
+    def add_node(self, node, parent=None):
+        #print "*************adding node %s %s" %(node, parent)
+        id = node.get_id()
+        if self.nodes.get(id):
+            print "Error : A node with this id %s already exists" %id
+            return False
+        else:
+            #We add the node
+            node.set_tree(self)
+            if parent:#    
+                node.set_parent(parent)
+                parent.add_child(id)
+            else:
+                self.root.add_child(id)
+            self.nodes[id] = node
+            #build the relationships that were waiting for that node
+            for rel in list(self.pending_relationships):
+                if id in rel:
+                    self.new_relationship(rel[0],rel[1])
+            return True
+
+    #this will remove a node and all his children
+    #does nothing if the node doesn't exist
+    def remove_node(self, id):
+        node = self.get_node(id)
+        if not node :
+            return
+        else:
+            if node.has_child():
+                for c_id in node.get_children():
+                    self.remove_node(c_id)
+            if node.has_parent():
+                for p_id in node.get_parents():
+                    par = self.get_node(p_id)
+                    par.remove_child(id)
+            else:
+                self.root.remove_child(id)
+            self.nodes.pop(id)
+        
+    #create a new relationship between nodes if it doesn't already exist
+    #return False if nothing was done
+    def new_relationship(self,parent_id,child_id):
+        #print "new relationship between %s and %s" %(parent_id,child_id)
+        if [parent_id,child_id] in self.pending_relationships:
+            self.pending_relationships.remove([parent_id,child_id])
+        toreturn = False
+        #no relationship allowed with yourself
+        if parent_id != child_id:
+            p = self.get_node(parent_id)
+            c = self.get_node(child_id)
+            if p and c :
+                #no circular relationship allowed
+                if not p.has_parent(child_id) and not c.has_child(parent_id):
+                    if not p.has_child(child_id):
+                        p.add_child(child_id)
+                        toreturn = True
+                    if not c.has_parent(parent_id):
+                        #print "creating the %s - %s relation" %(parent_id,child_id)
+                        c.add_parent(parent_id)
+                        toreturn = True
+                        #removing the root from the list of parent
+                        if self.root.has_child(child_id):
+                            self.root.remove_child(child_id)
+                else:
+                    #a circular relationship was found
+                    #undo everything
+                    self.break_relationship(parent_id,child_id)
+                    toreturn = False
+            else:
+                #at least one of the node is not loaded. Save the relation for later
+                #undo everything
+                self.break_relationship(parent_id,child_id)
+                #save it for later
+                if [parent_id,child_id] not in self.pending_relationships:
+                    self.pending_relationships.append([parent_id,child_id])
+                toreturn = True
+        return toreturn
+    
+    #break an existing relationship. The child is added to the root
+    #return False if the relationship didn't exist    
+    def break_relationship(self,parent_id,child_id):
+        toreturn = False
+        p = self.get_node(parent_id)
+        c = self.get_node(child_id)
+        if p and c :
+            if p.has_child(child_id):
+                p.remove_child(child_id)
+                toreturn = True
+            if c.has_parent(parent_id):
+                c.remove_parent(parent_id)
+                toreturn = True
+                #if no more parent left, adding to the root
+                if not c.has_parent():
+                    self.root.add_child(child_id)
+        return toreturn
+            
+    #Trying to make a function that bypass the weirdiness of lists
+    def get_node(self,id):
+        return self.nodes.get(id)
+            
+    def get_all_keys(self):
+        return list(self.nodes.keys())
+            
+    def get_all_nodes(self):
+        li = []
+        for k in self.nodes.keys():
+            no = self.get_node(k)
+            if no:
+                li.append(no)
+        return li
 
     def has_node(self, id):
-        return id in self.nodes.keys()
+        return (self.nodes.get(id) != None)
 
     def print_tree(self):
         self._print_from_node(self.root)
@@ -74,57 +171,33 @@
 
 ### HELPER FUNCTION FOR TREE #################################################
 #
-    def _rowref_for_path(self, node, path):
+    def _node_for_path(self,node,path):
         if path[0] < node.get_n_children():
             if len(path) == 1:
-                return "/" + str(node.get_nth_child(path[0]).get_id())
+                return node.get_nth_child(path[0])
             else:
                 node = node.get_nth_child(path[0])
                 path = path[1:]
-                c_path = self._rowref_for_path(node, path)
-                if c_path:
-                    return "/" + str(node.get_id()) + str(c_path)
-                else:
-                    return None
+                return self._node_for_path(node, path)
         else:
             return None
 
-    def _path_for_rowref(self, node, rowref):
-        if rowref.rfind('/') == 0:
-            return (node.get_child_index(rowref[1:]), )
-        else:
-            cur_id   = rowref[1:rowref.find('/', 1)]
-            cur_node = node.get_child(cur_id)
-            cur_path = (node.get_child_index(cur_id), )
-            rowref   = rowref[rowref.find(cur_id)+len(cur_id):]
-            return cur_path + self._path_for_rowref(cur_node, rowref)
-
-    def _node_for_rowref(self, node, rowref):
-        #print "_node_for_rowref: %s" % rowref
-        if rowref == '':
-            return self.root
-        elif rowref.rfind('/') == 0:
-            return node.get_child(rowref[1:])
-        else:
-            cur_id   = rowref[1:rowref.find('/', 1)]
-            cur_node = node.get_child(cur_id)
-            rowref   = rowref[rowref.find(cur_id)+len(cur_id):]
-            return self._node_for_rowref(cur_node, rowref)
-
-    def _rowref_for_node(self, node):
-        if not node.has_parent():
-            return ""
-        else:
-            parent = node.get_parent()
-            return self._rowref_for_node(parent) + "/" + str(node.get_id())
-
     def _path_for_node(self, node):
-        if not node.has_parent():
-            return ()
+        if node: 
+            if node == self.root:
+                toreturn = ()
+            elif not node.has_parent():
+                index  = self.root.get_child_index(node.get_id())
+                toreturn = self._path_for_node(self.root) + (index, )
+            else:
+                #FIXME : no multiparent support here
+                parent_id = node.get_parent()
+                parent = self.get_node(parent_id)
+                index  = parent.get_child_index(node.get_id())
+                toreturn = self._path_for_node(parent) + (index, )
         else:
-            parent = node.get_parent()
-            index  = parent.get_child_index(node.get_id())
-            return self._path_for_node(parent) + (index, )
+            toreturn = None
+        return toreturn
 
     def _print_from_node(self, node, prefix=""):
         print prefix + node.id
@@ -147,71 +220,136 @@
 
 class TreeNode():
 
-    def __init__(self, id, obj=None, parent=None):
-        self.parent   = parent
+    def __init__(self, id, tree=None, parent=None):
+        self.parents   = []
         self.id       = id
-        self.ids      = []
-        self.children = []
-        self.obj      = obj
+        self.children      = []
+        self.tree = tree
+        self.pending_relationship = []
+        if parent:
+            self.add_parent(parent)
 
     def __str__(self):
         return "<TreeNode: '%s'>" % (self.id)
-
-    def get_obj(self):
-        return self.obj
-
-    def set_obj(self, obj):
-        self.obj = obj
+        
+    def set_tree(self,tree):
+        self.tree = tree
+        for rel in list(self.pending_relationship):
+            self.tree.new_relationship(rel[0],rel[1])
+            self.pending_relationship.remove(rel)
+            
+    def get_tree(self):
+        return self.tree
 
     def get_id(self):
         return self.id
-
-    def has_parent(self):
-        return self.parent is not None
-
+        
+    
+    def new_relationship(self,par,chi):
+        if self.tree:
+            self.tree.new_relationship(par,chi)
+        else:
+            self.pending_relationship.append([par,chi])
+        
+        
+##### Parents
+
+    def has_parent(self,id=None):
+        if id:
+            return id in self.parents
+        else:
+            return len(self.parents) > 0
+    
+    #this one return only one parent.
+    #useful for tree where we know that there is only one
     def get_parent(self):
-        return self.parent
-
-    def set_parent(self, par):
-        self.parent = par
-
-    def has_child(self):
-        return len(self.ids) != 0
+        #we should throw an error if there are multiples parents
+        if len(self.parents) > 1:
+            print "Warning : get_parent will return one random parent because \
+                    there are multiple parents."
+        if self.has_parent():
+            return self.parents[0]
+        else:
+            return None
+    def get_parents(self):
+        return list(self.parents)
+
+    def add_parent(self, parent_id):
+#        root = self.tree.get_root()
+#        print "removing root node has parent"
+#        self.tree.break_relationship(root.get_id(),self.get_id())
+        if parent_id not in self.parents:
+            self.parents.append(parent_id)
+            return self.new_relationship(parent_id, self.get_id())
+        else:
+            return False
+    
+    #set_parent means that we remove all other parents
+    def set_parent(self,par):
+        if par:
+            for i in self.parents:
+                if i != par:
+                    self.remove_parent(i)
+            self.add_parent(par)
+            
+    def remove_parent(self,id):
+        if id in self.parents:
+            self.parents.remove(id)
+            self.tree.break_relationship(id,self.get_id())
+            
+###### Children
+
+    def has_child(self,id=None):
+        if id :
+            return id in self.children
+        else:
+            return len(self.children) != 0
 
     def get_children(self):
-        return list(self.ids)
-
-    def get_children_objs(self):
         return list(self.children)
 
     def get_n_children(self):
-        return len(self.ids)
+        return len(self.children)
 
     def get_nth_child(self, index):
-        return self.children[index]
+        try:
+            id = self.children[index]
+            return self.tree.get_node(id)
+        except(IndexError):
+            raise ValueError("Index is not in the children list")
 
     def get_child(self, id):
-        if id in self.ids:
-            idx = self.ids.index(id)
-            return self.children[idx]
+        if id in self.children:
+            return self.tree.get_node(id)
         else:
             return None
 
     def get_child_index(self, id):
-        return self.ids.index(id)
+        return self.children.index(id)
 
-    def add_child(self, id, child):
-        self.ids.append(id)
-        self.children.append(child)
+    #return True if the child was added correctly. False otherwise
+    #takes the id of the child as parameter.
+    #if the child is not already in the tree, the relation is anyway "saved"
+    def add_child(self, id):
+        self.children.append(id)
+        return self.new_relationship(self.get_id(),id)
 
     def remove_child(self, id):
-        idx   = self.ids.index(id)
-        child = self.children[idx]
-        self.ids.remove(id)
-        self.children.remove(child)
+        if id in self.children:
+            self.children.remove(id)
+            self.tree.break_relationship(self.get_id(),id)
+            return True
+        else:
+            return False
+
         
-    def reparent(self, parent):
-        if self.has_parent():
-            self.get_parent().remove_child(self.id)
-        self.set_parent(parent)
-        parent.add_child(self.id, self)
+    def change_id(self,newid):
+        oldid = self.id
+        self.id = newid
+        for p in self.parents:
+            par = self.tree.get(p)
+            par.remove_child(oldid)
+            par.add_child(self.id)
+        for c in self.get_children():
+            c.add_parent(newid)
+            c.remove_parent(oldid)

=== modified file 'GTG/gtg.py'
--- GTG/gtg.py	2009-12-03 09:47:09 +0000
+++ GTG/gtg.py	2010-03-03 02:01:18 +0000
@@ -42,6 +42,8 @@
 #
 #==============================================================================
 
+"""This is the top-level exec script for running GTG"""
+
 #=== IMPORT ===================================================================
 from __future__ import with_statement
 
@@ -51,11 +53,11 @@
 import logging
 
 #our own imports
-from GTG import _
-from GTG.taskbrowser.browser import TaskBrowser
-from GTG.core.datastore import DataStore
-from GTG.core.dbuswrapper import DBusTaskWrapper
-from GTG.core import CoreConfig
+from GTG                     import _
+from GTG.viewmanager.manager import Manager
+from GTG.core.datastore      import DataStore
+from GTG.core                import CoreConfig
+from GTG.tools.logger        import Log
 
 #=== OBJECTS ==================================================================
 
@@ -90,17 +92,10 @@
 #=== MAIN CLASS ===============================================================
 
 def main(options=None, args=None):
-    
-    # init logging system
-    logger = logging.getLogger("gtg_logger")
-    ch = logging.StreamHandler()
-    ch.setLevel(logging.DEBUG)
-    formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(module)s:%(funcName)s:%(lineno)d - %(message)s")
-    ch.setFormatter(formatter)
-    logger.addHandler(ch)
+    # Debugging subsystem initialization
     if options.debug:
-        logger.setLevel(logging.DEBUG)
-        logger.debug("Debug output enabled.")
+        Log.setLevel(logging.DEBUG)
+        Log.debug("Debug output enabled.")
     
     config = CoreConfig()
     check_instance(config.DATA_DIR)
@@ -117,9 +112,9 @@
         
     # Launch task browser
     req = ds.get_requester()
-    tb = TaskBrowser(req, config, logger=logger)
-    DBusTaskWrapper(req, tb)
-    tb.main()
+    manager = Manager(req, config)
+    #main loop
+    manager.main()
 
     # Ideally we should load window geometry configuration from a config.
     # backend like gconf at some point, and restore the appearance of the

=== modified file 'GTG/info.py'
--- GTG/info.py	2010-02-28 23:44:14 +0000
+++ GTG/info.py	2010-03-03 02:01:18 +0000
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-#various information about GTG. Should be updated for every release.
+"""Various information about GTG. Should be updated for every release."""
 
 URL             = "http://gtg.fritalk.com"
 EMAIL           = "[e-mail]"

=== modified file 'GTG/plugins/__init__.py'
--- GTG/plugins/__init__.py	2009-12-28 08:28:41 +0000
+++ GTG/plugins/__init__.py	2010-03-03 02:01:18 +0000
@@ -0,0 +1,1 @@
+"""Optional plug-ins for GTG"""

=== modified file 'GTG/plugins/export/export.ui'
--- GTG/plugins/export/export.ui	2010-01-07 09:08:19 +0000
+++ GTG/plugins/export/export.ui	2010-03-03 02:01:18 +0000
@@ -172,6 +172,7 @@
   <object class="GtkWindow" id="preferences_dialog">
     <property name="border_width">10</property>
     <property name="window_position">center-on-parent</property>
+    <property name="type_hint">dialog</property>
     <signal name="delete_event" handler="on_preferences_dialog_delete_event"/>
     <child>
       <object class="GtkVBox" id="vbox1">

=== modified file 'GTG/plugins/hamster/prefs.ui'
--- GTG/plugins/hamster/prefs.ui	2010-02-11 20:23:43 +0000
+++ GTG/plugins/hamster/prefs.ui	2010-03-03 02:01:18 +0000
@@ -5,7 +5,7 @@
   <object class="GtkDialog" id="dialog1">
     <property name="border_width">5</property>
     <property name="title" translatable="yes">Hamster Preferences</property>
-    <property name="type_hint">normal</property>
+    <property name="type_hint">dialog</property>
     <property name="has_separator">False</property>
     <signal name="delete_event" handler="prefs_close"/>
     <child internal-child="vbox">

=== modified file 'GTG/plugins/notification_area/notification_area.ui'
--- GTG/plugins/notification_area/notification_area.ui	2010-02-15 21:37:57 +0000
+++ GTG/plugins/notification_area/notification_area.ui	2010-03-03 02:01:18 +0000
@@ -6,6 +6,7 @@
   <object class="GtkWindow" id="preferences_dialog">
     <property name="border_width">10</property>
     <property name="window_position">center-on-parent</property>
+    <property name="type_hint">dialog</property>
     <signal name="delete_event" handler="on_preferences_dialog_delete_event"/>
     <child>
       <object class="GtkVBox" id="vbox1">

=== modified file 'GTG/plugins/rtm_sync/__init__.py'
--- GTG/plugins/rtm_sync/__init__.py	2009-12-28 14:08:19 +0000
+++ GTG/plugins/rtm_sync/__init__.py	2010-03-03 02:01:18 +0000
@@ -23,4 +23,3 @@
 
 #suppress pyflakes warning (given by make lint)
 if False == True: RtmSync()
-

=== modified file 'GTG/plugins/rtm_sync/genericTask.py'
--- GTG/plugins/rtm_sync/genericTask.py	2010-02-03 05:43:48 +0000
+++ GTG/plugins/rtm_sync/genericTask.py	2010-03-03 02:01:18 +0000
@@ -36,8 +36,8 @@
         # (where GET is fast, but SET is slow)
         if self.title != task.title:
             self.title = task.title
-            #    if self.text != task.text:
-                #self.text = task.text
+        if self.text != task.text:
+            self.text = task.text
         if self.status != task.status:
             self.status = task.status
         if self.due_date != task.due_date:

=== modified file 'GTG/plugins/rtm_sync/gtgProxy.py'
--- GTG/plugins/rtm_sync/gtgProxy.py	2010-02-13 23:14:31 +0000
+++ GTG/plugins/rtm_sync/gtgProxy.py	2010-03-03 02:01:18 +0000
@@ -53,4 +53,3 @@
         #NOTE: delete_task wants the internal gtg id, not the uuid
         id = task.get_gtg_task().get_id()
         self.requester.delete_task(id)
-

=== modified file 'GTG/plugins/rtm_sync/gtgTask.py'
--- GTG/plugins/rtm_sync/gtgTask.py	2010-02-10 05:51:04 +0000
+++ GTG/plugins/rtm_sync/gtgTask.py	2010-03-03 02:01:18 +0000
@@ -58,7 +58,7 @@
             self._gtg_task.remove_tag(tag)
         #tags to add
         for tag in other_tags_set.difference(gtg_tags_set):
-            gtg_all_tags = [ t.get_name() for t in \
+            gtg_all_tags = [t.get_name() for t in \
                             self.plugin_api.get_requester().get_all_tags()]
             matching_tags = filter(lambda t: t.lower() == tag, gtg_all_tags)
             if len(matching_tags) !=  0:
@@ -66,12 +66,10 @@
             self._gtg_task.add_tag(tag)
 
     def _get_text(self):
-        return self._gtg_task.get_excerpt()
-
+        return self._gtg_task.get_excerpt(strip_tags = True, \
+                                          strip_subtasks = True)
     def _set_text(self, text):
         #fill in subtasks
-
-
         self._gtg_task.set_text(text)
 
     def _set_status(self, status):

=== modified file 'GTG/plugins/rtm_sync/rtmProxy.py'
--- GTG/plugins/rtm_sync/rtmProxy.py	2010-03-01 23:15:01 +0000
+++ GTG/plugins/rtm_sync/rtmProxy.py	2010-03-03 02:01:18 +0000
@@ -23,6 +23,7 @@
 #import gobject
 from xdg.BaseDirectory import xdg_config_home
 from GTG.core.task import Task
+from GTG.tools.logger                 import Log
 from GTG import _
 import pickle
 #import xml.utils.iso8601
@@ -44,10 +45,9 @@
     __RTM_STATUSES = [True,
                       False]
 
-    def __init__(self, logger):
+    def __init__(self):
         super(RtmProxy, self).__init__()
         self.token = None
-        self.logger = logger
         self._gtg_to_rtm_status = dict(zip(self.__GTG_STATUSES,
                                             self.__RTM_STATUSES))
         self._gtg_to_rtm_status[Task.STA_DISMISSED] = "1"
@@ -129,16 +129,15 @@
         for task, list_id, taskseries_id in data:
             self._task_list.append(RtmTask(task, list_id, taskseries_id, \
                                           self.rtm, self.timeline, \
-                                          self.logger, self))
-        if self.logger:
-            map(lambda task: self.logger.debug("RTM task: |" + task.title),
-                                               self._task_list)
+                                          self))
+        map(lambda task: Log.debug("RTM task: |" + task.title),
+          self._task_list)
 
     def create_new_task(self, title):
         result = self.rtm.tasks.add(timeline=self.timeline, name=title)
         new_task= RtmTask(result.list.taskseries.task, result.list.id,\
                           result.list.taskseries.id, self.rtm, self.timeline,\
-                         self.logger, self)
+                          self)
         self._task_list.append(new_task)
         return new_task
 

=== modified file 'GTG/plugins/rtm_sync/rtmTask.py'
--- GTG/plugins/rtm_sync/rtmTask.py	2010-02-12 02:46:45 +0000
+++ GTG/plugins/rtm_sync/rtmTask.py	2010-03-03 02:01:18 +0000
@@ -21,19 +21,18 @@
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from genericTask import GenericTask
 
+from GTG.tools.logger import Log
 
 
 class RtmTask(GenericTask):
     
-    def __init__(self, task, list_id, taskseries_id, rtm, timeline, logger,
-                 proxy):
+    def __init__(self, task, list_id, taskseries_id, rtm, timeline, proxy):
         super(RtmTask, self).__init__(proxy)
         self.rtm = rtm
         self.timeline = timeline
         self.task = task
         self.list_id = list_id
         self.taskseries_id = taskseries_id
-        self.logger = logger
         #Checking if a task is recurring is done inside __get_rtm_task_attribute
         # so we call that to set self.recurring correctly
         self.recurring = False
@@ -135,16 +134,22 @@
            hasattr(self.task.notes, 'note'):
             #Rtm saves the notes text inside the member "$t". Don't ask me why.
             if type(self.task.notes.note) == list:
-                return "".join(map(lambda note: getattr(note, '$t') + "\n", \
+                text = "".join(map(lambda note: getattr(note, '$t') + "\n", \
                                 self.task.notes.note))
             else:
-                return getattr(self.task.notes.note, '$t')
-        else:
-            return ""
+                text = getattr(self.task.notes.note, '$t')
+        else:
+            text = ""
+        #adding back the tags (subtasks are added automatically)
+        tags = self.tags
+        if len(tags) > 0:
+            tagstxt = "@" + reduce(lambda x,y: x + ", " + "@" + y, self.tags) + "\n"
+        else:
+            tagstxt = ""
+        return tagstxt + text.strip()
 
     def _set_text(self, text):
         #delete old notes
-        #FIXME: the first check *should* not be necessary (but it is?).
         if hasattr(self.task, 'notes') and \
             hasattr(self.task.notes, 'note'):
             if type(self.task.notes.note) == list:
@@ -155,8 +160,7 @@
                     note_id=id), note_ids)
         #add a new one
         #TODO: investigate what is "Note title",  since there doesn't seem to
-        #be a note
-        # title in the web access.
+        #be a note title in the web access.
         #FIXME: minidom this way is ok, or do we suppose to get multiple
         #      nodes in "content"?
         if text == "":
@@ -168,9 +172,6 @@
                                 note_title = "",\
                                 note_text = text)
 
-
-
-
     def _get_due_date(self):
         if hasattr(self.task,'task'):
             if type(self.task.task) != list:
@@ -179,7 +180,6 @@
                 task = self.task.task[len(self.task.task) - 1]
             if hasattr(task, 'due') and task.due != "":
                 to_return = self.__time_rtm_to_datetime(task.due) 
-                        #   - datetime.timedelta(seconds = time.timezone)
                 return to_return.date()
         return None
 
@@ -223,13 +223,11 @@
 
 
     def __time_rtm_to_datetime(self, string):
-        #FIXME: need to handle time with TIMEZONES!
         string = string.split('.')[0].split('Z')[0]
         return datetime.datetime.strptime(string.split(".")[0], \
                                           "%Y-%m-%dT%H:%M:%S")
 
     def __time_rtm_to_date(self, string):
-        #FIXME: need to handle time with TIMEZONES!
         string = string.split('.')[0].split('Z')[0]
         return datetime.datetime.strptime(string.split(".")[0], "%Y-%m-%d")
 
@@ -244,5 +242,5 @@
         return timeobject.strftime("%Y-%m-%d")
 
     def __log(self, message):
-        if self.logger:
-            self.logger.debug (message)
+        Log.debug(message)
+

=== modified file 'GTG/plugins/rtm_sync/syncEngine.py'
--- GTG/plugins/rtm_sync/syncEngine.py	2010-02-13 10:28:15 +0000
+++ GTG/plugins/rtm_sync/syncEngine.py	2010-03-03 02:01:18 +0000
@@ -29,6 +29,7 @@
 from time import sleep
 import gobject
 from GTG import _
+from GTG.tools.logger import Log
 
 
 
@@ -67,9 +68,8 @@
         super(SyncEngine, self).__init__()
         self.this_plugin = this_plugin
         self.plugin_api = this_plugin.plugin_api
-        self.logger = self.this_plugin.plugin_api.get_logger()
         self.local_proxy = GtgProxy(self.this_plugin.plugin_api)
-        self.remote_proxy = RtmProxy(self.logger)
+        self.remote_proxy = RtmProxy()
         self.rtm_has_logon = False
 
     def rtmLogin(self):
@@ -127,18 +127,20 @@
                                                         local_tasks, \
                                                         self.remote_proxy)
         self._append_to_taskpairs(new_local_tasks, new_remote_tasks)
+        self.update_substatus("")
 
         #Add tasks to the local proxy
-	self.update_status(_("Adding tasks to gtg.."))
+        self.update_status(_("Adding tasks to gtg.."))
         self.update_progressbar(0.4)
         [new_remote_tasks, new_local_tasks] = self._process_new_tasks(\
                                                         new_remote_ids,\
                                                         remote_tasks,\
                                                         self.local_proxy)
         self._append_to_taskpairs(new_local_tasks, new_remote_tasks)
+        self.update_substatus("")
         
         #Delete tasks from the remote proxy
-	self.update_status(_("Deleting tasks from rtm.."))
+        self.update_status(_("Deleting tasks from rtm.."))
         self.update_progressbar(0.5)
         taskpairs_deleted = filter(lambda tp: tp.local_id in deleted_local_ids,\
                                     self.taskpairs)
@@ -146,18 +148,20 @@
         self._process_deleted_tasks(remote_ids_to_delete, remote_tasks,\
                                     self.remote_proxy)
         map(lambda tp: self.taskpairs.remove(tp), taskpairs_deleted)
+        self.update_substatus("")
 
         #Delete tasks from the local proxy
-	self.update_status(_("Deleting tasks from gtg.."))
+        self.update_status(_("Deleting tasks from gtg.."))
         self.update_progressbar(0.6)
         taskpairs_deleted = filter(lambda tp: tp.remote_id in deleted_remote_ids,\
                                     self.taskpairs)
         local_ids_to_delete = map( lambda tp: tp.local_id, taskpairs_deleted)
         self._process_deleted_tasks(local_ids_to_delete, local_tasks, self.local_proxy)
         map(lambda tp: self.taskpairs.remove(tp), taskpairs_deleted)
+        self.update_substatus("")
 
         #Update tasks
-	self.update_status(_("Updating changed tasks.."))
+        self.update_status(_("Updating changed tasks.."))
         self.update_progressbar(0.8)
         local_to_taskpair = self._list_to_dict(self.taskpairs, \
                                                   "local_id", \
@@ -169,7 +173,7 @@
                                                   "id", \
                                                   "self")
         for local_id in updatable_local_ids:
-            if not local_to_taskpair.has_key(local_id):
+            if not local_id in local_to_taskpair:
                 #task has been removed, skipping
                 continue
             taskpair = local_to_taskpair[local_id]
@@ -198,6 +202,7 @@
 
             taskpair.remote_synced_until = remote_task.modified
             taskpair.local_synced_until = local_task.modified
+        self.update_substatus("")
 
         #Lastly, save the list of known links
         self.update_status(_("Saving current state.."))
@@ -262,8 +267,7 @@
                                 remote_task = remote_title_to_task[title]))
 
     def __log(self, message):
-        if self.logger:
-            self.logger.debug(message)
+        Log.debug(message)
 
 ## GUI
     def close_gui(self, msg):

=== modified file 'GTG/plugins/send_email/sendEmail.py'
--- GTG/plugins/send_email/sendEmail.py	2010-02-25 00:49:44 +0000
+++ GTG/plugins/send_email/sendEmail.py	2010-03-03 02:01:18 +0000
@@ -35,7 +35,6 @@
 
     def activate(self, plugin_api):
         self.plugin_api = plugin_api
-        self.logger = self.plugin_api.get_logger()
 
     def onTaskClosed(self, plugin_api):
         pass
@@ -62,12 +61,6 @@
             plugin_api.remove_task_toolbar_item(self.tb_Taskbutton)
             print "ciao"
 
-## HELPER FUNCTIONS ############################################################
-
-    def __log(self, message):
-        if self.logger:
-            self.logger.debug(message)
-
 ## CORE FUNCTIONS ##############################################################
 
     def onTbTaskButton(self, widget, plugin_api):

=== modified file 'GTG/plugins/task_reaper/reaper.py'
--- GTG/plugins/task_reaper/reaper.py	2010-02-15 10:27:58 +0000
+++ GTG/plugins/task_reaper/reaper.py	2010-03-03 02:01:18 +0000
@@ -28,6 +28,7 @@
 from threading           import Timer
 
 from GTG.core.task       import Task
+from GTG.tools.logger    import Log
 
 
 class pluginReaper:
@@ -74,7 +75,6 @@
         self.menu_item_is_shown = False
         self.is_automatic = False
         self.timer = None
-        self.logger = self.plugin_api.get_logger()
         self.preferences_load()
         self.preferences_apply()
 
@@ -91,8 +91,7 @@
 ## HELPER FUNCTIONS ############################################################
 
     def __log(self, message):
-        if self.logger:
-            self.logger.debug(message)
+        Log.debug(message)
 
 ## CORE FUNCTIONS ##############################################################
 

=== modified file 'GTG/plugins/task_reaper/reaper.ui'
--- GTG/plugins/task_reaper/reaper.ui	2010-02-16 01:45:07 +0000
+++ GTG/plugins/task_reaper/reaper.ui	2010-03-03 02:01:18 +0000
@@ -6,6 +6,7 @@
   <object class="GtkWindow" id="preferences_dialog">
     <property name="border_width">10</property>
     <property name="window_position">center-on-parent</property>
+    <property name="type_hint">dialog</property>
     <signal name="delete_event" handler="on_preferences_dialog_delete_event"/>
     <child>
       <object class="GtkVBox" id="vbox1">

=== modified file 'GTG/taskbrowser/__init__.py'
--- GTG/taskbrowser/__init__.py	2009-12-28 15:10:47 +0000
+++ GTG/taskbrowser/__init__.py	2010-03-03 02:01:18 +0000
@@ -18,8 +18,12 @@
 # -----------------------------------------------------------------------------
 
 
-#This is the gnome_frontend package. It's a GTK interface that want to be
-#simple, HIG compliant and well integrated with Gnome.
+"""
+The GTK frontend for browsing collections of tasks.
+
+This is the gnome_frontend package. It's a GTK interface that wants to be
+simple, HIG compliant and well integrated with Gnome.
+"""
 import os
 
 from GTG import _

=== modified file 'GTG/taskbrowser/browser.py'
--- GTG/taskbrowser/browser.py	2010-02-25 00:54:40 +0000
+++ GTG/taskbrowser/browser.py	2010-03-03 02:01:18 +0000
@@ -18,6 +18,7 @@
 # this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------
 
+""" The main window for GTG, listing tags, and open and closed tasks """
 
 #=== IMPORT ===================================================================
 #system imports
@@ -36,12 +37,12 @@
 import GTG
 from GTG import info
 from GTG import _
+from GTG.tools.logger                 import Log
 from GTG.core.task                    import Task
 from GTG.core.tagstore                import Tag
-from GTG.taskeditor.editor            import TaskEditor
 from GTG.taskbrowser                  import GnomeConfig
 from GTG.taskbrowser                  import tasktree
-from GTG.taskbrowser.preferences      import PreferencesDialog
+#from GTG.taskbrowser.preferences      import PreferencesDialog
 from GTG.taskbrowser.tasktree         import TaskTreeModel,\
                                              ActiveTaskTreeView,\
                                              ClosedTaskTreeView
@@ -53,10 +54,6 @@
                                              no_date,\
                                              FuzzyDate
 from GTG.tools                        import clipboard
-from GTG.core.plugins.engine          import PluginEngine
-from GTG.core.plugins.api             import PluginAPI
-
-#=== OBJECTS ==================================================================
 
 #=== MAIN CLASS ===============================================================
 
@@ -69,7 +66,6 @@
 QUICKADD_PANE      = True
 TOOLBAR            = True
 BG_COLOR           = True
-#EXPERIMENTAL_NOTES = False
 TIME = 0
 
 class Timer:
@@ -80,25 +76,23 @@
         print "%s : %s" %(self.st,time.time() - self.start)
 
 class TaskBrowser:
-
-    def __init__(self, requester, config, logger=None):
-
-        self.logger=logger
-
+    """ The UI for browsing open and closed tasks, and listing tags in a tree """
+
+    def __init__(self, requester, vmanager, config):
         # Object prime variables
         self.priv   = {}
         self.req    = requester
-        self.config = config.conf_dict
-        self.task_config = config.task_conf_dict
+        self.vmanager = vmanager
+        self.config = config
+        self.tag_active = False
+        
+        #treeviews handlers
+        self.tags_tv = None
+        self.tasks_tv = None
+        self.ctask_tv = ClosedTaskTreeView()
 
         ### YOU CAN DEFINE YOUR INTERNAL MECHANICS VARIABLES BELOW
-        # Task deletion
-        self.tids_todelete = None # The tid that will be deleted
-        # Editors
-        self.opened_task  = {}   # This is the list of tasks that are already
-                                 # opened in an editor of course it's empty
-                                 # right now
-
+        
         # Setup default values for view
         self._init_browser_config()
 
@@ -124,9 +118,6 @@
         # Initialize "About" dialog
         self._init_about_dialog()
 
-        # Initialize "Preferences" dialog
-        self.preferences = PreferencesDialog(self)
-
         #Create our dictionary and connect it
         self._init_signal_connections()
 
@@ -138,24 +129,12 @@
         # Define accelerator keys
         self._init_accelerators()
         
-        # Initialize the plugin-engine
-        self.p_apis = [] #the list of each plugin apis.
-        self._init_plugin_engine()
-
-        self.refresh_lock = threading.Lock()
-
-        # NOTES
-        #self._init_note_support()
-        
-        #Shared clipboard
-        self.clipboard = clipboard.TaskClipboard(self.req)
-        
-
-        self.tag_active = False
-
         #Autocompletion for Tags
         self._init_tag_list()
         self._init_tag_completion()
+        
+        self.restore_state_from_conf()
+        self.window.show()
 
 ### INIT HELPER FUNCTIONS #####################################################
 #
@@ -170,7 +149,6 @@
         self.priv["ctasklist"]["sort_order"]  = gtk.SORT_ASCENDING
         self.priv['selected_rows']            = None
         self.priv['workview']                 = False
-        #self.priv['noteview']                = False
         self.priv['filter_cbs']               = []
         self.priv['quick_add_cbs']            = []
 
@@ -180,25 +158,18 @@
             gtk.icon_theme_get_default().prepend_search_path(i)
             gtk.window_set_default_icon_name("gtg")
 
+    #FIXME: we should group the initialization by widgets, not by type of methods
+    # it should be "init_active_tasks_pane", "init_sidebar", etc.
     def _init_models(self):
-
-        # Base models
-        self.task_tree_model = TaskTreeModel(requester=self.req)
-        
         # Active Tasks
-        self.task_modelfilter = self.task_tree_model.filter_new()
-        self.task_modelfilter.set_visible_func(self.active_task_visible_func)
-        self.task_modelsort = gtk.TreeModelSort(self.task_modelfilter)
+        self.req.apply_filter('active')
+        self.task_tree_model = TaskTreeModel(self.req)
+        self.task_modelsort = gtk.TreeModelSort(self.task_tree_model)
         self.task_modelsort.set_sort_func(\
             tasktree.COL_DDATE, self.dleft_sort_func)
         self.task_modelsort.set_sort_func(\
             tasktree.COL_DLEFT, self.dleft_sort_func)
-        
-        # Closed Tasks: dismissed and done
-        self.ctask_modelfilter = self.task_tree_model.filter_new()
-        self.ctask_modelfilter.set_visible_func(self.closed_task_visible_func)
-        self.ctask_modelsort = gtk.TreeModelSort(self.ctask_modelfilter)
-        
+
         # Tags
         self.tag_model = TagTreeModel(requester=self.req)
         self.tag_modelfilter = self.tag_model.filter_new()
@@ -207,45 +178,25 @@
         self.tag_modelsort.set_sort_func(\
             tagtree.COL_ID, self.tag_sort_func)
 
-        # Build the "all tags tag"
-        self.alltag_tag = Tag("gtg-tags-all")
-        self.alltag_tag.set_attribute("special","all")
-        self.alltag_tag.set_attribute("label","<span weight='bold'>%s</span>"\
-                                             % _("All tasks"))
-        self.alltag_tag.set_attribute("icon","gtg-tags-all")
-        self.alltag_tag.set_attribute("order",0)
-        # Build the "without tag tag"
-        self.notag_tag = Tag("gtg-tags-none")
-        self.notag_tag.set_attribute("special","notag")
-        self.notag_tag.set_attribute("label","<span weight='bold'>%s</span>"\
-                                             % _("Tasks with no tags"))
-        self.notag_tag.set_attribute("icon","gtg-tags-none")
-        self.notag_tag.set_attribute("order",1)
-        # Build the separator
-        self.sep_tag = Tag("gtg-tags-sep")
-        self.sep_tag.set_attribute("special","sep")
-        self.sep_tag.set_attribute("order",2)
-        # Add them to the model
-        self.tag_model.add_tag(self.alltag_tag.get_name(), self.alltag_tag)
-        self.tag_model.add_tag(self.notag_tag.get_name(), self.notag_tag)
-        self.tag_model.add_tag(self.sep_tag.get_name(), self.sep_tag)
-
     def _init_widget_aliases(self):
         self.window             = self.builder.get_object("MainWindow")
         self.tagpopup           = self.builder.get_object("TagContextMenu")
-        self.nonworkviewtag_checkbox     = self.builder.get_object("nonworkviewtag")
+        self.nonworkviewtag_cb  = self.builder.get_object("nonworkviewtag")
         self.taskpopup          = self.builder.get_object("TaskContextMenu")
         self.defertopopup       = self.builder.get_object("DeferToContextMenu")
-        self.ctaskpopup = \
-            self.builder.get_object("ClosedTaskContextMenu")
+        self.ctaskpopup         = self.builder.get_object("ClosedTaskContextMenu")
         self.editbutton         = self.builder.get_object("edit_b")
-        self.donebutton         = self.builder.get_object("mark_as_done_b")
+        self.edit_mi            = self.builder.get_object("edit_mi")
+        self.donebutton         = self.builder.get_object("done_b")
+        self.done_mi            = self.builder.get_object("done_mi")
         self.deletebutton       = self.builder.get_object("delete_b")
+        self.delete_mi          = self.builder.get_object("delete_mi")
         self.newtask            = self.builder.get_object("new_task_b")
         self.newsubtask         = self.builder.get_object("new_subtask_b")
-        self.dismissbutton      = self.builder.get_object("dismiss")
-        self.about              = self.builder.get_object("aboutdialog1")
-        self.edit_mi            = self.builder.get_object("edit_mi")
+        self.new_subtask_mi     = self.builder.get_object("new_subtask_mi")
+        self.dismissbutton      = self.builder.get_object("dismiss_b")
+        self.dismiss_mi         = self.builder.get_object("dismiss_mi")
+        self.about              = self.builder.get_object("about_dialog")
         self.main_pane          = self.builder.get_object("main_pane")
         self.menu_view_workview = self.builder.get_object("view_workview")
         self.toggle_workview    = self.builder.get_object("workview_toggle")
@@ -255,11 +206,8 @@
         self.quickadd_pane      = self.builder.get_object("quickadd_pane")
         self.sidebar            = self.builder.get_object("sidebar")
         self.sidebar_container  = self.builder.get_object("sidebar-scroll")
-        # Tree views
-        #self.tags_tv             = self.builder.get_object("tag_tview")
-        # NOTES
-        #self.new_note_button    = self.builder.get_object("new_note_button")
-        #self.note_toggle        = self.builder.get_object("note_toggle")
+        
+        self.closed_pane.add(self.ctask_tv)
 
     def _init_ui_widget(self):
         # The Active tasks treeview
@@ -267,11 +215,6 @@
         self.task_tv.set_model(self.task_modelsort)
         self.main_pane.add(self.task_tv)
 
-        # The done/dismissed taks treeview
-        self.ctask_tv = ClosedTaskTreeView()
-        self.ctask_tv.set_model(self.ctask_modelsort)
-        self.closed_pane.add(self.ctask_tv)
-
         # The tags treeview
         self.tags_tv = TagTreeView()
         self.tags_tv.set_model(self.tag_modelsort)
@@ -296,22 +239,15 @@
         self.about.set_translator_credits(info.TRANSLATORS)
 
     def _init_signal_connections(self):
-
         SIGNAL_CONNECTIONS_DIC = {
-#            "on_force_refresh":
-#                self.on_force_refresh,
             "on_add_task":
                 self.on_add_task,
-            "on_add_note":
-                (self.on_add_task, 'Note'),
             "on_edit_active_task":
                 self.on_edit_active_task,
             "on_edit_done_task":
                 self.on_edit_done_task,
-#            "on_edit_note":
-#                self.on_edit_note,
             "on_delete_task":
-                self.on_delete_task,
+                self.on_delete_tasks,
             "on_add_new_tag":
                 self.on_add_new_tag,
             "on_mark_as_done":
@@ -334,10 +270,6 @@
                 self.on_size_allocate,
             "gtk_main_quit":
                 self.on_close,
-            "on_delete_confirm":
-                self.on_delete_confirm,
-            "on_delete_cancel":
-                lambda x: x.hide,
             "on_addtag_confirm":
                 self.on_addtag_confirm,
             "on_addtag_cancel":
@@ -354,8 +286,6 @@
                 self.on_tagcontext_deactivate,
             "on_workview_toggled":
                 self.on_workview_toggled,
-            "on_note_toggled":
-                self.on_note_toggled,
             "on_view_workview_toggled":
                 self.on_workview_toggled,
             "on_view_closed_toggled":
@@ -380,14 +310,13 @@
                 self.on_about_close,
             "on_nonworkviewtag_toggled":
                 self.on_nonworkviewtag_toggled,
+            "on_preferences_activate":
+                self.open_preferences,
         }
-
-        SIGNAL_CONNECTIONS_DIC.update(self.preferences.get_signals_dict())
-
         self.builder.connect_signals(SIGNAL_CONNECTIONS_DIC)
 
         if (self.window):
-            self.window.connect("destroy", gtk.main_quit)
+            self.window.connect("destroy", self.quit)
             #The following is needed to let the Notification Area plugin to
             # minimize the window instead of closing the program
             self.delete_event_handle = \
@@ -404,7 +333,7 @@
             self.on_task_treeview_row_expanded)
         self.task_tv.connect('row-collapsed',\
             self.on_task_treeview_row_collapsed)
-        
+
         # Closed tasks TreeView
         self.ctask_tv.connect('row-activated',\
             self.on_edit_done_task)
@@ -428,7 +357,6 @@
         # Connect requester signals to TreeModels
         self.req.connect("task-added", self.on_task_added) 
         self.req.connect("task-deleted", self.on_task_deleted)
-        self.req.connect("task-modified", self.on_task_modified)
         
         # Connect signals from models
         self.task_modelsort.connect("row-has-child-toggled",\
@@ -452,118 +380,38 @@
         # Set sorting order
         self.task_modelsort.set_sort_column_id(\
             tasktree.COL_DLEFT, gtk.SORT_ASCENDING)
-        self.ctask_modelsort.set_sort_column_id(\
-            tasktree.COL_CDATE, gtk.SORT_DESCENDING)
         self.tag_modelsort.set_sort_column_id(\
             tagtree.COL_ID, gtk.SORT_ASCENDING)
 
+    def _add_accelerator_for_widget(self, agr, name, accel):
+        widget    = self.builder.get_object(name)
+        key, mod  = gtk.accelerator_parse(accel)
+        widget.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
+
     def _init_accelerators(self):
         agr = gtk.AccelGroup()
         self.builder.get_object("MainWindow").add_accel_group(agr)
 
-        view_sidebar = self.builder.get_object("view_sidebar")
-        key, mod     = gtk.accelerator_parse("F9")
-        view_sidebar.add_accelerator("activate", agr, key, mod,\
-            gtk.ACCEL_VISIBLE)
-
-        file_quit = self.builder.get_object("file_quit")
-        key, mod  = gtk.accelerator_parse("<Control>q")
-        file_quit.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
-
-        edit_undo = self.builder.get_object("edit_undo")
-        key, mod  = gtk.accelerator_parse("<Control>z")
-        edit_undo.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
-
-        edit_redo = self.builder.get_object("edit_redo")
-        key, mod  = gtk.accelerator_parse("<Control>y")
-        edit_redo.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
-
-        new_task_mi = self.builder.get_object("new_task_mi")
-        key, mod    = gtk.accelerator_parse("<Control>n")
-        new_task_mi.add_accelerator("activate", agr, key, mod,\
-            gtk.ACCEL_VISIBLE)
-
-        self.new_subtask_mi = self.builder.get_object("new_subtask_mi")
-        key, mod       = gtk.accelerator_parse("<Control><Shift>n")
-        self.new_subtask_mi.add_accelerator("activate", agr, key, mod,\
-            gtk.ACCEL_VISIBLE)
+        self._add_accelerator_for_widget(agr, "view_sidebar",   "F9")
+        self._add_accelerator_for_widget(agr, "file_quit",      "<Control>q")
+        self._add_accelerator_for_widget(agr, "edit_undo",      "<Control>z")
+        self._add_accelerator_for_widget(agr, "edit_redo",      "<Control>y")
+        self._add_accelerator_for_widget(agr, "new_task_mi",    "<Control>n")
+        self._add_accelerator_for_widget(agr, "new_subtask_mi", "<Control><Shift>n")
+        self._add_accelerator_for_widget(agr, "done_mi",        "<Control>d")
+        self._add_accelerator_for_widget(agr, "dismiss_mi",     "<Control>i")
+        self._add_accelerator_for_widget(agr, "delete_mi",      "Cancel")
+        self._add_accelerator_for_widget(agr, "tcm_addtag",     "<Control>t")
+        self._add_accelerator_for_widget(agr, "view_closed",    "<Control>F9")
 
         edit_button = self.builder.get_object("edit_b")
         key, mod    = gtk.accelerator_parse("<Control>e")
-        edit_button.add_accelerator("clicked", agr, key, mod,\
-            gtk.ACCEL_VISIBLE)
-
-        quickadd_field = self.builder.get_object('quickadd_field')
-        key, mod = gtk.accelerator_parse('<Control>l')
-        quickadd_field.add_accelerator(
-            'grab-focus', agr, key, mod, gtk.ACCEL_VISIBLE)
-
-        self.mark_done_mi = self.builder.get_object('mark_done_mi')
-        key, mod = gtk.accelerator_parse('<Control>d')
-        self.mark_done_mi.add_accelerator(
-            'activate', agr, key, mod, gtk.ACCEL_VISIBLE)
-
-        self.dismiss_mi = self.builder.get_object('task_dismiss')
-        key, mod = gtk.accelerator_parse('<Control>i')
-        self.dismiss_mi.add_accelerator(
-            'activate', agr, key, mod, gtk.ACCEL_VISIBLE)
-
-        self.delete_mi = self.builder.get_object('delete_mi')
-        key, mod = gtk.accelerator_parse('Cancel')
-        self.delete_mi.add_accelerator(
-            'activate', agr, key, mod, gtk.ACCEL_VISIBLE)
-        
-        addtag_button = self.builder.get_object('tcm_addtag')
-        key, mod = gtk.accelerator_parse('<Control>t')
-        addtag_button.add_accelerator('activate', agr, key, mod, \
-            gtk.ACCEL_VISIBLE)
-
-        addtag_button = self.builder.get_object('view_closed')
-        key, mod = gtk.accelerator_parse('<Control>F9')
-        addtag_button.add_accelerator('activate', agr, key, mod, \
-            gtk.ACCEL_VISIBLE)
-        
-    def _init_plugin_engine(self):
-        # plugins - Init
-        self.pengine = PluginEngine(GTG.PLUGIN_DIR)
-        # loads the plugins in the plugin dir
-        self.pengine.load_plugins()
-        # initializes the plugin api class
-        self.plugin_api = PluginAPI(window         = self.window,
-                                    config         = self.config,
-                                    data_dir       = GTG.DATA_DIR,
-                                    builder        = self.builder,
-                                    requester      = self.req,
-                                    taskview       = self.task_tv,
-                                    task_modelsort = self.task_modelsort,
-                                    ctaskview      = self.ctask_tv,
-                                    ctask_modelsort= self.ctask_modelsort,
-                                    filter_cbs     = self.priv['filter_cbs'],
-                                    tagpopup       = self.tagpopup,
-                                    tagview        = self.tags_tv,
-                                    task           = None,
-                                    texteditor     = None,
-                                    quick_add_cbs  = self.priv['quick_add_cbs'],
-                                    browser        = self,
-                                    logger         = self.logger)
-        self.p_apis.append(self.plugin_api)
-        # enable some plugins
-        if len(self.pengine.plugins) > 0:
-            # checks the conf for user settings
-            if "plugins" in self.config:
-                if "enabled" in self.config["plugins"]:
-                    plugins_enabled = self.config["plugins"]["enabled"]
-                if "disabled" in self.config["plugins"]:
-                    plugins_disabled = self.config["plugins"]["disabled"]
-                for name, plugin in self.pengine.plugins.iteritems():
-                    if name in plugins_enabled and name not in plugins_disabled:
-                        plugin.enabled = True
-                    else:
-                        # plugins not explicitly enabled are disabled
-                        plugin.enabled = False
-        # initializes and activates each plugin (that is enabled)
-        self.pengine.activate_plugins(self.p_apis)
-    
+        edit_button.add_accelerator("clicked", agr, key, mod, gtk.ACCEL_VISIBLE)
+
+        quickadd_field = self.builder.get_object("quickadd_field")
+        key, mod = gtk.accelerator_parse("<Control>l")
+        quickadd_field.add_accelerator("grab-focus", agr, key, mod, gtk.ACCEL_VISIBLE)
+
     def _init_tag_list(self):
         self.tag_list_model = gtk.ListStore(gobject.TYPE_STRING)
         self.tag_list = self.req.get_all_tags()
@@ -580,22 +428,14 @@
         self.tag_completion.set_inline_selection(True)
         self.tag_completion.set_popup_single_match(False)
 
-#    def _init_note_support(self):
-#        self.notes  = EXPERIMENTAL_NOTES
-#        # Hide notes if disabled
-#        if not self.notes:
-#            self.note_toggle.hide()
-#            self.new_note_button.hide()
-#        #Set the tooltip for the toolbar button
-#        self.new_note_button.set_tooltip_text("Create a new note")
-#        self.note_tview = self.builder.get_object("note_tview")
-#        self.note_tview = gtk.TreeView()
-#        self.note_tview.connect("row-activated", self.on_edit_note)
-#        self.note_tview.show()
-#        self.note_ts    = gtk.TreeStore(gobject.TYPE_PYOBJECT, str, str)
+### HELPER FUNCTIONS ########################################################
 
-### HELPER FUNCTIONS ##########################################################
-#
+    def open_preferences(self,widget):
+        self.vmanager.show_preferences()
+        
+    def quit(self,widget):
+        self.vmanager.close_browser()
+        
     def restore_state_from_conf(self):
 
         # Extract state from configuration dictionary
@@ -635,11 +475,9 @@
             closed_task_pane = eval(
                 self.config["browser"]["closed_task_pane"])
             if not closed_task_pane:
-                self.closed_pane.hide()
-                self.builder.get_object("view_closed").set_active(False)
+                self.hide_closed_pane()
             else:
-                self.closed_pane.show()
-                self.builder.get_object("view_closed").set_active(True)
+                self.show_closed_pane()
 
         if "ctask_pane_height" in self.config["browser"]:
             ctask_pane_height = eval(
@@ -699,36 +537,7 @@
             if odic == "None" or (len(odic)> 0 and odic[0] == "None"):
                 return
             for t in odic:
-                ted = self.open_task(t)
-                #restoring position doesn't work, I don't know why
-                #ted.move(odic[t][0],odic[t][1])
-
-#        if "experimental_notes" in self.config["browser"]:
-#            self.notes = eval(self.config["browser"]["experimental_notes"])
-#            if self.notes:
-#                self.note_toggle.show()
-#                self.new_note_button.show()
-#            else:
-#                self.note_toggle.hide()
-#                self.new_note_button.hide()
-
-    def count_tasks_rec(self, my_task, active_tasks):
-        count = 0
-        for t in my_task.get_subtasks():
-            if t.get_id() in active_tasks:
-                if len(t.get_subtasks()) != 0:
-                    count = count + 1 + self.count_tasks_rec(t, active_tasks)
-                else:
-                    count = count + 1
-        return count
-
-    def _count_subtask(self, model, iter):
-        count = 0
-        c = model.iter_children(iter)
-        while c:
-            count = count + 1 + self._count_subtask(model, c)
-            c = model.iter_next(c)
-        return count
+                ted = self.vmanager.open_task(t)
 
     
     def _start_gtg_maximized(self):
@@ -740,21 +549,21 @@
         #We have to be careful here to avoid a loop of signals
         #menu_state   = self.menu_view_workview.get_active()
         #button_state = self.toggle_workview.get_active()
-        #We cannot have note and workview at the same time
-#        if not self.priv['workview'] and self.note_toggle.get_active():
-#            self.note_toggle.set_active(False)
         #We do something only if both widget are in different state
         tobeset = not self.priv['workview']
         self.menu_view_workview.set_active(tobeset)
         self.toggle_workview.set_active(tobeset)
         self.priv['workview'] = tobeset
         self.tag_model.set_workview(self.priv['workview'])
-        self.task_modelfilter.refilter()
+        if tobeset:
+            self.req.apply_filter('workview')
+        else:
+            self.req.unapply_filter('workview')
         self.tag_modelfilter.refilter()
         self._update_window_title()
 
     def _update_window_title(self):
-        count = self.get_n_active_tasks()
+        count = self.req.get_main_n_tasks()
         #Set the title of the window:
         parenthesis = ""
         if count == 0:
@@ -825,125 +634,10 @@
             return no_date
         return strtodate(date)
 
-    def open_task(self, uid,thisisnew=False):
-        """Open the task identified by 'uid'.
-
-        If a Task editor is already opened for a given task, we present it.
-        Else, we create a new one.
-        """
-        t = self.req.get_task(uid)
-        tv = None
-        if uid in self.opened_task:
-            tv = self.opened_task[uid]
-            tv.present()
-        elif t:
-            tv = TaskEditor(
-                self.req, t, self.pengine.plugins.values(), \
-                self.on_delete_task, self.close_task, self.open_task, \
-                self.get_tasktitle,taskconfig=self.task_config, \
-                plugin_apis=self.p_apis,thisisnew=thisisnew,\
-                clipboard = self.clipboard)
-            #registering as opened
-            self.opened_task[uid] = tv
-        return tv
-
     def get_tasktitle(self, tid):
         task = self.req.get_task(tid)
         return task.get_title()
 
-    def close_task(self, tid):
-        # When an editor is closed, it should deregister itself.
-        if tid in self.opened_task:
-            del self.opened_task[tid]
-
-    def is_task_visible(self, task):
-        """Returns True if the task meets the criterion to be displayed
-        @param  task: the task to assess
-        """
-        
-        # Checks to see if we're working with a tag through a right click
-        # menu item. If we are, we'll treat the tag that was selected
-        # previous to the right click as the currently selected tag,
-        # even if the cursor is somewhere else.
-        if self.tag_active:
-            tag_list, notag_only = self.previous_tag
-        else:
-            tag_list, notag_only = self.get_selected_tags()
-
-        if len(tag_list)==1: #include child tags
-            tag_list = tag_list[0].all_children()
-
-        if not task.has_tags(tag_list=tag_list, notag_only=notag_only):
-            return False
-        
-        #if workview is enabled
-        if self.priv['workview']:
-            res = True
-            
-            # filter tasks view callbacks
-            for cb in self.priv['filter_cbs']:
-                res = cb(task.get_id())
-                if res == False:
-                    return False
-            
-            #we verify that the task is started
-            if not task.is_started() :
-                return False
-                    
-            #we verify that there is no non-workview tag for this task
-            for t in task.get_tags():
-                if t.get_attribute("nonworkview") and t not in tag_list:
-                    res = res and (not eval(t.get_attribute("nonworkview")))
-            return res and task.is_workable()
-        else:
-            return True
-
-    def is_lineage_visible(self, task):
-        """Returns True if at least one set of tasks that compose a lineage of
-        the given task can be found where all the tasks meets the criterion
-        to be displayed. (i.e.: there exists a chain of tasks from root to task
-        that can all be displayed)
-        @param task: the task whose lineage will be assessed
-        """
-        res = False
-        parents = task.get_parents()
-        for par_tid in parents:
-            par_task = self.req.get_task(par_tid)
-            if par_task.has_parents():
-                res = res or (self.is_task_visible(par_task) and self.is_lineage_visible(par_task))
-            else:
-                res = res or self.is_task_visible(par_task)
-        return res
-
-    def active_task_visible_func(self, model, iter, user_data=None):
-        """Return True if the row must be displayed in the treeview.
-        @param model: the model of the filtered treeview
-        @param iter: the iter whose visiblity must be evaluated
-        @param user_data:
-        """
-        task = model.get_value(iter, tasktree.COL_OBJ)
-        if not task or task.get_status() != Task.STA_ACTIVE:
-            return False
-        if not model.iter_parent(iter):
-            return self.is_task_visible(task) and not self.is_lineage_visible(task)
-        return self.is_task_visible(task)
-               
-    def closed_task_visible_func(self, model, iter, user_data=None):
-        """Return True if the row must be displayed in the treeview.
-        @param model: the model of the filtered treeview
-        @param iter: the iter whose visiblity must be evaluated
-        @param user_data:
-        """
-        tag_list, notag_only = self.get_selected_tags()
-        task = model.get_value(iter, tasktree.COL_OBJ)
-        if len(tag_list)==1: #include child tags
-            tag_list = tag_list[0].all_children()
-        if not task.has_tags(tag_list=tag_list, notag_only=notag_only):
-            return False
-        return task.get_status() != Task.STA_ACTIVE and\
-            not model.iter_parent(iter)
-                  
-
     def tag_visible_func(self, model, iter, user_data=None):
         """Return True if the row must be displayed in the treeview.
         @param model: the model of the filtered treeview
@@ -969,13 +663,17 @@
             return True
 
     def dleft_sort_func(self, model, iter1, iter2, user_data=None):
-        order = self.task_tv.get_model().get_sort_column_id()[1]
+        order = self.task_modelsort.get_sort_column_id()[1]
         task1 = model.get_value(iter1, tasktree.COL_OBJ)
         task2 = model.get_value(iter2, tasktree.COL_OBJ)
-        t1_dleft = task1.get_due_date()
-        t2_dleft = task2.get_due_date()
+        if task1 and task2:
+            t1_dleft = task1.get_due_date()
+            t2_dleft = task2.get_due_date()
+            sort = cmp(t2_dleft, t1_dleft)
+        else:
+            sort = -1
         
-        sort = 0
+        #sort = 0
         
         def reverse_if_descending(s):
             """Make a cmp() result relative to the top instead of following 
@@ -985,7 +683,7 @@
             else:
                 return -1 * s
         
-        sort = cmp(t2_dleft, t1_dleft)
+        
         
         if sort == 0:
             # Put fuzzy dates below real dates
@@ -1105,15 +803,6 @@
             view = "workview"
         else:
             view = "default"
-        
-        # plugins are deactivated
-        self.pengine.deactivate_plugins(self.p_apis)
-        
-        #save opened tasks and their positions.
-        open_task = []
-        for otid in self.opened_task.keys():     
-            open_task.append(otid)
-            self.opened_task[otid].close()
 
         # Populate configuration dictionary
         self.config["browser"] = {
@@ -1145,28 +834,12 @@
                 quickadd_pane,
             'view':
                 view,
-            'opened_tasks':
-                open_task,
             }
         if   sort_column is not None and sort_order == gtk.SORT_ASCENDING:
             self.config["browser"]["tasklist_sort"]  = [sort_column, 0]
         elif sort_column is not None and sort_order == gtk.SORT_DESCENDING:
             self.config["browser"]["tasklist_sort"]  = [sort_column, 1]
         self.config["browser"]["view"] = view
-#        if self.notes:
-#            self.config["browser"]["experimental_notes"] = True
-        
-        # adds the plugin settings to the conf
-        if len(self.pengine.plugins) > 0:
-            self.config["plugins"] = {}
-            self.config["plugins"]["disabled"] = \
-              self.pengine.disabled_plugins().keys()
-            self.config["plugins"]["enabled"] = \
-              self.pengine.enabled_plugins().keys()
-
-    def on_force_refresh(self, widget):
-        if self.refresh_lock.acquire(False):
-            gobject.idle_add(self.general_refresh)
 
     def on_about_clicked(self, widget):
         self.about.show()
@@ -1189,8 +862,8 @@
         #fact we should have a TagPropertiesEditor (like for project) Also,
         #color change should be immediate. There's no reason for a Ok/Cancel
         self.set_target_cursor()
-        dialog = gtk.ColorSelectionDialog('Choose color')
-        colorsel = dialog.colorsel
+        color_dialog = gtk.ColorSelectionDialog('Choose color')
+        colorsel = color_dialog.colorsel
         colorsel.connect("color_changed", self.on_color_changed)
 
         # Get previous color
@@ -1203,7 +876,7 @@
                 colorsel.set_previous_color(colorspec)
                 colorsel.set_current_color(colorspec)
                 init_color = colorsel.get_current_color()
-        response = dialog.run()
+        response = color_dialog.run()
         # Check response and set color if required
         if response != gtk.RESPONSE_OK and init_color:
             strcolor = gtk.color_selection_palette_to_string([init_color])
@@ -1212,7 +885,7 @@
                 t.set_attribute("color", strcolor)
         self.reset_cursor()
         self.task_tv.refresh()
-        dialog.destroy()
+        color_dialog.destroy()
         
     def on_resetcolor_activate(self, widget):
         self.set_target_cursor()
@@ -1238,18 +911,29 @@
             view_sidebar.set_active(True)
             self.sidebar.show()
 
-    def on_note_toggled(self, widget):
-        self.priv['noteview'] = not self.priv['noteview']
-        workview_state = self.toggle_workview.get_active()
-        if workview_state:
-            self.toggle_workview.set_active(False)
-        #self.do_refresh()
-
     def on_closed_toggled(self, widget):
         if widget.get_active():
-            self.closed_pane.show()
+            self.show_closed_pane()
         else:
-            self.closed_pane.hide()
+            self.hide_closed_pane()
+            
+    def show_closed_pane(self):
+        # The done/dismissed taks treeview
+        self.ctask_tree = self.req.get_custom_tasks_tree()
+        self.ctask_tree.apply_filter('closed')
+        ctask_tree_model = TaskTreeModel(self.req,self.ctask_tree)
+        ctask_modelsort = gtk.TreeModelSort(ctask_tree_model)
+        self.ctask_tv.set_model(ctask_modelsort)
+        ctask_modelsort.set_sort_column_id(\
+            tasktree.COL_CDATE, gtk.SORT_DESCENDING)
+        self.closed_pane.show()
+        self.builder.get_object("view_closed").set_active(True)
+
+    def hide_closed_pane(self):
+        self.closed_pane.hide()
+        self.ctask_tv.set_model(None)
+        self.ctask_tree = None
+        self.builder.get_object("view_closed").set_active(False)
 
     def on_bg_color_toggled(self, widget):
         if widget.get_active():
@@ -1260,8 +944,6 @@
             self.priv["bg_color_enable"] = False
             self.task_tv.set_bg_color(False)
             self.ctask_tv.set_bg_color(False)
-        self.task_tv.refresh()
-        self.ctask_tv.refresh()
 
     def on_toolbar_toggled(self, widget):
         if widget.get_active():
@@ -1281,7 +963,7 @@
             self.task_tv.expand_row(path, False)
         else:
             self.task_tv.collapse_row(path)
-            
+
     def on_task_treeview_row_expanded(self, treeview, iter, path):
         tid = treeview.get_model().get_value(iter, tasktree.COL_TID)
         if tid in self.priv["collapsed_tids"]:
@@ -1291,8 +973,7 @@
         tid = treeview.get_model().get_value(iter, tasktree.COL_TID)
         if tid not in self.priv["collapsed_tids"]:
             self.priv["collapsed_tids"].append(tid)
-            
-    
+
     def on_tag_child_toggled(self, model, path, iter):
         tag = model.get_value(iter, tagtree.COL_ID)
         if tag not in self.priv.get("collapsed_tags", []):
@@ -1309,8 +990,6 @@
         tag = treeview.get_model().get_value(iter, tagtree.COL_ID)
         if tag not in self.priv["collapsed_tags"]:
             self.priv["collapsed_tags"].append(tag)
-        
-   
 
     def on_quickadd_activate(self, widget):
         text = self.quickadd_entry.get_text()
@@ -1363,7 +1042,6 @@
             task.set_due_date(due_date)
             task.set_start_date(defer_date)
             id_toselect = task.get_id()
-            #############
             self.quickadd_entry.set_text('')
             # Refresh the treeview
             #self.do_refresh(toselect=id_toselect)
@@ -1424,14 +1102,12 @@
     def on_nonworkviewtag_toggled(self, widget):
         self.set_target_cursor()
         tags = self.get_selected_tags()[0]
-        nonworkview_item = self.nonworkviewtag_checkbox
         #We must inverse because the tagstore has True
         #for tasks that are not in workview (and also convert to string)
-        toset = str(not nonworkview_item.get_active())
+        toset = str(not self.nonworkview_cb.get_active())
         if len(tags) > 0:
             tags[0].set_attribute("nonworkview", toset)
         if self.priv['workview']:
-            self.task_modelfilter.refilter()
             self.tag_modelfilter.refilter()
         if not self.dont_reset:
             self.reset_cursor()
@@ -1452,7 +1128,7 @@
 
     def on_task_treeview_key_press_event(self, treeview, event):
         if gtk.gdk.keyval_name(event.keyval) == "Delete":
-            self.on_delete_task()
+            self.on_delete_tasks()
 
     def on_closed_task_treeview_button_press_event(self, treeview, event):
         if event.button == 3:
@@ -1469,7 +1145,7 @@
 
     def on_closed_task_treeview_key_press_event(self, treeview, event):
         if gtk.gdk.keyval_name(event.keyval) == "Delete":
-            self.on_delete_task()
+            self.on_delete_tasks()
 
     def on_add_task(self, widget, status=None):
         tags, notagonly = self.get_selected_tags()
@@ -1477,7 +1153,7 @@
         uid = task.get_id()
         if status:
             task.set_status(status)
-        self.open_task(uid,thisisnew=True)
+        self.vmanager.open_task(uid,thisisnew=True)
 
     def on_add_subtask(self, widget):
         uid = self.get_selected_task()
@@ -1486,87 +1162,29 @@
             tags   = zetask.get_tags()
             task   = self.req.new_task(tags=tags, newtask=True)
             task.add_parent(uid)
-            zetask.add_subtask(task.get_id())
-            self.open_task(task.get_id(),thisisnew=True)
+            zetask.add_child(task.get_id())
+            self.vmanager.open_task(task.get_id(),thisisnew=True)
             #self.do_refresh()
 
     def on_edit_active_task(self, widget, row=None, col=None):
         tid = self.get_selected_task()
         if tid:
-            self.open_task(tid)
+            self.vmanager.open_task(tid)
 
     def on_edit_done_task(self, widget, row=None, col=None):
         tid = self.get_selected_task(self.ctask_tv)
         if tid:
-            self.open_task(tid)
-
-#    def on_edit_note(self, widget, row=None, col=None):
-#        tid = self.get_selected_task(self.note_tview)
-#        if tid:
-#            self.open_task(tid)
-
-    def on_delete_confirm(self, widget):
-        """if we pass a tid as a parameter, we delete directly
-        otherwise, we will look which tid is selected"""
-        for tid in self.tids_todelete:
-            self.req.delete_task(tid)
-            if tid in self.opened_task:
-                self.opened_task[tid].close()
-        self.tids_todelete = None
-        if self.refresh_lock.acquire(False):
-            gobject.idle_add(self.general_refresh)
-
-    def on_delete_task(self, widget=None, tid=None):
+            self.vmanager.open_task(tid)
+
+    def on_delete_tasks(self, widget=None, tid=None):
         #If we don't have a parameter, then take the selection in the treeview
         if not tid:
             #tid_to_delete is a [project,task] tuple
-            self.tids_todelete = self.get_selected_tasks()
-        else:
-            self.tids_todelete = [tid]
-        #We must at least have something to delete !
-        if len(self.tids_todelete) > 0:
-            # We fill the text and the buttons' labels according to the number 
-            # of tasks to delete
-            label = self.builder.get_object("label1")
-            label_text = label.get_text()
-            cdlabel2 = self.builder.get_object("cd-label2")
-            cdlabel3 = self.builder.get_object("cd-label3")
-            cdlabel4 = self.builder.get_object("cd-label4")
-            if len(self.tids_todelete) == 1:
-                label_text = _("Deleting a task cannot be undone, and will delete the following task: ")
-                cdlabel2.set_label(_("Are you sure you want to delete this task?"))
-                cdlabel3.set_label(_("Keep selected task"))
-                cdlabel4.set_label(_("Permanently remove task"))
-            else:
-                label_text = _("Deleting a task cannot be undone, and will delete the following tasks: ")
-                cdlabel2.set_label(_("Are you sure you want to delete these tasks?"))
-                cdlabel3.set_label(_("Keep selected tasks"))
-                cdlabel4.set_label(_("Permanently remove tasks"))
-            label_text = label_text[0:label_text.find(":") + 1]
-            
-            # I find the tasks that are going to be deleted
-            tasks = []
-            for tid in self.tids_todelete:
-                def recursive_list_tasks(task_list, root):
-                    """Populate a list of all the subtasks and 
-                       their children, recursively"""
-                    if root not in task_list:
-                        task_list.append(root)
-                        for i in root.get_subtasks():
-                            recursive_list_tasks(task_list, i)
-                task = self.req.get_task(tid)
-                recursive_list_tasks(tasks, task)
-            titles_list = [task.get_title() for task in tasks]
-            titles = reduce (lambda x, y: x + "\n - " + y, titles_list)
-            label.set_text("%s %s" % (label_text, "\n - " + titles))
-            delete_dialog = self.builder.get_object("confirm_delete")
-            delete_dialog.run()
-            delete_dialog.hide()
-            #has the task been deleted ?
-            return not self.tids_todelete
-        else:
-            return False
-    
+            tids_todelete = self.get_selected_tasks()
+        else:
+            tids_todelete = [tid]
+        self.vmanager.ask_delete_tasks(tids_todelete)
+
     def update_start_date(self, widget, new_start_date):
         tasks_uid = filter(lambda uid: uid != None, self.get_selected_tasks())
         if len(tasks_uid) == 0:
@@ -1575,8 +1193,6 @@
         tasks_status = [task.get_status() for task in tasks]
         for uid, task, status in zip(tasks_uid, tasks, tasks_status):
             task.set_start_date(self.get_canonical_date(new_start_date))
-        if self.refresh_lock.acquire(False):
-            gobject.idle_add(self.general_refresh)
         #FIXME: If the task dialog is displayed, refresh its start_date widget
 
     def on_mark_as_started(self, widget):
@@ -1610,7 +1226,7 @@
                 apply_to_subtasks.set_active(False)
                 tag_entry.set_completion(self.tag_completion)
             tag_entry.grab_focus()
-            addtag_dialog = self.builder.get_object("TaskAddTag")
+            addtag_dialog = self.builder.get_object("addtag_dialog")
             addtag_dialog.run()
             addtag_dialog.hide()
             self.tids_to_addtag = None            
@@ -1619,7 +1235,7 @@
     
     def on_addtag_confirm(self, widget):
         tag_entry = self.builder.get_object("tag_entry")
-        addtag_dialog = self.builder.get_object("TaskAddTag")
+        addtag_dialog = self.builder.get_object("addtag_dialog")
         apply_to_subtasks = self.builder.get_object("apply_to_subtasks")
         addtag_error = False
         entry_text = tag_entry.get_text()
@@ -1672,7 +1288,6 @@