root/trunk/libtinymailui-gtk/tny-gtk-folder-store-tree-model.c

/* libtinymailui-gtk - The Tiny Mail UI library for Gtk+
 * Copyright (C) 2006-2007 Philip Van Hoof <pvanhoof@gnome.org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with self library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */


/**
 * TnyGtkFolderStoreTreeModel:
 *
 * A #GtkTreeModel for #TnyFolderStore instances that'll become #TnyFolderStoreObserver
 * and #TnyFolderObserver (in case the #TnyFolderStore instance is a #TnyFolder
 * too) of each added #TnyFolderStore and each of its children en grandchildren
 * (recursively).
 *
 * It will detect changes in the instance's tree structure this way and it will
 * adapt itself to a new situation automatically. It also contains columns that
 * contain certain popular numbers (like the unread and the total counts of
 * #TnyFolder instances).
 *
 * Note that a #TnyGtkFolderStoreTreeModel is a #TnyList too. You can use the
 * #TnyList API on instances of this type too.
 *
 * Note that you must make sure that you unreference #TnyFolderStore instances
 * that you get out of the instance column of this type using the #GtkTreeModel
 * API gtk_tree_model_get().
 *
 * free-function: g_object_unref
 **/

#include <config.h>
#include <string.h>

#include <glib.h>
#include <gtk/gtk.h>
#include <glib/gi18n-lib.h>

#include <tny-list.h>
#include <tny-iterator.h>
#include <tny-folder.h>
#include <tny-folder-store.h>
#include <tny-simple-list.h>
#include <tny-merge-folder.h>

#include <tny-store-account.h>
#include <tny-folder-store-change.h>
#include <tny-folder-store-observer.h>
#include <tny-folder-change.h>
#include <tny-folder-observer.h>

#include <tny-gtk-folder-store-tree-model.h>

#include "tny-gtk-folder-store-tree-model-iterator-priv.h"

#define PATH_SEPARATOR " "

static GObjectClass *parent_class = NULL;

typedef void (*treeaddfunc) (GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *parent);


static void 
add_folder_observer_weak (TnyGtkFolderStoreTreeModel *self, TnyFolder *folder)
{
        if (TNY_IS_FOLDER (folder)) {
                tny_folder_add_observer (folder, TNY_FOLDER_OBSERVER (self));
                self->fol_obs = g_list_prepend (self->fol_obs, folder);
        }
}

static void 
add_folder_store_observer_weak (TnyGtkFolderStoreTreeModel *self, TnyFolderStore *store)
{
        if (TNY_IS_FOLDER_STORE (store)) {
                tny_folder_store_add_observer (store, TNY_FOLDER_STORE_OBSERVER (self));
                self->store_obs = g_list_prepend (self->store_obs, store);
        }
}

static void 
remove_folder_observer_weak (TnyGtkFolderStoreTreeModel *self, TnyFolder *folder, gboolean final)
{
        if (TNY_IS_FOLDER (folder)) {
                if (!final)
                        self->fol_obs = g_list_remove (self->fol_obs, folder);
                tny_folder_remove_observer (folder, (TnyFolderObserver *) self);
        }
}

static void 
remove_folder_store_observer_weak (TnyGtkFolderStoreTreeModel *self, TnyFolderStore *store, gboolean final)
{
        if (TNY_IS_FOLDER_STORE (store)) {
                if (!final)
                        self->store_obs = g_list_remove (self->store_obs, store);
                tny_folder_store_remove_observer (store, (TnyFolderStoreObserver *) self);
        }
}

static void
recurse_folders_sync (TnyGtkFolderStoreTreeModel *self, 
                      TnyFolderStore *store, 
                      const gchar *parent_name,
                      GtkTreeIter *parent_tree_iter)
{
        TnyIterator *iter;
        TnyList *folders = tny_simple_list_new ();

        /* TODO add error checking and reporting here */
        tny_folder_store_get_folders (store, folders, self->query, TRUE, NULL);
        iter = tny_list_create_iterator (folders);

        if (parent_name == NULL)
                parent_name = "";

        while (!tny_iterator_is_done (iter))
        {
                GtkTreeModel *mmodel = (GtkTreeModel *) self;
                GtkTreeStore *model = GTK_TREE_STORE (self);
                GObject *instance = G_OBJECT (tny_iterator_get_current (iter));
                GtkTreeIter tree_iter;
                TnyFolder *folder = NULL;
                TnyFolderStore *folder_store = NULL;
                GtkTreeIter miter;
                gboolean found = FALSE;
                GObject *mark_for_removal = NULL;

                if (instance && (TNY_IS_FOLDER (instance) || TNY_IS_MERGE_FOLDER (instance)))
                        folder = TNY_FOLDER (instance);

                if (instance && (TNY_IS_FOLDER_STORE (instance)))
                        folder_store = TNY_FOLDER_STORE (instance);

                /* We check whether we have this folder already in the tree, or 
                 * whether it's a brand new one. If it's a new one, we'll add
                 * it, of course */

                if (gtk_tree_model_iter_children (mmodel, &miter, parent_tree_iter))
                  do
                  {
                        GObject *citem = NULL;
                        TnyIterator *niter = NULL;
                        
                        gtk_tree_model_get (mmodel, &miter, 
                                TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, 
                                &citem, -1);

                        if (citem == instance)
                        {
                                found = TRUE;
                                if (citem)
                                        g_object_unref (citem);
                                break;
                        }

                        /* We search whether this folder that we have in the 
                         * model, still exists in the actual list. Because if
                         * not, it probably got removed remotely (and we need
                         * to get rid of it in the model now) */

                        niter = tny_list_create_iterator (folders);
                        while (!tny_iterator_is_done (niter))
                        {
                                TnyFolder *ifound = TNY_FOLDER (tny_iterator_get_current (niter));
                                if (citem == (GObject *) ifound) {
                                        if (mark_for_removal)
                                                g_object_unref (mark_for_removal);
                                        mark_for_removal = g_object_ref (ifound);
                                }
                                g_object_unref (ifound);
                                tny_iterator_next (niter);
                        }
                        g_object_unref (niter);

                        if (citem)
                                g_object_unref (citem);

                  } while (gtk_tree_model_iter_next (mmodel, &miter));

                /* It was not found, so let's start adding it to the model! */

                if (!found)
                {
                        gchar *name;
                        gtk_tree_store_append (model, &tree_iter, parent_tree_iter);

                        /* Making self both a folder-store as a folder observer
                         * of this folder. This way we'll get notified when 
                         * both a removal and a creation happens. Also when a 
                         * rename happens: that's a removal and a creation. */

                        if (folder)
                        {
                                /* This adds a reference count to folder too. When it gets removed, that
                                   reference count is decreased automatically by the gtktreestore infra-
                                   structure. */

                                add_folder_observer_weak (self, folder);

                                if (self->flags & TNY_GTK_FOLDER_STORE_TREE_MODEL_FLAG_SHOW_PATH) {
                                        if ((parent_name == NULL) || *parent_name == '\0') {
                                                name = g_strdup (tny_folder_get_name (folder));
                                        } else {
                                                name = g_strconcat (parent_name,
                                                                    PATH_SEPARATOR,
                                                                    tny_folder_get_name (folder), 
                                                                    NULL);
                                        }
                                } else {
                                        name = g_strdup (tny_folder_get_name (folder));
                                }

                                gtk_tree_store_set  (model, &tree_iter,
                                        TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN, 
                                        name,
                                        TNY_GTK_FOLDER_STORE_TREE_MODEL_UNREAD_COLUMN, 
                                        tny_folder_get_unread_count (TNY_FOLDER (folder)),
                                        TNY_GTK_FOLDER_STORE_TREE_MODEL_ALL_COLUMN, 
                                        tny_folder_get_all_count (TNY_FOLDER (folder)),
                                        TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN,
                                        tny_folder_get_folder_type (TNY_FOLDER (folder)),
                                        TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,
                                        folder, -1);

                        } else {
                                name = g_strdup (tny_folder_get_name (folder));
                        }

                        /* it's a store by itself, so keep on recursing */
                        if (folder_store) {
                                add_folder_store_observer_weak (self, folder_store);
                                recurse_folders_sync (self, folder_store, name, &tree_iter);
                        }

                        g_free (name);

                        /* We're a folder, we'll request a status, since we've
                         * set self to be a folder observers of folder, we'll 
                         * receive the status update. This makes it possible to
                         * instantly get the unread and total counts, of course.
                         * 
                         * Note that the initial value is read from the cache in
                         * case the account is set offline, in TnyCamelFolder. 
                         * In case the account is online a STAT for POP or a 
                         * STATUS for IMAP is asked during the poke-status impl.
                         *
                         * This means that no priv->folder must be loaded, no
                         * memory peak will happen, few data must be transmitted
                         * in case we're online. Which is perfect! */

                        if (folder)
                                tny_folder_poke_status (TNY_FOLDER (folder));

                        if (mark_for_removal) {
                                g_object_unref (mark_for_removal);
                                mark_for_removal = NULL;
                        }

                } else {
                        if (mark_for_removal) {
                                g_object_unref (mark_for_removal);
                                mark_for_removal = NULL;
                        }
                }

                g_object_unref (instance);

                tny_iterator_next (iter);
        }

        g_object_unref (iter);
        g_object_unref (folders);
}


static const gchar*
get_root_name (TnyFolderStore *folder_store)
{
        const gchar *root_name;
        if (TNY_IS_ACCOUNT (folder_store))
                root_name = tny_account_get_name (TNY_ACCOUNT (folder_store));
        else
                root_name = _("Folder bag");
        return root_name;
}


static void
get_folders_cb (TnyFolderStore *fstore, gboolean cancelled, TnyList *list, GError *err, gpointer user_data)
{
        TnyGtkFolderStoreTreeModel *self = (TnyGtkFolderStoreTreeModel *) user_data;
        GtkTreeModel *model = GTK_TREE_MODEL (self);
        GtkTreeIter iter;
        GtkTreeIter name_iter;
        gboolean found = FALSE;

        g_object_unref (list);

        /* Note that the very first time, this code will pull all folder info.
         * Note that when it runs, you'll see LIST commands happen on the IMAP
         * socket. Especially the first time. You'll also see STATUS commands 
         * happen. This is, indeed, normal behaviour when this component is used.*/

        /* But first, let's find-back that damn account so that we have the
         * actual iter behind it in the model. */

        if (gtk_tree_model_get_iter_first (model, &iter))
          do 
          {
                GObject *citem;

                gtk_tree_model_get (model, &iter, 
                        TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, 
                        &citem, -1);

                if (citem == (GObject *) fstore)
                {
                        name_iter = iter;
                        found = TRUE;
                        if (citem)
                                g_object_unref (citem);
                        break;
                }

                g_object_unref (citem);

          } while (gtk_tree_model_iter_next (model, &iter));

        /* We found it, so we'll now just recursively start asking for all its
         * folders and subfolders. The recurse_folders_sync can indeed cope with
         * folders that already exist (it wont add them a second time). */

        if (found)
                recurse_folders_sync (self, fstore, NULL, &name_iter);

        g_object_unref (self);

        return;
}

static void 
tny_gtk_folder_store_tree_model_on_constatus_changed (TnyAccount *account, TnyConnectionStatus status, TnyGtkFolderStoreTreeModel *self)
{
        TnyList *list = NULL;

        if (!self || !TNY_IS_GTK_FOLDER_STORE_TREE_MODEL (self))
                return;

        /* This callback handler deals with connection status changes. In case
         * we got connected, we can expect that, at least sometimes, new folders
         * might have arrived. We'll need to scan for those, so we'll recursively
         * start asking the account about its folders. */

        if (status == TNY_CONNECTION_STATUS_RECONNECTING || status == TNY_CONNECTION_STATUS_DISCONNECTED)
                return;

        list = tny_simple_list_new ();
        tny_folder_store_get_folders_async (TNY_FOLDER_STORE (account), 
                list, self->query, TRUE, get_folders_cb, NULL, g_object_ref (self));

        return;
}



static void 
tny_gtk_folder_store_tree_model_on_changed (TnyAccount *account, TnyGtkFolderStoreTreeModel *self)
{
        GtkTreeModel *model = GTK_TREE_MODEL (self);
        GtkTreeIter iter;
        GtkTreeIter name_iter;
        gboolean found = FALSE;

        if (gtk_tree_model_get_iter_first (model, &iter))
          do 
          {
                GObject *citem = NULL;

                gtk_tree_model_get (model, &iter, 
                        TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, 
                        &citem, -1);

                if (citem == (GObject *) account)
                {
                        name_iter = iter;
                        found = TRUE;
                        if (citem)
                                g_object_unref (citem);
                        break;
                }

                if (citem)
                        g_object_unref (citem);

          } while (gtk_tree_model_iter_next (model, &iter));

        if (found) {
                gtk_tree_store_set (GTK_TREE_STORE (model), &name_iter,
                        TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN, 
                        get_root_name (TNY_FOLDER_STORE (account)), -1);
        }
}

typedef struct
{
        GObject *instance;
        guint handler_id;
} SignalSlot;

typedef struct
{
        TnyGtkFolderStoreTreeModel *self;
        TnyAccount *account;
} AccNotYetReadyInfo;

static void 
notify_signal_slots (gpointer user_data, GObject *instance)
{
        TnyGtkFolderStoreTreeModel *self = (TnyGtkFolderStoreTreeModel *) user_data;
        int i=0;

        for (i=0; i < self->signals->len; i++) {
                SignalSlot *slot = (SignalSlot *) self->signals->pdata[i];
                if (slot->instance == instance)
                        slot->instance = NULL;
        }
}

static gboolean
account_was_not_yet_ready_idle (gpointer user_data)
{
        AccNotYetReadyInfo *info = (AccNotYetReadyInfo *) user_data;
        gboolean repeat = TRUE;

        if (tny_account_is_ready (info->account))
        {
                SignalSlot *slot;

                slot = g_slice_new (SignalSlot);
                slot->instance = (GObject *) info->account;
                slot->handler_id = g_signal_connect (info->account, "connection-status-changed",
                        G_CALLBACK (tny_gtk_folder_store_tree_model_on_constatus_changed), info->self);
                g_object_weak_ref (G_OBJECT (info->account), notify_signal_slots, info->self);
                g_ptr_array_add (info->self->signals, slot);

                slot = g_slice_new (SignalSlot);
                slot->instance = (GObject *) info->account;
                slot->handler_id = g_signal_connect (info->account, "changed",
                        G_CALLBACK (tny_gtk_folder_store_tree_model_on_changed), info->self);
                g_object_weak_ref (G_OBJECT (info->account), notify_signal_slots, info->self);
                g_ptr_array_add (info->self->signals, slot);

                tny_gtk_folder_store_tree_model_on_constatus_changed (info->account, 
                        tny_account_get_connection_status (info->account), info->self);

                tny_gtk_folder_store_tree_model_on_changed (info->account, 
                        info->self);

                repeat = FALSE;
        }

        return repeat;
}

static void 
account_was_not_yet_ready_destroy (gpointer user_data)
{
        AccNotYetReadyInfo *info = (AccNotYetReadyInfo *) user_data;

        g_object_unref (info->account);
        g_object_unref (info->self);

        g_slice_free (AccNotYetReadyInfo, user_data);
}


static void
tny_gtk_folder_store_tree_model_add_i (TnyGtkFolderStoreTreeModel *self, TnyFolderStore *folder_store, treeaddfunc func, const gchar *root_name)
{
        GtkTreeStore *model = GTK_TREE_STORE (self);
        TnyList *folders = tny_simple_list_new ();
        GtkTreeIter name_iter;

        func (model, &name_iter, NULL);

        gtk_tree_store_set (model, &name_iter,
                TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN, root_name,
                TNY_GTK_FOLDER_STORE_TREE_MODEL_UNREAD_COLUMN, 0,
                TNY_GTK_FOLDER_STORE_TREE_MODEL_ALL_COLUMN, 0,
                TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, TNY_FOLDER_TYPE_ROOT,
                TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,
                folder_store, -1);

        /* In case we added a store account, it's possible that the account 
         * will have "the account just got connected" events happening. Accounts
         * that just got connected might have new folders for us to know about.
         * That's why we'll handle connection changes. */

        if (TNY_IS_STORE_ACCOUNT (folder_store)) {
                if (!tny_account_is_ready (TNY_ACCOUNT (folder_store))) 
                {
                        AccNotYetReadyInfo *info = g_slice_new (AccNotYetReadyInfo);

                        info->account = TNY_ACCOUNT (g_object_ref (folder_store));
                        info->self = TNY_GTK_FOLDER_STORE_TREE_MODEL (g_object_ref (self));

                        g_timeout_add_full (G_PRIORITY_HIGH, 100, 
                                account_was_not_yet_ready_idle, 
                                info, account_was_not_yet_ready_destroy);

                } else {
                        SignalSlot *slot;

                        slot = g_slice_new (SignalSlot);

                        slot->instance = (GObject *)folder_store; 
                        slot->handler_id = g_signal_connect (folder_store, "connection-status-changed",
                                G_CALLBACK (tny_gtk_folder_store_tree_model_on_constatus_changed), self);
                        g_object_weak_ref (G_OBJECT (folder_store), notify_signal_slots, self);
                        g_ptr_array_add (self->signals, slot);

                        slot = g_slice_new (SignalSlot);
                        slot->instance = (GObject *)folder_store; 
                        slot->handler_id = g_signal_connect (folder_store, "changed",
                                G_CALLBACK (tny_gtk_folder_store_tree_model_on_changed), self);
                        g_object_weak_ref (G_OBJECT (folder_store), notify_signal_slots, self);
                        g_ptr_array_add (self->signals, slot);
                }
        }

        /* Being online at startup is being punished by this: it'll have to
         * wait for the connection operation to finish before this queued item
         * will get its turn. TNY TODO: figure out how we can avoid this and
         * already return the offline folders (if we had those from a session
         * before this one) */

        tny_folder_store_get_folders_async (TNY_FOLDER_STORE (folder_store), 
                folders, self->query, TRUE,  get_folders_cb, NULL, g_object_ref (self));

        /* recurse_folders_sync (self, TNY_FOLDER_STORE (folder_store), &name_iter);  */


        /* Add an observer for the root folder store, so that we can observe 
         * the actual account too. */

        add_folder_store_observer_weak (self, folder_store);

        /* g_object_unref (G_OBJECT (folders)); */

        return;
}


/**
 * tny_gtk_folder_store_tree_model_new:
 * @query: the #TnyFolderStoreQuery that will be used to retrieve the child folders of each #TnyFolderStore
 *
 * Create a new #GtkTreeModel for showing #TnyFolderStore instances, with default flags
 * 
 * returns: (caller-owns): a new #GtkTreeModel for #TnyFolderStore instances
 * since: 1.0
 * audience: application-developer
 **/
GtkTreeModel*
tny_gtk_folder_store_tree_model_new (TnyFolderStoreQuery *query)
{
        return tny_gtk_folder_store_tree_model_new_with_flags (query, 0);
}

/**
 * tny_gtk_folder_store_tree_model_new:
 * @query: the #TnyFolderStoreQuery that will be used to retrieve the child folders of each #TnyFolderStore
 * @flags: #TnyGtkFolderStoreTreeModelFlags for setting the store
 *
 * Create a new #GtkTreeModel for showing #TnyFolderStore instances
 * 
 * returns: (caller-owns): a new #GtkTreeModel for #TnyFolderStore instances
 * since: 1.0
 * audience: application-developer
 **/
GtkTreeModel*
tny_gtk_folder_store_tree_model_new_with_flags (TnyFolderStoreQuery *query,
                                                TnyGtkFolderStoreTreeModelFlags flags)
{
        TnyGtkFolderStoreTreeModel *self = g_object_new (TNY_TYPE_GTK_FOLDER_STORE_TREE_MODEL, NULL);

        if (query) 
                self->query = g_object_ref (query);

        self->flags = flags;

        return GTK_TREE_MODEL (self);
}



static void
tny_gtk_folder_store_tree_model_finalize (GObject *object)
{
        TnyGtkFolderStoreTreeModel *me = (TnyGtkFolderStoreTreeModel*) object;
        int i = 0;

        for (i = 0; i < me->signals->len; i++) {
                SignalSlot *slot = (SignalSlot *) me->signals->pdata [i];
                if (slot->instance) {
                        g_signal_handler_disconnect (slot->instance, slot->handler_id);
                        g_object_weak_unref (G_OBJECT (slot->instance), notify_signal_slots, object);
                }
                g_slice_free (SignalSlot, slot);
        }

        g_ptr_array_free (me->signals, TRUE);
        me->signals = NULL;

/* Experimentally removed this. With weak referencing this ain't needed ...

        while (copy) {
                remove_folder_observer_weak (me, (TnyFolder *) copy->data, TRUE);
                copy = g_list_next (copy);
        }

        copy = me->store_obs;
        while (copy) {
                remove_folder_store_observer_weak (me, (TnyFolderStore *) copy->data, TRUE);
                copy = g_list_next (copy);
        }
*/

        if (me->fol_obs)
                g_list_free (me->fol_obs);
        me->fol_obs = NULL;

        if (me->store_obs)
                g_list_free (me->store_obs);
        me->store_obs = NULL;

        g_mutex_lock (me->iterator_lock);
        if (me->first) {
                if (me->first_needs_unref)
                        g_list_foreach (me->first, (GFunc)g_object_unref, NULL);
                me->first_needs_unref = FALSE;
                g_list_free (me->first); 
        }
        me->first = NULL;
        g_mutex_unlock (me->iterator_lock);


        g_mutex_free (me->iterator_lock);
        me->iterator_lock = NULL;

        if (me->query)
                g_object_unref (me->query);

        (*parent_class->finalize) (object);
}

static void
tny_gtk_folder_store_tree_model_class_init (TnyGtkFolderStoreTreeModelClass *class)
{
        GObjectClass *object_class;

        parent_class = g_type_class_peek_parent (class);
        object_class = (GObjectClass*) class;

        object_class->finalize = tny_gtk_folder_store_tree_model_finalize;

        return;
}

static void
tny_gtk_folder_store_tree_model_instance_init (GTypeInstance *instance, gpointer g_class)
{
        GtkTreeStore *store = (GtkTreeStore*) instance;
        TnyGtkFolderStoreTreeModel *me = (TnyGtkFolderStoreTreeModel*) instance;
        static GType types[] = { G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INT, G_TYPE_OBJECT };

        me->signals = g_ptr_array_new ();
        me->fol_obs = NULL;
        me->store_obs = NULL;
        me->iterator_lock = g_mutex_new ();
        me->first_needs_unref = FALSE;
        me->first = NULL;

        me->flags = 0;

        gtk_tree_store_set_column_types (store, 
                TNY_GTK_FOLDER_STORE_TREE_MODEL_N_COLUMNS, types);

        return;
}



static TnyIterator*
tny_gtk_folder_store_tree_model_create_iterator (TnyList *self)
{
        TnyGtkFolderStoreTreeModel *me = (TnyGtkFolderStoreTreeModel*)self;

        /* Return a new iterator */

        return TNY_ITERATOR (_tny_gtk_folder_store_tree_model_iterator_new (me));
}


/**
 * tny_gtk_folder_store_tree_model_prepend:
 * @self: a #TnyGtkFolderStoreTreeModel
 * @item: a #TnyFolderStore to add
 * @root_name: The node's root name 
 *
 * Prepends an item to the model
 *
 * since: 1.0
 * audience: application-developer
 **/
void
tny_gtk_folder_store_tree_model_prepend (TnyGtkFolderStoreTreeModel *self, TnyFolderStore* item, const gchar *root_name)
{
        TnyGtkFolderStoreTreeModel *me = (TnyGtkFolderStoreTreeModel*)self;

        g_mutex_lock (me->iterator_lock);

        /* Prepend something to the list */
        me->first = g_list_prepend (me->first, item);

        tny_gtk_folder_store_tree_model_add_i (me, TNY_FOLDER_STORE (item), 
                gtk_tree_store_prepend, root_name);

        g_mutex_unlock (me->iterator_lock);
}


static void
tny_gtk_folder_store_tree_model_prepend_i (TnyList *self, GObject* item)
{
        TnyGtkFolderStoreTreeModel *me = (TnyGtkFolderStoreTreeModel*)self;

        g_mutex_lock (me->iterator_lock);

        /* Prepend something to the list */
        me->first = g_list_prepend (me->first, item);

        tny_gtk_folder_store_tree_model_add_i (me, TNY_FOLDER_STORE (item), 
                gtk_tree_store_prepend, get_root_name (TNY_FOLDER_STORE (item)));

        g_mutex_unlock (me->iterator_lock);
}

/**
 * tny_gtk_folder_store_tree_model_append:
 * @self: a #TnyGtkFolderStoreTreeModel
 * @item: a #TnyFolderStore to add
 * @root_name: The node's root name 
 *
 * Appends an item to the model
 *
 * since: 1.0
 * audience: application-developer
 **/
void
tny_gtk_folder_store_tree_model_append (TnyGtkFolderStoreTreeModel *self, TnyFolderStore* item, const gchar *root_name)
{
        TnyGtkFolderStoreTreeModel *me = (TnyGtkFolderStoreTreeModel*)self;

        g_mutex_lock (me->iterator_lock);

        /* Append something to the list */
        me->first = g_list_append (me->first, item);

        tny_gtk_folder_store_tree_model_add_i (me, TNY_FOLDER_STORE (item), 
                gtk_tree_store_append, root_name);

        g_mutex_unlock (me->iterator_lock);
}

static void
tny_gtk_folder_store_tree_model_append_i (TnyList *self, GObject* item)
{
        TnyGtkFolderStoreTreeModel *me = (TnyGtkFolderStoreTreeModel*)self;

        g_mutex_lock (me->iterator_lock);

        /* Append something to the list */
        me->first = g_list_append (me->first, item);

        tny_gtk_folder_store_tree_model_add_i (me, TNY_FOLDER_STORE (item), 
                gtk_tree_store_append, get_root_name (TNY_FOLDER_STORE (item)));

        g_mutex_unlock (me->iterator_lock);
}

static guint
tny_gtk_folder_store_tree_model_get_length (TnyList *self)
{
        TnyGtkFolderStoreTreeModel *me = (TnyGtkFolderStoreTreeModel*)self;
        guint retval = 0;

        g_mutex_lock (me->iterator_lock);

        retval = me->first?g_list_length (me->first):0;

        g_mutex_unlock (me->iterator_lock);

        return retval;
}

static void
tny_gtk_folder_store_tree_model_remove (TnyList *self, GObject* item)
{
        TnyGtkFolderStoreTreeModel *me = (TnyGtkFolderStoreTreeModel*)self;
        GtkTreeModel *model = GTK_TREE_MODEL (me);
        GtkTreeIter iter;

        g_return_if_fail (G_IS_OBJECT (item));
        g_return_if_fail (G_IS_OBJECT (me));

        /* Remove something from the list */

        g_mutex_lock (me->iterator_lock);

        me->first = g_list_remove (me->first, (gconstpointer)item);

        /* This doesn't have to be recursive as only the first-level folders are
           actually really part of the list. */

        if (gtk_tree_model_get_iter_first (model, &iter))
          do 
          {
                GObject *citem = NULL;
                gtk_tree_model_get (model, &iter, 
                        TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, 
                        &citem, -1);
                if (citem == item)
                {
                        /* This removes a reference count */
                        gtk_tree_store_remove (GTK_TREE_STORE (me), &iter);
                        if (citem)
                                g_object_unref (citem);
                        break;
                }
                if (citem)
                        g_object_unref (citem);

          } while (gtk_tree_model_iter_next (model, &iter));

        g_mutex_unlock (me->iterator_lock);
}


static TnyList*
tny_gtk_folder_store_tree_model_copy_the_list (TnyList *self)
{
        TnyGtkFolderStoreTreeModel *me = (TnyGtkFolderStoreTreeModel*)self;
        TnyGtkFolderStoreTreeModel *copy = g_object_new (TNY_TYPE_GTK_FOLDER_STORE_TREE_MODEL, NULL);
        GList *list_copy = NULL;

        /* This only copies the TnyList pieces. The result is not a correct or good
           TnyHeaderListModel. But it will be a correct TnyList instance. It's the 
           only thing the user of this method expects (that is the contract of it).

           The new list will point to the same instances, of course. It's only a 
           copy of the list-nodes of course. */

        g_mutex_lock (me->iterator_lock);
        list_copy = g_list_copy (me->first);
        g_list_foreach (list_copy, (GFunc)g_object_ref, NULL);
        copy->first_needs_unref = TRUE;
        copy->first = list_copy;
        g_mutex_unlock (me->iterator_lock);

        return TNY_LIST (copy);
}

static void 
tny_gtk_folder_store_tree_model_foreach_in_the_list (TnyList *self, GFunc func, gpointer user_data)
{
        TnyGtkFolderStoreTreeModel *me = (TnyGtkFolderStoreTreeModel*)self;

        /* Foreach item in the list (without using a slower iterator) */

        g_mutex_lock (me->iterator_lock);
        g_list_foreach (me->first, func, user_data);
        g_mutex_unlock (me->iterator_lock);

        return;
}

typedef struct _FindParentHelperInfo {
        GtkTreeIter *iter;
        TnyFolder *folder;
        TnyAccount *account;
        gboolean found;
} FindParentHelperInfo;

static gboolean
find_parent_helper (GtkTreeModel *model,
                    GtkTreePath *path,
                    GtkTreeIter *iter,
                    gpointer userdata)
{
        TnyFolderStore *folder_store;
        FindParentHelperInfo *helper_info = (FindParentHelperInfo *) userdata;
        TnyList *children;
        TnyIterator *iterator;

        gtk_tree_model_get (model, iter, 
                            TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN,