root/trunk/src/tmut-folder-selector.c

/* TMut
 * 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.
 */

#if HAVE_CONFIG_H
#include "config.h"
#endif

#include <glib/gi18n-lib.h>

#include "tmut-folder-selector.h"
#include "tmut-shell-window.h"
#include "tmut-shell-child.h"
#include "tmut-account-store.h"

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

static GObjectClass *parent_class = NULL;

typedef struct _TMutFolderSelectorPriv TMutFolderSelectorPriv;

struct _TMutFolderSelectorPriv {
        GtkTreeView *folders_treeview;
        TMutShellWindow *shell;
        TnyFolderStore *current;
        TnyAccountStore *account_store;
        gint account_created_signal, account_deleted_signal;
};

typedef enum {
        TMUT_FOLDER_SELECTOR_FOLDER_SELECTED,
        TMUT_FOLDER_SELECTOR_LAST_SIGNAL
} TMutFolderSelectorSignal;

static guint tmut_folder_selector_signals [TMUT_FOLDER_SELECTOR_LAST_SIGNAL];

#define TMUT_FOLDER_SELECTOR_GET_PRIVATE(o) \
        (G_TYPE_INSTANCE_GET_PRIVATE ((o), TMUT_TYPE_FOLDER_SELECTOR, TMutFolderSelectorPriv))

TnyFolderStore*
tmut_folder_selector_get_current (TMutFolderSelector *self)
{
        TMutFolderSelectorPriv *priv = TMUT_FOLDER_SELECTOR_GET_PRIVATE (self);

        if (!priv->current)
                return NULL;

        return TNY_FOLDER_STORE (g_object_ref (priv->current));
}

static void
disconnect_account_store (TMutFolderSelectorPriv *priv)
{
        g_signal_handler_disconnect (priv->account_store, priv->account_created_signal);
        g_signal_handler_disconnect (priv->account_store, priv->account_deleted_signal);
        g_object_unref (priv->account_store);
        priv->account_store = NULL;
}

static void
on_account_created (TMutAccountStore *store, TnyAccount *account, TMutFolderSelector *self)
{
        TMutFolderSelectorPriv *priv = TMUT_FOLDER_SELECTOR_GET_PRIVATE (self);
        TnyList *model = TNY_LIST (gtk_tree_view_get_model (priv->folders_treeview));
        tny_list_prepend (model, (GObject *) account);
}


static void
on_account_deleted (TMutAccountStore *store, TnyAccount *account, TMutFolderSelector *self)
{
        TMutFolderSelectorPriv *priv = TMUT_FOLDER_SELECTOR_GET_PRIVATE (self);
        TnyList *model = TNY_LIST (gtk_tree_view_get_model (priv->folders_treeview));
        tny_list_remove (model, (GObject *) account);
}

static void
tmut_folder_selector_set_account_store (TnyAccountStoreView *self, TnyAccountStore *account_store)
{
        TMutFolderSelectorPriv *priv = TMUT_FOLDER_SELECTOR_GET_PRIVATE (self);
        TnyFolderStoreQuery *query;
        GtkTreeModel *model = NULL;

        query = tny_folder_store_query_new ();
        tny_folder_store_query_add_item (query, NULL, 
                TNY_FOLDER_STORE_QUERY_OPTION_SUBSCRIBED);
        model = tny_gtk_folder_store_tree_model_new (query);

        if (priv->account_store)
                disconnect_account_store (priv);
        priv->account_store = TNY_ACCOUNT_STORE (g_object_ref (account_store));

        tny_account_store_get_accounts (priv->account_store, TNY_LIST (model),
                TNY_ACCOUNT_STORE_STORE_ACCOUNTS);

        priv->account_created_signal = g_signal_connect (G_OBJECT (priv->account_store), "account_created",
                G_CALLBACK (on_account_created), self);
        priv->account_deleted_signal = g_signal_connect (G_OBJECT (priv->account_store), "account_deleted",
                G_CALLBACK (on_account_deleted), self);

        gtk_tree_view_set_model (priv->folders_treeview, model);

        g_object_unref (model);

        return;
}


static void
on_folder_changed (GtkTreeView *treeview, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data)
{
        TMutFolderSelector *self = TMUT_FOLDER_SELECTOR (user_data);
        TMutFolderSelectorPriv *priv = TMUT_FOLDER_SELECTOR_GET_PRIVATE (self);
        GtkTreeSelection *selection = gtk_tree_view_get_selection (treeview);
        GtkTreeModel *model;
        GtkTreeIter iter;

        if (gtk_tree_selection_get_selected (selection, &model, &iter)) 
        {
                gint type;
                gtk_tree_model_get (model, &iter, 
                        TNY_GTK_FOLDER_STORE_TREE_MODEL_TYPE_COLUMN, 
                        &type, -1);
                if (type != TNY_FOLDER_TYPE_ROOT) 
                {
                        TnyFolder *folder;
                        TMutFolderSelector *selector;

                        gtk_tree_model_get (model, &iter, 
                                TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, 
                                &folder, -1);
                        if (!folder)
                                return;

                        priv->current = TNY_FOLDER_STORE (g_object_ref (folder));

                        g_object_ref (self);
                        g_signal_emit (G_OBJECT (self), 
                                tmut_folder_selector_signals [TMUT_FOLDER_SELECTOR_FOLDER_SELECTED], 0);
                        g_object_unref (self);

                        g_object_unref (folder);
                }
        }

        return;
}


static void
tmut_folder_selector_instance_init (GTypeInstance *instance, gpointer g_class)
{
        TMutFolderSelector *self = (TMutFolderSelector *) instance;
        TMutFolderSelectorPriv *priv = TMUT_FOLDER_SELECTOR_GET_PRIVATE (self);
        GtkVBox *vbox = GTK_VBOX (self);
        GtkCellRenderer *renderer;
        GtkTreeViewColumn *column;
        GtkTreeSelection *select;
        GtkWidget *sw;

        priv->account_store = NULL;
        priv->account_created_signal = -1;
        priv->account_deleted_signal = -1;

        priv->current = NULL;
        sw = gtk_scrolled_window_new (NULL, NULL);
        gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), 
                GTK_SHADOW_NONE);
        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
        gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
        gtk_widget_show (sw);
        priv->folders_treeview = GTK_TREE_VIEW (gtk_tree_view_new ());
        gtk_tree_view_set_headers_visible (priv->folders_treeview, FALSE);
        gtk_tree_view_set_rules_hint (priv->folders_treeview, TRUE);
        gtk_tree_view_set_fixed_height_mode (priv->folders_treeview, TRUE);
        gtk_widget_show (GTK_WIDGET (priv->folders_treeview));
        gtk_container_add (GTK_CONTAINER (sw), GTK_WIDGET (priv->folders_treeview));
        renderer = gtk_cell_renderer_text_new ();
        column = gtk_tree_view_column_new_with_attributes (_("Folder"), renderer,
                        "text", TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN, NULL);
        gtk_tree_view_column_set_sort_column_id (column, 
                TNY_GTK_FOLDER_STORE_TREE_MODEL_NAME_COLUMN);
        gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
        gtk_tree_view_append_column (GTK_TREE_VIEW(priv->folders_treeview), column);
        select = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->folders_treeview));
        gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);

        g_signal_connect (G_OBJECT (priv->folders_treeview), "row-activated", 
                G_CALLBACK (on_folder_changed), self);

        return;
}


static void
tmut_folder_selector_finalize (GObject *object)
{
        TMutFolderSelectorPriv *priv = TMUT_FOLDER_SELECTOR_GET_PRIVATE (object);

        if (priv->account_store)
                disconnect_account_store (priv);

        (*parent_class->finalize) (object);

        return;
}

TMutShellWindow* 
tmut_folder_selector_get_window (TMutShellChild *self)
{
        TMutFolderSelectorPriv *priv = TMUT_FOLDER_SELECTOR_GET_PRIVATE (self);
        return priv->shell;
}

void 
tmut_folder_selector_set_window (TMutShellChild *self, TMutShellWindow *window)
{
        TMutFolderSelectorPriv *priv = TMUT_FOLDER_SELECTOR_GET_PRIVATE (self);
        priv->shell = window;
        return;
}

static void
tmut_shell_child_init (gpointer g, gpointer iface_data)
{
        TMutShellChildIface *klass = (TMutShellChildIface *)g;

        klass->get_window= tmut_folder_selector_get_window;
        klass->set_window= tmut_folder_selector_set_window;

        return;
}

static void
tny_account_store_view_init (gpointer g, gpointer iface_data)
{
        TnyAccountStoreViewIface *klass = (TnyAccountStoreViewIface *)g;

        klass->set_account_store= tmut_folder_selector_set_account_store;

        return;
}

static void 
tmut_folder_selector_class_init (TMutFolderSelectorClass *class)
{
        GObjectClass *object_class;

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

        object_class->finalize = tmut_folder_selector_finalize;

        g_type_class_add_private (object_class, sizeof (TMutFolderSelectorPriv));

        return;
}

static void
tmut_folder_selector_base_init (gpointer g_class)
{
        static gboolean tmut_folder_selector_initialized = FALSE;

        if (!tmut_folder_selector_initialized) 
        {
                tmut_folder_selector_signals[TMUT_FOLDER_SELECTOR_FOLDER_SELECTED] =
                   g_signal_new ("folder_selected",
                        TMUT_TYPE_FOLDER_SELECTOR,
                        G_SIGNAL_RUN_FIRST,
                        G_STRUCT_OFFSET (TMutFolderSelectorClass, folder_selected),
                        NULL, NULL,
                        g_cclosure_marshal_VOID__VOID, 
                        G_TYPE_NONE, 0);

                tmut_folder_selector_initialized = TRUE;
        }
}

/**
 * tmut_folder_selector_new:
 * 
 *
 * Return value: A new #TnySummarySelector instance implemented for TMUT
 **/
TMutFolderSelector*
tmut_folder_selector_new (void)
{
        TMutFolderSelector *self = g_object_new (TMUT_TYPE_FOLDER_SELECTOR, NULL);

        return TMUT_FOLDER_SELECTOR (self);
}

GType 
tmut_folder_selector_get_type (void)
{
        static GType type = 0;

        if (G_UNLIKELY(type == 0))
        {
                static const GTypeInfo info = 
                {
                  sizeof (TMutFolderSelectorClass),
                  tmut_folder_selector_base_init,   /* base_init */
                  NULL,   /* base_finalize */
                  (GClassInitFunc) tmut_folder_selector_class_init,   /* class_init */
                  NULL,   /* class_finalize */
                  NULL,   /* class_data */
                  sizeof (TMutFolderSelector),
                  0,      /* n_preallocs */
                  tmut_folder_selector_instance_init    /* instance_init */
                };

                static const GInterfaceInfo tny_account_store_view_info = 
                {
                  (GInterfaceInitFunc) tny_account_store_view_init, /* interface_init */
                  NULL,         /* interface_finalize */
                  NULL          /* interface_data */
                };

                static const GInterfaceInfo tmut_shell_child_info = 
                {
                  (GInterfaceInitFunc) tmut_shell_child_init, /* interface_init */
                  NULL,         /* interface_finalize */
                  NULL          /* interface_data */
                };

                type = g_type_register_static (GTK_TYPE_VBOX,
                        "TMutFolderSelector",
                        &info, 0);

                g_type_add_interface_static (type, TNY_TYPE_ACCOUNT_STORE_VIEW, 
                        &tny_account_store_view_info);

                g_type_add_interface_static (type, TMUT_TYPE_SHELL_CHILD, 
                        &tmut_shell_child_info);

        }

        return type;
}