src/summaryview.c

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