/*
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
- * Copyright (C) 1999-2001 Hiroyuki Yamamoto
+ * Copyright (C) 1999-2002 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
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-
#include "defs.h"
#include <glib.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/stat.h>
+#include <regex.h>
#include "intl.h"
#include "main.h"
#include "sourcewindow.h"
#include "prefs_common.h"
#include "prefs_summary_column.h"
+#include "prefs_filter.h"
#include "account.h"
#include "compose.h"
#include "utils.h"
#include "gtkutils.h"
+#include "stock_pixmap.h"
#include "filesel.h"
#include "manage_window.h"
#include "alertpanel.h"
#include "folder.h"
#include "colorlabel.h"
#include "inc.h"
+#include "imap.h"
#include "addressbook.h"
#include "addr_compl.h"
#include "scoring.h"
#include "prefs_folder_item.h"
#include "filtering.h"
-
-#include "pixmaps/dir-open.xpm"
-#include "pixmaps/mark.xpm"
-#include "pixmaps/deleted.xpm"
-#include "pixmaps/new.xpm"
-#include "pixmaps/unread.xpm"
-#include "pixmaps/replied.xpm"
-#include "pixmaps/forwarded.xpm"
-#include "pixmaps/clip.xpm"
-#include "pixmaps/ignorethread.xpm"
+#include "string_match.h"
#define STATUSBAR_PUSH(mainwin, str) \
{ \
#define SUMMARY_COL_MARK_WIDTH 10
#define SUMMARY_COL_UNREAD_WIDTH 13
-#define SUMMARY_COL_MIME_WIDTH 10
+#define SUMMARY_COL_LOCKED_WIDTH 13
+#define SUMMARY_COL_MIME_WIDTH 11
static GdkFont *boldfont;
static GdkFont *smallfont;
static GtkStyle *small_marked_style;
static GtkStyle *small_deleted_style;
-static GdkPixmap *folderxpm;
-static GdkBitmap *folderxpmmask;
-
static GdkPixmap *markxpm;
static GdkBitmap *markxpmmask;
static GdkPixmap *deletedxpm;
static GdkBitmap *forwardedxpmmask;
static GdkPixmap *ignorethreadxpm;
static GdkBitmap *ignorethreadxpmmask;
+static GdkPixmap *lockedxpm;
+static GdkBitmap *lockedxpmmask;
static GdkPixmap *clipxpm;
static GdkBitmap *clipxpmmask;
+static GdkPixmap *keyxpm;
+static GdkBitmap *keyxpmmask;
+static GdkPixmap *clipkeyxpm;
+static GdkBitmap *clipkeyxpmmask;
static void summary_free_msginfo_func (GtkCTree *ctree,
GtkCTreeNode *node,
static void summary_set_menu_sensitive (SummaryView *summaryview);
+static void summary_set_hide_read_msgs_menu (SummaryView *summaryview,
+ guint action);
+
static guint summary_get_msgnum (SummaryView *summaryview,
GtkCTreeNode *node);
/* display functions */
static void summary_status_show (SummaryView *summaryview);
+static void summary_set_column_titles (SummaryView *summaryview);
static void summary_set_ctree_from_list (SummaryView *summaryview,
GSList *mlist);
static void summary_set_header (SummaryView *summaryview,
static void summary_display_msg (SummaryView *summaryview,
GtkCTreeNode *row,
gboolean new_window);
-static void summary_toggle_view (SummaryView *summaryview);
+
static void summary_set_row_marks (SummaryView *summaryview,
GtkCTreeNode *row);
+static void summaryview_subject_filter_init (PrefsFolderItem *prefs);
/* message handling */
static void summary_mark_row (SummaryView *summaryview,
GtkCTreeNode *row);
+static void summary_lock_row (SummaryView *summaryview,
+ GtkCTreeNode *row);
static void summary_mark_row_as_read (SummaryView *summaryview,
GtkCTreeNode *row);
static void summary_mark_row_as_unread (SummaryView *summaryview,
GtkCTreeNode *node,
gpointer data);
+void summary_simplify_subject(SummaryView *summaryview, gchar * rexp,
+ GSList * mlist);
+
+void summary_processing(SummaryView *summaryview, GSList * mlist);
static void summary_filter_func (GtkCTree *ctree,
GtkCTreeNode *node,
gpointer data);
static GtkWidget *summary_ctree_create (SummaryView *summaryview);
+static void summary_toggle_view(SummaryView *summarview);
+
/* callback functions */
-static void summary_toggle_pressed (GtkWidget *eventbox,
- GdkEventButton *event,
- SummaryView *summaryview);
+static void summary_toggle_view_cb (GtkWidget *widget,
+ gpointer data);
static void summary_button_pressed (GtkWidget *ctree,
GdkEventButton *event,
SummaryView *summaryview);
SummaryView *summaryview);
static void summary_score_clicked (GtkWidget *button,
SummaryView *summaryview);
+static void summary_locked_clicked (GtkWidget *button,
+ SummaryView *summaryview);
static void summary_start_drag (GtkWidget *widget,
int button,
static gint summary_cmp_by_score (GtkCList *clist,
gconstpointer ptr1,
gconstpointer ptr2);
+static gint summary_cmp_by_locked (GtkCList *clist,
+ gconstpointer ptr1, gconstpointer ptr2);
static gint summary_cmp_by_label (GtkCList *clist,
gconstpointer ptr1,
gconstpointer ptr2);
-#if MARK_ALL_READ
-static void summary_mark_all_read (SummaryView *summaryview);
-#endif
-
GtkTargetEntry summary_drag_types[1] =
{
{"text/plain", GTK_TARGET_SAME_APP, TARGET_DUMMY}
{N_("/Follow-up and reply to"), NULL, summary_reply_cb, COMPOSE_FOLLOWUP_AND_REPLY_TO, NULL},
{N_("/Reply to a_ll"), NULL, summary_reply_cb, COMPOSE_REPLY_TO_ALL, NULL},
{N_("/_Forward"), NULL, summary_reply_cb, COMPOSE_FORWARD, NULL},
- {N_("/Forward as a_ttachment"),
- NULL, summary_reply_cb, COMPOSE_FORWARD_AS_ATTACH, NULL},
+ {N_("/Bounce"), NULL, summary_reply_cb, COMPOSE_BOUNCE, NULL},
{N_("/---"), NULL, NULL, 0, "<Separator>"},
{N_("/Re-_edit"), NULL, summary_reedit, 0, NULL},
{N_("/---"), NULL, NULL, 0, "<Separator>"},
{N_("/_Mark/---"), NULL, NULL, 0, "<Separator>"},
{N_("/_Mark/Mark as unr_ead"), NULL, summary_mark_as_unread, 0, NULL},
{N_("/_Mark/Mark as rea_d"), NULL, summary_mark_as_read, 0, NULL},
- {N_("/_Mark/Mark all read"), NULL, summary_mark_all_read, 0, NULL},
{N_("/_Mark/Ignore thread"), NULL, summary_ignore_thread, 0, NULL},
{N_("/_Mark/Unignore thread"), NULL, summary_unignore_thread, 0, NULL},
{N_("/Color la_bel"), NULL, NULL, 0, NULL},
N_("Date"), /* S_COL_DATE */
N_("Size"), /* S_COL_SIZE */
N_("No."), /* S_COL_NUMBER */
- N_("Score") /* S_COL_SCORE */
+ N_("Score"), /* S_COL_SCORE */
+ N_("L") /* S_COL_LOCKED */
};
SummaryView *summary_create(void)
GtkWidget *statlabel_folder;
GtkWidget *statlabel_select;
GtkWidget *statlabel_msgs;
- GtkWidget *toggle_eventbox;
- GtkWidget *toggle_arrow;
+ GtkWidget *toggle_view_btn;
+ GtkWidget *toggle_view_arrow;
GtkWidget *popupmenu;
GtkItemFactory *popupfactory;
gint n_entries;
statlabel_select = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(hbox), statlabel_select, FALSE, FALSE, 16);
- /* toggle view button */
- toggle_eventbox = gtk_event_box_new();
- gtk_box_pack_end(GTK_BOX(hbox), toggle_eventbox, FALSE, FALSE, 4);
- toggle_arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT);
- gtk_container_add(GTK_CONTAINER(toggle_eventbox), toggle_arrow);
- gtk_signal_connect(GTK_OBJECT(toggle_eventbox), "button_press_event",
- GTK_SIGNAL_FUNC(summary_toggle_pressed),
- summaryview);
+ /* toggle view buttons */
+ toggle_view_btn = gtk_button_new();
+ gtk_box_pack_end(GTK_BOX(hbox), toggle_view_btn, FALSE, FALSE, 0);
+ gtk_button_set_relief(GTK_BUTTON(toggle_view_btn), GTK_RELIEF_NONE);
+ toggle_view_arrow=gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT);
+ gtk_container_add(GTK_CONTAINER(toggle_view_btn), toggle_view_arrow);
+ gtk_signal_connect(GTK_OBJECT(toggle_view_btn), "clicked",
+ GTK_SIGNAL_FUNC(summary_toggle_view_cb), summaryview);
statlabel_msgs = gtk_label_new("");
gtk_box_pack_end(GTK_BOX(hbox), statlabel_msgs, FALSE, FALSE, 4);
summaryview->statlabel_folder = statlabel_folder;
summaryview->statlabel_select = statlabel_select;
summaryview->statlabel_msgs = statlabel_msgs;
- summaryview->toggle_eventbox = toggle_eventbox;
- summaryview->toggle_arrow = toggle_arrow;
+ summaryview->toggle_view_btn = toggle_view_btn;
+ summaryview->toggle_view_arrow = toggle_view_arrow;
summaryview->popupmenu = popupmenu;
summaryview->popupfactory = popupfactory;
summaryview->msg_is_toggled_on = TRUE;
GtkStyle *style;
GtkWidget *pixmap;
- PIXMAP_CREATE(summaryview->ctree, markxpm, markxpmmask, mark_xpm);
- PIXMAP_CREATE(summaryview->ctree, deletedxpm, deletedxpmmask,
- deleted_xpm);
- PIXMAP_CREATE(summaryview->ctree, newxpm, newxpmmask, new_xpm);
- PIXMAP_CREATE(summaryview->ctree, unreadxpm, unreadxpmmask, unread_xpm);
- PIXMAP_CREATE(summaryview->ctree, repliedxpm, repliedxpmmask,
- replied_xpm);
- PIXMAP_CREATE(summaryview->ctree, forwardedxpm, forwardedxpmmask,
- forwarded_xpm);
- PIXMAP_CREATE(summaryview->ctree, ignorethreadxpm, ignorethreadxpmmask,
- ignorethread_xpm);
- PIXMAP_CREATE(summaryview->ctree, clipxpm, clipxpmmask, clip_xpm);
- PIXMAP_CREATE(summaryview->hbox, folderxpm, folderxpmmask,
- dir_open_xpm);
-
- pixmap = gtk_pixmap_new(clipxpm, clipxpmmask);
- gtk_clist_set_column_widget(GTK_CLIST(summaryview->ctree),
- summaryview->col_pos[S_COL_MIME], pixmap);
- gtk_widget_show(pixmap);
+ stock_pixmap_gdk(summaryview->ctree, STOCK_PIXMAP_MARK,
+ &markxpm, &markxpmmask);
+ stock_pixmap_gdk(summaryview->ctree, STOCK_PIXMAP_DELETED,
+ &deletedxpm, &deletedxpmmask);
+ stock_pixmap_gdk(summaryview->ctree, STOCK_PIXMAP_NEW,
+ &newxpm, &newxpmmask);
+ stock_pixmap_gdk(summaryview->ctree, STOCK_PIXMAP_UNREAD,
+ &unreadxpm, &unreadxpmmask);
+ stock_pixmap_gdk(summaryview->ctree, STOCK_PIXMAP_REPLIED,
+ &repliedxpm, &repliedxpmmask);
+ stock_pixmap_gdk(summaryview->ctree, STOCK_PIXMAP_FORWARDED,
+ &forwardedxpm, &forwardedxpmmask);
+ stock_pixmap_gdk(summaryview->ctree, STOCK_PIXMAP_CLIP,
+ &clipxpm, &clipxpmmask);
+ stock_pixmap_gdk(summaryview->ctree, STOCK_PIXMAP_LOCKED,
+ &lockedxpm, &lockedxpmmask);
+ stock_pixmap_gdk(summaryview->ctree, STOCK_PIXMAP_IGNORETHREAD,
+ &ignorethreadxpm, &ignorethreadxpmmask);
+ stock_pixmap_gdk(summaryview->ctree, STOCK_PIXMAP_CLIP_KEY,
+ &clipkeyxpm, &clipkeyxpmmask);
+ stock_pixmap_gdk(summaryview->ctree, STOCK_PIXMAP_KEY,
+ &keyxpm, &keyxpmmask);
if (!small_style) {
small_style = gtk_style_copy
gtk_widget_set_style(summaryview->statlabel_select, style);
gtk_widget_set_style(summaryview->statlabel_msgs, style);
- pixmap = gtk_pixmap_new(folderxpm, folderxpmmask);
+ pixmap = stock_pixmap_widget(summaryview->hbox, STOCK_PIXMAP_DIR_OPEN);
gtk_box_pack_start(GTK_BOX(summaryview->hbox), pixmap, FALSE, FALSE, 4);
gtk_box_reorder_child(GTK_BOX(summaryview->hbox), pixmap, 0);
gtk_widget_show(pixmap);
summary_clear_list(summaryview);
+ summary_set_column_titles(summaryview);
summary_colorlabel_menu_create(summaryview);
summary_set_menu_sensitive(summaryview);
return FALSE;
}
folder_update_op_count();
- }
- else if (!summaryview->filtering_happened) {
- summary_write_cache(summaryview);
- }
-
- summaryview->filtering_happened = FALSE;
-
+ } else {
+ /*
+ * CLAWS: summary_show() is responsible for updating the caches.
+ * after filtering inc.c::inc_finished() forces the update of
+ * the cache by indirectly calling summary_show() (by re-selecting
+ * the currently selected mail folder).
+ * this collides with the new filtering system that may have set
+ * any message flag before calling summary_show().
+ * we can prevent this cache-write by checking the opened member
+ * of the folderview. if this is NULL, the folderview forced
+ * an update of the summary view.
+ */
+ if (summaryview->folderview->opened)
+ summary_write_cache(summaryview);
+ }
+
summaryview->folderview->opened = selected_node;
gtk_clist_freeze(GTK_CLIST(ctree));
summary_clear_list(summaryview);
+ summary_set_column_titles(summaryview);
summary_set_menu_sensitive(summaryview);
if (!is_refresh)
messageview_clear(summaryview->messageview);
change_dir(buf) < 0))) {
g_free(buf);
debug_print(_("empty folder\n\n"));
+ summary_set_hide_read_msgs_menu(summaryview, FALSE);
if (is_refresh)
messageview_clear(summaryview->messageview);
summary_clear_all(summaryview);
mlist = item->folder->get_msg_list(item->folder, item, !update_cache);
+ summary_processing(summaryview, mlist);
+
for(cur = mlist ; cur != NULL ; cur = g_slist_next(cur)) {
MsgInfo * msginfo = (MsgInfo *) cur->data;
}
summaryview->killed_messages = NULL;
+
+ if (summaryview->folder_item->hide_read_msgs) {
+ GSList *not_killed;
+ gint kill_score;
+
+ summary_set_hide_read_msgs_menu(summaryview, TRUE);
+ not_killed = NULL;
+ for(cur = mlist ; cur != NULL ; cur = g_slist_next(cur)) {
+ MsgInfo * msginfo = (MsgInfo *) cur->data;
+
+ if ((MSG_IS_UNREAD(msginfo->flags)
+ || MSG_IS_MARKED(msginfo->flags)
+ || MSG_IS_LOCKED(msginfo->flags))
+ && !MSG_IS_IGNORE_THREAD(msginfo->flags))
+ not_killed = g_slist_append(not_killed, msginfo);
+ else
+ summaryview->killed_messages =
+ g_slist_append(summaryview->killed_messages, msginfo);
+ }
+ g_slist_free(mlist);
+ mlist = not_killed;
+ } else {
+ summary_set_hide_read_msgs_menu(summaryview, FALSE);
+ }
+
if ((global_scoring || item->prefs->scoring) &&
(item->folder->type == F_NEWS)) {
GSList *not_killed;
}
summary_status_show(summaryview);
-
summary_set_menu_sensitive(summaryview);
-
main_window_set_toolbar_sensitive(summaryview->mainwin);
debug_print("\n");
menu_set_sensitive(ifactory, "/Mark/Mark as unread", TRUE);
menu_set_sensitive(ifactory, "/Mark/Mark as read", TRUE);
- menu_set_sensitive(ifactory, "/Mark/Mark all read", TRUE);
menu_set_sensitive(ifactory, "/Mark/Ignore thread", TRUE);
menu_set_sensitive(ifactory, "/Mark/Unignore thread", TRUE);
menu_set_sensitive(ifactory, "/Reply to sender", sens);
menu_set_sensitive(ifactory, "/Reply to all", sens);
menu_set_sensitive(ifactory, "/Forward", TRUE);
- menu_set_sensitive(ifactory, "/Forward as attachment", TRUE);
+ menu_set_sensitive(ifactory, "/Bounce", TRUE);
menu_set_sensitive(ifactory, "/Add sender to address book", sens);
void summary_select_next_unread(SummaryView *summaryview)
{
- GtkCTreeNode *node;
+ GtkCTreeNode *node = summaryview->selected;
GtkCTree *ctree = GTK_CTREE(summaryview->ctree);
- node = summary_find_next_unread_msg(summaryview, summaryview->selected);
-
- if (node) {
- gtkut_ctree_expand_parent_all(ctree, node);
- gtk_sctree_unselect_all(GTK_SCTREE(ctree));
- gtk_sctree_select(GTK_SCTREE(ctree), node);
- if (summaryview->displayed == node)
- summaryview->displayed = NULL;
- summary_display_msg(summaryview, node, FALSE);
- } else {
+ while ((node = summary_find_next_unread_msg(summaryview, node)) == NULL) {
AlertValue val;
switch (prefs_common.next_unread_msg_dialog) {
val = alertpanel(_("No more unread messages"),
_("No unread message found. "
"Go to next folder?"),
- _("Yes"), _("No"), NULL);
+ _("Yes"), _("Search again"), _("No"));
break;
case NEXTUNREADMSGDIALOG_ASSUME_YES:
val = G_ALERTDEFAULT;
(GTK_OBJECT(ctree),
"key_press_event");
folderview_select_next_unread(summaryview->folderview);
- }
+ return;
+ } else if (val == G_ALERTALTERNATE)
+ node = NULL;
+ else
+ return;
+ }
+
+ if (node) {
+ gtkut_ctree_expand_parent_all(ctree, node);
+ gtk_sctree_unselect_all(GTK_SCTREE(ctree));
+ gtk_sctree_select(GTK_SCTREE(ctree), node);
+ if (summaryview->displayed == node)
+ summaryview->displayed = NULL;
+ summary_display_msg(summaryview, node, FALSE);
}
}
for (; node != NULL; node = GTK_CTREE_NODE_PREV(node)) {
msginfo = gtk_ctree_node_get_row_data(ctree, node);
- if (!MSG_IS_DELETED(msginfo->flags)) break;
+ if (!MSG_IS_DELETED(msginfo->flags))
+ break;
}
return node;
for (; node != NULL; node = gtkut_ctree_node_next(ctree, node)) {
msginfo = gtk_ctree_node_get_row_data(ctree, node);
- if (!MSG_IS_DELETED(msginfo->flags)) break;
+ if (!MSG_IS_DELETED(msginfo->flags))
+ break;
}
return node;
gchar *del, *mv, *cp;
gchar *sel;
gchar *spc;
+ gchar *itstr;
GList *rowlist, *cur;
guint n_selected = 0;
off_t sel_size = 0;
else
spc = "";
- if (n_selected)
+ if (n_selected) {
sel = g_strdup_printf(" (%s)", to_human_readable(sel_size));
- else
+ if (n_selected == 1)
+ itstr = g_strdup(_(" item selected"));
+ else
+ itstr = g_strdup(_(" items selected"));
+ } else {
sel = g_strdup("");
+ itstr = g_strdup("");
+ }
+
str = g_strconcat(n_selected ? itos(n_selected) : "",
- n_selected ? _(" item(s) selected") : "",
- sel, spc, del, mv, cp, NULL);
+ itstr, sel, spc, del, mv, cp, NULL);
gtk_label_set(GTK_LABEL(summaryview->statlabel_select), str);
g_free(str);
g_free(sel);
g_free(del);
g_free(mv);
g_free(cp);
+ g_free(itstr);
if (summaryview->folder_item &&
FOLDER_IS_LOCAL(summaryview->folder_item->folder)) {
summaryview->messages);
}
+static void summary_set_column_titles(SummaryView *summaryview)
+{
+ GtkCList *clist = GTK_CLIST(summaryview->ctree);
+ GtkWidget *hbox;
+ GtkWidget *label;
+ GtkWidget *arrow;
+ gint pos;
+ const gchar *title;
+ SummaryColumnType type;
+ gboolean single_char;
+ GtkJustification justify;
+
+ static SummarySortType sort_by[N_SUMMARY_COLS] = {
+ SORT_BY_MARK,
+ SORT_BY_UNREAD,
+ SORT_BY_MIME,
+ SORT_BY_SUBJECT,
+ SORT_BY_FROM,
+ SORT_BY_DATE,
+ SORT_BY_SIZE,
+ SORT_BY_NUMBER,
+ SORT_BY_SCORE,
+ SORT_BY_LOCKED
+ };
+
+ for (pos = 0; pos < N_SUMMARY_COLS; pos++) {
+ type = summaryview->col_state[pos].type;
+
+ /* CLAWS: mime and unread are single char headers */
+ single_char = (type == S_COL_MIME || type == S_COL_UNREAD);
+ justify = (type == S_COL_NUMBER || type == S_COL_SIZE)
+ ? GTK_JUSTIFY_RIGHT : GTK_JUSTIFY_LEFT;
+
+ switch (type) {
+ case S_COL_SUBJECT:
+ case S_COL_FROM:
+ case S_COL_DATE:
+ case S_COL_NUMBER:
+ if (prefs_common.trans_hdr)
+ title = gettext(col_label[type]);
+ else
+ title = col_label[type];
+ break;
+ /* CLAWS: dummies for mark and locked headers */
+ case S_COL_MARK:
+ case S_COL_LOCKED:
+ title = "";
+ break;
+ default:
+ title = gettext(col_label[type]);
+ }
+
+ if (type == S_COL_MIME) {
+ label = gtk_pixmap_new(clipxpm, clipxpmmask);
+ gtk_widget_show(label);
+ gtk_clist_set_column_widget(clist, pos, label);
+ continue;
+ }
+ if (single_char) {
+ gtk_clist_set_column_title(clist, pos, title);
+ continue;
+ }
+
+ /* CLAWS: changed so that locked and mark headers
+ * show a pixmap instead of single character */
+ hbox = gtk_hbox_new(FALSE, 4);
+
+ if (type == S_COL_LOCKED)
+ label = gtk_pixmap_new(lockedxpm, lockedxpmmask);
+ else if (type == S_COL_MARK)
+ label = gtk_pixmap_new(markxpm, markxpmmask);
+ else
+ label = gtk_label_new(title);
+
+ if (justify == GTK_JUSTIFY_RIGHT)
+ gtk_box_pack_end(GTK_BOX(hbox), label,
+ FALSE, FALSE, 0);
+ else
+ gtk_box_pack_start(GTK_BOX(hbox), label,
+ FALSE, FALSE, 0);
+
+ if (summaryview->sort_mode == sort_by[type]) {
+ arrow = gtk_arrow_new
+ (summaryview->sort_type == GTK_SORT_ASCENDING
+ ? GTK_ARROW_DOWN : GTK_ARROW_UP,
+ GTK_SHADOW_IN);
+ if (justify == GTK_JUSTIFY_RIGHT)
+ gtk_box_pack_start(GTK_BOX(hbox), arrow,
+ FALSE, FALSE, 0);
+ else
+ gtk_box_pack_end(GTK_BOX(hbox), arrow,
+ FALSE, FALSE, 0);
+ }
+
+ gtk_widget_show_all(hbox);
+ gtk_clist_set_column_widget(clist, pos, hbox);
+ }
+}
+
void summary_sort(SummaryView *summaryview, SummarySortType type)
{
GtkCTree *ctree = GTK_CTREE(summaryview->ctree);
case SORT_BY_SCORE:
cmp_func = (GtkCListCompareFunc)summary_cmp_by_score;
break;
+ case SORT_BY_LOCKED:
+ cmp_func = (GtkCListCompareFunc)summary_cmp_by_locked;
+ break;
case SORT_BY_LABEL:
cmp_func = (GtkCListCompareFunc)summary_cmp_by_label;
break;
gtk_clist_set_sort_type(clist, summaryview->sort_type);
summaryview->sort_mode = type;
- gtk_ctree_sort_node(ctree, NULL);
+ summary_set_column_titles(summaryview);
- gtk_ctree_node_moveto(ctree, summaryview->selected, -1, 0.5, 0);
- /*gtkut_ctree_set_focus_row(ctree, summaryview->selected);*/
+ gtk_ctree_sort_recursive(ctree, NULL);
+ gtk_ctree_node_moveto(ctree, summaryview->selected, -1, 0.5, 0);
prefs_folder_item_set_config(summaryview->folder_item,
summaryview->sort_type,
summaryview->sort_mode);
return TRUE;
}
-static GtkCTreeNode * subject_table_lookup(GHashTable *subject_table,
- gchar * subject)
-{
- if (g_strncasecmp(subject, "Re: ", 4) == 0)
- return g_hash_table_lookup(subject_table, subject + 4);
- else
- return g_hash_table_lookup(subject_table, subject);
-}
-
-static void subject_table_insert(GHashTable *subject_table, gchar * subject,
- GtkCTreeNode * node)
-{
- if (g_strncasecmp(subject, "Re: ", 4) == 0)
- g_hash_table_insert(subject_table, subject + 4, node);
- else
- g_hash_table_insert(subject_table, subject, node);
-}
-
static void summary_set_ctree_from_list(SummaryView *summaryview,
GSList *mlist)
{
summaryview->important_score =
summaryview->folder_item->prefs->important_score;
}
+
+ summaryview_subject_filter_init(summaryview->folder_item->prefs);
if (summaryview->folder_item->threaded) {
GNode *root, *gnode;
if (msginfo->msgid)
g_hash_table_insert(msgid_table,
msginfo->msgid, node);
+
+ subject_table_insert(subject_table,
+ msginfo->subject,
+ node);
}
mlist = g_slist_reverse(mlist);
}
static gchar *from_name = NULL;
static gchar col_number[11];
static gchar col_score[11];
+ static gchar buf[BUFFSIZE];
+ PrefsFolderItem *prefs = summaryview->folder_item->prefs;
gint *col_pos = summaryview->col_pos;
text[col_pos[S_COL_MARK]] = NULL;
text[col_pos[S_COL_UNREAD]] = NULL;
text[col_pos[S_COL_MIME]] = NULL;
+ text[col_pos[S_COL_LOCKED]] = NULL;
text[col_pos[S_COL_NUMBER]] = itos(msginfo->msgnum);
text[col_pos[S_COL_SIZE]] = to_human_readable(msginfo->size);
text[col_pos[S_COL_SCORE]] = itos_buf(col_score, msginfo->threadscore);
#else
text[col_pos[S_COL_SCORE]] = itos_buf(col_score, msginfo->score);
-#endif
+#endif
if (msginfo->date_t) {
procheader_date_get_localtime(date_modified,
!MSG_IS_NEWS(msginfo->flags)) {
gchar *from;
- Xalloca(from, strlen(msginfo->from) + 1, return);
- strcpy(from, msginfo->from);
+ Xstrdup_a(from, msginfo->from, return);
extract_address(from);
if (account_find_from_address(from)) {
g_free(to);
}
}
- if ((text[S_COL_FROM] != to) && prefs_common.use_addr_book &&
+ if ((text[col_pos[S_COL_FROM]] != to) && prefs_common.use_addr_book &&
msginfo->from) {
gint count;
gchar *from;
- Xalloca(from, strlen(msginfo->from) + 1, return);
- strcpy(from, msginfo->from);
+ Xstrdup_a(from, msginfo->from, return);
extract_address(from);
if (*from) {
count = complete_address(from);
from = get_complete_address(1);
from_name = procheader_get_fromname(from);
g_free(from);
- text[S_COL_FROM] = from_name;
+ text[col_pos[S_COL_FROM]] = from_name;
}
}
}
- text[col_pos[S_COL_SUBJECT]] = msginfo->subject ? msginfo->subject :
- _("(No Subject)");
+ if (prefs->enable_simplify_subject
+ && prefs->simplify_subject_preg != NULL )
+ text[col_pos[S_COL_SUBJECT]] = msginfo->subject ?
+ string_remove_match(buf, BUFFSIZE, msginfo->subject,
+ prefs->simplify_subject_preg) :
+
+ _("(No Subject)");
+ else
+ text[col_pos[S_COL_SUBJECT]] = msginfo->subject ? msginfo->subject :
+ _("(No Subject)");
}
#define CHANGE_FLAGS(msginfo) \
{
GtkCTree *ctree = GTK_CTREE(summaryview->ctree);
MsgInfo *msginfo;
+ MsgFlags flags;
gchar *filename;
if (!new_window && summaryview->displayed == row) return;
summaryview->newmsgs--;
if (MSG_IS_UNREAD(msginfo->flags) && !MSG_IS_IGNORE_THREAD(msginfo->flags))
summaryview->unread--;
- if (MSG_IS_NEW(msginfo->flags) || MSG_IS_UNREAD(msginfo->flags)) {
+ if (MSG_IS_NEW(msginfo->flags) && !MSG_IS_IGNORE_THREAD(msginfo->flags) ||
+ MSG_IS_UNREAD(msginfo->flags) && !MSG_IS_IGNORE_THREAD(msginfo->flags)) {
MSG_UNSET_PERM_FLAGS(msginfo->flags, MSG_NEW | MSG_UNREAD);
- CHANGE_FLAGS(msginfo);
+ if (MSG_IS_IMAP(msginfo->flags))
+ imap_msg_unset_perm_flags(msginfo, MSG_NEW | MSG_UNREAD);
summary_set_row_marks(summaryview, row);
gtk_clist_thaw(GTK_CLIST(ctree));
summary_status_show(summaryview);
}
+ flags = msginfo->flags;
+
if (new_window) {
MessageView *msgview;
gtkut_ctree_node_move_if_on_the_edge(ctree, row);
}
+ if (MSG_IS_NEW(msginfo->flags) || MSG_IS_UNREAD(msginfo->flags) ||
+ (MSG_IS_MIME(msginfo->flags) - MSG_IS_MIME(flags) != 0)) {
+ MSG_UNSET_PERM_FLAGS(msginfo->flags, MSG_NEW | MSG_UNREAD);
+ CHANGE_FLAGS(msginfo);
+ summary_set_row_marks(summaryview, row);
+ gtk_clist_thaw(GTK_CLIST(ctree));
+ summary_status_show(summaryview);
+ }
+
if (GTK_WIDGET_VISIBLE(summaryview->headerwin->window))
header_window_show(summaryview->headerwin, msginfo);
}
static void summary_toggle_view(SummaryView *summaryview)
+{
+ MainWindow *mainwin = summaryview->mainwin;
+ GtkItemFactory *ifactory;
+
+ if (!mainwin) return;
+
+ ifactory = gtk_item_factory_from_widget(mainwin->menubar);
+ menu_toggle_toggle(ifactory, "/View/Expand Summary View");
+}
+
+void summary_toggle_view_real(SummaryView *summaryview)
{
MainWindow *mainwin = summaryview->mainwin;
union CompositeWin *cwin = &mainwin->win;
GtkWidget *vpaned = NULL;
GtkWidget *container = NULL;
-
+ GtkWidget *toggle_view_btn;
+ GtkWidget *toggle_view_arrow;
+ GtkItemFactory *ifactory = gtk_item_factory_from_widget(mainwin->menubar);
+
switch (mainwin->type) {
case SEPARATE_NONE:
vpaned = cwin->sep_none.vpaned;
summaryview->msg_is_toggled_on = FALSE;
summaryview->displayed = NULL;
gtk_widget_ref(vpaned);
- gtk_container_remove(GTK_CONTAINER(container), vpaned);
+ gtkut_container_remove(GTK_CONTAINER(container), vpaned);
gtk_widget_reparent(GTK_WIDGET_PTR(summaryview), container);
- gtk_arrow_set(GTK_ARROW(summaryview->toggle_arrow),
- GTK_ARROW_UP, GTK_SHADOW_OUT);
+
+ gtk_widget_destroy(summaryview->toggle_view_arrow);
+ gtk_widget_destroy(summaryview->toggle_view_btn);
+
+ toggle_view_btn = gtk_button_new();
+ gtk_box_pack_end(GTK_BOX(summaryview->hbox), toggle_view_btn, FALSE, FALSE, 0);
+ gtk_box_reorder_child(GTK_BOX(summaryview->hbox), toggle_view_btn, 0);
+ gtk_button_set_relief(GTK_BUTTON(toggle_view_btn), GTK_RELIEF_NONE);
+ toggle_view_arrow=gtk_arrow_new(GTK_ARROW_UP, GTK_SHADOW_OUT);
+ gtk_container_add(GTK_CONTAINER(toggle_view_btn), toggle_view_arrow);
+ gtk_signal_connect(GTK_OBJECT(toggle_view_btn), "clicked",
+ GTK_SIGNAL_FUNC(summary_toggle_view_cb), summaryview);
+ gtk_widget_show_all(toggle_view_btn);
+ menu_set_sensitive(ifactory, "/View/Expand Message View", FALSE);
} else {
summaryview->msg_is_toggled_on = TRUE;
gtk_widget_reparent(GTK_WIDGET_PTR(summaryview), vpaned);
gtk_container_add(GTK_CONTAINER(container), vpaned);
gtk_widget_unref(vpaned);
- gtk_arrow_set(GTK_ARROW(summaryview->toggle_arrow),
- GTK_ARROW_DOWN, GTK_SHADOW_OUT);
+
+ gtk_widget_destroy(summaryview->toggle_view_arrow);
+ gtk_widget_destroy(summaryview->toggle_view_btn);
+
+ toggle_view_btn = gtk_button_new();
+ gtk_box_pack_end(GTK_BOX(summaryview->hbox), toggle_view_btn, FALSE, FALSE, 0);
+ gtk_box_reorder_child(GTK_BOX(summaryview->hbox), toggle_view_btn, 0);
+ gtk_button_set_relief(GTK_BUTTON(toggle_view_btn), GTK_RELIEF_NONE);
+ toggle_view_arrow=gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT);
+ gtk_container_add(GTK_CONTAINER(toggle_view_btn), toggle_view_arrow);
+ gtk_signal_connect(GTK_OBJECT(toggle_view_btn), "clicked",
+ GTK_SIGNAL_FUNC(summary_toggle_view_cb), summaryview);
+ gtk_widget_show_all(toggle_view_btn);
+ menu_set_sensitive(ifactory, "/View/Expand Message View", TRUE);
}
gtk_widget_grab_focus(summaryview->ctree);
+
+ summaryview->toggle_view_btn = toggle_view_btn;
+ summaryview->toggle_view_arrow = toggle_view_arrow;
}
static gboolean summary_search_unread_recursive(GtkCTree *ctree,
gtk_ctree_node_set_text(ctree, row, col_pos[S_COL_MARK], NULL);
}
- if (MSG_IS_MIME(flags)) {
+ if (MSG_IS_LOCKED(flags)) {
+ gtk_ctree_node_set_pixmap(ctree, row, col_pos[S_COL_LOCKED],
+ lockedxpm, lockedxpmmask);
+ }
+ else {
+ gtk_ctree_node_set_text(ctree, row, col_pos[S_COL_LOCKED], NULL);
+ }
+
+ if (MSG_IS_MIME(flags) && MSG_IS_ENCRYPTED(flags)) {
+ gtk_ctree_node_set_pixmap(ctree, row, col_pos[S_COL_MIME],
+ clipkeyxpm, clipkeyxpmmask);
+ } else if (MSG_IS_ENCRYPTED(flags)) {
+ gtk_ctree_node_set_pixmap(ctree, row, col_pos[S_COL_MIME],
+ keyxpm, keyxpmmask);
+ } else if (MSG_IS_MIME(flags)) {
gtk_ctree_node_set_pixmap(ctree, row, col_pos[S_COL_MIME],
clipxpm, clipxpmmask);
} else {
void summary_set_marks_selected(SummaryView *summaryview)
{
- summary_set_row_marks(summaryview, summaryview->selected);
+ GtkCTree *ctree = GTK_CTREE(summaryview->ctree);
+ GList *cur;
+
+ for (cur = GTK_CLIST(ctree)->selection; cur != NULL; cur = cur->next)
+ summary_set_row_marks(summaryview, GTK_CTREE_NODE(cur->data));
}
static void summary_mark_row(SummaryView *summaryview, GtkCTreeNode *row)
MSG_UNSET_PERM_FLAGS(msginfo->flags, MSG_DELETED);
MSG_UNSET_TMP_FLAGS(msginfo->flags, MSG_MOVE | MSG_COPY);
MSG_SET_PERM_FLAGS(msginfo->flags, MSG_MARKED);
+ if (MSG_IS_IMAP(msginfo->flags))
+ imap_msg_set_perm_flags(msginfo, MSG_MARKED);
+ CHANGE_FLAGS(msginfo);
+ summary_set_row_marks(summaryview, row);
+ debug_print(_("Message %s/%d is marked\n"), msginfo->folder->path, msginfo->msgnum);
+}
+
+static void summary_lock_row(SummaryView *summaryview, GtkCTreeNode *row)
+{
+ /* almost verbatim summary_mark_row(); may want a menu action? */
+ gboolean changed = FALSE;
+ GtkCTree *ctree = GTK_CTREE(summaryview->ctree);
+ MsgInfo *msginfo;
+
+ msginfo = gtk_ctree_node_get_row_data(ctree, row);
+ if (MSG_IS_DELETED(msginfo->flags))
+ summaryview->deleted--;
+ if (MSG_IS_MOVE(msginfo->flags)) {
+ summaryview->moved--;
+ changed = TRUE;
+ }
+ if (MSG_IS_COPY(msginfo->flags)) {
+ summaryview->copied--;
+ changed = TRUE;
+ }
+ if (changed && !prefs_common.immediate_exec) {
+ msginfo->to_folder->op_count--;
+ if (msginfo->to_folder->op_count == 0)
+ folderview_update_item(msginfo->to_folder, 0);
+ }
+ msginfo->to_folder = NULL;
+ MSG_UNSET_PERM_FLAGS(msginfo->flags, MSG_DELETED);
+ MSG_UNSET_TMP_FLAGS(msginfo->flags, MSG_MOVE | MSG_COPY);
+ MSG_SET_PERM_FLAGS(msginfo->flags, MSG_LOCKED);
+ if (MSG_IS_IMAP(msginfo->flags))
+ imap_msg_set_perm_flags(msginfo, MSG_LOCKED);
CHANGE_FLAGS(msginfo);
summary_set_row_marks(summaryview, row);
- debug_print(_("Message %d is marked\n"), msginfo->msgnum);
+ debug_print(_("Message %d is locked\n"), msginfo->msgnum);
}
void summary_mark(SummaryView *summaryview)
if (MSG_IS_NEW(msginfo->flags) ||
MSG_IS_UNREAD(msginfo->flags)) {
MSG_UNSET_PERM_FLAGS(msginfo->flags, MSG_NEW | MSG_UNREAD);
+ if (MSG_IS_IMAP(msginfo->flags))
+ imap_msg_unset_perm_flags(msginfo, MSG_NEW | MSG_UNREAD);
CHANGE_FLAGS(msginfo);
summary_set_row_marks(summaryview, row);
debug_print(_("Message %d is marked as read\n"),
summaryview->deleted--;
}
MSG_UNSET_PERM_FLAGS(msginfo->flags, MSG_REPLIED | MSG_FORWARDED);
+ if (MSG_IS_IMAP(msginfo->flags))
+ imap_msg_unset_perm_flags(msginfo, MSG_REPLIED);
if (!MSG_IS_UNREAD(msginfo->flags)) {
MSG_SET_PERM_FLAGS(msginfo->flags, MSG_UNREAD);
+ if (MSG_IS_IMAP(msginfo->flags))
+ imap_msg_set_perm_flags(msginfo, MSG_UNREAD);
summaryview->unread++;
debug_print(_("Message %d is marked as unread\n"),
msginfo->msgnum);
msginfo = gtk_ctree_node_get_row_data(ctree, row);
+ if (MSG_IS_LOCKED(msginfo->flags)) return;
+
if (MSG_IS_DELETED(msginfo->flags)) return;
if (MSG_IS_MOVE(msginfo->flags)) {
}
msginfo->to_folder = NULL;
MSG_UNSET_PERM_FLAGS(msginfo->flags, MSG_MARKED);
+ if (MSG_IS_IMAP(msginfo->flags))
+ imap_msg_unset_perm_flags(msginfo, MSG_MARKED);
MSG_UNSET_TMP_FLAGS(msginfo->flags, MSG_MOVE | MSG_COPY);
MSG_SET_PERM_FLAGS(msginfo->flags, MSG_DELETED);
CHANGE_FLAGS(msginfo);
node = summary_find_next_msg(summaryview, sel_last);
if (!node)
node = summary_find_prev_msg(summaryview, sel_last);
- if (node == gtkut_ctree_node_next(ctree, sel_last))
- summary_step(summaryview, GTK_SCROLL_STEP_FORWARD);
- else if (node == GTK_CTREE_NODE_PREV(sel_last))
- summary_step(summaryview, GTK_SCROLL_STEP_BACKWARD);
- else
- summary_select_node
- (summaryview, node,
- summaryview->msg_is_toggled_on);
+
+ if (node) {
+ if (sel_last && node == gtkut_ctree_node_next(ctree, sel_last))
+ summary_step(summaryview, GTK_SCROLL_STEP_FORWARD);
+ else if (sel_last && node == GTK_CTREE_NODE_PREV(sel_last))
+ summary_step(summaryview, GTK_SCROLL_STEP_BACKWARD);
+ else
+ summary_select_node(summaryview, node,
+ summaryview->msg_is_toggled_on);
+ }
if (prefs_common.immediate_exec || item->stype == F_TRASH)
summary_execute(summaryview);
}
msginfo->to_folder = NULL;
MSG_UNSET_PERM_FLAGS(msginfo->flags, MSG_MARKED | MSG_DELETED);
+ if (MSG_IS_IMAP(msginfo->flags))
+ imap_msg_unset_perm_flags(msginfo, MSG_MARKED);
MSG_UNSET_TMP_FLAGS(msginfo->flags, MSG_MOVE | MSG_COPY);
CHANGE_FLAGS(msginfo);
summary_set_row_marks(summaryview, row);
-
debug_print(_("Message %s/%d is unmarked\n"),
msginfo->folder->path, msginfo->msgnum);
}
GtkCTree *ctree = GTK_CTREE(summaryview->ctree);
GList *cur;
- for (cur = GTK_CLIST(ctree)->selection; cur != NULL;
- cur = cur->next)
+ for (cur = GTK_CLIST(ctree)->selection; cur != NULL; cur = cur->next)
summary_unmark_row(summaryview, GTK_CTREE_NODE(cur->data));
summary_status_show(summaryview);
msginfo->to_folder->op_count--;
}
MSG_UNSET_PERM_FLAGS(msginfo->flags, MSG_MARKED | MSG_DELETED);
+ if (MSG_IS_IMAP(msginfo->flags))
+ imap_msg_unset_perm_flags(msginfo, MSG_MARKED);
MSG_UNSET_TMP_FLAGS(msginfo->flags, MSG_COPY);
if (!MSG_IS_MOVE(msginfo->flags)) {
MSG_SET_TMP_FLAGS(msginfo->flags, MSG_MOVE);
msginfo->to_folder->op_count--;
}
MSG_UNSET_PERM_FLAGS(msginfo->flags, MSG_MARKED | MSG_DELETED);
+ if (MSG_IS_IMAP(msginfo->flags))
+ imap_msg_unset_perm_flags(msginfo, MSG_MARKED);
MSG_UNSET_TMP_FLAGS(msginfo->flags, MSG_MOVE);
if (!MSG_IS_COPY(msginfo->flags)) {
MSG_SET_TMP_FLAGS(msginfo->flags, MSG_COPY);
{
GtkCTree *ctree = GTK_CTREE(summaryview->ctree);
MsgInfo *msginfo;
+ gchar *filename = NULL;
gchar *src, *dest;
if (!summaryview->selected) return;
msginfo = gtk_ctree_node_get_row_data(ctree, summaryview->selected);
if (!msginfo) return;
- dest = filesel_select_file(_("Save as"), NULL);
+ if (msginfo->subject) {
+ Xstrdup_a(filename, msginfo->subject, return);
+ subst_for_filename(filename);
+ }
+ dest = filesel_select_file(_("Save as"), filename);
if (!dest) return;
if (is_file_exist(dest)) {
AlertValue aval;
msginfo->msgid))
g_hash_table_remove(summaryview->msgid_table,
msginfo->msgid);
-
- if (msginfo->subject &&
- node == subject_table_lookup(summaryview->subject_table,
- msginfo->subject)) {
- gchar *s = msginfo->subject + (g_strncasecmp(msginfo->subject, "Re: ", 4) == 0 ? 4 : 0);
- g_hash_table_remove(summaryview->subject_table, s);
- }
}
}
msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(node);
+ parent = NULL;
+
/* alfons - claws seems to prefer subject threading before
* inreplyto threading. we should look more deeply in this,
* because inreplyto should have precedence... */
if (msginfo && msginfo->inreplyto) {
parent = g_hash_table_lookup(summaryview->msgid_table,
msginfo->inreplyto);
- if (parent && parent != node) {
- gtk_ctree_move(ctree, node, parent, NULL);
- gtk_ctree_expand(ctree, node);
- }
}
- else if (msginfo && msginfo->subject) {
- parent = g_hash_table_lookup
- (summaryview->subject_table, msginfo->subject);
- if (parent && parent != node) {
- gtk_ctree_move(ctree, node, parent, NULL);
- gtk_ctree_expand(ctree, node);
- }
+
+ if (parent == NULL) {
+ parent = subject_table_lookup
+ (summaryview->subject_table,
+ msginfo->subject);
+ }
+
+ if (parent && parent != node) {
+ gtk_ctree_move(ctree, node, parent, NULL);
+ gtk_ctree_expand(ctree, node);
}
node = next;
}
}
+void summary_processing(SummaryView *summaryview, GSList * mlist)
+{
+ GSList * processing_list;
+ FolderItem * folder_item;
+ GSList * cur;
+ gchar * id;
+ gchar * buf;
+
+ folder_item = summaryview->folder_item;
+ if (folder_item == NULL)
+ return;
+
+ processing_list = folder_item->prefs->processing;
+
+ if (processing_list == NULL)
+ return;
+
+ summary_lock(summaryview);
+
+ buf = g_strdup_printf(_("Processing (%s)..."), folder_item->path);
+ debug_print(buf);
+ STATUSBAR_PUSH(summaryview->mainwin, buf);
+ g_free(buf);
+
+ main_window_cursor_wait(summaryview->mainwin);
+
+ summaryview->folder_table = g_hash_table_new(NULL, NULL);
+
+ for(cur = mlist ; cur != NULL ; cur = cur->next) {
+ MsgInfo * msginfo;
+
+ msginfo = (MsgInfo *) cur->data;
+ filter_msginfo_move_or_delete(processing_list, msginfo,
+ summaryview->folder_table);
+ }
+
+ folder_item_scan_foreach(summaryview->folder_table);
+ folderview_update_item_foreach(summaryview->folder_table);
+
+ g_hash_table_destroy(summaryview->folder_table);
+ summaryview->folder_table = NULL;
+
+ if (prefs_common.immediate_exec) {
+ summary_unlock(summaryview);
+ summary_execute(summaryview);
+ summary_lock(summaryview);
+ } else
+ summary_status_show(summaryview);
+
+ debug_print(_("done.\n"));
+ STATUSBAR_POP(summaryview->mainwin);
+ main_window_cursor_normal(summaryview->mainwin);
+
+ summary_unlock(summaryview);
+}
+
void summary_filter(SummaryView *summaryview)
{
- if (!prefs_common.fltlist) return;
+ if (!prefs_common.fltlist && !global_processing) {
+ alertpanel_error(_("No filter rules defined."));
+ return;
+ }
summary_lock(summaryview);
gtk_clist_freeze(GTK_CLIST(summaryview->ctree));
- if (prefs_filtering == NULL) {
+ if (global_processing == NULL) {
gtk_ctree_pre_recursive(GTK_CTREE(summaryview->ctree), NULL,
GTK_CTREE_FUNC(summary_filter_func),
summaryview);
g_hash_table_destroy(summaryview->folder_table);
summaryview->folder_table = NULL;
-
- summary_show(summaryview, summaryview->folder_item, FALSE);
}
debug_print(_("done.\n"));
main_window_cursor_normal(summaryview->mainwin);
summary_unlock(summaryview);
+
+ /*
+ * CLAWS: summary_show() only valid after having a lock. ideally
+ * we want the lock to be context aware...
+ */
+ if (global_processing) {
+ /*
+ * CLAWS: to prevent summary_show to write the cache,
+ * we force an update of the summaryview in a special way,
+ * like inc.c::inc_finished().
+ */
+ folderview_unselect(summaryview->folderview);
+ folderview_select(summaryview->folderview, summaryview->folder_item);
+ }
}
static void summary_filter_func(GtkCTree *ctree, GtkCTreeNode *node,
gchar *file;
FolderItem *dest;
- if (prefs_filtering == NULL) {
+ if (global_processing == NULL) {
/* old filtering */
file = procmsg_get_message_file_path(msginfo);
dest = filter_get_dest_folder(prefs_common.fltlist, file);
summaryview->folder_item != dest)
summary_move_row_to(summaryview, node, dest);
}
- else
- filter_msginfo_move_or_delete(prefs_filtering, msginfo,
+ else
+ filter_msginfo_move_or_delete(global_processing, msginfo,
summaryview->folder_table);
}
+void summary_filter_open(SummaryView *summaryview, PrefsFilterType type)
+{
+ static HeaderEntry hentry[] = {{"List-Id:", NULL, FALSE},
+ {"X-ML-Name:", NULL, FALSE},
+ {"X-List:", NULL, FALSE},
+ {"X-Mailing-list:", NULL, FALSE},
+ {NULL, NULL, FALSE}};
+ enum
+ {
+ H_LIST_ID = 0,
+ H_X_ML_NAME = 1,
+ H_X_LIST = 2,
+ H_X_MAILING_LIST = 3
+ };
+
+ MsgInfo *msginfo;
+ gchar *header = NULL;
+ gchar *key = NULL;
+ FILE *fp;
+
+ if (!summaryview->selected) return;
+
+ msginfo = gtk_ctree_node_get_row_data(GTK_CTREE(summaryview->ctree),
+ summaryview->selected);
+ if (!msginfo) return;
+
+ switch (type) {
+ case FILTER_BY_NONE:
+ break;
+ case FILTER_BY_AUTO:
+ if ((fp = procmsg_open_message(msginfo)) == NULL) return;
+ procheader_get_header_fields(fp, hentry);
+ fclose(fp);
+
+ if (hentry[H_LIST_ID].body != NULL) {
+ header = "List-Id";
+ Xstrdup_a(key, hentry[H_LIST_ID].body, );
+ } else if (hentry[H_X_ML_NAME].body != NULL) {
+ header = "X-ML-Name";
+ Xstrdup_a(key, hentry[H_X_ML_NAME].body, );
+ } else if (hentry[H_X_LIST].body != NULL) {
+ header = "X-List";
+ Xstrdup_a(key, hentry[H_X_LIST].body, );
+ } else if (hentry[H_X_MAILING_LIST].body != NULL) {
+ header = "X-Mailing-list";
+ Xstrdup_a(key, hentry[H_X_MAILING_LIST].body, );
+ } else if (msginfo->subject) {
+ header = "Subject";
+ key = msginfo->subject;
+ }
+
+ g_free(hentry[H_LIST_ID].body);
+ hentry[H_LIST_ID].body = NULL;
+ g_free(hentry[H_X_ML_NAME].body);
+ hentry[H_X_ML_NAME].body = NULL;
+ g_free(hentry[H_X_LIST].body);
+ hentry[H_X_LIST].body = NULL;
+ g_free(hentry[H_X_MAILING_LIST].body);
+ hentry[H_X_MAILING_LIST].body = NULL;
+
+ break;
+ case FILTER_BY_FROM:
+ header = "From";
+ key = msginfo->from;
+ break;
+ case FILTER_BY_TO:
+ header = "To";
+ key = msginfo->to;
+ break;
+ case FILTER_BY_SUBJECT:
+ header = "Subject";
+ key = msginfo->subject;
+ break;
+ default:
+ break;
+ }
+
+ prefs_filter_open(header, key);
+}
+
/* color label */
#define N_COLOR_LABELS colorlabel_get_color_count()
GtkWidget *ctree;
gint *col_pos = summaryview->col_pos;
SummaryColumnState *col_state;
- const gchar *titles[N_SUMMARY_COLS];
+ gchar *titles[N_SUMMARY_COLS];
SummaryColumnType type;
gint pos;
+ memset(titles, 0, sizeof(titles));
+
col_state = prefs_summary_column_get_config();
for (pos = 0; pos < N_SUMMARY_COLS; pos++) {
summaryview->col_state[pos] = col_state[pos];
type = col_state[pos].type;
col_pos[type] = pos;
-
- switch (type) {
- case S_COL_NUMBER:
- case S_COL_DATE:
- case S_COL_FROM:
- case S_COL_SUBJECT:
- case S_COL_SCORE:
- if (prefs_common.trans_hdr)
- titles[pos] = gettext(col_label[type]);
- else
- titles[pos] = col_label[type];
- break;
- default:
- titles[pos] = gettext(col_label[type]);
- }
}
col_state = summaryview->col_state;
ctree = gtk_sctree_new_with_titles
- (N_SUMMARY_COLS, col_pos[S_COL_SUBJECT], (gchar **)titles);
+ (N_SUMMARY_COLS, col_pos[S_COL_SUBJECT], titles);
gtk_clist_set_selection_mode(GTK_CLIST(ctree), GTK_SELECTION_EXTENDED);
gtk_clist_set_column_justification(GTK_CLIST(ctree), col_pos[S_COL_MARK],
GTK_JUSTIFY_CENTER);
gtk_clist_set_column_justification(GTK_CLIST(ctree), col_pos[S_COL_UNREAD],
GTK_JUSTIFY_CENTER);
+ gtk_clist_set_column_justification(GTK_CLIST(ctree), col_pos[S_COL_LOCKED],
+ GTK_JUSTIFY_CENTER);
gtk_clist_set_column_justification(GTK_CLIST(ctree), col_pos[S_COL_MIME],
GTK_JUSTIFY_CENTER);
gtk_clist_set_column_justification(GTK_CLIST(ctree), col_pos[S_COL_SIZE],
SUMMARY_COL_MARK_WIDTH);
gtk_clist_set_column_width(GTK_CLIST(ctree), col_pos[S_COL_UNREAD],
SUMMARY_COL_UNREAD_WIDTH);
+ gtk_clist_set_column_width(GTK_CLIST(ctree), col_pos[S_COL_LOCKED],
+ SUMMARY_COL_LOCKED_WIDTH);
gtk_clist_set_column_width(GTK_CLIST(ctree), col_pos[S_COL_MIME],
SUMMARY_COL_MIME_WIDTH);
gtk_clist_set_column_width(GTK_CLIST(ctree), col_pos[S_COL_SUBJECT],
gtk_ctree_set_expander_style(GTK_CTREE(ctree),
GTK_CTREE_EXPANDER_TRIANGLE);
#endif
- gtk_ctree_set_indent(GTK_CTREE(ctree), 18);
+ gtk_ctree_set_indent(GTK_CTREE(ctree), 16);
gtk_object_set_user_data(GTK_OBJECT(ctree), summaryview);
for (pos = 0; pos < N_SUMMARY_COLS; pos++) {
CLIST_BUTTON_SIGNAL_CONNECT(S_COL_FROM , summary_from_clicked);
CLIST_BUTTON_SIGNAL_CONNECT(S_COL_SUBJECT, summary_subject_clicked);
CLIST_BUTTON_SIGNAL_CONNECT(S_COL_SCORE, summary_score_clicked);
+ CLIST_BUTTON_SIGNAL_CONNECT(S_COL_LOCKED, summary_locked_clicked);
#undef CLIST_BUTTON_SIGNAL_CONNECT
GtkWidget *scrolledwin = summaryview->scrolledwin;
GtkWidget *pixmap;
FolderItem *item;
+ guint selected_msgnum = summary_get_msgnum(summaryview, summaryview->selected);
+ guint displayed_msgnum = summary_get_msgnum(summaryview, summaryview->displayed);
+
item = summaryview->folder_item;
+
+ summary_lock(summaryview);
+ summary_write_cache(summaryview);
+ summary_unlock(summaryview);
+
summary_clear_all(summaryview);
gtk_widget_destroy(summaryview->ctree);
gtk_widget_show(ctree);
summary_show(summaryview, item, FALSE);
+
+ summary_select_by_msgnum(summaryview, selected_msgnum);
+ summaryview->displayed = summary_find_msg_by_msgnum(summaryview, displayed_msgnum);
+ if (!summaryview->displayed)
+ messageview_clear(summaryview->messageview);
+ else
+ summary_redisplay_msg(summaryview);
}
/* callback functions */
-static void summary_toggle_pressed(GtkWidget *eventbox, GdkEventButton *event,
- SummaryView *summaryview)
+static void summary_toggle_view_cb(GtkWidget *button,
+ gpointer data)
{
- if (!event)
- return;
-
+ SummaryView *summaryview = (SummaryView *) data;
+
if (!summaryview->msg_is_toggled_on && summaryview->selected)
summary_display_msg(summaryview, summaryview->selected, FALSE);
else
if (!event) return;
switch (event->keyval) {
- case GDK_g: /* Go */
- case GDK_G:
- RETURN_IF_LOCKED();
- BREAK_ON_MODIFIER_KEY();
- KEY_PRESS_EVENT_STOP();
- to_folder = foldersel_folder_sel(NULL, NULL);
- if (to_folder) {
- debug_print(_("Go to %s\n"), to_folder->path);
- folderview_select(summaryview->folderview, to_folder);
- }
- return;
- case GDK_w: /* Write new message */
- BREAK_ON_MODIFIER_KEY();
- if (summaryview->folder_item) {
- PrefsAccount *ac;
- ac = summaryview->folder_item->folder->account;
- if (ac && ac->protocol == A_NNTP)
- compose_new_with_recipient
- (ac, summaryview->folder_item->path);
- else
- compose_new_with_folderitem(ac, summaryview->folder_item);
- } else
- compose_new(NULL);
- return;
- case GDK_D: /* Empty trash */
- RETURN_IF_LOCKED();
- BREAK_ON_MODIFIER_KEY();
- KEY_PRESS_EVENT_STOP();
- main_window_empty_trash(summaryview->mainwin, TRUE);
- return;
- case GDK_Q: /* Quit */
- RETURN_IF_LOCKED();
- BREAK_ON_MODIFIER_KEY();
-
- if (prefs_common.confirm_on_exit) {
- if (alertpanel(_("Exit"), _("Exit this program?"),
- _("OK"), _("Cancel"), NULL)
- == G_ALERTDEFAULT) {
- manage_window_focus_in
- (summaryview->mainwin->window,
- NULL, NULL);
- app_will_exit(NULL, summaryview->mainwin);
- }
- }
- return;
- case GDK_Left: /* Move focus */
case GDK_Escape:
gtk_widget_grab_focus(summaryview->folderview->ctree);
return;
FALSE))
summary_select_next_unread(summaryview);
break;
- case GDK_n: /* Next */
- case GDK_N:
- BREAK_ON_MODIFIER_KEY();
- summary_step(summaryview, GTK_SCROLL_STEP_FORWARD);
- break;
- case GDK_BackSpace: /* Page up */
- case GDK_Delete:
- textview_scroll_page(summaryview->messageview->textview, TRUE);
- break;
- case GDK_p: /* Prev */
- case GDK_P:
- BREAK_ON_MODIFIER_KEY();
- summary_step(summaryview, GTK_SCROLL_STEP_BACKWARD);
- break;
- case GDK_v: /* Toggle summary mode / message mode */
- case GDK_V:
- BREAK_ON_MODIFIER_KEY();
-
- if (!summaryview->msg_is_toggled_on && summaryview->selected)
- summary_display_msg(summaryview,
- summaryview->selected, FALSE);
- else
- summary_toggle_view(summaryview);
- break;
case GDK_Return: /* Scroll up/down one line */
if (summaryview->displayed != summaryview->selected) {
summary_display_msg(summaryview,
textview_scroll_one_line(summaryview->messageview->textview,
(event->state & GDK_MOD1_MASK) != 0);
break;
- case GDK_asterisk: /* Mark */
- summary_mark(summaryview);
- break;
- case GDK_exclam: /* Mark as unread */
- summary_mark_as_unread(summaryview);
- break;
- case GDK_d: /* Delete */
+ case GDK_Delete:
RETURN_IF_LOCKED();
BREAK_ON_MODIFIER_KEY();
summary_delete(summaryview);
break;
- case GDK_u: /* Unmark */
- case GDK_U:
- BREAK_ON_MODIFIER_KEY();
- summary_unmark(summaryview);
- break;
- case GDK_o: /* Move */
- RETURN_IF_LOCKED();
- BREAK_ON_MODIFIER_KEY();
- summary_move_to(summaryview);
- break;
- case GDK_O: /* Copy */
- RETURN_IF_LOCKED();
- BREAK_ON_MODIFIER_KEY();
- summary_copy_to(summaryview);
- break;
- case GDK_x: /* Execute */
- case GDK_X:
- RETURN_IF_LOCKED();
- BREAK_ON_MODIFIER_KEY();
- KEY_PRESS_EVENT_STOP();
- summary_execute(summaryview);
- break;
- case GDK_a: /* Reply to the message */
- BREAK_ON_MODIFIER_KEY();
- summary_reply_cb(summaryview,
- COMPOSE_REPLY_TO_ALL_WITHOUT_QUOTE, NULL);
- break;
- case GDK_A: /* Reply to the message with quotation */
- BREAK_ON_MODIFIER_KEY();
- summary_reply_cb(summaryview,
- COMPOSE_REPLY_TO_ALL_WITH_QUOTE, NULL);
- break;
- case GDK_f: /* Forward the message */
- BREAK_ON_MODIFIER_KEY();
- summary_reply_cb(summaryview, COMPOSE_FORWARD, NULL);
+ case GDK_asterisk: /* Mark */
+ summary_mark(summaryview);
break;
- case GDK_F:
- BREAK_ON_MODIFIER_KEY();
- summary_reply_cb(summaryview, COMPOSE_FORWARD_AS_ATTACH, NULL);
+ case GDK_exclam: /* Mark as unread */
+ summary_mark_as_unread(summaryview);
break;
- case GDK_y: /* Save the message */
- BREAK_ON_MODIFIER_KEY();
- summary_save_as(summaryview);
+ case GDK_BackSpace: /* Page up */
+ textview_scroll_page(summaryview->messageview->textview, TRUE);
break;
default:
break;
case S_COL_MARK:
if (MSG_IS_MARKED(msginfo->flags)) {
MSG_UNSET_PERM_FLAGS(msginfo->flags, MSG_MARKED);
+ if (MSG_IS_IMAP(msginfo->flags))
+ imap_msg_unset_perm_flags(msginfo, MSG_MARKED);
CHANGE_FLAGS(msginfo);
summary_set_row_marks(summaryview, row);
} else
summary_status_show(summaryview);
}
break;
+ case S_COL_LOCKED:
+ if (MSG_IS_LOCKED(msginfo->flags)) {
+ MSG_UNSET_PERM_FLAGS(msginfo->flags, MSG_LOCKED);
+ CHANGE_FLAGS(msginfo);
+ summary_set_row_marks(summaryview, row);
+ }
+ else
+ summary_lock_row(summaryview, row);
+ break;
default:
break;
}
compose_reply(msginfo, FALSE, TRUE, FALSE);
break;
case COMPOSE_FORWARD:
- if (!sel->next) {
+ if (prefs_common.forward_as_attachment) {
+ summary_reply_cb(summaryview, COMPOSE_FORWARD_AS_ATTACH, widget);
+ return;
+ } else {
+ summary_reply_cb(summaryview, COMPOSE_FORWARD_INLINE, widget);
+ return;
+ }
+ break;
+ case COMPOSE_FORWARD_INLINE:
+ if (!sel->next) {
compose_forward(NULL, msginfo, FALSE);
break;
}
g_slist_free(msginfo_list);
}
break;
+ case COMPOSE_BOUNCE:
+ compose_bounce(NULL, msginfo);
+ break;
default:
g_warning("summary_reply_cb(): invalid action: %d\n", action);
}
summary_sort(summaryview, SORT_BY_SCORE);
}
+static void summary_locked_clicked(GtkWidget *button,
+ SummaryView *summaryview)
+{
+ summary_sort(summaryview, SORT_BY_LOCKED);
+}
+
static void summary_size_clicked(GtkWidget *button, SummaryView *summaryview)
{
summary_sort(summaryview, SORT_BY_SIZE);
list = gtk_target_list_new(summary_drag_types, 1);
context = gtk_drag_begin(widget, list,
- GDK_ACTION_MOVE, button, event);
+ GDK_ACTION_MOVE|GDK_ACTION_COPY|GDK_ACTION_DEFAULT, button, event);
gtk_drag_set_icon_default(context);
}
return summary_cmp_by_date(clist, ptr1, ptr2);
}
+static gint summary_cmp_by_locked(GtkCList *clist,
+ gconstpointer ptr1, gconstpointer ptr2)
+{
+ MsgInfo *msginfo1 = ((GtkCListRow *)ptr1)->data;
+ MsgInfo *msginfo2 = ((GtkCListRow *)ptr2)->data;
+
+ return MSG_IS_LOCKED(msginfo1->flags) - MSG_IS_LOCKED(msginfo2->flags);
+}
+
static void summary_ignore_thread_func(GtkCTree *ctree, GtkCTreeNode *row, gpointer data)
{
SummaryView *summaryview = (SummaryView *) data;
summary_status_show(summaryview);
}
+
+
+static gboolean processing_apply_func(GNode *node, gpointer data)
+{
+ FolderItem *item;
+ GSList * processing;
+ SummaryView * summaryview = (SummaryView *) data;
+
+ if (node == NULL)
+ return FALSE;
+
+ item = node->data;
+ /* prevent from the warning */
+ if (item->path == NULL)
+ return FALSE;
+ processing = item->prefs->processing;
+
+ if (processing != NULL) {
+ gchar * buf;
+ GSList * mlist;
+ GSList * cur;
+
+ buf = g_strdup_printf(_("Processing (%s)..."), item->path);
+ debug_print(buf);
+ STATUSBAR_PUSH(summaryview->mainwin, buf);
+ g_free(buf);
+
+ mlist = item->folder->get_msg_list(item->folder, item,
+ TRUE);
+
+ for(cur = mlist ; cur != NULL ; cur = cur->next) {
+ MsgInfo * msginfo;
+
+ msginfo = (MsgInfo *) cur->data;
+ filter_msginfo_move_or_delete(processing, msginfo,
+ NULL);
+ procmsg_msginfo_free(msginfo);
+ }
+
+ g_slist_free(mlist);
+
+ STATUSBAR_POP(summaryview->mainwin);
+ }
+
+
+ return FALSE;
+}
+
+void processing_apply(SummaryView * summaryview)
+{
+ GList * cur;
+
+ for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
+ Folder *folder;
+
+ folder = (Folder *) cur->data;
+ g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
+ processing_apply_func, summaryview);
+ }
+}
+
+void summary_toggle_show_read_messages(SummaryView *summaryview)
+{
+ if (summaryview->folder_item->hide_read_msgs)
+ summaryview->folder_item->hide_read_msgs = 0;
+ else
+ summaryview->folder_item->hide_read_msgs = 1;
+ summary_show(summaryview, summaryview->folder_item, FALSE);
+}
+
+static void summary_set_hide_read_msgs_menu (SummaryView *summaryview,
+ guint action)
+{
+ GtkWidget *widget;
+
+ widget = gtk_item_factory_get_item(gtk_item_factory_from_widget(summaryview->mainwin->menubar),
+ "/View/Hide read messages");
+ gtk_object_set_data(GTK_OBJECT(widget), "dont_toggle",
+ GINT_TO_POINTER(1));
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(widget), action);
+ gtk_object_set_data(GTK_OBJECT(widget), "dont_toggle",
+ GINT_TO_POINTER(0));
+}
+static void summaryview_subject_filter_init(PrefsFolderItem *prefs)
+{
+ int err;
+ gchar buf[BUFFSIZE];
+ if (prefs->enable_simplify_subject) {
+ if (prefs->simplify_subject_regexp &&
+ *prefs->simplify_subject_regexp != 0x00) {
+
+ if (!prefs->simplify_subject_preg)
+ prefs->simplify_subject_preg = g_new(regex_t, 1);
+ else
+ regfree(prefs->simplify_subject_preg);
+
+ err = string_match_precompile(prefs->simplify_subject_regexp,
+ prefs->simplify_subject_preg, REG_EXTENDED);
+ if (err) {
+ regerror(err, prefs->simplify_subject_preg, buf, BUFFSIZE);
+ alertpanel_error(_("Regular expression (regexp) error:\n%s"), buf);
+ g_free(prefs->simplify_subject_preg);
+ prefs->simplify_subject_preg = NULL;
+ }
+ } else {
+ if (prefs->simplify_subject_preg) {
+ regfree(prefs->simplify_subject_preg);
+ g_free(prefs->simplify_subject_preg);
+ prefs->simplify_subject_preg = NULL;
+ }
+ }
+ }
+}
+
+
/*
* End of Source.
*/
projects / claws.git / blobdiff