path: root/mail/e-mail-account-store.c

/*
 * e-mail-account-store.c
 *
 * This program 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.
 *
 * 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 Lesser General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 */

#include "e-mail-account-store.h"

#include <config.h>
#include <glib/gstdio.h>
#include <glib/gi18n-lib.h>

#include <libebackend/libebackend.h>

#include <libemail-engine/libemail-engine.h>

#include <mail/mail-vfolder-ui.h>

#define E_MAIL_ACCOUNT_STORE_GET_PRIVATE(obj) \
    (G_TYPE_INSTANCE_GET_PRIVATE \
    ((obj), E_TYPE_MAIL_ACCOUNT_STORE, EMailAccountStorePrivate))

typedef struct _IndexItem IndexItem;

struct _EMailAccountStorePrivate {
    CamelService *default_service;
    GHashTable *service_index;
    gchar *sort_order_filename;
    gpointer session;  /* weak pointer */
    guint busy_count;
};

struct _IndexItem {
    CamelService *service;
    GtkTreeRowReference *reference;
    gulong notify_handler_id;
};

enum {
    PROP_0,
    PROP_BUSY,
    PROP_DEFAULT_SERVICE,
    PROP_SESSION
};

enum {
    SERVICE_ADDED,
    SERVICE_REMOVED,
    SERVICE_ENABLED,
    SERVICE_DISABLED,
    SERVICES_REORDERED,
    REMOVE_REQUESTED,
    ENABLE_REQUESTED,
    DISABLE_REQUESTED,
    LAST_SIGNAL
};

static guint signals[LAST_SIGNAL];

/* Forward Declarations */
static void e_mail_account_store_interface_init
                        (GtkTreeModelIface *interface);

G_DEFINE_TYPE_WITH_CODE (
    EMailAccountStore,
    e_mail_account_store,
    GTK_TYPE_LIST_STORE,
    G_IMPLEMENT_INTERFACE (
        GTK_TYPE_TREE_MODEL,
        e_mail_account_store_interface_init)
    G_IMPLEMENT_INTERFACE (
        E_TYPE_EXTENSIBLE, NULL))

static void
index_item_free (IndexItem *item)
{
    g_signal_handler_disconnect (
        item->service, item->notify_handler_id);

    g_object_unref (item->service);
    gtk_tree_row_reference_free (item->reference);

    g_slice_free (IndexItem, item);
}

static gboolean
mail_account_store_get_iter (EMailAccountStore *store,
                             CamelService *service,
                             GtkTreeIter *iter)
{
    IndexItem *item;
    GtkTreeModel *model;
    GtkTreePath *path;
    gboolean iter_set;

    g_return_val_if_fail (service != NULL, FALSE);

    item = g_hash_table_lookup (store->priv->service_index, service);

    if (item == NULL)
        return FALSE;

    if (!gtk_tree_row_reference_valid (item->reference))
        return FALSE;

    model = gtk_tree_row_reference_get_model (item->reference);
    path = gtk_tree_row_reference_get_path (item->reference);
    iter_set = gtk_tree_model_get_iter (model, iter, path);
    gtk_tree_path_free (path);

    return iter_set;
}

static gint
mail_account_store_default_compare (CamelService *service_a,
                                    CamelService *service_b,
                                    EMailAccountStore *store)
{
    const gchar *display_name_a;
    const gchar *display_name_b;
    const gchar *uid_a;
    const gchar *uid_b;

    uid_a = camel_service_get_uid (service_a);
    uid_b = camel_service_get_uid (service_b);

    /* Check for special cases first. */

    if (g_str_equal (uid_a, E_MAIL_SESSION_LOCAL_UID))
        return -1;
    else if (g_str_equal (uid_b, E_MAIL_SESSION_LOCAL_UID))
        return 1;
    else if (g_str_equal (uid_a, E_MAIL_SESSION_VFOLDER_UID))
        return 1;
    else if (g_str_equal (uid_b, E_MAIL_SESSION_VFOLDER_UID))
        return -1;

    /* Otherwise sort them alphabetically. */

    display_name_a = camel_service_get_display_name (service_a);
    display_name_b = camel_service_get_display_name (service_b);

    if (display_name_a == NULL)
        display_name_a = "";

    if (display_name_b == NULL)
        display_name_b = "";

    return g_utf8_collate (display_name_a, display_name_b);
}

static void
mail_account_store_update_row (EMailAccountStore *store,
                               CamelService *service,
                               GtkTreeIter *iter)
{
    CamelProvider *provider;
    gboolean is_default;
    const gchar *backend_name;
    const gchar *display_name;

    is_default = (service == store->priv->default_service);
    display_name = camel_service_get_display_name (service);

    provider = camel_service_get_provider (service);
    backend_name = (provider != NULL) ? provider->protocol : NULL;

    gtk_list_store_set (
        GTK_LIST_STORE (store), iter,
        E_MAIL_ACCOUNT_STORE_COLUMN_DEFAULT, is_default,
        E_MAIL_ACCOUNT_STORE_COLUMN_BACKEND_NAME, backend_name,
        E_MAIL_ACCOUNT_STORE_COLUMN_DISPLAY_NAME, display_name,
        -1);
}

struct ServiceNotifyCbData
{
    EMailAccountStore *store;
    CamelService *service;
};

static void
service_notify_cb_data_free (gpointer ptr)
{
    struct ServiceNotifyCbData *data = ptr;

    g_clear_object (&data->store);
    g_clear_object (&data->service);
    g_slice_free (struct ServiceNotifyCbData, data);
}

static gboolean
mail_account_store_service_notify_idle_cb (gpointer user_data)
{
    struct ServiceNotifyCbData *data = user_data;
    GtkTreeIter iter;

    g_return_val_if_fail (data != NULL, FALSE);

    if (mail_account_store_get_iter (data->store, data->service, &iter))
        mail_account_store_update_row (data->store, data->service, &iter);

    return FALSE;
}

static void
mail_account_store_service_notify_cb (CamelService *service,
                                      GParamSpec *pspec,
                                      EMailAccountStore *store)
{
    struct ServiceNotifyCbData *data;

    data = g_slice_new0 (struct ServiceNotifyCbData);
    data->store = g_object_ref (store);
    data->service = g_object_ref (service);

    g_idle_add_full (
        G_PRIORITY_DEFAULT_IDLE,
        mail_account_store_service_notify_idle_cb,
        data,
        service_notify_cb_data_free);
}

static void
mail_account_store_remove_source_cb (ESource *source,
                                     GAsyncResult *result,
                                     EMailAccountStore *store)
{
    GError *error = NULL;

    /* FIXME EMailAccountStore should implement EAlertSink. */
    if (!e_source_remove_finish (source, result, &error)) {
        g_warning ("%s: %s", G_STRFUNC, error->message);
        g_error_free (error);
    }

    g_return_if_fail (store->priv->busy_count > 0);
    store->priv->busy_count--;
    g_object_notify (G_OBJECT (store), "busy");

    g_object_unref (store);
}

static void
mail_account_store_write_source_cb (ESource *source,
                                    GAsyncResult *result,
                                    EMailAccountStore *store)
{
    GError *error = NULL;

    /* FIXME EMailAccountStore should implement EAlertSink. */
    if (!e_source_write_finish (source, result, &error)) {
        g_warning ("%s: %s", G_STRFUNC, error->message);
        g_error_free (error);
    }

    g_return_if_fail (store->priv->busy_count > 0);
    store->priv->busy_count--;
    g_object_notify (G_OBJECT (store), "busy");

    g_object_unref (store);
}

static void
mail_account_store_clean_index (EMailAccountStore *store)
{
    GQueue trash = G_QUEUE_INIT;
    GHashTable *hash_table;
    GHashTableIter iter;
    gpointer key, value;

    hash_table = store->priv->service_index;
    g_hash_table_iter_init (&iter, hash_table);

    /* Remove index items with invalid GtkTreeRowReferences. */

    while (g_hash_table_iter_next (&iter, &key, &value)) {
        IndexItem *item = value;

        if (!gtk_tree_row_reference_valid (item->reference))
            g_queue_push_tail (&trash, key);
    }

    while ((key = g_queue_pop_head (&trash)) != NULL)
        g_hash_table_remove (hash_table, key);
}

static void
mail_account_store_update_index (EMailAccountStore *store,
                                 GtkTreePath *path,
                                 GtkTreeIter *iter)
{
    CamelService *service = NULL;
    GHashTable *hash_table;
    GtkTreeModel *model;
    IndexItem *item;

    model = GTK_TREE_MODEL (store);
    hash_table = store->priv->service_index;

    gtk_tree_model_get (
        model, iter,
        E_MAIL_ACCOUNT_STORE_COLUMN_SERVICE, &service, -1);

    if (service == NULL)
        return;

    item = g_hash_table_lookup (hash_table, service);

    if (item == NULL) {
        item = g_slice_new0 (IndexItem);
        item->service = g_object_ref (service);

        item->notify_handler_id = g_signal_connect (
            service, "notify", G_CALLBACK (
            mail_account_store_service_notify_cb), store);

        g_hash_table_insert (hash_table, item->service, item);
    }

    /* Update the row reference so the IndexItem will survive
     * drag-and-drop (new row is inserted, old row is deleted). */
    gtk_tree_row_reference_free (item->reference);
    item->reference = gtk_tree_row_reference_new (model, path);

    g_object_unref (service);
}

static void
mail_account_store_set_session (EMailAccountStore *store,
                                EMailSession *session)
{
    g_return_if_fail (E_IS_MAIL_SESSION (session));
    g_return_if_fail (store->priv->session == NULL);

    store->priv->session = session;

    g_object_add_weak_pointer (
        G_OBJECT (store->priv->session),
        &store->priv->session);
}

static void
mail_account_store_set_property (GObject *object,
                                 guint property_id,
                                 const GValue *value,
                                 GParamSpec *pspec)
{
    switch (property_id) {
        case PROP_DEFAULT_SERVICE:
            e_mail_account_store_set_default_service (
                E_MAIL_ACCOUNT_STORE (object),
                g_value_get_object (value));
            return;

        case PROP_SESSION:
            mail_account_store_set_session (
                E_MAIL_ACCOUNT_STORE (object),
                g_value_get_object (value));
            return;
    }

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
mail_account_store_get_property (GObject *object,
                                 guint property_id,
                                 GValue *value,
                                 GParamSpec *pspec)
{
    switch (property_id) {
        case PROP_BUSY:
            g_value_set_boolean (
                value,
                e_mail_account_store_get_busy (
                E_MAIL_ACCOUNT_STORE (object)));
            return;

        case PROP_DEFAULT_SERVICE:
            g_value_set_object (
                value,
                e_mail_account_store_get_default_service (
                E_MAIL_ACCOUNT_STORE (object)));
            return;

        case PROP_SESSION:
            g_value_set_object (
                value,
                e_mail_account_store_get_session (
                E_MAIL_ACCOUNT_STORE (object)));
            return;
    }

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
mail_account_store_dispose (GObject *object)
{
    EMailAccountStorePrivate *priv;

    priv = E_MAIL_ACCOUNT_STORE_GET_PRIVATE (object);

    if (priv->session != NULL) {
        g_object_remove_weak_pointer (
            G_OBJECT (priv->session), &priv->session);
        priv->session = NULL;
    }

    if (priv->default_service != NULL) {
        g_object_unref (priv->default_service);
        priv->default_service = NULL;
    }

    g_hash_table_remove_all (priv->service_index);

    /* Chain up to parent's dispose() method. */
    G_OBJECT_CLASS (e_mail_account_store_parent_class)->dispose (object);
}

static void
mail_account_store_finalize (GObject *object)
{
    EMailAccountStorePrivate *priv;

    priv = E_MAIL_ACCOUNT_STORE_GET_PRIVATE (object);

    g_warn_if_fail (priv->busy_count == 0);
    g_hash_table_destroy (priv->service_index);
    g_free (priv->sort_order_filename);

    /* Chain up to parent's finalize() method. */
    G_OBJECT_CLASS (e_mail_account_store_parent_class)->finalize (object);
}

static void
mail_account_store_constructed (GObject *object)
{
    EMailAccountStore *store;
    EMailSession *session;
    ESourceRegistry *registry;
    const gchar *config_dir;

    /* Chain up to parent's constructed() method. */
    G_OBJECT_CLASS (e_mail_account_store_parent_class)->constructed (object);

    store = E_MAIL_ACCOUNT_STORE (object);
    session = e_mail_account_store_get_session (store);
    registry = e_mail_session_get_registry (session);

    /* Bind the default mail account ESource to our default
     * CamelService, with help from some transform functions. */
    g_object_bind_property_full (
        registry, "default-mail-account",
        store, "default-service",
        G_BINDING_BIDIRECTIONAL |
        G_BINDING_SYNC_CREATE,
        e_binding_transform_source_to_service,
        e_binding_transform_service_to_source,
        session, (GDestroyNotify) NULL);

    config_dir = mail_session_get_config_dir ();

    /* XXX Should we take the filename as a constructor property? */
    store->priv->sort_order_filename = g_build_filename (
        config_dir, "sortorder.ini", NULL);

    e_extensible_load_extensions (E_EXTENSIBLE (object));
}

static void
mail_account_store_service_added (EMailAccountStore *store,
                                  CamelService *service)
{
    /* Placeholder so subclasses can safely chain up. */
}

static void
mail_account_store_service_removed (EMailAccountStore *store,
                                    CamelService *service)
{
    EMailSession *session;
    MailFolderCache *cache;
    ESourceRegistry *registry;
    ESource *source;
    const gchar *uid;

    session = e_mail_account_store_get_session (store);
    cache = e_mail_session_get_folder_cache (session);

    mail_folder_cache_service_removed (cache, service);

    uid = camel_service_get_uid (service);
    registry = e_mail_session_get_registry (session);
    source = e_source_registry_ref_source (registry, uid);

    /* If this ESource is part of a collection, we need to remove
     * the entire collection.  Check the ESource and its ancestors
     * for a collection extension and remove the containing source. */
    if (source != NULL) {
        ESource *collection;

        collection = e_source_registry_find_extension (
            registry, source, E_SOURCE_EXTENSION_COLLECTION);
        if (collection != NULL) {
            g_object_unref (source);
            source = collection;
        }
    }

    if (source != NULL && e_source_get_removable (source)) {
        store->priv->busy_count++;
        g_object_notify (G_OBJECT (store), "busy");

        /* XXX Should this be cancellable? */
        e_source_remove (
            source, NULL, (GAsyncReadyCallback)
            mail_account_store_remove_source_cb,
            g_object_ref (store));

        g_object_unref (source);
    }
}

static void
mail_account_store_service_enabled (EMailAccountStore *store,
                                    CamelService *service)
{
    EMailSession *session;
    MailFolderCache *cache;
    ESourceRegistry *registry;
    ESource *source;
    const gchar *uid;

    session = e_mail_account_store_get_session (store);
    cache = e_mail_session_get_folder_cache (session);

    mail_folder_cache_service_enabled (cache, service);

    uid = camel_service_get_uid (service);
    registry = e_mail_session_get_registry (session);
    source = e_source_registry_ref_source (registry, uid);

    /* Locate the identity source referenced in the [Mail Account]
     * extension.  We want to keep its enabled state synchronized
     * with the account's enabled state.  (Need to do this before
     * we swap the mail account ESource for a collection below.) */
    if (source != NULL) {
        ESource *identity = NULL;
        ESourceMailAccount *extension;
        const gchar *extension_name;

        extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
        extension = e_source_get_extension (source, extension_name);
        uid = e_source_mail_account_get_identity_uid (extension);

        if (uid != NULL)
            identity = e_source_registry_ref_source (registry, uid);

        if (identity != NULL && e_source_get_writable (identity)) {
            e_source_set_enabled (identity, TRUE);

            store->priv->busy_count++;
            g_object_notify (G_OBJECT (store), "busy");

            /* XXX Should this be cancellable? */
            e_source_write (
                identity, NULL, (GAsyncReadyCallback)
                mail_account_store_write_source_cb,
                g_object_ref (store));

            g_object_unref (identity);
        }
    }

    /* If this ESource is part of a collection, we need to enable
     * the entire collection.  Check the ESource and its ancestors
     * for a collection extension and enable the containing source. */
    if (source != NULL) {
        ESource *collection;

        collection = e_source_registry_find_extension (
            registry, source, E_SOURCE_EXTENSION_COLLECTION);
        if (collection != NULL) {
            g_object_unref (source);
            source = collection;
        }
    }

    if (source != NULL && e_source_get_writable (source)) {
        e_source_set_enabled (source, TRUE);

        store->priv->busy_count++;
        g_object_notify (G_OBJECT (store), "busy");

        /* XXX Should this be cancellable? */
        e_source_write (
            source, NULL, (GAsyncReadyCallback)
            mail_account_store_write_source_cb,
            g_object_ref (store));

        g_object_unref (source);
    }
}

static void
mail_account_store_service_disabled (EMailAccountStore *store,
                                     CamelService *service)
{
    EMailSession *session;
    MailFolderCache *cache;
    ESourceRegistry *registry;
    ESource *source;
    const gchar *uid;

    session = e_mail_account_store_get_session (store);
    cache = e_mail_session_get_folder_cache (session);

    mail_folder_cache_service_disabled (cache, service);

    uid = camel_service_get_uid (service);
    registry = e_mail_session_get_registry (session);
    source = e_source_registry_ref_source (registry, uid);

    /* Locate the identity source referenced in the [Mail Account]
     * extension.  We want to keep its enabled state synchronized
     * with the account's enabled state.  (Need to do this before
     * we swap the mail account ESource for a collection below.) */
    if (source != NULL) {
        ESource *identity = NULL;
        ESourceMailAccount *extension;
        const gchar *extension_name;

        extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
        extension = e_source_get_extension (source, extension_name);
        uid = e_source_mail_account_get_identity_uid (extension);

        if (uid != NULL)
            identity = e_source_registry_ref_source (registry, uid);

        if (identity != NULL && e_source_get_writable (identity)) {
            e_source_set_enabled (identity, FALSE);

            store->priv->busy_count++;
            g_object_notify (G_OBJECT (store), "busy");

            /* XXX Should this be cancellable? */
            e_source_write (
                identity, NULL, (GAsyncReadyCallback)
                mail_account_store_write_source_cb,
                g_object_ref (store));

            g_object_unref (identity);
        }
    }

    /* If this ESource is part of a collection, we need to disable
     * the entire collection.  Check the ESource and its ancestors
     * for a collection extension and disable the containing source. */
    if (source != NULL) {
        ESource *collection;

        collection = e_source_registry_find_extension (
            registry, source, E_SOURCE_EXTENSION_COLLECTION);
        if (collection != NULL) {
            g_object_unref (source);
            source = collection;
        }
    }

    if (source != NULL && e_source_get_writable (source)) {
        e_source_set_enabled (source, FALSE);

        store->priv->busy_count++;
        g_object_notify (G_OBJECT (store), "busy");

        /* XXX Should this be cancellable? */
        e_source_write (
            source, NULL, (GAsyncReadyCallback)
            mail_account_store_write_source_cb,
            g_object_ref (store));

        g_object_unref (source);
    }
}

static void
mail_account_store_services_reordered (EMailAccountStore *store,
                                       gboolean default_restored)
{
    /* XXX Should this be made asynchronous? */

    GError *error = NULL;

    if (default_restored) {
        const gchar *filename;

        filename = store->priv->sort_order_filename;

        if (g_file_test (filename, G_FILE_TEST_EXISTS))
            g_unlink (filename);

        return;
    }

    if (!e_mail_account_store_save_sort_order (store, &error)) {
        g_warning ("%s: %s", G_STRFUNC, error->message);
        g_error_free (error);
    }
}

static gboolean
mail_account_store_remove_requested (EMailAccountStore *store,
                                     GtkWindow *parent_window,
                                     CamelService *service)
{
    gint response;

    /* FIXME Need to use "mail:ask-delete-account-with-proxies" if the
     *       mail account has proxies.  But this is groupwise-specific
     *       and doesn't belong here anyway.  Think of a better idea. */

    response = e_alert_run_dialog_for_args (
        parent_window, "mail:ask-delete-account", NULL);

    return (response == GTK_RESPONSE_YES);
}

static gboolean
mail_account_store_enable_requested (EMailAccountStore *store,
                                     GtkWindow *parent_window,
                                     CamelService *service)
{
    return TRUE;
}

static gboolean
mail_account_store_disable_requested (EMailAccountStore *store,
                                      GtkWindow *parent_window,
                                      CamelService *service)
{
    /* FIXME Need to check whether the account has proxies and run a
     *       "mail:ask-delete-proxy-accounts" alert dialog, but this
     *       is groupwise-specific and doesn't belong here anyway.
     *       Think of a better idea. */

    return TRUE;
}

static void
mail_account_store_row_changed (GtkTreeModel *tree_model,
                                GtkTreePath *path,
                                GtkTreeIter *iter)
{
    EMailAccountStore *store;

    /* Neither GtkTreeModel nor GtkListStore implements
     * this method, so there is nothing to chain up to. */

    store = E_MAIL_ACCOUNT_STORE (tree_model);
    mail_account_store_update_index (store, path, iter);
}

static void
mail_account_store_row_inserted (GtkTreeModel *tree_model,
                                 GtkTreePath *path,
                                 GtkTreeIter *iter)
{
    EMailAccountStore *store;

    /* Neither GtkTreeModel nor GtkListStore implements
     * this method, so there is nothing to chain up to. */

    store = E_MAIL_ACCOUNT_STORE (tree_model);
    mail_account_store_update_index (store, path, iter);
}

static gboolean
mail_account_store_true_proceed (GSignalInvocationHint *ihint,
                                 GValue *return_accumulator,
                                 const GValue *handler_return,
                                 gpointer not_used)
{
    gboolean proceed;

    proceed = g_value_get_boolean (handler_return);
    g_value_set_boolean (return_accumulator, proceed);

    return proceed;
}

static void
e_mail_account_store_class_init (EMailAccountStoreClass *class)
{
    GObjectClass *object_class;

    g_type_class_add_private (class, sizeof (EMailAccountStorePrivate));

    object_class = G_OBJECT_CLASS (class);
    object_class->set_property = mail_account_store_set_property;
    object_class->get_property = mail_account_store_get_property;
    object_class->dispose = mail_account_store_dispose;
    object_class->finalize = mail_account_store_finalize;
    object_class->constructed = mail_account_store_constructed;

    class->service_added = mail_account_store_service_added;
    class->service_removed = mail_account_store_service_removed;
    class->service_enabled = mail_account_store_service_enabled;
    class->service_disabled = mail_account_store_service_disabled;
    class->services_reordered = mail_account_store_services_reordered;
    class->remove_requested = mail_account_store_remove_requested;
    class->enable_requested = mail_account_store_enable_requested;
    class->disable_requested = mail_account_store_disable_requested;

    g_object_class_install_property (
        object_class,
        PROP_BUSY,
        g_param_spec_boolean (
            "busy",
            "Busy",
            "Whether async operations are in progress",
            FALSE,
            G_PARAM_READABLE |
            G_PARAM_STATIC_STRINGS));

    g_object_class_install_property (
        object_class,
        PROP_DEFAULT_SERVICE,
        g_param_spec_object (
            "default-service",
            "Default Service",
            "Default mail store",
            CAMEL_TYPE_SERVICE,
            G_PARAM_READWRITE |
            G_PARAM_STATIC_STRINGS));

    g_object_class_install_property (
        object_class,
        PROP_SESSION,
        g_param_spec_object (
            "session",
            "Session",
            "Mail session",
            E_TYPE_MAIL_SESSION,
            G_PARAM_READWRITE |
            G_PARAM_CONSTRUCT_ONLY |
            G_PARAM_STATIC_STRINGS));

    signals[SERVICE_ADDED] = g_signal_new (
        "service-added",
        G_TYPE_FROM_CLASS (class),
        G_SIGNAL_RUN_LAST,
        G_STRUCT_OFFSET (EMailAccountStoreClass, service_added),
        NULL, NULL,
        g_cclosure_marshal_VOID__OBJECT,
        G_TYPE_NONE, 1,
        CAMEL_TYPE_SERVICE);

    signals[SERVICE_REMOVED] = g_signal_new (
        "service-removed",
        G_TYPE_FROM_CLASS (class),
        G_SIGNAL_RUN_LAST,
        G_STRUCT_OFFSET (EMailAccountStoreClass, service_removed),
        NULL, NULL,
        g_cclosure_marshal_VOID__OBJECT,
        G_TYPE_NONE, 1,
        CAMEL_TYPE_SERVICE);

    signals[SERVICE_ENABLED] = g_signal_new (
        "service-enabled",
        G_TYPE_FROM_CLASS (class),
        G_SIGNAL_RUN_LAST,
        G_STRUCT_OFFSET (EMailAccountStoreClass, service_enabled),
        NULL, NULL,
        g_cclosure_marshal_VOID__OBJECT,
        G_TYPE_NONE, 1,
        CAMEL_TYPE_SERVICE);

    signals[SERVICE_DISABLED] = g_signal_new (
        "service-disabled",
        G_TYPE_FROM_CLASS (class),
        G_SIGNAL_RUN_LAST,
        G_STRUCT_OFFSET (EMailAccountStoreClass, service_disabled),
        NULL, NULL,
        g_cclosure_marshal_VOID__OBJECT,
        G_TYPE_NONE, 1,
        CAMEL_TYPE_SERVICE);

    signals[SERVICES_REORDERED] = g_signal_new (
        "services-reordered",
        G_TYPE_FROM_CLASS (class),
        G_SIGNAL_RUN_LAST,
        G_STRUCT_OFFSET (EMailAccountStoreClass, services_reordered),
        NULL, NULL,
        g_cclosure_marshal_VOID__BOOLEAN,
        G_TYPE_NONE, 1,
        G_TYPE_BOOLEAN);

    signals[REMOVE_REQUESTED] = g_signal_new (
        "remove-requested",
        G_TYPE_FROM_CLASS (class),
        G_SIGNAL_RUN_LAST,
        G_STRUCT_OFFSET (EMailAccountStoreClass, remove_requested),
        mail_account_store_true_proceed, NULL,
        e_marshal_BOOLEAN__OBJECT_OBJECT,
        G_TYPE_BOOLEAN, 2,
        GTK_TYPE_WINDOW,
        CAMEL_TYPE_SERVICE);

    signals[ENABLE_REQUESTED] = g_signal_new (
        "enable-requested",
        G_TYPE_FROM_CLASS (class),
        G_SIGNAL_RUN_LAST,
        G_STRUCT_OFFSET (EMailAccountStoreClass, enable_requested),
        mail_account_store_true_proceed, NULL,
        e_marshal_BOOLEAN__OBJECT_OBJECT,
        G_TYPE_BOOLEAN, 2,
        GTK_TYPE_WINDOW,
        CAMEL_TYPE_SERVICE);

    signals[DISABLE_REQUESTED] = g_signal_new (
        "disable-requested",
        G_TYPE_FROM_CLASS (class),
        G_SIGNAL_RUN_LAST,
        G_STRUCT_OFFSET (EMailAccountStoreClass, disable_requested),
        mail_account_store_true_proceed, NULL,
        e_marshal_BOOLEAN__OBJECT_OBJECT,
        G_TYPE_BOOLEAN, 2,
        GTK_TYPE_WINDOW,
        CAMEL_TYPE_SERVICE);
}

static void
e_mail_account_store_interface_init (GtkTreeModelIface *interface)
{
    interface->row_changed = mail_account_store_row_changed;
    interface->row_inserted = mail_account_store_row_inserted;
}

static void
e_mail_account_store_init (EMailAccountStore *store)
{
    GType types[E_MAIL_ACCOUNT_STORE_NUM_COLUMNS];
    GHashTable *service_index;
    gint ii = 0;

    service_index = g_hash_table_new_full (
        (GHashFunc) g_direct_hash,
        (GEqualFunc) g_direct_equal,
        (GDestroyNotify) NULL,
        (GDestroyNotify) index_item_free);

    store->priv = E_MAIL_ACCOUNT_STORE_GET_PRIVATE (store);
    store->priv->service_index = service_index;

    types[ii++] = CAMEL_TYPE_SERVICE;   /* COLUMN_SERVICE */
    types[ii++] = G_TYPE_BOOLEAN;       /* COLUMN_BUILTIN */
    types[ii++] = G_TYPE_BOOLEAN;       /* COLUMN_ENABLED */
    types[ii++] = G_TYPE_BOOLEAN;       /* COLUMN_DEFAULT */
    types[ii++] = G_TYPE_STRING;        /* COLUMN_BACKEND_NAME */
    types[ii++] = G_TYPE_STRING;        /* COLUMN_DISPLAY_NAME */
    types[ii++] = G_TYPE_STRING;        /* COLUMN_ICON_NAME */
    types[ii++] = G_TYPE_BOOLEAN;       /* COLUMN_ONLINE_ACCOUNT */
    types[ii++] = G_TYPE_BOOLEAN;       /* COLUMN_ENABLED_VISIBLE */

    g_assert (ii == E_MAIL_ACCOUNT_STORE_NUM_COLUMNS);

    gtk_list_store_set_column_types (
        GTK_LIST_STORE (store),
        G_N_ELEMENTS (types), types);
}

EMailAccountStore *
e_mail_account_store_new (EMailSession *session)
{
    g_return_val_if_fail (E_IS_MAIL_SESSION (session), NULL);

    return g_object_new (
        E_TYPE_MAIL_ACCOUNT_STORE,
        "session", session, NULL);
}

void
e_mail_account_store_clear (EMailAccountStore *store)
{
    g_return_if_fail (E_IS_MAIL_ACCOUNT_STORE (store));

    gtk_list_store_clear (GTK_LIST_STORE (store));
    g_hash_table_remove_all (store->priv->service_index);
}

gboolean
e_mail_account_store_get_busy (EMailAccountStore *store)
{
    g_return_val_if_fail (E_IS_MAIL_ACCOUNT_STORE (store), FALSE);

    return (store->priv->busy_count > 0);
}

EMailSession *
e_mail_account_store_get_session (EMailAccountStore *store)
{
    g_return_val_if_fail (E_IS_MAIL_ACCOUNT_STORE (store), NULL);

    return E_MAIL_SESSION (store->priv->session);
}

CamelService *
e_mail_account_store_get_default_service (EMailAccountStore *store)
{
    g_return_val_if_fail (E_IS_MAIL_ACCOUNT_STORE (store), NULL);

    return store->priv->default_service;
}

void
e_mail_account_store_set_default_service (EMailAccountStore *store,
                                          CamelService *service)
{
    GtkTreeModel *model;
    GtkTreeIter iter;
    gboolean iter_set;

    g_return_if_fail (E_IS_MAIL_ACCOUNT_STORE (store));

    if (service == store->priv->default_service)
        return;

    if (service != NULL) {
        g_return_if_fail (CAMEL_IS_SERVICE (service));
        g_object_ref (service);
    }

    if (store->priv->default_service != NULL)
        g_object_unref (store->priv->default_service);

    store->priv->default_service = service;

    model = GTK_TREE_MODEL (store);
    iter_set = gtk_tree_model_get_iter_first (model, &iter);

    while (iter_set) {
        CamelService *candidate;

        gtk_tree_model_get (
            model, &iter,
            E_MAIL_ACCOUNT_STORE_COLUMN_SERVICE,
            &candidate, -1);

        gtk_list_store_set (
            GTK_LIST_STORE (model), &iter,
            E_MAIL_ACCOUNT_STORE_COLUMN_DEFAULT,
            service == candidate, -1);

        g_object_unref (candidate);

        iter_set = gtk_tree_model_iter_next (model, &iter);
    }

    g_object_notify (G_OBJECT (store), "default-service");
}

void
e_mail_account_store_add_service (EMailAccountStore *store,
                                  CamelService *service)
{
    EMailSession *session;
    ESourceRegistry *registry;
    ESource *collection;
    ESource *source;
    GtkTreeIter iter;
    const gchar *filename;
    const gchar *icon_name = NULL;
    const gchar *uid;
    gboolean builtin;
    gboolean enabled;
    gboolean online_account = FALSE;
    gboolean enabled_visible = TRUE;

    g_return_if_fail (E_IS_MAIL_ACCOUNT_STORE (store));
    g_return_if_fail (CAMEL_IS_SERVICE (service));

    /* Avoid duplicate services in the account store. */
    if (mail_account_store_get_iter (store, service, &iter))
        g_return_if_reached ();

    uid = camel_service_get_uid (service);

    builtin =
        (g_strcmp0 (uid, E_MAIL_SESSION_LOCAL_UID) == 0) ||
        (g_strcmp0 (uid, E_MAIL_SESSION_VFOLDER_UID) == 0);

    session = e_mail_account_store_get_session (store);

    registry = e_mail_session_get_registry (session);
    source = e_source_registry_ref_source (registry, uid);
    g_return_if_fail (source != NULL);

    /* If this ESource is part of a collection, we need to
     * pick up the enabled state for the entire collection.
     * Check the ESource and its ancestors for a collection
     * extension and read from the containing source. */
    collection = e_source_registry_find_extension (
        registry, source, E_SOURCE_EXTENSION_COLLECTION);
    if (collection != NULL) {
        const gchar *extension_name;

        enabled = e_source_get_enabled (collection);

        /* Check for GNOME Online Accounts linkage. */
        extension_name = E_SOURCE_EXTENSION_GOA;
        if (e_source_has_extension (collection, extension_name)) {
            online_account = TRUE;
            enabled_visible = FALSE;

            /* Provided by gnome-control-center-data. */
            icon_name = "goa-panel";
        }

        /* Check for Ubuntu Online Accounts linkage. */
        extension_name = E_SOURCE_EXTENSION_UOA;
        if (e_source_has_extension (collection, extension_name)) {
            online_account = TRUE;
            enabled_visible = FALSE;

            /* Provided by gnome-control-center-signon. */
            icon_name = "credentials-preferences";
        }

        g_object_unref (collection);
    } else {
        enabled = e_source_get_enabled (source);
    }

    g_object_unref (source);

    /* Where do we insert new services now that accounts can be
     * reordered?  This is just a simple policy I came up with.
     * It's certainly subject to debate and tweaking.
     *
     * Always insert new services in row 0 initially.  Then test
     * for the presence of the sort order file.  If present, the
     * user has messed around with the ordering so leave the new
     * service at row 0.  If not present, services are sorted in
     * their default order.  So re-apply the default order using
     * e_mail_account_store_reorder_services(store, NULL) so the
     * new service moves to its proper default position. */

    gtk_list_store_prepend (GTK_LIST_STORE (store), &iter);

    gtk_list_store_set (
        GTK_LIST_STORE (store), &iter,
        E_MAIL_ACCOUNT_STORE_COLUMN_SERVICE, service,
        E_MAIL_ACCOUNT_STORE_COLUMN_BUILTIN, builtin,
        E_MAIL_ACCOUNT_STORE_COLUMN_ENABLED, enabled,
        E_MAIL_ACCOUNT_STORE_COLUMN_ICON_NAME, icon_name,
        E_MAIL_ACCOUNT_STORE_COLUMN_ONLINE_ACCOUNT, online_account,
        E_MAIL_ACCOUNT_STORE_COLUMN_ENABLED_VISIBLE, enabled_visible,
        -1);

    /* This populates the rest of the columns. */
    mail_account_store_update_row (store, service, &iter);

    /* No need to connect to "service-added" emissions since it's
     * always immediately followed by either "service-enabled" or
     * "service-disabled" in MailFolderCache */

    g_signal_emit (store, signals[SERVICE_ADDED], 0, service);

    if (enabled)
        g_signal_emit (store, signals[SERVICE_ENABLED], 0, service);
    else
        g_signal_emit (store, signals[SERVICE_DISABLED], 0, service);

    filename = store->priv->sort_order_filename;

    if (!g_file_test (filename, G_FILE_TEST_EXISTS))
        e_mail_account_store_reorder_services (store, NULL);
}

void
e_mail_account_store_remove_service (EMailAccountStore *store,
                                     GtkWindow *parent_window,
                                     CamelService *service)
{
    GtkTreeIter iter;
    gboolean proceed = TRUE;

    g_return_if_fail (E_IS_MAIL_ACCOUNT_STORE (store));
    g_return_if_fail (CAMEL_IS_SERVICE (service));

    /* XXX Our service_removed() class method calls e_source_remove(),
     *     which causes the registry service to emit a "source-removed"
     *     signal.  But since other applications may also induce signal
     *     emissions from the registry service, EMailUISession handles
     *     "source-removed" by calling this function.  So quietly break
     *     the cycle if we don't find the service in our tree model. */
    if (!mail_account_store_get_iter (store, service, &iter))
        return;

    /* If no parent window was given, skip the request signal. */
    if (GTK_IS_WINDOW (parent_window))
        g_signal_emit (
            store, signals[REMOVE_REQUESTED], 0,
            parent_window, service, &proceed);

    if (proceed) {
        g_object_ref (service);

        gtk_list_store_remove (GTK_LIST_STORE (store), &iter);

        mail_account_store_clean_index (store);

        g_signal_emit (store, signals[SERVICE_REMOVED], 0, service);

        g_object_unref (service);
    }
}

void
e_mail_account_store_enable_service (EMailAccountStore *store,
                                     GtkWindow *parent_window,
                                     CamelService *service)
{
    GtkTreeIter iter;
    gboolean proceed = FALSE;

    g_return_if_fail (E_IS_MAIL_ACCOUNT_STORE (store));
    g_return_if_fail (CAMEL_IS_SERVICE (service));

    if (!mail_account_store_get_iter (store, service, &iter))
        g_return_if_reached ();

    /* If no parent window was given, skip the request signal. */
    if (GTK_IS_WINDOW (parent_window))
        g_signal_emit (
            store, signals[ENABLE_REQUESTED], 0,
            parent_window, service, &proceed);

    if (proceed) {
        gtk_list_store_set (
            GTK_LIST_STORE (store), &iter,
            E_MAIL_ACCOUNT_STORE_COLUMN_ENABLED, TRUE, -1);
        g_signal_emit (store, signals[SERVICE_ENABLED], 0, service);
    }
}

void
e_mail_account_store_disable_service (EMailAccountStore *store,
                                      GtkWindow *parent_window,
                                      CamelService *service)
{
    GtkTreeIter iter;
    gboolean proceed = FALSE;

    g_return_if_fail (E_IS_MAIL_ACCOUNT_STORE (store));
    g_return_if_fail (CAMEL_IS_SERVICE (service));

    if (!mail_account_store_get_iter (store, service, &iter))
        g_return_if_reached ();

    /* If no parent window was given, skip the request signal. */
    if (GTK_IS_WINDOW (parent_window))
        g_signal_emit (
            store, signals[DISABLE_REQUESTED], 0,
            parent_window, service, &proceed);

    if (proceed) {
        gtk_list_store_set (
            GTK_LIST_STORE (store), &iter,
            E_MAIL_ACCOUNT_STORE_COLUMN_ENABLED, FALSE, -1);
        g_signal_emit (store, signals[SERVICE_DISABLED], 0, service);
    }
}

void
e_mail_account_store_queue_services (EMailAccountStore *store,
                                     GQueue *out_queue)
{
    GtkTreeModel *tree_model;
    GtkTreeIter iter;
    gboolean iter_set;
    gint column;

    g_return_if_fail (E_IS_MAIL_ACCOUNT_STORE (store));
    g_return_if_fail (out_queue != NULL);

    tree_model = GTK_TREE_MODEL (store);

    iter_set = gtk_tree_model_get_iter_first (tree_model, &iter);

    while (iter_set) {
        GValue value = G_VALUE_INIT;

        column = E_MAIL_ACCOUNT_STORE_COLUMN_SERVICE;
        gtk_tree_model_get_value (tree_model, &iter, column, &value);
        g_queue_push_tail (out_queue, g_value_get_object (&value));
        g_value_unset (&value);

        iter_set = gtk_tree_model_iter_next (tree_model, &iter);
    }
}

void
e_mail_account_store_queue_enabled_services (EMailAccountStore *store,
                                             GQueue *out_queue)
{
    GtkTreeModel *tree_model;
    GtkTreeIter iter;
    gboolean iter_set;
    gint column;

    g_return_if_fail (E_IS_MAIL_ACCOUNT_STORE (store));
    g_return_if_fail (out_queue != NULL);

    tree_model = GTK_TREE_MODEL (store);

    iter_set = gtk_tree_model_get_iter_first (tree_model, &iter);

    while (iter_set) {
        GValue value = G_VALUE_INIT;
        gboolean enabled;

        column = E_MAIL_ACCOUNT_STORE_COLUMN_ENABLED;
        gtk_tree_model_get_value (tree_model, &iter, column, &value);
        enabled = g_value_get_boolean (&value);
        g_value_unset (&value);

        if (enabled) {
            column = E_MAIL_ACCOUNT_STORE_COLUMN_SERVICE;
            gtk_tree_model_get_value (tree_model, &iter, column, &value);
            g_queue_push_tail (out_queue, g_value_get_object (&value));
            g_value_unset (&value);
        }

        iter_set = gtk_tree_model_iter_next (tree_model, &iter);
    }
}

gboolean
e_mail_account_store_have_enabled_service (EMailAccountStore *store,
                                           GType service_type)
{
    GtkTreeModel *tree_model;
    GtkTreeIter iter;
    gboolean iter_set;
    gint column;
    gboolean found = FALSE;

    g_return_val_if_fail (E_IS_MAIL_ACCOUNT_STORE (store), FALSE);

    tree_model = GTK_TREE_MODEL (store);

    iter_set = gtk_tree_model_get_iter_first (tree_model, &iter);

    while (iter_set && !found) {
        GValue value = G_VALUE_INIT;
        gboolean enabled;

        column = E_MAIL_ACCOUNT_STORE_COLUMN_ENABLED;
        gtk_tree_model_get_value (tree_model, &iter, column, &value);
        enabled = g_value_get_boolean (&value);
        g_value_unset (&value);

        if (enabled) {
            CamelService *service;

            column = E_MAIL_ACCOUNT_STORE_COLUMN_SERVICE;
            gtk_tree_model_get_value (tree_model, &iter, column, &value);
            service = g_value_get_object (&value);
            found = service && G_TYPE_CHECK_INSTANCE_TYPE (service, service_type);
            g_value_unset (&value);
        }

        iter_set = gtk_tree_model_iter_next (tree_model, &iter);
    }

    return found;
}

void
e_mail_account_store_reorder_services (EMailAccountStore *store,
                                       GQueue *ordered_services)
{
    GQueue *current_order = NULL;
    GQueue *default_order = NULL;
    GtkTreeModel *tree_model;
    gboolean use_default_order;
    GList *head, *link;
    gint *new_order;
    gint n_children;
    gint new_pos = 0;

    g_return_if_fail (E_IS_MAIL_ACCOUNT_STORE (store));

    tree_model = GTK_TREE_MODEL (store);
    n_children = gtk_tree_model_iter_n_children (tree_model, NULL);

    /* Treat NULL queues and empty queues the same. */
    if (ordered_services != NULL && g_queue_is_empty (ordered_services))
        ordered_services = NULL;

    /* If the length of the custom ordering disagrees with the
     * number of rows in the store, revert to default ordering. */
    if (ordered_services != NULL) {
        if (g_queue_get_length (ordered_services) != n_children)
            ordered_services = NULL;
    }

    use_default_order = (ordered_services == NULL);

    /* Build a queue of CamelServices in the order they appear in
     * the list store.  We'll use this to construct the mapping to
     * pass to gtk_list_store_reorder(). */
    current_order = g_queue_new ();
    e_mail_account_store_queue_services (store, current_order);

    /* If a custom ordering was not given, revert to default. */
    if (use_default_order) {
        default_order = g_queue_copy (current_order);

        g_queue_sort (
            default_order, (GCompareDataFunc)
            mail_account_store_default_compare, store);

        ordered_services = default_order;
    }

    new_order = g_new0 (gint, n_children);
    head = g_queue_peek_head_link (ordered_services);

    for (link = head; link != NULL; link = g_list_next (link)) {
        GList *matching_link;
        gint old_pos;

        matching_link = g_queue_find (current_order, link->data);

        if (matching_link == NULL || matching_link->data == NULL)
            break;

        old_pos = g_queue_link_index (current_order, matching_link);

        matching_link->data = NULL;
        new_order[new_pos++] = old_pos;
    }

    if (new_pos == n_children) {
        gtk_list_store_reorder (GTK_LIST_STORE (store), new_order);
        g_signal_emit (
            store, signals[SERVICES_REORDERED], 0,
            use_default_order);
    }

    g_free (new_order);

    if (current_order != NULL)
        g_queue_free (current_order);

    if (default_order != NULL)
        g_queue_free (default_order);
}

gint
e_mail_account_store_compare_services (EMailAccountStore *store,
                                       CamelService *service_a,
                                       CamelService *service_b)
{
    GtkTreeModel *model;
    GtkTreePath *path_a;
    GtkTreePath *path_b;
    GtkTreeIter iter_a;
    GtkTreeIter iter_b;
    gboolean iter_a_set;
    gboolean iter_b_set;
    gint result;

    g_return_val_if_fail (E_IS_MAIL_ACCOUNT_STORE (store), -1);
    g_return_val_if_fail (CAMEL_IS_SERVICE (service_a), -1);
    g_return_val_if_fail (CAMEL_IS_SERVICE (service_b), -1);

    /* XXX This is horribly inefficient but should be
     *     over a small enough set to not be noticable. */

    iter_a_set = mail_account_store_get_iter (store, service_a, &iter_a);
    iter_b_set = mail_account_store_get_iter (store, service_b, &iter_b);

    if (!iter_a_set && !iter_b_set)
        return 0;

    if (!iter_a_set)
        return -1;

    if (!iter_b_set)
        return 1;

    model = GTK_TREE_MODEL (store);

    path_a = gtk_tree_model_get_path (model, &iter_a);
    path_b = gtk_tree_model_get_path (model, &iter_b);

    result = gtk_tree_path_compare (path_a, path_b);

    gtk_tree_path_free (path_a);
    gtk_tree_path_free (path_b);

    return result;
}

gboolean
e_mail_account_store_load_sort_order (EMailAccountStore *store,
                                      GError **error)
{
    GQueue service_queue = G_QUEUE_INIT;
    EMailSession *session;
    GKeyFile *key_file;
    const gchar *filename;
    gchar **service_uids;
    gboolean success = TRUE;
    gsize ii, length;

    g_return_val_if_fail (E_IS_MAIL_ACCOUNT_STORE (store), FALSE);

    session = e_mail_account_store_get_session (store);

    key_file = g_key_file_new ();
    filename = store->priv->sort_order_filename;

    if (g_file_test (filename, G_FILE_TEST_EXISTS))
        success = g_key_file_load_from_file (
            key_file, filename, G_KEY_FILE_NONE, error);

    if (!success) {
        g_key_file_free (key_file);
        return FALSE;
    }

    /* If the key is not present, length is set to zero. */
    service_uids = g_key_file_get_string_list (
        key_file, "Accounts", "SortOrder", &length, NULL);

    for (ii = 0; ii < length; ii++) {
        CamelService *service;

        service = camel_session_ref_service (
            CAMEL_SESSION (session), service_uids[ii]);
        if (service != NULL)
            g_queue_push_tail (&service_queue, service);
    }

    e_mail_account_store_reorder_services (store, &service_queue);

    while (!g_queue_is_empty (&service_queue))
        g_object_unref (g_queue_pop_head (&service_queue));

    g_strfreev (service_uids);

    g_key_file_free (key_file);

    return TRUE;
}

gboolean
e_mail_account_store_save_sort_order (EMailAccountStore *store,
                                      GError **error)
{
    GKeyFile *key_file;
    GtkTreeModel *model;
    GtkTreeIter iter;
    const gchar **service_uids;
    const gchar *filename;
    gchar *contents;
    gboolean iter_set;
    gboolean success;
    gsize length;
    gsize ii = 0;

    g_return_val_if_fail (E_IS_MAIL_ACCOUNT_STORE (store), FALSE);

    model = GTK_TREE_MODEL (store);
    length = gtk_tree_model_iter_n_children (model, NULL);

    /* Empty store, nothing to save. */
    if (length == 0)
        return TRUE;

    service_uids = g_new0 (const gchar *, length);

    iter_set = gtk_tree_model_get_iter_first (model, &iter);

    while (iter_set) {
        GValue value = G_VALUE_INIT;
        const gint column = E_MAIL_ACCOUNT_STORE_COLUMN_SERVICE;
        CamelService *service;

        gtk_tree_model_get_value (model, &iter, column, &value);
        service = g_value_get_object (&value);
        service_uids[ii++] = camel_service_get_uid (service);
        g_value_unset (&value);

        iter_set = gtk_tree_model_iter_next (model, &iter);
    }

    key_file = g_key_file_new ();
    filename = store->priv->sort_order_filename;

    g_key_file_set_string_list (
        key_file, "Accounts", "SortOrder", service_uids, length);

    contents = g_key_file_to_data (key_file, &length, NULL);
    success = g_file_set_contents (filename, contents, length, error);
    g_free (contents);

    g_key_file_free (key_file);

    g_free (service_uids);

    return success;
}