src/accountview.cpp

/*
 *  Copyright (C) 2015-2018 Savoir-faire Linux Inc.
 *  Author: Stepan Salenikovich <stepan.salenikovich@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.
 */

#include "accountview.h"

#include <gtk/gtk.h>
#include <glib/gi18n.h>
#include <accountmodel.h>
#include <protocolmodel.h>
#include <QtCore/QItemSelectionModel>
#include "models/gtkqtreemodel.h"
#include "models/gtkqtreemodel.h"
#include "models/activeitemproxymodel.h"
#include "accountgeneraltab.h"
#include "accountcreationwizard.h"
#include "accountadvancedtab.h"
#include "accountsecuritytab.h"
#include "accountdevicestab.h"
#include "dialogs.h"
#include <glib/gprintf.h>
#include "utils/models.h"
#include "accountbanstab.h"

#include <api/newaccountmodel.h>

static constexpr const char* ACCOUNT_CREATION_WIZARD_VIEW_NAME = "account-creation-wizard";

struct _AccountView
{
    GtkPaned parent;
};

struct _AccountViewClass
{
    GtkPanedClass parent_class;
};

typedef struct _AccountViewPrivate AccountViewPrivate;

struct _AccountViewPrivate
{
    AccountInfoPointer const *accountInfo_ = nullptr;
    AccountInfoPointer selectedInfo_ = nullptr;

    GtkWidget *treeview_account_list;
    GtkWidget *stack_account;
    GtkWidget *button_remove_account;
    GtkWidget *button_add_account;
    GtkWidget *combobox_account_type;
    GtkWidget *account_creation_wizard;

    gint current_page; /* keeps track of current notebook page displayed */

    QMetaObject::Connection protocol_selection_changed;
    QMetaObject::Connection account_selection_changed;
};

G_DEFINE_TYPE_WITH_PRIVATE(AccountView, account_view, GTK_TYPE_PANED);

#define ACCOUNT_VIEW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), ACCOUNT_VIEW_TYPE, AccountViewPrivate))

static void
account_view_dispose(GObject *object)
{
    AccountView *view = ACCOUNT_VIEW(object);
    AccountViewPrivate *priv = ACCOUNT_VIEW_GET_PRIVATE(view);

    QObject::disconnect(priv->protocol_selection_changed);
    QObject::disconnect(priv->account_selection_changed);

    G_OBJECT_CLASS(account_view_parent_class)->dispose(object);
}

static void
update_account_model_selection(GtkTreeSelection *selection, G_GNUC_UNUSED gpointer user_data)
{
    QModelIndex current = get_index_from_selection(selection);
    if (current.isValid())
        AccountModel::instance().selectionModel()->setCurrentIndex(current, QItemSelectionModel::ClearAndSelect);
    else
        AccountModel::instance().selectionModel()->clearCurrentIndex();
}

static GtkWidget *
create_scrolled_account_view(GtkWidget *account_view)
{
    auto scrolled = gtk_scrolled_window_new(NULL, NULL);
    gtk_container_add(GTK_CONTAINER(scrolled), account_view);
    return scrolled;
}

static void
tab_selection_changed(G_GNUC_UNUSED GtkNotebook *notebook,
                      G_GNUC_UNUSED GtkWidget   *page,
                                    guint        page_num,
                                    AccountView *self)
{
    g_return_if_fail(IS_ACCOUNT_VIEW(self));
    AccountViewPrivate *priv = ACCOUNT_VIEW_GET_PRIVATE(self);

    priv->current_page = page_num;
}

static void
account_selection_changed(GtkTreeSelection *selection, AccountView *self)
{
    g_return_if_fail(IS_ACCOUNT_VIEW(self));
    AccountViewPrivate *priv = ACCOUNT_VIEW_GET_PRIVATE(self);

    auto old_view = gtk_stack_get_visible_child(GTK_STACK(priv->stack_account));
    if(IS_ACCOUNT_CREATION_WIZARD(old_view))
    {
        // cancel account creation, this will call hide_account_creation_wizard via callback
        account_creation_wizard_cancel(ACCOUNT_CREATION_WIZARD(old_view));
        return;
    }

    QModelIndex account_idx = get_index_from_selection(selection);
    if (!account_idx.isValid()) {
        g_debug("accountview: invalid account selection");

        /* If no account is selected, check for account list size. If not 0, select
           the first account. */
        GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview_account_list));
        if (gtk_tree_model_iter_n_children(model, NULL)) {
            g_debug("accountview: other accounts are available, selecting first one");
            GtkTreePath *path = gtk_tree_path_new_from_indices(0, -1);
            gtk_tree_selection_select_path(gtk_tree_view_get_selection (GTK_TREE_VIEW(priv->treeview_account_list)), path);
            gtk_tree_path_free(path);
            return;
        }

        /* there is no account to select, display empty */
        GtkWidget *empty_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
        gtk_widget_show(empty_box);
        gtk_stack_add_named(GTK_STACK(priv->stack_account), empty_box, "placeholder");
        gtk_stack_set_visible_child(GTK_STACK(priv->stack_account), empty_box);

        /* cannot delete accounts */
        gtk_widget_set_sensitive(priv->button_remove_account, FALSE);
    } else {
        Account *account = AccountModel::instance().getAccountByModelIndex(account_idx);

        /* build new account view */
        GtkWidget *hbox_account = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
        gtk_widget_show(hbox_account);

        /* create account notebook */
        auto account_notebook = gtk_notebook_new();
        gtk_widget_show(account_notebook);
        gtk_notebook_set_scrollable(GTK_NOTEBOOK(account_notebook), TRUE);
        gtk_notebook_set_show_border(GTK_NOTEBOOK(account_notebook), FALSE);
        gtk_box_pack_start(GTK_BOX(hbox_account), account_notebook, TRUE, TRUE, 0);

        // Build a new AccountInfoPointer pointing on selected account in this view, not in the app
        // TODO in the future, get rid of the Account class (pass the selected id)
        auto selectedId = account->id().toStdString();
        priv->selectedInfo_ = &(*priv->accountInfo_)->accountModel->getAccountInfo(selectedId);

        /* customize account view based on account */
        auto general_tab = create_scrolled_account_view(account_general_tab_new(account, priv->selectedInfo_));
        gtk_widget_show(general_tab);
        gtk_notebook_append_page(GTK_NOTEBOOK(account_notebook),
                                 general_tab,
                                 gtk_label_new(C_("Account settings", "General")));

        if (account->protocol() == Account::Protocol::RING)
        {
            auto devices_tab = create_scrolled_account_view(account_devices_tab_new(account));
            gtk_widget_show(devices_tab);
            gtk_notebook_append_page(GTK_NOTEBOOK(account_notebook),
                                     devices_tab,
                                     gtk_label_new(C_("Account settings", "Devices")));
        }
        auto security_tab = create_scrolled_account_view(account_security_tab_new(account));
        gtk_widget_show(security_tab);
        gtk_notebook_append_page(GTK_NOTEBOOK(account_notebook),
                                 security_tab,
                                 gtk_label_new(C_("Account settings", "Security")));
        auto advanced_tab = create_scrolled_account_view(account_advanced_tab_new(account));
        gtk_widget_show(advanced_tab);
        gtk_notebook_append_page(GTK_NOTEBOOK(account_notebook),
                                 advanced_tab,
                                 gtk_label_new(C_("Account settings", "Advanced")));

        if (account->protocol() == Account::Protocol::RING) {
            auto banned_tab = create_scrolled_account_view(account_bans_tab_new(account));
            gtk_widget_show(banned_tab);
            gtk_notebook_append_page(GTK_NOTEBOOK(account_notebook),
                                     banned_tab,
                                     gtk_label_new(C_("List of banned peers", "Bans")));
        }

        /* set the tab displayed to the same as the prev account selected */
        gtk_notebook_set_current_page(GTK_NOTEBOOK(account_notebook), priv->current_page);
        /* now connect to the tab changed signal */
        g_signal_connect(account_notebook, "switch-page", G_CALLBACK(tab_selection_changed), self);

        /* set the new account view as visible */
        char *account_view_name = g_strdup_printf("%p_account", account);
        gtk_stack_add_named(GTK_STACK(priv->stack_account), hbox_account, account_view_name);
        gtk_stack_set_visible_child(GTK_STACK(priv->stack_account), hbox_account);
        g_free(account_view_name);

        /* can delete accounts */
        gtk_widget_set_sensitive(priv->button_remove_account, TRUE);
    }

    /* remove the old view */
    if (old_view)
        gtk_container_remove(GTK_CONTAINER(priv->stack_account), old_view);
}

static void
account_active_toggled(GtkCellRendererToggle *renderer, gchar *path, AccountView *view)
{
    g_return_if_fail(IS_ACCOUNT_VIEW(view));
    AccountViewPrivate *priv = ACCOUNT_VIEW_GET_PRIVATE(view);

    /* we want to set it to the opposite of the current value */
    gboolean toggle = !gtk_cell_renderer_toggle_get_active(renderer);

    /* get iter which was clicked */
    GtkTreePath *tree_path = gtk_tree_path_new_from_string(path);
    GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview_account_list));
    GtkTreeIter iter;
    gtk_tree_model_get_iter(model, &iter, tree_path);

    /* get qmodelindex from iter and set the model data */
    QModelIndex idx = gtk_q_tree_model_get_source_idx(GTK_Q_TREE_MODEL(model), &iter);
    if (idx.isValid()) {
        QVariant alias = idx.data(static_cast<int>(Account::Role::Alias));
        AccountModel::instance().setData(idx, QVariant(toggle), Qt::CheckStateRole);
        /* save the account to apply the changed state right away */
        AccountModel::instance().getAccountByModelIndex(idx)->performAction(Account::EditAction::SAVE);
    }
}

static gboolean
remove_account_dialog(AccountView *view, Account *account)
{
    gboolean response = FALSE;
    GtkWidget *dialog = gtk_message_dialog_new(NULL,
                            (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
                            GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL,
                            _("Are you sure you want to delete account \"%s\"?"),
                            account->alias().toLocal8Bit().constData());

    gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);

    /* get parent window so we can center on it */
    GtkWidget *parent = gtk_widget_get_toplevel(GTK_WIDGET(view));
    if (gtk_widget_is_toplevel(parent)) {
        gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(parent));
        gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
    }

    switch (gtk_dialog_run(GTK_DIALOG(dialog))) {
        case GTK_RESPONSE_OK:
            response = TRUE;
            break;
        default:
            response = FALSE;
            break;
    }

    gtk_widget_destroy(dialog);

    return response;
}

static gboolean
save_account(GtkWidget *working_dialog)
{
    AccountModel::instance().save();
    if (working_dialog)
        gtk_widget_destroy(working_dialog);

    return G_SOURCE_REMOVE;
}

static void
remove_account(G_GNUC_UNUSED GtkWidget *entry, AccountView *view)
{
    g_return_if_fail(IS_ACCOUNT_VIEW(view));
    AccountViewPrivate *priv = ACCOUNT_VIEW_GET_PRIVATE(view);

    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->treeview_account_list));
    QModelIndex idx = get_index_from_selection(selection);

    if (idx.isValid()) {
        /* this is a destructive operation, ask the user if they are sure */
        Account *account = AccountModel::instance().getAccountByModelIndex(idx);
        if (remove_account_dialog(view, account)) {
            /* show working dialog in case save operation takes time */
            GtkWidget *working = ring_dialog_working(GTK_WIDGET(view), NULL);
            gtk_window_present(GTK_WINDOW(working));

            AccountModel::instance().remove(idx);

            /* now save the time it takes to transition the account view to the new account (300ms)
             * the save doesn't happen before the "working" dialog is presented
             * the timeout function should destroy the "working" dialog when done saving
             */
            g_timeout_add_full(G_PRIORITY_DEFAULT, 300, (GSourceFunc)save_account, working, NULL);
        }
    }
}

static void
hide_account_creation_wizard(AccountView *view)
{
    g_return_if_fail(IS_ACCOUNT_VIEW(view));
    AccountViewPrivate *priv = ACCOUNT_VIEW_GET_PRIVATE(view);

    auto old_view = gtk_stack_get_visible_child(GTK_STACK(priv->stack_account));
    if (IS_ACCOUNT_CREATION_WIZARD(old_view))
    {
        account_creation_wizard_show_preview(ACCOUNT_CREATION_WIZARD(old_view), FALSE);
        gtk_container_remove(GTK_CONTAINER(priv->stack_account), old_view);
    }

    auto selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->treeview_account_list));
    account_selection_changed(selection, view);
}

static void
show_account_creation_wizard(AccountView *view)
{
    g_return_if_fail(IS_ACCOUNT_VIEW(view));
    AccountViewPrivate *priv = ACCOUNT_VIEW_GET_PRIVATE(view);

    auto old_view = gtk_stack_get_visible_child(GTK_STACK(priv->stack_account));

    if (!priv->account_creation_wizard)
    {
        priv->account_creation_wizard = account_creation_wizard_new(true);
        g_object_add_weak_pointer(G_OBJECT(priv->account_creation_wizard), (gpointer *)&priv->account_creation_wizard);
        gtk_stack_add_named(GTK_STACK(priv->stack_account),
                            priv->account_creation_wizard,
                            ACCOUNT_CREATION_WIZARD_VIEW_NAME);
        g_signal_connect_swapped(priv->account_creation_wizard, "account-creation-completed", G_CALLBACK(hide_account_creation_wizard), view);
        g_signal_connect_swapped(priv->account_creation_wizard, "account-creation-canceled", G_CALLBACK(hide_account_creation_wizard), view);
    }

    gtk_widget_show(priv->account_creation_wizard);

    gtk_stack_set_visible_child_name(GTK_STACK(priv->stack_account), ACCOUNT_CREATION_WIZARD_VIEW_NAME);

    /* remove the old view */
    if (old_view)
        gtk_container_remove(GTK_CONTAINER(priv->stack_account), old_view);
}

static void
add_account(G_GNUC_UNUSED GtkWidget *entry, AccountView *view)
{
    g_return_if_fail(IS_ACCOUNT_VIEW(view));
    AccountViewPrivate *priv = ACCOUNT_VIEW_GET_PRIVATE(view);

    auto idx = gtk_combo_box_get_index(GTK_COMBO_BOX(priv->combobox_account_type));
    if (idx.isValid()) {
        Account::Protocol protocol = qvariant_cast<Account::Protocol>(idx.data((int)ProtocolModel::Role::Protocol));
        if (protocol == Account::Protocol::RING)
        {
            auto old_view = gtk_stack_get_visible_child(GTK_STACK(priv->stack_account));
            if (IS_ACCOUNT_CREATION_WIZARD(old_view))
            {
                account_creation_wizard_cancel(ACCOUNT_CREATION_WIZARD(old_view));
            } else {
                show_account_creation_wizard(view);
            }
        }
        else
        {
            /* show working dialog in case save operation takes time */
            GtkWidget *working = ring_dialog_working(GTK_WIDGET(view), NULL);
            gtk_window_present(GTK_WINDOW(working));

            AccountModel::instance().add(QString(_("New Account")), idx);

            /* now save after a short timeout to make sure that
             * the save doesn't happen before the "working" dialog is presented
             * the timeout function should destroy the "working" dialog when done saving
             */
            g_timeout_add_full(G_PRIORITY_DEFAULT, 300, (GSourceFunc)save_account, working, NULL);
        }
    }
}

static void
state_to_string(G_GNUC_UNUSED GtkTreeViewColumn *tree_column,
                GtkCellRenderer *cell,
                GtkTreeModel *tree_model,
                GtkTreeIter *iter,
                GtkTreeView *treeview)
{
    // check if this iter is selected
    gboolean is_selected = FALSE;
    if (GTK_IS_TREE_VIEW(treeview)) {
        auto selection = gtk_tree_view_get_selection(treeview);
        is_selected = gtk_tree_selection_iter_is_selected(selection, iter);
    }

    gchar *display_state = NULL;

    /* get account */
    QModelIndex idx = gtk_q_tree_model_get_source_idx(GTK_Q_TREE_MODEL(tree_model), iter);
    if (idx.isValid()) {

        auto account = AccountModel::instance().getAccountByModelIndex(idx);
        auto humanState = account->toHumanStateName();

        auto escaped_state = g_markup_escape_text(humanState.toUtf8().constData(), -1);
        /* we want the color of the status text to be the default color if this iter is
         * selected so that the treeview is able to invert it against the selection color */
        if (is_selected) {
            display_state = escaped_state;
        } else {
            switch (account->registrationState()) {
                case Account::RegistrationState::READY:
                    display_state = g_strdup_printf("<span fgcolor=\"green\">%s</span>", escaped_state);
                break;
                case Account::RegistrationState::UNREGISTERED:
                    display_state = g_strdup_printf("<span fgcolor=\"gray\">%s</span>", escaped_state);
                break;
                case Account::RegistrationState::TRYING:
                case Account::RegistrationState::INITIALIZING:
                    display_state = g_strdup_printf("<span fgcolor=\"orange\">%s</span>", escaped_state);
                break;
                case Account::RegistrationState::ERROR:
                    display_state = g_strdup_printf("<span fgcolor=\"red\">%s</span>", escaped_state);
                break;
                case Account::RegistrationState::COUNT__:
                    g_warning("registration state should never be \"count\"");
                    display_state = g_strdup_printf("<span fgcolor=\"red\">%s</span>", escaped_state);
                break;
            }
            g_free(escaped_state);
        }
    }

    g_object_set(G_OBJECT(cell), "markup", display_state, NULL);
    g_free(display_state);
}

static void
account_view_init(AccountView *view)
{
    gtk_widget_init_template(GTK_WIDGET(view));

    AccountViewPrivate *priv = ACCOUNT_VIEW_GET_PRIVATE(view);

    /* account model */
    GtkQTreeModel *account_model;
    GtkCellRenderer *renderer;
    GtkTreeViewColumn *column;

    account_model = gtk_q_tree_model_new(&AccountModel::instance(), 4,
        0, Account::Role::Enabled, G_TYPE_BOOLEAN,
        0, Account::Role::Alias, G_TYPE_STRING,
        0, Account::Role::Proto, G_TYPE_STRING,
        0, Account::Role::RegistrationState, G_TYPE_UINT);
    gtk_tree_view_set_model(GTK_TREE_VIEW(priv->treeview_account_list), GTK_TREE_MODEL(account_model));

    renderer = gtk_cell_renderer_toggle_new();
    column = gtk_tree_view_column_new_with_attributes(C_("Account state column", "Enabled"), renderer, "active", 0, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(priv->treeview_account_list), column);

    g_signal_connect(renderer, "toggled", G_CALLBACK(account_active_toggled), view);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes(C_("Account alias (name) column", "Alias"), renderer, "text", 1, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(priv->treeview_account_list), column);
    g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
    gtk_tree_view_column_set_expand(column, TRUE);
    // set a min width so most of the account name is visible
    g_object_set(G_OBJECT(renderer), "width", 75, NULL);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes(C_("Account status column", "Status"), renderer, "text", 3, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(priv->treeview_account_list), column);
    g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
    gtk_tree_view_column_set_expand(column, TRUE);

    /* the registration state is an enum, we want to display it as a string */
    gtk_tree_view_column_set_cell_data_func(
        column,
        renderer,
        (GtkTreeCellDataFunc)state_to_string,
        priv->treeview_account_list,
        NULL);

    /* add an empty box to the account stack initially, otherwise there will
     * be no cool animation when the first account is selected */
    GtkWidget *empty_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
    gtk_widget_show(empty_box);
    gtk_stack_add_named(GTK_STACK(priv->stack_account), empty_box, "placeholder");
    gtk_stack_set_visible_child(GTK_STACK(priv->stack_account), empty_box);

    /* populate account type combo box */
    priv->protocol_selection_changed = gtk_combo_box_set_qmodel_text(
        GTK_COMBO_BOX(priv->combobox_account_type),
        AccountModel::instance().protocolModel(),
        AccountModel::instance().protocolModel()->selectionModel()
    );

    /* connect signals to and from the selection model of the account model */
    priv->account_selection_changed = QObject::connect(
        AccountModel::instance().selectionModel(),
        &QItemSelectionModel::currentChanged,
        [=](const QModelIndex & current, G_GNUC_UNUSED const QModelIndex & previous) {
            GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->treeview_account_list));

            /* select the current */
            if (current.isValid()) {
                GtkTreeIter new_iter;
                if (gtk_q_tree_model_source_index_to_iter(account_model, current, &new_iter)) {
                    gtk_tree_selection_select_iter(selection, &new_iter);
                } else {
                    g_warning("SelectionModel of AccountModel changed to invalid QModelIndex?");
                }
            }
        }
    );

    GtkTreeSelection *account_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->treeview_account_list));
    g_signal_connect(account_selection, "changed", G_CALLBACK(update_account_model_selection), NULL);
    g_signal_connect(account_selection, "changed", G_CALLBACK(account_selection_changed), view);

    /* connect signals to add/remove accounts */
    g_signal_connect(priv->button_remove_account, "clicked", G_CALLBACK(remove_account), view);
    g_signal_connect(priv->button_add_account, "clicked", G_CALLBACK(add_account), view);
}

static void
account_view_class_init(AccountViewClass *klass)
{
    G_OBJECT_CLASS(klass)->dispose = account_view_dispose;

    gtk_widget_class_set_template_from_resource(GTK_WIDGET_CLASS (klass),
                                                "/cx/ring/RingGnome/accountview.ui");

    gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS (klass), AccountView, treeview_account_list);
    gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS (klass), AccountView, stack_account);
    gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS (klass), AccountView, button_remove_account);
    gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS (klass), AccountView, button_add_account);
    gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS (klass), AccountView, combobox_account_type);
}

GtkWidget *
account_view_new(AccountInfoPointer const & accountInfo)
{
    auto* view = g_object_new(ACCOUNT_VIEW_TYPE, NULL);
    AccountViewPrivate *priv = ACCOUNT_VIEW_GET_PRIVATE(view);
    priv->accountInfo_ = &accountInfo;
    return (GtkWidget *)view;
}

void
account_settings_view_show(AccountView *view, gboolean show) {
    AccountViewPrivate *priv = ACCOUNT_VIEW_GET_PRIVATE(view);

    /* If displayed stack element is still the placeholder element, thats is it hasn't
       been initialized yet, change account selection. */
    if (show && strcmp(gtk_stack_get_visible_child_name (GTK_STACK(priv->stack_account)), "placeholder") == 0) {
        auto selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->treeview_account_list));
        account_selection_changed(selection, view);
        return;
    }

    /* If account creation wizard is currently open and settings get closed, cancel so
       the preview is stopped properly. */
    auto old_view = gtk_stack_get_visible_child(GTK_STACK(priv->stack_account));
    if (!show && IS_ACCOUNT_CREATION_WIZARD(old_view)) {
        account_creation_wizard_cancel(ACCOUNT_CREATION_WIZARD(old_view));
    }
}