path: root/mail/em-vfolder-editor-rule.c

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) version 3.
 *
 * 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with the program; if not, see <http://www.gnu.org/licenses/>
 *
 *
 * Authors:
 *      Not Zed <notzed@lostzed.mmc.com.au>
 *      Jeffrey Stedfast <fejj@ximian.com>
 *
 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <string.h>

#include <gtk/gtk.h>
#include <glib/gi18n.h>

#include <shell/e-shell.h>

#include <e-util/e-util.h>
#include <e-util/e-util-private.h>

#include <libemail-engine/e-mail-folder-utils.h>

#include "em-folder-selector.h"
#include "em-folder-tree.h"
#include "em-utils.h"
#include "em-vfolder-editor-context.h"
#include "em-vfolder-editor-rule.h"

#define EM_VFOLDER_EDITOR_RULE_GET_PRIVATE(obj) \
    (G_TYPE_INSTANCE_GET_PRIVATE \
    ((obj), EM_TYPE_VFOLDER_EDITOR_RULE, EMVFolderEditorRulePrivate))

#define EM_VFOLDER_EDITOR_RULE_GET_PRIVATE(obj) \
    (G_TYPE_INSTANCE_GET_PRIVATE \
    ((obj), EM_TYPE_VFOLDER_EDITOR_RULE, EMVFolderEditorRulePrivate))

struct _EMVFolderEditorRulePrivate {
    EMailSession *session;
};

enum {
    PROP_0,
    PROP_SESSION
};

static GtkWidget *get_widget (EFilterRule *fr, ERuleContext *f);

G_DEFINE_TYPE (
    EMVFolderEditorRule,
    em_vfolder_editor_rule,
    EM_TYPE_VFOLDER_RULE)

static void
vfolder_editor_rule_set_session (EMVFolderEditorRule *rule,
                          EMailSession *session)
{
    if (session == NULL) {
        EShell *shell;
        EShellBackend *shell_backend;
        EMailBackend *backend;

        shell = e_shell_get_default ();
        shell_backend = e_shell_get_backend_by_name (shell, "mail");

        backend = E_MAIL_BACKEND (shell_backend);
        session = e_mail_backend_get_session (backend);
    }

    g_return_if_fail (E_IS_MAIL_SESSION (session));
    g_return_if_fail (rule->priv->session == NULL);

    rule->priv->session = g_object_ref (session);
}

static void
vfolder_editor_rule_set_property (GObject *object,
                           guint property_id,
                           const GValue *value,
                           GParamSpec *pspec)
{
    switch (property_id) {
        case PROP_SESSION:
            vfolder_editor_rule_set_session (
                EM_VFOLDER_EDITOR_RULE (object),
                g_value_get_object (value));
            return;
    }

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
vfolder_editor_rule_get_property (GObject *object,
                           guint property_id,
                           GValue *value,
                           GParamSpec *pspec)
{
    switch (property_id) {
        case PROP_SESSION:
            g_value_set_object (
                value,
                em_vfolder_editor_rule_get_session (
                EM_VFOLDER_EDITOR_RULE (object)));
            return;
    }

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
vfolder_editor_rule_dispose (GObject *object)
{
    EMVFolderEditorRulePrivate *priv;

    priv = EM_VFOLDER_EDITOR_RULE_GET_PRIVATE (object);
    if (priv->session != NULL) {
        g_object_unref (priv->session);
        priv->session = NULL;
    }

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

static void
vfolder_editor_rule_finalize (GObject *object)
{
    /* EMVFolderEditorRule *rule = EM_VFOLDER_EDITOR_RULE (object); */

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

static void
em_vfolder_editor_rule_class_init (EMVFolderEditorRuleClass *class)
{
    GObjectClass *object_class;
    EFilterRuleClass *filter_rule_class;

    g_type_class_add_private (class, sizeof (EMVFolderEditorRulePrivate));

    object_class = G_OBJECT_CLASS (class);
    object_class->set_property = vfolder_editor_rule_set_property;
    object_class->get_property = vfolder_editor_rule_get_property;
    object_class->dispose = vfolder_editor_rule_dispose;
    object_class->finalize = vfolder_editor_rule_finalize;

    filter_rule_class = E_FILTER_RULE_CLASS (class);
    filter_rule_class->get_widget = get_widget;

    g_object_class_install_property (
        object_class,
        PROP_SESSION,
        g_param_spec_object (
            "session",
            NULL,
            NULL,
            E_TYPE_MAIL_SESSION,
            G_PARAM_READWRITE |
            G_PARAM_CONSTRUCT_ONLY));
}

static void
em_vfolder_editor_rule_init (EMVFolderEditorRule *rule)
{
    rule->priv = EM_VFOLDER_EDITOR_RULE_GET_PRIVATE (rule);
}

EFilterRule *
em_vfolder_editor_rule_new (EMailSession *session)
{
    g_return_val_if_fail (E_IS_MAIL_SESSION (session), NULL);

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

EMailSession *
em_vfolder_editor_rule_get_session (EMVFolderEditorRule *rule)
{
    g_return_val_if_fail (EM_IS_VFOLDER_RULE (rule), NULL);

    return rule->priv->session;
}

enum {
    BUTTON_ADD,
    BUTTON_REMOVE,
    BUTTON_LAST
};

struct _source_data {
    ERuleContext *rc;
    EMVFolderRule *vr;
    GtkListStore *model;
    GtkTreeView *tree_view;
    GtkWidget *source_selector;
    GtkWidget *buttons[BUTTON_LAST];
};

static void
set_sensitive (struct _source_data *data)
{
    GtkTreeSelection *selection;

    selection = gtk_tree_view_get_selection (data->tree_view);

    gtk_widget_set_sensitive (
        GTK_WIDGET (data->buttons[BUTTON_ADD]), TRUE);
    gtk_widget_set_sensitive (
        GTK_WIDGET (data->buttons[BUTTON_REMOVE]),
        selection && gtk_tree_selection_count_selected_rows (selection) > 0);
}

static void
selection_changed_cb (GtkTreeSelection *selection,
                      struct _source_data *data)
{
    set_sensitive (data);
}

static void
select_source_with_changed (GtkWidget *widget,
                            struct _source_data *data)
{
    em_vfolder_rule_with_t with;

    with = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
    if (with > EM_VFOLDER_RULE_WITH_LOCAL)
        with = 0;

    with = 3 - with;

    gtk_widget_set_sensitive (data->source_selector, !with);

    em_vfolder_rule_set_with (data->vr, with);
}

static void
autoupdate_toggled_cb (GtkToggleButton *toggle,
                       struct _source_data *data)
{
    em_vfolder_rule_set_autoupdate (data->vr, gtk_toggle_button_get_active (toggle));
}

static void
include_subfolders_toggled_cb (GtkCellRendererToggle *cell_renderer,
                               const gchar *path_string,
                               struct _source_data *data)
{
    GtkTreeModel *model;
    GtkTreePath *path;
    GtkTreeIter iter;

    gtk_cell_renderer_toggle_set_active (
        cell_renderer,
        !gtk_cell_renderer_toggle_get_active (cell_renderer));

    model = gtk_tree_view_get_model (data->tree_view);
    path = gtk_tree_path_new_from_string (path_string);

    if (gtk_tree_model_get_iter (model, &iter, path)) {
        gchar *source = NULL;

        gtk_list_store_set (
            GTK_LIST_STORE (model), &iter,
            2, gtk_cell_renderer_toggle_get_active (cell_renderer),
            -1);

        gtk_tree_model_get (model, &iter, 1, &source, -1);
        if (source) {
            em_vfolder_rule_source_set_include_subfolders (
                data->vr, source,
                gtk_cell_renderer_toggle_get_active (cell_renderer));
            g_free (source);
        }
    }

    gtk_tree_path_free (path);
}

static void
vfr_folder_response (EMFolderSelector *selector,
                     gint button,
                     struct _source_data *data)
{
    EMFolderTreeModel *model;
    EMFolderTree *folder_tree;
    CamelSession *session;
    GList *selected_uris;

    folder_tree = em_folder_selector_get_folder_tree (selector);
    model = em_folder_selector_get_model (selector);
    session = CAMEL_SESSION (em_folder_tree_model_get_session (model));

    selected_uris = em_folder_tree_get_selected_uris (folder_tree);

    if (button == GTK_RESPONSE_OK && selected_uris != NULL) {
        GList *uris_iter;
        GHashTable *known_uris;
        GtkTreeIter iter;
        GtkTreeSelection *selection;
        gboolean changed = FALSE;

        selection = gtk_tree_view_get_selection (data->tree_view);
        gtk_tree_selection_unselect_all (selection);

        known_uris = g_hash_table_new_full (
            (GHashFunc) g_str_hash,
            (GEqualFunc) g_str_equal,
            (GDestroyNotify) g_free,
            (GDestroyNotify) NULL);

        if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (data->model), &iter)) {
            GtkTreeModel *model = GTK_TREE_MODEL (data->model);
            do {
                gchar *known = NULL;

                gtk_tree_model_get (model, &iter, 1, &known, -1);

                if (known)
                    g_hash_table_add (known_uris, known);
            } while (gtk_tree_model_iter_next (model, &iter));
        }

        for (uris_iter = selected_uris; uris_iter != NULL; uris_iter = uris_iter->next) {
            const gchar *uri = uris_iter->data;
            gchar *markup;

            if (uri == NULL)
                continue;

            if (g_hash_table_contains (known_uris, uri))
                continue;

            g_hash_table_add (known_uris, g_strdup (uri));

            changed = TRUE;
            g_queue_push_tail (em_vfolder_rule_get_sources (data->vr), g_strdup (uri));

            markup = e_mail_folder_uri_to_markup (session, uri, NULL);

            gtk_list_store_append (data->model, &iter);
            gtk_list_store_set (data->model, &iter, 0, markup, 1, uri, -1);
            g_free (markup);

            /* select all newly added folders */
            gtk_tree_selection_select_iter (selection, &iter);
        }

        g_hash_table_destroy (known_uris);
        if (changed)
            em_vfolder_rule_sources_changed (data->vr);

        set_sensitive (data);
    }

    gtk_widget_destroy (GTK_WIDGET (selector));
    g_list_free_full (selected_uris, g_free);
}

static void
source_add (GtkWidget *widget,
            struct _source_data *data)
{
    EMFolderTree *folder_tree;
    EMFolderTreeModel *model;
    GtkTreeSelection *selection;
    GtkWidget *dialog;
    gpointer parent;

    parent = gtk_widget_get_toplevel (widget);
    parent = gtk_widget_is_toplevel (parent) ? parent : NULL;

    model = em_folder_tree_model_get_default ();

    dialog = em_folder_selector_new (
        parent, model,
        EM_FOLDER_SELECTOR_CAN_CREATE,
        _("Add Folder"), NULL, _("_Add"));

    folder_tree = em_folder_selector_get_folder_tree (
        EM_FOLDER_SELECTOR (dialog));

    em_folder_tree_set_excluded (folder_tree, EMFT_EXCLUDE_NOSELECT);

    selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_tree));
    gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);

    g_signal_connect (
        dialog, "response",
        G_CALLBACK (vfr_folder_response), data);

    gtk_widget_show (dialog);
}

static void
source_remove (GtkWidget *widget,
               struct _source_data *data)
{
    GtkTreeSelection *selection;
    const gchar *source, *prev_source;
    GtkTreePath *path;
    GtkTreeIter iter;
    GHashTable *to_remove;
    gint index = 0, first_selected = -1, removed;
    gint n;

    selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (data->tree_view));
    to_remove = g_hash_table_new (g_direct_hash, g_direct_equal);

    source = NULL;
    while ((source = em_vfolder_rule_next_source (data->vr, source))) {
        path = gtk_tree_path_new ();
        gtk_tree_path_append_index (path, index);

        if (gtk_tree_selection_path_is_selected (selection, path)) {
            g_hash_table_add (to_remove, GINT_TO_POINTER (index));

            if (first_selected == -1)
                first_selected = index;
        }

        index++;

        gtk_tree_path_free (path);
    }

    /* do not depend on selection when removing */
    gtk_tree_selection_unselect_all (selection);

    index = 0;
    source = NULL;
    removed = 0;
    prev_source = NULL;
    while ((source = em_vfolder_rule_next_source (data->vr, source))) {
        if (g_hash_table_contains (to_remove, GINT_TO_POINTER (index + removed))) {
            path = gtk_tree_path_new ();
            gtk_tree_path_append_index (path, index);
            gtk_tree_model_get_iter (
                GTK_TREE_MODEL (data->model), &iter, path);

            em_vfolder_rule_remove_source (data->vr, source);
            gtk_list_store_remove (data->model, &iter);
            gtk_tree_path_free (path);

            /* try again from the previous source */
            removed++;
            source = prev_source;
        } else {
            index++;
            prev_source = source;
        }
    }

    g_hash_table_destroy (to_remove);

    /* now select the next rule */
    n = gtk_tree_model_iter_n_children (
        GTK_TREE_MODEL (data->model), NULL);
    index = first_selected >= n ? n - 1 : first_selected;

    if (index >= 0) {
        path = gtk_tree_path_new ();
        gtk_tree_path_append_index (path, index);
        if (gtk_tree_model_get_iter (GTK_TREE_MODEL (data->model), &iter, path)) {
            gtk_tree_selection_select_iter (selection, &iter);
            gtk_tree_view_set_cursor (data->tree_view, path, NULL, FALSE);
        }
        gtk_tree_path_free (path);
    }

    set_sensitive (data);
}

static GtkWidget *
get_widget (EFilterRule *fr,
            ERuleContext *rc)
{
    EMVFolderRule *vr = (EMVFolderRule *) fr;
    EMailSession *session;
    GtkWidget *widget, *frame, *label, *combobox, *hgrid, *vgrid, *tree_view, *scrolled_window;
    GtkWidget *autoupdate;
    GtkListStore *model;
    GtkCellRenderer *renderer;
    GtkTreeViewColumn *column;
    struct _source_data *data;
    const gchar *source;
    gchar *tmp;
    GtkTreeIter iter;
    GtkTreeSelection *selection;

    widget = E_FILTER_RULE_CLASS (em_vfolder_editor_rule_parent_class)->
        get_widget (fr, rc);

    data = g_malloc0 (sizeof (*data));
    data->rc = rc;
    data->vr = vr;

    frame = gtk_grid_new ();
    gtk_orientable_set_orientation (GTK_ORIENTABLE (frame), GTK_ORIENTATION_VERTICAL);
    gtk_grid_set_row_spacing (GTK_GRID (frame), 6);

    g_object_set_data_full (G_OBJECT (frame), "data", data, g_free);

    tmp = g_strdup_printf ("<b>%s</b>", _("Search Folder Sources"));
    label = gtk_label_new (tmp);
    g_free (tmp);
    g_object_set (
        G_OBJECT (label),
        "use-markup", TRUE,
        "xalign", 0.0,
        NULL);

    gtk_container_add (GTK_CONTAINER (frame), label);

    hgrid = gtk_grid_new ();
    gtk_orientable_set_orientation (GTK_ORIENTABLE (hgrid), GTK_ORIENTATION_HORIZONTAL);
    gtk_container_add (GTK_CONTAINER (frame), hgrid);

    label = gtk_label_new ("    ");
    gtk_container_add (GTK_CONTAINER (hgrid), label);

    vgrid = gtk_grid_new ();
    g_object_set (
        G_OBJECT (vgrid),
        "orientation", GTK_ORIENTATION_VERTICAL,
        "border-width", 6,
        "row-spacing", 6,
        NULL);
    gtk_container_add (GTK_CONTAINER (hgrid), vgrid);

    hgrid = gtk_grid_new ();
    gtk_orientable_set_orientation (GTK_ORIENTABLE (hgrid), GTK_ORIENTATION_HORIZONTAL);
    gtk_grid_set_column_spacing (GTK_GRID (hgrid), 6);
    gtk_container_add (GTK_CONTAINER (vgrid), hgrid);

    autoupdate = gtk_check_button_new_with_mnemonic (_("Automatically update on any _source folder change"));
    gtk_container_add (GTK_CONTAINER (hgrid), autoupdate);

    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (autoupdate), em_vfolder_rule_get_autoupdate (vr));
    g_signal_connect (autoupdate, "toggled", G_CALLBACK (autoupdate_toggled_cb), data);

    hgrid = gtk_grid_new ();
    gtk_orientable_set_orientation (GTK_ORIENTABLE (hgrid), GTK_ORIENTATION_HORIZONTAL);
    gtk_grid_set_column_spacing (GTK_GRID (hgrid), 6);
    gtk_container_add (GTK_CONTAINER (vgrid), hgrid);

    combobox = gtk_combo_box_text_new ();
    gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combobox), NULL, _("All local folders"));
    gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combobox), NULL, _("All active remote folders"));
    gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combobox), NULL, _("All local and active remote folders"));
    gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combobox), NULL, _("Specific folders"));
    gtk_container_add (GTK_CONTAINER (hgrid), combobox);

    hgrid = gtk_grid_new ();
    gtk_orientable_set_orientation (GTK_ORIENTABLE (hgrid), GTK_ORIENTATION_HORIZONTAL);
    gtk_grid_set_column_spacing (GTK_GRID (hgrid), 6);
    gtk_container_add (GTK_CONTAINER (vgrid), hgrid);

    scrolled_window = gtk_scrolled_window_new (NULL, NULL);
    g_object_set (
        G_OBJECT (scrolled_window),
        "hscrollbar-policy", GTK_POLICY_AUTOMATIC,
        "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
        "shadow-type", GTK_SHADOW_IN,
        "halign", GTK_ALIGN_FILL,
        "hexpand", TRUE,
        "valign", GTK_ALIGN_FILL,
        "vexpand", TRUE,
        NULL);
    gtk_container_add (GTK_CONTAINER (hgrid), scrolled_window);

    model = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
    renderer = gtk_cell_renderer_text_new ();
    tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
    gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
    gtk_tree_view_insert_column_with_attributes (
        GTK_TREE_VIEW (tree_view),
        -1, "column", renderer, "markup", 0, NULL);

    renderer = gtk_cell_renderer_toggle_new ();
    column = gtk_tree_view_column_new_with_attributes (
        "include subfolders", renderer, "active", 2, NULL);
    g_signal_connect (renderer, "toggled", G_CALLBACK (include_subfolders_toggled_cb), data);

    renderer = gtk_cell_renderer_text_new ();
    g_object_set (
        G_OBJECT (renderer),
        "editable", FALSE,
        "text", _("include subfolders"),
        NULL);
    gtk_tree_view_column_pack_start (column, renderer, TRUE);
    gtk_tree_view_insert_column (GTK_TREE_VIEW (tree_view), column, -1);

    column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), 0);
    gtk_tree_view_column_set_expand (column, TRUE);

    gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), tree_view);

    vgrid = gtk_grid_new ();
    g_object_set (
        G_OBJECT (vgrid),
        "orientation", GTK_ORIENTATION_VERTICAL,
        "border-width", 6,
        "row-spacing", 6,
        NULL);
    gtk_container_add (GTK_CONTAINER (hgrid), vgrid);

    data->buttons[BUTTON_ADD] = gtk_button_new_from_stock (GTK_STOCK_ADD);
    g_signal_connect (
        data->buttons[BUTTON_ADD], "clicked",
        G_CALLBACK (source_add), data);

    data->buttons[BUTTON_REMOVE] = gtk_button_new_from_stock (GTK_STOCK_REMOVE);
    g_signal_connect (
        data->buttons[BUTTON_REMOVE], "clicked",
        G_CALLBACK (source_remove), data);

    gtk_container_add (GTK_CONTAINER (vgrid), data->buttons[BUTTON_ADD]);
    gtk_container_add (GTK_CONTAINER (vgrid), data->buttons[BUTTON_REMOVE]);

    data->tree_view = GTK_TREE_VIEW (tree_view);
    data->model = model;

    session = em_vfolder_editor_context_get_session (EM_VFOLDER_EDITOR_CONTEXT (rc));

    source = NULL;
    while ((source = em_vfolder_rule_next_source (vr, source))) {
        gchar *markup;

        markup = e_mail_folder_uri_to_markup (
            CAMEL_SESSION (session), source, NULL);

        gtk_list_store_append (data->model, &iter);
        gtk_list_store_set (
            data->model, &iter,
            0, markup,
            1, source,
            2, em_vfolder_rule_source_get_include_subfolders (vr, source),
            -1);
        g_free (markup);
    }

    selection = gtk_tree_view_get_selection (data->tree_view);
    gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);

    g_signal_connect (
        selection, "changed",
        G_CALLBACK (selection_changed_cb), data);

    data->source_selector = hgrid;

    gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), 3 - em_vfolder_rule_get_with (vr));
    g_signal_connect (
        combobox, "changed",
        G_CALLBACK (select_source_with_changed), data);
    select_source_with_changed (combobox, data);

    set_sensitive (data);

    gtk_widget_set_valign (frame, GTK_ALIGN_FILL);
    gtk_widget_set_vexpand (frame, TRUE);
    gtk_widget_show_all (frame);

    gtk_container_add (GTK_CONTAINER (widget), frame);

    return widget;
}