root/trunk/src/tmut-menu-view.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-account-store.h"
#include "tmut-menu-view.h"
#include "tmut-folder-view.h"
#include "tmut-msg-creator.h"
#include "tmut-folder-selector.h"
#include "tmut-shell-window.h"
#include "tmut-shell-child.h"
#include "tmut-account-manager.h"

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

static GObjectClass *parent_class = NULL;

typedef struct _TMutMenuViewPriv TMutMenuViewPriv;

struct _TMutMenuViewPriv
{
        GtkTreeView *folders_treeview;
        GtkComboBox *accounts_combo;
        TMutShellWindow *shell;
        TnyAccountStore *account_store;
        TnyAccount *active_account;
        gint account_created_signal, account_deleted_signal;
};

#define TMUT_MENU_VIEW_GET_PRIVATE(o) \
        (G_TYPE_INSTANCE_GET_PRIVATE ((o), TMUT_TYPE_MENU_VIEW, TMutMenuViewPriv))

static void 
status_update (GObject *sender, TnyStatus *status, gpointer user_data)
{
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (user_data);

        if (priv->shell)
                gtk_progress_set_percentage (tmut_shell_window_get_progress (priv->shell), 
                                tny_status_get_fraction (status));

        return;
}


static void 
on_copy_done (TnyFolder *folder, gboolean canceled, TnyFolderStore *into, TnyFolder *new_folder, GError *err, gpointer user_data)
{
        TMutMenuView *self = TMUT_MENU_VIEW (user_data);
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (self);
        gchar *msg = "";

        if (canceled)
                msg = _("User canceled the operation");
        else if (err)
                msg = err->message;

        if (err || canceled) 
        {
                GtkWidget *dialog = gtk_message_dialog_new (
                                GTK_WINDOW (gtk_widget_get_parent (GTK_WIDGET (priv->shell))),
                                GTK_DIALOG_DESTROY_WITH_PARENT,
                                GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, msg);
                g_signal_connect_swapped (dialog, "response",
                        G_CALLBACK (gtk_widget_destroy), dialog);
                gtk_widget_show_all (dialog);
        }

        g_object_unref (user_data);

        return;
}
typedef enum {
        DO_COPY,
        DO_MOVE
} MoveCopyOption;

typedef struct {
        TnyFolder *from;
        TMutMenuView *self;
        gboolean del_originals;
} OnMoveSelectedInfo;

static void
on_folder_selected_for_move (GtkWidget *widget, gpointer user_data)
{
        OnMoveSelectedInfo *info = (OnMoveSelectedInfo *) user_data;
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (info->self);
        TnyFolderStore *into = tmut_folder_selector_get_current (TMUT_FOLDER_SELECTOR (widget));

        tmut_shell_window_back (priv->shell);

        if (into) 
        {
                GtkWidget *dialog, *entry;
                gint result;

                dialog = gtk_dialog_new_with_buttons (_("Name target folder"),
                                GTK_WINDOW (priv->shell),
                                GTK_DIALOG_MODAL,
                                GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
                                GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
                                NULL);
                entry = gtk_entry_new ();
                gtk_entry_set_text (GTK_ENTRY (entry), tny_folder_get_name (info->from));
                gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), entry);
                gtk_widget_show (entry);

                if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) 
                {

                        const gchar *new_name = gtk_entry_get_text (GTK_ENTRY (entry));

                        tny_folder_copy_async (info->from, into, 
                                new_name, info->del_originals, on_copy_done, 
                                status_update,
                                g_object_ref (info->self));
                }

                if (dialog)
                        gtk_widget_destroy (dialog);

                g_object_unref (into);
        }


        return;
}

static void
on_folder_selected_for_move_destroy (GtkWidget *widget, gpointer user_data)
{
        OnMoveSelectedInfo *info = (OnMoveSelectedInfo *) user_data;

        g_object_unref (info->from);
        g_object_unref (info->self);
        g_slice_free (OnMoveSelectedInfo, info);

        return;
}


void
folder_mover_helper (GObject *sender, TMutMenuView *self, MoveCopyOption option)
{
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (self);
        GtkTreeSelection *selection = gtk_tree_view_get_selection (priv->folders_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 *view;
                        OnMoveSelectedInfo *info;

                        gtk_tree_model_get (model, &iter, 
                                TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, 
                                &folder, -1);
                        if (folder) {
                                gboolean del_originals = TRUE;

                                info = g_slice_new0 (OnMoveSelectedInfo);
                                info->self = TMUT_MENU_VIEW (g_object_ref (self));
                                info->from = TNY_FOLDER (g_object_ref (folder));

                                if (option == DO_MOVE)
                                        info->del_originals = TRUE;

                                view = tmut_folder_selector_new ();
                                tny_account_store_view_set_account_store (TNY_ACCOUNT_STORE_VIEW (view), priv->account_store);
                                g_signal_connect (G_OBJECT (view), "folder-selected",
                                        G_CALLBACK (on_folder_selected_for_move), info);
                                g_signal_connect (G_OBJECT (view), "destroy",
                                        G_CALLBACK (on_folder_selected_for_move_destroy), info);
                                gtk_widget_show (GTK_WIDGET (view));
                                tmut_shell_window_set_child (
                                        tmut_shell_child_get_window (TMUT_SHELL_CHILD (self)), 
                                        TMUT_SHELL_CHILD (view), _("Select destination"));

                                g_object_unref (folder);
                        }
                }
        }

        return;
}


void 
tmut_menu_view_on_folder_copy_activated (GObject *sender, TMutMenuView *self)
{
        folder_mover_helper (sender, self, DO_COPY);
        return;
}

void
tmut_menu_view_on_folder_move_activated (GObject *sender, TMutMenuView *self)
{
        folder_mover_helper (sender, self, DO_MOVE);
        return;
}


void 
tmut_menu_view_on_folder_rename_activated (GObject *sender, TMutMenuView *self)
{
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (self);
        GtkTreeSelection *selection = gtk_tree_view_get_selection (priv->folders_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;

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

                        if (folder) 
                        {
                                GtkWidget *dialog, *entry;
                                gint result;

                                dialog = gtk_dialog_new_with_buttons (_("Rename folder"),
                                                GTK_WINDOW (priv->shell),
                                                GTK_DIALOG_MODAL,
                                                GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
                                                GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
                                                NULL);

                                entry = gtk_entry_new ();
                                gtk_entry_set_text (GTK_ENTRY (entry), tny_folder_get_name (folder));
                                gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), entry);
                                gtk_widget_show (entry);

                                if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) 
                                {
                                        const gchar *newname = gtk_entry_get_text (GTK_ENTRY (entry));

                                        tny_folder_copy_async (folder, tny_folder_get_folder_store (folder), 
                                                newname, TRUE, on_copy_done, 
                                                status_update, g_object_ref (self));
                                }

                                if (dialog)
                                        gtk_widget_destroy (dialog);

                                g_object_unref (folder);
                        }
                }
        }

        return;}

void
tmut_menu_view_on_folder_create_activated (GObject *sender, TMutMenuView *self)
{
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (self);
        GtkTreeSelection *selection = gtk_tree_view_get_selection (priv->folders_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) 
                {
                        TnyFolderStore *store;
                        GtkWidget *dialog, *entry;
                        gint result;
                        gtk_tree_model_get (model, &iter, 
                                TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, 
                                &store, -1);
                        dialog = gtk_dialog_new_with_buttons (_("Create a folder"),
                                        GTK_WINDOW (priv->shell),
                                        GTK_DIALOG_MODAL,
                                        GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
                                        GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
                                        NULL);

                        entry = gtk_entry_new ();
                        gtk_entry_set_text (GTK_ENTRY (entry), _("New folder"));
                        gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), entry);
                        gtk_widget_show (entry);
                        if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) 
                        {
                                GError *err = NULL;
                                const gchar *newname = gtk_entry_get_text (GTK_ENTRY (entry));
                                TnyFolder *created = tny_folder_store_create_folder (store, newname, &err);
                                if (created) /* Can be NULL on failure */
                                        g_object_unref (created);
                                if (err) {
                                        GtkWidget *edialog;
                                        gtk_widget_destroy (dialog);
                                        dialog = NULL;
                                        edialog = gtk_message_dialog_new (
                                                        GTK_WINDOW (gtk_widget_get_parent (GTK_WIDGET (priv->shell))),
                                                        GTK_DIALOG_DESTROY_WITH_PARENT,
                                                        GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
                                                        err->message);
                                        g_signal_connect_swapped (edialog, "response",
                                                G_CALLBACK (gtk_widget_destroy), edialog);
                                        gtk_widget_show_all (edialog);
                                        g_error_free (err);
                                }
                        }

                        if (dialog)
                                gtk_widget_destroy (dialog);
                        g_object_unref (store);
                }

        }

        return;
}

void
tmut_menu_view_on_folder_delete_activated (GObject *sender, TMutMenuView *self)
{
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (self);
        GtkTreeSelection *selection = gtk_tree_view_get_selection (priv->folders_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 = NULL;
                        gtk_tree_model_get (model, &iter, 
                                TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, 
                                &folder, -1);
                        if (folder) 
                        {
                                gint result;
                                GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Delete a folder"),
                                          GTK_WINDOW (priv->shell),
                                          GTK_DIALOG_MODAL,
                                          GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
                                          GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
                                          NULL);
                                GtkWidget *label = gtk_label_new (_("Are you sure you want to delete this folder?"));
                                gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), label);
                                gtk_widget_show (label);
                                if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
                                {
                                        GError *err = NULL;
                                        TnyFolderStore *store = tny_folder_get_folder_store (folder);
                                        tny_folder_store_remove_folder (store, folder, &err);
                                        if (err) {
                                                GtkWidget *edialog;
                                                gtk_widget_destroy (dialog);
                                                dialog = NULL;
                                                edialog = gtk_message_dialog_new (
                                                        GTK_WINDOW (gtk_widget_get_parent (GTK_WIDGET (priv->shell))),
                                                        GTK_DIALOG_DESTROY_WITH_PARENT,
                                                        GTK_MESSAGE_ERROR,GTK_BUTTONS_CLOSE,
                                                        err->message);
                                                g_signal_connect_swapped (edialog, "response",
                                                        G_CALLBACK (gtk_widget_destroy), edialog);
                                                gtk_widget_show_all (edialog);
                                                g_error_free (err);
                                        }
                                        g_object_unref (store);
                                }
                                if (dialog)
                                        gtk_widget_destroy (dialog);
                                g_object_unref (folder);
                        }
                }
        }

        return;
}

static void 
tmut_menu_view_on_onli_activated (GtkMenuItem *menuitem, TMutMenuView *self)
{
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (self);
        TnyDevice *device = tny_account_store_get_device (priv->account_store);

        if (!tny_device_is_online (device)) {
                GtkWidget *label = gtk_bin_get_child (GTK_BIN (menuitem));
                tny_device_force_online (device);
                gtk_label_set (GTK_LABEL (label), _("Force offline"));
        } else {
                GtkWidget *label = gtk_bin_get_child (GTK_BIN (menuitem));
                tny_device_force_offline (device);
                gtk_label_set (GTK_LABEL (label), _("Force online"));
        }

        g_object_unref (device);
        return;
}

void 
tmut_menu_view_on_new_msg_activated (GObject *sender, TMutMenuView *self)
{
        TMutMsgCreator *view = tmut_msg_creator_new ();
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (self);

        if (priv->account_store)
                tny_account_store_view_set_account_store (TNY_ACCOUNT_STORE_VIEW (view), priv->account_store);

        gtk_widget_show (GTK_WIDGET (view));
        tmut_shell_window_set_child (
                tmut_shell_child_get_window (TMUT_SHELL_CHILD (self)), 
                TMUT_SHELL_CHILD (view), NULL);

        return;

}

void 
tmut_menu_view_on_account_manager_activated (GObject *sender, TMutMenuView *self)
{
        TMutAccountManager *view = tmut_account_manager_new ();
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (self);

        if (priv->account_store)
                tny_account_store_view_set_account_store (TNY_ACCOUNT_STORE_VIEW (view), priv->account_store);

        gtk_widget_show (GTK_WIDGET (view));
        tmut_shell_window_set_child (
                tmut_shell_child_get_window (TMUT_SHELL_CHILD (self)), 
                TMUT_SHELL_CHILD (view), NULL);

        return;
}


static void
popup_the_actions_menu (GtkButton *button, gpointer user_data)
{
        GtkMenu *menu = (GtkMenu *) user_data;
        gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 
                        0, gtk_get_current_event_time ());
        return;
}

typedef struct {
        TnyDevice *device;
        GtkMenuItem *menuitem;
} CheckOnlineStateInfo;

static gboolean 
check_online_state_idle (gpointer user_data)
{
        CheckOnlineStateInfo *info = (CheckOnlineStateInfo *) user_data;

        if (!tny_device_is_online (info->device)) {
                GtkWidget *label = gtk_bin_get_child (GTK_BIN (info->menuitem));
                gtk_label_set (GTK_LABEL (label), _("Force online"));
        } else {
                GtkWidget *label = gtk_bin_get_child (GTK_BIN (info->menuitem));
                gtk_label_set (GTK_LABEL (label), _("Force offline"));
        }

        return FALSE;
}

static void 
check_online_state_destroy (gpointer user_data)
{
        CheckOnlineStateInfo *info = (CheckOnlineStateInfo *) user_data;
        g_object_unref (info->device);
        g_object_unref (info->menuitem);
        g_slice_free (CheckOnlineStateInfo, info);
        return;
}

static void
tmut_menu_view_create_menu_default (TMutMenuView *self)
{
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (self);
        CheckOnlineStateInfo *info = g_slice_new0 (CheckOnlineStateInfo);
        GtkMenu *menu;
        GtkWidget *fcreate_menuitem, *fmove_menuitem, *fdel_menuitem, 
                  *nmsg_menuitem, *fcopy_menuitem, *frename_menuitem,
                  *onli_menuitem, *accmng_menuitem;
        GtkButton *menu_button;

        info->device = tny_account_store_get_device (priv->account_store);
        menu_button = GTK_BUTTON (gtk_button_new_with_label (_("Actions")));
        menu = GTK_MENU (gtk_menu_new ());
        fcreate_menuitem = gtk_menu_item_new_with_label (_("Create new folder"));
        fmove_menuitem = gtk_menu_item_new_with_label (_("Move a folder"));
        fcopy_menuitem = gtk_menu_item_new_with_label (_("Copy a folder"));
        frename_menuitem = gtk_menu_item_new_with_label (_("Rename a folder"));
        fdel_menuitem = gtk_menu_item_new_with_label (_("Delete a folder"));
        nmsg_menuitem = gtk_menu_item_new_with_label (_("New message"));
        accmng_menuitem = gtk_menu_item_new_with_label (_("Account manager"));

        if (!tny_device_is_online (info->device))
                onli_menuitem = gtk_menu_item_new_with_label (_("Force offline"));
        else
                onli_menuitem = gtk_menu_item_new_with_label (_("Force online"));

        info->menuitem = g_object_ref (onli_menuitem);

        g_idle_add_full (5000, check_online_state_idle, 
                info, check_online_state_destroy);

        gtk_widget_show (accmng_menuitem);
        gtk_widget_show (onli_menuitem);
        gtk_widget_show (nmsg_menuitem);
        gtk_widget_show (fcreate_menuitem);
        gtk_widget_show (fmove_menuitem);
        gtk_widget_show (fcopy_menuitem);
        gtk_widget_show (frename_menuitem);
        gtk_widget_show (fdel_menuitem);
        gtk_widget_show (GTK_WIDGET (menu));
        gtk_widget_show (GTK_WIDGET (menu_button));

        gtk_menu_prepend (menu, accmng_menuitem);
        gtk_menu_prepend (menu, onli_menuitem);
        gtk_menu_prepend (menu, nmsg_menuitem);
        gtk_menu_prepend (menu, fcreate_menuitem);
        gtk_menu_prepend (menu, fcopy_menuitem);
        gtk_menu_prepend (menu, fmove_menuitem);
        gtk_menu_prepend (menu, frename_menuitem);
        gtk_menu_prepend (menu, fdel_menuitem);
        gtk_menu_attach_to_widget (menu, GTK_WIDGET (menu_button), NULL);
        gtk_box_pack_start (GTK_BOX (self), GTK_WIDGET (menu_button), FALSE, TRUE, 0);

        g_signal_connect (G_OBJECT (menu_button), "clicked",
                G_CALLBACK (popup_the_actions_menu), menu);
        g_signal_connect (G_OBJECT (accmng_menuitem), "activate",
                G_CALLBACK (tmut_menu_view_on_account_manager_activated), self);
        g_signal_connect (G_OBJECT (onli_menuitem), "activate",
                G_CALLBACK (tmut_menu_view_on_onli_activated), self);
        g_signal_connect (G_OBJECT (nmsg_menuitem), "activate",
                G_CALLBACK (tmut_menu_view_on_new_msg_activated), self);
        g_signal_connect (G_OBJECT (fcreate_menuitem), "activate",
                G_CALLBACK (tmut_menu_view_on_folder_create_activated), self);
        g_signal_connect (G_OBJECT (fmove_menuitem), "activate",
                G_CALLBACK (tmut_menu_view_on_folder_move_activated), self);
        g_signal_connect (G_OBJECT (fcopy_menuitem), "activate",
                G_CALLBACK (tmut_menu_view_on_folder_copy_activated), self);
        g_signal_connect (G_OBJECT (frename_menuitem), "activate",
                G_CALLBACK (tmut_menu_view_on_folder_rename_activated), self);
        g_signal_connect (G_OBJECT (fdel_menuitem), "activate",
                G_CALLBACK (tmut_menu_view_on_folder_delete_activated), self);

        return;
}


void 
tmut_menu_view_set_active_account (TMutMenuView *self, TnyAccount *account)
{
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (self);
        TnyFolderStoreQuery *query;
        GtkTreeModel *old_model, *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);
        tny_gtk_folder_store_tree_model_append (TNY_GTK_FOLDER_STORE_TREE_MODEL (model),
                TNY_FOLDER_STORE (account), tny_account_get_name (account));

        gtk_tree_view_set_model (priv->folders_treeview, model);

        if (priv->active_account)
                g_object_unref (priv->active_account);
        priv->active_account = g_object_ref (account);

        g_object_unref (model);

        return;
}


static void 
on_account_changed (GtkComboBox *combobox, gpointer user_data)
{
        TMutMenuView *self = TMUT_MENU_VIEW (user_data);
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (self);
        GtkTreeIter iter;
        TnyAccount *account = NULL;
        GtkTreeModel *model = gtk_combo_box_get_model (combobox);

        if (gtk_combo_box_get_active_iter (priv->accounts_combo, &iter)) 
        {
                gtk_tree_model_get (model, &iter, 
                        TNY_GTK_ACCOUNT_LIST_MODEL_INSTANCE_COLUMN, 
                        &account, -1);
                if (account) {
                        tmut_menu_view_set_active_account (TMUT_MENU_VIEW (user_data), account);
                        g_object_unref (account);
                }
        }

        return;
}

static void
on_account_created (TMutAccountStore *store, TnyAccount *account, TMutMenuView *self)
{
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (self);
        TnyList *model = TNY_LIST (gtk_combo_box_get_model (priv->accounts_combo));
        tny_list_prepend (model, (GObject *) account);
}


static void
on_account_deleted (TMutAccountStore *store, TnyAccount *account, TMutMenuView *self)
{
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (self);
        TnyList *model = TNY_LIST (gtk_combo_box_get_model (priv->accounts_combo));
        if (account == priv->active_account) {
                g_object_unref (priv->active_account);
                priv->active_account = NULL;
                gtk_tree_view_set_model (priv->folders_treeview, NULL);
        }
        gtk_combo_box_set_active (priv->accounts_combo, -1);
        tny_list_remove (model, (GObject *) account);
}

static void
disconnect_account_store (TMutMenuViewPriv *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
tmut_menu_view_set_account_store (TnyAccountStoreView *self, TnyAccountStore *account_store)
{
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (self);
        TnyList *accounts = TNY_LIST (tny_gtk_account_list_model_new ());

        tny_account_store_get_accounts (account_store, accounts,
                TNY_ACCOUNT_STORE_STORE_ACCOUNTS);
        gtk_combo_box_set_model (priv->accounts_combo, GTK_TREE_MODEL (accounts));
        gtk_combo_box_set_active (priv->accounts_combo, 0);

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

        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);

        TMUT_MENU_VIEW_GET_CLASS (self)->create_menu (TMUT_MENU_VIEW (self));

        return;
}


static void
on_folder_changed (GtkTreeView *treeview, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data)
{
        TMutMenuView *self = TMUT_MENU_VIEW (user_data);
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_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;
                        TMutFolderView *view;

                        gtk_tree_model_get (model, &iter, 
                                TNY_GTK_FOLDER_STORE_TREE_MODEL_INSTANCE_COLUMN, 
                                &folder, -1);
                        if (!folder)
                                return;
                        view = tmut_folder_view_new (priv->account_store);
                        tmut_folder_view_set_active_folder (view, folder);
                        gtk_widget_show (GTK_WIDGET (view));
                        tmut_shell_window_set_child (
                                tmut_shell_child_get_window (TMUT_SHELL_CHILD (self)), 
                                TMUT_SHELL_CHILD (view), NULL);
                        g_object_unref (folder);
                }
        }

        return;
}


static void
tmut_menu_view_instance_init (GTypeInstance *instance, gpointer g_class)
{
        TMutMenuView *self = (TMutMenuView *) instance;
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (self);
        GtkVBox *vbox = GTK_VBOX (self);
        GtkCellRenderer *renderer;
        GtkTreeViewColumn *column;
        GtkTreeSelection *select;
        GtkWidget *sw;

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

        priv->accounts_combo = GTK_COMBO_BOX (gtk_combo_box_new ());
        gtk_widget_show (GTK_WIDGET (priv->accounts_combo));
        renderer = gtk_cell_renderer_text_new();
        gtk_cell_layout_pack_start(GTK_CELL_LAYOUT (priv->accounts_combo), renderer, TRUE);
        gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT (priv->accounts_combo), renderer, 
                "text", TNY_GTK_ACCOUNT_LIST_MODEL_NAME_COLUMN, NULL);
        gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (priv->accounts_combo), 
                FALSE, TRUE, 0);
        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->accounts_combo), "changed", 
                G_CALLBACK (on_account_changed), self);
        g_signal_connect (G_OBJECT (priv->folders_treeview), "row-activated", 
                G_CALLBACK (on_folder_changed), self);

        return;
}

static void
tmut_menu_view_finalize (GObject *object)
{
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (object);

        if (priv->active_account)
                g_object_unref (priv->active_account);

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

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

        (*parent_class->finalize) (object);

        return;
}

TMutShellWindow* 
tmut_menu_view_get_window (TMutShellChild *self)
{
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_GET_PRIVATE (self);
        return priv->shell;
}

void 
tmut_menu_view_set_window (TMutShellChild *self, TMutShellWindow *window)
{
        TMutMenuViewPriv *priv = TMUT_MENU_VIEW_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_menu_view_get_window;
        klass->set_window= tmut_menu_view_set_window;

        return;
}

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

        klass->set_account_store= tmut_menu_view_set_account_store;

        return;
}

static void 
tmut_menu_view_class_init (TMutMenuViewClass *class)
{
        GObjectClass *object_class;

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

        object_class->finalize = tmut_menu_view_finalize;

        class->create_menu= tmut_menu_view_create_menu_default;

        g_type_class_add_private (object_class, sizeof (TMutMenuViewPriv));

        return;
}

/**
 * tmut_menu_view_new:
 * 
 *
 * Return value: A new #TnySummaryView instance implemented for TMUT
 **/
TMutMenuView*
tmut_menu_view_new (void)
{
        TMutMenuView *self = g_object_new (TMUT_TYPE_MENU_VIEW, NULL);

        return TMUT_MENU_VIEW (self);
}

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

        if (G_UNLIKELY(type == 0))
        {
                static const GTypeInfo info = 
                {
                  sizeof (TMutMenuViewClass),
                  NULL,   /* base_init */
                  NU