Sylpheed

/*

 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client

 * Copyright (C) 1999-2009 Hiroyuki Yamamoto

 *

 * 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 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#include "defs.h"

#include <glib.h>

#include <glib/gi18n.h>

#include <gdk/gdkkeysyms.h>

#include <gtk/gtkwidget.h>

#include <gtk/gtkwindow.h>

#include <gtk/gtkvbox.h>

#include <gtk/gtktable.h>

#include <gtk/gtkoptionmenu.h>

#include <gtk/gtklabel.h>

#include <gtk/gtkentry.h>

#include <gtk/gtkhbox.h>

#include <gtk/gtkcheckbutton.h>

#include <gtk/gtkhbbox.h>

#include <gtk/gtkbutton.h>

#include <gtk/gtkmenuitem.h>

#include <gtk/gtkstock.h>

#include <gtk/gtktreemodel.h>

#include <gtk/gtkliststore.h>

#include <gtk/gtktreeview.h>

#include <gtk/gtktreeselection.h>

#include <gtk/gtkcellrenderertext.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "query_search.h"

#include "summaryview.h"

#include "messageview.h"

#include "mainwindow.h"

#include "folderview.h"

#include "menu.h"

#include "utils.h"

#include "gtkutils.h"

#include "manage_window.h"

#include "alertpanel.h"

#include "foldersel.h"

#include "statusbar.h"

#include "procmsg.h"

#include "procheader.h"

#include "folder.h"

#include "filter.h"

#include "prefs_filter.h"

#include "prefs_filter_edit.h"

enum

{

        COL_FOLDER,

        COL_SUBJECT,

        COL_FROM,

        COL_DATE,

        COL_MSGINFO,

        N_COLS

};

static struct QuerySearchWindow {

        GtkWidget *window;

        GtkWidget *bool_optmenu;

        FilterCondEdit *cond_edit;

        GtkWidget *folder_entry;

        GtkWidget *folder_btn;

        GtkWidget *subfolder_checkbtn;

        GtkWidget *case_checkbtn;

        GtkWidget *treeview;

        GtkListStore *store;

        GtkWidget *status_label;

        GtkWidget *clear_btn;

        GtkWidget *search_btn;

        GtkWidget *save_btn;

        GtkWidget *close_btn;

        FilterRule *rule;

        gboolean requires_full_headers;

        gboolean exclude_trash;

        gint n_found;

        gboolean on_search;

        gboolean cancelled;

} search_window;

typedef struct {

        GtkWidget *window;

        GtkWidget *folder_entry;

        GtkWidget *name_entry;

        GtkWidget *ok_btn;

        GtkWidget *cancel_btn;

        gboolean cancelled;

        gboolean finished;

} QuerySearchSaveDialog;

static void query_search_create        (void);

static FilterRule *query_search_dialog_to_rule        (const gchar        *name,

                                                 FolderItem    **item);

static void query_search_query                        (void);

static void query_search_folder                        (FolderItem        *item);

static gboolean query_search_recursive_func        (GNode                *node,

                                                 gpointer         data);

static void query_search_append_msg        (MsgInfo        *msginfo);

static void query_search_clear_list        (void);

static void query_search_hbox_added        (CondHBox        *hbox);

static void row_activated                (GtkTreeView                *treeview,

                                         GtkTreePath                *path,

                                         GtkTreeViewColumn        *column,

                                         gpointer                 data);

static gboolean row_selected                (GtkTreeSelection        *selection,

                                         GtkTreeModel                *model,

                                         GtkTreePath                *path,

                                         gboolean                 cur_selected,

                                         gpointer                 data);

static void query_search_clear                (GtkButton        *button,

                                         gpointer         data);

static void query_select_folder                (GtkButton        *button,

                                         gpointer         data);

static void query_search_clicked        (GtkButton        *button,

                                         gpointer         data);

static void query_search_save                (GtkButton        *button,

                                         gpointer         data);

static void query_search_close                (GtkButton        *button,

                                         gpointer         data);

static void query_search_entry_activated(GtkWidget        *widget,

                                         gpointer         data);

static gint query_search_deleted        (GtkWidget        *widget,

                                         GdkEventAny        *event,

                                         gpointer         data);

static gboolean key_pressed                (GtkWidget        *widget,

                                         GdkEventKey        *event,

                                         gpointer         data);

static gint query_search_cmp_by_folder        (GtkTreeModel        *model,

                                         GtkTreeIter        *a,

                                         GtkTreeIter        *b,

                                         gpointer         data);

static gint query_search_cmp_by_subject        (GtkTreeModel        *model,

                                         GtkTreeIter        *a,

                                         GtkTreeIter        *b,

                                         gpointer         data);

static gint query_search_cmp_by_from        (GtkTreeModel        *model,

                                         GtkTreeIter        *a,

                                         GtkTreeIter        *b,

                                         gpointer         data);

static gint query_search_cmp_by_date        (GtkTreeModel        *model,

                                         GtkTreeIter        *a,

                                         GtkTreeIter        *b,

                                         gpointer         data);

void query_search(FolderItem *item)

{

        gchar *id;

        if (!search_window.window)

                query_search_create();

        else

                gtk_window_present(GTK_WINDOW(search_window.window));

        if (item && item->stype != F_VIRTUAL) {

                id = folder_item_get_identifier(item);

                gtk_entry_set_text(GTK_ENTRY(search_window.folder_entry), id);

                g_free(id);

        } else

                gtk_entry_set_text(GTK_ENTRY(search_window.folder_entry), "");

        gtk_widget_grab_focus(search_window.search_btn);

        gtk_widget_show(search_window.window);

}

static void query_search_create(void)

{

        GtkWidget *window;

        GtkWidget *vbox1;

        GtkWidget *bool_hbox;

        GtkWidget *bool_optmenu;

        GtkWidget *bool_menu;

        GtkWidget *menuitem;

        GtkWidget *clear_btn;

        GtkWidget *search_btn;

        GtkWidget *scrolledwin;

        FilterCondEdit *cond_edit;

        CondHBox *cond_hbox;

        GtkWidget *folder_hbox;

        GtkWidget *folder_label;

        GtkWidget *folder_entry;

        GtkWidget *folder_btn;

        GtkWidget *checkbtn_hbox;

        GtkWidget *subfolder_checkbtn;

        GtkWidget *case_checkbtn;

        GtkWidget *treeview;

        GtkListStore *store;

        GtkTreeViewColumn *column;

        GtkCellRenderer *renderer;

        GtkTreeSelection *selection;

        GtkWidget *confirm_area;

        GtkWidget *status_label;

        GtkWidget *btn_hbox;

        GtkWidget *hbbox;

        GtkWidget *save_btn;

        GtkWidget *close_btn;

        window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

        gtk_window_set_title(GTK_WINDOW (window), _("Search messages"));

        gtk_widget_set_size_request(window, 600, -1);

        gtk_window_set_policy(GTK_WINDOW(window), FALSE, TRUE, TRUE);

        gtk_container_set_border_width(GTK_CONTAINER (window), 8);

        g_signal_connect(G_OBJECT(window), "delete_event",

                         G_CALLBACK(query_search_deleted), NULL);

        g_signal_connect(G_OBJECT(window), "key_press_event",

                         G_CALLBACK(key_pressed), NULL);

        MANAGE_WINDOW_SIGNALS_CONNECT(window);

        vbox1 = gtk_vbox_new (FALSE, 6);

        gtk_widget_show (vbox1);

        gtk_container_add (GTK_CONTAINER (window), vbox1);

        bool_hbox = gtk_hbox_new(FALSE, 12);

        gtk_widget_show(bool_hbox);

        gtk_box_pack_start(GTK_BOX(vbox1), bool_hbox, FALSE, FALSE, 0);

        bool_optmenu = gtk_option_menu_new();

        gtk_widget_show(bool_optmenu);

        gtk_box_pack_start(GTK_BOX(bool_hbox), bool_optmenu, FALSE, FALSE, 0);

        bool_menu = gtk_menu_new();

        MENUITEM_ADD(bool_menu, menuitem, _("Match any of the following"),

                     FLT_OR);

        MENUITEM_ADD(bool_menu, menuitem, _("Match all of the following"),

                     FLT_AND);

        gtk_option_menu_set_menu(GTK_OPTION_MENU(bool_optmenu), bool_menu);

        gtk_option_menu_set_history(GTK_OPTION_MENU(bool_optmenu), FLT_AND);

        hbbox = gtk_hbutton_box_new();

        gtk_widget_show(hbbox);

        gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_END);

        gtk_box_set_spacing(GTK_BOX(hbbox), 6);

        gtk_box_pack_end(GTK_BOX(bool_hbox), hbbox, FALSE, FALSE, 0);

        clear_btn = gtk_button_new_from_stock(GTK_STOCK_CLEAR);

        gtk_widget_show(clear_btn);

        gtk_box_pack_start(GTK_BOX(hbbox), clear_btn, FALSE, FALSE, 0);

        search_btn = gtk_button_new_from_stock(GTK_STOCK_FIND);

        GTK_WIDGET_SET_FLAGS(search_btn, GTK_CAN_DEFAULT);

        gtk_widget_show(search_btn);

        gtk_box_pack_start(GTK_BOX(hbbox), search_btn, FALSE, FALSE, 0);

        gtk_widget_grab_default(search_btn);

        scrolledwin = gtk_scrolled_window_new(NULL, NULL);

        gtk_widget_show(scrolledwin);

        gtk_box_pack_start(GTK_BOX(vbox1), scrolledwin, FALSE, FALSE, 0);

        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),

                                       GTK_POLICY_AUTOMATIC,

                                       GTK_POLICY_AUTOMATIC);

        gtk_widget_set_size_request(scrolledwin, -1, 120);

        cond_edit = prefs_filter_edit_cond_edit_create();

        cond_edit->add_hbox = query_search_hbox_added;

        gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolledwin),

                                              cond_edit->cond_vbox);

        prefs_filter_set_header_list(NULL);

        prefs_filter_edit_set_header_list(cond_edit, NULL);

        cond_hbox = prefs_filter_edit_cond_hbox_create(cond_edit);

        prefs_filter_edit_set_cond_hbox_widgets(cond_hbox, PF_COND_HEADER);

        prefs_filter_edit_insert_cond_hbox(cond_edit, cond_hbox, -1);

        if (cond_edit->add_hbox)

                cond_edit->add_hbox(cond_hbox);

        folder_hbox = gtk_hbox_new (FALSE, 8);

        gtk_widget_show (folder_hbox);

        gtk_box_pack_start (GTK_BOX (vbox1), folder_hbox, FALSE, FALSE, 0);

        folder_label = gtk_label_new (_("Folder:"));

        gtk_widget_show (folder_label);

        gtk_box_pack_start (GTK_BOX (folder_hbox), folder_label,

                            FALSE, FALSE, 0);

        folder_entry = gtk_entry_new ();

        gtk_widget_show (folder_entry);

        gtk_box_pack_start (GTK_BOX (folder_hbox), folder_entry, TRUE, TRUE, 0);

        folder_btn = gtk_button_new_with_label("...");

        gtk_widget_show (folder_btn);

        gtk_box_pack_start (GTK_BOX (folder_hbox), folder_btn, FALSE, FALSE, 0);

        checkbtn_hbox = gtk_hbox_new (FALSE, 12);

        gtk_widget_show (checkbtn_hbox);

        gtk_box_pack_start (GTK_BOX (vbox1), checkbtn_hbox, FALSE, FALSE, 0);

        subfolder_checkbtn =

                gtk_check_button_new_with_label (_("Search subfolders"));

        gtk_widget_show (subfolder_checkbtn);

        gtk_box_pack_start (GTK_BOX (checkbtn_hbox), subfolder_checkbtn,

                            FALSE, FALSE, 0);

        case_checkbtn = gtk_check_button_new_with_label (_("Case sensitive"));

        gtk_widget_show (case_checkbtn);

        gtk_box_pack_start (GTK_BOX (checkbtn_hbox), case_checkbtn,

                            FALSE, FALSE, 0);

        scrolledwin = gtk_scrolled_window_new(NULL, NULL);

        gtk_box_pack_start(GTK_BOX(vbox1), scrolledwin, TRUE, TRUE, 0);

        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),

                                       GTK_POLICY_AUTOMATIC,

                                       GTK_POLICY_AUTOMATIC);

        gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),

                                            GTK_SHADOW_IN);

        gtk_widget_set_size_request(scrolledwin, -1, 150);

        store = gtk_list_store_new(N_COLS,

                                   G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,

                                   G_TYPE_STRING, G_TYPE_POINTER);

        treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));

        g_object_unref(store);

        gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);

        g_signal_connect(G_OBJECT(treeview), "row-activated",

                         G_CALLBACK(row_activated), NULL);

        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), COL_FOLDER,

                                        query_search_cmp_by_folder, NULL, NULL);

        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), COL_SUBJECT,

                                        query_search_cmp_by_subject,

                                        NULL, NULL);

        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), COL_FROM,

                                        query_search_cmp_by_from, NULL, NULL);

        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), COL_DATE,

                                        query_search_cmp_by_date, NULL, NULL);

        selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));

        gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);

        gtk_tree_selection_set_select_function(selection, row_selected,

                                               NULL, NULL);

        gtk_container_add(GTK_CONTAINER(scrolledwin), treeview);

#define APPEND_COLUMN(label, col, width)                                \

{                                                                        \

        renderer = gtk_cell_renderer_text_new();                        \

        column = gtk_tree_view_column_new_with_attributes                \

                (label, renderer, "text", col, NULL);                        \

        gtk_tree_view_column_set_resizable(column, TRUE);                \

        if (width) {                                                        \

                gtk_tree_view_column_set_sizing                                \

                        (column, GTK_TREE_VIEW_COLUMN_FIXED);                \

                gtk_tree_view_column_set_fixed_width(column, width);        \

        }                                                                \

        gtk_tree_view_column_set_sort_column_id(column, col);                \

        gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);        \

}

        APPEND_COLUMN(_("Folder"), COL_FOLDER, 0);

        APPEND_COLUMN(_("Subject"), COL_SUBJECT, 200);

        APPEND_COLUMN(_("From"), COL_FROM, 180);

        APPEND_COLUMN(_("Date"), COL_DATE, 0);

        gtk_widget_show_all(scrolledwin);

        confirm_area = gtk_hbox_new(FALSE, 12);

        gtk_widget_show(confirm_area);

        gtk_box_pack_start(GTK_BOX(vbox1), confirm_area, FALSE, FALSE, 0);

        status_label = gtk_label_new("");

        gtk_widget_show(status_label);

        gtk_box_pack_start(GTK_BOX(confirm_area), status_label,

                           FALSE, FALSE, 0);

        btn_hbox = gtk_hbox_new(FALSE, 6);

        gtk_widget_show(btn_hbox);

        gtk_box_pack_end(GTK_BOX(confirm_area), btn_hbox, FALSE, FALSE, 0);

        gtkut_stock_button_set_create(&hbbox, &close_btn, GTK_STOCK_CLOSE,

                                      NULL, NULL, NULL, NULL);

        gtk_widget_show(hbbox);

        gtk_box_pack_end(GTK_BOX(btn_hbox), hbbox, FALSE, FALSE, 0);

        save_btn = gtk_button_new_with_mnemonic(_("_Save as search folder"));

        gtk_widget_show(save_btn);

        gtk_box_pack_end(GTK_BOX(btn_hbox), save_btn, FALSE, FALSE, 0);

        g_signal_connect(G_OBJECT(clear_btn), "clicked",

                         G_CALLBACK(query_search_clear), NULL);

        g_signal_connect(G_OBJECT(folder_btn), "clicked",

                         G_CALLBACK(query_select_folder), NULL);

        g_signal_connect(G_OBJECT(search_btn), "clicked",

                         G_CALLBACK(query_search_clicked), NULL);

        g_signal_connect(G_OBJECT(save_btn), "clicked",

                         G_CALLBACK(query_search_save), NULL);

        g_signal_connect(G_OBJECT(close_btn), "clicked",

                         G_CALLBACK(query_search_close), NULL);

        search_window.window = window;

        search_window.bool_optmenu = bool_optmenu;

        search_window.cond_edit = cond_edit;

        search_window.folder_entry = folder_entry;

        search_window.folder_btn = folder_btn;

        search_window.subfolder_checkbtn = subfolder_checkbtn;

        search_window.case_checkbtn = case_checkbtn;

        search_window.treeview = treeview;

        search_window.store = store;

        search_window.status_label = status_label;

        search_window.clear_btn = clear_btn;

        search_window.search_btn = search_btn;

        search_window.save_btn  = save_btn;

        search_window.close_btn = close_btn;

}

static FilterRule *query_search_dialog_to_rule(const gchar *name,

                                                 FolderItem **item)

{

        const gchar *id;

        FolderItem *item_;

        FilterBoolOp bool_op;

        gboolean recursive;

        gboolean case_sens;

        GSList *cond_list;

        FilterRule *rule;

        id = gtk_entry_get_text(GTK_ENTRY(search_window.folder_entry));

        item_ = folder_find_item_from_identifier(id);

        if (!item_)

                return NULL;

        if (item)

                *item = item_;

        bool_op = menu_get_option_menu_active_index

                (GTK_OPTION_MENU(search_window.bool_optmenu));

        recursive = gtk_toggle_button_get_active

                (GTK_TOGGLE_BUTTON(search_window.subfolder_checkbtn));

        case_sens = gtk_toggle_button_get_active

                (GTK_TOGGLE_BUTTON(search_window.case_checkbtn));

        cond_list = prefs_filter_edit_cond_edit_to_list(search_window.cond_edit,

                                                        case_sens);

        if (!cond_list)

                return NULL;

        rule = filter_rule_new(name, bool_op, cond_list, NULL);

        rule->target_folder = g_strdup(id);

        rule->recursive = recursive;

        return rule;

}

static void query_search_query(void)

{

        FolderItem *item;

        gchar *msg;

        if (search_window.on_search)

                return;

        search_window.on_search = TRUE;

        search_window.rule = query_search_dialog_to_rule("Query rule", &item);

        if (!search_window.rule) {

                search_window.on_search = FALSE;

                return;

        }

        search_window.requires_full_headers =

                filter_rule_requires_full_headers(search_window.rule);

        if (search_window.rule->recursive) {

                if (item->stype == F_TRASH)

                        search_window.exclude_trash = FALSE;

                else

                        search_window.exclude_trash = TRUE;

        } else

                search_window.exclude_trash = FALSE;

        search_window.n_found = 0;

        search_window.cancelled = FALSE;

        gtk_widget_set_sensitive(search_window.clear_btn, FALSE);

        gtk_button_set_label(GTK_BUTTON(search_window.search_btn),

                             GTK_STOCK_STOP);

        query_search_clear_list();

        if (search_window.rule->recursive)

                g_node_traverse(item->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,

                                query_search_recursive_func, NULL);

        else

                query_search_folder(item);

        filter_rule_free(search_window.rule);

        search_window.rule = NULL;

        search_window.requires_full_headers = FALSE;

        search_window.exclude_trash = FALSE;

        gtk_widget_set_sensitive(search_window.clear_btn, TRUE);

        gtk_button_set_label(GTK_BUTTON(search_window.search_btn),

                             GTK_STOCK_FIND);

        if (search_window.n_found == 0)

                msg = g_strdup_printf(_("Message not found."));

        else if (search_window.n_found == 1)

                msg = g_strdup_printf(_("1 message found."));

        else

                msg = g_strdup_printf(_("%d messages found."),

                                      search_window.n_found);

        gtk_label_set_text(GTK_LABEL(search_window.status_label), msg);

        g_free(msg);

        statusbar_pop_all();

        if (search_window.cancelled)

                debug_print("* query search cancelled.\n");

        debug_print("query search finished.\n");

        search_window.n_found = 0;

        search_window.on_search = FALSE;

        search_window.cancelled = FALSE;

}

typedef struct _QueryData

{

        FolderItem *item;

        gchar *folder_name;

        gint count;

        gint total;

        gint flag;

        GTimeVal tv_prev;

        GSList *mlist;

#if USE_THREADS

        GAsyncQueue *queue;

        guint timer_tag;

#endif

} QueryData;

static void query_search_folder_show_progress(const gchar *name, gint count,

                                              gint total)

{

        gchar *str;

        str = g_strdup_printf(_("Searching %s (%d / %d)..."),

                              name, count, total);

        gtk_label_set_text(GTK_LABEL(search_window.status_label), str);

        g_free(str);

#ifndef USE_THREADS

        ui_update();

#endif

}

#if USE_THREADS

static gboolean query_search_progress_func(gpointer data)

{

        QueryData *qdata = (QueryData *)data;

        MsgInfo *msginfo;

        gdk_threads_enter();

        query_search_folder_show_progress(qdata->folder_name,

                                          g_atomic_int_get(&qdata->count),

                                          qdata->total);

        while ((msginfo = g_async_queue_try_pop(qdata->queue)))

                query_search_append_msg(msginfo);

        gdk_threads_leave();

        return TRUE;

}

#endif

static gpointer query_search_folder_func(gpointer data)

{

        QueryData *qdata = (QueryData *)data;

        GSList *mlist, *cur;

        FilterInfo fltinfo;

        GTimeVal tv_cur;

        debug_print("query_search_folder_func start\n");

#if USE_THREADS

        g_async_queue_ref(qdata->queue);

#endif

        mlist = qdata->mlist;

        memset(&fltinfo, 0, sizeof(FilterInfo));

        debug_print("requires_full_headers: %d\n",

                    search_window.requires_full_headers);

        debug_print("start query search: %s\n",

                    qdata->item->path ? qdata->item->path : "");

        for (cur = mlist; cur != NULL; cur = cur->next) {

                MsgInfo *msginfo = (MsgInfo *)cur->data;

                GSList *hlist;

                g_atomic_int_add(&qdata->count, 1);

                g_get_current_time(&tv_cur);

                if ((tv_cur.tv_sec - qdata->tv_prev.tv_sec) * G_USEC_PER_SEC +

                    tv_cur.tv_usec - qdata->tv_prev.tv_usec >

                    PROGRESS_UPDATE_INTERVAL * 1000) {

#ifndef USE_THREADS

                        query_search_folder_show_progress(qdata->folder_name,

                                                          qdata->count,

                                                          qdata->total);

#endif

                        qdata->tv_prev = tv_cur;

                }

                if (search_window.cancelled)

                        break;

                fltinfo.flags = msginfo->flags;

                if (search_window.requires_full_headers) {

                        gchar *file;

                        file = procmsg_get_message_file(msginfo);

                        hlist = procheader_get_header_list_from_file(file);

                        g_free(file);

                } else

                        hlist = procheader_get_header_list_from_msginfo

                                (msginfo);

                if (!hlist)

                        continue;

                if (filter_match_rule(search_window.rule, msginfo, hlist,

                                      &fltinfo)) {

#if USE_THREADS

                        g_async_queue_push(qdata->queue, msginfo);

#else

                        query_search_append_msg(msginfo);

#endif

                        cur->data = NULL;

                        search_window.n_found++;

                }

                procheader_header_list_destroy(hlist);

        }

#if USE_THREADS

        g_async_queue_unref(qdata->queue);

#endif

        g_atomic_int_set(&qdata->flag, 1);

        g_main_context_wakeup(NULL);

        debug_print("query_search_folder_func end\n");

        return GINT_TO_POINTER(0);

}

static void query_search_folder(FolderItem *item)

{

        gchar *str;

        QueryData data = {item};

#if USE_THREADS

        GThread *thread;

        MsgInfo *msginfo;

#endif

        if (!item->path || item->stype == F_VIRTUAL)

                return;

        data.folder_name = g_path_get_basename(item->path);

        str = g_strdup_printf(_("Searching %s ..."), data.folder_name);

        gtk_label_set_text(GTK_LABEL(search_window.status_label), str);

        g_free(str);

        g_get_current_time(&data.tv_prev);

#ifndef USE_THREADS

        ui_update();

#endif

        if (search_window.cancelled) {

                g_free(data.folder_name);

                return;

        }

        if (item->opened)

                summary_write_cache(main_window_get()->summaryview);

        procmsg_set_auto_decrypt_message(FALSE);

        data.mlist = folder_item_get_msg_list(item, TRUE);

        data.total = g_slist_length(data.mlist);

#if USE_THREADS

        data.queue = g_async_queue_new();

        data.timer_tag = g_timeout_add(PROGRESS_UPDATE_INTERVAL,

                                       query_search_progress_func, &data);

        thread = g_thread_create(query_search_folder_func, &data, TRUE, NULL);

        debug_print("query_search_folder: thread started\n");

        while (g_atomic_int_get(&data.flag) == 0)

                gtk_main_iteration();

        log_window_flush();

        while ((msginfo = g_async_queue_try_pop(data.queue)))

                query_search_append_msg(msginfo);

        g_source_remove(data.timer_tag);

        g_thread_join(thread);

        debug_print("query_search_folder: thread exited\n");

        g_async_queue_unref(data.queue);

#else /* !USE_THREADS */

        query_search_folder_func(&data);

#endif

        procmsg_msg_list_free(data.mlist);

        procmsg_set_auto_decrypt_message(TRUE);

        g_free(data.folder_name);

}

static gboolean query_search_recursive_func(GNode *node, gpointer data)

{

        FolderItem *item;

        g_return_val_if_fail(node->data != NULL, FALSE);

        item = FOLDER_ITEM(node->data);

        if (!item->path)

                return FALSE;

        if (search_window.exclude_trash && item->stype == F_TRASH)

                return FALSE;

        query_search_folder(item);

        if (search_window.cancelled)

                return TRUE;

        return FALSE;

}

static void query_search_append_msg(MsgInfo *msginfo)

{

        GtkListStore *store = search_window.store;

        GtkTreeIter iter;

        gchar *folder;

        gchar date_buf[80];

        const gchar *subject, *from, *date;

        gchar *id;

        id = folder_item_get_identifier(msginfo->folder);

        folder = g_path_get_basename(id);

        g_free(id);

        subject = msginfo->subject ? msginfo->subject : _("(No Subject)");

        from = msginfo->from ? msginfo->from : _("(No From)");

        if (msginfo->date_t) {

                procheader_date_get_localtime(date_buf, sizeof(date_buf),

                                              msginfo->date_t);

                date = date_buf;

        } else if (msginfo->date)

                date = msginfo->date;

        else

                date = _("(No Date)");

        gtk_list_store_append(store, &iter);

        gtk_list_store_set(store, &iter,

                           COL_FOLDER, folder,

                           COL_SUBJECT, subject,

                           COL_FROM, from,

                           COL_DATE, date,

                           COL_MSGINFO, msginfo,

                           -1);

        g_free(folder);

}

static void query_search_clear_list(void)

{

        GtkTreeIter iter;

        GtkTreeModel *model = GTK_TREE_MODEL(search_window.store);

        MsgInfo *msginfo;

        gtkut_tree_sortable_unset_sort_column_id

                (GTK_TREE_SORTABLE(search_window.store));

        if (!gtk_tree_model_get_iter_first(model, &iter))

                return;

        do {

                gtk_tree_model_get(model, &iter, COL_MSGINFO, &msginfo, -1);

                procmsg_msginfo_free(msginfo);

        } while (gtk_tree_model_iter_next(model, &iter));

        gtk_list_store_clear(search_window.store);

}

static void query_search_hbox_added(CondHBox *hbox)

{

        g_signal_connect(hbox->key_entry, "activate",

                         G_CALLBACK(query_search_entry_activated), NULL);

}

static void row_activated(GtkTreeView *treeview, GtkTreePath *path,

                          GtkTreeViewColumn *column, gpointer data)

{

        GtkTreeIter iter;

        GtkTreeModel *model = GTK_TREE_MODEL(search_window.store);

        MsgInfo *msginfo;

        MessageView *msgview;

        if (!gtk_tree_model_get_iter(model, &iter, path))

                return;

        gtk_tree_model_get(model, &iter, COL_MSGINFO, &msginfo, -1);

        if (!summary_select_by_msginfo(main_window_get()->summaryview,

                                       msginfo)) {

                msgview = messageview_create_with_new_window();

                messageview_show(msgview, msginfo, FALSE);

                statusbar_pop_all();

        }

}

static gboolean row_selected(GtkTreeSelection *selection,

                             GtkTreeModel *model, GtkTreePath *path,

                             gboolean cur_selected, gpointer data)

{

        return TRUE;

}

static void query_search_clear(GtkButton *button, gpointer data)

{

        CondHBox *cond_hbox;

        if (search_window.on_search)

                return;

        prefs_filter_edit_clear_cond_edit(search_window.cond_edit);

        prefs_filter_set_header_list(NULL);

        prefs_filter_edit_set_header_list(search_window.cond_edit, NULL);

        cond_hbox = prefs_filter_edit_cond_hbox_create(search_window.cond_edit);

        prefs_filter_edit_set_cond_hbox_widgets(cond_hbox, PF_COND_HEADER);

        prefs_filter_edit_insert_cond_hbox

                (search_window.cond_edit, cond_hbox, -1);

        if (search_window.cond_edit->add_hbox)

                search_window.cond_edit->add_hbox(cond_hbox);

        gtk_label_set_text(GTK_LABEL(search_window.status_label), "");

        query_search_clear_list();

}

static void query_select_folder(GtkButton *button, gpointer data)

{

        FolderItem *item;

        gchar *id;

        item = foldersel_folder_sel(NULL, FOLDER_SEL_ALL, NULL);

        if (!item || item->stype == F_VIRTUAL)

                return;

        id = folder_item_get_identifier(item);

        if (id) {

                gtk_entry_set_text(GTK_ENTRY(search_window.folder_entry), id);

                g_free(id);

        }

}

static void query_search_clicked(GtkButton *button, gpointer data)

{

        if (search_window.on_search)

                search_window.cancelled = TRUE;

        else

                query_search_query();

}

static gint query_search_save_dialog_deleted(GtkWidget *widget,

                                             GdkEventAny *event, gpointer data)

{

        QuerySearchSaveDialog *dialog = (QuerySearchSaveDialog *)data;

        dialog->cancelled = TRUE;

        dialog->finished = TRUE;

        return TRUE;

}

static gint query_search_save_dialog_key_pressed(GtkWidget *widget,

                                                   GdkEventKey *event,

                                                   gpointer data)

{

        QuerySearchSaveDialog *dialog = (QuerySearchSaveDialog *)data;

        if (event && event->keyval == GDK_Escape) {

                dialog->cancelled = TRUE;

                dialog->finished = TRUE;

        }

        return FALSE;

}

static void query_search_save_dialog_select_folder(GtkButton *button,

                                                   gpointer data)

{

        QuerySearchSaveDialog *dialog = (QuerySearchSaveDialog *)data;

        FolderItem *item;

        gchar *id;

        item = foldersel_folder_sel(NULL, FOLDER_SEL_ALL, NULL);

        if (!item || item->no_sub || item->stype == F_VIRTUAL)

                return;

        id = folder_item_get_identifier(item);

        if (id) {

                gtk_entry_set_text(GTK_ENTRY(dialog->folder_entry), id);

                g_free(id);

        }

}

static void query_search_save_activated(GtkEditable *editable, gpointer data)

{

        QuerySearchSaveDialog *dialog = (QuerySearchSaveDialog *)data;

        gtk_button_clicked(GTK_BUTTON(dialog->ok_btn));

}

static void query_search_save_ok(GtkButton *button, gpointer data)

{

        QuerySearchSaveDialog *dialog = (QuerySearchSaveDialog *)data;

        dialog->finished = TRUE;

}

static void query_search_save_cancel(GtkButton *button, gpointer data)

{

        QuerySearchSaveDialog *dialog = (QuerySearchSaveDialog *)data;

        dialog->cancelled = TRUE;

        dialog->finished = TRUE;

}

static QuerySearchSaveDialog *query_search_save_dialog_create(void)

{

        QuerySearchSaveDialog *dialog;

        GtkWidget *window;

        GtkWidget *vbox;

        GtkWidget *hbox;

        GtkWidget *label;

        GtkWidget *folder_entry;

        GtkWidget *folder_btn;

        GtkWidget *name_entry;

        GtkWidget *confirm_area;

        GtkWidget *hbbox;

        GtkWidget *cancel_btn;

        GtkWidget *ok_btn;

        dialog = g_new0(QuerySearchSaveDialog, 1);

        window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

        gtk_window_set_title(GTK_WINDOW(window), _("Save as search folder"));

        gtk_widget_set_size_request(window, 400, -1);

        gtk_container_set_border_width(GTK_CONTAINER(window), 8);

        gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);

        gtk_window_set_modal(GTK_WINDOW(window), TRUE);

        gtk_window_set_policy(GTK_WINDOW(window), FALSE, TRUE, FALSE);

        g_signal_connect(G_OBJECT(window), "delete_event",

                         G_CALLBACK(query_search_save_dialog_deleted),

                         dialog);

        g_signal_connect(G_OBJECT(window), "key_press_event",

                         G_CALLBACK(query_search_save_dialog_key_pressed),

                         dialog);

        MANAGE_WINDOW_SIGNALS_CONNECT(window);

        manage_window_set_transient(GTK_WINDOW(window));

        vbox = gtk_vbox_new(FALSE, 8);

        gtk_container_add(GTK_CONTAINER(window), vbox);

        hbox = gtk_hbox_new(FALSE, 8);

        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        label = gtk_label_new(_("Location:"));

        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);

        folder_entry = gtk_entry_new();

        gtk_box_pack_start(GTK_BOX(hbox), folder_entry, TRUE, TRUE, 0);

        folder_btn = gtk_button_new_with_label("...");

        gtk_box_pack_start(GTK_BOX(hbox), folder_btn, FALSE, FALSE, 0);

        g_signal_connect(G_OBJECT(folder_btn), "clicked",

                         G_CALLBACK(query_search_save_dialog_select_folder),

                         dialog);

        hbox = gtk_hbox_new(FALSE, 8);

        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        label = gtk_label_new(_("Folder name:"));

        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);

        name_entry = gtk_entry_new();

        gtk_box_pack_start(GTK_BOX(hbox), name_entry, TRUE, TRUE, 0);

        g_signal_connect(G_OBJECT(name_entry), "activate",

                         G_CALLBACK(query_search_save_activated), dialog);

        confirm_area = gtk_hbox_new(FALSE, 12);

        gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);

        gtkut_stock_button_set_create(&hbbox,

                                      &ok_btn, GTK_STOCK_OK,

                                      &cancel_btn, GTK_STOCK_CANCEL,

                                      NULL, NULL);

        gtk_box_pack_end(GTK_BOX(confirm_area), hbbox, FALSE, FALSE, 0);

        GTK_WIDGET_SET_FLAGS(ok_btn, GTK_CAN_DEFAULT);

        gtk_widget_grab_default(ok_btn);

        g_signal_connect(G_OBJECT(ok_btn), "clicked",

                         G_CALLBACK(query_search_save_ok), dialog);

        g_signal_connect(G_OBJECT(cancel_btn), "clicked",

                         G_CALLBACK(query_search_save_cancel), dialog);

        gtk_widget_grab_focus(name_entry);

        gtk_widget_show_all(window);

        dialog->window = window;

        dialog->folder_entry = folder_entry;

        dialog->name_entry = name_entry;

        dialog->ok_btn = ok_btn;

        dialog->cancel_btn = cancel_btn;

        dialog->cancelled = FALSE;

        dialog->finished = FALSE;

        return dialog;

}

static void query_search_save_dialog_destroy(QuerySearchSaveDialog *dialog)

{

        gtk_widget_destroy(dialog->window);

        g_free(dialog);

}

static FolderItem *query_search_create_vfolder(FolderItem *parent,

                                               const gchar *name)

{

        gchar *path;

        gchar *fs_name;

        gchar *fullpath;

        FolderItem *item;

        g_return_val_if_fail(parent != NULL, NULL);

        g_return_val_if_fail(name != NULL, NULL);

        path = folder_item_get_path(parent);

        fs_name = g_filename_from_utf8(name, -1, NULL, NULL, NULL);

        fullpath = g_strconcat(path, G_DIR_SEPARATOR_S,

                               fs_name ? fs_name : name, NULL);

        g_free(fs_name);

        g_free(path);

        if (make_dir_hier(fullpath) < 0) {

                g_free(fullpath);

                return NULL;

        }

        if (parent->path)

                path = g_strconcat(parent->path, "/", name, NULL);

        else

                path = g_strdup(name);

        item = folder_item_new(name, path);

        item->stype = F_VIRTUAL;

        item->no_sub = TRUE;

        folder_item_append(parent, item);

        g_free(path);

        return item;

}

static void query_search_vfolder_update_rule(FolderItem *item)

{

        GSList list;

        FilterRule *rule;

        gchar *file;

        gchar *path;

        rule = query_search_dialog_to_rule(item->name, NULL);

        list.data = rule;

        list.next = NULL;

        path = folder_item_get_path(item);

        file = g_strconcat(path, G_DIR_SEPARATOR_S, FILTER_LIST, NULL);

        filter_write_file(&list, file);

        g_free(file);

        g_free(path);

        filter_rule_free(rule);

}

static void query_search_save(GtkButton *button, gpointer data)

{

        QuerySearchSaveDialog *dialog;

        const gchar *id, *name;

        FolderItem *parent, *item;

        dialog = query_search_save_dialog_create();

        id = gtk_entry_get_text(GTK_ENTRY(search_window.folder_entry));

        if (id && *id)

                gtk_entry_set_text(GTK_ENTRY(dialog->folder_entry), id);

        while (!dialog->finished)

                gtk_main_iteration();

        if (dialog->cancelled) {

                query_search_save_dialog_destroy(dialog);

                return;

        }

        id = gtk_entry_get_text(GTK_ENTRY(dialog->folder_entry));

        parent = folder_find_item_from_identifier(id);

        name = gtk_entry_get_text(GTK_ENTRY(dialog->name_entry));

        if (parent && name && *name) {

                if (folder_find_child_item_by_name(parent, name)) {

                        alertpanel_error(_("The folder `%s' already exists."),

                                         name);

                } else {

                        item = query_search_create_vfolder(parent, name);

                        if (item) {

                                query_search_vfolder_update_rule(item);

                                folderview_append_item(folderview_get(),

                                                       NULL, item, TRUE);

                                folder_write_list();

                        }

                }

        }

        query_search_save_dialog_destroy(dialog);

}

static void query_search_close(GtkButton *button, gpointer data)

{

        if (search_window.on_search)

                search_window.cancelled = TRUE;

        gtk_widget_hide(search_window.window);

}

static void query_search_entry_activated(GtkWidget *widget, gpointer data)

{

        gtk_button_clicked(GTK_BUTTON(search_window.search_btn));

}

static gint query_search_deleted(GtkWidget *widget, GdkEventAny *event,

                                 gpointer data)

{

        gtk_button_clicked(GTK_BUTTON(search_window.close_btn));

        return TRUE;

}

static gboolean key_pressed(GtkWidget *widget, GdkEventKey *event,

                            gpointer data)

{

        if (event && event->keyval == GDK_Escape) {

                if (search_window.on_search)

                        gtk_button_clicked

                                (GTK_BUTTON(search_window.search_btn));

                else

                        gtk_button_clicked(GTK_BUTTON(search_window.close_btn));

                return TRUE;

        }

        return FALSE;

}

static gint query_search_cmp_by_folder(GtkTreeModel *model,

                                       GtkTreeIter *a, GtkTreeIter *b,

                                       gpointer data)

{

        gchar *folder_a = NULL, *folder_b = NULL;

        MsgInfo *msginfo_a = NULL, *msginfo_b = NULL;

        gint ret;

        gtk_tree_model_get(model, a, COL_FOLDER, &folder_a, COL_MSGINFO,

                           &msginfo_a, -1);

        gtk_tree_model_get(model, b, COL_FOLDER, &folder_b, COL_MSGINFO,

                           &msginfo_b, -1);

        if (!folder_a || !folder_b || !msginfo_a || !msginfo_b)

                return 0;

        ret = g_ascii_strcasecmp(folder_a, folder_b);

        return (ret != 0) ? ret : (msginfo_a->date_t - msginfo_b->date_t);

}

static gint query_search_cmp_by_subject(GtkTreeModel *model,

                                        GtkTreeIter *a, GtkTreeIter *b,

                                        gpointer data)

{

        MsgInfo *msginfo_a = NULL, *msginfo_b = NULL;

        gint ret;

        gtk_tree_model_get(model, a, COL_MSGINFO, &msginfo_a, -1);

        gtk_tree_model_get(model, b, COL_MSGINFO, &msginfo_b, -1);

        if (!msginfo_a || !msginfo_b)

                return 0;

        if (!msginfo_a->subject)

                return -(msginfo_b->subject != NULL);

        if (!msginfo_b->subject)

                return (msginfo_a->subject != NULL);

        ret = subject_compare_for_sort(msginfo_a->subject, msginfo_b->subject);

        return (ret != 0) ? ret : (msginfo_a->date_t - msginfo_b->date_t);

}

static gint query_search_cmp_by_from(GtkTreeModel *model,

                                     GtkTreeIter *a, GtkTreeIter *b,

                                     gpointer data)

{

        MsgInfo *msginfo_a = NULL, *msginfo_b = NULL;

        gint ret;

        gtk_tree_model_get(model, a, COL_MSGINFO, &msginfo_a, -1);

        gtk_tree_model_get(model, b, COL_MSGINFO, &msginfo_b, -1);

        if (!msginfo_a || !msginfo_b)

                return 0;

        if (!msginfo_a->fromname)

                return -(msginfo_b->fromname != NULL);

        if (!msginfo_b->fromname)

                return (msginfo_a->fromname != NULL);

        ret = g_ascii_strcasecmp(msginfo_a->fromname, msginfo_b->fromname);

        return (ret != 0) ? ret : (msginfo_a->date_t - msginfo_b->date_t);

}

static gint query_search_cmp_by_date(GtkTreeModel *model,

                                     GtkTreeIter *a, GtkTreeIter *b,

                                     gpointer data)

{

        MsgInfo *msginfo_a = NULL, *msginfo_b = NULL;

        gtk_tree_model_get(model, a, COL_MSGINFO, &msginfo_a, -1);

        gtk_tree_model_get(model, b, COL_MSGINFO, &msginfo_b, -1);

        if (!msginfo_a || !msginfo_b)

                return 0;

        return msginfo_a->date_t - msginfo_b->date_t;

}