src/summaryview.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2011 Hiroyuki Yamamoto and the Claws Mail team
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  17  *
  18  */
  19
  20 #include "defs.h"
  21
  22 #include <glib.h>
  23 #include <glib/gi18n.h>
  24 #include <gdk/gdkkeysyms.h>
  25 #include <gtk/gtk.h>
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <ctype.h>
  31
  32 #include "main.h"
  33 #include "menu.h"
  34 #include "mbox.h"
  35 #include "mainwindow.h"
  36 #include "folderview.h"
  37 #include "summaryview.h"
  38 #include "messageview.h"
  39 #include "foldersel.h"
  40 #include "procmsg.h"
  41 #include "procheader.h"
  42 #include "sourcewindow.h"
  43 #include "prefs_common.h"
  44 #include "prefs_summary_column.h"
  45 #include "prefs_summary_open.h"
  46 #include "prefs_filtering.h"
  47 #include "account.h"
  48 #include "compose.h"
  49 #include "utils.h"
  50 #include "gtkutils.h"
  51 #include "stock_pixmap.h"
  52 #include "filesel.h"
  53 #include "alertpanel.h"
  54 #include "inputdialog.h"
  55 #include "statusbar.h"
  56 #include "folder.h"
  57 #include "colorlabel.h"
  58 #include "inc.h"
  59 #include "imap.h"
  60 #include "addressbook.h"
  61 #include "addr_compl.h"
  62 #include "folder_item_prefs.h"
  63 #include "filtering.h"
  64 #include "string_match.h"
  65 #include "toolbar.h"
  66 #include "news.h"
  67 #include "hooks.h"
  68 #include "description_window.h"
  69 #include "folderutils.h"
  70 #include "quicksearch.h"
  71 #include "partial_download.h"
  72 #include "tags.h"
  73 #include "timing.h"
  74 #include "log.h"
  75 #include "edittags.h"
  76 #include "manual.h"
  77
  78 #define SUMMARY_COL_MARK_WIDTH          10
  79 #define SUMMARY_COL_STATUS_WIDTH        13
  80 #define SUMMARY_COL_LOCKED_WIDTH        13
  81 #define SUMMARY_COL_MIME_WIDTH          11
  82
  83 static int normal_row_height = -1;
  84 static GtkStyle *bold_style;
  85 static GtkStyle *bold_marked_style;
  86 static GtkStyle *bold_deleted_style;
  87 static GtkStyle *small_style;
  88 static GtkStyle *small_marked_style;
  89 static GtkStyle *small_deleted_style;
  90
  91 static GdkPixbuf *markxpm;
  92 static GdkPixbuf *deletedxpm;
  93 static GdkPixbuf *movedxpm;
  94 static GdkPixbuf *copiedxpm;
  95
  96 static GdkPixbuf *newxpm;
  97 static GdkPixbuf *unreadxpm;
  98 static GdkPixbuf *repliedxpm;
  99 static GdkPixbuf *forwardedxpm;
 100 static GdkPixbuf *ignorethreadxpm;
 101 static GdkPixbuf *watchthreadxpm;
 102 static GdkPixbuf *lockedxpm;
 103 static GdkPixbuf *spamxpm;
 104
 105 static GdkPixbuf *clipxpm;
 106 static GdkPixbuf *keyxpm;
 107 static GdkPixbuf *clipkeyxpm;
 108 static GdkPixbuf *keysignxpm;
 109 static GdkPixbuf *gpgsignedxpm;
 110 static GdkPixbuf *clipgpgsignedxpm;
 111
 112 static void summary_free_msginfo_func   (GtkCMCTree             *ctree,
 113                                          GtkCMCTreeNode         *node,
 114                                          gpointer                data);
 115 static void summary_set_marks_func      (GtkCMCTree             *ctree,
 116                                          GtkCMCTreeNode         *node,
 117                                          gpointer                data);
 118
 119 void  summary_set_menu_sensitive        (SummaryView            *summaryview);
 120 guint summary_get_msgnum                (SummaryView            *summaryview,
 121                                          GtkCMCTreeNode         *node);
 122
 123
 124 static void summary_set_hide_read_msgs_menu (SummaryView *summaryview,
 125                                              guint action);
 126 static void summary_set_hide_del_msgs_menu (SummaryView *summaryview,
 127                                              guint action);
 128 static void summary_set_hide_read_threads_menu (SummaryView *summaryview,
 129                                              guint action);
 130
 131 static GtkCMCTreeNode *summary_find_prev_msg
 132                                         (SummaryView            *summaryview,
 133                                          GtkCMCTreeNode         *current_node);
 134 static GtkCMCTreeNode *summary_find_next_msg
 135                                         (SummaryView            *summaryview,
 136                                          GtkCMCTreeNode         *current_node);
 137
 138 static GtkCMCTreeNode *summary_find_prev_flagged_msg
 139                                         (SummaryView    *summaryview,
 140                                          GtkCMCTreeNode *current_node,
 141                                          MsgPermFlags    flags,
 142                                          gboolean        start_from_prev);
 143 static GtkCMCTreeNode *summary_find_next_flagged_msg
 144                                         (SummaryView    *summaryview,
 145                                          GtkCMCTreeNode *current_node,
 146                                          MsgPermFlags    flags,
 147                                          gboolean        start_from_next);
 148
 149 static GtkCMCTreeNode *summary_find_msg_by_msgnum
 150                                         (SummaryView            *summaryview,
 151                                          guint                   msgnum);
 152
 153 static void summary_update_status       (SummaryView            *summaryview);
 154
 155 /* display functions */
 156 static void summary_status_show         (SummaryView            *summaryview);
 157 static void summary_set_column_titles   (SummaryView            *summaryview);
 158 static void summary_set_ctree_from_list (SummaryView            *summaryview,
 159                                          GSList                 *mlist);
 160 static inline void summary_set_header   (SummaryView            *summaryview,
 161                                          gchar                  *text[],
 162                                          MsgInfo                *msginfo);
 163 static void summary_display_msg         (SummaryView            *summaryview,
 164                                          GtkCMCTreeNode         *row);
 165 static void summary_display_msg_full    (SummaryView            *summaryview,
 166                                          GtkCMCTreeNode         *row,
 167                                          gboolean                new_window,
 168                                          gboolean                all_headers);
 169 static void summary_set_row_marks       (SummaryView            *summaryview,
 170                                          GtkCMCTreeNode         *row);
 171
 172 static gboolean summary_set_row_tag     (SummaryView            *summaryview,
 173                                          GtkCMCTreeNode                 *row,
 174                                          gboolean                refresh,
 175                                          gboolean                set,
 176                                          gint                    id);
 177 /* message handling */
 178 static void summary_mark_row            (SummaryView            *summaryview,
 179                                          GtkCMCTreeNode         *row);
 180 static void summary_lock_row            (SummaryView            *summaryview,
 181                                          GtkCMCTreeNode         *row);
 182 static void summary_unlock_row          (SummaryView            *summaryview,
 183                                          GtkCMCTreeNode         *row);
 184 static void summary_mark_row_as_read    (SummaryView            *summaryview,
 185                                          GtkCMCTreeNode         *row);
 186 static void summary_mark_row_as_unread  (SummaryView            *summaryview,
 187                                          GtkCMCTreeNode         *row);
 188 static void summary_delete_row          (SummaryView            *summaryview,
 189                                          GtkCMCTreeNode         *row);
 190 static void summary_unmark_row          (SummaryView            *summaryview,
 191                                          GtkCMCTreeNode         *row);
 192 static void summary_move_row_to         (SummaryView            *summaryview,
 193                                          GtkCMCTreeNode         *row,
 194                                          FolderItem             *to_folder);
 195 static void summary_copy_row_to         (SummaryView            *summaryview,
 196                                          GtkCMCTreeNode         *row,
 197                                          FolderItem             *to_folder);
 198
 199 static gint summary_execute_move        (SummaryView            *summaryview);
 200 static void summary_execute_move_func   (GtkCMCTree             *ctree,
 201                                          GtkCMCTreeNode         *node,
 202                                          gpointer                data);
 203 static void summary_execute_copy        (SummaryView            *summaryview);
 204 static void summary_execute_copy_func   (GtkCMCTree             *ctree,
 205                                          GtkCMCTreeNode         *node,
 206                                          gpointer                data);
 207 static void summary_execute_delete      (SummaryView            *summaryview);
 208 static void summary_execute_delete_func (GtkCMCTree             *ctree,
 209                                          GtkCMCTreeNode         *node,
 210                                          gpointer                data);
 211 static void summary_execute_expunge     (SummaryView            *summaryview);
 212
 213 static void summary_thread_init         (SummaryView            *summaryview);
 214
 215 static void summary_unthread_for_exec           (SummaryView    *summaryview);
 216 static void summary_unthread_for_exec_func      (GtkCMCTree     *ctree,
 217                                                  GtkCMCTreeNode *node,
 218                                                  gpointer        data);
 219
 220 void summary_simplify_subject(SummaryView *summaryview, gchar * rexp,
 221                               GSList * mlist);
 222
 223 static void summary_filter_func         (MsgInfo *msginfo);
 224
 225 static void summary_colorlabel_menu_item_activate_cb
 226                                           (GtkWidget    *widget,
 227                                            gpointer      data);
 228 static void summary_colorlabel_menu_item_activate_item_cb
 229                                           (GtkMenuItem  *label_menu_item,
 230                                            gpointer      data);
 231 static void summary_colorlabel_menu_create(SummaryView  *summaryview,
 232                                            gboolean  refresh);
 233 static void summary_tags_menu_item_activate_cb
 234                                           (GtkWidget    *widget,
 235                                            gpointer      data);
 236 static void summary_tags_menu_item_activate_item_cb
 237                                           (GtkMenuItem  *label_menu_item,
 238                                            gpointer      data);
 239 static void summary_tags_menu_create(SummaryView        *summaryview,
 240                                            gboolean  refresh);
 241
 242 static GtkWidget *summary_ctree_create  (SummaryView    *summaryview);
 243
 244 /* callback functions */
 245 static gint summary_toggle_pressed      (GtkWidget              *eventbox,
 246                                          GdkEventButton         *event,
 247                                          SummaryView            *summaryview);
 248 #ifdef GENERIC_UMPC
 249 static void summary_toggle_multiple_pressed
 250                                         (GtkWidget              *widget,
 251                                          SummaryView            *summaryview);
 252 #endif
 253 static gint summary_folder_eventbox_pressed
 254                                         (GtkWidget              *eventbox,
 255                                          GdkEventButton         *event,
 256                                          SummaryView            *summaryview);
 257 static gboolean summary_button_pressed  (GtkWidget              *ctree,
 258                                          GdkEventButton         *event,
 259                                          SummaryView            *summaryview);
 260 static gboolean summary_button_released (GtkWidget              *ctree,
 261                                          GdkEventButton         *event,
 262                                          SummaryView            *summaryview);
 263 static gboolean summary_key_pressed     (GtkWidget              *ctree,
 264                                          GdkEventKey            *event,
 265                                          SummaryView            *summaryview);
 266 static void summary_tree_expanded       (GtkCMCTree             *ctree,
 267                                          GtkCMCTreeNode         *node,
 268                                          SummaryView            *summaryview);
 269 static void summary_tree_collapsed      (GtkCMCTree             *ctree,
 270                                          GtkCMCTreeNode         *node,
 271                                          SummaryView            *summaryview);
 272 static void summary_selected            (GtkCMCTree             *ctree,
 273                                          GtkCMCTreeNode         *row,
 274                                          gint                    column,
 275                                          SummaryView            *summaryview);
 276 static void summary_unselected          (GtkCMCTree             *ctree,
 277                                          GtkCMCTreeNode         *row,
 278                                          gint                    column,
 279                                          SummaryView            *summaryview);
 280 static void summary_col_resized         (GtkCMCList             *clist,
 281                                          gint                    column,
 282                                          gint                    width,
 283                                          SummaryView            *summaryview);
 284 static void summary_mark_clicked        (GtkWidget              *button,
 285                                          SummaryView            *summaryview);
 286 static void summary_status_clicked      (GtkWidget              *button,
 287                                          SummaryView            *summaryview);
 288 static void summary_mime_clicked        (GtkWidget              *button,
 289                                          SummaryView            *summaryview);
 290 static void summary_num_clicked         (GtkWidget              *button,
 291                                          SummaryView            *summaryview);
 292 static void summary_score_clicked       (GtkWidget *button,
 293                                          SummaryView *summaryview);
 294 static void summary_size_clicked        (GtkWidget              *button,
 295                                          SummaryView            *summaryview);
 296 static void summary_date_clicked        (GtkWidget              *button,
 297                                          SummaryView            *summaryview);
 298 static void summary_from_clicked        (GtkWidget              *button,
 299                                          SummaryView            *summaryview);
 300 static void summary_to_clicked          (GtkWidget              *button,
 301                                          SummaryView            *summaryview);
 302 static void summary_subject_clicked     (GtkWidget              *button,
 303                                          SummaryView            *summaryview);
 304 static void summary_score_clicked       (GtkWidget              *button,
 305                                          SummaryView            *summaryview);
 306 static void summary_locked_clicked      (GtkWidget              *button,
 307                                          SummaryView            *summaryview);
 308 static void summary_tags_clicked        (GtkWidget              *button,
 309                                          SummaryView            *summaryview);
 310
 311 static void summary_start_drag          (GtkWidget        *widget,
 312                                          int button,
 313                                          GdkEvent *event,
 314                                          SummaryView      *summaryview);
 315 static void summary_drag_data_get       (GtkWidget        *widget,
 316                                          GdkDragContext   *drag_context,
 317                                          GtkSelectionData *selection_data,
 318                                          guint             info,
 319                                          guint             time,
 320                                          SummaryView      *summaryview);
 321 static void summary_drag_data_received(GtkWidget        *widget,
 322                                         GdkDragContext   *drag_context,
 323                                         gint              x,
 324                                         gint              y,
 325                                         GtkSelectionData *data,
 326                                         guint             info,
 327                                         guint             time,
 328                                         SummaryView       *summaryview);
 329 static gboolean summary_drag_motion_cb(GtkWidget      *widget,
 330                                           GdkDragContext *context,
 331                                           gint            x,
 332                                           gint            y,
 333                                           guint           time,
 334                                           SummaryView    *summaryview);
 335 static void summary_drag_end(GtkWidget *widget,
 336                                           GdkDragContext *drag_context,
 337                                           SummaryView    *summaryview);
 338 /* custom compare functions for sorting */
 339
 340 static gint summary_cmp_by_mark         (GtkCMCList             *clist,
 341                                          gconstpointer           ptr1,
 342                                          gconstpointer           ptr2);
 343 static gint summary_cmp_by_status       (GtkCMCList             *clist,
 344                                          gconstpointer           ptr1,
 345                                          gconstpointer           ptr2);
 346 static gint summary_cmp_by_mime         (GtkCMCList             *clist,
 347                                          gconstpointer           ptr1,
 348                                          gconstpointer           ptr2);
 349 static gint summary_cmp_by_num          (GtkCMCList             *clist,
 350                                          gconstpointer           ptr1,
 351                                          gconstpointer           ptr2);
 352 static gint summary_cmp_by_size         (GtkCMCList             *clist,
 353                                          gconstpointer           ptr1,
 354                                          gconstpointer           ptr2);
 355 static gint summary_cmp_by_date         (GtkCMCList             *clist,
 356                                          gconstpointer           ptr1,
 357                                          gconstpointer           ptr2);
 358 static gint summary_cmp_by_thread_date  (GtkCMCList             *clist,
 359                                          gconstpointer           ptr1,
 360                                          gconstpointer           ptr2);
 361 static gint summary_cmp_by_from         (GtkCMCList             *clist,
 362                                          gconstpointer           ptr1,
 363                                          gconstpointer           ptr2);
 364 static gint summary_cmp_by_simplified_subject
 365                                         (GtkCMCList             *clist,
 366                                          gconstpointer           ptr1,
 367                                          gconstpointer           ptr2);
 368 static gint summary_cmp_by_score        (GtkCMCList             *clist,
 369                                          gconstpointer           ptr1,
 370                                          gconstpointer           ptr2);
 371 static gint summary_cmp_by_label        (GtkCMCList             *clist,
 372                                          gconstpointer           ptr1,
 373                                          gconstpointer           ptr2);
 374 static gint summary_cmp_by_to           (GtkCMCList             *clist,
 375                                          gconstpointer           ptr1,
 376                                          gconstpointer           ptr2);
 377 static gint summary_cmp_by_subject      (GtkCMCList             *clist,
 378                                          gconstpointer           ptr1,
 379                                          gconstpointer           ptr2);
 380 static gint summary_cmp_by_locked       (GtkCMCList             *clist,
 381                                          gconstpointer           ptr1,
 382                                          gconstpointer           ptr2);
 383 static gint summary_cmp_by_tags         (GtkCMCList             *clist,
 384                                          gconstpointer           ptr1,
 385                                          gconstpointer           ptr2);
 386
 387 static void quicksearch_execute_cb      (QuickSearch    *quicksearch,
 388                                          gpointer        data);
 389 static void tog_searchbar_cb            (GtkWidget      *w,
 390                                          gpointer        data);
 391
 392 static void summary_find_answers        (SummaryView    *summaryview,
 393                                          MsgInfo        *msg);
 394
 395 static gboolean summary_update_msg      (gpointer source, gpointer data);
 396 static gboolean summary_update_folder_item_hook(gpointer source, gpointer data);
 397 static gboolean summary_update_folder_hook(gpointer source, gpointer data);
 398 static void summary_set_colorlabel_color (GtkCMCTree            *ctree,
 399                                    GtkCMCTreeNode               *node,
 400                                    guint                 labelcolor);
 401 static void summary_thread_build(SummaryView *summaryview);
 402
 403 GtkTargetEntry summary_drag_types[3] =
 404 {
 405         {"text/uri-list", 0, TARGET_MAIL_URI_LIST},
 406         {"claws-mail/internal", GTK_TARGET_SAME_APP, TARGET_DUMMY},
 407         {"claws-mail/msg-path-list", 0, TARGET_MAIL_CM_PATH_LIST},
 408 };
 409
 410 #define DO_ACTION(name, act) {                                          \
 411         if(!strcmp(name, a_name)) {                                     \
 412                 act;                                                    \
 413         }                                                               \
 414 }
 415
 416 static GtkActionEntry summary_popup_entries[] =
 417 {
 418         {"SummaryViewPopup",                            NULL, "SummaryViewPopup" },
 419         {"SummaryViewPopup/ReplyTo",                    NULL, N_("Repl_y to") },
 420         {"SummaryViewPopup/Mark",                       NULL, N_("_Mark") },
 421         {"SummaryViewPopup/ColorLabel",                 NULL, N_("Color la_bel") },
 422         {"SummaryViewPopup/Tags",                       NULL, N_("Ta_gs") },
 423         {"SummaryViewPopup/CreateFilterRule",           NULL, N_("Create _filter rule") },
 424 #ifndef GENERIC_UMPC
 425         {"SummaryViewPopup/CreateProcessingRule",       NULL, N_("Create processing rule") },
 426 #endif
 427         {"SummaryViewPopup/View",                       NULL, N_("_View") },
 428 };
 429
 430 static const gchar *const col_label[N_SUMMARY_COLS] = {
 431         "",             /* S_COL_MARK    */
 432         N_("S"),        /* S_COL_STATUS  */
 433         "",             /* S_COL_MIME    */
 434         N_("Subject"),  /* S_COL_SUBJECT */
 435         N_("From"),     /* S_COL_FROM    */
 436         N_("To"),       /* S_COL_TO      */
 437         N_("Date"),     /* S_COL_DATE    */
 438         N_("Size"),     /* S_COL_SIZE    */
 439         N_("#"),        /* S_COL_NUMBER  */
 440         N_("Score"),    /* S_COL_SCORE   */
 441         "",             /* S_COL_LOCKED  */
 442         N_("Tags"),     /* S_COL_TAGS    */
 443 };
 444
 445 void summary_freeze(SummaryView *summaryview)
 446 {
 447         if (summaryview)
 448                 gtk_cmclist_freeze(GTK_CMCLIST(summaryview->ctree));
 449 }
 450
 451 void summary_thaw(SummaryView *summaryview)
 452 {
 453         if (summaryview)
 454                 gtk_cmclist_thaw(GTK_CMCLIST(summaryview->ctree));
 455 }
 456
 457 void summary_grab_focus(SummaryView *summaryview)
 458 {
 459         if (summaryview)
 460                 gtk_widget_grab_focus(summaryview->ctree);
 461 }
 462
 463 GtkWidget *summary_get_main_widget(SummaryView *summaryview)
 464 {
 465         if (summaryview)
 466                 return summaryview->ctree;
 467         else
 468                 return NULL;
 469 }
 470
 471 #define START_LONG_OPERATION(summaryview,force_freeze) {        \
 472         summary_lock(summaryview);                              \
 473         main_window_cursor_wait(summaryview->mainwin);          \
 474         if (force_freeze || sc_g_list_bigger(GTK_CMCLIST(summaryview->ctree)->selection, 1)) {\
 475                 froze = TRUE;                                           \
 476                 summary_freeze(summaryview);    \
 477         }                                                       \
 478         folder_item_update_freeze();                            \
 479         inc_lock();                                             \
 480         hooks_unregister_hook(MSGINFO_UPDATE_HOOKLIST,          \
 481                       summaryview->msginfo_update_callback_id); \
 482 }
 483 #define END_LONG_OPERATION(summaryview) {                       \
 484         inc_unlock();                                           \
 485         folder_item_update_thaw();                              \
 486         if (froze)                                              \
 487                 summary_thaw(summaryview);      \
 488         main_window_cursor_normal(summaryview->mainwin);        \
 489         summary_unlock(summaryview);                            \
 490         summaryview->msginfo_update_callback_id =               \
 491                 hooks_register_hook(MSGINFO_UPDATE_HOOKLIST,    \
 492                 summary_update_msg, (gpointer) summaryview);    \
 493 }
 494
 495 SummaryView *summary_create(MainWindow *mainwin)
 496 {
 497         SummaryView *summaryview;
 498         GtkWidget *vbox;
 499         GtkWidget *scrolledwin;
 500         GtkWidget *ctree;
 501         GtkWidget *hbox;
 502         GtkWidget *hbox_l;
 503         GtkWidget *stat_box;
 504         GtkWidget *stat_box2;
 505         GtkWidget *stat_vbox;
 506         GtkWidget *statlabel_folder;
 507         GtkWidget *statlabel_select;
 508         GtkWidget *statlabel_msgs;
 509         GtkWidget *hbox_spc;
 510         GtkWidget *toggle_eventbox;
 511 #ifdef GENERIC_UMPC
 512         GtkWidget *multiple_sel_togbtn;
 513 #endif
 514         GtkWidget *toggle_arrow;
 515         GtkWidget *toggle_search;
 516         QuickSearch *quicksearch;
 517
 518         debug_print("Creating summary view...\n");
 519         summaryview = g_new0(SummaryView, 1);
 520
 521 #if !(GTK_CHECK_VERSION(2,12,0))
 522         summaryview->tooltips = tips;
 523 #endif
 524 #define SUMMARY_VBOX_SPACING 3
 525         vbox = gtk_vbox_new(FALSE, SUMMARY_VBOX_SPACING);
 526
 527         /* create status label */
 528         hbox = gtk_hbox_new(FALSE, 0);
 529         gtk_widget_show(hbox);
 530
 531         stat_vbox = gtk_vbox_new(FALSE, 0);
 532         gtk_widget_show(stat_vbox);
 533
 534         stat_box = gtk_hbox_new(FALSE, 0);
 535         gtk_widget_show(stat_box);
 536
 537         stat_box2 = gtk_hbox_new(FALSE, 0);
 538         gtk_widget_show(stat_box2);
 539
 540         toggle_search = gtk_toggle_button_new();
 541         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle_search),
 542                                      prefs_common.show_searchbar);
 543         gtkut_widget_set_can_focus(toggle_search, FALSE);
 544         gtk_widget_show(toggle_search);
 545
 546         CLAWS_SET_TIP(toggle_search, _("Toggle quick search bar"));
 547
 548         gtk_box_pack_start(GTK_BOX(hbox), toggle_search, FALSE, FALSE, 2);
 549
 550         gtk_box_pack_start(GTK_BOX(hbox), stat_vbox, TRUE, TRUE, 0);
 551         gtk_box_pack_start(GTK_BOX(stat_vbox), stat_box, TRUE, TRUE, 0);
 552         gtk_box_pack_start(GTK_BOX(stat_vbox), stat_box2, TRUE, TRUE, 0);
 553
 554         hbox_l = gtk_hbox_new(FALSE, 0);
 555         gtk_widget_show(hbox_l);
 556         gtk_box_pack_start(GTK_BOX(stat_box), hbox_l, TRUE, TRUE, 0);
 557
 558         statlabel_folder = gtk_label_new("");
 559         gtk_widget_show(statlabel_folder);
 560         gtk_box_pack_start(GTK_BOX(hbox_l), statlabel_folder, FALSE, FALSE, 2);
 561         statlabel_select = gtk_label_new("");
 562         gtk_widget_show(statlabel_select);
 563         gtk_box_pack_start(GTK_BOX(hbox_l), statlabel_select, FALSE, FALSE, 12);
 564
 565         /* toggle view button */
 566         toggle_eventbox = gtk_event_box_new();
 567         gtk_widget_show(toggle_eventbox);
 568
 569         gtk_box_pack_end(GTK_BOX(hbox), toggle_eventbox, FALSE, FALSE, 4);
 570
 571         toggle_arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT);
 572         gtk_widget_show(toggle_arrow);
 573         gtk_container_add(GTK_CONTAINER(toggle_eventbox), toggle_arrow);
 574         g_signal_connect(G_OBJECT(toggle_eventbox), "button_press_event",
 575                          G_CALLBACK(summary_toggle_pressed),
 576                          summaryview);
 577
 578 #ifdef GENERIC_UMPC
 579         multiple_sel_togbtn = gtk_toggle_button_new();
 580         gtk_widget_show(multiple_sel_togbtn);
 581         gtk_box_pack_end(GTK_BOX(hbox), multiple_sel_togbtn, FALSE, FALSE, 4);
 582         CLAWS_SET_TIP(multiple_sel_togbtn,
 583                              _("Toggle multiple selection"));
 584         g_signal_connect(G_OBJECT(multiple_sel_togbtn), "toggled",
 585                          G_CALLBACK(summary_toggle_multiple_pressed),
 586                          summaryview);
 587 #endif
 588
 589         statlabel_msgs = gtk_label_new("");
 590         gtk_widget_show(statlabel_msgs);
 591         gtk_box_pack_end(GTK_BOX(stat_box), statlabel_msgs, FALSE, FALSE, 4);
 592
 593         hbox_spc = gtk_hbox_new(FALSE, 0);
 594         gtk_widget_show(hbox_spc);
 595         gtk_box_pack_end(GTK_BOX(hbox), hbox_spc, FALSE, FALSE, 6);
 596
 597         scrolledwin = gtk_scrolled_window_new(NULL, NULL);
 598         gtk_widget_show(scrolledwin);
 599         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
 600                                        GTK_POLICY_AUTOMATIC,
 601                                        GTK_POLICY_AUTOMATIC);
 602         summaryview->mainwidget_book = gtk_notebook_new();
 603         gtk_notebook_set_show_tabs(GTK_NOTEBOOK(summaryview->mainwidget_book), FALSE);
 604         gtk_notebook_set_show_border(GTK_NOTEBOOK(summaryview->mainwidget_book), FALSE);
 605 #ifndef GENERIC_UMPC
 606         gtk_container_add(GTK_CONTAINER(summaryview->mainwidget_book),
 607                 scrolledwin);
 608         gtk_box_pack_start(GTK_BOX(vbox), summaryview->mainwidget_book, TRUE, TRUE, 0);
 609 #endif
 610         gtk_widget_set_size_request(vbox,
 611                              prefs_common.summaryview_width,
 612                              prefs_common.summaryview_height);
 613
 614         ctree = summary_ctree_create(summaryview);
 615         gtk_widget_show(ctree);
 616
 617         gtk_scrolled_window_set_hadjustment(GTK_SCROLLED_WINDOW(scrolledwin),
 618                                             GTK_CMCLIST(ctree)->hadjustment);
 619         gtk_scrolled_window_set_vadjustment(GTK_SCROLLED_WINDOW(scrolledwin),
 620                                             GTK_CMCLIST(ctree)->vadjustment);
 621         gtk_container_add(GTK_CONTAINER(scrolledwin), ctree);
 622
 623         /* status label */
 624         gtk_widget_show_all(stat_vbox);
 625         gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 626
 627         /* quick search */
 628         quicksearch = quicksearch_new();
 629         gtk_box_pack_start(GTK_BOX(vbox), quicksearch_get_widget(quicksearch), FALSE, FALSE, 0);
 630
 631 #ifdef GENERIC_UMPC
 632         gtk_container_add(GTK_CONTAINER(summaryview->mainwidget_book),
 633                 scrolledwin);
 634         gtk_box_pack_start(GTK_BOX(vbox), summaryview->mainwidget_book, TRUE, TRUE, 0);
 635 #endif
 636         quicksearch_set_execute_callback(quicksearch, quicksearch_execute_cb, summaryview);
 637
 638         g_signal_connect (G_OBJECT(toggle_search), "toggled",
 639                           G_CALLBACK(tog_searchbar_cb), summaryview);
 640
 641         /* create popup menu */
 642
 643         gtk_action_group_add_actions(mainwin->action_group, summary_popup_entries,
 644                         G_N_ELEMENTS(summary_popup_entries), (gpointer)summaryview);
 645
 646         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/", "Menus", "Menus", GTK_UI_MANAGER_MENUBAR)
 647         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus", "SummaryViewPopup", "SummaryViewPopup", GTK_UI_MANAGER_MENU)
 648         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "Reply", "Message/Reply", GTK_UI_MANAGER_MENUITEM)
 649 #ifndef GENERIC_UMPC
 650         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "ReplyTo", "SummaryViewPopup/ReplyTo", GTK_UI_MANAGER_MENU)
 651         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "Separator1", "Message/---", GTK_UI_MANAGER_SEPARATOR)
 652 #endif
 653         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "Forward", "Message/Forward", GTK_UI_MANAGER_MENUITEM)
 654 #ifndef GENERIC_UMPC
 655         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "ForwardAtt", "Message/ForwardAtt", GTK_UI_MANAGER_MENUITEM)
 656         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "Redirect", "Message/Redirect", GTK_UI_MANAGER_MENUITEM)
 657 #endif
 658         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "Separator2", "Message/---", GTK_UI_MANAGER_SEPARATOR)
 659         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "Move", "Message/Move", GTK_UI_MANAGER_MENUITEM)
 660         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "Copy", "Message/Copy", GTK_UI_MANAGER_MENUITEM)
 661         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "Trash", "Message/Trash", GTK_UI_MANAGER_MENUITEM)
 662 #ifndef GENERIC_UMPC
 663         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "Delete", "Message/Delete", GTK_UI_MANAGER_MENUITEM)
 664 #endif
 665         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "Separator3", "Message/---", GTK_UI_MANAGER_SEPARATOR)
 666         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "Mark", "SummaryViewPopup/Mark", GTK_UI_MANAGER_MENU)
 667         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "ColorLabel", "SummaryViewPopup/ColorLabel", GTK_UI_MANAGER_MENU)
 668         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "Tags", "SummaryViewPopup/Tags", GTK_UI_MANAGER_MENU)
 669
 670         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "Separator4", "Message/---", GTK_UI_MANAGER_SEPARATOR)
 671 #ifndef GENERIC_UMPC
 672         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "AddSenderToAB", "Tools/AddSenderToAB", GTK_UI_MANAGER_MENUITEM)
 673 #endif
 674         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "CreateFilterRule", "SummaryViewPopup/CreateFilterRule", GTK_UI_MANAGER_MENU)
 675 #ifndef GENERIC_UMPC
 676         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "CreateProcessingRule", "SummaryViewPopup/CreateProcessingRule", GTK_UI_MANAGER_MENU)
 677 #endif
 678         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "Separator5", "Tools/---", GTK_UI_MANAGER_SEPARATOR)
 679         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "View", "SummaryViewPopup/View", GTK_UI_MANAGER_MENU)
 680         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "SaveAs", "File/SaveAs", GTK_UI_MANAGER_MENUITEM)
 681 #ifndef GENERIC_UMPC
 682         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "Print", "File/Print", GTK_UI_MANAGER_MENUITEM)
 683 #endif
 684         /* last separator, for plugins */
 685         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup", "Separator6", "File/---", GTK_UI_MANAGER_SEPARATOR)
 686
 687         /* submenus - replyto */
 688         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/ReplyTo", "All", "Message/ReplyTo/All", GTK_UI_MANAGER_MENUITEM)
 689         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/ReplyTo", "Sender", "Message/ReplyTo/Sender", GTK_UI_MANAGER_MENUITEM)
 690         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/ReplyTo", "MailingList", "Message/ReplyTo/List", GTK_UI_MANAGER_MENUITEM)
 691
 692         /* submenus - mark */
 693         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/Mark", "Mark", "Message/Mark/Mark", GTK_UI_MANAGER_MENUITEM)
 694         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/Mark", "Unmark", "Message/Mark/Unmark", GTK_UI_MANAGER_MENUITEM)
 695         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/Mark", "Separator1", "Message/Mark/---", GTK_UI_MANAGER_SEPARATOR)
 696         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/Mark", "MarkUnread", "Message/Mark/MarkUnread", GTK_UI_MANAGER_MENUITEM)
 697         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/Mark", "MarkRead", "Message/Mark/MarkRead", GTK_UI_MANAGER_MENUITEM)
 698         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/Mark", "MarkAllRead", "Message/Mark/MarkAllRead", GTK_UI_MANAGER_MENUITEM)
 699         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/Mark", "IgnoreThread", "Message/Mark/IgnoreThread", GTK_UI_MANAGER_MENUITEM)
 700         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/Mark", "UnignoreThread", "Message/Mark/UnignoreThread", GTK_UI_MANAGER_MENUITEM)
 701         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/Mark", "WatchThread", "Message/Mark/WatchThread", GTK_UI_MANAGER_MENUITEM)
 702         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/Mark", "UnwatchThread", "Message/Mark/UnwatchThread", GTK_UI_MANAGER_MENUITEM)
 703         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/Mark", "Separator2", "Message/Mark/---", GTK_UI_MANAGER_SEPARATOR)
 704         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/Mark", "MarkSpam", "Message/Mark/MarkSpam", GTK_UI_MANAGER_MENUITEM)
 705         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/Mark", "MarkHam", "Message/Mark/MarkHam", GTK_UI_MANAGER_MENUITEM)
 706         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/Mark", "Separator3", "Message/Mark/---", GTK_UI_MANAGER_SEPARATOR)
 707         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/Mark", "Lock", "Message/Mark/Lock", GTK_UI_MANAGER_MENUITEM)
 708         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/Mark", "Unlock", "Message/Mark/Unlock", GTK_UI_MANAGER_MENUITEM)
 709
 710         /* submenus - colorlabel and tags are dynamic */
 711         /* submenus - createfilterrule */
 712         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/CreateFilterRule", "Automatically", "Tools/CreateFilterRule/Automatically", GTK_UI_MANAGER_MENUITEM)
 713         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/CreateFilterRule", "ByFrom", "Tools/CreateFilterRule/ByFrom", GTK_UI_MANAGER_MENUITEM)
 714         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/CreateFilterRule", "ByTo", "Tools/CreateFilterRule/ByTo", GTK_UI_MANAGER_MENUITEM)
 715         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/CreateFilterRule", "BySubject", "Tools/CreateFilterRule/BySubject", GTK_UI_MANAGER_MENUITEM)
 716
 717 #ifndef GENERIC_UMPC
 718         /* submenus - createprocessingrule */
 719         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/CreateProcessingRule", "Automatically", "Tools/CreateProcessingRule/Automatically", GTK_UI_MANAGER_MENUITEM)
 720         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/CreateProcessingRule", "ByFrom", "Tools/CreateProcessingRule/ByFrom", GTK_UI_MANAGER_MENUITEM)
 721         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/CreateProcessingRule", "ByTo", "Tools/CreateProcessingRule/ByTo", GTK_UI_MANAGER_MENUITEM)
 722         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/CreateProcessingRule", "BySubject", "Tools/CreateProcessingRule/BySubject", GTK_UI_MANAGER_MENUITEM)
 723 #endif
 724
 725         /* submenus - view */
 726         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/View", "OpenNewWindow", "View/OpenNewWindow", GTK_UI_MANAGER_MENUITEM)
 727         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/View", "MessageSource", "View/MessageSource", GTK_UI_MANAGER_MENUITEM)
 728 #ifndef GENERIC_UMPC
 729         MENUITEM_ADDUI_MANAGER(mainwin->ui_manager, "/Menus/SummaryViewPopup/View", "AllHeaders", "View/AllHeaders", GTK_UI_MANAGER_MENUITEM)
 730 #endif
 731         summaryview->popupmenu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(
 732                                 gtk_ui_manager_get_widget(mainwin->ui_manager, "/Menus/SummaryViewPopup")) );
 733
 734
 735         summaryview->vbox = vbox;
 736         summaryview->scrolledwin = scrolledwin;
 737         summaryview->ctree = ctree;
 738         summaryview->hbox = hbox;
 739         summaryview->hbox_l = hbox_l;
 740         summaryview->hbox_spc = hbox_spc;
 741         summaryview->stat_box = stat_box;
 742         summaryview->stat_box2 = stat_box2;
 743         summaryview->statlabel_folder = statlabel_folder;
 744         summaryview->statlabel_select = statlabel_select;
 745         summaryview->statlabel_msgs = statlabel_msgs;
 746         summaryview->toggle_eventbox = toggle_eventbox;
 747         summaryview->toggle_arrow = toggle_arrow;
 748 #ifdef GENERIC_UMPC
 749         summaryview->multiple_sel_togbtn = multiple_sel_togbtn;
 750 #endif
 751         summaryview->toggle_search = toggle_search;
 752         summaryview->lock_count = 0;
 753         summaryview->msginfo_update_callback_id =
 754                 hooks_register_hook(MSGINFO_UPDATE_HOOKLIST, summary_update_msg, (gpointer) summaryview);
 755         summaryview->folder_item_update_callback_id =
 756                 hooks_register_hook(FOLDER_ITEM_UPDATE_HOOKLIST,
 757                                 summary_update_folder_item_hook,
 758                                 (gpointer) summaryview);
 759         summaryview->folder_update_callback_id =
 760                 hooks_register_hook(FOLDER_UPDATE_HOOKLIST,
 761                                 summary_update_folder_hook,
 762                                 (gpointer) summaryview);
 763
 764         summaryview->target_list = gtk_target_list_new(summary_drag_types, 3);
 765
 766         summaryview->quicksearch = quicksearch;
 767
 768         /* CLAWS: need this to get the SummaryView * from
 769          * the CList */
 770         g_object_set_data(G_OBJECT(ctree), "summaryview", (gpointer)summaryview);
 771
 772         gtk_widget_show_all(vbox);
 773
 774         gtk_widget_show(vbox);
 775
 776         if (prefs_common.show_searchbar)
 777                 quicksearch_show(quicksearch);
 778         else
 779                 quicksearch_hide(quicksearch);
 780
 781         if (prefs_common.layout_mode == WIDE_MSGLIST_LAYOUT ||
 782             prefs_common.layout_mode == SMALL_LAYOUT)
 783                 gtk_widget_hide(summaryview->toggle_eventbox);
 784
 785         return summaryview;
 786 }
 787
 788 void summary_relayout(SummaryView *summaryview)
 789 {
 790         gtk_widget_realize(summaryview->stat_box);
 791
 792         g_object_ref(summaryview->hbox_l);
 793         g_object_ref(summaryview->statlabel_msgs);
 794
 795         gtkut_container_remove(GTK_CONTAINER(
 796                 gtk_widget_get_parent(summaryview->hbox_l)), summaryview->hbox_l);
 797         gtkut_container_remove(GTK_CONTAINER(
 798                 gtk_widget_get_parent(summaryview->statlabel_msgs)), summaryview->statlabel_msgs);
 799
 800         switch (prefs_common.layout_mode) {
 801         case NORMAL_LAYOUT:
 802         case WIDE_LAYOUT:
 803         case WIDE_MSGLIST_LAYOUT:
 804                 gtk_box_pack_start(GTK_BOX(summaryview->stat_box), summaryview->hbox_l, TRUE, TRUE, 0);
 805                 gtk_box_pack_end(GTK_BOX(summaryview->stat_box), summaryview->statlabel_msgs, FALSE, FALSE, 4);
 806                 gtk_widget_show_all(summaryview->stat_box);
 807                 gtk_widget_show_all(summaryview->stat_box2);
 808                 if (prefs_common.layout_mode == WIDE_MSGLIST_LAYOUT ||
 809                     prefs_common.layout_mode == SMALL_LAYOUT)
 810                         gtk_widget_hide(summaryview->toggle_eventbox);
 811                 else
 812                         gtk_widget_show(summaryview->toggle_eventbox);
 813                 break;
 814         case VERTICAL_LAYOUT:
 815         case SMALL_LAYOUT:
 816                 gtk_box_pack_start(GTK_BOX(summaryview->stat_box), summaryview->hbox_l, TRUE, TRUE, 0);
 817                 gtk_box_pack_start(GTK_BOX(summaryview->stat_box2), summaryview->statlabel_msgs, FALSE, FALSE, 4);
 818                 gtk_widget_show_all(summaryview->stat_box);
 819                 gtk_widget_show_all(summaryview->stat_box2);
 820                 if (prefs_common.layout_mode == SMALL_LAYOUT) {
 821                         gtk_widget_hide(summaryview->toggle_eventbox);
 822                         gtk_widget_hide(summaryview->statlabel_msgs);
 823                 } else {
 824                         gtk_widget_show(summaryview->toggle_eventbox);
 825                         gtk_widget_show(summaryview->statlabel_msgs);
 826                 }
 827
 828                 break;
 829         }
 830         summary_set_column_order(summaryview);
 831
 832         g_object_unref(summaryview->hbox_l);
 833         g_object_unref(summaryview->statlabel_msgs);
 834         quicksearch_relayout(summaryview->quicksearch);
 835         if (prefs_common.show_searchbar)
 836                 quicksearch_show(summaryview->quicksearch);
 837         else
 838                 quicksearch_hide(summaryview->quicksearch);
 839 }
 840
 841 static void summary_set_fonts(SummaryView *summaryview)
 842 {
 843         PangoFontDescription *font_desc;
 844         gint size;
 845
 846         font_desc = pango_font_description_from_string(NORMAL_FONT);
 847         if (font_desc) {
 848                 gtk_widget_modify_font(summaryview->ctree, font_desc);
 849                 pango_font_description_free(font_desc);
 850         }
 851
 852         if (!bold_style) {
 853                 bold_style = gtk_style_copy
 854                         (gtk_widget_get_style(summaryview->ctree));
 855
 856                 if (prefs_common.derive_from_normal_font || !BOLD_FONT) {
 857                         font_desc = pango_font_description_from_string(NORMAL_FONT);
 858                         if (font_desc) {
 859                                 pango_font_description_free(bold_style->font_desc);
 860                                 bold_style->font_desc = font_desc;
 861                         }
 862                         pango_font_description_set_weight
 863                                         (bold_style->font_desc, PANGO_WEIGHT_BOLD);
 864                 } else {
 865                         font_desc = pango_font_description_from_string(BOLD_FONT);
 866                         if (font_desc) {
 867                                 pango_font_description_free(bold_style->font_desc);
 868                                 bold_style->font_desc = font_desc;
 869                         }
 870                 }
 871                 bold_marked_style = gtk_style_copy(bold_style);
 872                 bold_marked_style->fg[GTK_STATE_NORMAL] =
 873                         summaryview->color_marked;
 874                 bold_deleted_style = gtk_style_copy(bold_style);
 875                 bold_deleted_style->fg[GTK_STATE_NORMAL] =
 876                         summaryview->color_dim;
 877         }
 878
 879         if (prefs_common.derive_from_normal_font || !SMALL_FONT) {
 880                 font_desc = pango_font_description_new();
 881                 size = pango_font_description_get_size
 882                         (gtk_widget_get_style(summaryview->ctree)->font_desc);
 883                 pango_font_description_set_size(font_desc, size * PANGO_SCALE_SMALL);
 884         } else {
 885                 font_desc = pango_font_description_from_string(SMALL_FONT);
 886         }
 887         if (font_desc) {
 888                 gtk_widget_modify_font(summaryview->statlabel_folder, font_desc);
 889                 gtk_widget_modify_font(summaryview->statlabel_select, font_desc);
 890                 gtk_widget_modify_font(summaryview->statlabel_msgs, font_desc);
 891                 pango_font_description_free(font_desc);
 892         }
 893
 894 }
 895
 896 static void summary_set_folder_pixmap(SummaryView *summaryview, StockPixmap icon)
 897 {
 898         GtkWidget *pixmap;
 899         if (!summaryview->folder_pixmap_eventbox) {
 900                 summaryview->folder_pixmap_eventbox = gtk_event_box_new();
 901                 gtk_widget_show(summaryview->folder_pixmap_eventbox);
 902                 gtk_box_pack_start(GTK_BOX(summaryview->hbox_l), summaryview->folder_pixmap_eventbox, FALSE, FALSE, 4);
 903                 gtk_box_reorder_child(GTK_BOX(summaryview->hbox_l), summaryview->folder_pixmap_eventbox, 0); /* search_toggle before */
 904                 g_signal_connect(G_OBJECT(summaryview->folder_pixmap_eventbox), "button_press_event",
 905                          G_CALLBACK(summary_folder_eventbox_pressed),
 906                          summaryview);
 907         }
 908         if (summaryview->folder_pixmap)
 909                 gtk_widget_destroy(summaryview->folder_pixmap);
 910
 911         pixmap = stock_pixmap_widget(summaryview->hbox_l, icon);
 912         gtk_container_add(GTK_CONTAINER(summaryview->folder_pixmap_eventbox), pixmap);
 913         gtk_widget_show(pixmap);
 914         summaryview->folder_pixmap = pixmap;
 915 }
 916
 917 void summary_init(SummaryView *summaryview)
 918 {
 919         GtkWidget *pixmap;
 920
 921         gtk_widget_realize(summaryview->ctree);
 922         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_MARK,
 923                          &markxpm);
 924         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_DELETED,
 925                          &deletedxpm);
 926         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_NEW,
 927                          &newxpm);
 928         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_UNREAD,
 929                          &unreadxpm);
 930         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_REPLIED,
 931                          &repliedxpm);
 932         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_FORWARDED,
 933                          &forwardedxpm);
 934         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_CLIP,
 935                          &clipxpm);
 936         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_LOCKED,
 937                          &lockedxpm);
 938         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_IGNORETHREAD,
 939                          &ignorethreadxpm);
 940         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_WATCHTHREAD,
 941                          &watchthreadxpm);
 942         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_CLIP_KEY,
 943                          &clipkeyxpm);
 944         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_KEY_SIGN,
 945                          &keysignxpm);
 946         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_KEY,
 947                          &keyxpm);
 948         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_GPG_SIGNED,
 949                          &gpgsignedxpm);
 950         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_CLIP_GPG_SIGNED,
 951                          &clipgpgsignedxpm);
 952         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_SPAM,
 953                          &spamxpm);
 954         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_MOVED,
 955                          &movedxpm);
 956         stock_pixbuf_gdk(summaryview->ctree, STOCK_PIXMAP_COPIED,
 957                          &copiedxpm);
 958
 959         summary_set_fonts(summaryview);
 960
 961         summary_set_folder_pixmap(summaryview, STOCK_PIXMAP_DIR_OPEN);
 962
 963         pixmap = stock_pixmap_widget(summaryview->hbox, STOCK_PIXMAP_QUICKSEARCH);
 964         gtk_container_add (GTK_CONTAINER(summaryview->toggle_search), pixmap);
 965         gtk_widget_show(pixmap);
 966         summaryview->quick_search_pixmap = pixmap;
 967
 968 #ifdef GENERIC_UMPC
 969         pixmap = stock_pixmap_widget(summaryview->hbox, STOCK_PIXMAP_SELECTION);
 970         gtk_container_add(GTK_CONTAINER(summaryview->multiple_sel_togbtn), pixmap);
 971         gtk_widget_show(pixmap);
 972         summaryview->multiple_sel_image = pixmap;
 973 #endif
 974
 975         /* Init summaryview prefs */
 976         summaryview->sort_key = SORT_BY_NONE;
 977         summaryview->sort_type = SORT_ASCENDING;
 978
 979         /* Init summaryview extra data */
 980 #ifndef G_OS_WIN32
 981         summaryview->simplify_subject_preg = NULL;
 982 #endif
 983         summary_clear_list(summaryview);
 984         summary_set_column_titles(summaryview);
 985         summary_colorlabel_menu_create(summaryview, FALSE);
 986         summary_tags_menu_create(summaryview, FALSE);
 987         main_create_mailing_list_menu (summaryview->mainwin, NULL);
 988         summary_set_menu_sensitive(summaryview);
 989
 990 }
 991
 992 #define CURRENTLY_DISPLAYED(m) \
 993 ( (m->msgnum == displayed_msgnum) \
 994   && (!g_ascii_strcasecmp(m->folder->name,item->name)) )
 995
 996 #define FOLDER_SHOWS_TO_HDR(i) \
 997 ( i && (folder_has_parent_of_type(i, F_OUTBOX) \
 998         || folder_has_parent_of_type(i, F_DRAFT) \
 999         || folder_has_parent_of_type(i, F_QUEUE)) )
1000
1001 static void summary_switch_from_to(SummaryView *summaryview, FolderItem *item)
1002 {
1003         gboolean show_from = FALSE, show_to = FALSE;
1004         gboolean showing_from = FALSE, showing_to = FALSE;
1005         gint from_pos = 0, to_pos = 0;
1006         SummaryColumnState *col_state = summaryview->col_state;
1007         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
1008
1009         if (!item || (prefs_common.layout_mode == VERTICAL_LAYOUT && prefs_common.two_line_vert) )
1010                 return;
1011         if (FOLDER_SHOWS_TO_HDR(item))
1012                 show_to = TRUE;
1013         else
1014                 show_from = TRUE;
1015
1016         from_pos = summaryview->col_pos[S_COL_FROM];
1017         to_pos = summaryview->col_pos[S_COL_TO];
1018         showing_from = col_state[from_pos].visible;
1019         showing_to = col_state[to_pos].visible;
1020
1021         if (showing_from && showing_to) {
1022                 debug_print("showing both\n");
1023                 return;
1024         }
1025
1026         if (!showing_from && !showing_to) {
1027                 debug_print("showing none\n");
1028                 return;
1029         }
1030
1031         debug_print("showing %s %s, must show %s %s\n",
1032                 showing_from?"From":"",
1033                 showing_to?"To":"",
1034                 show_from?"From":"",
1035                 show_to?"To":"");
1036
1037         if (showing_from == show_from && showing_to == show_to)
1038                 return;
1039         /* else we'll switch both */
1040
1041         debug_print("switching columns\n");
1042         col_state[from_pos].type = S_COL_TO;
1043         col_state[from_pos].visible = show_to;
1044
1045         col_state[to_pos].type = S_COL_FROM;
1046         col_state[to_pos].visible = show_from;
1047
1048         summaryview->col_pos[S_COL_TO] = from_pos;
1049         summaryview->col_pos[S_COL_FROM] = to_pos;
1050
1051         gtk_cmclist_set_column_visibility
1052                 (GTK_CMCLIST(ctree), from_pos, col_state[from_pos].visible);
1053         gtk_cmclist_set_column_visibility
1054                 (GTK_CMCLIST(ctree), to_pos, col_state[to_pos].visible);
1055
1056         summary_set_column_titles(summaryview);
1057 }
1058
1059 static gboolean summaryview_quicksearch_recurse(gpointer data)
1060 {
1061         SummaryView *summaryview = (SummaryView *)data;
1062         main_window_cursor_wait(summaryview->mainwin);
1063         quicksearch_reset_cur_folder_item(summaryview->quicksearch);
1064         quicksearch_search_subfolders(summaryview->quicksearch,
1065                               summaryview->folderview,
1066                               summaryview->folder_item);
1067         main_window_cursor_normal(summaryview->mainwin);
1068         return FALSE;
1069 }
1070
1071 static gboolean summary_check_consistency(FolderItem *item, GSList *mlist)
1072 {
1073         int u = 0, n = 0, m = 0, t = 0, r = 0, f = 0, l = 0, i = 0, w = 0;
1074         GSList *cur;
1075         START_TIMING("");
1076         for(cur = mlist ; cur != NULL && cur->data != NULL ; cur = g_slist_next(cur)) {
1077                 MsgInfo * msginfo = (MsgInfo *) cur->data;
1078                 t++;
1079                 if (MSG_IS_NEW(msginfo->flags))
1080                         n++;
1081                 if (MSG_IS_UNREAD(msginfo->flags))
1082                         u++;
1083                 if (MSG_IS_MARKED(msginfo->flags))
1084                         m++;
1085                 if (MSG_IS_REPLIED(msginfo->flags))
1086                         r++;
1087                 if (MSG_IS_FORWARDED(msginfo->flags))
1088                         f++;
1089                 if (MSG_IS_LOCKED(msginfo->flags))
1090                         l++;
1091                 if (MSG_IS_IGNORE_THREAD(msginfo->flags))
1092                         i++;
1093                 if (MSG_IS_WATCH_THREAD(msginfo->flags))
1094                         w++;
1095         }
1096         if (t != item->total_msgs
1097         ||  n != item->new_msgs
1098         ||  u != item->unread_msgs
1099         ||  m != item->marked_msgs
1100         ||  r != item->replied_msgs
1101         ||  f != item->forwarded_msgs
1102         ||  l != item->locked_msgs
1103         ||  i != item->ignored_msgs
1104         ||  w != item->watched_msgs
1105         ||  (m == 0 && item->unreadmarked_msgs != 0)
1106         ||  item->unreadmarked_msgs < 0) {
1107                 debug_print("Inconsistency\n");
1108                 folder_item_scan_full(item, FALSE);
1109                 END_TIMING();
1110                 return FALSE;
1111         }
1112         END_TIMING();
1113         return TRUE;
1114 }
1115
1116 gboolean summary_show(SummaryView *summaryview, FolderItem *item)
1117 {
1118         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
1119         GtkCMCTreeNode *node = NULL;
1120         GSList *mlist = NULL;
1121         gchar *buf;
1122         gboolean is_refresh;
1123         guint selected_msgnum = 0;
1124         guint displayed_msgnum = 0;
1125         GSList *cur;
1126         GSList *not_killed;
1127         gboolean hidden_removed = FALSE;
1128
1129         if (summary_is_locked(summaryview)) return FALSE;
1130
1131         if (!summaryview->mainwin)
1132                 return FALSE;
1133         START_TIMING("");
1134         summaryview->last_displayed = NULL;
1135         summary_switch_from_to(summaryview, item);
1136
1137         inc_lock();
1138         summary_lock(summaryview);
1139
1140         menu_set_sensitive_all(GTK_MENU_SHELL(summaryview->popupmenu), TRUE);
1141
1142         utils_free_regex();
1143
1144         is_refresh = (item == summaryview->folder_item) ? TRUE : FALSE;
1145
1146         if (item && item->folder->klass->item_opened) {
1147                 item->folder->klass->item_opened(item);
1148         }
1149
1150         if (!is_refresh) {
1151                 main_create_mailing_list_menu (summaryview->mainwin, NULL);
1152                 if (prefs_common.layout_mode == SMALL_LAYOUT) {
1153                         if (item) {
1154                                 mainwindow_enter_folder(summaryview->mainwin);
1155                                 gtk_widget_grab_focus(summaryview->ctree);
1156                         }
1157                 }
1158         }
1159         if (!prefs_common.summary_quicksearch_sticky
1160          && (!prefs_common.summary_quicksearch_recurse
1161           || !quicksearch_is_active(summaryview->quicksearch)
1162           || (item && !quicksearch_is_in_subfolder(summaryview->quicksearch, item)))
1163          && !quicksearch_is_running(summaryview->quicksearch)
1164          && !is_refresh) {
1165                 quicksearch_set(summaryview->quicksearch, prefs_common.summary_quicksearch_type, "");
1166         }
1167
1168         /* STATUSBAR_POP(summaryview->mainwin); */
1169
1170         if (is_refresh) {
1171                 selected_msgnum = summary_get_msgnum(summaryview,
1172                                                      summaryview->selected);
1173                 displayed_msgnum = summary_get_msgnum(summaryview,
1174                                                       summaryview->displayed);
1175         }
1176
1177         /* process the marks if any */
1178         if (summaryview->mainwin->lock_count == 0 &&
1179             (summaryview->moved > 0 || summaryview->copied > 0)) {
1180                 AlertValue val;
1181                 gboolean changed = FALSE;
1182
1183                 val = alertpanel(_("Process mark"),
1184                                  _("Some marks are left. Process them?"),
1185                                  GTK_STOCK_NO, GTK_STOCK_YES, GTK_STOCK_CANCEL);
1186                 if (G_ALERTALTERNATE == val) {
1187                         summary_unlock(summaryview);
1188                         summary_execute(summaryview);
1189                         summary_lock(summaryview);
1190                         changed = TRUE;
1191                 } else if (G_ALERTDEFAULT == val) {
1192                         /* DO NOTHING */
1193                 } else {
1194                         summary_unlock(summaryview);
1195                         inc_unlock();
1196                         END_TIMING();
1197                         return FALSE;
1198                 }
1199                 if (changed || !quicksearch_is_active(summaryview->quicksearch))
1200                         folder_update_op_count();
1201         }
1202
1203         summary_freeze(summaryview);
1204
1205         summary_clear_list(summaryview);
1206
1207         buf = NULL;
1208         if (!item || !item->path || !folder_item_parent(item) || item->no_select) {
1209                 g_free(buf);
1210                 debug_print("empty folder (%p %s %p %d)\n\n",
1211                                 item,
1212                                 (item && item->path)?item->path:"(null)",
1213                                 item?folder_item_parent(item):0x0,
1214                                 item?item->no_select:FALSE);
1215                 summary_set_hide_read_msgs_menu(summaryview, FALSE);
1216                 summary_set_hide_del_msgs_menu(summaryview, FALSE);
1217                 summary_set_hide_read_threads_menu(summaryview, FALSE);
1218                 summary_clear_all(summaryview);
1219                 summaryview->folder_item = item;
1220                 summary_thaw(summaryview);
1221                 summary_unlock(summaryview);
1222                 inc_unlock();
1223                 if (item && quicksearch_is_running(summaryview->quicksearch)) {
1224                         main_window_cursor_wait(summaryview->mainwin);
1225                         quicksearch_reset_cur_folder_item(summaryview->quicksearch);
1226                         if (quicksearch_is_active(summaryview->quicksearch))
1227                                 quicksearch_search_subfolders(summaryview->quicksearch,
1228                                               summaryview->folderview,
1229                                               summaryview->folder_item);
1230                         main_window_cursor_normal(summaryview->mainwin);
1231                 }
1232                 END_TIMING();
1233                 return TRUE;
1234         }
1235         g_free(buf);
1236
1237         if (!is_refresh)
1238                 messageview_clear(summaryview->messageview);
1239
1240         summaryview->folder_item = item;
1241         item->opened = TRUE;
1242
1243         buf = g_strdup_printf(_("Scanning folder (%s)..."), item->path);
1244         debug_print("%s\n", buf);
1245         STATUSBAR_PUSH(summaryview->mainwin, buf);
1246         g_free(buf);
1247
1248         main_window_cursor_wait(summaryview->mainwin);
1249
1250         mlist = folder_item_get_msg_list(item);
1251
1252         if (!summary_check_consistency(item, mlist)) {
1253                 debug_print("reloading due to inconsistency\n");
1254                 procmsg_msg_list_free(mlist);
1255                 mlist = folder_item_get_msg_list(item);
1256         }
1257
1258         if ((summaryview->folder_item->hide_read_msgs
1259              || summaryview->folder_item->hide_del_msgs
1260              || summaryview->folder_item->hide_read_threads) &&
1261             quicksearch_is_active(summaryview->quicksearch) == FALSE) {
1262                 GSList *not_killed;
1263
1264                 summary_set_hide_read_msgs_menu(summaryview, summaryview->folder_item->hide_read_msgs);
1265                 summary_set_hide_del_msgs_menu(summaryview, summaryview->folder_item->hide_del_msgs);
1266                 summary_set_hide_read_threads_menu(summaryview, summaryview->folder_item->hide_read_threads);
1267                 not_killed = NULL;
1268                 for(cur = mlist ; cur != NULL && cur->data != NULL ; cur = g_slist_next(cur)) {
1269                         MsgInfo * msginfo = (MsgInfo *) cur->data;
1270
1271                         if (!msginfo->hidden) {
1272                                 if (MSG_IS_DELETED(msginfo->flags) && summaryview->folder_item->hide_del_msgs) {
1273                                         procmsg_msginfo_free(msginfo);
1274                                         continue;
1275                                 }
1276                                 if (summaryview->folder_item->hide_read_msgs) {
1277                                         if (MSG_IS_UNREAD(msginfo->flags) &&
1278                                             !MSG_IS_IGNORE_THREAD(msginfo->flags))
1279                                                 not_killed = g_slist_prepend(not_killed, msginfo);
1280                                         else if (MSG_IS_MARKED(msginfo->flags) ||
1281                                                  MSG_IS_LOCKED(msginfo->flags))
1282                                                 not_killed = g_slist_prepend(not_killed, msginfo);
1283                                         else if (is_refresh &&
1284                                                 (msginfo->msgnum == selected_msgnum ||
1285                                                  msginfo->msgnum == displayed_msgnum))
1286                                                 not_killed = g_slist_prepend(not_killed, msginfo);
1287                                         else
1288                                                 procmsg_msginfo_free(msginfo);
1289                                 } else {
1290                                         not_killed = g_slist_prepend(not_killed, msginfo);
1291                                 }
1292                          } else
1293                                 procmsg_msginfo_free(msginfo);
1294                 }
1295                 hidden_removed = TRUE;
1296                 g_slist_free(mlist);
1297                 mlist = not_killed;
1298         } else {
1299                 summary_set_hide_read_msgs_menu(summaryview, FALSE);
1300                 summary_set_hide_del_msgs_menu(summaryview, FALSE);
1301                 summary_set_hide_read_threads_menu(summaryview, FALSE);
1302         }
1303
1304         if (quicksearch_is_active(summaryview->quicksearch)) {
1305                 GSList *not_killed;
1306                 gint interval = quicksearch_is_fast(summaryview->quicksearch) ? 5000:100;
1307                 START_TIMING("quicksearch");
1308                 gint num = 0, total = summaryview->folder_item->total_msgs;
1309                 statusbar_print_all(_("Searching in %s... \n"),
1310                         summaryview->folder_item->path ?
1311                         summaryview->folder_item->path : "(null)");
1312                 not_killed = NULL;
1313                 folder_item_update_freeze();
1314                 for (cur = mlist ; cur != NULL && cur->data != NULL ; cur = g_slist_next(cur)) {
1315                         MsgInfo * msginfo = (MsgInfo *) cur->data;
1316
1317                         statusbar_progress_all(num++,total, interval);
1318
1319                         if (!msginfo->hidden && quicksearch_match(summaryview->quicksearch, msginfo))
1320                                 not_killed = g_slist_prepend(not_killed, msginfo);
1321                         else
1322                                 procmsg_msginfo_free(msginfo);
1323                         if (num % interval == 0)
1324                                 GTK_EVENTS_FLUSH();
1325                         if (!quicksearch_is_active(summaryview->quicksearch)) {
1326                                 break;
1327                         }
1328                 }
1329                 folder_item_update_thaw();
1330                 statusbar_progress_all(0,0,0);
1331                 statusbar_pop_all();
1332
1333                 hidden_removed = TRUE;
1334                 if (!quicksearch_is_active(summaryview->quicksearch)) {
1335                         debug_print("search cancelled!\n");
1336                         summary_thaw(summaryview);
1337                         STATUSBAR_POP(summaryview->mainwin);
1338                         main_window_cursor_normal(summaryview->mainwin);
1339                         summary_unlock(summaryview);
1340                         inc_unlock();
1341                         summary_show(summaryview, summaryview->folder_item);
1342                         END_TIMING();
1343                         return FALSE;
1344                 }
1345                 g_slist_free(mlist);
1346                 mlist = not_killed;
1347                 END_TIMING();
1348         }
1349
1350         if (!hidden_removed) {
1351                 START_TIMING("removing hidden");
1352                 not_killed = NULL;
1353                 for(cur = mlist ; cur != NULL && cur->data != NULL ; cur = g_slist_next(cur)) {
1354                         MsgInfo * msginfo = (MsgInfo *) cur->data;
1355
1356                         if (!msginfo->hidden)
1357                                 not_killed = g_slist_prepend(not_killed, msginfo);
1358                         else
1359                                 procmsg_msginfo_free(msginfo);
1360                 }
1361                 g_slist_free(mlist);
1362                 mlist = not_killed;
1363                 END_TIMING();
1364         }
1365
1366         STATUSBAR_POP(summaryview->mainwin);
1367
1368         /* set ctree and hash table from the msginfo list, and
1369            create the thread */
1370         summary_set_ctree_from_list(summaryview, mlist);
1371
1372         g_slist_free(mlist);
1373
1374         if (quicksearch_is_active(summaryview->quicksearch) &&
1375             quicksearch_is_running(summaryview->quicksearch)) {
1376                 /* only scan subfolders when quicksearch changed,
1377                  * not when search is the same and folder changed */
1378                 g_timeout_add(100, summaryview_quicksearch_recurse, summaryview);
1379         }
1380
1381         if (is_refresh) {
1382                 if (!quicksearch_is_in_typing(summaryview->quicksearch)) {
1383                         summaryview->last_displayed = summaryview->displayed;
1384                         summaryview->displayed =
1385                                 summary_find_msg_by_msgnum(summaryview,
1386                                                            displayed_msgnum);
1387                         if (!summaryview->displayed)
1388                                 messageview_clear(summaryview->messageview);
1389                         summary_unlock(summaryview);
1390                         summary_select_by_msgnum(summaryview, selected_msgnum);
1391                         summary_lock(summaryview);
1392                         if (!summaryview->selected) {
1393                                 /* no selected message - select first unread
1394                                    message, but do not display it */
1395                                 node = summary_find_next_flagged_msg(summaryview, NULL,
1396                                                                      MSG_UNREAD, FALSE);
1397                                 if (node == NULL && GTK_CMCLIST(ctree)->row_list != NULL)
1398                                         node = gtk_cmctree_node_nth
1399                                                 (ctree,
1400                                                  item->sort_type == SORT_DESCENDING
1401                                                  ? 0 : GTK_CMCLIST(ctree)->rows - 1);
1402                                 summary_unlock(summaryview);
1403                                 summary_select_node(summaryview, node, FALSE, TRUE);
1404                                 summary_lock(summaryview);
1405                         }
1406                 } else {
1407                         /* just select first/last */
1408                         if (GTK_CMCLIST(ctree)->row_list != NULL)
1409                                 node = gtk_cmctree_node_nth
1410                                         (ctree,
1411                                          item->sort_type == SORT_DESCENDING
1412                                          ? 0 : GTK_CMCLIST(ctree)->rows - 1);
1413                         gtk_sctree_select(GTK_SCTREE(ctree), node);
1414                         summaryview->selected = node;
1415                         gtk_cmctree_node_moveto(ctree, node, 0, 0.5, 0);
1416                 }
1417         } else {
1418                 /* backward compat */
1419                 int i = 0;
1420                 gboolean set = FALSE, stop = FALSE;
1421                 for (i = 0; i < 6; i++) {
1422                         EntryAction act = prefs_common.summary_select_prio[i];
1423
1424                         if (act != ACTION_UNSET) {
1425                                 set = TRUE;
1426                                 break;
1427                         }
1428                 }
1429                 if (!set)
1430                         prefs_summary_open_set_defaults();
1431
1432                 for (i = 0; i < 6 && node == NULL; i++) {
1433                         EntryAction act = prefs_common.summary_select_prio[i];
1434
1435                         switch(act) {
1436                         case ACTION_MARKED:
1437                                 node = summary_find_next_flagged_msg(summaryview, NULL,
1438                                              MSG_MARKED, FALSE);
1439                                 break;
1440                         case ACTION_NEW:
1441                                 node = summary_find_next_flagged_msg(summaryview, NULL,
1442                                              MSG_NEW, FALSE);
1443                                 break;
1444                         case ACTION_UNREAD:
1445                                 node = summary_find_next_flagged_msg(summaryview, NULL,
1446                                              MSG_UNREAD, FALSE);
1447                                 break;
1448                         case ACTION_LAST_OPENED:
1449                                 if (summaryview->folder_item) {
1450                                         node = summary_find_msg_by_msgnum(summaryview,
1451                                                         summaryview->folder_item->last_seen);
1452                                 }
1453                                 break;
1454                         case ACTION_LAST_LIST:
1455                                 if (GTK_CMCLIST(ctree)->row_list != NULL) {
1456                                         node = gtk_cmctree_node_nth
1457                                                 (ctree,
1458                                                  item->sort_type == SORT_DESCENDING
1459                                                  ? 0 : GTK_CMCLIST(ctree)->rows - 1);
1460                                 }
1461                                 break;
1462                         case ACTION_FIRST_LIST:
1463                                 if (GTK_CMCLIST(ctree)->row_list != NULL) {
1464                                         node = gtk_cmctree_node_nth
1465                                                 (ctree,
1466                                                  item->sort_type == SORT_ASCENDING
1467                                                  ? 0 : GTK_CMCLIST(ctree)->rows - 1);
1468                                 }
1469                                 break;
1470                         case ACTION_NOTHING:
1471                         case ACTION_UNSET:
1472                                 node = NULL;
1473                                 stop = TRUE;
1474                                 break;
1475                         }
1476
1477                         if (stop || node)
1478                                 break;
1479                 }
1480
1481                 summary_unlock(summaryview);
1482                 if (node) {
1483                         gboolean show = (prefs_common.always_show_msg == OPENMSG_ALWAYS) ||
1484                                 (prefs_common.always_show_msg == OPENMSG_WHEN_VIEW_VISIBLE &&
1485                                                 messageview_is_visible(summaryview->messageview));
1486                         summary_select_node(summaryview, node, show, TRUE);
1487                 }
1488                 summary_lock(summaryview);
1489         }
1490
1491         summary_status_show(summaryview);
1492         summary_set_menu_sensitive(summaryview);
1493         toolbar_main_set_sensitive(summaryview->mainwin);
1494
1495         summary_thaw(summaryview);
1496         debug_print("\n");
1497         STATUSBAR_PUSH(summaryview->mainwin, _("Done."));
1498         STATUSBAR_POP(summaryview->mainwin);
1499         main_window_cursor_normal(summaryview->mainwin);
1500         summary_unlock(summaryview);
1501         inc_unlock();
1502         END_TIMING();
1503         return TRUE;
1504 }
1505
1506 #undef CURRENTLY_DISPLAYED
1507
1508
1509 void summary_clear_list(SummaryView *summaryview)
1510 {
1511         GtkCMCList *clist = GTK_CMCLIST(summaryview->ctree);
1512         gint optimal_width;
1513
1514         summary_freeze(summaryview);
1515
1516         gtk_cmctree_pre_recursive(GTK_CMCTREE(summaryview->ctree),
1517                                 NULL, summary_free_msginfo_func, NULL);
1518
1519         if (summaryview->folder_item) {
1520                 summaryview->folder_item->opened = FALSE;
1521                 summaryview->folder_item = NULL;
1522         }
1523
1524         summaryview->display_msg = FALSE;
1525
1526         summaryview->selected = NULL;
1527         summaryview->displayed = NULL;
1528         summaryview->total_size = 0;
1529         summaryview->deleted = summaryview->moved = 0;
1530         summaryview->copied = 0;
1531         if (summaryview->msgid_table) {
1532                 g_hash_table_destroy(summaryview->msgid_table);
1533                 summaryview->msgid_table = NULL;
1534         }
1535         if (summaryview->subject_table) {
1536                 g_hash_table_destroy(summaryview->subject_table);
1537                 summaryview->subject_table = NULL;
1538         }
1539         summaryview->mlist = NULL;
1540
1541         gtk_cmclist_clear(clist);
1542         if (summaryview->col_pos[S_COL_SUBJECT] == N_SUMMARY_COLS - 1) {
1543                 optimal_width = gtk_cmclist_optimal_column_width
1544                         (clist, summaryview->col_pos[S_COL_SUBJECT]);
1545                 gtk_cmclist_set_column_width
1546                         (clist, summaryview->col_pos[S_COL_SUBJECT],
1547                          optimal_width);
1548         }
1549
1550         summary_thaw(summaryview);
1551 }
1552
1553 void summary_clear_all(SummaryView *summaryview)
1554 {
1555         messageview_clear(summaryview->messageview);
1556         summary_clear_list(summaryview);
1557         summary_set_menu_sensitive(summaryview);
1558         toolbar_main_set_sensitive(summaryview->mainwin);
1559         summary_status_show(summaryview);
1560 }
1561
1562 void summary_lock(SummaryView *summaryview)
1563 {
1564         summaryview->lock_count++;
1565 }
1566
1567 void summary_unlock(SummaryView *summaryview)
1568 {
1569         if (summaryview->lock_count)
1570                 summaryview->lock_count--;
1571 }
1572
1573 gboolean summary_is_locked(SummaryView *summaryview)
1574 {
1575         return summaryview->lock_count > 0;
1576 }
1577
1578 SummarySelection summary_get_selection_type(SummaryView *summaryview)
1579 {
1580         GtkCMCList *clist = GTK_CMCLIST(summaryview->ctree);
1581         SummarySelection selection;
1582
1583         if (!clist->row_list)
1584                 selection = SUMMARY_NONE;
1585         else if (!clist->selection)
1586                 selection = SUMMARY_SELECTED_NONE;
1587         else if (!clist->selection->next)
1588                 selection = SUMMARY_SELECTED_SINGLE;
1589         else
1590                 selection = SUMMARY_SELECTED_MULTIPLE;
1591
1592         return selection;
1593 }
1594
1595 /*!
1596  *\return       MsgInfo * Selected message if there's one selected;
1597  *              if multiple selected, or none, return NULL.
1598  */
1599 MsgInfo *summary_get_selected_msg(SummaryView *summaryview)
1600 {
1601         /* summaryview->selected may be valid when multiple
1602          * messages were selected */
1603         GList *sellist = GTK_CMCLIST(summaryview->ctree)->selection;
1604
1605         if (sellist == NULL || sellist->next)
1606                 return NULL;
1607
1608         return GTKUT_CTREE_NODE_GET_ROW_DATA(sellist->data);
1609 }
1610
1611 GSList *summary_get_selected_msg_list(SummaryView *summaryview)
1612 {
1613         GSList *mlist = NULL;
1614         GList *cur;
1615         MsgInfo *msginfo;
1616
1617         for (cur = GTK_CMCLIST(summaryview->ctree)->selection; cur != NULL && cur->data != NULL;
1618              cur = cur->next) {
1619                 msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(cur->data);
1620                 mlist = g_slist_prepend(mlist, msginfo);
1621         }
1622
1623         mlist = g_slist_reverse(mlist);
1624
1625         return mlist;
1626 }
1627
1628 void summary_set_menu_sensitive(SummaryView *summaryview)
1629 {
1630         SensitiveCond state;
1631         gboolean sensitive;
1632         gint i;
1633
1634         static const struct {
1635                 gchar *const entry;
1636                 SensitiveCond cond;
1637         } entry[] = {
1638                 {"Menus/SummaryViewPopup/Reply"                 , M_HAVE_ACCOUNT|M_TARGET_EXIST},
1639 #ifndef GENERIC_UMPC
1640                 {"Menus/SummaryViewPopup/ReplyTo"                       , M_HAVE_ACCOUNT|M_TARGET_EXIST},
1641                 {"Menus/SummaryViewPopup/ReplyTo/All"           , M_HAVE_ACCOUNT|M_TARGET_EXIST},
1642                 {"Menus/SummaryViewPopup/ReplyTo/Sender"             , M_HAVE_ACCOUNT|M_TARGET_EXIST},
1643                 {"Menus/SummaryViewPopup/ReplyTo/MailingList"       , M_HAVE_ACCOUNT|M_TARGET_EXIST},
1644 #endif
1645
1646                 {"Menus/SummaryViewPopup/Forward"                       , M_HAVE_ACCOUNT|M_TARGET_EXIST},
1647 #ifndef GENERIC_UMPC
1648                 {"Menus/SummaryViewPopup/ForwardAtt"    , M_HAVE_ACCOUNT|M_TARGET_EXIST},
1649                 {"Menus/SummaryViewPopup/Redirect"                      , M_HAVE_ACCOUNT|M_TARGET_EXIST},
1650 #endif
1651
1652                 {"Menus/SummaryViewPopup/Move"                  , M_TARGET_EXIST|M_ALLOW_DELETE|M_NOT_NEWS},
1653                 {"Menus/SummaryViewPopup/Copy"                  , M_TARGET_EXIST|M_EXEC},
1654                 {"Menus/SummaryViewPopup/Trash"         , M_TARGET_EXIST|M_ALLOW_DELETE|M_NOT_NEWS|M_NOT_TRASH},
1655 #ifndef GENERIC_UMPC
1656                 {"Menus/SummaryViewPopup/Delete"                        , M_TARGET_EXIST|M_ALLOW_DELETE},
1657 #endif
1658
1659                 {"Menus/SummaryViewPopup/Mark"                  , M_TARGET_EXIST},
1660                 {"Menus/SummaryViewPopup/Mark/Mark"             , M_TARGET_EXIST},
1661                 {"Menus/SummaryViewPopup/Mark/Unmark"                   , M_TARGET_EXIST},
1662                 {"Menus/SummaryViewPopup/Mark/MarkUnread"       , M_TARGET_EXIST},
1663                 {"Menus/SummaryViewPopup/Mark/MarkRead"         , M_TARGET_EXIST},
1664                 {"Menus/SummaryViewPopup/Mark/MarkAllRead"      , M_TARGET_EXIST},
1665                 {"Menus/SummaryViewPopup/Mark/IgnoreThread"     , M_TARGET_EXIST},
1666                 {"Menus/SummaryViewPopup/Mark/UnignoreThread"           , M_TARGET_EXIST},
1667                 {"Menus/SummaryViewPopup/Mark/WatchThread"              , M_TARGET_EXIST},
1668                 {"Menus/SummaryViewPopup/Mark/UnwatchThread"    , M_TARGET_EXIST},
1669                 {"Menus/SummaryViewPopup/Mark/Unlock"                   , M_TARGET_EXIST},
1670                 {"Menus/SummaryViewPopup/Mark/Lock"             , M_TARGET_EXIST},
1671                 {"Menus/SummaryViewPopup/Mark/MarkSpam"         , M_TARGET_EXIST|M_CAN_LEARN_SPAM},
1672                 {"Menus/SummaryViewPopup/Mark/MarkHam"          , M_TARGET_EXIST|M_CAN_LEARN_SPAM},
1673                 {"Menus/SummaryViewPopup/ColorLabel"                    , M_TARGET_EXIST},
1674                 {"Menus/SummaryViewPopup/Tags"                  , M_TARGET_EXIST},
1675
1676 #ifndef GENERIC_UMPC
1677                 {"Menus/SummaryViewPopup/AddSenderToAB" , M_SINGLE_TARGET_EXIST},
1678 #endif
1679                 {"Menus/SummaryViewPopup/CreateFilterRule"              , M_SINGLE_TARGET_EXIST|M_UNLOCKED},
1680 #ifndef GENERIC_UMPC
1681                 {"Menus/SummaryViewPopup/CreateProcessingRule"  , M_SINGLE_TARGET_EXIST|M_UNLOCKED},
1682 #endif
1683
1684                 {"Menus/SummaryViewPopup/View"                  , M_SINGLE_TARGET_EXIST},
1685                 {"Menus/SummaryViewPopup/View/OpenNewWindow"     , M_SINGLE_TARGET_EXIST},
1686                 {"Menus/SummaryViewPopup/View/MessageSource"            , M_SINGLE_TARGET_EXIST},
1687 #ifndef GENERIC_UMPC
1688                 {"Menus/SummaryViewPopup/View/AllHeaders"               , M_SINGLE_TARGET_EXIST},
1689 #endif
1690                 {"Menus/SummaryViewPopup/SaveAs"                        , M_TARGET_EXIST},
1691 #ifndef GENERIC_UMPC
1692                 {"Menus/SummaryViewPopup/Print"                 , M_TARGET_EXIST},
1693 #endif
1694                 {NULL, 0}
1695         };
1696
1697         main_window_set_menu_sensitive(summaryview->mainwin);
1698
1699         state = main_window_get_current_state(summaryview->mainwin);
1700
1701         for (i = 0; entry[i].entry != NULL; i++) {
1702                 sensitive = ((entry[i].cond & state) == entry[i].cond);
1703                 cm_menu_set_sensitive_full(summaryview->mainwin->ui_manager, entry[i].entry, sensitive);
1704         }
1705
1706         summary_lock(summaryview);
1707 #ifndef GENERIC_UMPC
1708         if (summaryview->messageview
1709         &&  summaryview->messageview->mimeview
1710         &&  summaryview->messageview->mimeview->textview)
1711                 cm_toggle_menu_set_active_full(summaryview->mainwin->ui_manager, "Menus/SummaryViewPopup/View/AllHeaders",
1712                         prefs_common.show_all_headers);
1713 #endif
1714         summary_unlock(summaryview);
1715 }
1716
1717 void summary_select_prev_unread(SummaryView *summaryview)
1718 {
1719         GtkCMCTreeNode *node;
1720         gboolean skip_cur = FALSE;
1721
1722         if (summaryview->displayed
1723         &&  summaryview->selected == summaryview->displayed) {
1724                 debug_print("skipping current\n");
1725                 skip_cur = TRUE;
1726         }
1727
1728         node = summary_find_prev_flagged_msg
1729                 (summaryview, summaryview->selected, MSG_UNREAD, skip_cur);
1730
1731         if (!node || node == summaryview->selected) {
1732                 AlertValue val = 0;
1733
1734                 switch (prefs_common.next_unread_msg_dialog) {
1735                         case NEXTUNREADMSGDIALOG_ALWAYS:
1736                                 val = alertpanel(_("No more unread messages"),
1737                                                  _("No unread message found. "
1738                                                    "Search from the end?"),
1739                                                  GTK_STOCK_NO, "+"GTK_STOCK_YES, NULL);
1740                                 break;
1741                         case NEXTUNREADMSGDIALOG_ASSUME_YES:
1742                                 val = G_ALERTALTERNATE;
1743                                 break;
1744                         case NEXTUNREADMSGDIALOG_ASSUME_NO:
1745                                 val = !G_ALERTALTERNATE;
1746                                 break;
1747                         default:
1748                                 debug_print(
1749                                         _("Internal error: unexpected value for prefs_common.next_unread_msg_dialog\n"));
1750                 }
1751                 if (val != G_ALERTALTERNATE) return;
1752                 node = summary_find_prev_flagged_msg(summaryview, NULL,
1753                                                      MSG_UNREAD, FALSE);
1754         }
1755
1756         if (!node)
1757                 alertpanel_notice(_("No unread messages."));
1758         else
1759                 summary_select_node(summaryview, node, TRUE, FALSE);
1760 }
1761
1762 void summary_select_next_unread(SummaryView *summaryview)
1763 {
1764         GtkCMCTreeNode *node = summaryview->selected;
1765         gboolean skip_cur = FALSE;
1766
1767         if (summaryview->displayed
1768         &&  summaryview->selected == summaryview->displayed) {
1769                 debug_print("skipping cur (%p %p)\n",
1770                         summaryview->displayed, summaryview->selected);
1771                 skip_cur = TRUE;
1772         }
1773
1774
1775         node = summary_find_next_flagged_msg
1776                 (summaryview, node, MSG_UNREAD, skip_cur);
1777
1778         if (node)
1779                 summary_select_node(summaryview, node, TRUE, FALSE);
1780         else {
1781                 node = summary_find_next_flagged_msg
1782                         (summaryview, NULL, MSG_UNREAD, FALSE);
1783                 if (node == NULL || node == summaryview->selected) {
1784                         AlertValue val = 0;
1785
1786                         switch (prefs_common.next_unread_msg_dialog) {
1787                                 case NEXTUNREADMSGDIALOG_ALWAYS:
1788                                         val = alertpanel(_("No more unread messages"),
1789                                                          _("No unread message found. "
1790                                                            "Go to next folder?"),
1791                                                          GTK_STOCK_NO, "+"GTK_STOCK_YES, NULL);
1792                                         break;
1793                                 case NEXTUNREADMSGDIALOG_ASSUME_YES:
1794                                         val = G_ALERTALTERNATE;
1795                                         break;
1796                                 case NEXTUNREADMSGDIALOG_ASSUME_NO:
1797                                         val = G_ALERTOTHER;
1798                                         break;
1799                                 default:
1800                                         debug_print(
1801                                                 _("Internal error: unexpected value for prefs_common.next_unread_msg_dialog\n"));
1802                         }
1803
1804                         if (val == G_ALERTALTERNATE) {
1805                                 folderview_select_next_unread(summaryview->folderview, TRUE);
1806                                 return;
1807                         }
1808                         else
1809                                 return;
1810                 } else
1811                         summary_select_node(summaryview, node, TRUE, FALSE);
1812
1813         }
1814 }
1815
1816 void summary_select_prev_new(SummaryView *summaryview)
1817 {
1818         GtkCMCTreeNode *node;
1819         gboolean skip_cur = FALSE;
1820
1821         if (summaryview->displayed
1822         &&  summaryview->selected == summaryview->displayed) {
1823                 debug_print("skipping current\n");
1824                 skip_cur = TRUE;
1825         }
1826
1827         node = summary_find_prev_flagged_msg
1828                 (summaryview, summaryview->selected, MSG_NEW, skip_cur);
1829
1830         if (!node || node == summaryview->selected) {
1831                 AlertValue val = 0;
1832
1833                 switch (prefs_common.next_unread_msg_dialog) {
1834                         case NEXTUNREADMSGDIALOG_ALWAYS:
1835                                 val = alertpanel(_("No more new messages"),
1836                                                  _("No new message found. "
1837                                                    "Search from the end?"),
1838                                                  GTK_STOCK_NO, "+"GTK_STOCK_YES, NULL);
1839                                 break;
1840                         case NEXTUNREADMSGDIALOG_ASSUME_YES:
1841                                 val = G_ALERTALTERNATE;
1842                                 break;
1843                         case NEXTUNREADMSGDIALOG_ASSUME_NO:
1844                                 val = !G_ALERTALTERNATE;
1845                                 break;
1846                         default:
1847                                 debug_print(
1848                                         _("Internal error: unexpected value for prefs_common.next_unread_msg_dialog\n"));
1849                 }
1850                 if (val != G_ALERTALTERNATE) return;
1851                 node = summary_find_prev_flagged_msg(summaryview, NULL,
1852                                                      MSG_NEW, FALSE);
1853         }
1854
1855         if (!node)
1856                 alertpanel_notice(_("No new messages."));
1857         else
1858                 summary_select_node(summaryview, node, TRUE, FALSE);
1859 }
1860
1861 void summary_select_next_new(SummaryView *summaryview)
1862 {
1863         GtkCMCTreeNode *node = summaryview->selected;
1864         gboolean skip_cur = FALSE;
1865
1866         if (summaryview->displayed
1867         &&  summaryview->selected == summaryview->displayed) {
1868                 debug_print("skipping cur (%p %p)\n",
1869                         summaryview->displayed, summaryview->selected);
1870                 skip_cur = TRUE;
1871         }
1872
1873
1874         node = summary_find_next_flagged_msg
1875                 (summaryview, node, MSG_NEW, skip_cur);
1876
1877         if (node)
1878                 summary_select_node(summaryview, node, TRUE, FALSE);
1879         else {
1880                 node = summary_find_next_flagged_msg
1881                         (summaryview, NULL, MSG_NEW, FALSE);
1882                 if (node == NULL || node == summaryview->selected) {
1883                         AlertValue val = 0;
1884
1885                         switch (prefs_common.next_unread_msg_dialog) {
1886                                 case NEXTUNREADMSGDIALOG_ALWAYS:
1887                                         val = alertpanel(_("No more new messages"),
1888                                                          _("No new message found. "
1889                                                            "Go to next folder?"),
1890                                                          GTK_STOCK_NO, "+"GTK_STOCK_YES, NULL);
1891                                         break;
1892                                 case NEXTUNREADMSGDIALOG_ASSUME_YES:
1893                                         val = G_ALERTALTERNATE;
1894                                         break;
1895                                 case NEXTUNREADMSGDIALOG_ASSUME_NO:
1896                                         val = G_ALERTOTHER;
1897                                         break;
1898                                 default:
1899                                         debug_print(
1900                                                 _("Internal error: unexpected value for prefs_common.next_unread_msg_dialog\n"));
1901                         }
1902
1903                         if (val == G_ALERTALTERNATE) {
1904                                 folderview_select_next_new(summaryview->folderview);
1905                                 return;
1906                         }
1907                         else
1908                                 return;
1909                 } else
1910                         summary_select_node(summaryview, node, TRUE, FALSE);
1911
1912         }
1913 }
1914
1915 void summary_select_prev_marked(SummaryView *summaryview)
1916 {
1917         GtkCMCTreeNode *node;
1918
1919         node = summary_find_prev_flagged_msg
1920                 (summaryview, summaryview->selected, MSG_MARKED, TRUE);
1921
1922         if (!node) {
1923                 AlertValue val;
1924
1925                 val = alertpanel(_("No more marked messages"),
1926                                  _("No marked message found. "
1927                                    "Search from the end?"),
1928                                  GTK_STOCK_NO, "+"GTK_STOCK_YES, NULL);
1929                 if (val != G_ALERTALTERNATE) return;
1930                 node = summary_find_prev_flagged_msg(summaryview, NULL,
1931                                                      MSG_MARKED, TRUE);
1932         }
1933
1934         if (!node)
1935                 alertpanel_notice(_("No marked messages."));
1936         else
1937                 summary_select_node(summaryview, node, TRUE, FALSE);
1938 }
1939
1940 void summary_select_next_marked(SummaryView *summaryview)
1941 {
1942         GtkCMCTreeNode *node = summaryview->selected;
1943         gboolean skip_cur = FALSE;
1944
1945         if (summaryview->displayed
1946         &&  summaryview->selected == summaryview->displayed) {
1947                 debug_print("skipping cur (%p %p)\n",
1948                         summaryview->displayed, summaryview->selected);
1949                 skip_cur = TRUE;
1950         }
1951
1952
1953         node = summary_find_next_flagged_msg
1954                 (summaryview, node, MSG_MARKED, skip_cur);
1955
1956         if (node)
1957                 summary_select_node(summaryview, node, TRUE, FALSE);
1958         else {
1959                 node = summary_find_next_flagged_msg
1960                         (summaryview, NULL, MSG_MARKED, FALSE);
1961                 if (node == NULL || node == summaryview->selected) {
1962                         AlertValue val = 0;
1963
1964                         switch (prefs_common.next_unread_msg_dialog) {
1965                                 case NEXTUNREADMSGDIALOG_ALWAYS:
1966                                         val = alertpanel(_("No more marked messages"),
1967                                                          _("No marked message found. "
1968                                                            "Go to next folder?"),
1969                                                          GTK_STOCK_NO, "+"GTK_STOCK_YES, NULL);
1970                                         break;
1971                                 case NEXTUNREADMSGDIALOG_ASSUME_YES:
1972                                         val = G_ALERTALTERNATE;
1973                                         break;
1974                                 case NEXTUNREADMSGDIALOG_ASSUME_NO:
1975                                         val = G_ALERTOTHER;
1976                                         break;
1977                                 default:
1978                                         debug_print(
1979                                                 _("Internal error: unexpected value for prefs_common.next_unread_msg_dialog\n"));
1980                         }
1981
1982                         if (val == G_ALERTALTERNATE) {
1983                                 folderview_select_next_marked(summaryview->folderview);
1984                                 return;
1985                         }
1986                         else
1987                                 return;
1988                 } else
1989                         summary_select_node(summaryview, node, TRUE, FALSE);
1990
1991         }
1992 }
1993
1994 void summary_select_prev_labeled(SummaryView *summaryview)
1995 {
1996         GtkCMCTreeNode *node;
1997
1998         node = summary_find_prev_flagged_msg
1999                 (summaryview, summaryview->selected, MSG_CLABEL_FLAG_MASK, TRUE);
2000
2001         if (!node) {
2002                 AlertValue val;
2003
2004                 val = alertpanel(_("No more labeled messages"),
2005                                  _("No labeled message found. "
2006                                    "Search from the end?"),
2007                                  GTK_STOCK_NO, "+"GTK_STOCK_YES, NULL);
2008                 if (val != G_ALERTALTERNATE) return;
2009                 node = summary_find_prev_flagged_msg(summaryview, NULL,
2010                                                      MSG_CLABEL_FLAG_MASK, TRUE);
2011         }
2012
2013         if (!node)
2014                 alertpanel_notice(_("No labeled messages."));
2015         else
2016                 summary_select_node(summaryview, node, TRUE, FALSE);
2017 }
2018
2019 void summary_select_next_labeled(SummaryView *summaryview)
2020 {
2021         GtkCMCTreeNode *node;
2022
2023         node = summary_find_next_flagged_msg
2024                 (summaryview, summaryview->selected, MSG_CLABEL_FLAG_MASK, TRUE);
2025
2026         if (!node) {
2027                 AlertValue val;
2028
2029                 val = alertpanel(_("No more labeled messages"),
2030                                  _("No labeled message found. "
2031                                    "Search from the beginning?"),
2032                                  GTK_STOCK_NO, "+"GTK_STOCK_YES, NULL);
2033                 if (val != G_ALERTALTERNATE) return;
2034                 node = summary_find_next_flagged_msg(summaryview, NULL,
2035                                                      MSG_CLABEL_FLAG_MASK, TRUE);
2036         }
2037
2038         if (!node)
2039                 alertpanel_notice(_("No labeled messages."));
2040         else
2041                 summary_select_node(summaryview, node, TRUE, FALSE);
2042 }
2043
2044 void summary_select_last_read(SummaryView *summaryview)
2045 {
2046         if (summaryview->last_displayed)
2047                 summary_select_node(summaryview, summaryview->last_displayed, TRUE, FALSE);
2048 }
2049
2050 void summary_select_parent(SummaryView *summaryview)
2051 {
2052         GtkCMCTreeNode *node = NULL;
2053
2054         if (summaryview->selected)
2055                 node = GTK_CMCTREE_ROW(summaryview->selected)->parent;
2056         if (node)
2057                 summary_select_node(summaryview, node, TRUE, FALSE);
2058 }
2059
2060 void summary_select_by_msgnum(SummaryView *summaryview, guint msgnum)
2061 {
2062         GtkCMCTreeNode *node;
2063
2064         node = summary_find_msg_by_msgnum(summaryview, msgnum);
2065         summary_select_node(summaryview, node, FALSE, TRUE);
2066 }
2067
2068 void summary_select_by_msg_list(SummaryView     *summaryview, GSList *msginfos)
2069 {
2070         GtkCMCTree *ctree;
2071         GSList *msgnum_list, *walk;
2072         gboolean froze = FALSE;
2073
2074         ctree = GTK_CMCTREE(summaryview->ctree);
2075
2076         msgnum_list = NULL;
2077         for(walk = msginfos; walk; walk = walk->next) {
2078                 MsgInfo *msginfo;
2079                 msginfo = walk->data;
2080                 msgnum_list = g_slist_prepend(msgnum_list, GUINT_TO_POINTER(msginfo->msgnum));
2081         }
2082         START_LONG_OPERATION(summaryview, FALSE);
2083         for(walk = msgnum_list; walk; walk = walk->next) {
2084                 GtkCMCTreeNode *node;
2085                 node = summary_find_msg_by_msgnum(summaryview, GPOINTER_TO_UINT(walk->data));
2086                 gtk_cmctree_select(ctree, node);
2087         }
2088         END_LONG_OPERATION(summaryview);
2089         g_slist_free(msgnum_list);
2090 }
2091
2092 typedef struct _PostponedSelectData
2093 {
2094         GtkCMCTree *ctree;
2095         GtkCMCTreeNode *row;
2096         GtkCMCTreeNode *node;
2097         GtkScrollType type;
2098         gint column;
2099         SummaryView *summaryview;
2100         gboolean display_msg;
2101         gboolean do_refresh;
2102 } PostponedSelectData;
2103
2104 static gboolean summary_select_retry(void *data)
2105 {
2106         PostponedSelectData *psdata = (PostponedSelectData *)data;
2107         debug_print("trying again\n");
2108         if (psdata->row)
2109                 summary_selected(psdata->ctree, psdata->row,
2110                             psdata->column, psdata->summaryview);
2111         else if (psdata->node)
2112                 summary_select_node(psdata->summaryview, psdata->node,
2113                             psdata->display_msg, psdata->do_refresh);
2114         else
2115                 summary_step(psdata->summaryview, psdata->type);
2116         g_free(psdata);
2117         return FALSE;
2118 }
2119
2120 /**
2121  * summary_select_node:
2122  * @summaryview: Summary view.
2123  * @node: Summary tree node.
2124  * @display_msg: TRUE to display the selected message.
2125  * @do_refresh: TRUE to refresh the widget.
2126  *
2127  * Select @node (bringing it into view by scrolling and expanding its
2128  * thread, if necessary) and unselect all others.  If @display_msg is
2129  * TRUE, display the corresponding message in the message view.
2130  * If @do_refresh is TRUE, the widget is refreshed.
2131  **/
2132 void summary_select_node(SummaryView *summaryview, GtkCMCTreeNode *node,
2133                          gboolean display_msg, gboolean do_refresh)
2134 {
2135         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
2136
2137         if (summary_is_locked(summaryview)
2138         && !GTK_SCTREE(ctree)->selecting_range
2139         && summaryview->messageview->mimeview
2140         && summaryview->messageview->mimeview->type == MIMEVIEW_TEXT
2141         && summaryview->messageview->mimeview->textview->loading) {
2142                 PostponedSelectData *data = g_new0(PostponedSelectData, 1);
2143                 summaryview->messageview->mimeview->textview->stop_loading = TRUE;
2144
2145                 data->ctree = ctree;
2146                 data->row = NULL;
2147                 data->node = node;
2148                 data->summaryview = summaryview;
2149                 data->display_msg = display_msg;
2150                 data->do_refresh = do_refresh;
2151                 debug_print("postponing open of message till end of load\n");
2152                 g_timeout_add(100, summary_select_retry, data);
2153                 return;
2154         }
2155         if (summary_is_locked(summaryview)) {
2156                 return;
2157         }
2158         if (!summaryview->folder_item)
2159                 return;
2160         if (node) {
2161                 gtkut_ctree_expand_parent_all(ctree, node);
2162                 if (do_refresh) {
2163                         summary_lock(summaryview);
2164                         GTK_EVENTS_FLUSH();
2165                         summary_unlock(summaryview);
2166                         gtk_widget_grab_focus(GTK_WIDGET(ctree));
2167                         gtk_cmctree_node_moveto(ctree, node, 0, 0.5, 0);
2168                 }
2169                 if (display_msg && summaryview->displayed == node)
2170                         summaryview->displayed = NULL;
2171                 summaryview->display_msg = display_msg;
2172                 gtk_sctree_select(GTK_SCTREE(ctree), node);
2173                 if (summaryview->selected == NULL)
2174                         summaryview->selected = node;
2175         }
2176 }
2177
2178 guint summary_get_msgnum(SummaryView *summaryview, GtkCMCTreeNode *node)
2179 {
2180         GtkCMCTree *ctree =NULL;
2181         MsgInfo *msginfo;
2182
2183         if (!summaryview)
2184                 return 0;
2185         ctree = GTK_CMCTREE(summaryview->ctree);
2186         if (!node)
2187                 return 0;
2188         msginfo = gtk_cmctree_node_get_row_data(ctree, node);
2189         if (msginfo)
2190                 return msginfo->msgnum;
2191         else
2192                 return -1;
2193 }
2194
2195 static GtkCMCTreeNode *summary_find_prev_msg(SummaryView *summaryview,
2196                                            GtkCMCTreeNode *current_node)
2197 {
2198         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
2199         GtkCMCTreeNode *node;
2200         MsgInfo *msginfo;
2201
2202         if (current_node)
2203                 node = current_node;
2204         else
2205                 node = gtk_cmctree_node_nth(ctree, GTK_CMCLIST(ctree)->rows - 1);
2206
2207         for (; node != NULL; node = GTK_CMCTREE_NODE_PREV(node)) {
2208                 msginfo = gtk_cmctree_node_get_row_data(ctree, node);
2209                 if (msginfo && !MSG_IS_DELETED(msginfo->flags)) break;
2210         }
2211
2212         return node;
2213 }
2214
2215 static GtkCMCTreeNode *summary_find_next_msg(SummaryView *summaryview,
2216                                            GtkCMCTreeNode *current_node)
2217 {
2218         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
2219         GtkCMCTreeNode *node;
2220         MsgInfo *msginfo;
2221
2222         if (current_node)
2223                 node = current_node;
2224         else
2225                 node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
2226
2227         for (; node != NULL; node = gtkut_ctree_node_next(ctree, node)) {
2228                 msginfo = gtk_cmctree_node_get_row_data(ctree, node);
2229                 if (msginfo && !MSG_IS_DELETED(msginfo->flags)
2230                 && !MSG_IS_MOVE(msginfo->flags)) break;
2231         }
2232
2233         return node;
2234 }
2235
2236 static GtkCMCTreeNode *summary_find_prev_flagged_msg(SummaryView *summaryview,
2237                                                    GtkCMCTreeNode *current_node,
2238                                                    MsgPermFlags flags,
2239                                                    gboolean start_from_prev)
2240 {
2241         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
2242         GtkCMCTreeNode *node;
2243         MsgInfo *msginfo;
2244
2245         if (current_node) {
2246                 if (start_from_prev)
2247                         node = GTK_CMCTREE_NODE_PREV(current_node);
2248                 else
2249                         node = current_node;
2250         } else
2251                 node = gtk_cmctree_node_nth(ctree, GTK_CMCLIST(ctree)->rows - 1);
2252
2253         for (; node != NULL; node = GTK_CMCTREE_NODE_PREV(node)) {
2254                 msginfo = gtk_cmctree_node_get_row_data(ctree, node);
2255                 if (msginfo && (msginfo->flags.perm_flags & flags) != 0) break;
2256         }
2257
2258         return node;
2259 }
2260
2261 static GtkCMCTreeNode *summary_find_next_flagged_msg(SummaryView *summaryview,
2262                                                    GtkCMCTreeNode *current_node,
2263                                                    MsgPermFlags flags,
2264                                                    gboolean start_from_next)
2265 {
2266         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
2267         GtkCMCTreeNode *node;
2268         MsgInfo *msginfo;
2269
2270         if (current_node) {
2271                 if (start_from_next)
2272                         node = gtkut_ctree_node_next(ctree, current_node);
2273                 else
2274                         node = current_node;
2275         } else
2276                 node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
2277
2278         for (; node != NULL; node = gtkut_ctree_node_next(ctree, node)) {
2279                 msginfo = gtk_cmctree_node_get_row_data(ctree, node);
2280                 /* Find msg with matching flags but ignore messages with
2281                    ignore flags, if searching for new or unread messages */
2282                 if ((msginfo && (msginfo->flags.perm_flags & flags) != 0) &&
2283                     !(((flags & (MSG_NEW | MSG_UNREAD)) != 0) && MSG_IS_IGNORE_THREAD(msginfo->flags))
2284                         )
2285                         break;
2286         }
2287
2288         return node;
2289 }
2290
2291 static GtkCMCTreeNode *summary_find_msg_by_msgnum(SummaryView *summaryview,
2292                                                 guint msgnum)
2293 {
2294         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
2295         GtkCMCTreeNode *node;
2296         MsgInfo *msginfo;
2297
2298         node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
2299
2300         for (; node != NULL; node = gtkut_ctree_node_next(ctree, node)) {
2301                 msginfo = gtk_cmctree_node_get_row_data(ctree, node);
2302                 if (msginfo && msginfo->msgnum == msgnum) break;
2303         }
2304
2305         return node;
2306 }
2307
2308 static guint attract_hash_func(gconstpointer key)
2309 {
2310         gchar *str;
2311         gchar *p;
2312         guint h;
2313
2314         Xstrdup_a(str, (const gchar *)key, return 0);
2315         trim_subject(str);
2316
2317         p = str;
2318         h = *p;
2319
2320         if (h) {
2321                 for (p += 1; *p != '\0'; p++)
2322                         h = (h << 5) - h + *p;
2323         }
2324
2325         return h;
2326 }
2327
2328 static gint attract_compare_func(gconstpointer a, gconstpointer b)
2329 {
2330         return subject_compare((const gchar *)a, (const gchar *)b) == 0;
2331 }
2332
2333 void summary_attract_by_subject(SummaryView *summaryview)
2334 {
2335         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
2336         GtkCMCList *clist = GTK_CMCLIST(ctree);
2337         GtkCMCTreeNode *src_node;
2338         GtkCMCTreeNode *dst_node, *sibling;
2339         GtkCMCTreeNode *tmp;
2340         MsgInfo *src_msginfo, *dst_msginfo;
2341         GHashTable *subject_table;
2342
2343         debug_print("Attracting messages by subject...");
2344         STATUSBAR_PUSH(summaryview->mainwin,
2345                        _("Attracting messages by subject..."));
2346
2347         main_window_cursor_wait(summaryview->mainwin);
2348         summary_freeze(summaryview);
2349
2350         subject_table = g_hash_table_new(attract_hash_func,
2351                                          attract_compare_func);
2352
2353         for (src_node = GTK_CMCTREE_NODE(clist->row_list);
2354              src_node != NULL;
2355              src_node = tmp) {
2356                 tmp = GTK_CMCTREE_ROW(src_node)->sibling;
2357                 src_msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(src_node);
2358                 if (!src_msginfo) continue;
2359                 if (!src_msginfo->subject) continue;
2360
2361                 /* find attracting node */
2362                 dst_node = g_hash_table_lookup(subject_table,
2363                                                src_msginfo->subject);
2364
2365                 if (dst_node) {
2366                         dst_msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(dst_node);
2367
2368                         /* if the time difference is more than 20 days,
2369                            don't attract */
2370                         if (ABS(src_msginfo->date_t - dst_msginfo->date_t)
2371                             > 60 * 60 * 24 * 20)
2372                                 continue;
2373
2374                         sibling = GTK_CMCTREE_ROW(dst_node)->sibling;
2375                         if (src_node != sibling)
2376                                 gtk_cmctree_move(ctree, src_node, NULL, sibling);
2377                 }
2378
2379                 g_hash_table_insert(subject_table,
2380                                     src_msginfo->subject, src_node);
2381         }
2382
2383         g_hash_table_destroy(subject_table);
2384
2385         gtk_cmctree_node_moveto(ctree, summaryview->selected, 0, 0.5, 0);
2386
2387         summary_thaw(summaryview);
2388
2389         debug_print("done.\n");
2390         STATUSBAR_POP(summaryview->mainwin);
2391
2392         main_window_cursor_normal(summaryview->mainwin);
2393 }
2394
2395 static void summary_free_msginfo_func(GtkCMCTree *ctree, GtkCMCTreeNode *node,
2396                                       gpointer data)
2397 {
2398         MsgInfo *msginfo = gtk_cmctree_node_get_row_data(ctree, node);
2399
2400         if (msginfo)
2401                 procmsg_msginfo_free(msginfo);
2402 }
2403
2404 static void summary_set_marks_func(GtkCMCTree *ctree, GtkCMCTreeNode *node,
2405                                    gpointer data)
2406 {
2407         SummaryView *summaryview = data;
2408         MsgInfo *msginfo;
2409
2410         msginfo = gtk_cmctree_node_get_row_data(ctree, node);
2411
2412         if (MSG_IS_DELETED(msginfo->flags))
2413                 summaryview->deleted++;
2414
2415         summaryview->total_size += msginfo->size;
2416
2417         summary_set_row_marks(summaryview, node);
2418 }
2419
2420 static void summary_update_status(SummaryView *summaryview)
2421 {
2422         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
2423         GtkCMCTreeNode *node;
2424         MsgInfo *msginfo;
2425
2426         summaryview->total_size =
2427         summaryview->deleted = summaryview->moved = summaryview->copied = 0;
2428
2429         for (node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
2430              node != NULL; node = gtkut_ctree_node_next(ctree, node)) {
2431                 msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(node);
2432
2433                 if (!msginfo)
2434                         continue;
2435
2436                 if (MSG_IS_DELETED(msginfo->flags))
2437                         summaryview->deleted++;
2438                 if (MSG_IS_MOVE(msginfo->flags))
2439                         summaryview->moved++;
2440                 if (MSG_IS_COPY(msginfo->flags))
2441                         summaryview->copied++;
2442                 summaryview->total_size += msginfo->size;
2443         }
2444 }
2445
2446 static void summary_status_show(SummaryView *summaryview)
2447 {
2448         gchar *str;
2449         gchar *del, *mv, *cp;
2450         gchar *sel;
2451         gchar *spc;
2452         gchar *itstr;
2453         GList *rowlist, *cur;
2454         guint n_selected = 0, n_new = 0, n_unread = 0, n_total = 0;
2455         guint n_marked = 0, n_replied = 0, n_forwarded = 0, n_locked = 0, n_ignored = 0, n_watched = 0;
2456         goffset sel_size = 0, n_size = 0;
2457         MsgInfo *msginfo;
2458         gchar *name;
2459         gchar *tooltip;
2460
2461         if (!summaryview->folder_item) {
2462                 gtk_label_set_text(GTK_LABEL(summaryview->statlabel_folder), "");
2463                 gtk_label_set_text(GTK_LABEL(summaryview->statlabel_select), "");
2464                 gtk_label_set_text(GTK_LABEL(summaryview->statlabel_msgs),   "");
2465                 toolbar_main_set_sensitive(summaryview->mainwin);
2466                 return;
2467         }
2468
2469         rowlist = GTK_CMCLIST(summaryview->ctree)->selection;
2470         for (cur = rowlist; cur != NULL && cur->data != NULL; cur = cur->next) {
2471                 msginfo = gtk_cmctree_node_get_row_data
2472                         (GTK_CMCTREE(summaryview->ctree),
2473                          GTK_CMCTREE_NODE(cur->data));
2474                 if (msginfo) {
2475                         sel_size += msginfo->size;
2476                         n_selected++;
2477                 }
2478         }
2479
2480         if (summaryview->folder_item->hide_read_msgs
2481         || summaryview->folder_item->hide_del_msgs
2482         || summaryview->folder_item->hide_read_threads
2483         || quicksearch_is_active(summaryview->quicksearch)) {
2484                 rowlist = GTK_CMCLIST(summaryview->ctree)->row_list;
2485                 for (cur = rowlist; cur != NULL && cur->data != NULL; cur = cur->next) {
2486                         msginfo = gtk_cmctree_node_get_row_data
2487                                 (GTK_CMCTREE(summaryview->ctree),
2488                                  GTK_CMCTREE_NODE(cur));
2489                         if (msginfo) {
2490                                 n_size += msginfo->size;
2491                                 n_total++;
2492                                 if (MSG_IS_NEW(msginfo->flags))
2493                                         n_new++;
2494                                 if (MSG_IS_UNREAD(msginfo->flags))
2495                                         n_unread++;
2496                                 if (MSG_IS_MARKED(msginfo->flags))
2497                                         n_marked++;
2498                                 if (MSG_IS_REPLIED(msginfo->flags))
2499                                         n_replied++;
2500                                 if (MSG_IS_FORWARDED(msginfo->flags))
2501                                         n_forwarded++;
2502                                 if (MSG_IS_LOCKED(msginfo->flags))
2503                                         n_locked++;
2504                                 if (MSG_IS_IGNORE_THREAD(msginfo->flags))
2505                                         n_ignored++;
2506                                 if (MSG_IS_WATCH_THREAD(msginfo->flags))
2507                                         n_watched++;
2508                         }
2509                 }
2510         } else {
2511                 n_new = summaryview->folder_item->new_msgs;
2512                 n_unread = summaryview->folder_item->unread_msgs;
2513                 n_marked = summaryview->folder_item->marked_msgs;
2514                 n_replied = summaryview->folder_item->replied_msgs;
2515                 n_forwarded = summaryview->folder_item->forwarded_msgs;
2516                 n_locked = summaryview->folder_item->locked_msgs;
2517                 n_ignored = summaryview->folder_item->ignored_msgs;
2518                 n_watched = summaryview->folder_item->watched_msgs;
2519                 n_total = summaryview->folder_item->total_msgs;
2520                 n_size = summaryview->total_size;
2521         }
2522
2523         name = folder_item_get_name(summaryview->folder_item);
2524         gtk_label_set_text(GTK_LABEL(summaryview->statlabel_folder), name);
2525         g_free(name);
2526
2527         if (summaryview->deleted)
2528                 del = g_strdup_printf(_("%d deleted"), summaryview->deleted);
2529         else
2530                 del = g_strdup("");
2531         if (summaryview->moved)
2532                 mv = g_strdup_printf(_("%s%d moved"),
2533                                      summaryview->deleted ? _(", ") : "",
2534                                      summaryview->moved);
2535         else
2536                 mv = g_strdup("");
2537         if (summaryview->copied)
2538                 cp = g_strdup_printf(_("%s%d copied"),
2539                                      summaryview->deleted ||
2540                                      summaryview->moved ? _(", ") : "",
2541                                      summaryview->copied);
2542         else
2543                 cp = g_strdup("");
2544
2545         if (summaryview->deleted || summaryview->moved || summaryview->copied)
2546                 spc = "    ";
2547         else
2548                 spc = "";
2549
2550         if (n_selected) {
2551                 sel = g_strdup_printf(" (%s)", to_human_readable((goffset)sel_size));
2552                 itstr = g_strdup_printf(ngettext(" item selected"," items selected", n_selected));
2553         } else {
2554                 sel = g_strdup("");
2555                 itstr = g_strdup("");
2556         }
2557
2558         if (prefs_common.layout_mode != SMALL_LAYOUT) {
2559                 str = g_strconcat(n_selected ? itos(n_selected) : "",
2560                                                 itstr, sel, spc, del, mv, cp, NULL);
2561                 g_free(sel);
2562                 g_free(del);
2563                 g_free(mv);
2564                 g_free(cp);
2565                 g_free(itstr);
2566
2567                 gtk_label_set_text(GTK_LABEL(summaryview->statlabel_select), str);
2568                 g_free(str);
2569
2570                 str = g_strdup_printf(_("%d new, %d unread, %d total (%s)"),
2571                                               n_new, n_unread, n_total,
2572                                               to_human_readable((goffset)n_size));
2573
2574
2575                 gtk_label_set_text(GTK_LABEL(summaryview->statlabel_msgs), str);
2576                 g_free(str);
2577                 tooltip = g_strdup_printf(_("<b>Message summary</b>\n"
2578                                             "<b>New:</b> %d\n"
2579                                             "<b>Unread:</b> %d\n"
2580                                             "<b>Total:</b> %d\n"
2581                                             "<b>Size:</b> %s\n\n"
2582                                             "<b>Marked:</b> %d\n"
2583                                             "<b>Replied:</b> %d\n"
2584                                             "<b>Forwarded:</b> %d\n"
2585                                             "<b>Locked:</b> %d\n"
2586                                             "<b>Ignored:</b> %d\n"
2587                                             "<b>Watched:</b> %d"),
2588                                               n_new, n_unread, n_total,
2589                                               to_human_readable((goffset)n_size),
2590                                               n_marked,n_replied,n_forwarded,
2591                                               n_locked,n_ignored,n_watched);
2592
2593                 gtk_widget_set_tooltip_markup(GTK_WIDGET(summaryview->statlabel_msgs),
2594                                             tooltip);
2595                 g_free(tooltip);
2596         } else {
2597                 gchar *ssize, *tsize;
2598                 if (n_selected) {
2599                         ssize = g_strdup(to_human_readable((goffset)sel_size));
2600                         tsize = g_strdup(to_human_readable((goffset)n_size));
2601                         str = g_strdup_printf(_("%d/%d selected (%s/%s), %d unread"),
2602                                 n_selected, n_total, ssize, tsize, n_unread);
2603                         g_free(ssize);
2604                         g_free(tsize);
2605                 } else
2606                         str = g_strdup_printf(_("%d new, %d unread, %d total (%s)"),
2607                                 n_new, n_unread, n_total, to_human_readable((goffset)n_size));
2608                 g_free(sel);
2609                 g_free(del);
2610                 g_free(mv);
2611                 g_free(cp);
2612                 g_free(itstr);
2613
2614                 gtk_label_set_text(GTK_LABEL(summaryview->statlabel_select), str);
2615                 g_free(str);
2616         }
2617
2618         summary_set_menu_sensitive(summaryview);
2619         toolbar_main_set_sensitive(summaryview->mainwin);
2620 }
2621
2622 static void summary_set_column_titles(SummaryView *summaryview)
2623 {
2624         GtkCMCList *clist = GTK_CMCLIST(summaryview->ctree);
2625         FolderItem *item = summaryview->folder_item;
2626         GtkWidget *hbox;
2627         GtkWidget *label;
2628         GtkWidget *arrow;
2629         gint pos;
2630         const gchar *title;
2631         SummaryColumnType type;
2632         GtkJustification justify;
2633
2634         static FolderSortKey sort_by[N_SUMMARY_COLS] = {
2635                 SORT_BY_MARK,
2636                 SORT_BY_STATUS,
2637                 SORT_BY_MIME,
2638                 SORT_BY_SUBJECT,
2639                 SORT_BY_FROM,
2640                 SORT_BY_TO,
2641                 SORT_BY_DATE,
2642                 SORT_BY_SIZE,
2643                 SORT_BY_NUMBER,
2644                 SORT_BY_SCORE,
2645                 SORT_BY_LOCKED,
2646                 SORT_BY_TAGS
2647         };
2648
2649         for (pos = 0; pos < N_SUMMARY_COLS; pos++) {
2650                 type = summaryview->col_state[pos].type;
2651
2652                 /* CLAWS: mime and unread are single char headers */
2653                 justify = (type == S_COL_NUMBER || type == S_COL_SIZE)
2654                         ? GTK_JUSTIFY_RIGHT : GTK_JUSTIFY_LEFT;
2655
2656                 switch (type) {
2657                 case S_COL_SUBJECT:
2658                 case S_COL_FROM:
2659                 case S_COL_TO:
2660                 case S_COL_DATE:
2661                 case S_COL_NUMBER:
2662                         if(type == S_COL_FROM && item != NULL &&
2663                                         FOLDER_SHOWS_TO_HDR(item) &&
2664                                         !summaryview->col_state[summaryview->col_pos[S_COL_TO]].visible)
2665                                 type = S_COL_TO;
2666                         if(type == S_COL_NUMBER)
2667                                 title = gettext(col_label[type]);
2668                         else
2669                                 title = prefs_common_translated_header_name(col_label[type]);
2670                         break;
2671                 default:
2672                         title = gettext(col_label[type]);
2673                 }
2674
2675                 if (type == S_COL_MIME) {
2676                         label = gtk_image_new_from_pixbuf(clipxpm);
2677                         gtk_widget_show(label);
2678                         gtk_cmclist_set_column_widget(clist, pos, label);
2679                         gtk_sctree_set_column_tooltip(GTK_SCTREE(clist), pos, _("Attachment"));
2680                         continue;
2681                 } else if (type == S_COL_MARK) {
2682                         label = gtk_image_new_from_pixbuf(markxpm);
2683                         gtk_widget_show(label);
2684                         gtk_cmclist_set_column_widget(clist, pos, label);
2685                         gtk_sctree_set_column_tooltip(GTK_SCTREE(clist), pos, _("Mark"));
2686                         continue;
2687                 } else if (type == S_COL_LOCKED) {
2688                         label = gtk_image_new_from_pixbuf(lockedxpm);
2689                         gtk_widget_show(label);
2690                         gtk_cmclist_set_column_widget(clist, pos, label);
2691                         gtk_sctree_set_column_tooltip(GTK_SCTREE(clist), pos, _("Locked"));
2692                         continue;
2693                 } else if (type == S_COL_STATUS) {
2694                         gtk_cmclist_set_column_title(clist, pos, title);
2695                         gtk_sctree_set_column_tooltip(GTK_SCTREE(clist), pos, _("Status"));
2696                         continue;
2697                 }
2698
2699                 hbox  = gtk_hbox_new(FALSE, 4);
2700                 label = gtk_label_new(title);
2701 #ifdef GENERIC_UMPC
2702         gtk_widget_set_size_request(hbox, -1, 20);
2703 #endif
2704
2705                 if (justify == GTK_JUSTIFY_RIGHT)
2706                         gtk_box_pack_end(GTK_BOX(hbox), label,
2707                                          FALSE, FALSE, 0);
2708                 else
2709                         gtk_box_pack_start(GTK_BOX(hbox), label,
2710                                            FALSE, FALSE, 0);
2711
2712                 if (summaryview->sort_key == sort_by[type]) {
2713                         arrow = gtk_arrow_new
2714                                 (summaryview->sort_type == SORT_ASCENDING
2715                                  ? GTK_ARROW_DOWN : GTK_ARROW_UP,
2716                                  GTK_SHADOW_IN);
2717                         gtk_widget_set_size_request(GTK_WIDGET(arrow), 10, 10);
2718                         if (justify == GTK_JUSTIFY_RIGHT)
2719                                 gtk_box_pack_start(GTK_BOX(hbox), arrow,
2720                                                    FALSE, FALSE, 0);
2721                         else
2722                                 gtk_box_pack_end(GTK_BOX(hbox), arrow,
2723                                                  FALSE, FALSE, 0);
2724                 }
2725
2726                 gtk_widget_show_all(hbox);
2727                 gtk_cmclist_set_column_widget(clist, pos, hbox);
2728         }
2729 }
2730
2731 void summary_reflect_tags_changes(SummaryView *summaryview)
2732 {
2733         GtkMenuShell *menu;
2734         GList *children, *cur;
2735         GtkCMCTreeNode *node;
2736         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
2737         gboolean froze = FALSE;
2738         gboolean redisplay = FALSE;
2739
2740         /* re-create colorlabel submenu */
2741         menu = GTK_MENU_SHELL(summaryview->tags_menu);
2742         cm_return_if_fail(menu != NULL);
2743
2744         /* clear items. get item pointers. */
2745         children = gtk_container_get_children(GTK_CONTAINER(menu));
2746         for (cur = children; cur != NULL && cur->data != NULL; cur = cur->next) {
2747                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(cur->data), NULL);
2748         }
2749         g_list_free(children);
2750         summary_tags_menu_create(summaryview, TRUE);
2751
2752         START_LONG_OPERATION(summaryview, TRUE);
2753         for (node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list); node != NULL;
2754              node = gtkut_ctree_node_next(ctree, node)) {
2755                 redisplay |= summary_set_row_tag(summaryview,
2756                                            node, TRUE, FALSE, 0);
2757         }
2758         END_LONG_OPERATION(summaryview);
2759         if (redisplay)
2760                 summary_redisplay_msg(summaryview);
2761 }
2762
2763
2764 void summary_reflect_prefs(void)
2765 {
2766         static gchar *last_smallfont = NULL;
2767         static gchar *last_normalfont = NULL;
2768         static gchar *last_boldfont = NULL;
2769         static gboolean last_derive = 0;
2770         gboolean update_font = FALSE;
2771         SummaryView *summaryview = NULL;
2772
2773         if (!mainwindow_get_mainwindow())
2774                 return;
2775         summaryview = mainwindow_get_mainwindow()->summaryview;
2776
2777         if (!last_smallfont || strcmp(last_smallfont, SMALL_FONT) ||
2778                         !last_normalfont || strcmp(last_normalfont, NORMAL_FONT) ||
2779                         !last_boldfont || strcmp(last_boldfont, BOLD_FONT) ||
2780                         last_derive != prefs_common.derive_from_normal_font)
2781                 update_font = TRUE;
2782
2783         g_free(last_smallfont);
2784         last_smallfont = g_strdup(SMALL_FONT);
2785         g_free(last_normalfont);
2786         last_normalfont = g_strdup(NORMAL_FONT);
2787         g_free(last_boldfont);
2788         last_boldfont = g_strdup(BOLD_FONT);
2789         last_derive = prefs_common.derive_from_normal_font;
2790
2791         if (update_font) {
2792                 bold_style = bold_marked_style = bold_deleted_style =
2793                         small_style = small_marked_style = small_deleted_style = NULL;
2794                 summary_set_fonts(summaryview);
2795         }
2796
2797         summary_set_column_titles(summaryview);
2798         summary_relayout(summaryview);
2799
2800         if (summaryview->folder_item)
2801                 summary_show(summaryview, summaryview->folder_item);
2802 }
2803
2804 void summary_sort(SummaryView *summaryview,
2805                   FolderSortKey sort_key, FolderSortType sort_type)
2806 {
2807         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
2808         GtkCMCList *clist = GTK_CMCLIST(summaryview->ctree);
2809         GtkCMCListCompareFunc cmp_func = NULL;
2810         START_TIMING("");
2811         g_signal_handlers_block_by_func(G_OBJECT(summaryview->ctree),
2812                                        G_CALLBACK(summary_tree_expanded), summaryview);
2813         summary_freeze(summaryview);
2814
2815         switch (sort_key) {
2816         case SORT_BY_MARK:
2817                 cmp_func = (GtkCMCListCompareFunc)summary_cmp_by_mark;
2818                 break;
2819         case SORT_BY_STATUS:
2820                 cmp_func = (GtkCMCListCompareFunc)summary_cmp_by_status;
2821                 break;
2822         case SORT_BY_MIME:
2823                 cmp_func = (GtkCMCListCompareFunc)summary_cmp_by_mime;
2824                 break;
2825         case SORT_BY_NUMBER:
2826                 cmp_func = (GtkCMCListCompareFunc)summary_cmp_by_num;
2827                 break;
2828         case SORT_BY_SIZE:
2829                 cmp_func = (GtkCMCListCompareFunc)summary_cmp_by_size;
2830                 break;
2831         case SORT_BY_DATE:
2832                 cmp_func = (GtkCMCListCompareFunc)summary_cmp_by_date;
2833                 break;
2834         case SORT_BY_THREAD_DATE:
2835                 cmp_func = (GtkCMCListCompareFunc)summary_cmp_by_thread_date;
2836                 break;
2837         case SORT_BY_FROM:
2838                 cmp_func = (GtkCMCListCompareFunc)summary_cmp_by_from;
2839                 break;
2840         case SORT_BY_SUBJECT:
2841 #ifndef G_OS_WIN32
2842                 if (summaryview->simplify_subject_preg)
2843                         cmp_func = (GtkCMCListCompareFunc)summary_cmp_by_simplified_subject;
2844                 else
2845 #endif
2846                         cmp_func = (GtkCMCListCompareFunc)summary_cmp_by_subject;
2847                 break;
2848         case SORT_BY_SCORE:
2849                 cmp_func = (GtkCMCListCompareFunc)summary_cmp_by_score;
2850                 break;
2851         case SORT_BY_LABEL:
2852                 cmp_func = (GtkCMCListCompareFunc)summary_cmp_by_label;
2853                 break;
2854         case SORT_BY_TO:
2855                 cmp_func = (GtkCMCListCompareFunc)summary_cmp_by_to;
2856                 break;
2857         case SORT_BY_LOCKED:
2858                 cmp_func = (GtkCMCListCompareFunc)summary_cmp_by_locked;
2859                 break;
2860         case SORT_BY_TAGS:
2861                 cmp_func = (GtkCMCListCompareFunc)summary_cmp_by_tags;
2862                 break;
2863         case SORT_BY_NONE:
2864                 break;
2865         default:
2866                 goto unlock;
2867         }
2868
2869         summaryview->sort_key = sort_key;
2870         summaryview->sort_type = sort_type;
2871
2872         summary_set_column_titles(summaryview);
2873         summary_set_menu_sensitive(summaryview);
2874
2875         /* allow fallback to don't sort */
2876         if (summaryview->sort_key == SORT_BY_NONE)
2877                 goto unlock;
2878
2879         if (cmp_func != NULL) {
2880                 debug_print("Sorting summary...");
2881                 STATUSBAR_PUSH(summaryview->mainwin, _("Sorting summary..."));
2882
2883                 main_window_cursor_wait(summaryview->mainwin);
2884
2885                 gtk_cmclist_set_compare_func(clist, cmp_func);
2886
2887                 gtk_cmclist_set_sort_type(clist, (GtkSortType)sort_type);
2888                 gtk_sctree_sort_recursive(ctree, NULL);
2889
2890                 gtk_cmctree_node_moveto(ctree, summaryview->selected, 0, 0.5, 0);
2891
2892                 main_window_cursor_normal(summaryview->mainwin);
2893
2894                 debug_print("done.\n");
2895                 STATUSBAR_POP(summaryview->mainwin);
2896         }
2897 unlock:
2898         summary_thaw(summaryview);
2899         g_signal_handlers_unblock_by_func(G_OBJECT(summaryview->ctree),
2900                                        G_CALLBACK(summary_tree_expanded), summaryview);
2901         END_TIMING();
2902 }
2903
2904 static gboolean summary_update_thread_age(GNode *node, gpointer data)
2905 {
2906         MsgInfo *msginfo = node->data;
2907         time_t *most_recent = (time_t *)data;
2908
2909         if (msginfo->date_t > *most_recent) {
2910                 *most_recent = msginfo->date_t;
2911         }
2912         return FALSE;
2913 }
2914
2915 static void summary_find_thread_age(GNode *gnode)
2916 {
2917         MsgInfo *msginfo = (MsgInfo *)gnode->data;
2918         time_t most_recent;
2919
2920         if (!msginfo)
2921                 return;
2922         most_recent = msginfo->thread_date = msginfo->date_t;
2923
2924         g_node_traverse(gnode, G_IN_ORDER, G_TRAVERSE_ALL, -1, summary_update_thread_age, &most_recent);
2925
2926         msginfo->thread_date = most_recent;
2927 }
2928
2929 static gboolean summary_update_is_read(GNode *node, gpointer data)
2930 {
2931         MsgInfo *msginfo = node->data;
2932         gboolean *all_read = (gboolean *)data;
2933
2934         if (MSG_IS_UNREAD(msginfo->flags)) {
2935                 *all_read = FALSE;
2936                 return TRUE;
2937         }
2938         return FALSE;
2939 }
2940
2941 static gboolean summary_thread_is_read(GNode *gnode)
2942 {
2943         MsgInfo *msginfo = (MsgInfo *)gnode->data;
2944         gboolean all_read = TRUE;
2945
2946         if (!msginfo)
2947                 return all_read;
2948
2949         g_node_traverse(gnode, G_IN_ORDER, G_TRAVERSE_ALL, -1, summary_update_is_read, &all_read);
2950     return all_read;
2951 }
2952
2953 static gboolean summary_insert_gnode_func(GtkCMCTree *ctree, guint depth, GNode *gnode,
2954                                    GtkCMCTreeNode *cnode, gpointer data)
2955 {
2956         SummaryView *summaryview = (SummaryView *)data;
2957         MsgInfo *msginfo = (MsgInfo *)gnode->data;
2958         gchar *text[N_SUMMARY_COLS];
2959         gint *col_pos = summaryview->col_pos;
2960         const gchar *msgid = msginfo->msgid;
2961         GHashTable *msgid_table = summaryview->msgid_table;
2962         gboolean vert = (prefs_common.layout_mode == VERTICAL_LAYOUT);
2963
2964         summary_set_header(summaryview, text, msginfo);
2965
2966         gtk_cmctree_set_node_info(ctree, cnode, text[col_pos[S_COL_SUBJECT]], 2,
2967                                 NULL, NULL, FALSE, summaryview->threaded && !summaryview->thread_collapsed);
2968 #define SET_TEXT(col) {                                         \
2969         gtk_cmctree_node_set_text(ctree, cnode, col_pos[col],   \
2970                                 text[col_pos[col]]);            \
2971 }
2972
2973         if (summaryview->col_state[summaryview->col_pos[S_COL_NUMBER]].visible)
2974                 SET_TEXT(S_COL_NUMBER);
2975         if (summaryview->col_state[summaryview->col_pos[S_COL_SCORE]].visible)
2976                 SET_TEXT(S_COL_SCORE);
2977         if (summaryview->col_state[summaryview->col_pos[S_COL_SIZE]].visible)
2978                 SET_TEXT(S_COL_SIZE);
2979         if (summaryview->col_state[summaryview->col_pos[S_COL_DATE]].visible)
2980                 SET_TEXT(S_COL_DATE);
2981         if (summaryview->col_state[summaryview->col_pos[S_COL_FROM]].visible)
2982                 SET_TEXT(S_COL_FROM);
2983         if (summaryview->col_state[summaryview->col_pos[S_COL_TO]].visible)
2984                 SET_TEXT(S_COL_TO);
2985         if (summaryview->col_state[summaryview->col_pos[S_COL_TAGS]].visible)
2986                 SET_TEXT(S_COL_TAGS);
2987
2988         if (vert && prefs_common.two_line_vert)
2989                 g_free(text[summaryview->col_pos[S_COL_SUBJECT]]);
2990
2991 #undef SET_TEXT
2992
2993         GTKUT_CTREE_NODE_SET_ROW_DATA(cnode, msginfo);
2994         summary_set_marks_func(ctree, cnode, summaryview);
2995
2996         if (msgid && msgid[0] != '\0')
2997                 g_hash_table_insert(msgid_table, (gchar *)msgid, cnode);
2998
2999         return TRUE;
3000 }
3001
3002 static void summary_set_ctree_from_list(SummaryView *summaryview,
3003                                         GSList *mlist)
3004 {
3005         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
3006         MsgInfo *msginfo;
3007         GtkCMCTreeNode *node = NULL;
3008         GHashTable *msgid_table;
3009         GHashTable *subject_table = NULL;
3010         GSList * cur;
3011         gboolean vert = (prefs_common.layout_mode == VERTICAL_LAYOUT);
3012
3013         START_TIMING("");
3014
3015         if (!mlist) return;
3016
3017         debug_print("\tSetting summary from message data...\n");
3018         STATUSBAR_PUSH(summaryview->mainwin,
3019                        _("Setting summary from message data..."));
3020         gdk_flush();
3021
3022         g_signal_handlers_block_by_func(G_OBJECT(ctree),
3023                                        G_CALLBACK(summary_tree_expanded), summaryview);
3024
3025         msgid_table = g_hash_table_new(g_str_hash, g_str_equal);
3026         summaryview->msgid_table = msgid_table;
3027
3028         if (prefs_common.thread_by_subject) {
3029                 subject_table = g_hash_table_new(g_str_hash, g_str_equal);
3030                 summaryview->subject_table = subject_table;
3031         } else {
3032                 summaryview->subject_table = NULL;
3033         }
3034
3035         if (prefs_common.use_addr_book)
3036                 start_address_completion(NULL);
3037
3038         if (summaryview->threaded) {
3039                 GNode *root, *gnode;
3040                 START_TIMING("threaded");
3041                 root = procmsg_get_thread_tree(mlist);
3042
3043
3044                 for (gnode = root->children; gnode != NULL;
3045                      gnode = gnode->next) {
3046             if (!summaryview->folder_item->hide_read_threads ||
3047                     !summary_thread_is_read(gnode))
3048             {
3049                 summary_find_thread_age(gnode);
3050                 node = gtk_sctree_insert_gnode
3051                     (ctree, NULL, node, gnode,
3052                      summary_insert_gnode_func, summaryview);
3053             }
3054                 }
3055
3056                 g_node_destroy(root);
3057
3058                 END_TIMING();
3059         } else {
3060                 gchar *text[N_SUMMARY_COLS];
3061                 START_TIMING("unthreaded");
3062                 cur = mlist;
3063                 for (; mlist != NULL; mlist = mlist->next) {
3064                         msginfo = (MsgInfo *)mlist->data;
3065
3066                         summary_set_header(summaryview, text, msginfo);
3067
3068                         node = gtk_sctree_insert_node
3069                                 (ctree, NULL, node, text, 2,
3070                                  NULL, NULL,
3071                                  FALSE, FALSE);
3072                         if (vert && prefs_common.two_line_vert)
3073                                 g_free(text[summaryview->col_pos[S_COL_SUBJECT]]);
3074
3075                         GTKUT_CTREE_NODE_SET_ROW_DATA(node, msginfo);
3076                         summary_set_marks_func(ctree, node, summaryview);
3077
3078                         if (msginfo->msgid && msginfo->msgid[0] != '\0')
3079                                 g_hash_table_insert(msgid_table,
3080                                                     msginfo->msgid, node);
3081
3082                         if (prefs_common.thread_by_subject)
3083                                 subject_table_insert(subject_table,
3084                                              msginfo->subject,
3085                                              node);
3086                 }
3087                 mlist = cur;
3088                 END_TIMING();
3089         }
3090
3091         if (prefs_common.enable_hscrollbar &&
3092             summaryview->col_pos[S_COL_SUBJECT] == N_SUMMARY_COLS - 1) {
3093                 gint optimal_width;
3094
3095                 optimal_width = gtk_cmclist_optimal_column_width
3096                         (GTK_CMCLIST(ctree), summaryview->col_pos[S_COL_SUBJECT]);
3097                 gtk_cmclist_set_column_width(GTK_CMCLIST(ctree),
3098                                            summaryview->col_pos[S_COL_SUBJECT],
3099                                            optimal_width);
3100         }
3101
3102         if (prefs_common.use_addr_book)
3103                 end_address_completion();
3104
3105         debug_print("done.\n");
3106         STATUSBAR_POP(summaryview->mainwin);
3107         if (debug_get_mode()) {
3108                 debug_print("\tmsgid hash table size = %d\n",
3109                             g_hash_table_size(msgid_table));
3110                 if (prefs_common.thread_by_subject)
3111                         debug_print("\tsubject hash table size = %d\n",
3112                             g_hash_table_size(subject_table));
3113         }
3114
3115         summary_sort(summaryview, summaryview->sort_key, summaryview->sort_type);
3116
3117         node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
3118
3119         if (prefs_common.bold_unread) {
3120                 START_TIMING("bold_unread");
3121                 while (node) {
3122                         GtkCMCTreeNode *next = GTK_CMCTREE_NODE_NEXT(node);
3123                         if (GTK_CMCTREE_ROW(node)->children)
3124                                 summary_set_row_marks(summaryview, node);
3125                         node = next;
3126                 }
3127                 END_TIMING();
3128         }
3129
3130         g_signal_handlers_unblock_by_func(G_OBJECT(ctree),
3131                                        G_CALLBACK(summary_tree_expanded), summaryview);
3132         END_TIMING();
3133 }
3134
3135 static gchar *summary_complete_address(const gchar *addr)
3136 {
3137         gint count;
3138         gchar *res, *tmp, *email_addr;
3139
3140         if (addr == NULL || !strchr(addr, '@'))
3141                 return NULL;
3142
3143         Xstrdup_a(email_addr, addr, return NULL);
3144         extract_address(email_addr);
3145         if (!*email_addr)
3146                 return NULL;
3147
3148         /*
3149          * completion stuff must be already initialized
3150          */
3151         res = NULL;
3152         if (1 < (count = complete_address(email_addr))) {
3153                 tmp = get_complete_address(1);
3154                 res = procheader_get_fromname(tmp);
3155                 g_free(tmp);
3156         }
3157
3158         return res;
3159 }
3160
3161 static inline void summary_set_header(SummaryView *summaryview, gchar *text[],
3162                                MsgInfo *msginfo)
3163 {
3164         static gchar date_modified[80];
3165         static gchar col_score[11];
3166         static gchar buf[BUFFSIZE], tmp1[BUFFSIZE], tmp2[BUFFSIZE], tmp3[BUFFSIZE];
3167         gint *col_pos = summaryview->col_pos;
3168         gchar *from_text = NULL, *to_text = NULL, *tags_text = NULL;
3169         gboolean should_swap = FALSE;
3170         gboolean vert = (prefs_common.layout_mode == VERTICAL_LAYOUT);
3171         static const gchar *color_dim_rgb = NULL;
3172         if (!color_dim_rgb)
3173                 color_dim_rgb = gdk_color_to_string(&summaryview->color_dim);
3174         text[col_pos[S_COL_FROM]]   = "";
3175         text[col_pos[S_COL_TO]]     = "";
3176         text[col_pos[S_COL_SUBJECT]]= "";
3177         text[col_pos[S_COL_MARK]]   = "";
3178         text[col_pos[S_COL_STATUS]] = "";
3179         text[col_pos[S_COL_MIME]]   = "";
3180         text[col_pos[S_COL_LOCKED]] = "";
3181         text[col_pos[S_COL_DATE]]   = "";
3182         text[col_pos[S_COL_TAGS]]   = "";
3183         if (summaryview->col_state[summaryview->col_pos[S_COL_NUMBER]].visible)
3184                 text[col_pos[S_COL_NUMBER]] = itos(msginfo->msgnum);
3185         else
3186                 text[col_pos[S_COL_NUMBER]] = "";
3187
3188         /* slow! */
3189         if (summaryview->col_state[summaryview->col_pos[S_COL_SIZE]].visible)
3190                 text[col_pos[S_COL_SIZE]] = to_human_readable(msginfo->size);
3191         else
3192                 text[col_pos[S_COL_SIZE]] = "";
3193
3194         if (summaryview->col_state[summaryview->col_pos[S_COL_SCORE]].visible)
3195                 text[col_pos[S_COL_SCORE]] = itos_buf(col_score, msginfo->score);
3196         else
3197                 text[col_pos[S_COL_SCORE]] = "";
3198
3199         if (summaryview->col_state[summaryview->col_pos[S_COL_TAGS]].visible) {
3200                 tags_text = procmsg_msginfo_get_tags_str(msginfo);
3201                 if (!tags_text) {
3202                         text[col_pos[S_COL_TAGS]] = "-";
3203                 } else {
3204                         strncpy2(tmp1, tags_text, sizeof(tmp1));
3205                         tmp1[sizeof(tmp1)-1]='\0';
3206                         g_free(tags_text);
3207                         text[col_pos[S_COL_TAGS]] = tmp1;
3208                 }
3209         } else
3210                 text[col_pos[S_COL_TAGS]] = "";
3211
3212         /* slow! */
3213         if (summaryview->col_state[summaryview->col_pos[S_COL_DATE]].visible ||
3214             (vert && prefs_common.two_line_vert)) {
3215                 if (msginfo->date_t && msginfo->date_t > 0) {
3216                         procheader_date_get_localtime(date_modified,
3217                                                       sizeof(date_modified),
3218                                                       msginfo->date_t);
3219                         text[col_pos[S_COL_DATE]] = date_modified;
3220                 } else if (msginfo->date)
3221                         text[col_pos[S_COL_DATE]] = msginfo->date;
3222                 else
3223                         text[col_pos[S_COL_DATE]] = _("(No Date)");
3224         }
3225
3226         if (prefs_common.swap_from && msginfo->from && msginfo->to
3227         &&  !summaryview->col_state[summaryview->col_pos[S_COL_TO]].visible) {
3228                 gchar *addr = NULL;
3229
3230                 addr = g_strdup(msginfo->from);
3231
3232                 if (addr) {
3233                         extract_address(addr);
3234                         if (account_find_from_address(addr, FALSE)) {
3235                                 should_swap = TRUE;
3236                         }
3237                         g_free(addr);
3238                 }
3239         }
3240
3241         if (!prefs_common.use_addr_book) {
3242                 if (prefs_common.summary_from_show == SHOW_NAME)
3243                         from_text = msginfo->fromname;
3244                 else if (prefs_common.summary_from_show == SHOW_BOTH)
3245                         from_text = msginfo->from;
3246                 else {
3247                         from_text = msginfo->from;
3248                         extract_address(from_text);
3249                 }
3250                 if (!from_text)
3251                         _("(No From)");
3252         } else {
3253                 gchar *tmp = summary_complete_address(msginfo->from);
3254                 if (tmp) {
3255                         strncpy2(buf, tmp, sizeof(buf));
3256                         g_free(tmp);
3257                         from_text = buf;
3258                 } else {
3259                         if (prefs_common.summary_from_show == SHOW_NAME)
3260                                 from_text = msginfo->fromname;
3261                         else if (prefs_common.summary_from_show == SHOW_BOTH)
3262                                 from_text = msginfo->from;
3263                         else {
3264                                 from_text = msginfo->from;
3265                                 extract_address(from_text);
3266                         }
3267                         if (!from_text)
3268                                 _("(No From)");
3269                 }
3270         }
3271
3272         to_text = msginfo->to ? msginfo->to :
3273                    (msginfo->cc ? msginfo->cc :
3274                      (msginfo->newsgroups ? msginfo->newsgroups : _("(No Recipient)")
3275                      )
3276                    );
3277
3278         text[col_pos[S_COL_TO]] = to_text;
3279         if (!should_swap) {
3280                 text[col_pos[S_COL_FROM]] = from_text;
3281         } else {
3282                 if (prefs_common.use_addr_book) {
3283                         gchar *tmp = summary_complete_address(to_text);
3284                         if (tmp) {
3285                                 strncpy2(buf, tmp, sizeof(buf));
3286                                 g_free(tmp);
3287                                 to_text = buf;
3288                         } else {
3289                                 to_text = to_text ? to_text : _("(No From)");
3290                         }
3291                 }
3292                 snprintf(tmp2, BUFFSIZE-1, "--> %s", to_text);
3293                 tmp2[BUFFSIZE-1]='\0';
3294                 text[col_pos[S_COL_FROM]] = tmp2;
3295         }
3296
3297 #ifndef G_OS_WIN32
3298         if (summaryview->simplify_subject_preg != NULL)
3299                 text[col_pos[S_COL_SUBJECT]] = msginfo->subject ?
3300                         string_remove_match(tmp3, BUFFSIZE, msginfo->subject,
3301                                         summaryview->simplify_subject_preg) :
3302                         _("(No Subject)");
3303         else
3304 #endif
3305                 text[col_pos[S_COL_SUBJECT]] = msginfo->subject ? msginfo->subject :
3306                         _("(No Subject)");
3307         if (vert && prefs_common.two_line_vert) {
3308                 if (!FOLDER_SHOWS_TO_HDR(summaryview->folder_item)) {
3309                         gchar *tmp = g_markup_printf_escaped(_("%s\n<span color='%s' style='italic'>From: %s, on %s</span>"),
3310                                         text[col_pos[S_COL_SUBJECT]],
3311                                         color_dim_rgb,
3312                                         text[col_pos[S_COL_FROM]],
3313                                         text[col_pos[S_COL_DATE]]);
3314                         text[col_pos[S_COL_SUBJECT]] = tmp;
3315                 } else {
3316                         gchar *tmp = g_markup_printf_escaped(_("%s\n<span color='%s' style='italic'>To: %s, on %s</span>"),
3317                                         text[col_pos[S_COL_SUBJECT]],
3318                                         color_dim_rgb,
3319                                         text[col_pos[S_COL_TO]],
3320                                         text[col_pos[S_COL_DATE]]);
3321                         text[col_pos[S_COL_SUBJECT]] = tmp;
3322                 }
3323         }
3324 }
3325
3326 static void summary_display_msg(SummaryView *summaryview, GtkCMCTreeNode *row)
3327 {
3328         summary_display_msg_full(summaryview, row, FALSE, FALSE);
3329 }
3330
3331 static gboolean defer_change(gpointer data);
3332 typedef struct _ChangeData {
3333         MsgInfo *info;
3334         gint op; /* 0, 1, 2 for unset, set, change */
3335         MsgPermFlags set_flags;
3336         MsgTmpFlags  set_tmp_flags;
3337         MsgPermFlags unset_flags;
3338         MsgTmpFlags  unset_tmp_flags;
3339 } ChangeData;
3340
3341 static void summary_msginfo_unset_flags(MsgInfo *msginfo, MsgPermFlags flags, MsgTmpFlags tmp_flags)
3342 {
3343         if (!msginfo->folder || !msginfo->folder->processing_pending) {
3344                 debug_print("flags: doing unset now\n");
3345                 procmsg_msginfo_unset_flags(msginfo, flags, tmp_flags);
3346         } else {
3347                 ChangeData *unset_data = g_new0(ChangeData, 1);
3348                 unset_data->info = msginfo;
3349                 unset_data->op = 0;
3350                 unset_data->unset_flags = flags;
3351                 unset_data->unset_tmp_flags = tmp_flags;
3352                 debug_print("flags: deferring unset\n");
3353                 g_timeout_add(100, defer_change, unset_data);
3354         }
3355 }
3356
3357 static void summary_msginfo_set_flags(MsgInfo *msginfo, MsgPermFlags flags, MsgTmpFlags tmp_flags)
3358 {
3359         if (!msginfo->folder || !msginfo->folder->processing_pending) {
3360                 debug_print("flags: doing set now\n");
3361                 procmsg_msginfo_set_flags(msginfo, flags, tmp_flags);
3362         } else {
3363                 ChangeData *set_data = g_new0(ChangeData, 1);
3364                 set_data->info = msginfo;
3365                 set_data->op = 1;
3366                 set_data->set_flags = flags;
3367                 set_data->set_tmp_flags = tmp_flags;
3368                 debug_print("flags: deferring set\n");
3369                 g_timeout_add(100, defer_change, set_data);
3370         }
3371 }
3372
3373 static void summary_msginfo_change_flags(MsgInfo *msginfo,
3374                 MsgPermFlags add_flags, MsgTmpFlags add_tmp_flags,
3375                 MsgPermFlags rem_flags, MsgTmpFlags rem_tmp_flags)
3376 {
3377         if (!msginfo->folder || !msginfo->folder->processing_pending) {
3378                 debug_print("flags: doing change now\n");
3379                 procmsg_msginfo_change_flags(msginfo, add_flags, add_tmp_flags,
3380                         rem_flags, rem_tmp_flags);
3381         } else {
3382                 ChangeData *change_data = g_new0(ChangeData, 1);
3383                 change_data->info = msginfo;
3384                 change_data->op = 2;
3385                 change_data->set_flags = add_flags;
3386                 change_data->set_tmp_flags = add_tmp_flags;
3387                 change_data->unset_flags = rem_flags;
3388                 change_data->unset_tmp_flags = rem_tmp_flags;
3389                 debug_print("flags: deferring change\n");
3390                 g_timeout_add(100, defer_change, change_data);
3391         }
3392 }
3393
3394 gboolean defer_change(gpointer data)
3395 {
3396         ChangeData *chg = (ChangeData *)data;
3397         if (chg->info->folder && chg->info->folder->processing_pending) {
3398                 debug_print("flags: trying later\n");
3399                 return TRUE; /* try again */
3400         } else {
3401                 debug_print("flags: finally doing it\n");
3402                 switch(chg->op) {
3403                 case 0:
3404                         procmsg_msginfo_unset_flags(chg->info, chg->unset_flags, chg->unset_tmp_flags);
3405                         break;
3406                 case 1:
3407                         procmsg_msginfo_set_flags(chg->info, chg->set_flags, chg->set_tmp_flags);
3408                         break;
3409                 case 2:
3410                         procmsg_msginfo_change_flags(chg->info, chg->set_flags, chg->set_tmp_flags,
3411                                 chg->unset_flags, chg->unset_tmp_flags);
3412                         break;
3413                 default:
3414                         g_warning("shouldn't happen\n");
3415                 }
3416                 g_free(chg);
3417         }
3418         return FALSE;
3419 }
3420
3421 static void msginfo_mark_as_read (SummaryView *summaryview, MsgInfo *msginfo,
3422                                       GtkCMCTreeNode *row)
3423 {
3424         cm_return_if_fail(summaryview != NULL);
3425         cm_return_if_fail(msginfo != NULL);
3426         cm_return_if_fail(row != NULL);
3427
3428         if (MSG_IS_NEW(msginfo->flags) || MSG_IS_UNREAD(msginfo->flags)) {
3429                 summary_msginfo_unset_flags
3430                         (msginfo, MSG_NEW | MSG_UNREAD, 0);
3431                 summary_set_row_marks(summaryview, row);
3432                 summary_status_show(summaryview);
3433         }
3434 }
3435
3436 typedef struct  {
3437         MsgInfo *msginfo;
3438         SummaryView *summaryview;
3439 } MarkAsReadData;
3440
3441 static int msginfo_mark_as_read_timeout(void *data)
3442 {
3443         MarkAsReadData *mdata = (MarkAsReadData *)data;
3444         if (!mdata)
3445                 return FALSE;
3446
3447         if (mdata->msginfo == summary_get_selected_msg(mdata->summaryview))
3448                 msginfo_mark_as_read(mdata->summaryview, mdata->msginfo,
3449                                      mdata->summaryview->selected);
3450
3451         g_free(mdata);
3452
3453         return FALSE;
3454 }
3455
3456 static void summary_display_msg_full(SummaryView *summaryview,
3457                                      GtkCMCTreeNode *row,
3458                                      gboolean new_window, gboolean all_headers)
3459 {
3460         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
3461         MsgInfo *msginfo;
3462         gint val;
3463         START_TIMING("");
3464         if (!new_window) {
3465                 if (summaryview->displayed == row &&
3466                     messageview_is_visible(summaryview->messageview))
3467                         return;
3468                 else if (summaryview->messageview)
3469                         summaryview->messageview->filtered = FALSE;
3470         }
3471         cm_return_if_fail(row != NULL);
3472
3473         if (summary_is_locked(summaryview)) return;
3474         summary_lock(summaryview);
3475
3476         STATUSBAR_POP(summaryview->mainwin);
3477         GTK_EVENTS_FLUSH();
3478
3479         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
3480
3481         if (!msginfo) {
3482                 debug_print("NULL msginfo\n");
3483                 summary_unlock(summaryview);
3484                 END_TIMING();
3485                 return;
3486         }
3487
3488         if (new_window && prefs_common.layout_mode != SMALL_LAYOUT) {
3489                 MessageView *msgview;
3490
3491                 msgview = messageview_create_with_new_window(summaryview->mainwin);
3492                 val = messageview_show(msgview, msginfo, all_headers);
3493         } else {
3494                 MessageView *msgview;
3495
3496                 if (prefs_common.layout_mode == SMALL_LAYOUT) {
3497                         if (summaryview->ext_messageview == NULL)
3498                                 summaryview->ext_messageview = messageview_create_with_new_window(summaryview->mainwin);
3499                         else
3500                                 gtkut_window_popup(summaryview->ext_messageview->window);
3501                         msgview = summaryview->ext_messageview;
3502                         summaryview->last_displayed = summaryview->displayed;
3503                         summaryview->displayed = row;
3504                         val = messageview_show(msgview, msginfo, all_headers);
3505                         if (mimeview_tree_is_empty(msgview->mimeview))
3506                                 gtk_widget_grab_focus(summaryview->ctree);
3507                         gtkut_ctree_node_move_if_on_the_edge(ctree, row,
3508                                 GTK_CMCLIST(summaryview->ctree)->focus_row);
3509                 } else {
3510                         msgview = summaryview->messageview;
3511                         summaryview->last_displayed = summaryview->displayed;
3512                         summaryview->displayed = row;
3513                         if (!messageview_is_visible(msgview) &&
3514                             gtk_window_is_active(GTK_WINDOW(summaryview->mainwin->window))) {
3515                                 main_window_toggle_message_view(summaryview->mainwin);
3516                                 GTK_EVENTS_FLUSH();
3517                         }
3518                         val = messageview_show(msgview, msginfo, all_headers);
3519                         if (mimeview_tree_is_empty(msgview->mimeview))
3520                                 gtk_widget_grab_focus(summaryview->ctree);
3521                         gtkut_ctree_node_move_if_on_the_edge(ctree, row,
3522                                 GTK_CMCLIST(summaryview->ctree)->focus_row);
3523                 }
3524         }
3525
3526         if (val == 0 && MSG_IS_UNREAD(msginfo->flags)) {
3527                 if (!prefs_common.mark_as_read_on_new_window &&
3528                     prefs_common.mark_as_read_delay) {
3529                         MarkAsReadData *data = g_new0(MarkAsReadData, 1);
3530                         data->summaryview = summaryview;
3531                         data->msginfo = msginfo;
3532 #if GLIB_CHECK_VERSION(2,14,0)
3533                         g_timeout_add_seconds(prefs_common.mark_as_read_delay,
3534                                 msginfo_mark_as_read_timeout, data);
3535 #else
3536                         g_timeout_add(prefs_common.mark_as_read_delay * 1000,
3537                                 msginfo_mark_as_read_timeout, data);
3538 #endif
3539                 } else if (new_window || !prefs_common.mark_as_read_on_new_window) {
3540                         msginfo_mark_as_read(summaryview, msginfo, row);
3541                 }
3542         }
3543
3544         summary_set_menu_sensitive(summaryview);
3545         toolbar_main_set_sensitive(summaryview->mainwin);
3546         messageview_set_menu_sensitive(summaryview->messageview);
3547
3548         summary_unlock(summaryview);
3549         END_TIMING();
3550 }
3551
3552 void summary_display_msg_selected(SummaryView *summaryview,
3553                                   gboolean all_headers)
3554 {
3555         if (summary_is_locked(summaryview)) return;
3556         summaryview->displayed = NULL;
3557         summary_display_msg_full(summaryview, summaryview->selected, FALSE,
3558                                  all_headers);
3559 }
3560
3561 void summary_redisplay_msg(SummaryView *summaryview)
3562 {
3563         GtkCMCTreeNode *node;
3564
3565         if (summaryview->displayed) {
3566                 node = summaryview->displayed;
3567                 summaryview->displayed = NULL;
3568                 summary_display_msg(summaryview, node);
3569         }
3570 }
3571
3572 void summary_open_msg(SummaryView *summaryview)
3573 {
3574         if (!summaryview->selected) return;
3575
3576         /* CLAWS: if separate message view, don't open a new window
3577          * but rather use the current separated message view */
3578         summary_display_msg_full(summaryview, summaryview->selected,
3579                                  TRUE, FALSE);
3580 }
3581
3582 void summary_view_source(SummaryView * summaryview)
3583 {
3584         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
3585         MsgInfo *msginfo;
3586         SourceWindow *srcwin;
3587
3588         if (!summaryview->selected) return;
3589
3590         srcwin = source_window_create();
3591         msginfo = gtk_cmctree_node_get_row_data(ctree, summaryview->selected);
3592         source_window_show_msg(srcwin, msginfo);
3593         source_window_show(srcwin);
3594 #ifdef MAEMO
3595         maemo_window_full_screen_if_needed(GTK_WINDOW(srcwin->window));
3596         maemo_connect_key_press_to_mainwindow(GTK_WINDOW(srcwin->window));
3597 #endif
3598 }
3599
3600 void summary_reedit(SummaryView *summaryview)
3601 {
3602         MsgInfo *msginfo;
3603
3604         if (!summaryview->selected) return;
3605         if (!summaryview->folder_item) return;
3606         if (!FOLDER_SHOWS_TO_HDR(summaryview->folder_item))
3607                 return;
3608
3609         msginfo = gtk_cmctree_node_get_row_data(GTK_CMCTREE(summaryview->ctree),
3610                                               summaryview->selected);
3611         if (!msginfo) return;
3612
3613         compose_reedit(msginfo, FALSE);
3614 }
3615
3616 gboolean summary_step(SummaryView *summaryview, GtkScrollType type)
3617 {
3618         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
3619         GtkCMCTreeNode *node;
3620
3621         if (summary_is_locked(summaryview)
3622         && !GTK_SCTREE(ctree)->selecting_range
3623         && summaryview->messageview->mimeview
3624         && summaryview->messageview->mimeview->type == MIMEVIEW_TEXT
3625         && summaryview->messageview->mimeview->textview->loading) {
3626                 PostponedSelectData *data = g_new0(PostponedSelectData, 1);
3627                 summaryview->messageview->mimeview->textview->stop_loading = TRUE;
3628
3629                 data->ctree = ctree;
3630                 data->row = NULL;
3631                 data->node = NULL;
3632                 data->type = type;
3633                 data->summaryview = summaryview;
3634                 debug_print("postponing open of message till end of load\n");
3635                 g_timeout_add(100, summary_select_retry, data);
3636                 return FALSE;
3637         }
3638         if (summary_is_locked(summaryview))
3639                 return FALSE;
3640         if (type == GTK_SCROLL_STEP_FORWARD) {
3641                 node = gtkut_ctree_node_next(ctree, summaryview->selected);
3642                 if (node)
3643                         gtkut_ctree_expand_parent_all(ctree, node);
3644                 else
3645                         return FALSE;
3646         } else {
3647                 if (summaryview->selected) {
3648                         node = GTK_CMCTREE_NODE_PREV(summaryview->selected);
3649                         if (!node) return FALSE;
3650                 }
3651         }
3652
3653         if (messageview_is_visible(summaryview->messageview))
3654                 summaryview->display_msg = TRUE;
3655
3656         g_signal_emit_by_name(G_OBJECT(ctree), "scroll_vertical", type, 0.0);
3657
3658         if (GTK_CMCLIST(ctree)->selection)
3659                 gtk_sctree_set_anchor_row
3660                         (GTK_SCTREE(ctree),
3661                          GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->selection->data));
3662
3663         return TRUE;
3664 }
3665
3666 gboolean summary_is_list(SummaryView *summaryview)
3667 {
3668         return (gtk_notebook_get_current_page(
3669                 GTK_NOTEBOOK(summaryview->mainwidget_book)) == 0);
3670 }
3671
3672 void summary_toggle_view(SummaryView *summaryview)
3673 {
3674         if (prefs_common.layout_mode == SMALL_LAYOUT)
3675                 return;
3676         if (summary_is_locked(summaryview))
3677                 return;
3678         if (!messageview_is_visible(summaryview->messageview) &&
3679             summaryview->selected && summary_is_list(summaryview))
3680                 summary_display_msg(summaryview,
3681                                     summaryview->selected);
3682         else
3683                 main_window_toggle_message_view(summaryview->mainwin);
3684 }
3685
3686 static gboolean summary_search_unread_recursive(GtkCMCTree *ctree,
3687                                                 GtkCMCTreeNode *node)
3688 {
3689         MsgInfo *msginfo;
3690
3691         if (node) {
3692                 msginfo = gtk_cmctree_node_get_row_data(ctree, node);
3693                 if (msginfo && MSG_IS_UNREAD(msginfo->flags) && !MSG_IS_IGNORE_THREAD(msginfo->flags))
3694                         return TRUE;
3695                 node = GTK_CMCTREE_ROW(node)->children;
3696         } else
3697                 node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
3698
3699         while (node) {
3700                 if (summary_search_unread_recursive(ctree, node) == TRUE)
3701                         return TRUE;
3702                 node = GTK_CMCTREE_ROW(node)->sibling;
3703         }
3704
3705         return FALSE;
3706 }
3707
3708 static gboolean summary_have_unread_children(SummaryView *summaryview,
3709                                              GtkCMCTreeNode *node)
3710 {
3711         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
3712
3713         if (!node) return FALSE;
3714
3715         node = GTK_CMCTREE_ROW(node)->children;
3716
3717         while (node) {
3718                 if (summary_search_unread_recursive(ctree, node) == TRUE)
3719                         return TRUE;
3720                 node = GTK_CMCTREE_ROW(node)->sibling;
3721         }
3722         return FALSE;
3723 }
3724
3725 static void summary_set_row_marks(SummaryView *summaryview, GtkCMCTreeNode *row)
3726 {
3727         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
3728         GtkStyle *style = NULL;
3729         MsgInfo *msginfo;
3730         MsgFlags flags;
3731         gint *col_pos = summaryview->col_pos;
3732
3733         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
3734         if (!msginfo) return;
3735
3736         flags = msginfo->flags;
3737
3738         gtk_cmctree_node_set_foreground(ctree, row, NULL);
3739
3740         /* set new/unread column */
3741         if (MSG_IS_IGNORE_THREAD(flags)) {
3742                 gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_STATUS],
3743                                           ignorethreadxpm);
3744         } else if (MSG_IS_WATCH_THREAD(flags)) {
3745                 gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_STATUS],
3746                                           watchthreadxpm);
3747         } else if (MSG_IS_SPAM(flags)) {
3748                 gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_STATUS],
3749                                           spamxpm);
3750         } else if (MSG_IS_NEW(flags)) {
3751                 gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_STATUS],
3752                                           newxpm);
3753         } else if (MSG_IS_UNREAD(flags)) {
3754                 gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_STATUS],
3755                                           unreadxpm);
3756         } else if (MSG_IS_REPLIED(flags)) {
3757                 gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_STATUS],
3758                                           repliedxpm);
3759         } else if (MSG_IS_FORWARDED(flags)) {
3760                 gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_STATUS],
3761                                           forwardedxpm);
3762         } else {
3763                 gtk_cmctree_node_set_text(ctree, row, col_pos[S_COL_STATUS],
3764                                         "");
3765         }
3766
3767         if (prefs_common.bold_unread &&
3768             ((MSG_IS_UNREAD(flags) && !MSG_IS_IGNORE_THREAD(flags)) ||
3769              (!GTK_CMCTREE_ROW(row)->expanded &&
3770               GTK_CMCTREE_ROW(row)->children &&
3771               summary_have_unread_children(summaryview, row))))
3772                 style = bold_style;
3773
3774         /* set mark column */
3775         if (MSG_IS_DELETED(flags)) {
3776                 gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_MARK],
3777                                           deletedxpm);
3778                 if (style)
3779                         style = bold_deleted_style;
3780                 else {
3781                         style = small_deleted_style;
3782                 }
3783                         gtk_cmctree_node_set_foreground
3784                                 (ctree, row, &summaryview->color_dim);
3785         } else if (MSG_IS_MARKED(flags)) {
3786                 gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_MARK],
3787                                           markxpm);
3788         } else if (MSG_IS_MOVE(flags)) {
3789                 gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_MARK],
3790                                           movedxpm);
3791                 if (style)
3792                         style = bold_marked_style;
3793                 else {
3794                         style = small_marked_style;
3795                 }
3796                         gtk_cmctree_node_set_foreground
3797                                 (ctree, row, &summaryview->color_marked);
3798         } else if (MSG_IS_COPY(flags)) {
3799                 gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_MARK],
3800                                           copiedxpm);
3801                 if (style)
3802                         style = bold_marked_style;
3803                 else {
3804                         style = small_marked_style;
3805                 }
3806                         gtk_cmctree_node_set_foreground
3807                                 (ctree, row, &summaryview->color_marked);
3808         } else {
3809                 gtk_cmctree_node_set_text(ctree, row, col_pos[S_COL_MARK], "");
3810         }
3811
3812         if (MSG_IS_LOCKED(flags)) {
3813                 gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_LOCKED],
3814                                           lockedxpm);
3815         }
3816         else {
3817                 gtk_cmctree_node_set_text(ctree, row, col_pos[S_COL_LOCKED], "");
3818         }
3819
3820         if (MSG_IS_WITH_ATTACHMENT(flags) && MSG_IS_SIGNED(flags)) {
3821                 gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_MIME],
3822                                           clipgpgsignedxpm);
3823         } else if (MSG_IS_SIGNED(flags)) {
3824                 if (MSG_IS_ENCRYPTED(flags)) {
3825                         gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_MIME],
3826                                           keysignxpm);
3827                 } else {
3828                         gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_MIME],
3829                                                   gpgsignedxpm);
3830                 }
3831         } else if (MSG_IS_WITH_ATTACHMENT(flags) && MSG_IS_ENCRYPTED(flags)) {
3832                 gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_MIME],
3833                                           clipkeyxpm);
3834         } else if (MSG_IS_ENCRYPTED(flags)) {
3835                 gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_MIME],
3836                                           keyxpm);
3837         } else if (MSG_IS_WITH_ATTACHMENT(flags)) {
3838                 gtk_cmctree_node_set_pixbuf(ctree, row, col_pos[S_COL_MIME],
3839                                           clipxpm);
3840         } else {
3841                 gtk_cmctree_node_set_text(ctree, row, col_pos[S_COL_MIME], "");
3842         }
3843         if (!style)
3844                 style = small_style;
3845
3846         gtk_cmctree_node_set_row_style(ctree, row, style);
3847
3848         if (MSG_GET_COLORLABEL(flags))
3849                 summary_set_colorlabel_color(ctree, row, MSG_GET_COLORLABEL_VALUE(flags));
3850 }
3851
3852 static void summary_mark_row(SummaryView *summaryview, GtkCMCTreeNode *row)
3853 {
3854         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
3855         MsgInfo *msginfo;
3856
3857         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
3858         cm_return_if_fail(msginfo);
3859         if (MSG_IS_DELETED(msginfo->flags))
3860                 summaryview->deleted--;
3861         if (MSG_IS_MOVE(msginfo->flags))
3862                 summaryview->moved--;
3863         if (MSG_IS_COPY(msginfo->flags))
3864                 summaryview->copied--;
3865
3866         procmsg_msginfo_set_to_folder(msginfo, NULL);
3867         summary_msginfo_change_flags(msginfo, MSG_MARKED, 0, MSG_DELETED,
3868                 MSG_MOVE | MSG_COPY | MSG_MOVE_DONE);
3869         summary_set_row_marks(summaryview, row);
3870         debug_print("Message %s/%d is marked\n", msginfo->folder->path, msginfo->msgnum);
3871 }
3872
3873 static void summary_lock_row(SummaryView *summaryview, GtkCMCTreeNode *row)
3874 {
3875         gboolean changed = FALSE;
3876         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
3877         MsgInfo *msginfo;
3878
3879         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
3880         cm_return_if_fail(msginfo);
3881         if (MSG_IS_DELETED(msginfo->flags))
3882                 summaryview->deleted--;
3883         if (MSG_IS_MOVE(msginfo->flags)) {
3884                 summaryview->moved--;
3885                 changed = TRUE;
3886         }
3887         if (MSG_IS_COPY(msginfo->flags)) {
3888                 summaryview->copied--;
3889                 changed = TRUE;
3890         }
3891         procmsg_msginfo_set_to_folder(msginfo, NULL);
3892         summary_msginfo_change_flags(msginfo, MSG_LOCKED, 0, MSG_DELETED,
3893                 MSG_MOVE | MSG_COPY | MSG_MOVE_DONE);
3894
3895         summary_set_row_marks(summaryview, row);
3896         debug_print("Message %d is locked\n", msginfo->msgnum);
3897 }
3898
3899 static void summary_unlock_row(SummaryView *summaryview, GtkCMCTreeNode *row)
3900 {
3901         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
3902         MsgInfo *msginfo;
3903
3904         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
3905         cm_return_if_fail(msginfo);
3906         if (!MSG_IS_LOCKED(msginfo->flags))
3907                 return;
3908         procmsg_msginfo_set_to_folder(msginfo, NULL);
3909         summary_msginfo_unset_flags(msginfo, MSG_LOCKED, 0);
3910         summary_set_row_marks(summaryview, row);
3911         debug_print("Message %d is unlocked\n", msginfo->msgnum);
3912 }
3913
3914 void summary_mark(SummaryView *summaryview)
3915 {
3916         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
3917         GList *cur;
3918         gboolean froze = FALSE;
3919
3920         if (summary_is_locked(summaryview))
3921                 return;
3922         START_LONG_OPERATION(summaryview, FALSE);
3923         folder_item_set_batch(summaryview->folder_item, TRUE);
3924         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
3925                 summary_mark_row(summaryview, GTK_CMCTREE_NODE(cur->data));
3926         folder_item_set_batch(summaryview->folder_item, FALSE);
3927         END_LONG_OPERATION(summaryview);
3928
3929         summary_status_show(summaryview);
3930 }
3931
3932 static void summary_mark_row_as_read(SummaryView *summaryview,
3933                                      GtkCMCTreeNode *row)
3934 {
3935         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
3936         MsgInfo *msginfo;
3937
3938         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
3939         cm_return_if_fail(msginfo);
3940
3941         if(!(MSG_IS_NEW(msginfo->flags) || MSG_IS_UNREAD(msginfo->flags)))
3942                 return;
3943
3944         summary_msginfo_unset_flags(msginfo, MSG_NEW | MSG_UNREAD, 0);
3945         summary_set_row_marks(summaryview, row);
3946         debug_print("Message %d is marked as read\n",
3947                 msginfo->msgnum);
3948 }
3949
3950 void summary_mark_as_read(SummaryView *summaryview)
3951 {
3952         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
3953         GList *cur;
3954         gboolean froze = FALSE;
3955
3956         if (summary_is_locked(summaryview))
3957                 return;
3958         START_LONG_OPERATION(summaryview, FALSE);
3959         folder_item_set_batch(summaryview->folder_item, TRUE);
3960         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
3961                 summary_mark_row_as_read(summaryview,
3962                                          GTK_CMCTREE_NODE(cur->data));
3963         folder_item_set_batch(summaryview->folder_item, FALSE);
3964         END_LONG_OPERATION(summaryview);
3965
3966         summary_status_show(summaryview);
3967 }
3968
3969 void summary_msgs_lock(SummaryView *summaryview)
3970 {
3971         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
3972         GList *cur;
3973         gboolean froze = FALSE;
3974
3975         if (summary_is_locked(summaryview))
3976                 return;
3977         START_LONG_OPERATION(summaryview, FALSE);
3978         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
3979                 summary_lock_row(summaryview,
3980                                          GTK_CMCTREE_NODE(cur->data));
3981         END_LONG_OPERATION(summaryview);
3982
3983         summary_status_show(summaryview);
3984 }
3985
3986 void summary_msgs_unlock(SummaryView *summaryview)
3987 {
3988         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
3989         GList *cur;
3990         gboolean froze = FALSE;
3991
3992         if (summary_is_locked(summaryview))
3993                 return;
3994         START_LONG_OPERATION(summaryview, FALSE);
3995         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
3996                 summary_unlock_row(summaryview,
3997                                    GTK_CMCTREE_NODE(cur->data));
3998         END_LONG_OPERATION(summaryview);
3999
4000         summary_status_show(summaryview);
4001 }
4002
4003 void summary_mark_all_read(SummaryView *summaryview)
4004 {
4005         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
4006         GtkCMCTreeNode *node;
4007         AlertValue val;
4008         gboolean froze = FALSE;
4009
4010         if (prefs_common.ask_mark_all_read) {
4011                 val = alertpanel_full(_("Mark all as read"),
4012                         _("Do you really want to mark all mails in this "
4013                           "folder as read ?"), GTK_STOCK_NO, GTK_STOCK_YES, NULL,
4014                           TRUE, NULL, ALERT_QUESTION, G_ALERTDEFAULT);
4015
4016                 if ((val & ~G_ALERTDISABLE) != G_ALERTALTERNATE)
4017                         return;
4018                 else if (val & G_ALERTDISABLE)
4019                         prefs_common.ask_mark_all_read = FALSE;
4020         }
4021
4022         if (summary_is_locked(summaryview))
4023                 return;
4024         START_LONG_OPERATION(summaryview, TRUE);
4025         folder_item_set_batch(summaryview->folder_item, TRUE);
4026         for (node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list); node != NULL;
4027              node = gtkut_ctree_node_next(ctree, node))
4028                 summary_mark_row_as_read(summaryview, node);
4029         folder_item_set_batch(summaryview->folder_item, FALSE);
4030         for (node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list); node != NULL;
4031              node = gtkut_ctree_node_next(ctree, node)) {
4032                 if (!GTK_CMCTREE_ROW(node)->expanded)
4033                         summary_set_row_marks(summaryview, node);
4034         }
4035         END_LONG_OPERATION(summaryview);
4036
4037         summary_status_show(summaryview);
4038 }
4039
4040 void summary_mark_as_spam(SummaryView *summaryview, guint action, GtkWidget *widget)
4041 {
4042         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
4043         GList *cur;
4044         gboolean is_spam = action;
4045         GSList *msgs = NULL;
4046         gboolean immediate_exec = prefs_common.immediate_exec;
4047         gboolean moved = FALSE;
4048         gboolean froze = FALSE;
4049
4050
4051         if (summary_is_locked(summaryview))
4052                 return;
4053
4054         prefs_common.immediate_exec = FALSE;
4055         START_LONG_OPERATION(summaryview, FALSE);
4056         folder_item_set_batch(summaryview->folder_item, TRUE);
4057         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next) {
4058                 GtkCMCTreeNode *row = GTK_CMCTREE_NODE(cur->data);
4059                 MsgInfo *msginfo = gtk_cmctree_node_get_row_data(ctree, row);
4060                 if (msginfo)
4061                         msgs = g_slist_prepend(msgs, msginfo);
4062         }
4063
4064         if (procmsg_spam_learner_learn(NULL, msgs, is_spam) == 0) {
4065                 for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next) {
4066                         GtkCMCTreeNode *row = GTK_CMCTREE_NODE(cur->data);
4067                         MsgInfo *msginfo = gtk_cmctree_node_get_row_data(ctree, row);
4068                         if (!msginfo)
4069                                 continue;
4070                         if (is_spam) {
4071                                 summary_msginfo_change_flags(msginfo, MSG_SPAM, 0, MSG_NEW|MSG_UNREAD, 0);
4072                                 if (procmsg_spam_get_folder(msginfo) != summaryview->folder_item) {
4073                                         summary_move_row_to(summaryview, row,
4074                                                         procmsg_spam_get_folder(msginfo));
4075                                         moved = TRUE;
4076                                 }
4077                         } else {
4078                                 summary_msginfo_unset_flags(msginfo, MSG_SPAM, 0);
4079                         }
4080                         summaryview->display_msg = prefs_common.always_show_msg;
4081
4082                         summary_set_row_marks(summaryview, row);
4083                 }
4084         } else {
4085                 log_error(LOG_PROTOCOL, _("An error happened while learning.\n"));
4086         }
4087
4088         prefs_common.immediate_exec = immediate_exec;
4089         folder_item_set_batch(summaryview->folder_item, FALSE);
4090         END_LONG_OPERATION(summaryview);
4091
4092         if (prefs_common.immediate_exec && moved) {
4093                 summary_execute(summaryview);
4094         }
4095
4096         if (!moved && msgs) {
4097                 MsgInfo *msginfo = (MsgInfo *)msgs->data;
4098                 toolbar_set_learn_button
4099                         (summaryview->mainwin->toolbar,
4100                          MSG_IS_SPAM(msginfo->flags)?LEARN_HAM:LEARN_SPAM);
4101         }
4102         g_slist_free(msgs);
4103
4104         summary_status_show(summaryview);
4105 }
4106
4107
4108 static void summary_mark_row_as_unread(SummaryView *summaryview,
4109                                        GtkCMCTreeNode *row)
4110 {
4111         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
4112         MsgInfo *msginfo;
4113
4114         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
4115         cm_return_if_fail(msginfo);
4116         if (MSG_IS_DELETED(msginfo->flags)) {
4117                 procmsg_msginfo_set_to_folder(msginfo, NULL);
4118                 summary_msginfo_unset_flags(msginfo, MSG_DELETED, 0);
4119                 summaryview->deleted--;
4120         }
4121
4122         summary_msginfo_set_flags(msginfo, MSG_UNREAD, 0);
4123         debug_print("Message %d is marked as unread\n",
4124                 msginfo->msgnum);
4125
4126         summary_set_row_marks(summaryview, row);
4127 }
4128
4129 void summary_mark_as_unread(SummaryView *summaryview)
4130 {
4131         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
4132         GList *cur;
4133         gboolean froze = FALSE;
4134
4135         if (summary_is_locked(summaryview))
4136                 return;
4137         START_LONG_OPERATION(summaryview, FALSE);
4138         folder_item_set_batch(summaryview->folder_item, TRUE);
4139         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL;
4140                 cur = cur->next)
4141                 summary_mark_row_as_unread(summaryview,
4142                                            GTK_CMCTREE_NODE(cur->data));
4143         folder_item_set_batch(summaryview->folder_item, FALSE);
4144         END_LONG_OPERATION(summaryview);
4145
4146         summary_status_show(summaryview);
4147 }
4148
4149 static gboolean check_permission(SummaryView *summaryview, MsgInfo * msginfo)
4150 {
4151         GList * cur;
4152         gboolean found;
4153
4154         switch (FOLDER_TYPE(summaryview->folder_item->folder)) {
4155
4156         case F_NEWS:
4157
4158                 /*
4159                   security : checks if one the accounts correspond to
4160                   the author of the post
4161                 */
4162
4163                 found = FALSE;
4164                 for(cur = account_get_list() ; cur != NULL ; cur = cur->next) {
4165                         PrefsAccount * account;
4166                         gchar * from_name;
4167
4168                         account = cur->data;
4169                         if (account->name && *account->name)
4170                                 from_name =
4171                                         g_strdup_printf("%s <%s>",
4172                                                         account->name,
4173                                                         account->address);
4174                         else
4175                                 from_name =
4176                                         g_strdup_printf("%s",
4177                                                         account->address);
4178
4179                         if (g_utf8_collate(from_name, msginfo->from) == 0) {
4180                                 g_free(from_name);
4181                                 found = TRUE;
4182                                 break;
4183                         }
4184                         g_free(from_name);
4185                 }
4186
4187                 if (!found) {
4188                         alertpanel_error(_("You're not the author of the article.\n"));
4189                 }
4190
4191                 return found;
4192
4193         default:
4194                 return TRUE;
4195         }
4196 }
4197
4198 static void summary_delete_row(SummaryView *summaryview, GtkCMCTreeNode *row)
4199 {
4200         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
4201         MsgInfo *msginfo;
4202
4203         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
4204         cm_return_if_fail(msginfo);
4205
4206         if (MSG_IS_LOCKED(msginfo->flags)) return;
4207
4208         if (MSG_IS_DELETED(msginfo->flags)) return;
4209
4210         if (MSG_IS_MOVE(msginfo->flags))
4211                 summaryview->moved--;
4212         if (MSG_IS_COPY(msginfo->flags))
4213                 summaryview->copied--;
4214
4215         procmsg_msginfo_set_to_folder(msginfo, NULL);
4216         summary_msginfo_change_flags(msginfo, MSG_DELETED, 0, MSG_MARKED,
4217                 MSG_MOVE | MSG_COPY | MSG_MOVE_DONE);
4218         summaryview->deleted++;
4219
4220         if (!prefs_common.immediate_exec &&
4221             !folder_has_parent_of_type(summaryview->folder_item, F_TRASH)) {
4222                 summary_set_row_marks(summaryview, row);
4223         } else if (summaryview->folder_item->folder->account && !summaryview->folder_item->folder->account->imap_use_trash) {
4224                 summary_set_row_marks(summaryview, row);
4225         }
4226         debug_print("Message %s/%d is set to delete\n",
4227                     msginfo->folder->path, msginfo->msgnum);
4228 }
4229
4230 void summary_cancel(SummaryView *summaryview)
4231 {
4232         MsgInfo * msginfo;
4233
4234         msginfo = gtk_cmctree_node_get_row_data(GTK_CMCTREE(summaryview->ctree),
4235                                               summaryview->selected);
4236         if (!msginfo) return;
4237
4238         if (!check_permission(summaryview, msginfo))
4239                 return;
4240
4241         news_cancel_article(summaryview->folder_item->folder, msginfo);
4242
4243         if (summary_is_locked(summaryview)) return;
4244
4245         summary_lock(summaryview);
4246
4247         summary_freeze(summaryview);
4248
4249         summary_update_status(summaryview);
4250         summary_status_show(summaryview);
4251
4252         summary_thaw(summaryview);
4253
4254         summary_unlock(summaryview);
4255 }
4256
4257 void summary_delete(SummaryView *summaryview)
4258 {
4259         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
4260         FolderItem *item = summaryview->folder_item;
4261         GList *cur;
4262         GtkCMCTreeNode *sel_last = NULL;
4263         GtkCMCTreeNode *node;
4264         AlertValue aval;
4265         MsgInfo *msginfo;
4266         gboolean froze = FALSE;
4267
4268         if (!item) return;
4269
4270         if (summary_is_locked(summaryview)) return;
4271
4272         if (!summaryview->folder_item) return;
4273
4274         if (!summaryview->folder_item->folder->account || summaryview->folder_item->folder->account->imap_use_trash) {
4275                 if (!prefs_common.live_dangerously) {
4276                         gchar *buf = NULL;
4277                         int num = g_list_length(GTK_CMCLIST(summaryview->ctree)->selection);
4278                         buf = g_strdup_printf(ngettext(
4279                                 "Do you really want to delete the selected message?",
4280                                 "Do you really want to delete the %d selected messages?", num),
4281                                 num);
4282                         aval = alertpanel(_("Delete message(s)"),
4283                                           buf,
4284                                           GTK_STOCK_CANCEL, "+"GTK_STOCK_DELETE, NULL);
4285                         g_free(buf);
4286                         if (aval != G_ALERTALTERNATE) return;
4287                 }
4288         }
4289
4290         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL;
4291              cur = cur->next) {
4292                 GtkCMCTreeNode *row = GTK_CMCTREE_NODE(cur->data);
4293                 msginfo = gtk_cmctree_node_get_row_data(ctree, row);
4294                 if (msginfo && msginfo->total_size != 0 &&
4295                     msginfo->size != (goffset)msginfo->total_size)
4296                         partial_mark_for_delete(msginfo);
4297         }
4298
4299         main_window_cursor_wait(summaryview->mainwin);
4300
4301         /* next code sets current row focus right. We need to find a row
4302          * that is not deleted. */
4303         START_LONG_OPERATION(summaryview, FALSE);
4304         folder_item_set_batch(summaryview->folder_item, TRUE);
4305         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next) {
4306                 sel_last = GTK_CMCTREE_NODE(cur->data);
4307                 summary_delete_row(summaryview, sel_last);
4308         }
4309         folder_item_set_batch(summaryview->folder_item, FALSE);
4310         END_LONG_OPERATION(summaryview);
4311
4312         node = summary_find_next_msg(summaryview, sel_last);
4313         if (!node)
4314                 node = summary_find_prev_msg(summaryview, sel_last);
4315
4316         summary_select_node(summaryview, node, prefs_common.always_show_msg, TRUE);
4317
4318         if (prefs_common.immediate_exec || folder_has_parent_of_type(item, F_TRASH)) {
4319                 summary_execute(summaryview);
4320                 /* after deleting, the anchor may be at an invalid row
4321                  * so reset it to the node we found earlier */
4322                 gtk_sctree_set_anchor_row(GTK_SCTREE(ctree), node);
4323         } else
4324                 summary_status_show(summaryview);
4325
4326
4327         main_window_cursor_normal(summaryview->mainwin);
4328 }
4329
4330 void summary_delete_trash(SummaryView *summaryview)
4331 {
4332         FolderItem *to_folder = NULL;
4333         PrefsAccount *ac;
4334         if (!summaryview->folder_item ||
4335             FOLDER_TYPE(summaryview->folder_item->folder) == F_NEWS) return;
4336
4337         if (NULL != (ac = account_find_from_item(summaryview->folder_item)))
4338                 to_folder = account_get_special_folder(ac, F_TRASH);
4339
4340         if (to_folder == NULL)
4341                 to_folder = summaryview->folder_item->folder->trash;
4342
4343         if (to_folder == NULL || to_folder == summaryview->folder_item
4344             || folder_has_parent_of_type(summaryview->folder_item, F_TRASH)
4345             || (summaryview->folder_item->folder->account && !summaryview->folder_item->folder->account->imap_use_trash))
4346                 summary_delete(summaryview);
4347         else
4348                 summary_move_selected_to(summaryview, to_folder);
4349 }
4350
4351
4352 static void summary_unmark_row(SummaryView *summaryview, GtkCMCTreeNode *row)
4353 {
4354         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
4355         MsgInfo *msginfo;
4356
4357         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
4358         cm_return_if_fail(msginfo);
4359         if (MSG_IS_DELETED(msginfo->flags))
4360                 summaryview->deleted--;
4361         if (MSG_IS_MOVE(msginfo->flags))
4362                 summaryview->moved--;
4363         if (MSG_IS_COPY(msginfo->flags))
4364                 summaryview->copied--;
4365
4366         procmsg_msginfo_set_to_folder(msginfo, NULL);
4367         summary_msginfo_unset_flags(msginfo, MSG_MARKED | MSG_DELETED,
4368                 MSG_MOVE | MSG_COPY | MSG_MOVE_DONE);
4369         summary_set_row_marks(summaryview, row);
4370
4371         debug_print("Message %s/%d is unmarked\n",
4372                     msginfo->folder->path, msginfo->msgnum);
4373 }
4374
4375 void summary_unmark(SummaryView *summaryview)
4376 {
4377         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
4378         GList *cur;
4379         gboolean froze = FALSE;
4380
4381         if (summary_is_locked(summaryview))
4382                 return;
4383         START_LONG_OPERATION(summaryview, FALSE);
4384         folder_item_set_batch(summaryview->folder_item, TRUE);
4385         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
4386                 summary_unmark_row(summaryview, GTK_CMCTREE_NODE(cur->data));
4387         folder_item_set_batch(summaryview->folder_item, FALSE);
4388         END_LONG_OPERATION(summaryview);
4389
4390         summary_status_show(summaryview);
4391 }
4392
4393 static void summary_move_row_to(SummaryView *summaryview, GtkCMCTreeNode *row,
4394                                 FolderItem *to_folder)
4395 {
4396         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
4397         MsgInfo *msginfo;
4398
4399         cm_return_if_fail(to_folder != NULL);
4400
4401         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
4402         cm_return_if_fail(msginfo);
4403         if (MSG_IS_LOCKED(msginfo->flags))
4404                 return;
4405
4406         procmsg_msginfo_set_to_folder(msginfo, to_folder);
4407         if (MSG_IS_DELETED(msginfo->flags))
4408                 summaryview->deleted--;
4409         if (MSG_IS_COPY(msginfo->flags)) {
4410                 summaryview->copied--;
4411         }
4412         if (!MSG_IS_MOVE(msginfo->flags)) {
4413                 summary_msginfo_change_flags(msginfo, 0, MSG_MOVE, MSG_DELETED,
4414                         MSG_COPY | MSG_MOVE_DONE);
4415                 summaryview->moved++;
4416         } else {
4417                 summary_msginfo_unset_flags(msginfo, MSG_DELETED, MSG_COPY);
4418         }
4419
4420         if (!prefs_common.immediate_exec) {
4421                 summary_set_row_marks(summaryview, row);
4422         } else if (msginfo->folder->folder->account && !msginfo->folder->folder->account->imap_use_trash) {
4423                 summary_set_row_marks(summaryview, row);
4424         }
4425
4426         debug_print("Message %d is set to move to %s\n",
4427                     msginfo->msgnum, to_folder->path);
4428 }
4429
4430 void summary_move_selected_to(SummaryView *summaryview, FolderItem *to_folder)
4431 {
4432         GList *cur;
4433         GtkCMCTreeNode *sel_last = NULL;
4434         gboolean froze = FALSE;
4435
4436         if (!to_folder) return;
4437         if (!summaryview->folder_item ||
4438             FOLDER_TYPE(summaryview->folder_item->folder) == F_NEWS) return;
4439
4440         if (summary_is_locked(summaryview)) return;
4441
4442         if (summaryview->folder_item == to_folder) {
4443                 alertpanel_error(_("Destination is same as current folder."));
4444                 return;
4445         }
4446
4447         if (to_folder->no_select) {
4448                 alertpanel_error(_("The destination folder can only be used to "
4449                                    "store subfolders."));
4450                 return;
4451         }
4452
4453         START_LONG_OPERATION(summaryview, FALSE);
4454
4455         for (cur = GTK_CMCLIST(summaryview->ctree)->selection;
4456              cur != NULL && cur->data != NULL; cur = cur->next) {
4457                 sel_last = GTK_CMCTREE_NODE(cur->data);
4458                 summary_move_row_to
4459                         (summaryview, GTK_CMCTREE_NODE(cur->data), to_folder);
4460         }
4461         END_LONG_OPERATION(summaryview);
4462
4463         summaryview->display_msg = (prefs_common.always_show_msg == OPENMSG_ALWAYS) ||
4464                 ((prefs_common.always_show_msg == OPENMSG_WHEN_VIEW_VISIBLE &&
4465                                 messageview_is_visible(summaryview->messageview)));
4466
4467         if (prefs_common.immediate_exec) {
4468                 summary_execute(summaryview);
4469         } else {
4470                 GtkCMCTreeNode *node = summary_find_next_msg(summaryview, sel_last);
4471                 if (!node)
4472                         node = summary_find_prev_msg(summaryview, sel_last);
4473                 summary_select_node(summaryview, node, summaryview->display_msg, TRUE);
4474                 summary_status_show(summaryview);
4475         }
4476
4477         if (!summaryview->selected) { /* this was the last message */
4478                 GtkCMCTreeNode *node = gtk_cmctree_node_nth (GTK_CMCTREE(summaryview->ctree),
4479                                                          GTK_CMCLIST(summaryview->ctree)->rows - 1);
4480                 if (node)
4481                         summary_select_node(summaryview, node, summaryview->display_msg, TRUE);
4482         }
4483
4484 }
4485
4486 void summary_move_to(SummaryView *summaryview)
4487 {
4488         FolderItem *to_folder;
4489
4490         if (!summaryview->folder_item ||
4491             FOLDER_TYPE(summaryview->folder_item->folder) == F_NEWS) return;
4492
4493         to_folder = foldersel_folder_sel(summaryview->folder_item->folder,
4494                                          FOLDER_SEL_MOVE, NULL, FALSE);
4495         summary_move_selected_to(summaryview, to_folder);
4496 }
4497
4498 static void summary_copy_row_to(SummaryView *summaryview, GtkCMCTreeNode *row,
4499                                 FolderItem *to_folder)
4500 {
4501         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
4502         MsgInfo *msginfo;
4503
4504         cm_return_if_fail(to_folder != NULL);
4505
4506         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
4507         cm_return_if_fail(msginfo);
4508         procmsg_msginfo_set_to_folder(msginfo, to_folder);
4509         if (MSG_IS_DELETED(msginfo->flags))
4510                 summaryview->deleted--;
4511         if (MSG_IS_MOVE(msginfo->flags)) {
4512                 summaryview->moved--;
4513         }
4514
4515         if (!MSG_IS_COPY(msginfo->flags)) {
4516                 summary_msginfo_change_flags(msginfo, 0, MSG_COPY, MSG_DELETED,
4517                         MSG_MOVE | MSG_MOVE_DONE);
4518                 summaryview->copied++;
4519         } else {
4520                 summary_msginfo_unset_flags(msginfo, MSG_DELETED, MSG_MOVE);
4521         }
4522         if (!prefs_common.immediate_exec) {
4523                 summary_set_row_marks(summaryview, row);
4524         }
4525
4526         debug_print("Message %d is set to copy to %s\n",
4527                     msginfo->msgnum, to_folder->path);
4528 }
4529
4530 void summary_copy_selected_to(SummaryView *summaryview, FolderItem *to_folder)
4531 {
4532         GList *cur;
4533         gboolean froze = FALSE;
4534
4535         if (!to_folder) return;
4536         if (!summaryview->folder_item) return;
4537
4538         if (summary_is_locked(summaryview)) return;
4539
4540         if (summaryview->folder_item == to_folder) {
4541                 alertpanel_error
4542                         (_("Destination to copy is same as current folder."));
4543                 return;
4544         }
4545
4546         if (to_folder->no_select) {
4547                 alertpanel_error(_("The destination folder can only be used to "
4548                                    "store subfolders."));
4549                 return;
4550         }
4551
4552         START_LONG_OPERATION(summaryview, FALSE);
4553
4554         for (cur = GTK_CMCLIST(summaryview->ctree)->selection;
4555              cur != NULL && cur->data != NULL; cur = cur->next)
4556                 summary_copy_row_to
4557                         (summaryview, GTK_CMCTREE_NODE(cur->data), to_folder);
4558
4559         END_LONG_OPERATION(summaryview);
4560
4561         if (prefs_common.immediate_exec)
4562                 summary_execute(summaryview);
4563         else {
4564                 summary_status_show(summaryview);
4565         }
4566 }
4567
4568 void summary_copy_to(SummaryView *summaryview)
4569 {
4570         FolderItem *to_folder;
4571
4572         if (!summaryview->folder_item) return;
4573
4574         to_folder = foldersel_folder_sel(summaryview->folder_item->folder,
4575                                          FOLDER_SEL_COPY, NULL, FALSE);
4576         summary_copy_selected_to(summaryview, to_folder);
4577 }
4578
4579 void summary_add_address(SummaryView *summaryview)
4580 {
4581         MsgInfo *msginfo, *full_msginfo;
4582         gchar *from;
4583         GtkWidget *image = NULL;
4584         GdkPixbuf *picture = NULL;
4585
4586         msginfo = gtk_cmctree_node_get_row_data(GTK_CMCTREE(summaryview->ctree),
4587                                               summaryview->selected);
4588         if (!msginfo || !msginfo->from)
4589                 return;
4590
4591         Xstrdup_a(from, msginfo->from, return);
4592         eliminate_address_comment(from);
4593         extract_address(from);
4594
4595         full_msginfo = procmsg_msginfo_get_full_info(msginfo);
4596         if (full_msginfo &&
4597             full_msginfo->extradata &&
4598             full_msginfo->extradata->face) {
4599                 image = face_get_from_header(full_msginfo->extradata->face);
4600         }
4601 #if HAVE_LIBCOMPFACE
4602         else if (full_msginfo &&
4603                  full_msginfo->extradata &&
4604                  full_msginfo->extradata->xface) {
4605                 image = xface_get_from_header(full_msginfo->extradata->xface,
4606                                 &summaryview->ctree->style->white,
4607                                 summaryview->mainwin->window->window);
4608         }
4609 #endif
4610         procmsg_msginfo_free(full_msginfo);
4611         if (image)
4612                 picture = gtk_image_get_pixbuf(GTK_IMAGE(image));
4613
4614         addressbook_add_contact(msginfo->fromname, from, NULL, picture);
4615
4616         if (image)
4617                 gtk_widget_destroy(image);
4618 }
4619
4620 void summary_select_all(SummaryView *summaryview)
4621 {
4622         if (!summaryview->folder_item) return;
4623
4624         summary_lock(summaryview);
4625         gtk_cmclist_select_all(GTK_CMCLIST(summaryview->ctree));
4626         summary_unlock(summaryview);
4627         summary_status_show(summaryview);
4628 }
4629
4630 void summary_unselect_all(SummaryView *summaryview)
4631 {
4632         summary_lock(summaryview);
4633         gtk_sctree_unselect_all(GTK_SCTREE(summaryview->ctree));
4634         summary_unlock(summaryview);
4635         summary_status_show(summaryview);
4636 }
4637
4638 void summary_select_thread(SummaryView *summaryview, gboolean delete_thread)
4639 {
4640         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
4641         GtkCMCTreeNode *node = NULL;
4642         gboolean froze = FALSE;
4643         GList *cur = NULL;
4644         GList *copy = NULL;
4645         if (!GTK_CMCLIST(summaryview->ctree)->selection)
4646                 return;
4647
4648
4649         START_LONG_OPERATION(summaryview, FALSE);
4650         copy = g_list_copy(GTK_CMCLIST(summaryview->ctree)->selection);
4651         for (cur = copy; cur != NULL && cur->data != NULL;
4652              cur = cur->next) {
4653                 node = GTK_CMCTREE_NODE(cur->data);
4654                 if (!node)
4655                         continue;
4656                 while (GTK_CMCTREE_ROW(node)->parent != NULL)
4657                         node = GTK_CMCTREE_ROW(node)->parent;
4658
4659                 gtk_cmctree_select_recursive(ctree, node);
4660         }
4661         g_list_free(copy);
4662         END_LONG_OPERATION(summaryview);
4663
4664         if (delete_thread) {
4665                 if (FOLDER_TYPE(summaryview->folder_item->folder) == F_NEWS)
4666                         summary_delete(summaryview);
4667                 else
4668                         summary_delete_trash(summaryview);
4669         }
4670         summary_status_show(summaryview);
4671 }
4672
4673 void summary_save_as(SummaryView *summaryview)
4674 {
4675         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
4676         MsgInfo *msginfo;
4677         gchar *filename = NULL;
4678         gchar *src, *dest;
4679         gchar *tmp;
4680
4681         AlertValue aval = 0;
4682
4683         if (!summaryview->selected) return;
4684         msginfo = gtk_cmctree_node_get_row_data(ctree, summaryview->selected);
4685         if (!msginfo) return;
4686
4687         if (msginfo->subject) {
4688                 Xstrdup_a(filename, msginfo->subject, return);
4689                 subst_for_filename(filename);
4690         }
4691         if (filename && !g_utf8_validate(filename, -1, NULL)) {
4692                 gchar *oldstr = filename;
4693                 filename = conv_codeset_strdup(filename,
4694                                                conv_get_locale_charset_str(),
4695                                                CS_UTF_8);
4696                 if (!filename) {
4697                         g_warning("summary_save_as(): failed to convert character set.");
4698                         filename = g_strdup(oldstr);
4699                 }
4700                 dest = filesel_select_file_save(_("Save as"), filename);
4701                 g_free(filename);
4702         } else
4703                 dest = filesel_select_file_save(_("Save as"), filename);
4704         filename = NULL;
4705         if (!dest) return;
4706         if (is_file_exist(dest)) {
4707                 aval = alertpanel(_("Append or Overwrite"),
4708                                   _("Append or overwrite existing file?"),
4709                                   _("_Append"), _("_Overwrite"),
4710                                   GTK_STOCK_CANCEL);
4711                 if (aval != 0 && aval != 1)
4712                         return;
4713         }
4714
4715         src = procmsg_get_message_file(msginfo);
4716         tmp = g_path_get_basename(dest);
4717
4718         if ( aval==0 ) { /* append */
4719                 if (append_file(src, dest, TRUE) < 0)
4720                         alertpanel_error(_("Couldn't save the file '%s'."), tmp);
4721         } else { /* overwrite */
4722                 if (copy_file(src, dest, TRUE) < 0)
4723                         alertpanel_error(_("Couldn't save the file '%s'."), tmp);
4724         }
4725         g_free(src);
4726
4727         /*
4728          * If two or more msgs are selected,
4729          * append them to the output file.
4730          */
4731         if (GTK_CMCLIST(ctree)->selection->next) {
4732                 GList *item;
4733                 for (item = GTK_CMCLIST(ctree)->selection->next; item != NULL; item=item->next) {
4734                         msginfo = gtk_cmctree_node_get_row_data(ctree, GTK_CMCTREE_NODE(item->data));
4735                         if (!msginfo) break;
4736                         src = procmsg_get_message_file(msginfo);
4737                         if (append_file(src, dest, TRUE) < 0)
4738                                 alertpanel_error(_("Couldn't save the file '%s'."), tmp);
4739                 }
4740                 g_free(src);
4741         }
4742         g_free(dest);
4743         g_free(tmp);
4744 }
4745
4746 void summary_print(SummaryView *summaryview)
4747 {
4748         GtkCMCList *clist = GTK_CMCLIST(summaryview->ctree);
4749         GList *cur;
4750         gchar *msg = g_strdup_printf(_("You are about to print %d "
4751                                        "messages, one by one. Do you "
4752                                        "want to continue?"),
4753                                        g_list_length(clist->selection));
4754         if (g_list_length(clist->selection) > 9
4755         &&  alertpanel(_("Warning"), msg, GTK_STOCK_CANCEL, "+" GTK_STOCK_YES, NULL)
4756             != G_ALERTALTERNATE) {
4757                 g_free(msg);
4758                 return;
4759         }
4760         g_free(msg);
4761
4762         if (clist->selection == NULL) return;
4763         for (cur = clist->selection;
4764              cur != NULL && cur->data != NULL;
4765              cur = cur->next) {
4766                 GtkCMCTreeNode *node = GTK_CMCTREE_NODE(cur->data);
4767                 MsgInfo *msginfo = gtk_cmctree_node_get_row_data(
4768                                         GTK_CMCTREE(summaryview->ctree),
4769                                         node);
4770                 gint sel_start = -1, sel_end = -1, partnum = 0;
4771
4772                 if (node == summaryview->displayed) {
4773                         partnum = mimeview_get_selected_part_num(summaryview->messageview->mimeview);
4774                         textview_get_selection_offsets(summaryview->messageview->mimeview->textview,
4775                                 &sel_start, &sel_end);
4776                 }
4777                 messageview_print(msginfo, summaryview->messageview->all_headers,
4778                         sel_start, sel_end, partnum);
4779         }
4780 }
4781
4782 gboolean summary_execute(SummaryView *summaryview)
4783 {
4784         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
4785         GtkCMCList *clist = GTK_CMCLIST(summaryview->ctree);
4786         GtkCMCTreeNode *node, *next;
4787         GtkCMCTreeNode *new_selected = NULL;
4788         gint move_val = -1;
4789
4790         if (!summaryview->folder_item) return FALSE;
4791
4792         if (summary_is_locked(summaryview)) return FALSE;
4793         summary_lock(summaryview);
4794
4795         summary_freeze(summaryview);
4796
4797         main_window_cursor_wait(summaryview->mainwin);
4798
4799         if (summaryview->threaded)
4800                 summary_unthread_for_exec(summaryview);
4801
4802         folder_item_update_freeze();
4803         move_val = summary_execute_move(summaryview);
4804         summary_execute_copy(summaryview);
4805         summary_execute_delete(summaryview);
4806
4807         node = GTK_CMCTREE_NODE(clist->row_list);
4808         for (; node != NULL; node = next) {
4809                 next = gtkut_ctree_node_next(ctree, node);
4810                 if (gtk_cmctree_node_get_row_data(ctree, node) != NULL) continue;
4811
4812                 if (node == summaryview->displayed) {
4813                         messageview_clear(summaryview->messageview);
4814                         summaryview->displayed = NULL;
4815                 }
4816                 if (GTK_CMCTREE_ROW(node)->children != NULL) {
4817                         next = NULL;
4818                         if (GTK_CMCTREE_ROW(node)->sibling) {
4819                                 next = GTK_CMCTREE_ROW(node)->sibling;
4820                         } else {
4821                                 GtkCMCTreeNode *parent = NULL;
4822                                 for (parent = GTK_CMCTREE_ROW(node)->parent; parent != NULL;
4823                                      parent = GTK_CMCTREE_ROW(parent)->parent) {
4824                                         if (GTK_CMCTREE_ROW(parent)->sibling) {
4825                                                 next = GTK_CMCTREE_ROW(parent)->sibling;
4826                                         }
4827                                 }
4828                         }
4829                 }
4830
4831                 if (!new_selected &&
4832                     gtkut_ctree_node_is_selected(ctree, node)) {
4833                         summary_unselect_all(summaryview);
4834                         new_selected = summary_find_next_msg(summaryview, node);
4835                         if (!new_selected)
4836                                 new_selected = summary_find_prev_msg
4837                                         (summaryview, node);
4838                 }
4839
4840                 gtk_sctree_remove_node((GtkSCTree *)ctree, node);
4841         }
4842
4843         folder_item_update_thaw();
4844
4845         if (new_selected) {
4846                 summary_unlock(summaryview);
4847                 gtk_sctree_select
4848                         (GTK_SCTREE(ctree), new_selected);
4849                 summary_lock(summaryview);
4850         }
4851
4852         if (summaryview->threaded) {
4853                 summary_thread_build(summaryview);
4854                 summary_thread_init(summaryview);
4855         }
4856
4857         summary_thaw(summaryview);
4858
4859         summaryview->selected = clist->selection ?
4860                 GTK_CMCTREE_NODE(clist->selection->data) : NULL;
4861
4862         if (!GTK_CMCLIST(summaryview->ctree)->row_list) {
4863                 menu_set_insensitive_all
4864                         (GTK_MENU_SHELL(summaryview->popupmenu));
4865                 gtk_widget_grab_focus(summaryview->folderview->ctree);
4866         } else {
4867                 menu_set_sensitive_all(GTK_MENU_SHELL(summaryview->popupmenu), TRUE);
4868                 gtk_widget_grab_focus(summaryview->ctree);
4869         }
4870         summary_update_status(summaryview);
4871         summary_status_show(summaryview);
4872
4873         gtk_cmctree_node_moveto(ctree, summaryview->selected, 0, 0.5, 0);
4874
4875         summary_unlock(summaryview);
4876
4877         main_window_cursor_normal(summaryview->mainwin);
4878
4879         if (move_val < 0)
4880                 summary_show(summaryview, summaryview->folder_item);
4881         return TRUE;
4882 }
4883
4884 gboolean summary_expunge(SummaryView *summaryview)
4885 {
4886         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
4887         GtkCMCList *clist = GTK_CMCLIST(summaryview->ctree);
4888         GtkCMCTreeNode *node, *next;
4889         GtkCMCTreeNode *new_selected = NULL;
4890
4891         if (!summaryview->folder_item) return FALSE;
4892
4893         if (summary_is_locked(summaryview)) return FALSE;
4894
4895         summary_lock(summaryview);
4896
4897         summary_freeze(summaryview);
4898
4899         main_window_cursor_wait(summaryview->mainwin);
4900
4901         if (summaryview->threaded)
4902                 summary_unthread_for_exec(summaryview);
4903
4904         folder_item_update_freeze();
4905         summary_execute_expunge(summaryview);
4906
4907         node = GTK_CMCTREE_NODE(clist->row_list);
4908         for (; node != NULL; node = next) {
4909                 next = gtkut_ctree_node_next(ctree, node);
4910                 if (gtk_cmctree_node_get_row_data(ctree, node) != NULL) continue;
4911
4912                 if (node == summaryview->displayed) {
4913                         messageview_clear(summaryview->messageview);
4914                         summaryview->displayed = NULL;
4915                 }
4916                 if (GTK_CMCTREE_ROW(node)->children != NULL) {
4917                         next = NULL;
4918                         if (GTK_CMCTREE_ROW(node)->sibling) {
4919                                 next = GTK_CMCTREE_ROW(node)->sibling;
4920                         } else {
4921                                 GtkCMCTreeNode *parent = NULL;
4922                                 for (parent = GTK_CMCTREE_ROW(node)->parent; parent != NULL;
4923                                      parent = GTK_CMCTREE_ROW(parent)->parent) {
4924                                         if (GTK_CMCTREE_ROW(parent)->sibling) {
4925                                                 next = GTK_CMCTREE_ROW(parent)->sibling;
4926                                         }
4927                                 }
4928                         }
4929                 }
4930
4931                 if (!new_selected &&
4932                     gtkut_ctree_node_is_selected(ctree, node)) {
4933                         summary_unselect_all(summaryview);
4934                         new_selected = summary_find_next_msg(summaryview, node);
4935                         if (!new_selected)
4936                                 new_selected = summary_find_prev_msg
4937                                         (summaryview, node);
4938                 }
4939
4940                 gtk_sctree_remove_node((GtkSCTree *)ctree, node);
4941         }
4942
4943         folder_item_update_thaw();
4944
4945         if (new_selected) {
4946                 summary_unlock(summaryview);
4947                 gtk_sctree_select
4948                         (GTK_SCTREE(ctree), new_selected);
4949                 summary_lock(summaryview);
4950         }
4951
4952         if (summaryview->threaded) {
4953                 summary_thread_build(summaryview);
4954                 summary_thread_init(summaryview);
4955         }
4956
4957         summary_thaw(summaryview);
4958
4959         summaryview->selected = clist->selection ?
4960                 GTK_CMCTREE_NODE(clist->selection->data) : NULL;
4961
4962         if (!GTK_CMCLIST(summaryview->ctree)->row_list) {
4963                 menu_set_insensitive_all
4964                         (GTK_MENU_SHELL(summaryview->popupmenu));
4965                 gtk_widget_grab_focus(summaryview->folderview->ctree);
4966         } else {
4967                 menu_set_sensitive_all(GTK_MENU_SHELL(summaryview->popupmenu), TRUE);
4968                 gtk_widget_grab_focus(summaryview->ctree);
4969         }
4970
4971         summary_update_status(summaryview);
4972         summary_status_show(summaryview);
4973
4974         gtk_cmctree_node_moveto(ctree, summaryview->selected, 0, 0.5, 0);
4975
4976         summary_unlock(summaryview);
4977
4978         main_window_cursor_normal(summaryview->mainwin);
4979
4980         return TRUE;
4981 }
4982
4983 static void summary_set_deleted_func(GtkCMCTree *ctree, GtkCMCTreeNode *node,
4984                                       gpointer data)
4985 {
4986         SummaryView *summaryview = data;
4987         MsgInfo *msginfo;
4988
4989         msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(node);
4990
4991         if (msginfo && MSG_IS_MOVE(msginfo->flags)) {
4992                 msginfo->flags.tmp_flags &= ~ MSG_MOVE;
4993                 msginfo->flags.perm_flags |= MSG_DELETED;
4994                 summary_set_row_marks(summaryview, node);
4995                 summaryview->moved--;
4996                 summaryview->deleted++;
4997         }
4998 }
4999
5000 static gint summary_execute_move(SummaryView *summaryview)
5001 {
5002         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5003         GSList *cur;
5004         gint val = -1;
5005         /* search moving messages and execute */
5006
5007         gtk_cmctree_pre_recursive(ctree, NULL, summary_execute_move_func,
5008                         summaryview);
5009
5010         if (summaryview->mlist) {
5011                 hooks_unregister_hook(MSGINFO_UPDATE_HOOKLIST,
5012                         summaryview->msginfo_update_callback_id);
5013                 val = procmsg_move_messages(summaryview->mlist);
5014                 summaryview->msginfo_update_callback_id =
5015                 hooks_register_hook(MSGINFO_UPDATE_HOOKLIST,
5016                         summary_update_msg, (gpointer) summaryview);
5017
5018                 if (!summaryview->folder_item->folder->account || summaryview->folder_item->folder->account->imap_use_trash) {
5019                         for (cur = summaryview->mlist; cur != NULL && cur->data != NULL; cur = cur->next)
5020                                 procmsg_msginfo_free((MsgInfo *)cur->data);
5021                 }
5022                 if (summaryview->folder_item->folder->account && !summaryview->folder_item->folder->account->imap_use_trash) {
5023                         gtk_cmctree_pre_recursive(ctree, NULL, summary_set_deleted_func,
5024                                         summaryview);
5025                 }
5026                 g_slist_free(summaryview->mlist);
5027                 summaryview->mlist = NULL;
5028                 return val;
5029         }
5030         return 0;
5031 }
5032
5033 static void summary_execute_move_func(GtkCMCTree *ctree, GtkCMCTreeNode *node,
5034                                       gpointer data)
5035 {
5036         SummaryView *summaryview = data;
5037         MsgInfo *msginfo;
5038
5039         msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(node);
5040
5041         if (msginfo && MSG_IS_MOVE(msginfo->flags) && msginfo->to_folder) {
5042                 summaryview->mlist =
5043                         g_slist_prepend(summaryview->mlist, msginfo);
5044                 if (!summaryview->folder_item->folder->account ||
5045                      summaryview->folder_item->folder->account->imap_use_trash) {
5046                         gtk_cmctree_node_set_row_data(ctree, node, NULL);
5047
5048                         if (msginfo->msgid && *msginfo->msgid &&
5049                             node == g_hash_table_lookup(summaryview->msgid_table,
5050                                                         msginfo->msgid))
5051                                 g_hash_table_remove(summaryview->msgid_table,
5052                                                     msginfo->msgid);
5053                         if (prefs_common.thread_by_subject &&
5054                             msginfo->subject && *msginfo->subject &&
5055                             node == subject_table_lookup(summaryview->subject_table,
5056                                                          msginfo->subject)) {
5057                                 subject_table_remove(summaryview->subject_table,
5058                                                      msginfo->subject);
5059                         }
5060                 }
5061         }
5062 }
5063
5064 static void summary_execute_copy(SummaryView *summaryview)
5065 {
5066         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5067
5068         /* search copying messages and execute */
5069         hooks_unregister_hook(MSGINFO_UPDATE_HOOKLIST,
5070                 summaryview->msginfo_update_callback_id);
5071         gtk_cmctree_pre_recursive(ctree, NULL, summary_execute_copy_func,
5072                                 summaryview);
5073
5074         if (summaryview->mlist) {
5075                 summaryview->mlist = g_slist_reverse(summaryview->mlist);
5076                 procmsg_copy_messages(summaryview->mlist);
5077
5078                 g_slist_free(summaryview->mlist);
5079                 summaryview->mlist = NULL;
5080         }
5081         summaryview->msginfo_update_callback_id =
5082                 hooks_register_hook(MSGINFO_UPDATE_HOOKLIST,
5083                         summary_update_msg, (gpointer) summaryview);
5084 }
5085
5086 static void summary_execute_copy_func(GtkCMCTree *ctree, GtkCMCTreeNode *node,
5087                                       gpointer data)
5088 {
5089         SummaryView *summaryview = data;
5090         MsgInfo *msginfo;
5091
5092         msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(node);
5093
5094         if (msginfo && MSG_IS_COPY(msginfo->flags) && msginfo->to_folder) {
5095                 summaryview->mlist =
5096                         g_slist_prepend(summaryview->mlist, msginfo);
5097
5098                 summary_msginfo_unset_flags(msginfo, 0, MSG_COPY);
5099                 summary_set_row_marks(summaryview, node);
5100         }
5101 }
5102
5103 static void summary_execute_delete(SummaryView *summaryview)
5104 {
5105         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5106         GSList *cur;
5107
5108         /* search deleting messages and execute */
5109         if (!summaryview->folder_item->folder->account || summaryview->folder_item->folder->account->imap_use_trash) {
5110                 gtk_cmctree_pre_recursive
5111                         (ctree, NULL, summary_execute_delete_func, summaryview);
5112         }
5113         if (!summaryview->mlist) return;
5114
5115         hooks_unregister_hook(MSGINFO_UPDATE_HOOKLIST,
5116                 summaryview->msginfo_update_callback_id);
5117
5118         folder_item_remove_msgs(summaryview->folder_item,
5119                                 summaryview->mlist);
5120
5121         summaryview->msginfo_update_callback_id =
5122                 hooks_register_hook(MSGINFO_UPDATE_HOOKLIST,
5123                         summary_update_msg, (gpointer) summaryview);
5124         if (!summaryview->folder_item->folder->account || summaryview->folder_item->folder->account->imap_use_trash) {
5125                 for (cur = summaryview->mlist; cur != NULL && cur->data != NULL; cur = cur->next)
5126                         procmsg_msginfo_free((MsgInfo *)cur->data);
5127         }
5128         g_slist_free(summaryview->mlist);
5129         summaryview->mlist = NULL;
5130 }
5131
5132 static void summary_execute_delete_func(GtkCMCTree *ctree, GtkCMCTreeNode *node,
5133                                         gpointer data)
5134 {
5135         SummaryView *summaryview = data;
5136         MsgInfo *msginfo;
5137
5138         msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(node);
5139
5140         if (msginfo && MSG_IS_DELETED(msginfo->flags)) {
5141                 summaryview->mlist =
5142                         g_slist_prepend(summaryview->mlist, msginfo);
5143                 gtk_cmctree_node_set_row_data(ctree, node, NULL);
5144
5145                 if (msginfo->msgid && *msginfo->msgid &&
5146                     node == g_hash_table_lookup(summaryview->msgid_table,
5147                                                 msginfo->msgid)) {
5148                         g_hash_table_remove(summaryview->msgid_table,
5149                                             msginfo->msgid);
5150                 }
5151                 if (prefs_common.thread_by_subject &&
5152                     msginfo->subject && *msginfo->subject &&
5153                     node == subject_table_lookup(summaryview->subject_table,
5154                                                  msginfo->subject)) {
5155                         subject_table_remove(summaryview->subject_table,
5156                                              msginfo->subject);
5157                 }
5158         }
5159 }
5160
5161 static void summary_execute_expunge_func(GtkCMCTree *ctree, GtkCMCTreeNode *node,
5162                                         gpointer data)
5163 {
5164         SummaryView *summaryview = data;
5165         MsgInfo *msginfo;
5166
5167         msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(node);
5168
5169         if (msginfo && MSG_IS_DELETED(msginfo->flags)) {
5170                 summaryview->mlist =
5171                         g_slist_prepend(summaryview->mlist, msginfo);
5172                 gtk_cmctree_node_set_row_data(ctree, node, NULL);
5173
5174                 if (msginfo->msgid && *msginfo->msgid &&
5175                     node == g_hash_table_lookup(summaryview->msgid_table,
5176                                                 msginfo->msgid)) {
5177                         g_hash_table_remove(summaryview->msgid_table,
5178                                             msginfo->msgid);
5179                 }
5180                 if (prefs_common.thread_by_subject &&
5181                     msginfo->subject && *msginfo->subject &&
5182                     node == subject_table_lookup(summaryview->subject_table,
5183                                                  msginfo->subject)) {
5184                         subject_table_remove(summaryview->subject_table,
5185                                              msginfo->subject);
5186                 }
5187         }
5188 }
5189
5190 static void summary_execute_expunge(SummaryView *summaryview)
5191 {
5192         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5193         GSList *cur;
5194
5195         gtk_cmctree_pre_recursive
5196                 (ctree, NULL, summary_execute_expunge_func, summaryview);
5197
5198         hooks_unregister_hook(MSGINFO_UPDATE_HOOKLIST,
5199                 summaryview->msginfo_update_callback_id);
5200
5201         folder_item_expunge(summaryview->folder_item);
5202
5203         summaryview->msginfo_update_callback_id =
5204                 hooks_register_hook(MSGINFO_UPDATE_HOOKLIST,
5205                         summary_update_msg, (gpointer) summaryview);
5206         for (cur = summaryview->mlist; cur != NULL && cur->data != NULL; cur = cur->next)
5207                 procmsg_msginfo_free((MsgInfo *)cur->data);
5208
5209         g_slist_free(summaryview->mlist);
5210         summaryview->mlist = NULL;
5211 }
5212
5213 /* thread functions */
5214
5215 static void summary_thread_build(SummaryView *summaryview)
5216 {
5217         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5218         GtkCMCTreeNode *node;
5219         GtkCMCTreeNode *next;
5220         GtkCMCTreeNode *parent;
5221         MsgInfo *msginfo;
5222         GSList *reflist;
5223
5224         summary_lock(summaryview);
5225
5226         debug_print("Building threads...");
5227         STATUSBAR_PUSH(summaryview->mainwin, _("Building threads..."));
5228         main_window_cursor_wait(summaryview->mainwin);
5229
5230         g_signal_handlers_block_by_func(G_OBJECT(ctree),
5231                                        G_CALLBACK(summary_tree_expanded), summaryview);
5232         summary_freeze(summaryview);
5233
5234         node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
5235         while (node) {
5236                 next = GTK_CMCTREE_ROW(node)->sibling;
5237
5238                 msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(node);
5239
5240                 parent = NULL;
5241
5242                 if (msginfo && msginfo->inreplyto) {
5243                         parent = g_hash_table_lookup(summaryview->msgid_table,
5244                                                      msginfo->inreplyto);
5245
5246                         if (!parent && msginfo->references) {
5247                                 for (reflist = msginfo->references;
5248                                      reflist != NULL; reflist = reflist->next)
5249                                         if ((parent = g_hash_table_lookup
5250                                                 (summaryview->msgid_table,
5251                                                  reflist->data)))
5252                                                 break;
5253                         }
5254                 }
5255
5256                 if (msginfo && prefs_common.thread_by_subject && parent == NULL) {
5257                         parent = subject_table_lookup
5258                                 (summaryview->subject_table,
5259                                  msginfo->subject);
5260                 }
5261
5262                 if (parent && parent != node && parent != GTK_CMCTREE_ROW(node)->parent) {
5263                         gtk_cmctree_move(ctree, node, parent, NULL);
5264                 }
5265
5266                 node = next;
5267         }
5268
5269         gtkut_ctree_set_focus_row(ctree, summaryview->selected);
5270
5271         summary_thaw(summaryview);
5272         g_signal_handlers_unblock_by_func(G_OBJECT(ctree),
5273                                          G_CALLBACK(summary_tree_expanded), summaryview);
5274
5275         debug_print("done.\n");
5276         STATUSBAR_POP(summaryview->mainwin);
5277         main_window_cursor_normal(summaryview->mainwin);
5278
5279         summaryview->threaded = TRUE;
5280
5281         summary_unlock(summaryview);
5282 }
5283
5284 static void summary_thread_init(SummaryView *summaryview)
5285 {
5286         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5287         GtkCMCTreeNode *node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
5288         GtkCMCTreeNode *next;
5289         START_TIMING("");
5290         if (!summaryview->thread_collapsed) {
5291                 g_signal_handlers_block_by_func(G_OBJECT(ctree),
5292                                        G_CALLBACK(summary_tree_expanded), summaryview);
5293                 while (node) {
5294                         next = GTK_CMCTREE_ROW(node)->sibling;
5295                         if (GTK_CMCTREE_ROW(node)->children)
5296                                 gtk_cmctree_expand_recursive(ctree, node);
5297                         node = next;
5298                 }
5299                 g_signal_handlers_unblock_by_func(G_OBJECT(ctree),
5300                                        G_CALLBACK(summary_tree_expanded), summaryview);
5301         }
5302         END_TIMING();
5303 }
5304
5305 static void summary_unthread_for_exec(SummaryView *summaryview)
5306 {
5307         GtkCMCTreeNode *node;
5308         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5309         gboolean froze = FALSE;
5310
5311         debug_print("Unthreading for execution...");
5312
5313         START_LONG_OPERATION(summaryview, TRUE);
5314         for (node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
5315              node != NULL; node = GTK_CMCTREE_NODE_NEXT(node)) {
5316                 summary_unthread_for_exec_func(ctree, node, summaryview);
5317         }
5318
5319         END_LONG_OPERATION(summaryview);
5320
5321         debug_print("done.\n");
5322 }
5323
5324 static void summary_unthread_for_exec_func(GtkCMCTree *ctree, GtkCMCTreeNode *node,
5325                                            gpointer data)
5326 {
5327         MsgInfo *msginfo;
5328         GtkCMCTreeNode *top_parent;
5329         GtkCMCTreeNode *child;
5330         GtkCMCTreeNode *sibling;
5331         SummaryView * summaryview = (SummaryView *)data;
5332         msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(node);
5333
5334         if (!msginfo ||
5335             (!MSG_IS_MOVE(msginfo->flags) &&
5336              !MSG_IS_DELETED(msginfo->flags)))
5337                 return;
5338         child = GTK_CMCTREE_ROW(node)->children;
5339         if (!child) return;
5340
5341         if (node == summaryview->selected)
5342                 summaryview->selected = NULL;
5343         if (node == summaryview->displayed)
5344                 summaryview->displayed = NULL;
5345
5346         for (top_parent = node;
5347              GTK_CMCTREE_ROW(top_parent)->parent != NULL;
5348              top_parent = GTK_CMCTREE_ROW(top_parent)->parent)
5349                 ;
5350         sibling = GTK_CMCTREE_ROW(top_parent)->sibling;
5351
5352         GTK_SCTREE(ctree)->sorting = TRUE;
5353         while (child != NULL) {
5354                 GtkCMCTreeNode *next_child;
5355                 MsgInfo *cinfo = GTKUT_CTREE_NODE_GET_ROW_DATA(child);
5356
5357                 next_child = GTK_CMCTREE_ROW(child)->sibling;
5358
5359                 if (!MSG_IS_MOVE(cinfo->flags) && !MSG_IS_DELETED(cinfo->flags)) {
5360                         gtk_cmctree_move(ctree, child,
5361                                 NULL,
5362                                 sibling);
5363                 } else {
5364                         if (child == summaryview->displayed) {
5365                                 messageview_clear(summaryview->messageview);
5366                                 summaryview->displayed = NULL;
5367                         }
5368                         if (child == summaryview->selected) {
5369                                 messageview_clear(summaryview->messageview);
5370                                 summaryview->selected = NULL;
5371                         }
5372                 }
5373                 child = next_child;
5374         }
5375         GTK_SCTREE(ctree)->sorting = FALSE;
5376 }
5377
5378 void summary_expand_threads(SummaryView *summaryview)
5379 {
5380         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5381         GtkCMCTreeNode *node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
5382         GtkCMCTreeNode *focus_node = GTK_CMCTREE_NODE (g_list_nth (GTK_CMCLIST(ctree)->row_list, GTK_CMCLIST(ctree)->focus_row));
5383
5384         g_signal_handlers_block_by_func(G_OBJECT(ctree),
5385                                        G_CALLBACK(summary_tree_expanded), summaryview);
5386         summary_freeze(summaryview);
5387         GTK_SCTREE(ctree)->sorting = TRUE;
5388
5389         while (node) {
5390                 if (GTK_CMCTREE_ROW(node)->children) {
5391                         gtk_cmctree_expand(ctree, node);
5392                         summary_set_row_marks(summaryview, node);
5393                 }
5394                 node = GTK_CMCTREE_NODE_NEXT(node);
5395         }
5396
5397         GTK_SCTREE(ctree)->sorting = FALSE;
5398         if (focus_node) {
5399                 GTK_CMCLIST(ctree)->focus_row = g_list_position (GTK_CMCLIST(ctree)->row_list,(GList *)focus_node);
5400         }
5401         summary_thaw(summaryview);
5402
5403         g_signal_handlers_unblock_by_func(G_OBJECT(ctree),
5404                                          G_CALLBACK(summary_tree_expanded), summaryview);
5405
5406         summaryview->thread_collapsed = FALSE;
5407
5408         gtk_cmctree_node_moveto(ctree, summaryview->selected, 0, 0.5, 0);
5409 }
5410
5411 void summary_collapse_threads(SummaryView *summaryview)
5412 {
5413         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5414         GtkCMCTreeNode *node = NULL;
5415         GtkCMCTreeNode *focus_node = GTK_CMCTREE_NODE (g_list_nth (GTK_CMCLIST(ctree)->row_list, GTK_CMCLIST(ctree)->focus_row));
5416
5417         g_signal_handlers_block_by_func(G_OBJECT(ctree),
5418                                        G_CALLBACK(summary_tree_collapsed), summaryview);
5419         summary_freeze(summaryview);
5420         GTK_SCTREE(ctree)->sorting = TRUE;
5421
5422         node = focus_node;
5423         while (node && GTK_CMCTREE_ROW(node)->parent) {
5424                 focus_node = node = GTK_CMCTREE_ROW(node)->parent;
5425         }
5426         gtk_sctree_select(GTK_SCTREE(ctree), focus_node);
5427         node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
5428         while (node) {
5429                 if (GTK_CMCTREE_ROW(node)->children) {
5430                         gtk_cmctree_collapse(ctree, node);
5431                         summary_set_row_marks(summaryview, node);
5432                 }
5433                 node = GTK_CMCTREE_ROW(node)->sibling;
5434         }
5435
5436         GTK_SCTREE(ctree)->sorting = FALSE;
5437         if (focus_node) {
5438                 GTK_CMCLIST(ctree)->focus_row = g_list_position (GTK_CMCLIST(ctree)->row_list,(GList *)focus_node);
5439         }
5440         GTK_SCTREE(ctree)->anchor_row =
5441                         gtk_cmctree_node_nth(ctree, GTK_CMCLIST(ctree)->focus_row);
5442         summary_thaw(summaryview);
5443         g_signal_handlers_unblock_by_func(G_OBJECT(ctree),
5444                                          G_CALLBACK(summary_tree_collapsed), summaryview);
5445
5446         summaryview->thread_collapsed = TRUE;
5447
5448         gtk_cmctree_node_moveto(ctree, summaryview->selected, 0, 0.5, 0);
5449 }
5450
5451 static void account_rules_radio_button_toggled_cb(GtkToggleButton *btn, gpointer data)
5452 {
5453         prefs_common.apply_per_account_filtering_rules = GPOINTER_TO_INT(data);
5454 }
5455
5456 static gboolean summary_filter_get_mode(void)
5457 /* ask what to do w/ them: skip them, apply them regardless to the account,
5458    use the current account */
5459 {
5460         /* TODO: eventually also propose to use the current folder's default account,
5461            if it is set */
5462         /* TODO: eventually allow to select the account to use from a optmenu */
5463
5464         GtkWidget *vbox;
5465         GtkWidget *account_rules_skip;
5466         GtkWidget *account_rules_force;
5467         GtkWidget *account_rules_user_current;
5468         AlertValue val;
5469
5470         vbox = gtk_vbox_new (FALSE, 0);
5471
5472         account_rules_skip = gtk_radio_button_new_with_label
5473                                                         (NULL, _("Skip these rules"));
5474         account_rules_force = gtk_radio_button_new_with_label_from_widget
5475                                                         (GTK_RADIO_BUTTON(account_rules_skip),
5476                                                         _("Apply these rules regardless of the account they belong to"));
5477         account_rules_user_current = gtk_radio_button_new_with_label_from_widget
5478                                                         (GTK_RADIO_BUTTON(account_rules_skip),
5479                                                         _("Apply these rules if they apply to the current account"));
5480         gtk_box_pack_start (GTK_BOX (vbox), account_rules_skip, FALSE, FALSE, 0);
5481         gtk_box_pack_start (GTK_BOX (vbox), account_rules_force, FALSE, FALSE, 0);
5482         gtk_box_pack_start (GTK_BOX (vbox), account_rules_user_current, FALSE, FALSE, 0);
5483         g_signal_connect(G_OBJECT(account_rules_skip), "toggled",
5484                         G_CALLBACK(account_rules_radio_button_toggled_cb),
5485                         GINT_TO_POINTER(FILTERING_ACCOUNT_RULES_SKIP));
5486         g_signal_connect(G_OBJECT(account_rules_force), "toggled",
5487                         G_CALLBACK(account_rules_radio_button_toggled_cb),
5488                         GINT_TO_POINTER(FILTERING_ACCOUNT_RULES_FORCE));
5489         g_signal_connect(G_OBJECT(account_rules_user_current), "toggled",
5490                         G_CALLBACK(account_rules_radio_button_toggled_cb),
5491                         GINT_TO_POINTER(FILTERING_ACCOUNT_RULES_USE_CURRENT));
5492         switch (prefs_common.apply_per_account_filtering_rules) {
5493         case FILTERING_ACCOUNT_RULES_SKIP:
5494                 gtk_toggle_button_set_active(
5495                                 GTK_TOGGLE_BUTTON(account_rules_skip), TRUE);
5496                 break;
5497         case FILTERING_ACCOUNT_RULES_FORCE:
5498                 gtk_toggle_button_set_active(
5499                                 GTK_TOGGLE_BUTTON(account_rules_force), TRUE);
5500                 break;
5501         case FILTERING_ACCOUNT_RULES_USE_CURRENT:
5502                 gtk_toggle_button_set_active(
5503                                 GTK_TOGGLE_BUTTON(account_rules_user_current), TRUE);
5504                 break;
5505         }
5506
5507         val = alertpanel_with_widget(
5508                         _("Filtering"),
5509                         _("There are some filtering rules that belong to an account.\n"
5510                           "Please choose what to do with these rules:"),
5511                         GTK_STOCK_CANCEL, _("_Filter"), NULL, TRUE, G_ALERTALTERNATE, vbox);
5512
5513         if ((val & ~G_ALERTDISABLE) != G_ALERTALTERNATE) {
5514                 return FALSE;
5515         } else if (val & G_ALERTDISABLE)
5516                 prefs_common.ask_apply_per_account_filtering_rules = FALSE;
5517
5518         return TRUE;
5519 }
5520
5521 void summary_filter(SummaryView *summaryview, gboolean selected_only)
5522 {
5523         GSList *mlist = NULL, *cur_list;
5524         summary_lock(summaryview);
5525
5526         /* are there any per-account filtering rules? */
5527         if (prefs_common.ask_apply_per_account_filtering_rules == TRUE &&
5528                 filtering_peek_per_account_rules(filtering_rules)) {
5529
5530                 if (summary_filter_get_mode() == FALSE) {
5531                         summary_unlock(summaryview);
5532                         return;
5533                 }
5534         }
5535
5536         folder_item_update_freeze();
5537
5538         debug_print("filtering...");
5539         STATUSBAR_PUSH(summaryview->mainwin, _("Filtering..."));
5540         main_window_cursor_wait(summaryview->mainwin);
5541
5542         summary_freeze(summaryview);
5543
5544         if (selected_only) {
5545                 GList *cur;
5546
5547                 for (cur = GTK_CMCLIST(summaryview->ctree)->selection;
5548                      cur != NULL && cur->data != NULL; cur = cur->next) {
5549                         mlist = g_slist_prepend(mlist,
5550                                  procmsg_msginfo_new_ref(
5551                                   GTKUT_CTREE_NODE_GET_ROW_DATA(cur->data)));
5552                 }
5553                 mlist = g_slist_reverse(mlist);
5554         } else {
5555                 mlist = folder_item_get_msg_list(summaryview->folder_item);
5556         }
5557
5558         folder_item_set_batch(summaryview->folder_item, TRUE);
5559         for (cur_list = mlist; cur_list; cur_list = cur_list->next) {
5560                 summary_filter_func((MsgInfo *)cur_list->data);
5561         }
5562         folder_item_set_batch(summaryview->folder_item, FALSE);
5563
5564         filtering_move_and_copy_msgs(mlist);
5565
5566         for (cur_list = mlist; cur_list; cur_list = cur_list->next) {
5567                 procmsg_msginfo_free((MsgInfo *)cur_list->data);
5568         }
5569         g_slist_free(mlist);
5570
5571         summary_thaw(summaryview);
5572
5573         folder_item_update_thaw();
5574         debug_print("done.\n");
5575         STATUSBAR_POP(summaryview->mainwin);
5576         main_window_cursor_normal(summaryview->mainwin);
5577
5578         summary_unlock(summaryview);
5579
5580         /*
5581          * CLAWS: summary_show() only valid after having a lock. ideally
5582          * we want the lock to be context aware...
5583          */
5584         summary_show(summaryview, summaryview->folder_item);
5585 }
5586
5587 static void summary_filter_func(MsgInfo *msginfo)
5588 {
5589         MailFilteringData mail_filtering_data;
5590
5591         mail_filtering_data.msginfo = msginfo;
5592         mail_filtering_data.msglist = NULL;
5593         mail_filtering_data.filtered = NULL;
5594         mail_filtering_data.unfiltered = NULL;
5595         if (hooks_invoke(MAIL_MANUAL_FILTERING_HOOKLIST, &mail_filtering_data))
5596                 return;
5597
5598         filter_message_by_msginfo(filtering_rules, msginfo, NULL,
5599                         FILTERING_MANUALLY, NULL);
5600 }
5601
5602 void summary_msginfo_filter_open(FolderItem * item, MsgInfo *msginfo,
5603                                  PrefsFilterType type, gint processing_rule)
5604 {
5605         gchar *header = NULL;
5606         gchar *key = NULL;
5607
5608         procmsg_get_filter_keyword(msginfo, &header, &key, type);
5609
5610         if (processing_rule) {
5611                 if (item == NULL)
5612                         prefs_filtering_open(&pre_global_processing,
5613                                              _("Processing rules to apply before folder rules"),
5614                                              MANUAL_ANCHOR_PROCESSING,
5615                                              header, key, FALSE);
5616                 else
5617                         prefs_filtering_open(&item->prefs->processing,
5618                                              _("Processing configuration"),
5619                                              MANUAL_ANCHOR_PROCESSING,
5620                                              header, key, FALSE);
5621         }
5622         else {
5623                 prefs_filtering_open(&filtering_rules,
5624                                 _("Filtering configuration"),
5625                                 MANUAL_ANCHOR_FILTERING,
5626                                 header, key, TRUE);
5627         }
5628
5629         g_free(header);
5630         g_free(key);
5631 }
5632
5633 void summary_filter_open(SummaryView *summaryview, PrefsFilterType type,
5634                          gint processing_rule)
5635 {
5636         MsgInfo *msginfo;
5637         FolderItem * item;
5638
5639         if (!summaryview->selected) return;
5640
5641         msginfo = gtk_cmctree_node_get_row_data(GTK_CMCTREE(summaryview->ctree),
5642                                               summaryview->selected);
5643         if (!msginfo) return;
5644
5645         item = summaryview->folder_item;
5646         summary_msginfo_filter_open(item, msginfo, type, processing_rule);
5647 }
5648
5649 /* color label */
5650
5651 #define N_COLOR_LABELS colorlabel_get_color_count()
5652
5653 static void summary_colorlabel_menu_item_activate_cb(GtkWidget *widget,
5654                                                      gpointer data)
5655 {
5656         guint color = GPOINTER_TO_UINT(data);
5657         SummaryView *summaryview;
5658
5659         summaryview = g_object_get_data(G_OBJECT(widget), "summaryview");
5660         cm_return_if_fail(summaryview != NULL);
5661
5662         /* "dont_toggle" state set? */
5663         if (g_object_get_data(G_OBJECT(summaryview->colorlabel_menu),
5664                                 "dont_toggle"))
5665                 return;
5666
5667         summary_set_colorlabel(summaryview, color, NULL);
5668 }
5669
5670 /* summary_set_colorlabel_color() - labelcolor parameter is the color *flag*
5671  * for the messsage; not the color index */
5672 void summary_set_colorlabel_color(GtkCMCTree *ctree, GtkCMCTreeNode *node,
5673                                   guint labelcolor)
5674 {
5675         GdkColor color;
5676         GtkStyle *style, *prev_style, *ctree_style;
5677         MsgInfo *msginfo;
5678         gint color_index;
5679
5680         msginfo = gtk_cmctree_node_get_row_data(ctree, node);
5681         cm_return_if_fail(msginfo);
5682
5683         color_index = labelcolor == 0 ? -1 : (gint)labelcolor - 1;
5684         ctree_style = gtk_widget_get_style(GTK_WIDGET(ctree));
5685         prev_style = gtk_cmctree_node_get_row_style(ctree, node);
5686
5687         if (color_index < 0 || color_index >= N_COLOR_LABELS) {
5688                 if (!prev_style) return;
5689                 style = gtk_style_copy(prev_style);
5690                 color = ctree_style->fg[GTK_STATE_NORMAL];
5691                 style->fg[GTK_STATE_NORMAL] = color;
5692                 color = ctree_style->fg[GTK_STATE_SELECTED];
5693                 style->fg[GTK_STATE_SELECTED] = color;
5694         } else {
5695                 if (prev_style)
5696                         style = gtk_style_copy(prev_style);
5697                 else
5698                         style = gtk_style_copy(ctree_style);
5699                 color = colorlabel_get_color(color_index);
5700                 style->fg[GTK_STATE_NORMAL] = color;
5701                 /* get the average of label color and selected fg color
5702                    for visibility */
5703                 style->fg[GTK_STATE_SELECTED].red   = (color.red   + 3*ctree_style->fg[GTK_STATE_SELECTED].red  ) / 4;
5704                 style->fg[GTK_STATE_SELECTED].green = (color.green + 3*ctree_style->fg[GTK_STATE_SELECTED].green) / 4;
5705                 style->fg[GTK_STATE_SELECTED].blue  = (color.blue  + 3*ctree_style->fg[GTK_STATE_SELECTED].blue ) / 4;
5706         }
5707
5708         gtk_cmctree_node_set_row_style(ctree, node, style);
5709         g_object_unref(style);
5710 }
5711
5712 static void summary_set_row_colorlabel(SummaryView *summaryview, GtkCMCTreeNode *row, guint labelcolor)
5713 {
5714         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5715         MsgInfo *msginfo;
5716
5717         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
5718         cm_return_if_fail(msginfo);
5719
5720         summary_msginfo_change_flags(msginfo, MSG_COLORLABEL_TO_FLAGS(labelcolor), 0,
5721                                         MSG_CLABEL_FLAG_MASK, 0);
5722         summary_set_row_marks(summaryview, row);
5723 }
5724
5725 void summary_set_colorlabel(SummaryView *summaryview, guint labelcolor,
5726                             GtkWidget *widget)
5727 {
5728         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5729         GList *cur;
5730         gboolean froze = FALSE;
5731
5732         START_LONG_OPERATION(summaryview, FALSE);
5733         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
5734                 summary_set_row_colorlabel(summaryview,
5735                                            GTK_CMCTREE_NODE(cur->data), labelcolor);
5736         END_LONG_OPERATION(summaryview);
5737 }
5738
5739 static gboolean summary_set_row_tag(SummaryView *summaryview, GtkCMCTreeNode *row, gboolean refresh, gboolean set, gint id)
5740 {
5741         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5742         MsgInfo *msginfo;
5743         gchar *tags_str = NULL;
5744         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
5745         cm_return_val_if_fail(msginfo, FALSE);
5746
5747         procmsg_msginfo_update_tags(msginfo, set, id);
5748
5749         if (summaryview->col_state[summaryview->col_pos[S_COL_TAGS]].visible) {
5750                 tags_str = procmsg_msginfo_get_tags_str(msginfo);
5751                 gtk_cmctree_node_set_text(ctree, row,
5752                                 summaryview->col_pos[S_COL_TAGS],
5753                                 tags_str?tags_str:"-");
5754                 g_free(tags_str);
5755         }
5756
5757         summary_set_row_marks(summaryview, row);
5758         if (row == summaryview->displayed) {
5759                 return TRUE;
5760         }
5761         return FALSE;
5762 }
5763
5764 void summary_set_tag(SummaryView *summaryview, gint tag_id,
5765                             GtkWidget *widget)
5766 {
5767         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5768         GList *cur;
5769         gboolean set = tag_id > 0;
5770         gint real_id = set? tag_id:-tag_id;
5771         gboolean froze = FALSE;
5772         gboolean redisplay = FALSE;
5773
5774         if (summary_is_locked(summaryview))
5775                 return;
5776         START_LONG_OPERATION(summaryview, FALSE);
5777         folder_item_set_batch(summaryview->folder_item, TRUE);
5778         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next) {
5779                 redisplay |= summary_set_row_tag(summaryview,
5780                                            GTK_CMCTREE_NODE(cur->data), FALSE, set, real_id);
5781         }
5782         folder_item_set_batch(summaryview->folder_item, FALSE);
5783         END_LONG_OPERATION(summaryview);
5784         if (redisplay)
5785                 summary_redisplay_msg(summaryview);
5786 }
5787
5788 static void summary_tags_menu_item_activate_cb(GtkWidget *widget,
5789                                                      gpointer data)
5790 {
5791         gint id = GPOINTER_TO_INT(data);
5792         gboolean set = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));
5793         SummaryView *summaryview;
5794
5795         summaryview = g_object_get_data(G_OBJECT(widget), "summaryview");
5796         cm_return_if_fail(summaryview != NULL);
5797
5798         /* "dont_toggle" state set? */
5799         if (g_object_get_data(G_OBJECT(summaryview->tags_menu),
5800                                 "dont_toggle"))
5801                 return;
5802
5803         if (!set)
5804                 id = -id;
5805         summary_set_tag(summaryview, id, NULL);
5806 }
5807
5808 static void summary_colorlabel_menu_item_activate_item_cb(GtkMenuItem *menu_item,
5809                                                           gpointer data)
5810 {
5811         SummaryView *summaryview;
5812         GtkMenuShell *menu;
5813         GtkCheckMenuItem **items;
5814         gint n;
5815         GList *children, *cur, *sel;
5816
5817         summaryview = (SummaryView *)data;
5818         cm_return_if_fail(summaryview != NULL);
5819
5820         sel = GTK_CMCLIST(summaryview->ctree)->selection;
5821         if (!sel) return;
5822
5823         menu = GTK_MENU_SHELL(summaryview->colorlabel_menu);
5824
5825         cm_return_if_fail(menu != NULL);
5826
5827         Xalloca(items, (N_COLOR_LABELS + 1) * sizeof(GtkWidget *), return);
5828
5829         /* NOTE: don't return prematurely because we set the "dont_toggle"
5830          * state for check menu items */
5831         g_object_set_data(G_OBJECT(menu), "dont_toggle",
5832                           GINT_TO_POINTER(1));
5833
5834         /* clear items. get item pointers. */
5835         children = gtk_container_get_children(GTK_CONTAINER(menu));
5836         for (n = 0, cur = children; cur != NULL && cur->data != NULL; cur = cur->next) {
5837                 if (GTK_IS_CHECK_MENU_ITEM(cur->data)) {
5838                         gtk_check_menu_item_set_active
5839                                 (GTK_CHECK_MENU_ITEM(cur->data), FALSE);
5840                         items[n] = GTK_CHECK_MENU_ITEM(cur->data);
5841                         n++;
5842                 }
5843         }
5844
5845         g_list_free(children);
5846
5847         if (n == (N_COLOR_LABELS + 1)) {
5848                 /* iterate all messages and set the state of the appropriate
5849                  * items */
5850                 for (; sel != NULL; sel = sel->next) {
5851                         MsgInfo *msginfo;
5852                         gint clabel;
5853
5854                         msginfo = gtk_cmctree_node_get_row_data
5855                                 (GTK_CMCTREE(summaryview->ctree),
5856                                  GTK_CMCTREE_NODE(sel->data));
5857                         if (msginfo) {
5858                                 clabel = MSG_GET_COLORLABEL_VALUE(msginfo->flags);
5859                                 if (!gtk_check_menu_item_get_active(items[clabel]))
5860                                         gtk_check_menu_item_set_active
5861                                                 (items[clabel], TRUE);
5862                         }
5863                 }
5864         } else
5865                 g_warning("invalid number of color elements (%d)\n", n);
5866
5867         /* reset "dont_toggle" state */
5868         g_object_set_data(G_OBJECT(menu), "dont_toggle",
5869                           GINT_TO_POINTER(0));
5870 }
5871
5872 static void summary_colorlabel_menu_create(SummaryView *summaryview, gboolean refresh)
5873 {
5874         GtkWidget *label_menuitem;
5875         GtkWidget *menu;
5876         GtkWidget *item;
5877         gint i;
5878         gchar *accel_path = NULL;
5879
5880         label_menuitem = gtk_ui_manager_get_widget(summaryview->mainwin->ui_manager, "/Menus/SummaryViewPopup/ColorLabel");
5881         g_signal_connect(G_OBJECT(label_menuitem), "activate",
5882                          G_CALLBACK(summary_colorlabel_menu_item_activate_item_cb),
5883                            summaryview);
5884         gtk_widget_show(label_menuitem);
5885
5886         menu = gtk_menu_new();
5887
5888         gtk_menu_set_accel_group (GTK_MENU (menu),
5889                 gtk_ui_manager_get_accel_group(mainwindow_get_mainwindow()->ui_manager));
5890
5891         /* create sub items. for the menu item activation callback we pass the
5892          * index of label_colors[] as data parameter. for the None color we
5893          * pass an invalid (high) value. also we attach a data pointer so we
5894          * can always get back the SummaryView pointer. */
5895
5896         item = gtk_check_menu_item_new_with_label(_("None"));
5897         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
5898         g_signal_connect(G_OBJECT(item), "activate",
5899                          G_CALLBACK(summary_colorlabel_menu_item_activate_cb),
5900                            GUINT_TO_POINTER(0));
5901         g_object_set_data(G_OBJECT(item), "summaryview", summaryview);
5902         gtk_widget_show(item);
5903
5904         accel_path = g_strdup_printf("<ClawsColorLabels>/None");
5905         gtk_menu_item_set_accel_path(GTK_MENU_ITEM(item), accel_path);
5906         g_free(accel_path);
5907         gtk_accel_map_add_entry("<ClawsColorLabels>/None", GDK_0, GDK_CONTROL_MASK);
5908
5909         item = gtk_menu_item_new();
5910         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
5911         gtk_widget_show(item);
5912
5913         /* create pixmap/label menu items */
5914         for (i = 0; i < N_COLOR_LABELS; i++) {
5915                 item = colorlabel_create_check_color_menu_item(
5916                         i, refresh, SUMMARY_COLORMENU);
5917                 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
5918                 g_signal_connect(G_OBJECT(item), "activate",
5919                                  G_CALLBACK(summary_colorlabel_menu_item_activate_cb),
5920                                  GUINT_TO_POINTER(i + 1));
5921                 g_object_set_data(G_OBJECT(item), "summaryview",
5922                                   summaryview);
5923                 gtk_widget_show(item);
5924                 accel_path = g_strdup_printf("<ClawsColorLabels>/%d", i+1);
5925                 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(item), accel_path);
5926                 if (i < 9)
5927                         gtk_accel_map_add_entry(accel_path, GDK_1+i, GDK_CONTROL_MASK);
5928                 g_free(accel_path);
5929                 g_signal_connect (gtk_ui_manager_get_accel_group(mainwindow_get_mainwindow()->ui_manager),
5930                         "accel-changed", G_CALLBACK (mainwin_accel_changed_cb), item);
5931         }
5932
5933         gtk_widget_show(menu);
5934         gtk_menu_item_set_submenu(GTK_MENU_ITEM(label_menuitem), menu);
5935         summaryview->colorlabel_menu = menu;
5936 }
5937
5938 static void summary_tags_menu_item_activate_item_cb(GtkMenuItem *menu_item,
5939                                                           gpointer data)
5940 {
5941         GtkMenuShell *menu;
5942         GList *children, *cur;
5943         GList *sel;
5944         GHashTable *menu_table = g_hash_table_new_full(
5945                                         g_direct_hash,
5946                                         g_direct_equal,
5947                                         NULL, NULL);
5948         GHashTable *menu_allsel_table = g_hash_table_new_full(
5949                                         g_direct_hash,
5950                                         g_direct_equal,
5951                                         NULL, NULL);
5952         gint sel_len;
5953         SummaryView *summaryview = (SummaryView *)data;
5954         cm_return_if_fail(summaryview != NULL);
5955
5956         sel = GTK_CMCLIST(summaryview->ctree)->selection;
5957         if (!sel) return;
5958
5959         menu = GTK_MENU_SHELL(summaryview->tags_menu);
5960         cm_return_if_fail(menu != NULL);
5961
5962         /* NOTE: don't return prematurely because we set the "dont_toggle"
5963          * state for check menu items */
5964         g_object_set_data(G_OBJECT(menu), "dont_toggle",
5965                           GINT_TO_POINTER(1));
5966
5967         /* clear items. get item pointers. */
5968         children = gtk_container_get_children(GTK_CONTAINER(menu));
5969         for (cur = children; cur != NULL && cur->data != NULL; cur = cur->next) {
5970                 if (GTK_IS_CHECK_MENU_ITEM(cur->data)) {
5971                         gint id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cur->data),
5972                                 "tag_id"));
5973                         gtk_check_menu_item_set_active
5974                                 (GTK_CHECK_MENU_ITEM(cur->data), FALSE);
5975
5976                         g_hash_table_insert(menu_table, GINT_TO_POINTER(id), GTK_CHECK_MENU_ITEM(cur->data));
5977                         g_hash_table_insert(menu_allsel_table, GINT_TO_POINTER(id), GINT_TO_POINTER(0));
5978                 }
5979         }
5980
5981         g_list_free(children);
5982
5983         /* iterate all messages and set the state of the appropriate
5984          * items */
5985         sel_len = 0;
5986         for (; sel != NULL; sel = sel->next) {
5987                 MsgInfo *msginfo;
5988                 GSList *tags = NULL;
5989                 gint id;
5990                 GtkCheckMenuItem *item;
5991                 msginfo = gtk_cmctree_node_get_row_data
5992                         (GTK_CMCTREE(summaryview->ctree),
5993                          GTK_CMCTREE_NODE(sel->data));
5994                 sel_len++;
5995                 if (msginfo) {
5996                         tags =  msginfo->tags;
5997                         if (!tags)
5998                                 continue;
5999
6000                         for (; tags; tags = tags->next) {
6001                                 gint num_checked = GPOINTER_TO_INT(g_hash_table_lookup(menu_allsel_table, tags->data));
6002                                 id = GPOINTER_TO_INT(tags->data);
6003                                 item = g_hash_table_lookup(menu_table, GINT_TO_POINTER(tags->data));
6004                                 if (item && !gtk_check_menu_item_get_active(item)) {
6005                                         gtk_check_menu_item_set_active
6006                                                 (item, TRUE);
6007                                 }
6008                                 num_checked++;
6009                                 g_hash_table_replace(menu_allsel_table, tags->data, GINT_TO_POINTER(num_checked));
6010                         }
6011                 }
6012         }
6013
6014         children = gtk_container_get_children(GTK_CONTAINER(menu));
6015         for (cur = children; cur != NULL && cur->data != NULL; cur = cur->next) {
6016                 if (GTK_IS_CHECK_MENU_ITEM(cur->data)) {
6017                         gint id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cur->data),
6018                                 "tag_id"));
6019                         gint num_checked = GPOINTER_TO_INT(g_hash_table_lookup(menu_allsel_table, GINT_TO_POINTER(id)));
6020                         if (num_checked < sel_len && num_checked > 0)
6021                                 gtk_check_menu_item_set_inconsistent(GTK_CHECK_MENU_ITEM(cur->data), TRUE);
6022                         else
6023                                 gtk_check_menu_item_set_inconsistent(GTK_CHECK_MENU_ITEM(cur->data), FALSE);
6024                 }
6025         }
6026         g_list_free(children);
6027         g_hash_table_destroy(menu_table);
6028         g_hash_table_destroy(menu_allsel_table);
6029         /* reset "dont_toggle" state */
6030         g_object_set_data(G_OBJECT(menu), "dont_toggle",
6031                           GINT_TO_POINTER(0));
6032 }
6033
6034 void summaryview_destroy(SummaryView *summaryview)
6035 {
6036 #ifndef G_OS_WIN32
6037         if(summaryview->simplify_subject_preg) {
6038                 regfree(summaryview->simplify_subject_preg);
6039                 g_free(summaryview->simplify_subject_preg);
6040                 summaryview->simplify_subject_preg = NULL;
6041         }
6042 #endif
6043 }
6044 static void summary_tags_menu_item_apply_tags_activate_cb(GtkWidget *widget,
6045                                                      gpointer data)
6046 {
6047         SummaryView *summaryview;
6048
6049         summaryview = g_object_get_data(G_OBJECT(widget), "summaryview");
6050         cm_return_if_fail(summaryview != NULL);
6051
6052         /* "dont_toggle" state set? */
6053         if (g_object_get_data(G_OBJECT(summaryview->tags_menu),
6054                                 "dont_toggle"))
6055                 return;
6056
6057         tag_apply_open(summary_get_selection(summaryview));
6058 }
6059
6060 static gint summary_tag_cmp_list(gconstpointer a, gconstpointer b)
6061 {
6062         gint id_a = GPOINTER_TO_INT(a);
6063         gint id_b = GPOINTER_TO_INT(b);
6064         const gchar *tag_a = tags_get_tag(id_a);
6065         const gchar *tag_b = tags_get_tag(id_b);
6066
6067         if (tag_a == NULL)
6068                 return tag_b == NULL ? 0:1;
6069
6070         if (tag_b == NULL)
6071                 return tag_a == NULL ? 0:1;
6072
6073         return g_utf8_collate(tag_a, tag_b);
6074 }
6075
6076 static void summary_tags_menu_create(SummaryView *summaryview, gboolean refresh)
6077 {
6078
6079         GtkWidget *label_menuitem;
6080         GtkWidget *menu;
6081         GtkWidget *item;
6082         GSList *cur = tags_get_list();
6083         GSList *orig = NULL;
6084         gboolean existing_tags = FALSE;
6085         gchar *accel_path = NULL;
6086
6087         cur = orig = g_slist_sort(cur, summary_tag_cmp_list);
6088         label_menuitem = gtk_ui_manager_get_widget(summaryview->mainwin->ui_manager, "/Menus/SummaryViewPopup/Tags");
6089         g_signal_connect(G_OBJECT(label_menuitem), "activate",
6090                          G_CALLBACK(summary_tags_menu_item_activate_item_cb),
6091                            summaryview);
6092
6093         gtk_widget_show(label_menuitem);
6094
6095         menu = gtk_menu_new();
6096
6097         gtk_menu_set_accel_group (GTK_MENU (menu),
6098                 gtk_ui_manager_get_accel_group(summaryview->mainwin->ui_manager));
6099
6100         /* create tags menu items */
6101         for (; cur; cur = cur->next) {
6102                 gint id = GPOINTER_TO_INT(cur->data);
6103                 const gchar *tag = tags_get_tag(id);
6104                 item = gtk_check_menu_item_new_with_label(tag);
6105                 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
6106                 g_signal_connect(G_OBJECT(item), "activate",
6107                                  G_CALLBACK(summary_tags_menu_item_activate_cb),
6108                                  GINT_TO_POINTER(id));
6109                 g_object_set_data(G_OBJECT(item), "summaryview",
6110                                   summaryview);
6111                 g_object_set_data(G_OBJECT(item), "tag_id",
6112                                   GINT_TO_POINTER(id));
6113                 gtk_widget_show(item);
6114                 accel_path = g_strconcat("<ClawsTags>/",tag, NULL);
6115                 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(item), accel_path);
6116                 g_free(accel_path);
6117                 existing_tags = TRUE;
6118         }
6119         if (existing_tags) {
6120                 /* separator */
6121                 item = gtk_menu_item_new();
6122                 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
6123                 gtk_widget_show(item);
6124         }
6125
6126         item = gtk_menu_item_new_with_label(_("Apply tags..."));
6127         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
6128         g_signal_connect(G_OBJECT(item), "activate",
6129                          G_CALLBACK(summary_tags_menu_item_apply_tags_activate_cb),
6130                          NULL);
6131         g_object_set_data(G_OBJECT(item), "summaryview",
6132                           summaryview);
6133         gtk_widget_show(item);
6134         accel_path = g_strdup_printf("<ClawsTags>/ApplyTags");
6135         gtk_menu_item_set_accel_path(GTK_MENU_ITEM(item), accel_path);
6136         g_free(accel_path);
6137
6138         g_slist_free(orig);
6139         gtk_widget_show(menu);
6140         gtk_menu_item_set_submenu(GTK_MENU_ITEM(label_menuitem), menu);
6141         summaryview->tags_menu = menu;
6142 }
6143
6144 static gboolean summary_popup_menu(GtkWidget *widget, gpointer data)
6145 {
6146         SummaryView *summaryview = (SummaryView *)data;
6147         summaryview->display_msg = messageview_is_visible(summaryview->messageview);
6148
6149         gtk_menu_popup(GTK_MENU(summaryview->popupmenu),
6150                        NULL, NULL, NULL, NULL,
6151                        3, gtk_get_current_event_time());
6152
6153         return TRUE;
6154 }
6155
6156 #if !GENERIC_UMPC
6157 static gchar *summaryview_get_tooltip_text(SummaryView *summaryview, MsgInfo *info, gint column)
6158 {
6159         MsgFlags flags;
6160         if (!info)
6161                 return NULL;
6162
6163         flags = info->flags;
6164
6165         switch(summaryview->col_state[column].type) {
6166                 case S_COL_STATUS:
6167                         if (MSG_IS_IGNORE_THREAD(flags)) {
6168                                 return _("Ignored thread");
6169                         } else if (MSG_IS_WATCH_THREAD(flags)) {
6170                                 return _("Watched thread");
6171                         } else if (MSG_IS_SPAM(flags)) {
6172                                 return _("Spam");
6173                         } else if (MSG_IS_NEW(flags)) {
6174                                 return _("New");
6175                         } else if (MSG_IS_UNREAD(flags)) {
6176                                 return _("Unread");
6177                         } else if (MSG_IS_REPLIED(flags)) {
6178                                 return _("Replied - click to see reply");
6179                         } else if (MSG_IS_FORWARDED(flags)) {
6180                                 return _("Forwarded");
6181                         } else {
6182                                 return NULL;
6183                         }
6184                 case S_COL_MARK:
6185                         if (MSG_IS_DELETED(flags)) {
6186                                 return _("Deleted");
6187                         } else if (MSG_IS_MARKED(flags)) {
6188                                 return _("Marked");
6189                         } else if (MSG_IS_MOVE(flags)) {
6190                                 return _("To be moved");
6191                         } else if (MSG_IS_COPY(flags)) {
6192                                 return _("To be copied");
6193                         } else {
6194                                 return NULL;
6195                         }
6196                 case S_COL_LOCKED:
6197                         if (MSG_IS_LOCKED(flags)) {
6198                                 return _("Locked");
6199                         } else {
6200                                 return NULL;
6201                         }
6202                 case S_COL_MIME:
6203                         if (MSG_IS_WITH_ATTACHMENT(flags) && MSG_IS_SIGNED(flags)) {
6204                                 return _("Signed, has attachment(s)");
6205                         } else if (MSG_IS_SIGNED(flags)) {
6206                                 return _("Signed");
6207                         } else if (MSG_IS_WITH_ATTACHMENT(flags) && MSG_IS_ENCRYPTED(flags)) {
6208                                 return _("Encrypted, has attachment(s)");
6209                         } else if (MSG_IS_ENCRYPTED(flags)) {
6210                                 return _("Encrypted");
6211                         } else if (MSG_IS_WITH_ATTACHMENT(flags)) {
6212                                 return _("Has attachment(s)");
6213                         } else {
6214                                 return NULL;
6215                         }
6216                 default:
6217                         return NULL;
6218         }
6219 }
6220 static gboolean tooltip_cb (GtkWidget  *widget,
6221                             gint        x,
6222                             gint        y,
6223                             gboolean    keyboard_mode,
6224                             GtkTooltip *tooltip,
6225                             gpointer    user_data)
6226 {
6227         GtkCMCTree *ctree = GTK_CMCTREE(widget);
6228         SummaryView *summaryview = (SummaryView *)user_data;
6229         gint row = -1, column = -1;
6230         int offset = prefs_common.show_col_headers ? 24:0;
6231         GtkCMCTreeNode *node = NULL;
6232         gchar *text = NULL;
6233         gchar *formatted = NULL;
6234         MsgInfo *info = NULL;
6235         GdkRectangle rect;
6236         gboolean vert = (prefs_common.layout_mode == VERTICAL_LAYOUT);
6237
6238         if (!prefs_common.show_tooltips)
6239                 return FALSE;
6240
6241         if (y - offset < 0)
6242                 return FALSE;
6243
6244         if (!gtk_cmclist_get_selection_info(GTK_CMCLIST(ctree), x, y - offset,
6245                                           &row, &column))
6246                 return FALSE;
6247
6248         if ((node = gtk_cmctree_node_nth(ctree, row)) == NULL)
6249                 return FALSE;
6250
6251         if ((info = gtk_cmctree_node_get_row_data(ctree, node)) == NULL)
6252                 return FALSE;
6253
6254         switch (gtk_cmctree_node_get_cell_type(ctree, node, column)) {
6255                 case GTK_CMCELL_TEXT:
6256                         if (gtk_cmctree_node_get_text(ctree, node, column, &text) != TRUE)
6257                                 return FALSE;
6258                         break;
6259                 case GTK_CMCELL_PIXTEXT:
6260                         if (gtk_cmctree_node_get_pixtext(ctree, node, column, &text,
6261                                 NULL, NULL) != TRUE)
6262                                 return FALSE;
6263                         break;
6264                 default:
6265                         if ((text = summaryview_get_tooltip_text(summaryview, info, column)) == NULL)
6266                                 return FALSE;
6267         }
6268
6269         if (!text || !*text)
6270                 return FALSE;
6271
6272         formatted = g_strdup(text);
6273         g_strstrip(formatted);
6274
6275         if (!vert)
6276                 gtk_tooltip_set_text (tooltip, formatted);
6277         else if (prefs_common.two_line_vert)
6278                 gtk_tooltip_set_markup (tooltip, formatted);
6279         g_free(formatted);
6280
6281         rect.x = x - 2;
6282         rect.y = y - 2;
6283         rect.width = 12;
6284         rect.height= 12;
6285         gtk_tooltip_set_tip_area(tooltip, &rect);
6286
6287         return TRUE;
6288 }
6289 #endif
6290 static GtkWidget *summary_ctree_create(SummaryView *summaryview)
6291 {
6292         GtkWidget *ctree;
6293         gint *col_pos = summaryview->col_pos;
6294         SummaryColumnState *col_state;
6295         gchar *titles[N_SUMMARY_COLS];
6296         SummaryColumnType type;
6297         gint pos;
6298         gboolean vert = (prefs_common.layout_mode == VERTICAL_LAYOUT);
6299
6300         memset(titles, 0, sizeof(titles));
6301
6302         col_state = prefs_summary_column_get_config();
6303         for (pos = 0; pos < N_SUMMARY_COLS; pos++) {
6304                 summaryview->col_state[pos] = col_state[pos];
6305                 type = col_state[pos].type;
6306                 col_pos[type] = pos;
6307                 titles[pos] = "dummy";
6308         }
6309         col_state = summaryview->col_state;
6310
6311         ctree = gtk_sctree_new_with_titles
6312                 (N_SUMMARY_COLS, col_pos[S_COL_SUBJECT], titles);
6313
6314         /* get normal row height */
6315         gtk_cmclist_set_row_height(GTK_CMCLIST(ctree), 0);
6316         normal_row_height = GTK_CMCLIST(ctree)->row_height;
6317
6318         if (prefs_common.show_col_headers == FALSE)
6319                 gtk_cmclist_column_titles_hide(GTK_CMCLIST(ctree));
6320
6321         gtk_cmclist_set_selection_mode(GTK_CMCLIST(ctree), GTK_SELECTION_EXTENDED);
6322         gtk_cmclist_set_column_justification(GTK_CMCLIST(ctree), col_pos[S_COL_MARK],
6323                                            GTK_JUSTIFY_CENTER);
6324         gtk_cmclist_set_column_justification(GTK_CMCLIST(ctree), col_pos[S_COL_STATUS],
6325                                            GTK_JUSTIFY_CENTER);
6326         gtk_cmclist_set_column_justification(GTK_CMCLIST(ctree), col_pos[S_COL_LOCKED],
6327                                            GTK_JUSTIFY_CENTER);
6328         gtk_cmclist_set_column_justification(GTK_CMCLIST(ctree), col_pos[S_COL_MIME],
6329                                            GTK_JUSTIFY_CENTER);
6330         gtk_cmclist_set_column_justification(GTK_CMCLIST(ctree), col_pos[S_COL_SIZE],
6331                                            GTK_JUSTIFY_RIGHT);
6332         gtk_cmclist_set_column_justification(GTK_CMCLIST(ctree), col_pos[S_COL_NUMBER],
6333                                            GTK_JUSTIFY_RIGHT);
6334         gtk_cmclist_set_column_justification(GTK_CMCLIST(ctree), col_pos[S_COL_SCORE],
6335                                            GTK_JUSTIFY_RIGHT);
6336         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_MARK],
6337                                    prefs_common.summary_col_size[S_COL_MARK]);
6338         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_STATUS],
6339                                    prefs_common.summary_col_size[S_COL_STATUS]);
6340         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_LOCKED],
6341                                    prefs_common.summary_col_size[S_COL_LOCKED]);
6342         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_MIME],
6343                                    prefs_common.summary_col_size[S_COL_MIME]);
6344         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_SUBJECT],
6345                                    prefs_common.summary_col_size[S_COL_SUBJECT]);
6346         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_FROM],
6347                                    prefs_common.summary_col_size[S_COL_FROM]);
6348         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_TO],
6349                                    prefs_common.summary_col_size[S_COL_TO]);
6350         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_DATE],
6351                                    prefs_common.summary_col_size[S_COL_DATE]);
6352         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_SIZE],
6353                                    prefs_common.summary_col_size[S_COL_SIZE]);
6354         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_NUMBER],
6355                                    prefs_common.summary_col_size[S_COL_NUMBER]);
6356         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_SCORE],
6357                                    prefs_common.summary_col_size[S_COL_SCORE]);
6358         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_TAGS],
6359                                    prefs_common.summary_col_size[S_COL_TAGS]);
6360
6361         gtk_cmctree_set_line_style(GTK_CMCTREE(ctree), GTK_CMCTREE_LINES_NONE);
6362         gtk_cmctree_set_expander_style(GTK_CMCTREE(ctree),
6363                              GTK_CMCTREE_EXPANDER_TRIANGLE);
6364
6365         gtk_sctree_set_stripes(GTK_SCTREE(ctree), prefs_common.use_stripes_in_summaries);
6366
6367         gtk_cmctree_set_indent(GTK_CMCTREE(ctree), 12);
6368         g_object_set_data(G_OBJECT(ctree), "summaryview", (gpointer)summaryview);
6369
6370         for (pos = 0; pos < N_SUMMARY_COLS; pos++) {
6371                 gtkut_widget_set_can_focus(GTK_CMCLIST(ctree)->column[pos].button,
6372                                        FALSE);
6373                 if (((pos == summaryview->col_pos[S_COL_FROM] && !FOLDER_SHOWS_TO_HDR(summaryview->folder_item)) ||
6374                      (pos == summaryview->col_pos[S_COL_TO] && FOLDER_SHOWS_TO_HDR(summaryview->folder_item)) ||
6375                      pos == summaryview->col_pos[S_COL_DATE]) && vert &&
6376                             prefs_common.two_line_vert)
6377                         gtk_cmclist_set_column_visibility
6378                                 (GTK_CMCLIST(ctree), pos, FALSE);
6379                 else
6380                         gtk_cmclist_set_column_visibility
6381                                 (GTK_CMCLIST(ctree), pos, col_state[pos].visible);
6382         }
6383         if (prefs_common.two_line_vert)
6384                 gtk_sctree_set_use_markup(GTK_SCTREE(ctree), summaryview->col_pos[S_COL_SUBJECT], vert);
6385
6386         /* connect signal to the buttons for sorting */
6387 #define CLIST_BUTTON_SIGNAL_CONNECT(col, func) \
6388         g_signal_connect \
6389                 (G_OBJECT(GTK_CMCLIST(ctree)->column[col_pos[col]].button), \
6390                  "clicked", \
6391                  G_CALLBACK(func), \
6392                  summaryview)
6393
6394         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_MARK   , summary_mark_clicked);
6395         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_STATUS , summary_status_clicked);
6396         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_MIME   , summary_mime_clicked);
6397         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_NUMBER , summary_num_clicked);
6398         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_SIZE   , summary_size_clicked);
6399         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_DATE   , summary_date_clicked);
6400         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_FROM   , summary_from_clicked);
6401         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_TO     , summary_to_clicked);
6402         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_SUBJECT, summary_subject_clicked);
6403         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_SCORE,   summary_score_clicked);
6404         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_LOCKED,  summary_locked_clicked);
6405         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_TAGS,    summary_tags_clicked);
6406
6407 #undef CLIST_BUTTON_SIGNAL_CONNECT
6408
6409         g_signal_connect(G_OBJECT(ctree), "tree_select_row",
6410                          G_CALLBACK(summary_selected), summaryview);
6411         g_signal_connect(G_OBJECT(ctree), "tree_unselect_row",
6412                          G_CALLBACK(summary_unselected), summaryview);
6413         g_signal_connect(G_OBJECT(ctree), "button_press_event",
6414                          G_CALLBACK(summary_button_pressed),
6415                          summaryview);
6416 #ifndef MAEMO
6417         g_signal_connect(G_OBJECT(ctree), "popup-menu",
6418                          G_CALLBACK(summary_popup_menu), summaryview);
6419 #else
6420         gtk_widget_tap_and_hold_setup(GTK_WIDGET(ctree), NULL, NULL,
6421                         GTK_TAP_AND_HOLD_NONE | GTK_TAP_AND_HOLD_NO_INTERNALS);
6422         g_signal_connect(G_OBJECT(ctree), "tap-and-hold",
6423                          G_CALLBACK(summary_popup_menu), summaryview);
6424 #endif
6425         g_signal_connect(G_OBJECT(ctree), "button_release_event",
6426                          G_CALLBACK(summary_button_released),
6427                          summaryview);
6428         g_signal_connect(G_OBJECT(ctree), "key_press_event",
6429                          G_CALLBACK(summary_key_pressed), summaryview);
6430         g_signal_connect(G_OBJECT(ctree), "resize_column",
6431                          G_CALLBACK(summary_col_resized), summaryview);
6432         g_signal_connect(G_OBJECT(ctree), "open_row",
6433                          G_CALLBACK(summary_open_row), summaryview);
6434
6435         g_signal_connect_after(G_OBJECT(ctree), "tree_expand",
6436                                G_CALLBACK(summary_tree_expanded),
6437                                summaryview);
6438         g_signal_connect_after(G_OBJECT(ctree), "tree_collapse",
6439                                G_CALLBACK(summary_tree_collapsed),
6440                                summaryview);
6441
6442         g_signal_connect(G_OBJECT(ctree), "start_drag",
6443                          G_CALLBACK(summary_start_drag),
6444                          summaryview);
6445         g_signal_connect(G_OBJECT(ctree), "drag_data_get",
6446                          G_CALLBACK(summary_drag_data_get),
6447                          summaryview);
6448         g_signal_connect(G_OBJECT(ctree), "drag_end",
6449                          G_CALLBACK(summary_drag_end),
6450                          summaryview);
6451
6452         gtk_drag_dest_set(ctree, GTK_DEST_DEFAULT_ALL & ~GTK_DEST_DEFAULT_HIGHLIGHT,
6453                           summary_drag_types, 3,
6454                           GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_DEFAULT);
6455
6456         g_signal_connect(G_OBJECT(ctree), "drag_data_received",
6457                          G_CALLBACK(summary_drag_data_received),
6458                          summaryview);
6459
6460         g_signal_connect(G_OBJECT(ctree), "drag_motion",
6461                          G_CALLBACK(summary_drag_motion_cb),
6462                          summaryview);
6463
6464 #if !GENERIC_UMPC
6465         g_object_set (G_OBJECT(ctree), "has-tooltip", TRUE, NULL);
6466         g_signal_connect(G_OBJECT(ctree), "query-tooltip",
6467                          G_CALLBACK(tooltip_cb),
6468                         summaryview);
6469 #endif
6470         return ctree;
6471 }
6472
6473 void summary_set_column_order(SummaryView *summaryview)
6474 {
6475         GtkWidget *ctree;
6476         GtkWidget *scrolledwin = summaryview->scrolledwin;
6477         FolderItem *item;
6478         guint selected_msgnum = summary_get_msgnum(summaryview, summaryview->selected);
6479         guint displayed_msgnum = summary_get_msgnum(summaryview, summaryview->displayed);
6480
6481         item = summaryview->folder_item;
6482
6483         summary_clear_all(summaryview);
6484         gtk_widget_destroy(summaryview->ctree);
6485
6486         summaryview->ctree = ctree = summary_ctree_create(summaryview);
6487         summary_set_fonts(summaryview);
6488         summary_set_column_titles(summaryview);
6489         gtk_scrolled_window_set_hadjustment(GTK_SCROLLED_WINDOW(scrolledwin),
6490                                             GTK_CMCLIST(ctree)->hadjustment);
6491         gtk_scrolled_window_set_vadjustment(GTK_SCROLLED_WINDOW(scrolledwin),
6492                                             GTK_CMCLIST(ctree)->vadjustment);
6493         gtk_container_add(GTK_CONTAINER(scrolledwin), ctree);
6494         gtk_widget_show(ctree);
6495
6496         summary_show(summaryview, item);
6497
6498         summary_select_by_msgnum(summaryview, selected_msgnum);
6499
6500         summaryview->selected = summary_find_msg_by_msgnum(summaryview, selected_msgnum);
6501         summaryview->displayed = summary_find_msg_by_msgnum(summaryview, displayed_msgnum);
6502         summaryview->last_displayed = summaryview->displayed;
6503         if (!summaryview->displayed)
6504                 messageview_clear(summaryview->messageview);
6505         else
6506                 summary_redisplay_msg(summaryview);
6507
6508         if (prefs_common.layout_mode == VERTICAL_LAYOUT &&
6509             prefs_common.two_line_vert) {
6510                 gtk_cmclist_set_row_height(GTK_CMCLIST(summaryview->ctree), 2*normal_row_height + 2);
6511         } else {
6512                 gtk_cmclist_set_row_height(GTK_CMCLIST(summaryview->ctree), 0);
6513         }
6514 }
6515
6516
6517 /* callback functions */
6518
6519 static gint summary_folder_eventbox_pressed(GtkWidget *eventbox, GdkEventButton *event,
6520                                             SummaryView *summaryview)
6521 {
6522         if (event) {
6523                 gtk_widget_grab_focus(summaryview->folderview->ctree);
6524                 mainwindow_exit_folder(summaryview->mainwin);
6525         }
6526         return TRUE;
6527 }
6528
6529 static gint summary_toggle_pressed(GtkWidget *eventbox, GdkEventButton *event,
6530                                    SummaryView *summaryview)
6531 {
6532         if (event)
6533                 summary_toggle_view(summaryview);
6534         return TRUE;
6535 }
6536 #ifdef GENERIC_UMPC
6537 static void summary_toggle_multiple_pressed(GtkWidget *widget,
6538                                    SummaryView *summaryview)
6539 {
6540         GTK_SCTREE(summaryview->ctree)->force_additive_sel =
6541                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
6542 }
6543 #endif
6544 static gboolean summary_button_pressed(GtkWidget *ctree, GdkEventButton *event,
6545                                        SummaryView *summaryview)
6546 {
6547         if (!event) return FALSE;
6548
6549         if (event->button == 3) {
6550                 /* right clicked */
6551                 summary_set_menu_sensitive(summaryview);
6552                 gtk_menu_popup(GTK_MENU(summaryview->popupmenu), NULL, NULL,
6553                                NULL, NULL, event->button, event->time);
6554         } else if (event->button == 2) {
6555                 summaryview->display_msg = messageview_is_visible(summaryview->messageview);
6556         } else if (event->button == 1) {
6557                 if (!prefs_common.emulate_emacs &&
6558                     messageview_is_visible(summaryview->messageview))
6559                         summaryview->display_msg = TRUE;
6560         }
6561
6562         return FALSE;
6563 }
6564
6565 static gboolean summary_button_released(GtkWidget *ctree, GdkEventButton *event,
6566                                         SummaryView *summaryview)
6567 {
6568         return FALSE;
6569 }
6570
6571 gboolean summary_pass_key_press_event(SummaryView *summaryview, GdkEventKey *event)
6572 {
6573         if (!summaryview)
6574                 return FALSE;
6575         if (summary_is_list(summaryview))
6576                 return summary_key_pressed(summaryview->ctree, event, summaryview);
6577         else
6578                 return FALSE;
6579 }
6580
6581 #define BREAK_ON_MODIFIER_KEY() \
6582         if ((event->state & (GDK_MOD1_MASK|GDK_CONTROL_MASK)) != 0) break
6583
6584 static gboolean summary_key_pressed(GtkWidget *widget, GdkEventKey *event,
6585                                     SummaryView *summaryview)
6586 {
6587         GtkCMCTree *ctree = GTK_CMCTREE(widget);
6588         GtkCMCTreeNode *node;
6589         MessageView *messageview;
6590         TextView *textview;
6591         GtkAdjustment *adj;
6592         gboolean mod_pressed;
6593
6594         if (!event)
6595                 return TRUE;
6596
6597         if (quicksearch_has_focus(summaryview->quicksearch))
6598                 return FALSE;
6599
6600         messageview = summaryview->messageview;
6601         textview = messageview->mimeview->textview;
6602
6603         mod_pressed =
6604                 ((event->state & (GDK_SHIFT_MASK|GDK_MOD1_MASK)) != 0);
6605
6606         if (summaryview->selected) {
6607                 gboolean handled = FALSE;
6608                 switch (event->keyval) {
6609                 case GDK_KEY_space:             /* Page down or go to the next */
6610                         handled = TRUE;
6611                         if (event->state & GDK_CONTROL_MASK) {
6612                                 handled = FALSE;
6613                                 break;
6614                         }
6615                         if (event->state & GDK_SHIFT_MASK)
6616                                 mimeview_scroll_page(messageview->mimeview, TRUE);
6617                         else {
6618                                 if (summaryview->displayed != summaryview->selected) {
6619                                         summary_display_msg(summaryview,
6620                                                             summaryview->selected);
6621                                         break;
6622                                 }
6623                                 if (mod_pressed) {
6624                                         if (!mimeview_scroll_page(messageview->mimeview, TRUE))
6625                                                 summary_select_prev_unread(summaryview);
6626                                 } else {
6627                                         if (!mimeview_scroll_page(messageview->mimeview, FALSE))
6628                                                 summary_select_next_unread(summaryview);
6629                                 }
6630                         }
6631                         break;
6632                 case GDK_KEY_BackSpace: /* Page up */
6633                         handled = TRUE;
6634                         mimeview_scroll_page(messageview->mimeview, TRUE);
6635                         break;
6636                 case GDK_KEY_Return:    /* Scroll up/down one line */
6637                 case GDK_KEY_KP_Enter:
6638                         handled = TRUE;
6639                         if (summaryview->displayed != summaryview->selected) {
6640 #ifndef GENERIC_UMPC
6641                                 summary_display_msg(summaryview,
6642                                                     summaryview->selected);
6643 #else
6644                                 summary_open_row(NULL, summaryview);
6645 #endif
6646                                 break;
6647                         }
6648                         mimeview_scroll_one_line(messageview->mimeview, mod_pressed);
6649                         break;
6650                 }
6651
6652                 if (handled)
6653                         return FALSE;
6654         }
6655         if (summary_is_locked(summaryview))
6656                 return TRUE;
6657
6658         switch (event->keyval) {
6659         case GDK_KEY_Left:              /* Move focus */
6660                 adj = gtk_scrolled_window_get_hadjustment
6661                         (GTK_SCROLLED_WINDOW(summaryview->scrolledwin));
6662                 if (gtk_adjustment_get_lower(adj) != gtk_adjustment_get_value(adj))
6663                         break;
6664                 /* FALLTHROUGH */
6665         case GDK_KEY_Escape:
6666                 gtk_widget_grab_focus(summaryview->folderview->ctree);
6667                 mainwindow_exit_folder(summaryview->mainwin);
6668                 return TRUE;
6669         case GDK_KEY_Home:
6670         case GDK_KEY_End:
6671                 if ((node = summaryview->selected) != NULL) {
6672                         GtkCMCTreeNode *next = NULL;
6673                         next = (event->keyval == GDK_KEY_Home)
6674                                         ? gtk_cmctree_node_nth(ctree, 0)
6675                                         : gtk_cmctree_node_nth(ctree,
6676                                                 g_list_length(GTK_CMCLIST(ctree)->row_list)-1);
6677                         if (next) {
6678                                 gtk_sctree_select_with_state
6679                                         (GTK_SCTREE(ctree), next, (event->state & ~GDK_CONTROL_MASK) );
6680
6681                                 /* Deprecated - what are the non-deprecated equivalents? */
6682                                 if (gtk_cmctree_node_is_visible(GTK_CMCTREE(ctree), next) != GTK_VISIBILITY_FULL)
6683                                         gtk_cmctree_node_moveto(GTK_CMCTREE(ctree), next, 0, 0, 0);
6684                                 summaryview->selected = next;
6685                         }
6686                 }
6687                 return TRUE;
6688         default:
6689                 break;
6690         }
6691
6692         if (!summaryview->selected) {
6693                 node = gtk_cmctree_node_nth(ctree, 0);
6694                 if (node)
6695                         gtk_sctree_select(GTK_SCTREE(ctree), node);
6696                 else
6697                         return TRUE;
6698         }
6699
6700         switch (event->keyval) {
6701         case GDK_KEY_Delete:
6702                 BREAK_ON_MODIFIER_KEY();
6703                 summary_delete_trash(summaryview);
6704                 break;
6705         case GDK_KEY_y:
6706         case GDK_KEY_t:
6707         case GDK_KEY_l:
6708         case GDK_KEY_o:
6709         case GDK_KEY_c:
6710         case GDK_KEY_a:
6711         case GDK_KEY_z:
6712                 if ((event->state & (GDK_MOD1_MASK|GDK_CONTROL_MASK)) == 0) {
6713                         g_signal_stop_emission_by_name(G_OBJECT(widget),
6714                                        "key_press_event");
6715                         mimeview_pass_key_press_event(messageview->mimeview,
6716                                                       event);
6717                         break;
6718                 }
6719         default:
6720                 break;
6721         }
6722         return FALSE;
6723 }
6724
6725 static void quicksearch_execute_cb(QuickSearch *quicksearch, gpointer data)
6726 {
6727         SummaryView *summaryview = data;
6728
6729         summary_show(summaryview, summaryview->folder_item);
6730 }
6731
6732 static void tog_searchbar_cb(GtkWidget *w, gpointer data)
6733 {
6734         SummaryView *summaryview = (SummaryView *)data;
6735
6736         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))) {
6737                 prefs_common.show_searchbar = TRUE;
6738                 quicksearch_show(summaryview->quicksearch);
6739         } else {
6740                 prefs_common.show_searchbar = FALSE;
6741                 quicksearch_hide(summaryview->quicksearch);
6742         }
6743 }
6744
6745 void summaryview_activate_quicksearch(SummaryView *summaryview, gboolean show)
6746 {
6747         prefs_common.show_searchbar = show;
6748         gtk_toggle_button_set_active(
6749                 GTK_TOGGLE_BUTTON(summaryview->toggle_search),
6750                 show);
6751         if (show) {
6752                 quicksearch_show(summaryview->quicksearch);
6753         } else {
6754                 quicksearch_hide(summaryview->quicksearch);
6755                 summary_grab_focus(summaryview);
6756         }
6757 }
6758
6759 void summary_open_row(GtkSCTree *sctree, SummaryView *summaryview)
6760 {
6761         if (FOLDER_SHOWS_TO_HDR(summaryview->folder_item))
6762                 summary_reedit(summaryview);
6763         else
6764                 summary_open_msg(summaryview);
6765
6766         summaryview->display_msg = FALSE;
6767 }
6768
6769 static void summary_tree_expanded(GtkCMCTree *ctree, GtkCMCTreeNode *node,
6770                                   SummaryView *summaryview)
6771 {
6772         summary_set_row_marks(summaryview, node);
6773         if (prefs_common.bold_unread) {
6774                 while (node) {
6775                         GtkCMCTreeNode *next = GTK_CMCTREE_NODE_NEXT(node);
6776                         if (GTK_CMCTREE_ROW(node)->children)
6777                                 summary_set_row_marks(summaryview, node);
6778                         node = next;
6779                 }
6780         }
6781 }
6782
6783 static void summary_tree_collapsed(GtkCMCTree *ctree, GtkCMCTreeNode *node,
6784                                    SummaryView *summaryview)
6785 {
6786         gtk_sctree_select(GTK_SCTREE(ctree), node);
6787         summary_set_row_marks(summaryview, node);
6788 }
6789
6790 static void summary_unselected(GtkCMCTree *ctree, GtkCMCTreeNode *row,
6791                                gint column, SummaryView *summaryview)
6792 {
6793         if (summary_is_locked(summaryview)
6794         ||  GTK_SCTREE(ctree)->selecting_range) {
6795                 return;
6796         }
6797
6798         summary_status_show(summaryview);
6799 }
6800
6801 static void summary_selected(GtkCMCTree *ctree, GtkCMCTreeNode *row,
6802                              gint column, SummaryView *summaryview)
6803 {
6804         MsgInfo *msginfo;
6805         gboolean marked_unread = FALSE;
6806
6807         if (summary_is_locked(summaryview)
6808         && !GTK_SCTREE(ctree)->selecting_range
6809         && summaryview->messageview
6810         && summaryview->messageview->mimeview
6811         && summaryview->messageview->mimeview->type == MIMEVIEW_TEXT
6812         && summaryview->messageview->mimeview->textview->loading) {
6813                 PostponedSelectData *data = g_new0(PostponedSelectData, 1);
6814                 summaryview->messageview->mimeview->textview->stop_loading = TRUE;
6815
6816                 data->ctree = ctree;
6817                 data->row = row;
6818                 data->node = NULL;
6819                 data->column = column;
6820                 data->summaryview = summaryview;
6821                 debug_print("postponing open of message till end of load\n");
6822                 g_timeout_add(100, summary_select_retry, data);
6823                 return;
6824         }
6825         if (summary_is_locked(summaryview)
6826         ||  GTK_SCTREE(ctree)->selecting_range) {
6827                 return;
6828         }
6829
6830         summary_status_show(summaryview);
6831
6832         if (GTK_CMCLIST(ctree)->selection &&
6833             GTK_CMCLIST(ctree)->selection->next) {
6834                 summaryview->display_msg = FALSE;
6835                 summary_set_menu_sensitive(summaryview);
6836                 toolbar_main_set_sensitive(summaryview->mainwin);
6837                 return;
6838         }
6839
6840         summaryview->selected = row;
6841
6842         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
6843         cm_return_if_fail(msginfo != NULL);
6844
6845         main_create_mailing_list_menu (summaryview->mainwin, msginfo);
6846         toolbar_set_learn_button
6847                 (summaryview->mainwin->toolbar,
6848                  MSG_IS_SPAM(msginfo->flags)?LEARN_HAM:LEARN_SPAM);
6849
6850         switch (column < 0 ? column : summaryview->col_state[column].type) {
6851         case S_COL_MARK:
6852                 if (!MSG_IS_DELETED(msginfo->flags) &&
6853                     !MSG_IS_MOVE(msginfo->flags) &&
6854                     !MSG_IS_COPY(msginfo->flags)) {
6855                         if (MSG_IS_MARKED(msginfo->flags)) {
6856                                 summary_unmark_row(summaryview, row);
6857                                 summary_status_show(summaryview);
6858                         } else {
6859                                 summary_mark_row(summaryview, row);
6860                                 summary_status_show(summaryview);
6861                         }
6862                 }
6863                 break;
6864         case S_COL_STATUS:
6865                 if (MSG_IS_UNREAD(msginfo->flags)) {
6866                         summary_mark_row_as_read(summaryview, row);
6867                         summary_status_show(summaryview);
6868                 } else if (MSG_IS_SPAM(msginfo->flags)) {
6869                                 if (procmsg_spam_learner_learn(msginfo, NULL, FALSE) == 0)
6870                                         summary_msginfo_unset_flags(msginfo, MSG_SPAM, 0);
6871                                 else
6872                                         log_error(LOG_PROTOCOL, _("An error happened while learning.\n"));
6873                 } else if (!MSG_IS_REPLIED(msginfo->flags) &&
6874                          !MSG_IS_FORWARDED(msginfo->flags)) {
6875                         marked_unread = TRUE;
6876                 } else if (MSG_IS_REPLIED(msginfo->flags)) {
6877                         summary_find_answers(summaryview, msginfo);
6878                         return;
6879                 }
6880                 break;
6881         case S_COL_LOCKED:
6882                 if (MSG_IS_LOCKED(msginfo->flags)) {
6883                         summary_unlock_row(summaryview, row);
6884                         summary_status_show(summaryview);
6885                 }
6886                 else {
6887                         summary_lock_row(summaryview, row);
6888                         summary_status_show(summaryview);
6889                 }
6890                 break;
6891         default:
6892                 break;
6893         }
6894
6895         if (summaryview->display_msg ||
6896             (prefs_common.always_show_msg &&
6897              messageview_is_visible(summaryview->messageview))) {
6898                 summaryview->display_msg = FALSE;
6899                 if (summaryview->displayed != row) {
6900                         summary_display_msg(summaryview, row);
6901                         if (marked_unread) {
6902                                 summary_mark_row_as_unread(summaryview, row);
6903                                 summary_status_show(summaryview);
6904                         }
6905                         return;
6906                 }
6907         }
6908
6909         if (marked_unread) {
6910                 summary_mark_row_as_unread(summaryview, row);
6911                 summary_status_show(summaryview);
6912         }
6913
6914         summary_set_menu_sensitive(summaryview);
6915         toolbar_main_set_sensitive(summaryview->mainwin);
6916 }
6917
6918 static void summary_col_resized(GtkCMCList *clist, gint column, gint width,
6919                                 SummaryView *summaryview)
6920 {
6921         SummaryColumnType type = summaryview->col_state[column].type;
6922
6923         prefs_common.summary_col_size[type] = width;
6924 }
6925
6926
6927 /*
6928  * \brief get List of msginfo selected in SummaryView
6929  *
6930  * \param summaryview
6931  *
6932  * \return GSList holding MsgInfo
6933  */
6934 GSList *summary_get_selection(SummaryView *summaryview)
6935 {
6936         GList *sel = NULL;
6937         GSList *msginfo_list = NULL;
6938
6939         cm_return_val_if_fail(summaryview != NULL, NULL);
6940
6941         sel = GTK_CMCLIST(summaryview->ctree)->selection;
6942
6943         cm_return_val_if_fail(sel != NULL, NULL);
6944
6945         for ( ; sel != NULL; sel = sel->next)
6946                 msginfo_list =
6947                         g_slist_prepend(msginfo_list,
6948                                        gtk_cmctree_node_get_row_data(GTK_CMCTREE(summaryview->ctree),
6949                                                                    GTK_CMCTREE_NODE(sel->data)));
6950         return g_slist_reverse(msginfo_list);
6951 }
6952
6953 static void summary_sort_by_column_click(SummaryView *summaryview,
6954                                          FolderSortKey sort_key)
6955 {
6956         GtkCMCTreeNode *node = NULL;
6957         START_TIMING("");
6958         if (summaryview->sort_key == sort_key)
6959                 summary_sort(summaryview, sort_key,
6960                              summaryview->sort_type == SORT_ASCENDING
6961                              ? SORT_DESCENDING : SORT_ASCENDING);
6962         else
6963                 summary_sort(summaryview, sort_key, SORT_ASCENDING);
6964
6965         node = GTK_CMCTREE_NODE(GTK_CMCLIST(summaryview->ctree)->row_list);
6966
6967         summary_freeze(summaryview);
6968         if (prefs_common.bold_unread) {
6969                 while (node) {
6970                         GtkCMCTreeNode *next = GTK_CMCTREE_NODE_NEXT(node);
6971                         if (GTK_CMCTREE_ROW(node)->children)
6972                                 summary_set_row_marks(summaryview, node);
6973                         node = next;
6974                 }
6975         }
6976         summary_thaw(summaryview);
6977         END_TIMING();
6978 }
6979
6980 static void summary_mark_clicked(GtkWidget *button, SummaryView *summaryview)
6981 {
6982         summary_sort_by_column_click(summaryview, SORT_BY_MARK);
6983 }
6984
6985 static void summary_status_clicked(GtkWidget *button, SummaryView *summaryview)
6986 {
6987         summary_sort_by_column_click(summaryview, SORT_BY_STATUS);
6988 }
6989
6990 static void summary_mime_clicked(GtkWidget *button, SummaryView *summaryview)
6991 {
6992         summary_sort_by_column_click(summaryview, SORT_BY_MIME);
6993 }
6994
6995 static void summary_num_clicked(GtkWidget *button, SummaryView *summaryview)
6996 {
6997         summary_sort_by_column_click(summaryview, SORT_BY_NUMBER);
6998 }
6999
7000 static void summary_size_clicked(GtkWidget *button, SummaryView *summaryview)
7001 {
7002         summary_sort_by_column_click(summaryview, SORT_BY_SIZE);
7003 }
7004
7005 static void summary_date_clicked(GtkWidget *button, SummaryView *summaryview)
7006 {
7007         summary_sort_by_column_click(summaryview, SORT_BY_DATE);
7008 }
7009
7010 static void summary_from_clicked(GtkWidget *button, SummaryView *summaryview)
7011 {
7012         if (summaryview->col_state[summaryview->col_pos[S_COL_FROM]].visible)
7013                 summary_sort_by_column_click(summaryview, SORT_BY_FROM);
7014         else
7015                 summary_sort_by_column_click(summaryview, SORT_BY_TO);
7016 }
7017
7018 static void summary_to_clicked(GtkWidget *button, SummaryView *summaryview)
7019 {
7020         if (summaryview->col_state[summaryview->col_pos[S_COL_TO]].visible)
7021                 summary_sort_by_column_click(summaryview, SORT_BY_TO);
7022         else
7023                 summary_sort_by_column_click(summaryview, SORT_BY_FROM);
7024 }
7025
7026 static void summary_subject_clicked(GtkWidget *button,
7027                                     SummaryView *summaryview)
7028 {
7029         summary_sort_by_column_click(summaryview, SORT_BY_SUBJECT);
7030 }
7031
7032 static void summary_score_clicked(GtkWidget *button,
7033                                   SummaryView *summaryview)
7034 {
7035         summary_sort_by_column_click(summaryview, SORT_BY_SCORE);
7036 }
7037
7038 static void summary_locked_clicked(GtkWidget *button,
7039                                    SummaryView *summaryview)
7040 {
7041         summary_sort_by_column_click(summaryview, SORT_BY_LOCKED);
7042 }
7043
7044 static void summary_tags_clicked(GtkWidget *button,
7045                                    SummaryView *summaryview)
7046 {
7047         summary_sort_by_column_click(summaryview, SORT_BY_TAGS);
7048 }
7049
7050 static void summary_start_drag(GtkWidget *widget, gint button, GdkEvent *event,
7051                                SummaryView *summaryview)
7052 {
7053         GdkDragContext *context;
7054
7055         cm_return_if_fail(summaryview != NULL);
7056         cm_return_if_fail(summaryview->folder_item != NULL);
7057         cm_return_if_fail(summaryview->folder_item->folder != NULL);
7058
7059         if (summaryview->selected == NULL) return;
7060
7061         context = gtk_drag_begin(widget, summaryview->target_list,
7062                                  GDK_ACTION_MOVE|GDK_ACTION_COPY|GDK_ACTION_DEFAULT, button, event);
7063         gtk_drag_set_icon_default(context);
7064         if (prefs_common.layout_mode == SMALL_LAYOUT) {
7065                 GtkWidget *paned = gtk_widget_get_parent(GTK_WIDGET_PTR(summaryview));
7066                 if (paned && GTK_IS_PANED(paned)) {
7067                         mainwindow_reset_paned(GTK_PANED(paned));
7068                 }
7069         }
7070 }
7071
7072 static gboolean summary_return_to_list(void *data)
7073 {
7074         SummaryView *summaryview = (SummaryView *)data;
7075         mainwindow_enter_folder(summaryview->mainwin);
7076         return FALSE;
7077 }
7078
7079 static void summary_drag_end       (GtkWidget       *widget,
7080                                    GdkDragContext   *drag_context,
7081                                    SummaryView      *summaryview)
7082 {
7083         if (prefs_common.layout_mode == SMALL_LAYOUT) {
7084                 g_timeout_add(250, summary_return_to_list, summaryview);
7085         }
7086 }
7087
7088 static void summary_drag_data_get(GtkWidget        *widget,
7089                                   GdkDragContext   *drag_context,
7090                                   GtkSelectionData *selection_data,
7091                                   guint             info,
7092                                   guint             time,
7093                                   SummaryView      *summaryview)
7094 {
7095         if (info == TARGET_MAIL_URI_LIST) {
7096                 GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
7097                 GList *cur;
7098                 MsgInfo *msginfo;
7099                 gchar *mail_list = NULL, *tmp1, *tmp2;
7100
7101                 for (cur = GTK_CMCLIST(ctree)->selection;
7102                      cur != NULL && cur->data != NULL; cur = cur->next) {
7103                         msginfo = gtk_cmctree_node_get_row_data
7104                                 (ctree, GTK_CMCTREE_NODE(cur->data));
7105                         tmp2 = procmsg_get_message_file(msginfo);
7106                         if (!tmp2) continue;
7107                         if (msginfo->subject) {
7108                                 gchar *san_subject = g_strdup(msginfo->subject);
7109                                 gchar *dest = NULL;
7110                                 subst_for_filename(san_subject);
7111                                 dest = g_strdup_printf("%s%s%s.%d.txt",
7112                                                 get_tmp_dir(),
7113                                                 G_DIR_SEPARATOR_S,
7114                                                 san_subject, msginfo->msgnum);
7115                                 g_free(san_subject);
7116                                 san_subject = g_filename_from_utf8(dest, -1, NULL, NULL, NULL);
7117                                 g_free(dest);
7118                                 dest = san_subject;
7119                                 if (copy_file(tmp2, dest, TRUE) == 0) {
7120                                         g_free(tmp2);
7121                                         tmp2 = dest;
7122                                 }
7123                         }
7124                         tmp1 = g_filename_to_uri(tmp2, NULL, NULL);
7125                         g_free(tmp2);
7126                         tmp2 = g_strconcat(tmp1, "\r\n", NULL);
7127                         g_free(tmp1);
7128                         tmp1 = tmp2;
7129
7130                         if (!mail_list) {
7131                                 mail_list = tmp1;
7132                         } else {
7133                                 tmp2 = g_strconcat(mail_list, tmp1, NULL);
7134                                 g_free(mail_list);
7135                                 g_free(tmp1);
7136                                 mail_list = tmp2;
7137                         }
7138                 }
7139
7140                 if (mail_list != NULL) {
7141                         gtk_selection_data_set(selection_data,
7142                                                gtk_selection_data_get_target(selection_data), 8,
7143                                                mail_list, strlen(mail_list));
7144                         g_free(mail_list);
7145                 }
7146         } else if (info == TARGET_DUMMY) {
7147                 if (GTK_CMCLIST(summaryview->ctree)->selection)
7148                         gtk_selection_data_set(selection_data,
7149                                                gtk_selection_data_get_target(selection_data), 8,
7150                                                "Dummy-Summaryview",
7151                                                strlen("Dummy-Summaryview")+1);
7152         } else if (info == TARGET_MAIL_CM_PATH_LIST) {
7153                 /* content: folder_item_identifier\nmsgid1\nmsgid2\nmsgid3 */
7154
7155                 GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
7156                 GList *cur;
7157                 MsgInfo *msginfo;
7158                 gchar *path_list = NULL;
7159
7160                 /* identifier */
7161                 if(GTK_CMCLIST(ctree)->selection != NULL) {
7162                         msginfo = gtk_cmctree_node_get_row_data(ctree, GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->selection->data));
7163             if(msginfo && msginfo->folder)
7164               path_list = folder_item_get_identifier(msginfo->folder);
7165                 }
7166
7167                 for (cur = GTK_CMCLIST(ctree)->selection;
7168                      cur != NULL && cur->data != NULL; cur = cur->next) {
7169                         gchar *tmp;
7170
7171                         msginfo = gtk_cmctree_node_get_row_data(ctree, GTK_CMCTREE_NODE(cur->data));
7172             if(!msginfo)
7173               continue;
7174                         tmp = path_list;
7175                         path_list = g_strconcat(path_list, "\n", (msginfo->msgid ? msginfo->msgid : "unknown"), NULL);
7176                         g_free(tmp);
7177                 }
7178
7179                 if (path_list != NULL) {
7180                         gtk_selection_data_set(selection_data,
7181                                                gtk_selection_data_get_target(selection_data), 8,
7182                                                path_list, strlen(path_list));
7183                         g_free(path_list);
7184                 }
7185     }
7186 }
7187
7188 static gboolean summary_drag_motion_cb(GtkWidget      *widget,
7189                                           GdkDragContext *context,
7190                                           gint            x,
7191                                           gint            y,
7192                                           guint           time,
7193                                           SummaryView    *summaryview)
7194 {
7195         FolderItem *item = summaryview->folder_item;
7196         if (!(item && item->folder && folder_item_parent(item) != NULL
7197                     && FOLDER_CLASS(item->folder)->add_msg != NULL)) {
7198                 gdk_drag_status(context, 0, time);
7199                 return FALSE;
7200         } else if (gtk_drag_get_source_widget(context) ==
7201                 mainwindow_get_mainwindow()->folderview->ctree) {
7202                 /* no folders */
7203                 gdk_drag_status(context, 0, time);
7204                 return FALSE;
7205         } else if (gtk_drag_get_source_widget(context) ==
7206                 summaryview->ctree) {
7207                 /* not from same folder */
7208                 gdk_drag_status(context, 0, time);
7209                 return FALSE;
7210         } else {
7211                 gdk_drag_status(context, GDK_ACTION_COPY, time);
7212                 return TRUE;
7213         }
7214 }
7215
7216 static void summary_drag_data_received(GtkWidget        *widget,
7217                                         GdkDragContext   *drag_context,
7218                                         gint              x,
7219                                         gint              y,
7220                                         GtkSelectionData *data,
7221                                         guint             info,
7222                                         guint             time,
7223                                         SummaryView       *summaryview)
7224 {
7225         if (info == TARGET_MAIL_URI_LIST) {
7226                 FolderItem *item = summaryview->folder_item;
7227                 if (!item) {
7228                         gtk_drag_finish(drag_context, FALSE, FALSE, time);
7229                         return;
7230                 } else {
7231                         folderview_finish_dnd(gtk_selection_data_get_data(data),
7232                                 drag_context, time, item);
7233                 }
7234         }
7235 }
7236
7237
7238 /* custom compare functions for sorting */
7239
7240 static gint summary_cmp_by_date(GtkCMCList *clist,
7241                       gconstpointer ptr1, gconstpointer ptr2)
7242 {
7243         MsgInfo *msginfo1 = ((GtkCMCListRow *)ptr1)->data;
7244         MsgInfo *msginfo2 = ((GtkCMCListRow *)ptr2)->data;
7245         gint res;
7246         if (!msginfo1 || !msginfo2)
7247                 return -1;
7248
7249         res = (msginfo1->date_t - msginfo2->date_t);
7250         if (res == 0)
7251                 res = msginfo1->msgnum - msginfo2->msgnum;
7252         return res;
7253 }
7254
7255 #define CMP_FUNC_DEF(func_name, val)                                     \
7256 static gint func_name(GtkCMCList *clist,                                 \
7257                       gconstpointer ptr1, gconstpointer ptr2)            \
7258 {                                                                        \
7259         MsgInfo *msginfo1 = ((GtkCMCListRow *)ptr1)->data;               \
7260         MsgInfo *msginfo2 = ((GtkCMCListRow *)ptr2)->data;               \
7261         gint res;                                                        \
7262         if (!msginfo1 || !msginfo2)                                      \
7263                 return -1;                                               \
7264                                                                          \
7265         res = (val);                                                     \
7266         return (res != 0) ? res:summary_cmp_by_date(clist, ptr1, ptr2);  \
7267 }
7268
7269 CMP_FUNC_DEF(summary_cmp_by_mark,
7270              MSG_IS_MARKED(msginfo1->flags) - MSG_IS_MARKED(msginfo2->flags))
7271 CMP_FUNC_DEF(summary_cmp_by_status,
7272              (-(MSG_IS_SPAM(msginfo1->flags))+(MSG_IS_UNREAD(msginfo1->flags)<<1)+(MSG_IS_NEW(msginfo1->flags)<<2))
7273              - (-(MSG_IS_SPAM(msginfo2->flags))+(MSG_IS_UNREAD(msginfo2->flags)<<1)+(MSG_IS_NEW(msginfo2->flags)<<2)) )
7274 CMP_FUNC_DEF(summary_cmp_by_mime,
7275              MSG_IS_WITH_ATTACHMENT(msginfo1->flags) - MSG_IS_WITH_ATTACHMENT(msginfo2->flags))
7276 CMP_FUNC_DEF(summary_cmp_by_label,
7277              MSG_GET_COLORLABEL(msginfo1->flags) -
7278              MSG_GET_COLORLABEL(msginfo2->flags))
7279 CMP_FUNC_DEF(summary_cmp_by_locked,
7280              MSG_IS_LOCKED(msginfo1->flags) - MSG_IS_LOCKED(msginfo2->flags))
7281
7282 CMP_FUNC_DEF(summary_cmp_by_num, msginfo1->msgnum - msginfo2->msgnum)
7283 CMP_FUNC_DEF(summary_cmp_by_size, msginfo1->size - msginfo2->size)
7284
7285 #undef CMP_FUNC_DEF
7286
7287 static gint summary_cmp_by_subject(GtkCMCList *clist,
7288                                    gconstpointer ptr1,
7289                                    gconstpointer ptr2)
7290 {
7291         MsgInfo *msginfo1 = ((GtkCMCListRow *)ptr1)->data;
7292         MsgInfo *msginfo2 = ((GtkCMCListRow *)ptr2)->data;
7293         gint res;
7294
7295         if (!msginfo1->subject)
7296                 return (msginfo2->subject != NULL);
7297         if (!msginfo2->subject)
7298                 return -1;
7299
7300         res = subject_compare_for_sort
7301                 (msginfo1->subject, msginfo2->subject);
7302         return (res != 0)? res: summary_cmp_by_date(clist, ptr1, ptr2);
7303 }
7304
7305 static gint summary_cmp_by_thread_date(GtkCMCList *clist,
7306                                    gconstpointer ptr1,
7307                                    gconstpointer ptr2)
7308 {
7309         MsgInfo *msginfo1 = ((GtkCMCListRow *)ptr1)->data;
7310         MsgInfo *msginfo2 = ((GtkCMCListRow *)ptr2)->data;
7311         gint thread_diff = msginfo1->thread_date - msginfo2->thread_date;
7312
7313         if (msginfo1->thread_date > 0 && msginfo2->thread_date > 0)
7314                 return thread_diff;
7315         else
7316                 return msginfo1->date_t - msginfo2->date_t;
7317 }
7318
7319 static gint summary_cmp_by_from(GtkCMCList *clist, gconstpointer ptr1,
7320                                 gconstpointer ptr2)
7321 {
7322         const gchar *str1, *str2;
7323         const GtkCMCListRow *r1 = (const GtkCMCListRow *) ptr1;
7324         const GtkCMCListRow *r2 = (const GtkCMCListRow *) ptr2;
7325         MsgInfo *msginfo1 = ((GtkCMCListRow *)ptr1)->data;
7326         MsgInfo *msginfo2 = ((GtkCMCListRow *)ptr2)->data;
7327         const SummaryView *sv = g_object_get_data(G_OBJECT(clist), "summaryview");
7328         gint res;
7329
7330         cm_return_val_if_fail(sv, -1);
7331         if (sv->col_state[sv->col_pos[S_COL_FROM]].visible) {
7332                 str1 = GTK_CMCELL_TEXT(r1->cell[sv->col_pos[S_COL_FROM]])->text;
7333                 str2 = GTK_CMCELL_TEXT(r2->cell[sv->col_pos[S_COL_FROM]])->text;
7334         } else {
7335                 str1 = msginfo1->from;
7336                 str2 = msginfo2->from;
7337         }
7338
7339         if (!str1)
7340                 return str2 != NULL;
7341
7342         if (!str2)
7343                 return -1;
7344
7345         res = g_utf8_collate(str1, str2);
7346         return (res != 0)? res: summary_cmp_by_date(clist, ptr1, ptr2);
7347 }
7348
7349 static gint summary_cmp_by_to(GtkCMCList *clist, gconstpointer ptr1,
7350                                 gconstpointer ptr2)
7351 {
7352         const gchar *str1, *str2;
7353         const GtkCMCListRow *r1 = (const GtkCMCListRow *) ptr1;
7354         const GtkCMCListRow *r2 = (const GtkCMCListRow *) ptr2;
7355         MsgInfo *msginfo1 = ((GtkCMCListRow *)ptr1)->data;
7356         MsgInfo *msginfo2 = ((GtkCMCListRow *)ptr2)->data;
7357         const SummaryView *sv = g_object_get_data(G_OBJECT(clist), "summaryview");
7358         gint res;
7359         cm_return_val_if_fail(sv, -1);
7360
7361         if (sv->col_state[sv->col_pos[S_COL_TO]].visible) {
7362                 str1 = GTK_CMCELL_TEXT(r1->cell[sv->col_pos[S_COL_TO]])->text;
7363                 str2 = GTK_CMCELL_TEXT(r2->cell[sv->col_pos[S_COL_TO]])->text;
7364         } else {
7365                 str1 = msginfo1->to;
7366                 str2 = msginfo2->to;
7367         }
7368
7369         if (!str1)
7370                 return str2 != NULL;
7371
7372         if (!str2)
7373                 return -1;
7374
7375         res = g_utf8_collate(str1, str2);
7376         return (res != 0)? res: summary_cmp_by_date(clist, ptr1, ptr2);
7377 }
7378
7379 static gint summary_cmp_by_tags(GtkCMCList *clist, gconstpointer ptr1,
7380                                 gconstpointer ptr2)
7381 {
7382         gchar *str1, *str2;
7383         const GtkCMCListRow *r1 = (const GtkCMCListRow *) ptr1;
7384         const GtkCMCListRow *r2 = (const GtkCMCListRow *) ptr2;
7385         const SummaryView *sv = g_object_get_data(G_OBJECT(clist), "summaryview");
7386         MsgInfo *msginfo1 = ((GtkCMCListRow *)ptr1)->data;
7387         MsgInfo *msginfo2 = ((GtkCMCListRow *)ptr2)->data;
7388         gint res;
7389         cm_return_val_if_fail(sv, -1);
7390
7391         if (sv->col_state[sv->col_pos[S_COL_TAGS]].visible) {
7392                 str1 = g_strdup(GTK_CMCELL_TEXT(r1->cell[sv->col_pos[S_COL_TAGS]])->text);
7393                 str2 = g_strdup(GTK_CMCELL_TEXT(r2->cell[sv->col_pos[S_COL_TAGS]])->text);
7394         } else {
7395                 str1 = procmsg_msginfo_get_tags_str(msginfo1);
7396                 str2 = procmsg_msginfo_get_tags_str(msginfo2);
7397         }
7398
7399         if (!str1) {
7400                 res = (str2 != NULL);
7401                 g_free(str2);
7402                 return res;
7403         }
7404         if (!str2) {
7405                 g_free(str1);
7406                 return -1;
7407         }
7408
7409         res = g_utf8_collate(str1, str2);
7410         g_free(str1);
7411         g_free(str2);
7412         return (res != 0)? res: summary_cmp_by_date(clist, ptr1, ptr2);
7413 }
7414
7415 static gint summary_cmp_by_simplified_subject
7416         (GtkCMCList *clist, gconstpointer ptr1, gconstpointer ptr2)
7417 {
7418         const FolderItemPrefs *prefs;
7419         const gchar *str1, *str2;
7420         const GtkCMCListRow *r1 = (const GtkCMCListRow *) ptr1;
7421         const GtkCMCListRow *r2 = (const GtkCMCListRow *) ptr2;
7422         const MsgInfo *msginfo1 = r1->data;
7423         const MsgInfo *msginfo2 = r2->data;
7424         const SummaryView *sv = g_object_get_data(G_OBJECT(clist), "summaryview");
7425         gint res;
7426
7427         cm_return_val_if_fail(sv, -1);
7428         cm_return_val_if_fail(msginfo1 != NULL && msginfo2 != NULL, -1);
7429
7430         if (sv->col_state[sv->col_pos[S_COL_SUBJECT]].visible) {
7431                 str1 = GTK_CMCELL_TEXT(r1->cell[sv->col_pos[S_COL_SUBJECT]])->text;
7432                 str2 = GTK_CMCELL_TEXT(r2->cell[sv->col_pos[S_COL_SUBJECT]])->text;
7433         } else {
7434                 str1 = msginfo1->subject;
7435                 str2 = msginfo2->subject;
7436         }
7437
7438         if (!str1)
7439                 return str2 != NULL;
7440
7441         if (!str2)
7442                 return -1;
7443
7444         prefs = msginfo1->folder->prefs;
7445         if (!prefs)
7446                 prefs = msginfo2->folder->prefs;
7447         if (!prefs)
7448                 return -1;
7449
7450         res = subject_compare_for_sort(str1, str2);
7451         return (res != 0)? res: summary_cmp_by_date(clist, ptr1, ptr2);
7452 }
7453
7454 static gint summary_cmp_by_score(GtkCMCList *clist,
7455                                  gconstpointer ptr1, gconstpointer ptr2)
7456 {
7457         MsgInfo *msginfo1 = ((GtkCMCListRow *)ptr1)->data;
7458         MsgInfo *msginfo2 = ((GtkCMCListRow *)ptr2)->data;
7459         int diff;
7460
7461         /* if score are equal, sort by date */
7462
7463         diff = msginfo1->score - msginfo2->score;
7464         if (diff != 0)
7465                 return diff;
7466         else
7467                 return summary_cmp_by_date(clist, ptr1, ptr2);
7468 }
7469
7470 static void summary_ignore_thread_func(GtkCMCTree *ctree, GtkCMCTreeNode *row, gpointer data)
7471 {
7472         SummaryView *summaryview = (SummaryView *) data;
7473         MsgInfo *msginfo;
7474
7475         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
7476         cm_return_if_fail(msginfo);
7477
7478         summary_msginfo_unset_flags(msginfo, MSG_WATCH_THREAD, 0);
7479         summary_msginfo_change_flags(msginfo, MSG_IGNORE_THREAD, 0, MSG_NEW | MSG_UNREAD, 0);
7480
7481         summary_set_row_marks(summaryview, row);
7482         debug_print("Message %d is marked as ignore thread\n",
7483             msginfo->msgnum);
7484 }
7485
7486 void summary_ignore_thread(SummaryView *summaryview)
7487 {
7488         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
7489         GList *cur;
7490         gboolean froze = FALSE;
7491
7492         START_LONG_OPERATION(summaryview, FALSE);
7493         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
7494                 gtk_cmctree_pre_recursive(ctree, GTK_CMCTREE_NODE(cur->data),
7495                                         GTK_CMCTREE_FUNC(summary_ignore_thread_func),
7496                                         summaryview);
7497
7498         END_LONG_OPERATION(summaryview);
7499
7500         summary_status_show(summaryview);
7501 }
7502
7503 static void summary_unignore_thread_func(GtkCMCTree *ctree, GtkCMCTreeNode *row, gpointer data)
7504 {
7505         SummaryView *summaryview = (SummaryView *) data;
7506         MsgInfo *msginfo;
7507
7508         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
7509         cm_return_if_fail(msginfo);
7510
7511         summary_msginfo_unset_flags(msginfo, MSG_IGNORE_THREAD, 0);
7512
7513         summary_set_row_marks(summaryview, row);
7514         debug_print("Message %d is marked as unignore thread\n",
7515             msginfo->msgnum);
7516 }
7517
7518 void summary_unignore_thread(SummaryView *summaryview)
7519 {
7520         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
7521         GList *cur;
7522         gboolean froze = FALSE;
7523
7524         START_LONG_OPERATION(summaryview, FALSE);
7525         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
7526                 gtk_cmctree_pre_recursive(ctree, GTK_CMCTREE_NODE(cur->data),
7527                                         GTK_CMCTREE_FUNC(summary_unignore_thread_func),
7528                                         summaryview);
7529
7530         END_LONG_OPERATION(summaryview);
7531
7532         summary_status_show(summaryview);
7533 }
7534
7535 static void summary_check_ignore_thread_func
7536                 (GtkCMCTree *ctree, GtkCMCTreeNode *row, gpointer data)
7537 {
7538         MsgInfo *msginfo;
7539         gint *found_ignore = (gint *) data;
7540
7541         if (*found_ignore) return;
7542         else {
7543                 msginfo = gtk_cmctree_node_get_row_data(ctree, row);
7544                 *found_ignore = msginfo && MSG_IS_IGNORE_THREAD(msginfo->flags);
7545         }
7546 }
7547
7548 void summary_toggle_ignore_thread(SummaryView *summaryview)
7549 {
7550         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
7551         GList *cur;
7552         gint found_ignore = 0;
7553
7554         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
7555                 gtk_cmctree_pre_recursive(ctree, GTK_CMCTREE_NODE(cur->data),
7556                                         GTK_CMCTREE_FUNC(summary_check_ignore_thread_func),
7557                                         &found_ignore);
7558
7559         if (found_ignore)
7560                 summary_unignore_thread(summaryview);
7561         else
7562                 summary_ignore_thread(summaryview);
7563 }
7564
7565 static void summary_watch_thread_func(GtkCMCTree *ctree, GtkCMCTreeNode *row, gpointer data)
7566 {
7567         SummaryView *summaryview = (SummaryView *) data;
7568         MsgInfo *msginfo;
7569
7570         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
7571         cm_return_if_fail(msginfo);
7572
7573         summary_msginfo_change_flags(msginfo, MSG_WATCH_THREAD, 0, MSG_IGNORE_THREAD, 0);
7574
7575         summary_set_row_marks(summaryview, row);
7576         debug_print("Message %d is marked as watch thread\n",
7577             msginfo->msgnum);
7578 }
7579
7580 void summary_watch_thread(SummaryView *summaryview)
7581 {
7582         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
7583         GList *cur;
7584         gboolean froze = FALSE;
7585
7586         START_LONG_OPERATION(summaryview, FALSE);
7587         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
7588                 gtk_cmctree_pre_recursive(ctree, GTK_CMCTREE_NODE(cur->data),
7589                                         GTK_CMCTREE_FUNC(summary_watch_thread_func),
7590                                         summaryview);
7591
7592         END_LONG_OPERATION(summaryview);
7593
7594         summary_status_show(summaryview);
7595 }
7596
7597 static void summary_unwatch_thread_func(GtkCMCTree *ctree, GtkCMCTreeNode *row, gpointer data)
7598 {
7599         SummaryView *summaryview = (SummaryView *) data;
7600         MsgInfo *msginfo;
7601
7602         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
7603         cm_return_if_fail(msginfo);
7604
7605         summary_msginfo_unset_flags(msginfo, MSG_WATCH_THREAD, 0);
7606
7607         summary_set_row_marks(summaryview, row);
7608         debug_print("Message %d is marked as unwatch thread\n",
7609             msginfo->msgnum);
7610 }
7611
7612 void summary_unwatch_thread(SummaryView *summaryview)
7613 {
7614         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
7615         GList *cur;
7616         gboolean froze = FALSE;
7617
7618         START_LONG_OPERATION(summaryview, FALSE);
7619         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
7620                 gtk_cmctree_pre_recursive(ctree, GTK_CMCTREE_NODE(cur->data),
7621                                         GTK_CMCTREE_FUNC(summary_unwatch_thread_func),
7622                                         summaryview);
7623
7624         END_LONG_OPERATION(summaryview);
7625
7626         summary_status_show(summaryview);
7627 }
7628
7629 static void summary_check_watch_thread_func
7630                 (GtkCMCTree *ctree, GtkCMCTreeNode *row, gpointer data)
7631 {
7632         MsgInfo *msginfo;
7633         gint *found_watch = (gint *) data;
7634
7635         if (*found_watch) return;
7636         else {
7637                 msginfo = gtk_cmctree_node_get_row_data(ctree, row);
7638                 *found_watch = msginfo && MSG_IS_WATCH_THREAD(msginfo->flags);
7639         }
7640 }
7641
7642 void summary_toggle_watch_thread(SummaryView *summaryview)
7643 {
7644         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
7645         GList *cur;
7646         gint found_watch = 0;
7647
7648         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
7649                 gtk_cmctree_pre_recursive(ctree, GTK_CMCTREE_NODE(cur->data),
7650                                         GTK_CMCTREE_FUNC(summary_check_watch_thread_func),
7651                                         &found_watch);
7652
7653         if (found_watch)
7654                 summary_unwatch_thread(summaryview);
7655         else
7656                 summary_watch_thread(summaryview);
7657 }
7658
7659 void summary_toggle_show_read_messages(SummaryView *summaryview)
7660 {
7661         FolderItemUpdateData source;
7662         if (summaryview->folder_item->hide_read_msgs)
7663                 summaryview->folder_item->hide_read_msgs = 0;
7664         else
7665                 summaryview->folder_item->hide_read_msgs = 1;
7666
7667         source.item = summaryview->folder_item;
7668         source.update_flags = F_ITEM_UPDATE_NAME;
7669         source.msg = NULL;
7670         hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST, &source);
7671         summary_show(summaryview, summaryview->folder_item);
7672 }
7673
7674 void summary_toggle_show_del_messages(SummaryView *summaryview)
7675 {
7676         FolderItemUpdateData source;
7677         if (summaryview->folder_item->hide_del_msgs)
7678                 summaryview->folder_item->hide_del_msgs = 0;
7679         else
7680                 summaryview->folder_item->hide_del_msgs = 1;
7681
7682         source.item = summaryview->folder_item;
7683         source.update_flags = F_ITEM_UPDATE_NAME;
7684         source.msg = NULL;
7685         hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST, &source);
7686         summary_show(summaryview, summaryview->folder_item);
7687 }
7688
7689 void summary_toggle_show_read_threads(SummaryView *summaryview)
7690 {
7691         FolderItemUpdateData source;
7692         if (summaryview->folder_item->hide_read_threads)
7693                 summaryview->folder_item->hide_read_threads = 0;
7694         else
7695                 summaryview->folder_item->hide_read_threads = 1;
7696
7697         source.item = summaryview->folder_item;
7698         source.update_flags = F_ITEM_UPDATE_NAME;
7699         source.msg = NULL;
7700         hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST, &source);
7701         summary_show(summaryview, summaryview->folder_item);
7702 }
7703
7704 static void summary_set_hide_read_msgs_menu (SummaryView *summaryview,
7705                                              guint action)
7706 {
7707         GtkWidget *widget;
7708
7709         widget = gtk_ui_manager_get_widget(summaryview->mainwin->ui_manager, "/Menu/View/HideReadMessages");
7710         g_object_set_data(G_OBJECT(widget), "dont_toggle",
7711                           GINT_TO_POINTER(1));
7712         gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(widget), action);
7713         g_object_set_data(G_OBJECT(widget), "dont_toggle",
7714                           GINT_TO_POINTER(0));
7715 }
7716
7717 static void summary_set_hide_read_threads_menu (SummaryView *summaryview,
7718                                              guint action)
7719 {
7720         GtkWidget *widget;
7721
7722         widget = gtk_ui_manager_get_widget(summaryview->mainwin->ui_manager, "/Menu/View/HideReadThreads");
7723         g_object_set_data(G_OBJECT(widget), "dont_toggle",
7724                           GINT_TO_POINTER(1));
7725         gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(widget), action);
7726         g_object_set_data(G_OBJECT(widget), "dont_toggle",
7727                           GINT_TO_POINTER(0));
7728 }
7729
7730 static void summary_set_hide_del_msgs_menu (SummaryView *summaryview,
7731                                              guint action)
7732 {
7733         GtkWidget *widget;
7734
7735         widget = gtk_ui_manager_get_widget(summaryview->mainwin->ui_manager, "/Menu/View/HideDelMessages");
7736         g_object_set_data(G_OBJECT(widget), "dont_toggle",
7737                           GINT_TO_POINTER(1));
7738         gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(widget), action);
7739         g_object_set_data(G_OBJECT(widget), "dont_toggle",
7740                           GINT_TO_POINTER(0));
7741 }
7742
7743 void summary_reflect_prefs_pixmap_theme(SummaryView *summaryview)
7744 {
7745         GtkWidget *ctree = summaryview->ctree;
7746         GtkWidget *pixmap;
7747
7748         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_MARK, &markxpm);
7749         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_DELETED, &deletedxpm);
7750         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_NEW, &newxpm);
7751         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_UNREAD, &unreadxpm);
7752         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_REPLIED, &repliedxpm);
7753         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_FORWARDED, &forwardedxpm);
7754         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_CLIP, &clipxpm);
7755         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_LOCKED, &lockedxpm);
7756         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_IGNORETHREAD, &ignorethreadxpm);
7757         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_WATCHTHREAD, &watchthreadxpm);
7758         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_CLIP_KEY, &clipkeyxpm);
7759         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_KEY, &keyxpm);
7760         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_KEY_SIGN, &keysignxpm);
7761         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_GPG_SIGNED, &gpgsignedxpm);
7762         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_CLIP_GPG_SIGNED, &clipgpgsignedxpm);
7763         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_SPAM, &spamxpm);
7764         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_MOVED, &movedxpm);
7765         stock_pixbuf_gdk(ctree, STOCK_PIXMAP_COPIED, &copiedxpm);
7766
7767         summary_set_folder_pixmap(summaryview, STOCK_PIXMAP_DIR_OPEN);
7768
7769         pixmap = stock_pixmap_widget(summaryview->hbox, STOCK_PIXMAP_QUICKSEARCH);
7770         gtk_container_remove (GTK_CONTAINER(summaryview->toggle_search),
7771                               summaryview->quick_search_pixmap);
7772         gtk_container_add(GTK_CONTAINER(summaryview->toggle_search), pixmap);
7773         gtk_widget_show(pixmap);
7774         summaryview->quick_search_pixmap = pixmap;
7775
7776 #ifdef GENERIC_UMPC
7777         pixmap = stock_pixmap_widget(summaryview->hbox, STOCK_PIXMAP_SELECTION);
7778         gtk_container_remove (GTK_CONTAINER(summaryview->multiple_sel_togbtn),
7779                               summaryview->multiple_sel_image);
7780         gtk_container_add(GTK_CONTAINER(summaryview->multiple_sel_togbtn), pixmap);
7781         gtk_widget_show(pixmap);
7782         summaryview->multiple_sel_togbtn = pixmap;
7783 #endif
7784
7785         folderview_unselect(summaryview->folderview);
7786         folderview_select(summaryview->folderview, summaryview->folder_item);
7787         summary_set_column_titles(summaryview);
7788 }
7789
7790 void summary_reflect_prefs_custom_colors(SummaryView *summaryview)
7791 {
7792         GtkMenuShell *menu;
7793         GList *children, *cur;
7794
7795         /* re-create colorlabel submenu */
7796         menu = GTK_MENU_SHELL(summaryview->colorlabel_menu);
7797         cm_return_if_fail(menu != NULL);
7798
7799         /* clear items. get item pointers. */
7800         children = gtk_container_get_children(GTK_CONTAINER(menu));
7801         for (cur = children; cur != NULL && cur->data != NULL; cur = cur->next) {
7802                 g_signal_handlers_disconnect_matched
7803                          (gtk_ui_manager_get_accel_group(summaryview->mainwin->ui_manager),
7804                          G_SIGNAL_MATCH_DATA|G_SIGNAL_MATCH_FUNC,
7805                          0, 0, NULL, mainwin_accel_changed_cb, cur->data);
7806                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(cur->data), NULL);
7807         }
7808         g_list_free(children);
7809         summary_colorlabel_menu_create(summaryview, TRUE);
7810 }
7811
7812 /*
7813  * Harvest addresses for selected messages in summary view.
7814  */
7815 void summary_harvest_address(SummaryView *summaryview)
7816 {
7817         GtkCMCTree *ctree = GTK_CMCTREE( summaryview->ctree );
7818         GList *cur;
7819         GList *msgList;
7820         MsgInfo *msginfo;
7821
7822         msgList = NULL;
7823         for( cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next ) {
7824                 msginfo = gtk_cmctree_node_get_row_data( ctree, GTK_CMCTREE_NODE(cur->data) );
7825                 if (!msginfo)
7826                         continue;
7827                 msgList = g_list_append( msgList, GUINT_TO_POINTER( msginfo->msgnum ) );
7828         }
7829         addressbook_harvest( summaryview->folder_item, TRUE, msgList );
7830         g_list_free( msgList );
7831 }
7832
7833 #ifndef G_OS_WIN32
7834 static regex_t *summary_compile_simplify_regexp(gchar *simplify_subject_regexp)
7835 {
7836         int err;
7837         gchar buf[BUFFSIZE];
7838         regex_t *preg = NULL;
7839
7840         preg = g_new0(regex_t, 1);
7841
7842         err = string_match_precompile(simplify_subject_regexp,
7843                                       preg, REG_EXTENDED);
7844         if (err) {
7845                 regerror(err, preg, buf, BUFFSIZE);
7846                 alertpanel_error(_("Regular expression (regexp) error:\n%s"), buf);
7847                 g_free(preg);
7848                 preg = NULL;
7849         }
7850
7851         return preg;
7852 }
7853 #endif
7854 void summary_set_prefs_from_folderitem(SummaryView *summaryview, FolderItem *item)
7855 {
7856         FolderSortKey sort_key;
7857         FolderSortType sort_type;
7858         cm_return_if_fail(summaryview != NULL);
7859         cm_return_if_fail(item != NULL);
7860
7861         /* Subject simplification */
7862 #ifndef G_OS_WIN32
7863         if(summaryview->simplify_subject_preg) {
7864                 regfree(summaryview->simplify_subject_preg);
7865                 g_free(summaryview->simplify_subject_preg);
7866                 summaryview->simplify_subject_preg = NULL;
7867         }
7868         if(item->prefs && item->prefs->simplify_subject_regexp &&
7869            item->prefs->simplify_subject_regexp[0] && item->prefs->enable_simplify_subject)
7870                 summaryview->simplify_subject_preg = summary_compile_simplify_regexp(item->prefs->simplify_subject_regexp);
7871 #endif
7872         /* Sorting */
7873         sort_key = item->sort_key;
7874         sort_type = item->sort_type;
7875
7876         folder_get_sort_type(item->folder, &sort_key, &sort_type);
7877
7878         summaryview->sort_key = sort_key;
7879         summaryview->sort_type = sort_type;
7880
7881         /* Threading */
7882         summaryview->threaded = item->threaded;
7883         summaryview->thread_collapsed = item->thread_collapsed;
7884
7885         /* Scoring */
7886 }
7887
7888 void summary_save_prefs_to_folderitem(SummaryView *summaryview, FolderItem *item)
7889 {
7890         /* Sorting */
7891         item->sort_key = summaryview->sort_key;
7892         item->sort_type = summaryview->sort_type;
7893
7894         /* Threading */
7895         item->threaded = summaryview->threaded;
7896         item->thread_collapsed = summaryview->thread_collapsed;
7897 }
7898
7899 static gboolean summary_update_msg(gpointer source, gpointer data)
7900 {
7901         MsgInfoUpdate *msginfo_update = (MsgInfoUpdate *) source;
7902         SummaryView *summaryview = (SummaryView *)data;
7903         GtkCMCTreeNode *node;
7904
7905         cm_return_val_if_fail(msginfo_update != NULL, TRUE);
7906         cm_return_val_if_fail(summaryview != NULL, FALSE);
7907
7908         if (msginfo_update->msginfo->folder != summaryview->folder_item)
7909                 return FALSE;
7910
7911         if (msginfo_update->flags & MSGINFO_UPDATE_FLAGS) {
7912                 node = gtk_cmctree_find_by_row_data(
7913                                 GTK_CMCTREE(summaryview->ctree), NULL,
7914                                 msginfo_update->msginfo);
7915
7916                 if (node)
7917                         summary_set_row_marks(summaryview, node);
7918         }
7919
7920         return FALSE;
7921 }
7922
7923 void summary_update_unread(SummaryView *summaryview, FolderItem *removed_item)
7924 {
7925         guint new, unread, unreadmarked, marked, total;
7926         guint replied, forwarded, locked, ignored, watched;
7927         static gboolean tips_initialized = FALSE;
7928 #if !(GTK_CHECK_VERSION(2,12,0))
7929         GtkTooltips *tips = summaryview->tooltips;
7930 #endif
7931
7932         if (prefs_common.layout_mode != SMALL_LAYOUT) {
7933                 if (tips_initialized) {
7934                         summary_set_folder_pixmap(summaryview, STOCK_PIXMAP_DIR_OPEN);
7935                         CLAWS_SET_TIP(summaryview->folder_pixmap_eventbox,
7936                              NULL);
7937                         tips_initialized = FALSE;
7938                 }
7939                 return;
7940         }
7941         folder_count_total_msgs(&new, &unread, &unreadmarked, &marked, &total,
7942                                 &replied, &forwarded, &locked, &ignored,
7943                                 &watched);
7944         if (removed_item) {
7945                 total -= removed_item->total_msgs;
7946                 new -= removed_item->new_msgs;
7947                 unread -= removed_item->unread_msgs;
7948         }
7949
7950         if (new > 0 || unread > 0) {
7951                 tips_initialized = TRUE;
7952                 summary_set_folder_pixmap(summaryview, STOCK_PIXMAP_DIR_OPEN_HRM);
7953                 CLAWS_SET_TIP(summaryview->folder_pixmap_eventbox,
7954                              _("Go back to the folder list (You have unread messages)"));
7955         } else {
7956                 tips_initialized = TRUE;
7957                 summary_set_folder_pixmap(summaryview, STOCK_PIXMAP_DIR_OPEN);
7958                 CLAWS_SET_TIP(summaryview->folder_pixmap_eventbox,
7959                              _("Go back to the folder list"));
7960         }
7961 }
7962
7963 static gboolean summary_update_folder_item_hook(gpointer source, gpointer data)
7964 {
7965         FolderItemUpdateData *hookdata = (FolderItemUpdateData *)source;
7966         SummaryView *summaryview = (SummaryView *)data;
7967
7968         cm_return_val_if_fail(hookdata != NULL, FALSE);
7969         cm_return_val_if_fail(hookdata->item != NULL, FALSE);
7970         cm_return_val_if_fail(summaryview != NULL, FALSE);
7971
7972         if (hookdata->update_flags & F_ITEM_UPDATE_NAME) {
7973                 gchar *name = folder_item_get_name(hookdata->item);
7974                 gtk_label_set_text(GTK_LABEL(summaryview->statlabel_folder), name);
7975                 g_free(name);
7976         }
7977         summary_update_unread(summaryview, NULL);
7978
7979         return FALSE;
7980 }
7981
7982 static gboolean summary_update_folder_hook(gpointer source, gpointer data)
7983 {
7984         FolderUpdateData *hookdata;
7985         SummaryView *summaryview = (SummaryView *)data;
7986         hookdata = source;
7987         if (hookdata->update_flags & FOLDER_REMOVE_FOLDERITEM)
7988                 summary_update_unread(summaryview, hookdata->item);
7989         else
7990                 summary_update_unread(summaryview, NULL);
7991
7992         return FALSE;
7993 }
7994
7995 /*!
7996  *\brief        change summaryview to display your answer(s) to a message
7997  *
7998  *\param        summaryview The SummaryView ;)
7999  *\param        msginfo The message for which answers are searched
8000  *
8001  */
8002 static void summary_find_answers (SummaryView *summaryview, MsgInfo *msg)
8003 {
8004         FolderItem *sent_folder = NULL;
8005         PrefsAccount *account = NULL;
8006         GtkCMCTreeNode *node = NULL;
8007         char *buf = NULL;
8008         if (msg == NULL || msg->msgid == NULL)
8009                 return;
8010
8011         account = account_get_reply_account(msg, prefs_common.reply_account_autosel);
8012         if (account == NULL)
8013                 return;
8014         sent_folder = account_get_special_folder
8015                                 (account, F_OUTBOX);
8016
8017         buf = g_strdup_printf("inreplyto matchcase \"%s\"", msg->msgid);
8018
8019         if (sent_folder != summaryview->folder_item) {
8020                 folderview_select(summaryview->mainwin->folderview, sent_folder);
8021         }
8022
8023         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(summaryview->toggle_search), TRUE);
8024
8025         quicksearch_set(summaryview->quicksearch, QUICK_SEARCH_EXTENDED, buf);
8026         g_free(buf);
8027
8028         node = gtk_cmctree_node_nth(GTK_CMCTREE(summaryview->ctree), 0);
8029         if (node)
8030                 summary_select_node(summaryview, node, TRUE, TRUE);
8031 }
8032
8033 gint summaryview_export_mbox_list(SummaryView *summaryview)
8034 /* return values: -2 skipped, -1 error, 0 OK */
8035 {
8036         GSList *list = summary_get_selected_msg_list(summaryview);
8037         gchar *mbox = filesel_select_file_save(_("Export to mbox file"), NULL);
8038         gint ret;
8039
8040         if (mbox == NULL)
8041                 return -2;
8042         if (list == NULL)
8043                 return -1;
8044
8045         ret = export_list_to_mbox(list, mbox);
8046
8047         g_slist_free(list);
8048         g_free(mbox);
8049
8050         return ret;
8051 }
8052
8053 void summaryview_lock(SummaryView *summaryview, FolderItem *item)
8054 {
8055         if (!summaryview || !summaryview->folder_item || !item) {
8056                 return;
8057         }
8058
8059         if (summaryview->folder_item->folder == item->folder) {
8060                 gtk_widget_set_sensitive(summaryview->ctree, FALSE);
8061         }
8062 }
8063 void summaryview_unlock(SummaryView *summaryview, FolderItem *item)
8064 {
8065         gtk_widget_set_sensitive(summaryview->ctree, TRUE);
8066 }