path: root/src/pdm-dialog.c

/*
 *  Copyright © 2002 Jorn Baayen
 *  Copyright © 2003 Marco Pesenti Gritti
 *  Copyright © 2003, 2004 Christian Persch
 *  Copyright © 2009 Igalia S.L., Author: Xan Lopez <xlopez@igalia.com>
 *  Copyright © 2009 Holger Hans Peter Freyther
 *
 *  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 2, 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 "config.h"

#include "pdm-dialog.h"
#include "ephy-shell.h"
#include "ephy-file-helpers.h"
#include "ephy-gui.h"
#include "ephy-state.h"
#include "ephy-string.h"
#include "ephy-stock-icons.h"
#include "ephy-debug.h"
#include "ephy-time-helpers.h"
#include "ephy-embed-single.h"
#include "ephy-favicon-cache.h"
#include "ephy-history.h"
#include "ephy-password-info.h"

#include <gtk/gtk.h>
#include <glib/gi18n.h>
#include <libsoup/soup.h>
#include <webkit/webkit.h>
#include <gnome-keyring.h>
#include <gnome-keyring-memory.h>

#include <string.h>
#include <time.h>

typedef struct PdmActionInfo PdmActionInfo;

struct PdmActionInfo
{
    /* Methods */
    void (* construct)  (PdmActionInfo *info);
    void (* destruct)   (PdmActionInfo *info);
    void (* fill)       (PdmActionInfo *info);
    void (* add)        (PdmActionInfo *info,
                         gpointer data);
    gboolean (* remove) (PdmActionInfo *info,
                         gpointer data);
    void (* scroll_to)  (PdmActionInfo *info);

    /* Data */
    PdmDialog *dialog;
    GtkTreeView *treeview;
    GtkTreeSelection *selection;
    GtkTreeModel *model;
    int remove_id;
    int data_col;
    char *scroll_to_host;
    gboolean filled;
};

#define EPHY_PDM_DIALOG_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EPHY_TYPE_PDM_DIALOG, PdmDialogPrivate))

struct PdmDialogPrivate
{
    GtkWidget *notebook;
    GtkTreeModel *model;
    PdmActionInfo *cookies;
    PdmActionInfo *passwords;
};

enum
{
    COL_COOKIES_HOST,
    COL_COOKIES_HOST_KEY,
    COL_COOKIES_NAME,
    COL_COOKIES_DATA,
};

enum
{
    TV_COL_COOKIES_HOST,
    TV_COL_COOKIES_NAME
};

enum
{
    COL_PASSWORDS_HOST,
    COL_PASSWORDS_USER,
    COL_PASSWORDS_PASS,
    COL_PASSWORDS_DATA,
    PASSWORDS_NUM_COL
};

enum
{
    PROP_WINDOW,
    PROP_NOTEBOOK,
    PROP_COOKIES_TREEVIEW,
    PROP_COOKIES_REMOVE,
    PROP_COOKIES_PROPERTIES,
    PROP_PASSWORDS_TREEVIEW,
    PROP_PASSWORDS_REMOVE,
    PROP_PASSWORDS_SHOW
};

enum
{
    PDM_DIALOG_RESPONSE_CLEAR = 1
};

static const
EphyDialogProperty properties [] =
{
    { "pdm_dialog",         NULL, PT_NORMAL, 0 },
    { "pdm_notebook",       NULL, PT_NORMAL, 0 },

    { "cookies_treeview",       NULL, PT_NORMAL, 0 },
    { "cookies_remove_button",  NULL, PT_NORMAL, 0 },
    { "cookies_properties_button",  NULL, PT_NORMAL, 0 },
    { "passwords_treeview",     NULL, PT_NORMAL, 0 },
    { "passwords_remove_button",    NULL, PT_NORMAL, 0 },
    { "passwords_show_button",  NULL, PT_NORMAL, 0 },

    { NULL }
};

static void pdm_dialog_class_init   (PdmDialogClass *klass);
static void pdm_dialog_init     (PdmDialog *dialog);
static void pdm_dialog_finalize     (GObject *object);
static gboolean pdm_dialog_password_remove (PdmActionInfo *info, gpointer data);

G_DEFINE_TYPE (PdmDialog, pdm_dialog, EPHY_TYPE_DIALOG)

static void
pdm_dialog_class_init (PdmDialogClass *klass)
{
    GObjectClass *object_class = G_OBJECT_CLASS (klass);

    object_class->finalize = pdm_dialog_finalize;

    g_type_class_add_private (object_class, sizeof(PdmDialogPrivate));
}

static void
pdm_dialog_show_help (PdmDialog *pd)
{
    GtkWidget *notebook, *window;
    int id;

    static char * const help_preferences[] = {
        "managing-cookies",
        "managing-passwords"
    };

    ephy_dialog_get_controls
        (EPHY_DIALOG (pd),
         properties[PROP_WINDOW].id, &window,
         properties[PROP_NOTEBOOK].id, &notebook,
         NULL);

    id = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook));
    g_return_if_fail (id == 0 || id == 1);

    ephy_gui_help (GTK_WINDOW (window), "epiphany", help_preferences[id]);
}

typedef struct
{
    EphyDialog *dialog;
    GtkWidget *checkbutton_history;
    GtkWidget *checkbutton_cookies;
    GtkWidget *checkbutton_passwords;
    GtkWidget *checkbutton_cache;
    guint num_checked;
} PdmClearAllDialogButtons;

static SoupCookieJar*
get_cookie_jar ()
{
    SoupSession* session;

    session = webkit_get_default_session ();
    return (SoupCookieJar*)soup_session_get_feature (session, SOUP_TYPE_COOKIE_JAR);
}

static void
clear_all_dialog_release_cb (PdmClearAllDialogButtons *data)
{
    g_slice_free (PdmClearAllDialogButtons, data);
}

static void
clear_all_cookies (SoupCookieJar *jar)
{
    GSList *l, *p;

    l = soup_cookie_jar_all_cookies (jar);
    for (p = l; p; p = p->next)
        soup_cookie_jar_delete_cookie (jar, (SoupCookie*)p->data);

    soup_cookies_free (l);
}

static void
clear_all_dialog_response_cb (GtkDialog *dialog,
        int response,
        PdmClearAllDialogButtons *checkbuttons)
{
    if (response == GTK_RESPONSE_HELP)
    {
        /* Show help and return early */

        ephy_gui_help (GTK_WINDOW (dialog), "epiphany", "clearing-personal-data");
        return;
    }

    if (response == GTK_RESPONSE_OK)
    {
        if (gtk_toggle_button_get_active 
                (GTK_TOGGLE_BUTTON (checkbuttons->checkbutton_history)))
        {
            EphyEmbedShell *shell;
            EphyHistory *history;

            shell = ephy_embed_shell_get_default ();
            history = EPHY_HISTORY (ephy_embed_shell_get_global_history (shell));
            ephy_history_clear (history);
        }
        if (gtk_toggle_button_get_active
                (GTK_TOGGLE_BUTTON (checkbuttons->checkbutton_cookies)))
        {
            SoupCookieJar *jar;

            jar = get_cookie_jar ();

            clear_all_cookies (jar);
        }
        if (gtk_toggle_button_get_active
                (GTK_TOGGLE_BUTTON (checkbuttons->checkbutton_passwords)))
        {
            PdmDialog *pdialog = EPHY_PDM_DIALOG (checkbuttons->dialog);
            PdmActionInfo *pinfo = pdialog->priv->passwords;
            GtkTreeModel *model = pinfo->model;
            GtkTreeIter iter;
            gboolean valid;

            valid = gtk_tree_model_get_iter_first (model, &iter);

            while (valid) {
                GValue val = { 0, };
                gboolean result;

                gtk_tree_model_get_value (model, &iter,
                        COL_PASSWORDS_DATA, &val);
                result = pdm_dialog_password_remove(pinfo,
                        g_value_get_boxed (&val));
                g_value_unset (&val);

                if (result)
                    valid = gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
                else
                    valid = gtk_tree_model_iter_next (model, &iter);
            }
        }
        if (gtk_toggle_button_get_active
                (GTK_TOGGLE_BUTTON (checkbuttons->checkbutton_cache)))
        {
            EphyEmbedShell *shell;
            EphyEmbedSingle *single;
            EphyFaviconCache *cache;

            shell = ephy_embed_shell_get_default ();

            single = EPHY_EMBED_SINGLE (ephy_embed_shell_get_embed_single (shell));

            ephy_embed_single_clear_cache (single);

            cache = EPHY_FAVICON_CACHE (ephy_embed_shell_get_favicon_cache (shell));
            ephy_favicon_cache_clear (cache);
        }
    }
    gtk_widget_destroy (GTK_WIDGET (dialog));
}

static void
clear_all_dialog_checkbutton_toggled_cb (GtkToggleButton *toggle,
        PdmClearAllDialogButtons *data)
{
    GtkWidget *dialog;
    dialog = gtk_widget_get_toplevel (GTK_WIDGET (toggle));

    if (gtk_toggle_button_get_active (toggle) == TRUE)
    {
        data->num_checked++;
    }
    else
    {
        data->num_checked--;
    }
    gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK,
            data->num_checked != 0);
}

void
pdm_dialog_show_clear_all_dialog (EphyDialog *edialog,
        GtkWidget *parent,
        PdmClearAllDialogFlags flags)
{
    GtkWidget *dialog, *vbox;
    GtkWidget *check, *label;
    PdmClearAllDialogButtons *checkbuttons;
    GtkWidget *button, *icon;

    dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (parent),
            GTK_DIALOG_DESTROY_WITH_PARENT |
            GTK_DIALOG_MODAL,
            GTK_MESSAGE_QUESTION,
            GTK_BUTTONS_NONE,
            _("<b>Select the personal data "
                "you want to clear</b>"));
    gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
            _("You are about to clear personal data "
                "that is stored about the web pages "
                "you have visited. Before proceeding, "
                "check the types of information that you "
                "want to remove:"));
    gtk_window_set_title (GTK_WINDOW (dialog), _("Clear All Personal Data"));

    gtk_dialog_add_buttons (GTK_DIALOG (dialog),
            GTK_STOCK_HELP,
            GTK_RESPONSE_HELP,
            GTK_STOCK_CANCEL,
            GTK_RESPONSE_CANCEL,
            NULL);

    /* Clear button */
    button = gtk_dialog_add_button (GTK_DIALOG (dialog),
            _("Cl_ear"),
            GTK_RESPONSE_OK);
    icon = gtk_image_new_from_stock (GTK_STOCK_CLEAR, GTK_ICON_SIZE_BUTTON);
    gtk_button_set_image (GTK_BUTTON (button), icon);
    gtk_widget_show (button);

    gtk_dialog_set_default_response (GTK_DIALOG (dialog),
            GTK_RESPONSE_CANCEL);
    gtk_label_set_selectable (GTK_LABEL (GTK_MESSAGE_DIALOG (dialog)->label),
            FALSE);

    vbox = gtk_vbox_new (FALSE, 6);
    gtk_box_pack_start (GTK_BOX (GTK_MESSAGE_DIALOG (dialog)->label->parent),
            vbox, FALSE, FALSE, 0);

    checkbuttons = g_slice_new0 (PdmClearAllDialogButtons);
    checkbuttons->dialog = edialog;
    checkbuttons->num_checked = 0;

    /* Cookies */
    check = gtk_check_button_new_with_mnemonic (_("C_ookies"));
    checkbuttons->checkbutton_cookies = check;
    gtk_box_pack_start (GTK_BOX (vbox), check,
            FALSE, FALSE, 0);
    g_signal_connect (check, "toggled",
            G_CALLBACK (clear_all_dialog_checkbutton_toggled_cb), checkbuttons);
    if (flags & CLEAR_ALL_COOKIES)
    {
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
    }

    /* Passwords */
    check = gtk_check_button_new_with_mnemonic (_("Saved _passwords"));
    checkbuttons->checkbutton_passwords = check;
    gtk_box_pack_start (GTK_BOX (vbox), check,
            FALSE, FALSE, 0);
    g_signal_connect (check, "toggled",
            G_CALLBACK (clear_all_dialog_checkbutton_toggled_cb), checkbuttons);
    if (flags & CLEAR_ALL_PASSWORDS)
    {
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
    }

    /* History */
    check = gtk_check_button_new_with_mnemonic (_("Hi_story"));
    checkbuttons->checkbutton_history = check;
    gtk_box_pack_start (GTK_BOX (vbox), check,
            FALSE, FALSE, 0);
    g_signal_connect (check, "toggled",
            G_CALLBACK (clear_all_dialog_checkbutton_toggled_cb), checkbuttons);
    if (flags & CLEAR_ALL_HISTORY)
    {
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
    }

    /* Cache */
    check = gtk_check_button_new_with_mnemonic (_("_Temporary files"));
    checkbuttons->checkbutton_cache = check;
    gtk_box_pack_start (GTK_BOX (vbox), check,
            FALSE, FALSE, 0);
    g_signal_connect (check, "toggled",
            G_CALLBACK (clear_all_dialog_checkbutton_toggled_cb), checkbuttons);
    if (flags & CLEAR_ALL_CACHE)
    {
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
    }

    /* Show vbox and all checkbuttons */
    gtk_widget_show_all (vbox);

    label = gtk_label_new (NULL);
    gtk_label_set_markup (GTK_LABEL (label),
            _("<small><i><b>Note:</b> You cannot undo this action. "
                "The data you are choosing to clear "
                "will be deleted forever.</i></small>"));
    gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
            label, FALSE, FALSE, 0);
    /* Need to do this or the label will wrap too early */
    gtk_widget_set_size_request (label, 330, -1);
    gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
    gtk_misc_set_alignment (GTK_MISC (label),
            0, 0);
    gtk_misc_set_padding (GTK_MISC (label),
            6, 0);
    gtk_widget_show (label);

    gtk_window_present (GTK_WINDOW (dialog));
    g_signal_connect_data (dialog, "response",
            G_CALLBACK (clear_all_dialog_response_cb),
            checkbuttons, (GClosureNotify) clear_all_dialog_release_cb,
            (GConnectFlags) 0);
}

static void
action_treeview_selection_changed_cb (GtkTreeSelection *selection,
        PdmActionInfo *action)
{
    GtkWidget *widget;
    EphyDialog *d = EPHY_DIALOG(action->dialog);
    gboolean has_selection;

    has_selection = gtk_tree_selection_count_selected_rows (selection) > 0;

    widget = ephy_dialog_get_control (d, properties[action->remove_id].id);
    gtk_widget_set_sensitive (widget, has_selection);

}

static void
pdm_cmd_delete_selection (PdmActionInfo *action)
{

    GList *llist, *rlist = NULL, *l, *r;
    GtkTreeModel *model;
    GtkTreeSelection *selection;
    GtkTreePath *path;
    GtkTreeIter iter, iter2;
    GtkTreeRowReference *row_ref = NULL;

    selection = gtk_tree_view_get_selection
        (GTK_TREE_VIEW(action->treeview));
    llist = gtk_tree_selection_get_selected_rows (selection, &model);

    if (llist == NULL)
    {
        /* nothing to delete, return early */
        return;
    }

    for (l = llist;l != NULL; l = l->next)
    {
        rlist = g_list_prepend (rlist, gtk_tree_row_reference_new
                    (model, (GtkTreePath *)l->data));
    }

    /* Intelligent selection logic, no actual selection yet */

    path = gtk_tree_row_reference_get_path
        ((GtkTreeRowReference *) g_list_first (rlist)->data);

    gtk_tree_model_get_iter (model, &iter, path);
    gtk_tree_path_free (path);
    iter2 = iter;

    if (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter))
    {
        path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
        row_ref = gtk_tree_row_reference_new (model, path);
    }
    else
    {
        path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter2);
        if (gtk_tree_path_prev (path))
        {
            row_ref = gtk_tree_row_reference_new (model, path);
        }
    }
    gtk_tree_path_free (path);

    /* Removal */

    for (r = rlist; r != NULL; r = r->next)
    {
        GValue val = { 0, };
        gboolean remove;

        path = gtk_tree_row_reference_get_path
            ((GtkTreeRowReference *)r->data);

        gtk_tree_model_get_iter (model, &iter, path);
        gtk_tree_model_get_value (model, &iter, action->data_col, &val);
        remove = action->remove (action, g_value_get_boxed (&val));
        g_value_unset (&val);

        /*
         * Remove the item:
         * cookies are deleted using callback, passwords right here
         */
        if (remove)
            gtk_list_store_remove (GTK_LIST_STORE (model), &iter);

        gtk_tree_row_reference_free ((GtkTreeRowReference *)r->data);
        gtk_tree_path_free (path);
    }

    g_list_foreach (llist, (GFunc)gtk_tree_path_free, NULL);
    g_list_free (llist);
    g_list_free (rlist);

    /* Selection */
    if (row_ref != NULL)
    {
        path = gtk_tree_row_reference_get_path (row_ref);

        if (path != NULL)
        {
            gtk_tree_view_set_cursor (GTK_TREE_VIEW (action->treeview), path, NULL, FALSE);
            gtk_tree_path_free (path);
        }

        gtk_tree_row_reference_free (row_ref);
    }
}

static gboolean
pdm_key_pressed_cb (GtkTreeView *treeview,
            GdkEventKey *event,
            PdmActionInfo *action)
{
    if (event->keyval == GDK_Delete || event->keyval == GDK_KP_Delete)
    {
        pdm_cmd_delete_selection (action);

        return TRUE;
    }

    return FALSE;
}

static void
pdm_dialog_remove_button_clicked_cb (GtkWidget *button,
                     PdmActionInfo *action)
{
    pdm_cmd_delete_selection (action);

    /* Restore the focus to the button */
    gtk_widget_grab_focus (button);
}

static void
setup_action (PdmActionInfo *action)
{
    GtkWidget *widget;
    GtkTreeSelection *selection;

    widget = ephy_dialog_get_control (EPHY_DIALOG(action->dialog),
                      properties[action->remove_id].id);
    g_signal_connect (widget, "clicked",
              G_CALLBACK (pdm_dialog_remove_button_clicked_cb),
              action);

    selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(action->treeview));
    g_signal_connect (selection, "changed",
              G_CALLBACK (action_treeview_selection_changed_cb),
              action);

    g_signal_connect (G_OBJECT (action->treeview),
              "key_press_event",
              G_CALLBACK (pdm_key_pressed_cb),
              action);
}

/* "Cookies" tab */

static void
show_cookies_properties (PdmDialog *dialog,
             SoupCookie *info)
{
    GtkWidget *gdialog;
    GtkWidget *table;
    GtkWidget *label;
    GtkWidget *parent;
    GtkWidget *dialog_vbox;
    char *str;

    parent = ephy_dialog_get_control (EPHY_DIALOG(dialog),
                      properties[PROP_WINDOW].id);

    gdialog = gtk_dialog_new_with_buttons
         (_("Cookie Properties"),
          GTK_WINDOW (parent),
          GTK_DIALOG_DESTROY_WITH_PARENT,
          GTK_STOCK_CLOSE, 0, NULL);
    ephy_state_add_window (GTK_WIDGET (gdialog), "cookie_properties",
                   -1, -1, FALSE,
                   EPHY_STATE_WINDOW_SAVE_SIZE | EPHY_STATE_WINDOW_SAVE_POSITION);
    gtk_dialog_set_has_separator (GTK_DIALOG(gdialog), FALSE);
    gtk_container_set_border_width (GTK_CONTAINER (gdialog), 5);
    gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (gdialog)->vbox), 14); /* 24 = 2 * 5 + 14 */

    table = gtk_table_new (2, 4, FALSE);
    gtk_container_set_border_width (GTK_CONTAINER (table), 5);
    gtk_table_set_row_spacings (GTK_TABLE (table), 6);
    gtk_table_set_col_spacings (GTK_TABLE (table), 12);
    gtk_widget_show (table);

    str = g_strconcat ("<b>", _("Content:"), "</b>", NULL);
    label = gtk_label_new (str);
    g_free (str);
    gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
              GTK_FILL, GTK_FILL, 0, 0);

    label = gtk_label_new (info->value);
    gtk_label_set_selectable (GTK_LABEL (label), TRUE);
    gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
    gtk_widget_show (label);
    gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, 0, 1);

    str = g_strconcat ("<b>", _("Path:"), "</b>", NULL);
    label = gtk_label_new (str);
    g_free (str);
    gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
              GTK_FILL, GTK_FILL, 0, 0);

    label = gtk_label_new (info->path);
    gtk_label_set_selectable (GTK_LABEL (label), TRUE);
    gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
    gtk_widget_show (label);
    gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, 1, 2);

    str = g_strconcat ("<b>", _("Send for:"), "</b>", NULL);
    label = gtk_label_new (str);
    g_free (str);
    gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
              GTK_FILL, GTK_FILL, 0, 0);

    label = gtk_label_new (info->secure ? _("Encrypted connections only") : _("Any type of connection") );
    gtk_label_set_selectable (GTK_LABEL (label), TRUE);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
    gtk_widget_show (label);
    gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, 2, 3);

    str = g_strconcat ("<b>", _("Expires:"), "</b>", NULL);
    label = gtk_label_new (str);
    g_free (str);
    gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
    gtk_widget_show (label);
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4,
              GTK_FILL, GTK_FILL, 0, 0);

    if (info->expires == NULL)
    {
        /* Session cookie */
        str = g_strdup (_("End of current session"));
    }
    else
    {
        struct tm t;
        time_t out = soup_date_to_time_t(info->expires);
        str = eel_strdup_strftime ("%c", localtime_r (&out, &t));
    }
    label = gtk_label_new (str);
    g_free (str);
    gtk_label_set_selectable (GTK_LABEL (label), TRUE);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
    gtk_widget_show (label);
    gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, 3, 4);

    dialog_vbox = GTK_DIALOG(gdialog)->vbox;
    gtk_box_pack_start (GTK_BOX(dialog_vbox),
                table,
                FALSE, FALSE, 0);

    gtk_window_group_add_window (ephy_gui_ensure_window_group (GTK_WINDOW (parent)),
                     GTK_WINDOW (gdialog));

    gtk_dialog_run (GTK_DIALOG (gdialog));

    gtk_widget_destroy (gdialog);
}

static void
cookies_properties_clicked_cb (GtkWidget *button,
                   PdmDialog *dialog)
{
    GtkTreeModel *model;
    GValue val = {0, };
    GtkTreeIter iter;
    GtkTreePath *path;
    SoupCookie *cookie;
    GList *l;
    GtkTreeSelection *selection;

    selection = gtk_tree_view_get_selection (dialog->priv->cookies->treeview);
    l = gtk_tree_selection_get_selected_rows
        (selection, &model);

    path = (GtkTreePath *)l->data;
    gtk_tree_model_get_iter (model, &iter, path);
    gtk_tree_model_get_value
        (model, &iter, COL_COOKIES_DATA, &val);
    cookie = (SoupCookie *) g_value_get_boxed (&val);

    show_cookies_properties (dialog, cookie);

    g_value_unset (&val);

    g_list_foreach (l, (GFunc)gtk_tree_path_free, NULL);
    g_list_free (l);
}

static void
cookies_treeview_selection_changed_cb (GtkTreeSelection *selection,
                       PdmDialog *dialog)
{
    GtkWidget *widget;
    EphyDialog *d = EPHY_DIALOG(dialog);
    gboolean has_selection;

    has_selection = gtk_tree_selection_count_selected_rows (selection) == 1;

    widget = ephy_dialog_get_control (d, properties[PROP_COOKIES_PROPERTIES].id);
    gtk_widget_set_sensitive (widget, has_selection);
}

static gboolean
cookie_search_equal (GtkTreeModel *model,
             int column,
             const gchar *key,
             GtkTreeIter *iter,
             gpointer search_data)
{
    GValue value = { 0, };
    gboolean retval;

    /* Note that this is function has to return FALSE for a *match* ! */

    gtk_tree_model_get_value (model, iter, column, &value);
    retval = strstr (g_value_get_string (&value), key) == NULL;
    g_value_unset (&value);

    return retval;
}

static void
pdm_dialog_cookies_construct (PdmActionInfo *info)
{
    PdmDialog *dialog = info->dialog;
    GtkTreeView *treeview;
    GtkListStore *liststore;
    GtkCellRenderer *renderer;
    GtkTreeViewColumn *column;
    GtkTreeSelection *selection;
    GtkWidget *button;

    LOG ("pdm_dialog_cookies_construct");

    ephy_dialog_get_controls (EPHY_DIALOG (dialog),
                  properties[PROP_COOKIES_TREEVIEW].id, &treeview,
                  properties[PROP_COOKIES_PROPERTIES].id, &button,
                  NULL);

    g_signal_connect (button, "clicked",
              G_CALLBACK (cookies_properties_clicked_cb), dialog);

    /* set tree model */
    liststore = gtk_list_store_new (4,
                    G_TYPE_STRING,
                    G_TYPE_STRING,
                    G_TYPE_STRING,
                    SOUP_TYPE_COOKIE);
    gtk_tree_view_set_model (treeview, GTK_TREE_MODEL(liststore));
    gtk_tree_view_set_headers_visible (treeview, TRUE);
    selection = gtk_tree_view_get_selection (treeview);
    gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);

    info->model = GTK_TREE_MODEL (liststore);
    g_object_unref (liststore);

    g_signal_connect (selection, "changed",
              G_CALLBACK(cookies_treeview_selection_changed_cb),
              dialog);

    renderer = gtk_cell_renderer_text_new ();

    gtk_tree_view_insert_column_with_attributes (treeview,
                             TV_COL_COOKIES_HOST,
                             _("Domain"),
                             renderer,
                             "text", COL_COOKIES_HOST,
                             NULL);
    column = gtk_tree_view_get_column (treeview, TV_COL_COOKIES_HOST);
    gtk_tree_view_column_set_resizable (column, TRUE);
    gtk_tree_view_column_set_reorderable (column, TRUE);
    gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
    gtk_tree_view_column_set_sort_column_id (column, COL_COOKIES_HOST_KEY);

    gtk_tree_view_insert_column_with_attributes (treeview,
                             TV_COL_COOKIES_NAME,
                             _("Name"),
                             renderer,
                             "text", COL_COOKIES_NAME,
                             NULL);
    column = gtk_tree_view_get_column (treeview, TV_COL_COOKIES_NAME);
    gtk_tree_view_column_set_resizable (column, TRUE);
    gtk_tree_view_column_set_reorderable (column, TRUE);
    gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
    gtk_tree_view_column_set_sort_column_id (column, COL_COOKIES_NAME);

    gtk_tree_view_set_enable_search (treeview, TRUE);
    gtk_tree_view_set_search_column (treeview, COL_COOKIES_HOST);
    gtk_tree_view_set_search_equal_func (treeview,
                         (GtkTreeViewSearchEqualFunc) cookie_search_equal,
                         dialog, NULL);

    info->treeview = treeview;
    info->selection = selection;

    setup_action (info);
}

static gboolean
cookie_to_iter (GtkTreeModel *model,
        const SoupCookie *cookie,
        GtkTreeIter *iter)
{
    gboolean valid;
    gboolean found = FALSE;

    valid = gtk_tree_model_get_iter_first (model, iter);

    while (valid)
    {
        SoupCookie *data;

        gtk_tree_model_get (model, iter,
                    COL_COOKIES_DATA, &data,
                    -1);

        found = soup_cookie_equal ((SoupCookie*)cookie, data);

        soup_cookie_free (data);

        if (found) break;

        valid = gtk_tree_model_iter_next (model, iter);
    }

    return found;
}

static void
cookie_changed_cb (SoupCookieJar *jar,
           const SoupCookie *old_cookie,
           const SoupCookie *new_cookie,
           PdmDialog *dialog)
{
    PdmActionInfo *info;
    GtkTreeIter iter;

    g_return_if_fail (EPHY_IS_PDM_DIALOG (dialog));
    info = dialog->priv->cookies;

    LOG ("cookie_changed_cb");

    g_return_if_fail (info);

    if (old_cookie)
    {
        /* Cookie changed or deleted, let's get rid of the old one
           in any case */
        if (cookie_to_iter (info->model, old_cookie, &iter))
        {
            gtk_list_store_remove (GTK_LIST_STORE (info->model), &iter);
        }
        else
        {
            g_warning ("Unable to find changed cookie in list!\n");
        }
    }

    if (new_cookie)
    {
        /* Cookie changed or added, let's add the new cookie in
           any case */
        info->add (info, (gpointer) soup_cookie_copy ((SoupCookie*)new_cookie));
    }
}

static gboolean
cookie_host_to_iter (GtkTreeModel *model,
             const char *key1,
             GtkTreeIter *iter)
{
    GtkTreeIter iter2;
    gboolean valid;
    gssize len;
    int max = 0;

    len = strlen (key1);

    valid = gtk_tree_model_get_iter_first (model, &iter2);

    while (valid)
    {
        const char *p, *q;
        char *key2;
        int n = 0;

        gtk_tree_model_get (model, &iter2, COL_COOKIES_HOST, &key2, -1);

        /* Count the segments (string between successive dots)
         * that key1 and key2 share.
         */

        /* Start on the \0 */
        p = key1 + len;
        q = key2 + strlen (key2);

        do
        {
            if (*p == '.') ++n;
            --p;
            --q;
        }
        while (p >= key1 && q >= key2 && *p == *q);

        if ((p < key1 && q < key2 && *key1 != '.' && *key2 != '.') ||
            (p < key1 && q >= key2 && *q == '.') ||
            (q < key2 && p >= key1 && *p == '.'))
        {
            ++n;
        }

        g_free (key2);

        /* Complete match */
        if (p < key1 && q < key2)
        {
            *iter = iter2;
            return TRUE;
        }

        if (n > max)
        {
            max = n;
            *iter = iter2;
        }

        valid = gtk_tree_model_iter_next (model, &iter2);
    }

    return max > 0;
}

static int
compare_cookie_host_keys (GtkTreeModel *model,
              GtkTreeIter  *a,
              GtkTreeIter  *b,
              gpointer user_data)
{
    GValue a_value = {0, };
    GValue b_value = {0, };
    int retval;

    gtk_tree_model_get_value (model, a, COL_COOKIES_HOST_KEY, &a_value);
    gtk_tree_model_get_value (model, b, COL_COOKIES_HOST_KEY, &b_value);

    retval = strcmp (g_value_get_string (&a_value),
             g_value_get_string (&b_value));

    g_value_unset (&a_value);
    g_value_unset (&b_value);

    return retval;
}

static void
pdm_dialog_fill_cookies_list (PdmActionInfo *info)
{
    SoupCookieJar *jar;
    GSList *list, *l;

    g_assert (info->filled == FALSE);

    jar = get_cookie_jar ();
    list = soup_cookie_jar_all_cookies (jar);

    for (l = list; l != NULL; l = l->next)
    {
        info->add (info, l->data);
    }

    /* the element data has been consumed, so we need only to free the list */
    g_slist_free (list);

    /* Now turn on sorting */
    gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (info->model),
                     COL_COOKIES_HOST_KEY,
                     (GtkTreeIterCompareFunc) compare_cookie_host_keys,
                     NULL, NULL);
    gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (info->model),
                          COL_COOKIES_HOST_KEY,
                          GTK_SORT_ASCENDING);

    info->filled = TRUE;

    g_signal_connect (jar, "changed",
              G_CALLBACK (cookie_changed_cb), info->dialog);

    info->scroll_to (info);
}

static void
pdm_dialog_cookies_destruct (PdmActionInfo *info)
{
    g_free (info->scroll_to_host);
    info->scroll_to_host = NULL;
}

static void
pdm_dialog_cookie_add (PdmActionInfo *info,
               gpointer data)
{
    SoupCookie *cookie = (SoupCookie *) data;
    GtkListStore *store;
    GtkTreeIter iter;
    int column[4] = { COL_COOKIES_HOST, COL_COOKIES_HOST_KEY, COL_COOKIES_NAME, COL_COOKIES_DATA };
    GValue value[4] = { { 0, }, { 0, }, { 0, }, { 0, } };

    store = GTK_LIST_STORE(info->model);

    /* NOTE: We use this strange method to insert the row, because
     * we want to use g_value_take_string but all the row data needs to
     * be inserted in one call as it's needed when the new row is sorted
     * into the model.
     */

    g_value_init (&value[0], G_TYPE_STRING);
    g_value_init (&value[1], G_TYPE_STRING);
    g_value_init (&value[2], G_TYPE_STRING);
    g_value_init (&value[3], SOUP_TYPE_COOKIE);

    g_value_set_static_string (&value[0], cookie->domain);
    g_value_take_string (&value[1], ephy_string_collate_key_for_domain (cookie->domain, -1));
    g_value_set_static_string (&value[2], cookie->name);
    g_value_take_boxed (&value[3], cookie);

    gtk_list_store_insert_with_valuesv (store, &iter, -1,
                        column, value,
                        G_N_ELEMENTS (value));

    g_value_unset (&value[0]);
    g_value_unset (&value[1]);
    g_value_unset (&value[2]);
    g_value_unset (&value[3]);
}

static gboolean
pdm_dialog_cookie_remove (PdmActionInfo *info,
              gpointer data)
{
    SoupCookie *cookie = (SoupCookie *) data;
    SoupCookieJar *jar;

    jar = get_cookie_jar();

    soup_cookie_jar_delete_cookie (jar, cookie);
    return FALSE;
}

static void
pdm_dialog_cookie_scroll_to (PdmActionInfo *info)
{
    GtkTreeIter iter;
    GtkTreePath *path;

    if (info->scroll_to_host == NULL || !info->filled) return;

    if (cookie_host_to_iter (info->model, info->scroll_to_host, &iter))
    {
        gtk_tree_selection_unselect_all (info->selection);

        path = gtk_tree_model_get_path (info->model, &iter);
        gtk_tree_view_scroll_to_cell (info->treeview,
                          path, NULL, TRUE,
                          0.5, 0.0);
        gtk_tree_path_free (path);
    }

    g_free (info->scroll_to_host);
    info->scroll_to_host = NULL;
}

/* "Passwords" tab */
static void
passwords_data_func (GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,
            GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
{
   EphyPasswordInfo *info;
   GValue val = { 0, };

   if (!gtk_tree_view_column_get_visible (tree_column))
       return;

   gtk_tree_model_get_value (model, iter, COL_PASSWORDS_DATA, &val);
   info = g_value_get_boxed (&val);

   /* get the password and store it */
   if (info->secret == NULL) {
       GnomeKeyringResult result;
       GnomeKeyringItemInfo *kinfo;
       result = gnome_keyring_item_get_info_full_sync (GNOME_KEYRING_DEFAULT,
                           info->keyring_id,
                           GNOME_KEYRING_ITEM_INFO_SECRET,
                           &kinfo);

       /* FIXME: get_secret makes insecure copy... */
       if (result == GNOME_KEYRING_RESULT_OK) {
           info->secret = gnome_keyring_memory_strdup (
                       gnome_keyring_item_info_get_secret (kinfo));
           gnome_keyring_item_info_free (kinfo);
       }

       /* eek, this will do a strdup in GtkCellRendererText... */
       g_object_set (cell, "text", info->secret, NULL);
       g_value_unset(&val);
   }
}

static void
passwords_show_toggled_cb (GtkWidget *button,
               PdmDialog *dialog)
{
    GtkTreeView *treeview;
    GtkTreeViewColumn *column;
    gboolean active;

    treeview = GTK_TREE_VIEW (ephy_dialog_get_control
            (EPHY_DIALOG(dialog), properties[PROP_PASSWORDS_TREEVIEW].id));
    column = gtk_tree_view_get_column (treeview, COL_PASSWORDS_PASS);

    active = gtk_toggle_button_get_active ((GTK_TOGGLE_BUTTON (button)));

    gtk_tree_view_column_set_visible (column, active);
}

static void
pdm_dialog_passwords_construct (PdmActionInfo *info)
{
    PdmDialog *dialog = info->dialog;
    GtkTreeView *treeview;
    GtkListStore *liststore;
    GtkCellRenderer *renderer;
    GtkTreeViewColumn *column;
    GtkTreeSelection *selection;
    GtkWidget *button;

    LOG ("pdm_dialog_passwords_construct");

    ephy_dialog_get_controls (EPHY_DIALOG (dialog),
                  properties[PROP_PASSWORDS_TREEVIEW].id, &treeview,
                  properties[PROP_PASSWORDS_SHOW].id, &button,
                  NULL);

    g_signal_connect (button, "toggled",
              G_CALLBACK (passwords_show_toggled_cb), dialog);

    /* set tree model */
    liststore = gtk_list_store_new (PASSWORDS_NUM_COL,
                    G_TYPE_STRING,
                    G_TYPE_STRING,
                    G_TYPE_STRING,
                    EPHY_TYPE_PASSWORD_INFO);

    gtk_tree_view_set_model (treeview, GTK_TREE_MODEL(liststore));
    gtk_tree_view_set_headers_visible (treeview, TRUE);
    selection = gtk_tree_view_get_selection (treeview);
    gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);

    info->model = GTK_TREE_MODEL (liststore);
    g_object_unref (liststore);

    renderer = gtk_cell_renderer_text_new ();

    gtk_tree_view_insert_column_with_attributes (treeview,
                            COL_PASSWORDS_HOST,
                            _("Host"),
                            renderer,
                            "text", COL_PASSWORDS_HOST,
                            NULL);
    column = gtk_tree_view_get_column (treeview, COL_PASSWORDS_HOST);
    gtk_tree_view_column_set_resizable (column, TRUE);
    gtk_tree_view_column_set_reorderable (column, TRUE);
    gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
    gtk_tree_view_column_set_sort_column_id (column, COL_PASSWORDS_HOST);

    renderer = gtk_cell_renderer_text_new ();
    gtk_tree_view_insert_column_with_attributes (treeview,
                             COL_PASSWORDS_USER,
                             _("User Name"),
                             renderer,
                             "text", COL_PASSWORDS_USER,
                             NULL);
    column = gtk_tree_view_get_column (treeview, COL_PASSWORDS_USER);
    gtk_tree_view_column_set_resizable (column, TRUE);
    gtk_tree_view_column_set_reorderable (column, TRUE);
    gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
    gtk_tree_view_column_set_sort_column_id (column, COL_PASSWORDS_USER);

    /* Initially shown as hidden colum */
    gtk_tree_view_insert_column_with_data_func (treeview,
                            COL_PASSWORDS_PASS,
                            _("User Password"),
                            renderer,
                            passwords_data_func,
                            info,
                            NULL);
    column = gtk_tree_view_get_column (treeview, COL_PASSWORDS_PASS);
    gtk_tree_view_column_set_visible (column, FALSE);
    gtk_tree_view_column_set_resizable (column, TRUE);
    gtk_tree_view_column_set_reorderable (column, TRUE);
    gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);

    info->treeview = treeview;
    setup_action (info);
}

static void
pdm_dialog_fill_passwords_list_async_cb (GnomeKeyringResult result,
                                         GList *list,
                                         gpointer data)
{
  GList *l;
  PdmActionInfo *info = (PdmActionInfo *)data;

  if (result != GNOME_KEYRING_RESULT_OK)
    return;

  for (l = list; l != NULL; l = l->next)
    info->add (info, l->data);

  info->filled = TRUE;
  gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (info->model),
                                        COL_PASSWORDS_HOST,
                                        GTK_SORT_ASCENDING);
}

static void
pdm_dialog_fill_passwords_list (PdmActionInfo *info)
{
  gnome_keyring_list_item_ids (GNOME_KEYRING_DEFAULT,
                               pdm_dialog_fill_passwords_list_async_cb,
                               info,
                               NULL);
}

static void
pdm_dialog_passwords_destruct (PdmActionInfo *info)
{
}

static void
pdm_dialog_password_add (PdmActionInfo *info,
             gpointer data)
{
    GnomeKeyringResult result;
    GnomeKeyringItemInfo *kinfo;
    GnomeKeyringAttribute *attribute;
    GnomeKeyringAttributeList *attributes;
    gchar *user, *host, *protocol;
    EphyPasswordInfo *pinfo;
    GtkListStore *store;
    GtkTreeIter iter;
    guint key_id = GPOINTER_TO_UINT(data);
    int i;

    /*
     * We have the item id of the password. We will have to check if this
     * password entry is of the right type and then can proceed to get the
     * the private information. Seahorse is treating every protocol that
     * starts with http as Web Access and we will do the same here.
     */

    /* Get the type of the key_id */
    result = gnome_keyring_item_get_info_full_sync (GNOME_KEYRING_DEFAULT,
                            key_id,
                            GNOME_KEYRING_ITEM_INFO_BASICS,
                            &kinfo);

    if (result != GNOME_KEYRING_RESULT_OK)
        goto out;

    if (gnome_keyring_item_info_get_type (kinfo) != GNOME_KEYRING_ITEM_NETWORK_PASSWORD)
        goto out_info_free;

    /* Get the attributes to check protocol */
    result = gnome_keyring_item_get_attributes_sync (GNOME_KEYRING_DEFAULT,
                            key_id, &attributes);
    if (result != GNOME_KEYRING_RESULT_OK)
        goto out_info_free;

    user = host = protocol = NULL;
    attribute = (GnomeKeyringAttribute *) attributes->data;
    for (i = 0; i < attributes->len; ++i) {
        if (attribute[i].type == GNOME_KEYRING_ATTRIBUTE_TYPE_STRING) {
            if (strcmp (attribute[i].name, "server") == 0)
                host = g_strdup (attribute[i].value.string);
            else if (strcmp (attribute[i].name, "user") == 0)
                user = g_strdup (attribute[i].value.string);
            else if (strcmp (attribute[i].name, "protocol") == 0)
                protocol = attribute[i].value.string;
       }
    }
    if (!protocol || strncmp("http", protocol, 4) != 0)
        goto out_attr_free;

    pinfo = ephy_password_info_new (key_id);
    if (!pinfo)
        goto out_attr_free;

    store = GTK_LIST_STORE (info->model);

    gtk_list_store_append (store, &iter);
    gtk_list_store_set (store,
                &iter,
                COL_PASSWORDS_HOST, host,
                COL_PASSWORDS_USER, user,
                COL_PASSWORDS_PASS, NULL,
                COL_PASSWORDS_DATA, pinfo,
                -1);

out_attr_free:
   gnome_keyring_attribute_list_free (attributes);
out_info_free:
   gnome_keyring_item_info_free (kinfo);
out:
   return;
}

static gboolean
pdm_dialog_password_remove (PdmActionInfo *info,
                gpointer data)
{
    EphyPasswordInfo *pinfo = (EphyPasswordInfo *) data;
    GnomeKeyringResult result;

    result = gnome_keyring_item_delete_sync (GNOME_KEYRING_DEFAULT,
                                             pinfo->keyring_id);
    return result == GNOME_KEYRING_RESULT_OK;
}

/* common routines */

static void
sync_notebook_tab (GtkWidget *notebook,
           GtkNotebookPage *page,
           int page_num,
           PdmDialog *dialog)
{
    PdmDialogPrivate *priv = dialog->priv;

    /* Lazily fill the list store */
    if (page_num == 0 && priv->cookies->filled == FALSE)
    {
        priv->cookies->fill (priv->cookies);

        priv->cookies->scroll_to (priv->cookies);
    }
    else if (page_num == 1 && priv->passwords->filled == FALSE)
    {
        priv->passwords->fill (priv->passwords);
    }
}

static void
pdm_dialog_response_cb (GtkDialog *widget,
            int response,
            PdmDialog *dialog)
{
    if (response == GTK_RESPONSE_HELP)
    {
        pdm_dialog_show_help (dialog);
        return;
    }
    if (response == PDM_DIALOG_RESPONSE_CLEAR)
    {
        int page;
        GtkWidget *parent;

        parent = ephy_dialog_get_control (EPHY_DIALOG (dialog),
                          properties[PROP_WINDOW].id);

        page = gtk_notebook_get_current_page (GTK_NOTEBOOK (dialog->priv->notebook));
        if (page == 0)
        {
            /* Cookies */
            pdm_dialog_show_clear_all_dialog (EPHY_DIALOG (dialog),
                              parent, CLEAR_ALL_COOKIES);
        }
        if (page == 1)
        {
            /* Passwords */
            pdm_dialog_show_clear_all_dialog (EPHY_DIALOG (dialog),
                              parent, CLEAR_ALL_PASSWORDS);
        }
        return;
    }

    g_object_unref (dialog);
}

static void
pdm_dialog_init (PdmDialog *dialog)
{
    PdmDialogPrivate *priv;
    PdmActionInfo *cookies, *passwords;
    GtkWidget *window;

    priv = dialog->priv = EPHY_PDM_DIALOG_GET_PRIVATE (dialog);

    ephy_dialog_construct (EPHY_DIALOG(dialog),
                   properties,
                   ephy_file ("epiphany.ui"),
                   "pdm_dialog",
                   NULL);

    ephy_dialog_get_controls (EPHY_DIALOG (dialog),
                  properties[PROP_WINDOW].id, &window,
                  properties[PROP_NOTEBOOK].id, &priv->notebook,
                  NULL);

    ephy_gui_ensure_window_group (GTK_WINDOW (window));

    gtk_window_set_icon_name (GTK_WINDOW (window), EPHY_STOCK_EPHY);

    g_signal_connect (window, "response",
              G_CALLBACK (pdm_dialog_response_cb), dialog);
    /*
     * Group all Properties and Remove buttons in the same size group to
     * avoid the little jerk you get otherwise when switching pages because
     * one set of buttons is wider than another.
     */
    ephy_dialog_set_size_group (EPHY_DIALOG (dialog),
                    properties[PROP_COOKIES_REMOVE].id,
                    properties[PROP_COOKIES_PROPERTIES].id,
                    properties[PROP_PASSWORDS_REMOVE].id,
                    NULL);

    cookies = g_new0 (PdmActionInfo, 1);
    cookies->construct = pdm_dialog_cookies_construct;
    cookies->destruct = pdm_dialog_cookies_destruct;
    cookies->fill = pdm_dialog_fill_cookies_list;
    cookies->add = pdm_dialog_cookie_add;
    cookies->remove = pdm_dialog_cookie_remove;
    cookies->scroll_to = pdm_dialog_cookie_scroll_to;
    cookies->dialog = dialog;
    cookies->remove_id = PROP_COOKIES_REMOVE;
    cookies->data_col = COL_COOKIES_DATA;
    cookies->scroll_to_host = NULL;
    cookies->filled = FALSE;

    passwords = g_new0 (PdmActionInfo, 1);
    passwords->construct = pdm_dialog_passwords_construct;
    passwords->destruct = pdm_dialog_passwords_destruct;
    passwords->fill = pdm_dialog_fill_passwords_list;
    passwords->add = pdm_dialog_password_add;
    passwords->remove = pdm_dialog_password_remove;
    passwords->dialog = dialog;
    passwords->remove_id = PROP_PASSWORDS_REMOVE;
    passwords->data_col = COL_PASSWORDS_DATA;
    passwords->scroll_to_host = NULL;
    passwords->filled = FALSE;

    priv->cookies = cookies;
    priv->passwords = passwords;

    cookies->construct (cookies);
    passwords->construct (passwords);

    sync_notebook_tab (priv->notebook, NULL, 0, dialog);
    g_signal_connect (G_OBJECT (priv->notebook), "switch_page",
              G_CALLBACK (sync_notebook_tab), dialog);
}

static void
pdm_dialog_finalize (GObject *object)
{
    PdmDialog *dialog = EPHY_PDM_DIALOG (object);
    GObject *single;

    single = ephy_embed_shell_get_embed_single (embed_shell);

    g_signal_handlers_disconnect_matched
        (single, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, object);

    g_signal_handlers_disconnect_by_func (get_cookie_jar (), cookie_changed_cb, object);

    dialog->priv->cookies->destruct (dialog->priv->cookies);
    dialog->priv->passwords->destruct (dialog->priv->passwords);

    g_free (dialog->priv->passwords);
    g_free (dialog->priv->cookies);

    G_OBJECT_CLASS (pdm_dialog_parent_class)->finalize (object);
}

void
pdm_dialog_open (PdmDialog *dialog,
         const char *host)
{
    PdmDialogPrivate *priv = dialog->priv;

    /* Switch to cookies tab */
    gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), 0);

    g_free (priv->cookies->scroll_to_host);
    priv->cookies->scroll_to_host = g_strdup (host);

    priv->cookies->scroll_to (priv->cookies);
    gtk_widget_grab_focus (GTK_WIDGET (priv->cookies->treeview));

    ephy_dialog_show (EPHY_DIALOG (dialog));
}