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         gtk_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->text[GTK_STATE_NORMAL] =
 890                         summaryview->color_marked;
 891                 bold_deleted_style = gtk_style_copy(bold_style);
 892                 bold_deleted_style->text[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, ALERTFOCUS_FIRST);
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, ALERTFOCUS_SECOND);
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, ALERTFOCUS_SECOND);
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, ALERTFOCUS_SECOND);
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, ALERTFOCUS_SECOND);
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, ALERTFOCUS_SECOND);
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, ALERTFOCUS_SECOND);
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, ALERTFOCUS_SECOND);
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, ALERTFOCUS_SECOND);
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, ALERTFOCUS_FIRST,
4209                           TRUE, NULL, ALERT_QUESTION);
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, ALERTFOCUS_FIRST,
4248                           TRUE, NULL, ALERT_QUESTION);
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, ALERTFOCUS_SECOND);
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         GtkCMCTreeNode *node;
4823
4824         if (!summaryview->folder_item) return;
4825
4826         if (GTK_CMCLIST(summaryview->ctree)->focus_row < 0) {
4827                 /* If no row is selected, select (but do not open) the first
4828                  * row, to get summaryview into correct state for selecting all. */
4829                 debug_print("summary_select_all: no row selected, selecting first one\n");
4830                 if (GTK_CMCLIST(summaryview->ctree)->row_list != NULL) {
4831                         node = gtk_cmctree_node_nth(GTK_CMCTREE(summaryview->ctree), 0);
4832                         summary_select_node(summaryview, node, FALSE);
4833                 }
4834         }
4835
4836         /* Now select all rows while locking the summaryview for
4837          * faster performance. */
4838         summary_lock(summaryview);
4839         gtk_cmclist_select_all(GTK_CMCLIST(summaryview->ctree));
4840         summary_unlock(summaryview);
4841
4842         summary_status_show(summaryview);
4843 }
4844
4845 void summary_unselect_all(SummaryView *summaryview)
4846 {
4847         summary_lock(summaryview);
4848         gtk_sctree_unselect_all(GTK_SCTREE(summaryview->ctree));
4849         summary_unlock(summaryview);
4850         summary_status_show(summaryview);
4851 }
4852
4853 void summary_select_thread(SummaryView *summaryview, gboolean delete_thread,
4854                            gboolean trash_thread)
4855 {
4856         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
4857         GtkCMCTreeNode *node = NULL;
4858         gboolean froze = FALSE;
4859         GList *cur = NULL;
4860         GList *copy = NULL;
4861         if (!GTK_CMCLIST(summaryview->ctree)->selection)
4862                 return;
4863
4864
4865         START_LONG_OPERATION(summaryview, FALSE);
4866         copy = g_list_copy(GTK_CMCLIST(summaryview->ctree)->selection);
4867         for (cur = copy; cur != NULL && cur->data != NULL;
4868              cur = cur->next) {
4869                 node = GTK_CMCTREE_NODE(cur->data);
4870                 if (!node)
4871                         continue;
4872                 while (GTK_CMCTREE_ROW(node)->parent != NULL)
4873                         node = GTK_CMCTREE_ROW(node)->parent;
4874
4875                 gtk_cmctree_select_recursive(ctree, node);
4876         }
4877         g_list_free(copy);
4878         END_LONG_OPERATION(summaryview);
4879
4880         if (trash_thread) {
4881                 if (FOLDER_TYPE(summaryview->folder_item->folder) == F_NEWS)
4882                         summary_delete(summaryview);
4883                 else
4884                         summary_delete_trash(summaryview);
4885         } else if (delete_thread)
4886                 summary_delete(summaryview);
4887
4888         summary_status_show(summaryview);
4889 }
4890
4891 void summary_save_as(SummaryView *summaryview)
4892 {
4893         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
4894         MsgInfo *msginfo;
4895         gchar *filename = NULL;
4896         gchar *src, *dest;
4897         gchar *tmp;
4898
4899         AlertValue aval = 0;
4900
4901         if (!summaryview->selected) return;
4902         msginfo = gtk_cmctree_node_get_row_data(ctree, summaryview->selected);
4903         if (!msginfo) return;
4904
4905         if (msginfo->subject) {
4906                 Xstrdup_a(filename, msginfo->subject, return);
4907                 subst_for_filename(filename);
4908         }
4909
4910         manage_window_focus_in(summaryview->window, NULL, NULL);
4911
4912         if (filename && !g_utf8_validate(filename, -1, NULL)) {
4913                 gchar *oldstr = filename;
4914                 filename = conv_codeset_strdup(filename,
4915                                                conv_get_locale_charset_str(),
4916                                                CS_UTF_8);
4917                 if (!filename) {
4918                         g_warning("summary_save_as(): failed to convert character set.");
4919                         filename = g_strdup(oldstr);
4920                 }
4921                 dest = filesel_select_file_save(_("Save as"), filename);
4922                 g_free(filename);
4923         } else
4924                 dest = filesel_select_file_save(_("Save as"), filename);
4925         filename = NULL;
4926         if (!dest) return;
4927         if (is_file_exist(dest)) {
4928                 aval = alertpanel(_("Append or Overwrite"),
4929                                   _("Append or overwrite existing file?"),
4930                                   _("_Append"), _("_Overwrite"), GTK_STOCK_CANCEL,
4931                                         ALERTFOCUS_FIRST);
4932                 if (aval != 0 && aval != 1)
4933                         return;
4934         }
4935
4936         src = procmsg_get_message_file(msginfo);
4937         tmp = g_path_get_basename(dest);
4938
4939         if ( aval==0 ) { /* append */
4940                 if (append_file(src, dest, TRUE) < 0)
4941                         alertpanel_error(_("Couldn't save the file '%s'."), tmp);
4942         } else { /* overwrite */
4943                 if (copy_file(src, dest, TRUE) < 0)
4944                         alertpanel_error(_("Couldn't save the file '%s'."), tmp);
4945         }
4946         g_free(src);
4947
4948         /*
4949          * If two or more msgs are selected,
4950          * append them to the output file.
4951          */
4952         if (GTK_CMCLIST(ctree)->selection->next) {
4953                 GList *item;
4954                 for (item = GTK_CMCLIST(ctree)->selection->next; item != NULL; item=item->next) {
4955                         msginfo = gtk_cmctree_node_get_row_data(ctree, GTK_CMCTREE_NODE(item->data));
4956                         if (!msginfo) break;
4957                         src = procmsg_get_message_file(msginfo);
4958                         if (append_file(src, dest, TRUE) < 0)
4959                                 alertpanel_error(_("Couldn't save the file '%s'."), tmp);
4960                 }
4961                 g_free(src);
4962         }
4963         g_free(dest);
4964         g_free(tmp);
4965 }
4966
4967 void summary_print(SummaryView *summaryview)
4968 {
4969         GtkCMCList *clist = GTK_CMCLIST(summaryview->ctree);
4970         GList *cur;
4971         gchar *msg = g_strdup_printf(_("You are about to print %d "
4972                                        "messages, one by one. Do you "
4973                                        "want to continue?"),
4974                                        g_list_length(clist->selection));
4975         if (g_list_length(clist->selection) > 9
4976         &&  alertpanel(_("Warning"), msg, GTK_STOCK_CANCEL, GTK_STOCK_YES,
4977                 NULL, ALERTFOCUS_SECOND) != G_ALERTALTERNATE) {
4978                 g_free(msg);
4979                 return;
4980         }
4981         g_free(msg);
4982
4983         if (clist->selection == NULL) return;
4984         for (cur = clist->selection;
4985              cur != NULL && cur->data != NULL;
4986              cur = cur->next) {
4987                 GtkCMCTreeNode *node = GTK_CMCTREE_NODE(cur->data);
4988                 MsgInfo *msginfo = gtk_cmctree_node_get_row_data(
4989                                         GTK_CMCTREE(summaryview->ctree),
4990                                         node);
4991                 gint sel_start = -1, sel_end = -1, partnum = 0;
4992
4993                 if (node == summaryview->displayed) {
4994                         partnum = mimeview_get_selected_part_num(summaryview->messageview->mimeview);
4995                         textview_get_selection_offsets(summaryview->messageview->mimeview->textview,
4996                                 &sel_start, &sel_end);
4997                 }
4998                 messageview_print(msginfo, summaryview->messageview->all_headers,
4999                         sel_start, sel_end, partnum);
5000         }
5001 }
5002
5003 gboolean summary_execute(SummaryView *summaryview)
5004 {
5005         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5006         GtkCMCList *clist = GTK_CMCLIST(summaryview->ctree);
5007         GtkCMCTreeNode *node, *next;
5008         GtkCMCTreeNode *new_selected = NULL;
5009         gint move_val = -1;
5010
5011         if (!summaryview->folder_item) return FALSE;
5012
5013         if (summary_is_locked(summaryview)) return FALSE;
5014         summary_lock(summaryview);
5015
5016         summary_freeze(summaryview);
5017
5018         main_window_cursor_wait(summaryview->mainwin);
5019
5020         if (summaryview->threaded)
5021                 summary_unthread_for_exec(summaryview);
5022
5023         folder_item_update_freeze();
5024         move_val = summary_execute_move(summaryview);
5025         summary_execute_copy(summaryview);
5026         summary_execute_delete(summaryview);
5027
5028         node = GTK_CMCTREE_NODE(clist->row_list);
5029         for (; node != NULL; node = next) {
5030                 next = gtkut_ctree_node_next(ctree, node);
5031                 if (gtk_cmctree_node_get_row_data(ctree, node) != NULL) continue;
5032
5033                 if (node == summaryview->displayed) {
5034                         messageview_clear(summaryview->messageview);
5035                         summary_cancel_mark_read_timeout(summaryview);
5036                         summaryview->displayed = NULL;
5037                 }
5038                 if (GTK_CMCTREE_ROW(node)->children != NULL) {
5039                         next = NULL;
5040                         if (GTK_CMCTREE_ROW(node)->sibling) {
5041                                 next = GTK_CMCTREE_ROW(node)->sibling;
5042                         } else {
5043                                 GtkCMCTreeNode *parent = NULL;
5044                                 for (parent = GTK_CMCTREE_ROW(node)->parent; parent != NULL;
5045                                      parent = GTK_CMCTREE_ROW(parent)->parent) {
5046                                         if (GTK_CMCTREE_ROW(parent)->sibling) {
5047                                                 next = GTK_CMCTREE_ROW(parent)->sibling;
5048                                         }
5049                                 }
5050                         }
5051                 }
5052
5053                 if (!new_selected &&
5054                     gtkut_ctree_node_is_selected(ctree, node)) {
5055                         summary_unselect_all(summaryview);
5056                         if (summaryview->sort_type == SORT_ASCENDING) {
5057                                 new_selected = summary_find_next_msg(summaryview, node,TRUE);
5058                                 if (!new_selected || prefs_common.next_on_delete == FALSE)
5059                                         new_selected = summary_find_prev_msg(summaryview, node,TRUE);
5060                         } else {
5061                                 new_selected = summary_find_prev_msg(summaryview, node,TRUE);
5062                                 if (!new_selected || prefs_common.next_on_delete == FALSE)
5063                                         new_selected = summary_find_next_msg(summaryview, node,TRUE);
5064                         }
5065                 }
5066
5067                 gtk_sctree_remove_node((GtkSCTree *)ctree, node);
5068         }
5069
5070         folder_item_update_thaw();
5071
5072         if (new_selected) {
5073                 summary_unlock(summaryview);
5074                 summary_select_node(summaryview, new_selected, OPEN_SELECTED_ON_DELETEMOVE);
5075                 summary_lock(summaryview);
5076         }
5077
5078         if (summaryview->threaded) {
5079                 summary_thread_build(summaryview);
5080                 summary_thread_init(summaryview);
5081         }
5082
5083         summary_thaw(summaryview);
5084
5085         summaryview->selected = clist->selection ?
5086                 GTK_CMCTREE_NODE(clist->selection->data) : NULL;
5087
5088         if (!GTK_CMCLIST(summaryview->ctree)->row_list) {
5089                 menu_set_insensitive_all
5090                         (GTK_MENU_SHELL(summaryview->popupmenu));
5091                 folderview_grab_focus(summaryview->folderview);
5092         } else {
5093                 menu_set_sensitive_all(GTK_MENU_SHELL(summaryview->popupmenu), TRUE);
5094                 gtk_widget_grab_focus(summaryview->ctree);
5095         }
5096         summary_update_status(summaryview);
5097         summary_status_show(summaryview);
5098
5099         gtk_cmctree_node_moveto(ctree, summaryview->selected, 0, 0.5, 0);
5100
5101         summary_unlock(summaryview);
5102
5103         main_window_cursor_normal(summaryview->mainwin);
5104
5105         if (move_val < 0)
5106                 summary_show(summaryview, summaryview->folder_item);
5107         return TRUE;
5108 }
5109
5110 gboolean summary_expunge(SummaryView *summaryview)
5111 {
5112         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5113         GtkCMCList *clist = GTK_CMCLIST(summaryview->ctree);
5114         GtkCMCTreeNode *node, *next;
5115         GtkCMCTreeNode *new_selected = NULL;
5116
5117         if (!summaryview->folder_item) return FALSE;
5118
5119         if (summary_is_locked(summaryview)) return FALSE;
5120
5121         summary_lock(summaryview);
5122
5123         summary_freeze(summaryview);
5124
5125         main_window_cursor_wait(summaryview->mainwin);
5126
5127         if (summaryview->threaded)
5128                 summary_unthread_for_exec(summaryview);
5129
5130         folder_item_update_freeze();
5131         summary_execute_expunge(summaryview);
5132
5133         node = GTK_CMCTREE_NODE(clist->row_list);
5134         for (; node != NULL; node = next) {
5135                 next = gtkut_ctree_node_next(ctree, node);
5136                 if (gtk_cmctree_node_get_row_data(ctree, node) != NULL) continue;
5137
5138                 if (node == summaryview->displayed) {
5139                         messageview_clear(summaryview->messageview);
5140                         summary_cancel_mark_read_timeout(summaryview);
5141                         summaryview->displayed = NULL;
5142                 }
5143                 if (GTK_CMCTREE_ROW(node)->children != NULL) {
5144                         next = NULL;
5145                         if (GTK_CMCTREE_ROW(node)->sibling) {
5146                                 next = GTK_CMCTREE_ROW(node)->sibling;
5147                         } else {
5148                                 GtkCMCTreeNode *parent = NULL;
5149                                 for (parent = GTK_CMCTREE_ROW(node)->parent; parent != NULL;
5150                                      parent = GTK_CMCTREE_ROW(parent)->parent) {
5151                                         if (GTK_CMCTREE_ROW(parent)->sibling) {
5152                                                 next = GTK_CMCTREE_ROW(parent)->sibling;
5153                                         }
5154                                 }
5155                         }
5156                 }
5157
5158                 if (!new_selected &&
5159                     gtkut_ctree_node_is_selected(ctree, node)) {
5160                         summary_unselect_all(summaryview);
5161                         new_selected = summary_find_next_msg(summaryview, node,TRUE);
5162                         if (!new_selected)
5163                                 new_selected = summary_find_prev_msg
5164                                         (summaryview, node,TRUE);
5165                 }
5166
5167                 gtk_sctree_remove_node((GtkSCTree *)ctree, node);
5168         }
5169
5170         folder_item_update_thaw();
5171
5172         if (new_selected) {
5173                 summary_unlock(summaryview);
5174                 summary_select_node(summaryview, new_selected, OPEN_SELECTED_ON_DELETEMOVE);
5175                 summary_lock(summaryview);
5176         }
5177
5178         if (summaryview->threaded) {
5179                 summary_thread_build(summaryview);
5180                 summary_thread_init(summaryview);
5181         }
5182
5183         summary_thaw(summaryview);
5184
5185         summaryview->selected = clist->selection ?
5186                 GTK_CMCTREE_NODE(clist->selection->data) : NULL;
5187
5188         if (!GTK_CMCLIST(summaryview->ctree)->row_list) {
5189                 menu_set_insensitive_all
5190                         (GTK_MENU_SHELL(summaryview->popupmenu));
5191                 folderview_grab_focus(summaryview->folderview);
5192         } else {
5193                 menu_set_sensitive_all(GTK_MENU_SHELL(summaryview->popupmenu), TRUE);
5194                 gtk_widget_grab_focus(summaryview->ctree);
5195         }
5196
5197         summary_update_status(summaryview);
5198         summary_status_show(summaryview);
5199
5200         gtk_cmctree_node_moveto(ctree, summaryview->selected, 0, 0.5, 0);
5201
5202         summary_unlock(summaryview);
5203
5204         main_window_cursor_normal(summaryview->mainwin);
5205
5206         return TRUE;
5207 }
5208
5209 static gint summary_execute_move(SummaryView *summaryview)
5210 {
5211         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5212         GSList *cur;
5213         gint val = -1;
5214         /* search moving messages and execute */
5215
5216         gtk_cmctree_pre_recursive(ctree, NULL, summary_execute_move_func,
5217                         summaryview);
5218
5219         if (summaryview->mlist) {
5220                 hooks_unregister_hook(MSGINFO_UPDATE_HOOKLIST,
5221                         summaryview->msginfo_update_callback_id);
5222                 val = procmsg_move_messages(summaryview->mlist);
5223                 summaryview->msginfo_update_callback_id =
5224                 hooks_register_hook(MSGINFO_UPDATE_HOOKLIST,
5225                         summary_update_msg, (gpointer) summaryview);
5226
5227                 for (cur = summaryview->mlist; cur != NULL && cur->data != NULL; cur = cur->next) {
5228                         procmsg_msginfo_free((MsgInfo **)&(cur->data));
5229                 }
5230
5231                 g_slist_free(summaryview->mlist);
5232                 summaryview->mlist = NULL;
5233                 return val;
5234         }
5235         return 0;
5236 }
5237
5238 static void summary_execute_move_func(GtkCMCTree *ctree, GtkCMCTreeNode *node,
5239                                       gpointer data)
5240 {
5241         SummaryView *summaryview = data;
5242         MsgInfo *msginfo;
5243
5244         msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(node);
5245
5246         if (msginfo && MSG_IS_MOVE(msginfo->flags) && msginfo->to_folder) {
5247                 summaryview->mlist =
5248                         g_slist_prepend(summaryview->mlist, msginfo);
5249                 gtk_cmctree_node_set_row_data(ctree, node, NULL);
5250
5251                 if (msginfo->msgid && *msginfo->msgid &&
5252                     node == g_hash_table_lookup(summaryview->msgid_table,
5253                                                 msginfo->msgid))
5254                         g_hash_table_remove(summaryview->msgid_table,
5255                                             msginfo->msgid);
5256                 if (prefs_common.thread_by_subject &&
5257                     msginfo->subject && *msginfo->subject &&
5258                     node == subject_table_lookup(summaryview->subject_table,
5259                                                  msginfo->subject)) {
5260                         subject_table_remove(summaryview->subject_table,
5261                                              msginfo->subject);
5262                 }
5263         }
5264 }
5265
5266 static void summary_execute_copy(SummaryView *summaryview)
5267 {
5268         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5269
5270         /* search copying messages and execute */
5271         hooks_unregister_hook(MSGINFO_UPDATE_HOOKLIST,
5272                 summaryview->msginfo_update_callback_id);
5273         gtk_cmctree_pre_recursive(ctree, NULL, summary_execute_copy_func,
5274                                 summaryview);
5275
5276         if (summaryview->mlist) {
5277                 summaryview->mlist = g_slist_reverse(summaryview->mlist);
5278                 procmsg_copy_messages(summaryview->mlist);
5279
5280                 g_slist_free(summaryview->mlist);
5281                 summaryview->mlist = NULL;
5282         }
5283         summaryview->msginfo_update_callback_id =
5284                 hooks_register_hook(MSGINFO_UPDATE_HOOKLIST,
5285                         summary_update_msg, (gpointer) summaryview);
5286 }
5287
5288 static void summary_execute_copy_func(GtkCMCTree *ctree, GtkCMCTreeNode *node,
5289                                       gpointer data)
5290 {
5291         SummaryView *summaryview = data;
5292         MsgInfo *msginfo;
5293
5294         msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(node);
5295
5296         if (msginfo && MSG_IS_COPY(msginfo->flags) && msginfo->to_folder) {
5297                 summaryview->mlist =
5298                         g_slist_prepend(summaryview->mlist, msginfo);
5299
5300                 summary_msginfo_unset_flags(msginfo, 0, MSG_COPY);
5301                 summary_set_row_marks(summaryview, node);
5302         }
5303 }
5304
5305 static void summary_execute_delete(SummaryView *summaryview)
5306 {
5307         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5308         GSList *cur;
5309
5310         /* search deleting messages and execute */
5311         gtk_cmctree_pre_recursive
5312                 (ctree, NULL, summary_execute_delete_func, summaryview);
5313
5314         if (!summaryview->mlist) return;
5315
5316         hooks_unregister_hook(MSGINFO_UPDATE_HOOKLIST,
5317                 summaryview->msginfo_update_callback_id);
5318
5319         folder_item_remove_msgs(summaryview->folder_item,
5320                                 summaryview->mlist);
5321
5322         summaryview->msginfo_update_callback_id =
5323                 hooks_register_hook(MSGINFO_UPDATE_HOOKLIST,
5324                         summary_update_msg, (gpointer) summaryview);
5325
5326         for (cur = summaryview->mlist; cur != NULL && cur->data != NULL; cur = cur->next) {
5327                         procmsg_msginfo_free((MsgInfo **)&(cur->data));
5328         }
5329
5330         g_slist_free(summaryview->mlist);
5331         summaryview->mlist = NULL;
5332 }
5333
5334 static void summary_execute_delete_func(GtkCMCTree *ctree, GtkCMCTreeNode *node,
5335                                         gpointer data)
5336 {
5337         SummaryView *summaryview = data;
5338         MsgInfo *msginfo;
5339
5340         msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(node);
5341
5342         if (msginfo && MSG_IS_DELETED(msginfo->flags)) {
5343                 summaryview->mlist =
5344                         g_slist_prepend(summaryview->mlist, msginfo);
5345                 gtk_cmctree_node_set_row_data(ctree, node, NULL);
5346
5347                 if (msginfo->msgid && *msginfo->msgid &&
5348                     node == g_hash_table_lookup(summaryview->msgid_table,
5349                                                 msginfo->msgid)) {
5350                         g_hash_table_remove(summaryview->msgid_table,
5351                                             msginfo->msgid);
5352                 }
5353                 if (prefs_common.thread_by_subject &&
5354                     msginfo->subject && *msginfo->subject &&
5355                     node == subject_table_lookup(summaryview->subject_table,
5356                                                  msginfo->subject)) {
5357                         subject_table_remove(summaryview->subject_table,
5358                                              msginfo->subject);
5359                 }
5360         }
5361 }
5362
5363 static void summary_execute_expunge_func(GtkCMCTree *ctree, GtkCMCTreeNode *node,
5364                                         gpointer data)
5365 {
5366         SummaryView *summaryview = data;
5367         MsgInfo *msginfo;
5368
5369         msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(node);
5370
5371         if (msginfo && MSG_IS_DELETED(msginfo->flags)) {
5372                 summaryview->mlist =
5373                         g_slist_prepend(summaryview->mlist, msginfo);
5374                 gtk_cmctree_node_set_row_data(ctree, node, NULL);
5375
5376                 if (msginfo->msgid && *msginfo->msgid &&
5377                     node == g_hash_table_lookup(summaryview->msgid_table,
5378                                                 msginfo->msgid)) {
5379                         g_hash_table_remove(summaryview->msgid_table,
5380                                             msginfo->msgid);
5381                 }
5382                 if (prefs_common.thread_by_subject &&
5383                     msginfo->subject && *msginfo->subject &&
5384                     node == subject_table_lookup(summaryview->subject_table,
5385                                                  msginfo->subject)) {
5386                         subject_table_remove(summaryview->subject_table,
5387                                              msginfo->subject);
5388                 }
5389         }
5390 }
5391
5392 static void summary_execute_expunge(SummaryView *summaryview)
5393 {
5394         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5395         GSList *cur;
5396
5397         gtk_cmctree_pre_recursive
5398                 (ctree, NULL, summary_execute_expunge_func, summaryview);
5399
5400         hooks_unregister_hook(MSGINFO_UPDATE_HOOKLIST,
5401                 summaryview->msginfo_update_callback_id);
5402
5403         folder_item_expunge(summaryview->folder_item);
5404
5405         summaryview->msginfo_update_callback_id =
5406                 hooks_register_hook(MSGINFO_UPDATE_HOOKLIST,
5407                         summary_update_msg, (gpointer) summaryview);
5408         for (cur = summaryview->mlist; cur != NULL && cur->data != NULL; cur = cur->next)
5409                 procmsg_msginfo_free((MsgInfo **)&(cur->data));
5410
5411         g_slist_free(summaryview->mlist);
5412         summaryview->mlist = NULL;
5413 }
5414
5415 /* thread functions */
5416
5417 static void summary_thread_build(SummaryView *summaryview)
5418 {
5419         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5420         GtkCMCTreeNode *node;
5421         GtkCMCTreeNode *next;
5422         GtkCMCTreeNode *parent;
5423         MsgInfo *msginfo;
5424         GSList *reflist;
5425
5426         summary_lock(summaryview);
5427
5428         debug_print("Building threads...\n");
5429         STATUSBAR_PUSH(summaryview->mainwin, _("Building threads..."));
5430         main_window_cursor_wait(summaryview->mainwin);
5431
5432         g_signal_handlers_block_by_func(G_OBJECT(ctree),
5433                                        G_CALLBACK(summary_tree_expanded), summaryview);
5434         summary_freeze(summaryview);
5435
5436         node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
5437         while (node) {
5438                 next = GTK_CMCTREE_ROW(node)->sibling;
5439
5440                 msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(node);
5441
5442                 parent = NULL;
5443
5444                 if (msginfo && msginfo->inreplyto) {
5445                         parent = g_hash_table_lookup(summaryview->msgid_table,
5446                                                      msginfo->inreplyto);
5447
5448                         if (!parent && msginfo->references) {
5449                                 for (reflist = msginfo->references;
5450                                      reflist != NULL; reflist = reflist->next)
5451                                         if ((parent = g_hash_table_lookup
5452                                                 (summaryview->msgid_table,
5453                                                  reflist->data)))
5454                                                 break;
5455                         }
5456                 }
5457
5458                 if (msginfo && prefs_common.thread_by_subject && parent == NULL) {
5459                         parent = subject_table_lookup
5460                                 (summaryview->subject_table,
5461                                  msginfo->subject);
5462                 }
5463
5464                 if (parent && parent != node && parent != GTK_CMCTREE_ROW(node)->parent) {
5465                         gtk_cmctree_move(ctree, node, parent, NULL);
5466                 }
5467
5468                 node = next;
5469         }
5470
5471         gtkut_ctree_set_focus_row(ctree, summaryview->selected);
5472
5473         summary_thaw(summaryview);
5474         g_signal_handlers_unblock_by_func(G_OBJECT(ctree),
5475                                          G_CALLBACK(summary_tree_expanded), summaryview);
5476
5477         debug_print("Building threads done.\n");
5478         STATUSBAR_POP(summaryview->mainwin);
5479         main_window_cursor_normal(summaryview->mainwin);
5480
5481         summaryview->threaded = TRUE;
5482
5483         summary_unlock(summaryview);
5484 }
5485
5486 static void summary_thread_init(SummaryView *summaryview)
5487 {
5488         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5489         GtkCMCTreeNode *node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
5490         GtkCMCTreeNode *next;
5491         START_TIMING("");
5492         if (!summaryview->thread_collapsed) {
5493                 g_signal_handlers_block_by_func(G_OBJECT(ctree),
5494                                        G_CALLBACK(summary_tree_expanded), summaryview);
5495                 while (node) {
5496                         next = GTK_CMCTREE_ROW(node)->sibling;
5497                         if (GTK_CMCTREE_ROW(node)->children)
5498                                 gtk_cmctree_expand_recursive(ctree, node);
5499                         node = next;
5500                 }
5501                 g_signal_handlers_unblock_by_func(G_OBJECT(ctree),
5502                                        G_CALLBACK(summary_tree_expanded), summaryview);
5503         }
5504         END_TIMING();
5505 }
5506
5507 static void summary_unthread_for_exec(SummaryView *summaryview)
5508 {
5509         GtkCMCTreeNode *node;
5510         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5511         gboolean froze = FALSE;
5512
5513         debug_print("Unthreading for execution...\n");
5514
5515         START_LONG_OPERATION(summaryview, TRUE);
5516         for (node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
5517              node != NULL; node = GTK_CMCTREE_NODE_NEXT(node)) {
5518                 summary_unthread_for_exec_func(ctree, node, summaryview);
5519         }
5520
5521         END_LONG_OPERATION(summaryview);
5522
5523         debug_print("Unthreading for execution done.\n");
5524 }
5525
5526 static void summary_unthread_for_exec_func(GtkCMCTree *ctree, GtkCMCTreeNode *node,
5527                                            gpointer data)
5528 {
5529         MsgInfo *msginfo;
5530         GtkCMCTreeNode *top_parent;
5531         GtkCMCTreeNode *child;
5532         GtkCMCTreeNode *sibling;
5533         SummaryView * summaryview = (SummaryView *)data;
5534         msginfo = GTKUT_CTREE_NODE_GET_ROW_DATA(node);
5535
5536         if (!msginfo ||
5537             (!MSG_IS_MOVE(msginfo->flags) &&
5538              !MSG_IS_DELETED(msginfo->flags)))
5539                 return;
5540         child = GTK_CMCTREE_ROW(node)->children;
5541         if (!child) return;
5542
5543         if (node == summaryview->selected)
5544                 summaryview->selected = NULL;
5545         if (node == summaryview->displayed)
5546                 summaryview->displayed = NULL;
5547
5548         summary_cancel_mark_read_timeout(summaryview);
5549
5550         for (top_parent = node;
5551              GTK_CMCTREE_ROW(top_parent)->parent != NULL;
5552              top_parent = GTK_CMCTREE_ROW(top_parent)->parent)
5553                 ;
5554         sibling = GTK_CMCTREE_ROW(top_parent)->sibling;
5555
5556         GTK_SCTREE(ctree)->sorting = TRUE;
5557         while (child != NULL) {
5558                 GtkCMCTreeNode *next_child;
5559                 MsgInfo *cinfo = GTKUT_CTREE_NODE_GET_ROW_DATA(child);
5560
5561                 next_child = GTK_CMCTREE_ROW(child)->sibling;
5562
5563                 if (!MSG_IS_MOVE(cinfo->flags) && !MSG_IS_DELETED(cinfo->flags)) {
5564                         gtk_cmctree_move(ctree, child,
5565                                 NULL,
5566                                 sibling);
5567                 } else {
5568                         if (child == summaryview->displayed) {
5569                                 messageview_clear(summaryview->messageview);
5570                                 summaryview->displayed = NULL;
5571                         }
5572                         if (child == summaryview->selected) {
5573                                 messageview_clear(summaryview->messageview);
5574                                 summaryview->selected = NULL;
5575                         }
5576                 }
5577                 child = next_child;
5578         }
5579         GTK_SCTREE(ctree)->sorting = FALSE;
5580 }
5581
5582 void summary_expand_threads(SummaryView *summaryview)
5583 {
5584         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5585         GtkCMCTreeNode *node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
5586         GtkCMCTreeNode *focus_node = GTK_CMCTREE_NODE (g_list_nth (GTK_CMCLIST(ctree)->row_list, GTK_CMCLIST(ctree)->focus_row));
5587
5588         g_signal_handlers_block_by_func(G_OBJECT(ctree),
5589                                        G_CALLBACK(summary_tree_expanded), summaryview);
5590         summary_freeze(summaryview);
5591         GTK_SCTREE(ctree)->sorting = TRUE;
5592
5593         while (node) {
5594                 if (GTK_CMCTREE_ROW(node)->children) {
5595                         gtk_cmctree_expand(ctree, node);
5596                         summary_set_row_marks(summaryview, node);
5597                 }
5598                 node = GTK_CMCTREE_NODE_NEXT(node);
5599         }
5600
5601         GTK_SCTREE(ctree)->sorting = FALSE;
5602         if (focus_node) {
5603                 GTK_CMCLIST(ctree)->focus_row = g_list_position (GTK_CMCLIST(ctree)->row_list,(GList *)focus_node);
5604         }
5605         summary_thaw(summaryview);
5606
5607         g_signal_handlers_unblock_by_func(G_OBJECT(ctree),
5608                                          G_CALLBACK(summary_tree_expanded), summaryview);
5609
5610         summaryview->thread_collapsed = FALSE;
5611
5612         gtk_cmctree_node_moveto(ctree, summaryview->selected, 0, 0.5, 0);
5613 }
5614
5615 void summary_collapse_threads(SummaryView *summaryview)
5616 {
5617         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5618         GtkCMCTreeNode *node = NULL;
5619         GtkCMCTreeNode *focus_node = GTK_CMCTREE_NODE (g_list_nth (GTK_CMCLIST(ctree)->row_list, GTK_CMCLIST(ctree)->focus_row));
5620
5621         g_signal_handlers_block_by_func(G_OBJECT(ctree),
5622                                        G_CALLBACK(summary_tree_collapsed), summaryview);
5623         summary_freeze(summaryview);
5624         GTK_SCTREE(ctree)->sorting = TRUE;
5625
5626         node = focus_node;
5627         while (node && GTK_CMCTREE_ROW(node)->parent) {
5628                 focus_node = node = GTK_CMCTREE_ROW(node)->parent;
5629         }
5630         summary_select_node(summaryview, node, OPEN_SELECTED_ON_DIRECTIONAL);
5631         node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
5632         while (node) {
5633                 if (GTK_CMCTREE_ROW(node)->children) {
5634                         gtk_cmctree_collapse(ctree, node);
5635                         summary_set_row_marks(summaryview, node);
5636                 }
5637                 node = GTK_CMCTREE_ROW(node)->sibling;
5638         }
5639
5640         GTK_SCTREE(ctree)->sorting = FALSE;
5641         if (focus_node) {
5642                 GTK_CMCLIST(ctree)->focus_row = g_list_position (GTK_CMCLIST(ctree)->row_list,(GList *)focus_node);
5643         }
5644         GTK_SCTREE(ctree)->anchor_row =
5645                         gtk_cmctree_node_nth(ctree, GTK_CMCLIST(ctree)->focus_row);
5646         summary_thaw(summaryview);
5647         g_signal_handlers_unblock_by_func(G_OBJECT(ctree),
5648                                          G_CALLBACK(summary_tree_collapsed), summaryview);
5649
5650         summaryview->thread_collapsed = TRUE;
5651
5652         gtk_cmctree_node_moveto(ctree, summaryview->selected, 0, 0.5, 0);
5653 }
5654
5655 static void account_rules_radio_button_toggled_cb(GtkToggleButton *btn, gpointer data)
5656 {
5657         prefs_common.apply_per_account_filtering_rules = GPOINTER_TO_INT(data);
5658 }
5659
5660 static gboolean summary_filter_get_mode(void)
5661 /* ask what to do w/ them: skip them, apply them regardless to the account,
5662    use the current account */
5663 {
5664         /* TODO: eventually also propose to use the current folder's default account,
5665            if it is set */
5666         /* TODO: eventually allow to select the account to use from a optmenu */
5667
5668         GtkWidget *vbox;
5669         GtkWidget *account_rules_skip;
5670         GtkWidget *account_rules_force;
5671         GtkWidget *account_rules_user_current;
5672         AlertValue val;
5673
5674         vbox = gtk_vbox_new (FALSE, 0);
5675
5676         account_rules_skip = gtk_radio_button_new_with_label
5677                                                         (NULL, _("Skip these rules"));
5678         account_rules_force = gtk_radio_button_new_with_label_from_widget
5679                                                         (GTK_RADIO_BUTTON(account_rules_skip),
5680                                                         _("Apply these rules regardless of the account they belong to"));
5681         account_rules_user_current = gtk_radio_button_new_with_label_from_widget
5682                                                         (GTK_RADIO_BUTTON(account_rules_skip),
5683                                                         _("Apply these rules if they apply to the current account"));
5684         gtk_box_pack_start (GTK_BOX (vbox), account_rules_skip, FALSE, FALSE, 0);
5685         gtk_box_pack_start (GTK_BOX (vbox), account_rules_force, FALSE, FALSE, 0);
5686         gtk_box_pack_start (GTK_BOX (vbox), account_rules_user_current, FALSE, FALSE, 0);
5687         g_signal_connect(G_OBJECT(account_rules_skip), "toggled",
5688                         G_CALLBACK(account_rules_radio_button_toggled_cb),
5689                         GINT_TO_POINTER(FILTERING_ACCOUNT_RULES_SKIP));
5690         g_signal_connect(G_OBJECT(account_rules_force), "toggled",
5691                         G_CALLBACK(account_rules_radio_button_toggled_cb),
5692                         GINT_TO_POINTER(FILTERING_ACCOUNT_RULES_FORCE));
5693         g_signal_connect(G_OBJECT(account_rules_user_current), "toggled",
5694                         G_CALLBACK(account_rules_radio_button_toggled_cb),
5695                         GINT_TO_POINTER(FILTERING_ACCOUNT_RULES_USE_CURRENT));
5696         switch (prefs_common.apply_per_account_filtering_rules) {
5697         case FILTERING_ACCOUNT_RULES_SKIP:
5698                 gtk_toggle_button_set_active(
5699                                 GTK_TOGGLE_BUTTON(account_rules_skip), TRUE);
5700                 break;
5701         case FILTERING_ACCOUNT_RULES_FORCE:
5702                 gtk_toggle_button_set_active(
5703                                 GTK_TOGGLE_BUTTON(account_rules_force), TRUE);
5704                 break;
5705         case FILTERING_ACCOUNT_RULES_USE_CURRENT:
5706                 gtk_toggle_button_set_active(
5707                                 GTK_TOGGLE_BUTTON(account_rules_user_current), TRUE);
5708                 break;
5709         }
5710
5711         val = alertpanel_with_widget(
5712                         _("Filtering"),
5713                         _("There are some filtering rules that belong to an account.\n"
5714                           "Please choose what to do with these rules:"),
5715                         GTK_STOCK_CANCEL, _("_Filter"), NULL, ALERTFOCUS_SECOND,
5716                         TRUE, vbox);
5717
5718         if ((val & ~G_ALERTDISABLE) != G_ALERTALTERNATE) {
5719                 return FALSE;
5720         } else if (val & G_ALERTDISABLE)
5721                 prefs_common.ask_apply_per_account_filtering_rules = FALSE;
5722
5723         return TRUE;
5724 }
5725
5726 void summary_filter(SummaryView *summaryview, gboolean selected_only)
5727 {
5728         GSList *mlist = NULL, *cur_list;
5729         summary_lock(summaryview);
5730
5731         /* are there any per-account filtering rules? */
5732         if (prefs_common.ask_apply_per_account_filtering_rules == TRUE &&
5733                 filtering_peek_per_account_rules(filtering_rules)) {
5734
5735                 if (summary_filter_get_mode() == FALSE) {
5736                         summary_unlock(summaryview);
5737                         return;
5738                 }
5739         }
5740
5741         folder_item_update_freeze();
5742
5743         debug_print("filtering...\n");
5744         STATUSBAR_PUSH(summaryview->mainwin, _("Filtering..."));
5745         main_window_cursor_wait(summaryview->mainwin);
5746
5747         summary_freeze(summaryview);
5748
5749         if (selected_only) {
5750                 GList *cur;
5751
5752                 for (cur = GTK_CMCLIST(summaryview->ctree)->selection;
5753                      cur != NULL && cur->data != NULL; cur = cur->next) {
5754                         mlist = g_slist_prepend(mlist,
5755                                  procmsg_msginfo_new_ref(
5756                                   GTKUT_CTREE_NODE_GET_ROW_DATA(cur->data)));
5757                 }
5758                 mlist = g_slist_reverse(mlist);
5759         } else {
5760                 mlist = folder_item_get_msg_list(summaryview->folder_item);
5761         }
5762
5763         folder_item_set_batch(summaryview->folder_item, TRUE);
5764         for (cur_list = mlist; cur_list; cur_list = cur_list->next) {
5765                 summary_filter_func((MsgInfo *)cur_list->data);
5766         }
5767         folder_item_set_batch(summaryview->folder_item, FALSE);
5768
5769         filtering_move_and_copy_msgs(mlist);
5770
5771         for (cur_list = mlist; cur_list; cur_list = cur_list->next) {
5772                 procmsg_msginfo_free((MsgInfo **)&(cur_list->data));
5773         }
5774         g_slist_free(mlist);
5775
5776         summary_thaw(summaryview);
5777
5778         folder_item_update_thaw();
5779         debug_print("filtering done.\n");
5780         STATUSBAR_POP(summaryview->mainwin);
5781         main_window_cursor_normal(summaryview->mainwin);
5782
5783         summary_unlock(summaryview);
5784
5785         /*
5786          * CLAWS: summary_show() only valid after having a lock. ideally
5787          * we want the lock to be context aware...
5788          */
5789         summary_show(summaryview, summaryview->folder_item);
5790 }
5791
5792 static void summary_filter_func(MsgInfo *msginfo)
5793 {
5794         MailFilteringData mail_filtering_data;
5795
5796         mail_filtering_data.msginfo = msginfo;
5797         mail_filtering_data.msglist = NULL;
5798         mail_filtering_data.filtered = NULL;
5799         mail_filtering_data.unfiltered = NULL;
5800         if (hooks_invoke(MAIL_MANUAL_FILTERING_HOOKLIST, &mail_filtering_data))
5801                 return;
5802
5803         filter_message_by_msginfo(filtering_rules, msginfo, NULL,
5804                         FILTERING_MANUALLY, NULL);
5805 }
5806
5807 void summary_msginfo_filter_open(FolderItem * item, MsgInfo *msginfo,
5808                                  PrefsFilterType type, gint processing_rule)
5809 {
5810         gchar *header = NULL;
5811         gchar *key = NULL;
5812
5813         procmsg_get_filter_keyword(msginfo, &header, &key, type);
5814
5815         if (processing_rule) {
5816                 if (item == NULL)
5817                         prefs_filtering_open(&pre_global_processing,
5818                                              _("Processing rules to apply before folder rules"),
5819                                              MANUAL_ANCHOR_PROCESSING,
5820                                              header, key, FALSE);
5821                 else
5822                         prefs_filtering_open(&item->prefs->processing,
5823                                              _("Processing configuration"),
5824                                              MANUAL_ANCHOR_PROCESSING,
5825                                              header, key, FALSE);
5826         }
5827         else {
5828                 prefs_filtering_open(&filtering_rules,
5829                                 _("Filtering configuration"),
5830                                 MANUAL_ANCHOR_FILTERING,
5831                                 header, key, TRUE);
5832         }
5833
5834         g_free(header);
5835         g_free(key);
5836 }
5837
5838 void summary_filter_open(SummaryView *summaryview, PrefsFilterType type,
5839                          gint processing_rule)
5840 {
5841         MsgInfo *msginfo;
5842         FolderItem * item;
5843
5844         if (!summaryview->selected) return;
5845
5846         msginfo = gtk_cmctree_node_get_row_data(GTK_CMCTREE(summaryview->ctree),
5847                                               summaryview->selected);
5848         if (!msginfo) return;
5849
5850         item = summaryview->folder_item;
5851         summary_msginfo_filter_open(item, msginfo, type, processing_rule);
5852 }
5853
5854 /* color label */
5855
5856 #define N_COLOR_LABELS colorlabel_get_color_count()
5857
5858 static void summary_colorlabel_menu_item_activate_cb(GtkWidget *widget,
5859                                                      gpointer data)
5860 {
5861         guint color = GPOINTER_TO_UINT(data);
5862         SummaryView *summaryview;
5863
5864         summaryview = g_object_get_data(G_OBJECT(widget), "summaryview");
5865         cm_return_if_fail(summaryview != NULL);
5866
5867         /* "dont_toggle" state set? */
5868         if (g_object_get_data(G_OBJECT(summaryview->colorlabel_menu),
5869                                 "dont_toggle"))
5870                 return;
5871
5872         summary_set_colorlabel(summaryview, color, NULL);
5873 }
5874
5875 /* summary_set_colorlabel_color() - labelcolor parameter is the color *flag*
5876  * for the messsage; not the color index */
5877 void summary_set_colorlabel_color(GtkCMCTree *ctree, GtkCMCTreeNode *node,
5878                                   guint labelcolor)
5879 {
5880         GdkColor color;
5881         GtkStyle *style, *prev_style, *ctree_style;
5882         MsgInfo *msginfo;
5883         gint color_index;
5884
5885         msginfo = gtk_cmctree_node_get_row_data(ctree, node);
5886         cm_return_if_fail(msginfo);
5887
5888         color_index = labelcolor == 0 ? -1 : (gint)labelcolor - 1;
5889         ctree_style = gtk_widget_get_style(GTK_WIDGET(ctree));
5890         prev_style = gtk_cmctree_node_get_row_style(ctree, node);
5891
5892         if (color_index < 0 || color_index >= N_COLOR_LABELS) {
5893                 if (!prev_style) return;
5894                 style = gtk_style_copy(prev_style);
5895                 color = ctree_style->text[GTK_STATE_NORMAL];
5896                 style->text[GTK_STATE_NORMAL] = color;
5897                 color = ctree_style->text[GTK_STATE_SELECTED];
5898                 style->text[GTK_STATE_SELECTED] = color;
5899         } else {
5900                 if (prev_style)
5901                         style = gtk_style_copy(prev_style);
5902                 else
5903                         style = gtk_style_copy(ctree_style);
5904                 color = colorlabel_get_color(color_index);
5905                 style->text[GTK_STATE_NORMAL] = color;
5906                 /* get the average of label color and selected fg color
5907                    for visibility */
5908                 style->text[GTK_STATE_SELECTED].red   = (color.red   + 3*ctree_style->text[GTK_STATE_SELECTED].red  ) / 4;
5909                 style->text[GTK_STATE_SELECTED].green = (color.green + 3*ctree_style->text[GTK_STATE_SELECTED].green) / 4;
5910                 style->text[GTK_STATE_SELECTED].blue  = (color.blue  + 3*ctree_style->text[GTK_STATE_SELECTED].blue ) / 4;
5911         }
5912
5913         gtk_cmctree_node_set_row_style(ctree, node, style);
5914         g_object_unref(style);
5915 }
5916
5917 static void summary_set_row_colorlabel(SummaryView *summaryview, GtkCMCTreeNode *row, guint labelcolor)
5918 {
5919         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5920         MsgInfo *msginfo;
5921
5922         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
5923         cm_return_if_fail(msginfo);
5924
5925         summary_msginfo_change_flags(msginfo, MSG_COLORLABEL_TO_FLAGS(labelcolor), 0,
5926                                         MSG_CLABEL_FLAG_MASK, 0);
5927         summary_set_row_marks(summaryview, row);
5928 }
5929
5930 void summary_set_colorlabel(SummaryView *summaryview, guint labelcolor,
5931                             GtkWidget *widget)
5932 {
5933         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5934         GList *cur;
5935         gboolean froze = FALSE;
5936
5937         START_LONG_OPERATION(summaryview, FALSE);
5938         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
5939                 summary_set_row_colorlabel(summaryview,
5940                                            GTK_CMCTREE_NODE(cur->data), labelcolor);
5941         END_LONG_OPERATION(summaryview);
5942 }
5943
5944 static gboolean summary_set_row_tag(SummaryView *summaryview, GtkCMCTreeNode *row, gboolean refresh, gboolean set, gint id)
5945 {
5946         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5947         MsgInfo *msginfo;
5948         gchar *tags_str = NULL;
5949         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
5950         cm_return_val_if_fail(msginfo, FALSE);
5951
5952         procmsg_msginfo_update_tags(msginfo, set, id);
5953
5954         if (summaryview->col_state[summaryview->col_pos[S_COL_TAGS]].visible) {
5955                 tags_str = procmsg_msginfo_get_tags_str(msginfo);
5956                 gtk_cmctree_node_set_text(ctree, row,
5957                                 summaryview->col_pos[S_COL_TAGS],
5958                                 tags_str?tags_str:"-");
5959                 g_free(tags_str);
5960         }
5961
5962         summary_set_row_marks(summaryview, row);
5963         if (row == summaryview->displayed) {
5964                 return TRUE;
5965         }
5966         return FALSE;
5967 }
5968
5969 void summary_set_tag(SummaryView *summaryview, gint tag_id,
5970                             GtkWidget *widget)
5971 {
5972         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
5973         GList *cur;
5974         gboolean set = tag_id > 0;
5975         gint real_id = set? tag_id:-tag_id;
5976         gboolean froze = FALSE;
5977         gboolean redisplay = FALSE;
5978
5979         if (summary_is_locked(summaryview))
5980                 return;
5981         START_LONG_OPERATION(summaryview, FALSE);
5982         folder_item_set_batch(summaryview->folder_item, TRUE);
5983         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next) {
5984                 redisplay |= summary_set_row_tag(summaryview,
5985                                            GTK_CMCTREE_NODE(cur->data), FALSE, set, real_id);
5986         }
5987         folder_item_set_batch(summaryview->folder_item, FALSE);
5988         END_LONG_OPERATION(summaryview);
5989         if (redisplay)
5990                 summary_redisplay_msg(summaryview);
5991 }
5992
5993 static void summary_tags_menu_item_activate_cb(GtkWidget *widget,
5994                                                      gpointer data)
5995 {
5996         gint id = GPOINTER_TO_INT(data);
5997         gboolean set = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));
5998         SummaryView *summaryview;
5999
6000         summaryview = g_object_get_data(G_OBJECT(widget), "summaryview");
6001         cm_return_if_fail(summaryview != NULL);
6002
6003         /* "dont_toggle" state set? */
6004         if (g_object_get_data(G_OBJECT(summaryview->tags_menu),
6005                                 "dont_toggle"))
6006                 return;
6007
6008         if (!set)
6009                 id = -id;
6010         summary_set_tag(summaryview, id, NULL);
6011 }
6012
6013 static void summary_colorlabel_menu_item_activate_item_cb(GtkMenuItem *menu_item,
6014                                                           gpointer data)
6015 {
6016         SummaryView *summaryview;
6017         GtkMenuShell *menu;
6018         GtkCheckMenuItem **items;
6019         gint n;
6020         GList *children, *cur, *sel;
6021
6022         summaryview = (SummaryView *)data;
6023         cm_return_if_fail(summaryview != NULL);
6024
6025         sel = GTK_CMCLIST(summaryview->ctree)->selection;
6026         if (!sel) return;
6027
6028         menu = GTK_MENU_SHELL(summaryview->colorlabel_menu);
6029
6030         cm_return_if_fail(menu != NULL);
6031
6032         Xalloca(items, (N_COLOR_LABELS + 1) * sizeof(GtkWidget *), return);
6033
6034         /* NOTE: don't return prematurely because we set the "dont_toggle"
6035          * state for check menu items */
6036         g_object_set_data(G_OBJECT(menu), "dont_toggle",
6037                           GINT_TO_POINTER(1));
6038
6039         /* clear items. get item pointers. */
6040         children = gtk_container_get_children(GTK_CONTAINER(menu));
6041         for (n = 0, cur = children; cur != NULL && cur->data != NULL; cur = cur->next) {
6042                 if (GTK_IS_CHECK_MENU_ITEM(cur->data)) {
6043                         gtk_check_menu_item_set_active
6044                                 (GTK_CHECK_MENU_ITEM(cur->data), FALSE);
6045                         items[n] = GTK_CHECK_MENU_ITEM(cur->data);
6046                         n++;
6047                 }
6048         }
6049
6050         g_list_free(children);
6051
6052         if (n == (N_COLOR_LABELS + 1)) {
6053                 /* iterate all messages and set the state of the appropriate
6054                  * items */
6055                 for (; sel != NULL; sel = sel->next) {
6056                         MsgInfo *msginfo;
6057                         gint clabel;
6058
6059                         msginfo = gtk_cmctree_node_get_row_data
6060                                 (GTK_CMCTREE(summaryview->ctree),
6061                                  GTK_CMCTREE_NODE(sel->data));
6062                         if (msginfo) {
6063                                 clabel = MSG_GET_COLORLABEL_VALUE(msginfo->flags);
6064                                 if (!gtk_check_menu_item_get_active(items[clabel]))
6065                                         gtk_check_menu_item_set_active
6066                                                 (items[clabel], TRUE);
6067                         }
6068                 }
6069         } else
6070                 g_warning("invalid number of color elements (%d)", n);
6071
6072         /* reset "dont_toggle" state */
6073         g_object_set_data(G_OBJECT(menu), "dont_toggle",
6074                           GINT_TO_POINTER(0));
6075 }
6076
6077 static void summary_colorlabel_menu_create(SummaryView *summaryview, gboolean refresh)
6078 {
6079         GtkWidget *label_menuitem;
6080         GtkWidget *menu;
6081         GtkWidget *item;
6082         gint i;
6083         gchar *accel_path = NULL;
6084
6085         label_menuitem = gtk_ui_manager_get_widget(summaryview->mainwin->ui_manager, "/Menus/SummaryViewPopup/ColorLabel");
6086         g_signal_connect(G_OBJECT(label_menuitem), "activate",
6087                          G_CALLBACK(summary_colorlabel_menu_item_activate_item_cb),
6088                            summaryview);
6089         gtk_widget_show(label_menuitem);
6090
6091         menu = gtk_menu_new();
6092
6093         gtk_menu_set_accel_group (GTK_MENU (menu),
6094                 gtk_ui_manager_get_accel_group(mainwindow_get_mainwindow()->ui_manager));
6095
6096         /* create sub items. for the menu item activation callback we pass the
6097          * index of label_colors[] as data parameter. for the None color we
6098          * pass an invalid (high) value. also we attach a data pointer so we
6099          * can always get back the SummaryView pointer. */
6100
6101         item = gtk_check_menu_item_new_with_label(_("None"));
6102         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
6103         g_signal_connect(G_OBJECT(item), "activate",
6104                          G_CALLBACK(summary_colorlabel_menu_item_activate_cb),
6105                            GUINT_TO_POINTER(0));
6106         g_object_set_data(G_OBJECT(item), "summaryview", summaryview);
6107         gtk_widget_show(item);
6108
6109         accel_path = g_strdup_printf("<ClawsColorLabels>/None");
6110         gtk_menu_item_set_accel_path(GTK_MENU_ITEM(item), accel_path);
6111         g_free(accel_path);
6112         gtk_accel_map_add_entry("<ClawsColorLabels>/None", GDK_KEY_0, GDK_CONTROL_MASK);
6113
6114         item = gtk_menu_item_new();
6115         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
6116         gtk_widget_show(item);
6117
6118         /* create pixmap/label menu items */
6119         for (i = 0; i < N_COLOR_LABELS; i++) {
6120                 item = colorlabel_create_check_color_menu_item(
6121                         i, refresh, SUMMARY_COLORMENU);
6122                 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
6123                 g_signal_connect(G_OBJECT(item), "activate",
6124                                  G_CALLBACK(summary_colorlabel_menu_item_activate_cb),
6125                                  GUINT_TO_POINTER(i + 1));
6126                 g_object_set_data(G_OBJECT(item), "summaryview",
6127                                   summaryview);
6128                 gtk_widget_show(item);
6129                 accel_path = g_strdup_printf("<ClawsColorLabels>/%d", i+1);
6130                 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(item), accel_path);
6131                 if (i < 9)
6132                         gtk_accel_map_add_entry(accel_path, GDK_KEY_1+i, GDK_CONTROL_MASK);
6133                 g_free(accel_path);
6134                 g_signal_connect (gtk_ui_manager_get_accel_group(mainwindow_get_mainwindow()->ui_manager),
6135                         "accel-changed", G_CALLBACK (mainwin_accel_changed_cb), item);
6136         }
6137
6138         gtk_widget_show(menu);
6139         gtk_menu_item_set_submenu(GTK_MENU_ITEM(label_menuitem), menu);
6140         summaryview->colorlabel_menu = menu;
6141 }
6142
6143 static void summary_tags_menu_item_activate_item_cb(GtkMenuItem *menu_item,
6144                                                           gpointer data)
6145 {
6146         GtkMenuShell *menu;
6147         GList *children, *cur;
6148         GList *sel;
6149         GHashTable *menu_table = g_hash_table_new_full(
6150                                         g_direct_hash,
6151                                         g_direct_equal,
6152                                         NULL, NULL);
6153         GHashTable *menu_allsel_table = g_hash_table_new_full(
6154                                         g_direct_hash,
6155                                         g_direct_equal,
6156                                         NULL, NULL);
6157         gint sel_len;
6158         SummaryView *summaryview = (SummaryView *)data;
6159         cm_return_if_fail(summaryview != NULL);
6160
6161         sel = GTK_CMCLIST(summaryview->ctree)->selection;
6162         if (!sel) return;
6163
6164         menu = GTK_MENU_SHELL(summaryview->tags_menu);
6165         cm_return_if_fail(menu != NULL);
6166
6167         /* NOTE: don't return prematurely because we set the "dont_toggle"
6168          * state for check menu items */
6169         g_object_set_data(G_OBJECT(menu), "dont_toggle",
6170                           GINT_TO_POINTER(1));
6171
6172         /* clear items. get item pointers. */
6173         children = gtk_container_get_children(GTK_CONTAINER(menu));
6174         for (cur = children; cur != NULL && cur->data != NULL; cur = cur->next) {
6175                 if (GTK_IS_CHECK_MENU_ITEM(cur->data)) {
6176                         gint id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cur->data),
6177                                 "tag_id"));
6178                         gtk_check_menu_item_set_active
6179                                 (GTK_CHECK_MENU_ITEM(cur->data), FALSE);
6180
6181                         g_hash_table_insert(menu_table, GINT_TO_POINTER(id), GTK_CHECK_MENU_ITEM(cur->data));
6182                         g_hash_table_insert(menu_allsel_table, GINT_TO_POINTER(id), GINT_TO_POINTER(0));
6183                 }
6184         }
6185
6186         g_list_free(children);
6187
6188         /* iterate all messages and set the state of the appropriate
6189          * items */
6190         sel_len = 0;
6191         for (; sel != NULL; sel = sel->next) {
6192                 MsgInfo *msginfo;
6193                 GSList *tags = NULL;
6194                 GtkCheckMenuItem *item;
6195                 msginfo = gtk_cmctree_node_get_row_data
6196                         (GTK_CMCTREE(summaryview->ctree),
6197                          GTK_CMCTREE_NODE(sel->data));
6198                 sel_len++;
6199                 if (msginfo) {
6200                         tags =  msginfo->tags;
6201                         if (!tags)
6202                                 continue;
6203
6204                         for (; tags; tags = tags->next) {
6205                                 gint num_checked = GPOINTER_TO_INT(g_hash_table_lookup(menu_allsel_table, tags->data));
6206                                 item = g_hash_table_lookup(menu_table, GINT_TO_POINTER(tags->data));
6207                                 if (item && !gtk_check_menu_item_get_active(item)) {
6208                                         gtk_check_menu_item_set_active
6209                                                 (item, TRUE);
6210                                 }
6211                                 num_checked++;
6212                                 g_hash_table_replace(menu_allsel_table, tags->data, GINT_TO_POINTER(num_checked));
6213                         }
6214                 }
6215         }
6216
6217         children = gtk_container_get_children(GTK_CONTAINER(menu));
6218         for (cur = children; cur != NULL && cur->data != NULL; cur = cur->next) {
6219                 if (GTK_IS_CHECK_MENU_ITEM(cur->data)) {
6220                         gint id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(cur->data),
6221                                 "tag_id"));
6222                         gint num_checked = GPOINTER_TO_INT(g_hash_table_lookup(menu_allsel_table, GINT_TO_POINTER(id)));
6223                         if (num_checked < sel_len && num_checked > 0)
6224                                 gtk_check_menu_item_set_inconsistent(GTK_CHECK_MENU_ITEM(cur->data), TRUE);
6225                         else
6226                                 gtk_check_menu_item_set_inconsistent(GTK_CHECK_MENU_ITEM(cur->data), FALSE);
6227                 }
6228         }
6229         g_list_free(children);
6230         g_hash_table_destroy(menu_table);
6231         g_hash_table_destroy(menu_allsel_table);
6232         /* reset "dont_toggle" state */
6233         g_object_set_data(G_OBJECT(menu), "dont_toggle",
6234                           GINT_TO_POINTER(0));
6235 }
6236
6237 void summaryview_destroy(SummaryView *summaryview)
6238 {
6239         if(summaryview->simplify_subject_preg) {
6240                 regfree(summaryview->simplify_subject_preg);
6241                 g_free(summaryview->simplify_subject_preg);
6242                 summaryview->simplify_subject_preg = NULL;
6243         }
6244 }
6245 static void summary_tags_menu_item_apply_tags_activate_cb(GtkWidget *widget,
6246                                                      gpointer data)
6247 {
6248         SummaryView *summaryview;
6249
6250         summaryview = g_object_get_data(G_OBJECT(widget), "summaryview");
6251         cm_return_if_fail(summaryview != NULL);
6252
6253         /* "dont_toggle" state set? */
6254         if (g_object_get_data(G_OBJECT(summaryview->tags_menu),
6255                                 "dont_toggle"))
6256                 return;
6257
6258         tag_apply_open(summary_get_selection(summaryview));
6259 }
6260
6261 static gint summary_tag_cmp_list(gconstpointer a, gconstpointer b)
6262 {
6263         gint id_a = GPOINTER_TO_INT(a);
6264         gint id_b = GPOINTER_TO_INT(b);
6265         const gchar *tag_a = tags_get_tag(id_a);
6266         const gchar *tag_b = tags_get_tag(id_b);
6267
6268         if (tag_a == NULL)
6269                 return tag_b == NULL ? 0:1;
6270
6271         if (tag_b == NULL)
6272                 return 1;
6273
6274         return g_utf8_collate(tag_a, tag_b);
6275 }
6276
6277 static void summary_tags_menu_create(SummaryView *summaryview, gboolean refresh)
6278 {
6279
6280         GtkWidget *label_menuitem;
6281         GtkWidget *menu;
6282         GtkWidget *item;
6283         GSList *cur = tags_get_list();
6284         GSList *orig = NULL;
6285         gboolean existing_tags = FALSE;
6286         gchar *accel_path = NULL;
6287
6288         cur = orig = g_slist_sort(cur, summary_tag_cmp_list);
6289         label_menuitem = gtk_ui_manager_get_widget(summaryview->mainwin->ui_manager, "/Menus/SummaryViewPopup/Tags");
6290         g_signal_connect(G_OBJECT(label_menuitem), "activate",
6291                          G_CALLBACK(summary_tags_menu_item_activate_item_cb),
6292                            summaryview);
6293
6294         gtk_widget_show(label_menuitem);
6295
6296         menu = gtk_menu_new();
6297
6298         gtk_menu_set_accel_group (GTK_MENU (menu),
6299                 gtk_ui_manager_get_accel_group(summaryview->mainwin->ui_manager));
6300
6301         /* create tags menu items */
6302         for (; cur; cur = cur->next) {
6303                 gint id = GPOINTER_TO_INT(cur->data);
6304                 const gchar *tag = tags_get_tag(id);
6305                 item = gtk_check_menu_item_new_with_label(tag);
6306                 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
6307                 g_signal_connect(G_OBJECT(item), "activate",
6308                                  G_CALLBACK(summary_tags_menu_item_activate_cb),
6309                                  GINT_TO_POINTER(id));
6310                 g_object_set_data(G_OBJECT(item), "summaryview",
6311                                   summaryview);
6312                 g_object_set_data(G_OBJECT(item), "tag_id",
6313                                   GINT_TO_POINTER(id));
6314                 gtk_widget_show(item);
6315                 accel_path = g_strconcat("<ClawsTags>/",tag, NULL);
6316                 gtk_menu_item_set_accel_path(GTK_MENU_ITEM(item), accel_path);
6317                 g_free(accel_path);
6318                 existing_tags = TRUE;
6319         }
6320         if (existing_tags) {
6321                 /* separator */
6322                 item = gtk_menu_item_new();
6323                 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
6324                 gtk_widget_show(item);
6325         }
6326
6327         item = gtk_menu_item_new_with_label(_("Apply tags..."));
6328         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
6329         g_signal_connect(G_OBJECT(item), "activate",
6330                          G_CALLBACK(summary_tags_menu_item_apply_tags_activate_cb),
6331                          NULL);
6332         g_object_set_data(G_OBJECT(item), "summaryview",
6333                           summaryview);
6334         gtk_widget_show(item);
6335         accel_path = g_strdup_printf("<ClawsTags>/ApplyTags");
6336         gtk_menu_item_set_accel_path(GTK_MENU_ITEM(item), accel_path);
6337         g_free(accel_path);
6338
6339         g_slist_free(orig);
6340         gtk_widget_show(menu);
6341         gtk_menu_item_set_submenu(GTK_MENU_ITEM(label_menuitem), menu);
6342         summaryview->tags_menu = menu;
6343 }
6344
6345 static gboolean summary_popup_menu(GtkWidget *widget, gpointer data)
6346 {
6347         SummaryView *summaryview = (SummaryView *)data;
6348         summaryview->display_msg = messageview_is_visible(summaryview->messageview);
6349
6350         gtk_menu_popup(GTK_MENU(summaryview->popupmenu),
6351                        NULL, NULL, NULL, NULL,
6352                        3, gtk_get_current_event_time());
6353
6354         return TRUE;
6355 }
6356
6357 #if !GENERIC_UMPC
6358 static gchar *summaryview_get_tooltip_text(SummaryView *summaryview, MsgInfo *info, gint column)
6359 {
6360         MsgFlags flags;
6361         if (!info)
6362                 return NULL;
6363
6364         flags = info->flags;
6365
6366         switch(summaryview->col_state[column].type) {
6367                 case S_COL_STATUS:
6368                         if (MSG_IS_IGNORE_THREAD(flags)) {
6369                                 return _("Ignored thread");
6370                         } else if (MSG_IS_WATCH_THREAD(flags)) {
6371                                 return _("Watched thread");
6372                         } else if (MSG_IS_SPAM(flags)) {
6373                                 return _("Spam");
6374                         } else if (MSG_IS_NEW(flags)) {
6375                                 return _("New");
6376                         } else if (MSG_IS_UNREAD(flags)) {
6377                                 return _("Unread");
6378                         } else if (MSG_IS_REPLIED(flags) && MSG_IS_FORWARDED(flags)) {
6379                                 return _("Replied but also forwarded - click to see reply");
6380                         } else if (MSG_IS_REPLIED(flags)) {
6381                                 return _("Replied - click to see reply");
6382                         } else if (MSG_IS_FORWARDED(flags)) {
6383                                 return _("Forwarded");
6384                         } else {
6385                                 return NULL;
6386                         }
6387                 case S_COL_MARK:
6388                         if (MSG_IS_DELETED(flags)) {
6389                                 return _("Deleted");
6390                         } else if (MSG_IS_MARKED(flags)) {
6391                                 return _("Marked");
6392                         } else if (MSG_IS_MOVE(flags)) {
6393                                 return _("To be moved");
6394                         } else if (MSG_IS_COPY(flags)) {
6395                                 return _("To be copied");
6396                         } else {
6397                                 return NULL;
6398                         }
6399                 case S_COL_LOCKED:
6400                         if (MSG_IS_LOCKED(flags)) {
6401                                 return _("Locked");
6402                         } else {
6403                                 return NULL;
6404                         }
6405                 case S_COL_MIME:
6406                         if (MSG_IS_WITH_ATTACHMENT(flags) && MSG_IS_SIGNED(flags)) {
6407                                 return _("Signed, has attachment(s)");
6408                         } else if (MSG_IS_SIGNED(flags)) {
6409                                 return _("Signed");
6410                         } else if (MSG_IS_WITH_ATTACHMENT(flags) && MSG_IS_ENCRYPTED(flags)) {
6411                                 return _("Encrypted, has attachment(s)");
6412                         } else if (MSG_IS_ENCRYPTED(flags)) {
6413                                 return _("Encrypted");
6414                         } else if (MSG_IS_WITH_ATTACHMENT(flags)) {
6415                                 return _("Has attachment(s)");
6416                         } else {
6417                                 return NULL;
6418                         }
6419                 default:
6420                         return NULL;
6421         }
6422 }
6423 static gboolean tooltip_cb (GtkWidget  *widget,
6424                             gint        x,
6425                             gint        y,
6426                             gboolean    keyboard_mode,
6427                             GtkTooltip *tooltip,
6428                             gpointer    user_data)
6429 {
6430         GtkCMCTree *ctree = GTK_CMCTREE(widget);
6431         SummaryView *summaryview = (SummaryView *)user_data;
6432         gint row = -1, column = -1;
6433         int offset = prefs_common.show_col_headers ? 24:0;
6434         GtkCMCTreeNode *node = NULL;
6435         gchar *text = NULL;
6436         gchar *formatted = NULL;
6437         MsgInfo *info = NULL;
6438         GdkRectangle rect;
6439         gboolean vert_layout = (prefs_common.layout_mode == VERTICAL_LAYOUT);
6440         gboolean small_layout = (prefs_common.layout_mode == SMALL_LAYOUT);
6441         if (!prefs_common.show_tooltips)
6442                 return FALSE;
6443
6444         if (y - offset < 0)
6445                 return FALSE;
6446
6447         if (!gtk_cmclist_get_selection_info(GTK_CMCLIST(ctree), x, y - offset,
6448                                           &row, &column))
6449                 return FALSE;
6450
6451         if ((node = gtk_cmctree_node_nth(ctree, row)) == NULL)
6452                 return FALSE;
6453
6454         if ((info = gtk_cmctree_node_get_row_data(ctree, node)) == NULL)
6455                 return FALSE;
6456
6457         switch (gtk_cmctree_node_get_cell_type(ctree, node, column)) {
6458                 case GTK_CMCELL_TEXT:
6459                         if (gtk_cmctree_node_get_text(ctree, node, column, &text) != TRUE)
6460                                 return FALSE;
6461                         break;
6462                 case GTK_CMCELL_PIXTEXT:
6463                         if (gtk_cmctree_node_get_pixtext(ctree, node, column, &text,
6464                                 NULL, NULL) != TRUE)
6465                                 return FALSE;
6466                         break;
6467                 default:
6468                         if ((text = summaryview_get_tooltip_text(summaryview, info, column)) == NULL)
6469                                 return FALSE;
6470         }
6471
6472         if (!text || !*text)
6473                 return FALSE;
6474
6475         formatted = g_strdup(text);
6476         g_strstrip(formatted);
6477
6478         if ((vert_layout || small_layout) && prefs_common.two_line_vert)
6479                 gtk_tooltip_set_markup (tooltip, formatted);
6480         else
6481                         gtk_tooltip_set_text (tooltip, formatted);
6482         g_free(formatted);
6483
6484         rect.x = x - 2;
6485         rect.y = y - 2;
6486         rect.width = 12;
6487         rect.height= 12;
6488         gtk_tooltip_set_tip_area(tooltip, &rect);
6489
6490         return TRUE;
6491 }
6492 #endif
6493 static GtkWidget *summary_ctree_create(SummaryView *summaryview)
6494 {
6495         GtkWidget *ctree;
6496         gint *col_pos = summaryview->col_pos;
6497         SummaryColumnState *col_state;
6498         gchar *titles[N_SUMMARY_COLS];
6499         SummaryColumnType type;
6500         gint pos;
6501         gboolean vert_layout = (prefs_common.layout_mode == VERTICAL_LAYOUT);
6502         gboolean small_layout = (prefs_common.layout_mode == SMALL_LAYOUT);
6503         memset(titles, 0, sizeof(titles));
6504
6505         col_state = prefs_summary_column_get_config();
6506         for (pos = 0; pos < N_SUMMARY_COLS; pos++) {
6507                 summaryview->col_state[pos] = col_state[pos];
6508                 type = col_state[pos].type;
6509                 col_pos[type] = pos;
6510                 titles[pos] = "dummy";
6511         }
6512         col_state = summaryview->col_state;
6513
6514         ctree = gtk_sctree_new_with_titles
6515                 (N_SUMMARY_COLS, col_pos[S_COL_SUBJECT], titles);
6516
6517         if (prefs_common.show_col_headers == FALSE)
6518                 gtk_cmclist_column_titles_hide(GTK_CMCLIST(ctree));
6519
6520         gtk_cmclist_set_selection_mode(GTK_CMCLIST(ctree), GTK_SELECTION_MULTIPLE);
6521         gtk_cmclist_set_column_justification(GTK_CMCLIST(ctree), col_pos[S_COL_MARK],
6522                                            GTK_JUSTIFY_CENTER);
6523         gtk_cmclist_set_column_justification(GTK_CMCLIST(ctree), col_pos[S_COL_STATUS],
6524                                            GTK_JUSTIFY_CENTER);
6525         gtk_cmclist_set_column_justification(GTK_CMCLIST(ctree), col_pos[S_COL_LOCKED],
6526                                            GTK_JUSTIFY_CENTER);
6527         gtk_cmclist_set_column_justification(GTK_CMCLIST(ctree), col_pos[S_COL_MIME],
6528                                            GTK_JUSTIFY_CENTER);
6529         gtk_cmclist_set_column_justification(GTK_CMCLIST(ctree), col_pos[S_COL_SIZE],
6530                                            GTK_JUSTIFY_RIGHT);
6531         gtk_cmclist_set_column_justification(GTK_CMCLIST(ctree), col_pos[S_COL_NUMBER],
6532                                            GTK_JUSTIFY_RIGHT);
6533         gtk_cmclist_set_column_justification(GTK_CMCLIST(ctree), col_pos[S_COL_SCORE],
6534                                            GTK_JUSTIFY_RIGHT);
6535         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_MARK],
6536                                    prefs_common.summary_col_size[S_COL_MARK]);
6537         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_STATUS],
6538                                    prefs_common.summary_col_size[S_COL_STATUS]);
6539         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_LOCKED],
6540                                    prefs_common.summary_col_size[S_COL_LOCKED]);
6541         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_MIME],
6542                                    prefs_common.summary_col_size[S_COL_MIME]);
6543         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_SUBJECT],
6544                                    prefs_common.summary_col_size[S_COL_SUBJECT]);
6545         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_FROM],
6546                                    prefs_common.summary_col_size[S_COL_FROM]);
6547         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_TO],
6548                                    prefs_common.summary_col_size[S_COL_TO]);
6549         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_DATE],
6550                                    prefs_common.summary_col_size[S_COL_DATE]);
6551         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_SIZE],
6552                                    prefs_common.summary_col_size[S_COL_SIZE]);
6553         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_NUMBER],
6554                                    prefs_common.summary_col_size[S_COL_NUMBER]);
6555         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_SCORE],
6556                                    prefs_common.summary_col_size[S_COL_SCORE]);
6557         gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[S_COL_TAGS],
6558                                    prefs_common.summary_col_size[S_COL_TAGS]);
6559
6560         gtk_cmctree_set_line_style(GTK_CMCTREE(ctree), GTK_CMCTREE_LINES_NONE);
6561         gtk_cmctree_set_expander_style(GTK_CMCTREE(ctree),
6562                              GTK_CMCTREE_EXPANDER_TRIANGLE);
6563
6564         gtk_sctree_set_stripes(GTK_SCTREE(ctree), prefs_common.use_stripes_in_summaries);
6565
6566         gtk_cmctree_set_indent(GTK_CMCTREE(ctree), 12);
6567         g_object_set_data(G_OBJECT(ctree), "summaryview", (gpointer)summaryview);
6568
6569         for (pos = 0; pos < N_SUMMARY_COLS; pos++) {
6570                 gtk_widget_set_can_focus(GTK_CMCLIST(ctree)->column[pos].button,
6571                                        FALSE);
6572                 if (((pos == summaryview->col_pos[S_COL_FROM] && !FOLDER_SHOWS_TO_HDR(summaryview->folder_item)) ||
6573                      (pos == summaryview->col_pos[S_COL_TO] && FOLDER_SHOWS_TO_HDR(summaryview->folder_item)) ||
6574                      pos == summaryview->col_pos[S_COL_DATE]) && (vert_layout || small_layout) &&
6575                             prefs_common.two_line_vert)
6576                         gtk_cmclist_set_column_visibility
6577                                 (GTK_CMCLIST(ctree), pos, FALSE);
6578                 else
6579                         gtk_cmclist_set_column_visibility
6580                                 (GTK_CMCLIST(ctree), pos, col_state[pos].visible);
6581         }
6582         if (prefs_common.two_line_vert)
6583                 gtk_sctree_set_use_markup(GTK_SCTREE(ctree), summaryview->col_pos[S_COL_SUBJECT], vert_layout||small_layout);
6584
6585         /* connect signal to the buttons for sorting */
6586 #define CLIST_BUTTON_SIGNAL_CONNECT(col, func) \
6587         g_signal_connect \
6588                 (G_OBJECT(GTK_CMCLIST(ctree)->column[col_pos[col]].button), \
6589                  "clicked", \
6590                  G_CALLBACK(func), \
6591                  summaryview)
6592
6593         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_MARK   , summary_mark_clicked);
6594         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_STATUS , summary_status_clicked);
6595         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_MIME   , summary_mime_clicked);
6596         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_NUMBER , summary_num_clicked);
6597         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_SIZE   , summary_size_clicked);
6598         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_DATE   , summary_date_clicked);
6599         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_FROM   , summary_from_clicked);
6600         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_TO     , summary_to_clicked);
6601         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_SUBJECT, summary_subject_clicked);
6602         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_SCORE,   summary_score_clicked);
6603         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_LOCKED,  summary_locked_clicked);
6604         CLIST_BUTTON_SIGNAL_CONNECT(S_COL_TAGS,    summary_tags_clicked);
6605
6606 #undef CLIST_BUTTON_SIGNAL_CONNECT
6607
6608         g_signal_connect(G_OBJECT(ctree), "tree_select_row",
6609                          G_CALLBACK(summary_selected), summaryview);
6610         g_signal_connect(G_OBJECT(ctree), "tree_unselect_row",
6611                          G_CALLBACK(summary_unselected), summaryview);
6612         g_signal_connect(G_OBJECT(ctree), "button_press_event",
6613                          G_CALLBACK(summary_button_pressed),
6614                          summaryview);
6615         g_signal_connect(G_OBJECT(ctree), "popup-menu",
6616                          G_CALLBACK(summary_popup_menu), summaryview);
6617         g_signal_connect(G_OBJECT(ctree), "button_release_event",
6618                          G_CALLBACK(summary_button_released),
6619                          summaryview);
6620         g_signal_connect(G_OBJECT(ctree), "key_press_event",
6621                          G_CALLBACK(summary_key_pressed), summaryview);
6622         g_signal_connect(G_OBJECT(ctree), "resize_column",
6623                          G_CALLBACK(summary_col_resized), summaryview);
6624         g_signal_connect(G_OBJECT(ctree), "open_row",
6625                          G_CALLBACK(summary_open_row), summaryview);
6626
6627         g_signal_connect_after(G_OBJECT(ctree), "tree_expand",
6628                                G_CALLBACK(summary_tree_expanded),
6629                                summaryview);
6630         g_signal_connect_after(G_OBJECT(ctree), "tree_collapse",
6631                                G_CALLBACK(summary_tree_collapsed),
6632                                summaryview);
6633
6634         g_signal_connect(G_OBJECT(ctree), "start_drag",
6635                          G_CALLBACK(summary_start_drag),
6636                          summaryview);
6637         g_signal_connect(G_OBJECT(ctree), "drag_data_get",
6638                          G_CALLBACK(summary_drag_data_get),
6639                          summaryview);
6640         g_signal_connect(G_OBJECT(ctree), "drag_end",
6641                          G_CALLBACK(summary_drag_end),
6642                          summaryview);
6643
6644         gtk_drag_dest_set(ctree, GTK_DEST_DEFAULT_ALL & ~GTK_DEST_DEFAULT_HIGHLIGHT,
6645                           summary_drag_types, 3,
6646                           GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_DEFAULT);
6647
6648         g_signal_connect(G_OBJECT(ctree), "drag_data_received",
6649                          G_CALLBACK(summary_drag_data_received),
6650                          summaryview);
6651
6652         g_signal_connect(G_OBJECT(ctree), "drag_motion",
6653                          G_CALLBACK(summary_drag_motion_cb),
6654                          summaryview);
6655
6656 #if !GENERIC_UMPC
6657         g_object_set (G_OBJECT(ctree), "has-tooltip", TRUE, NULL);
6658         g_signal_connect(G_OBJECT(ctree), "query-tooltip",
6659                          G_CALLBACK(tooltip_cb),
6660                         summaryview);
6661 #endif
6662         return ctree;
6663 }
6664
6665 void summary_set_column_order(SummaryView *summaryview)
6666 {
6667         GtkWidget *ctree;
6668         GtkWidget *scrolledwin = summaryview->scrolledwin;
6669         FolderItem *item;
6670         guint selected_msgnum = summary_get_msgnum(summaryview, summaryview->selected);
6671         guint displayed_msgnum = summary_get_msgnum(summaryview, summaryview->displayed);
6672
6673         item = summaryview->folder_item;
6674
6675         summary_clear_all(summaryview);
6676         gtk_widget_destroy(summaryview->ctree);
6677
6678         summaryview->ctree = ctree = summary_ctree_create(summaryview);
6679         summary_set_fonts(summaryview);
6680         summary_set_column_titles(summaryview);
6681         gtk_scrolled_window_set_hadjustment(GTK_SCROLLED_WINDOW(scrolledwin),
6682                                             GTK_CMCLIST(ctree)->hadjustment);
6683         gtk_scrolled_window_set_vadjustment(GTK_SCROLLED_WINDOW(scrolledwin),
6684                                             GTK_CMCLIST(ctree)->vadjustment);
6685         gtk_container_add(GTK_CONTAINER(scrolledwin), ctree);
6686         gtk_widget_show(ctree);
6687
6688         summary_show(summaryview, item);
6689
6690         summary_select_by_msgnum(summaryview, selected_msgnum, FALSE);
6691
6692         summaryview->selected = summary_find_msg_by_msgnum(summaryview, selected_msgnum);
6693         summaryview->displayed = summary_find_msg_by_msgnum(summaryview, displayed_msgnum);
6694         if (!summaryview->displayed)
6695                 messageview_clear(summaryview->messageview);
6696         else
6697                 summary_redisplay_msg(summaryview);
6698
6699         /* get normal row height */
6700         gtk_cmclist_set_row_height(GTK_CMCLIST(ctree), 0);
6701         normal_row_height = GTK_CMCLIST(ctree)->row_height;
6702
6703         if ((prefs_common.layout_mode == SMALL_LAYOUT || prefs_common.layout_mode == VERTICAL_LAYOUT) &&
6704             prefs_common.two_line_vert) {
6705                 gtk_cmclist_set_row_height(GTK_CMCLIST(summaryview->ctree), 2*normal_row_height + 2);
6706         }
6707 }
6708
6709
6710 /* callback functions */
6711
6712 static gint summary_folder_eventbox_pressed(GtkWidget *eventbox, GdkEventButton *event,
6713                                             SummaryView *summaryview)
6714 {
6715         if (event) {
6716                 folderview_grab_focus(summaryview->folderview);
6717                 mainwindow_exit_folder(summaryview->mainwin);
6718         }
6719         return TRUE;
6720 }
6721
6722 static gint summary_toggle_pressed(GtkWidget *eventbox, GdkEventButton *event,
6723                                    SummaryView *summaryview)
6724 {
6725         if (event)
6726                 summary_toggle_view(summaryview);
6727         return TRUE;
6728 }
6729 #ifdef GENERIC_UMPC
6730 static void summary_toggle_multiple_pressed(GtkWidget *widget,
6731                                    SummaryView *summaryview)
6732 {
6733         GTK_SCTREE(summaryview->ctree)->force_additive_sel =
6734                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
6735 }
6736 #endif
6737 static gboolean summary_button_pressed(GtkWidget *ctree, GdkEventButton *event,
6738                                        SummaryView *summaryview)
6739 {
6740         if (!event) return FALSE;
6741
6742         if (event->button == 3) {
6743                 /* right clicked */
6744                 summary_set_menu_sensitive(summaryview);
6745                 gtk_menu_popup(GTK_MENU(summaryview->popupmenu), NULL, NULL,
6746                                NULL, NULL, event->button, event->time);
6747         } else if (event->button == 2) {
6748                 summaryview->display_msg = messageview_is_visible(summaryview->messageview);
6749         } else if (event->button == 1) {
6750                 if (!prefs_common.emulate_emacs &&
6751                     messageview_is_visible(summaryview->messageview))
6752                         summaryview->display_msg = TRUE;
6753         }
6754
6755         return FALSE;
6756 }
6757
6758 static gboolean summary_button_released(GtkWidget *ctree, GdkEventButton *event,
6759                                         SummaryView *summaryview)
6760 {
6761         return FALSE;
6762 }
6763
6764 gboolean summary_pass_key_press_event(SummaryView *summaryview, GdkEventKey *event)
6765 {
6766         if (!summaryview)
6767                 return FALSE;
6768         if (summary_is_list(summaryview))
6769                 return summary_key_pressed(summaryview->ctree, event, summaryview);
6770         else
6771                 return FALSE;
6772 }
6773
6774 #define BREAK_ON_MODIFIER_KEY() \
6775         if ((event->state & (GDK_MOD1_MASK|GDK_CONTROL_MASK)) != 0) break
6776
6777 /* Copied from gtkcmclist.c, if it changes there, it has to change
6778  * here as well. This is an ugly hack, there must be a better way to
6779  * find out how much to move for page up/down. */
6780 #define CELL_SPACING 1
6781 static gboolean summary_key_pressed(GtkWidget *widget, GdkEventKey *event,
6782                                     SummaryView *summaryview)
6783 {
6784         GtkCMCTree *ctree = GTK_CMCTREE(widget);
6785         GtkCMCTreeNode *node;
6786         MessageView *messageview;
6787         GtkAdjustment *adj;
6788         gboolean mod_pressed;
6789
6790         if (!event)
6791                 return TRUE;
6792
6793         if (quicksearch_has_focus(summaryview->quicksearch))
6794                 return FALSE;
6795
6796         messageview = summaryview->messageview;
6797
6798         mod_pressed =
6799                 ((event->state & (GDK_SHIFT_MASK|GDK_MOD1_MASK)) != 0);
6800
6801         if (summaryview->selected) {
6802                 gboolean handled = FALSE;
6803                 switch (event->keyval) {
6804                 case GDK_KEY_space:             /* Page down or go to the next */
6805                         handled = TRUE;
6806                         if (event->state & GDK_CONTROL_MASK) {
6807                                 handled = FALSE;
6808                                 break;
6809                         }
6810                         if (event->state & GDK_SHIFT_MASK)
6811                                 mimeview_scroll_page(messageview->mimeview, TRUE);
6812                         else {
6813                                 if (summaryview->displayed != summaryview->selected) {
6814                                         summary_display_msg(summaryview,
6815                                                             summaryview->selected);
6816                                         break;
6817                                 }
6818                                 if (mod_pressed) {
6819                                         if (!mimeview_scroll_page(messageview->mimeview, TRUE))
6820                                                 summary_select_prev_unread(summaryview);
6821                                 } else {
6822                                         if (!mimeview_scroll_page(messageview->mimeview, FALSE))
6823                                                 summary_select_next_unread(summaryview);
6824                                 }
6825                         }
6826                         break;
6827                 case GDK_KEY_BackSpace: /* Page up */
6828                         handled = TRUE;
6829                         mimeview_scroll_page(messageview->mimeview, TRUE);
6830                         break;
6831                 case GDK_KEY_Return:    /* Scroll up/down one line */
6832                 case GDK_KEY_KP_Enter:
6833                         handled = TRUE;
6834                         if (summaryview->displayed != summaryview->selected) {
6835 #ifndef GENERIC_UMPC
6836                                 summary_display_msg(summaryview,
6837                                                     summaryview->selected);
6838 #else
6839                                 summary_open_row(NULL, summaryview);
6840 #endif
6841                                 break;
6842                         }
6843                         mimeview_scroll_one_line(messageview->mimeview, mod_pressed);
6844                         break;
6845                 }
6846
6847                 if (handled)
6848                         return FALSE;
6849         }
6850         if (summary_is_locked(summaryview))
6851                 return TRUE;
6852
6853         switch (event->keyval) {
6854         case GDK_KEY_Left:              /* Move focus */
6855                 adj = gtk_scrolled_window_get_hadjustment
6856                         (GTK_SCROLLED_WINDOW(summaryview->scrolledwin));
6857                 if (gtk_adjustment_get_lower(adj) != gtk_adjustment_get_value(adj))
6858                         break;
6859                 /* FALLTHROUGH */
6860         case GDK_KEY_Escape:
6861                 folderview_grab_focus(summaryview->folderview);
6862                 mainwindow_exit_folder(summaryview->mainwin);
6863                 return TRUE;
6864         case GDK_KEY_Home: case GDK_KEY_KP_Home:
6865         case GDK_KEY_End: case GDK_KEY_KP_End:
6866         case GDK_KEY_Up: case GDK_KEY_KP_Up:
6867         case GDK_KEY_Down: case GDK_KEY_KP_Down:
6868         case GDK_KEY_Page_Up: case GDK_KEY_KP_Page_Up:
6869         case GDK_KEY_Page_Down: case GDK_KEY_KP_Page_Down:
6870                 if ((node = summaryview->selected) != NULL) {
6871                         GtkCMCTreeNode *next = NULL;
6872                         switch (event->keyval) {
6873                                 case GDK_KEY_Home: case GDK_KEY_KP_Home:
6874                                         next = gtk_cmctree_node_nth(ctree, 0);
6875                                         break;
6876                                 case GDK_KEY_End: case GDK_KEY_KP_End:
6877                                         next = gtk_cmctree_node_nth(ctree,
6878                                                         g_list_length(GTK_CMCLIST(ctree)->row_list)-1);
6879                                         break;
6880                                 case GDK_KEY_Up: case GDK_KEY_KP_Up:
6881                                         next = gtk_cmctree_node_nth(ctree,
6882                                                         MAX(0, GTK_CMCLIST(ctree)->focus_row - 1));
6883                                         break;
6884                                 case GDK_KEY_Down: case GDK_KEY_KP_Down:
6885                                         next = gtk_cmctree_node_nth(ctree,
6886                                                         MIN(GTK_CMCLIST(ctree)->focus_row + 1, GTK_CMCLIST(ctree)->rows));
6887                                         break;
6888                                 case GDK_KEY_Page_Up: case GDK_KEY_KP_Page_Up:
6889                                         next = gtk_cmctree_node_nth(ctree,
6890                                                         MAX(0, GTK_CMCLIST(ctree)->focus_row -
6891                                                                 (2 * GTK_CMCLIST(ctree)->clist_window_height -
6892                                                                  GTK_CMCLIST(ctree)->row_height - CELL_SPACING) /
6893                                                                 (2 * (GTK_CMCLIST(ctree)->row_height + CELL_SPACING))));
6894                                         break;
6895                                 case GDK_KEY_Page_Down: case GDK_KEY_KP_Page_Down:
6896                                         next = gtk_cmctree_node_nth(ctree,
6897                                                         MIN(GTK_CMCLIST(ctree)->rows - 1, GTK_CMCLIST(ctree)->focus_row +
6898                                                                 (2 * GTK_CMCLIST(ctree)->clist_window_height -
6899                                                                  GTK_CMCLIST(ctree)->row_height - CELL_SPACING) /
6900                                                                 (2 * (GTK_CMCLIST(ctree)->row_height + CELL_SPACING))));
6901                                         break;
6902                         }
6903
6904                         if (next) {
6905                                 gtk_sctree_select_with_state
6906                                         (GTK_SCTREE(ctree), next, (event->state & ~GDK_CONTROL_MASK) );
6907
6908                                 /* Deprecated - what are the non-deprecated equivalents? */
6909                                 if (gtk_cmctree_node_is_visible(GTK_CMCTREE(ctree), next) != GTK_VISIBILITY_FULL)
6910                                         gtkut_ctree_node_move_if_on_the_edge(GTK_CMCTREE(ctree), next, -1);
6911                                 if (!mod_pressed)
6912                                         summary_select_node(summaryview, summaryview->selected, OPEN_SELECTED_ON_DIRECTIONAL);
6913                                 summaryview->selected = next;
6914                         }
6915                 }
6916                 return TRUE;
6917         default:
6918                 break;
6919         }
6920
6921         if (!summaryview->selected) {
6922                 node = gtk_cmctree_node_nth(ctree, 0);
6923                 if (node)
6924                         gtk_sctree_select(GTK_SCTREE(ctree), node);
6925                 else
6926                         return TRUE;
6927         }
6928
6929         switch (event->keyval) {
6930         case GDK_KEY_Delete:
6931                 BREAK_ON_MODIFIER_KEY();
6932                 summary_delete_trash(summaryview);
6933                 break;
6934         default:
6935                 break;
6936         }
6937         return FALSE;
6938 }
6939 #undef CELL_SPACING
6940
6941 static void quicksearch_execute_cb(QuickSearch *quicksearch, gpointer data)
6942 {
6943         SummaryView *summaryview = data;
6944
6945         summaryview_reset_recursive_folder_match(summaryview);
6946         if (summary_show(summaryview, summaryview->folder_item))
6947                 summaryview_quicksearch_recurse(summaryview);
6948         else
6949                 summaryview_reset_recursive_folder_match(summaryview);
6950 }
6951
6952 static void tog_searchbar_cb(GtkWidget *w, gpointer data)
6953 {
6954         SummaryView *summaryview = (SummaryView *)data;
6955
6956         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))) {
6957                 prefs_common.show_searchbar = TRUE;
6958                 quicksearch_show(summaryview->quicksearch);
6959         } else {
6960                 prefs_common.show_searchbar = FALSE;
6961                 quicksearch_hide(summaryview->quicksearch);
6962         }
6963 }
6964
6965 void summaryview_activate_quicksearch(SummaryView *summaryview, gboolean show)
6966 {
6967         prefs_common.show_searchbar = show;
6968         gtk_toggle_button_set_active(
6969                 GTK_TOGGLE_BUTTON(summaryview->toggle_search),
6970                 show);
6971         if (show) {
6972                 quicksearch_show(summaryview->quicksearch);
6973         } else {
6974                 quicksearch_hide(summaryview->quicksearch);
6975                 summary_grab_focus(summaryview);
6976         }
6977 }
6978
6979 void summary_open_row(GtkSCTree *sctree, SummaryView *summaryview)
6980 {
6981         if (FOLDER_SHOWS_TO_HDR(summaryview->folder_item))
6982                 summary_reedit(summaryview);
6983         else
6984                 summary_open_msg(summaryview);
6985
6986         summaryview->display_msg = FALSE;
6987 }
6988
6989 static void summary_tree_expanded(GtkCMCTree *ctree, GtkCMCTreeNode *node,
6990                                   SummaryView *summaryview)
6991 {
6992         summary_set_row_marks(summaryview, node);
6993         if (prefs_common.bold_unread) {
6994                 while (node) {
6995                         GtkCMCTreeNode *next = GTK_CMCTREE_NODE_NEXT(node);
6996                         if (GTK_CMCTREE_ROW(node)->children)
6997                                 summary_set_row_marks(summaryview, node);
6998                         node = next;
6999                 }
7000         }
7001 }
7002
7003 static void summary_tree_collapsed(GtkCMCTree *ctree, GtkCMCTreeNode *node,
7004                                    SummaryView *summaryview)
7005 {
7006         gtk_sctree_select(GTK_SCTREE(ctree), node);
7007         summary_set_row_marks(summaryview, node);
7008 }
7009
7010 static void summary_unselected(GtkCMCTree *ctree, GtkCMCTreeNode *row,
7011                                gint column, SummaryView *summaryview)
7012 {
7013         if (summary_is_locked(summaryview)
7014         ||  GTK_SCTREE(ctree)->selecting_range) {
7015                 return;
7016         }
7017
7018         summary_status_show(summaryview);
7019 }
7020
7021 static void summary_selected(GtkCMCTree *ctree, GtkCMCTreeNode *row,
7022                              gint column, SummaryView *summaryview)
7023 {
7024         const GList *list, *cur;
7025         MessageView *msgview;
7026         MsgInfo *msginfo;
7027         gboolean marked_unread = FALSE;
7028
7029         if (summary_is_locked(summaryview)
7030         && !GTK_SCTREE(ctree)->selecting_range
7031         && summaryview->messageview
7032         && summaryview->messageview->mimeview
7033         && summaryview->messageview->mimeview->type == MIMEVIEW_TEXT
7034         && summaryview->messageview->mimeview->textview->loading) {
7035                 PostponedSelectData *data = g_new0(PostponedSelectData, 1);
7036                 summaryview->messageview->mimeview->textview->stop_loading = TRUE;
7037
7038                 data->ctree = ctree;
7039                 data->row = row;
7040                 data->node = NULL;
7041                 data->column = column;
7042                 data->summaryview = summaryview;
7043                 debug_print("postponing open of message till end of load\n");
7044                 g_timeout_add(100, summary_select_retry, data);
7045                 return;
7046         }
7047         if (summary_is_locked(summaryview)
7048         ||  GTK_SCTREE(ctree)->selecting_range) {
7049                 return;
7050         }
7051
7052         summary_status_show(summaryview);
7053
7054         if (GTK_CMCLIST(ctree)->selection &&
7055             GTK_CMCLIST(ctree)->selection->next) {
7056                 summaryview->display_msg = FALSE;
7057                 summary_set_menu_sensitive(summaryview);
7058                 toolbar_main_set_sensitive(summaryview->mainwin);
7059                 return;
7060         }
7061
7062         summaryview->selected = row;
7063
7064         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
7065         cm_return_if_fail(msginfo != NULL);
7066
7067         main_create_mailing_list_menu (summaryview->mainwin, msginfo);
7068         toolbar_set_learn_button
7069                 (summaryview->mainwin->toolbar,
7070                  MSG_IS_SPAM(msginfo->flags)?LEARN_HAM:LEARN_SPAM);
7071
7072         switch (column < 0 ? column : summaryview->col_state[column].type) {
7073         case S_COL_MARK:
7074                 if (!MSG_IS_DELETED(msginfo->flags) &&
7075                     !MSG_IS_MOVE(msginfo->flags) &&
7076                     !MSG_IS_COPY(msginfo->flags)) {
7077                         if (MSG_IS_MARKED(msginfo->flags)) {
7078                                 summary_unmark_row(summaryview, row);
7079                                 summary_status_show(summaryview);
7080                         } else {
7081                                 summary_mark_row(summaryview, row);
7082                                 summary_status_show(summaryview);
7083                         }
7084                 }
7085                 break;
7086         case S_COL_STATUS:
7087                 if (MSG_IS_UNREAD(msginfo->flags)) {
7088                         summary_mark_row_as_read(summaryview, row);
7089                         summary_status_show(summaryview);
7090                 } else if (MSG_IS_SPAM(msginfo->flags)) {
7091                                 if (procmsg_spam_learner_learn(msginfo, NULL, FALSE) == 0)
7092                                         summary_msginfo_unset_flags(msginfo, MSG_SPAM, 0);
7093                                 else
7094                                         log_error(LOG_PROTOCOL, _("An error happened while learning.\n"));
7095                 } else if (!MSG_IS_REPLIED(msginfo->flags) &&
7096                          !MSG_IS_FORWARDED(msginfo->flags)) {
7097                         marked_unread = TRUE;
7098                 } else if (MSG_IS_REPLIED(msginfo->flags)) {
7099                         summary_find_answers(summaryview, msginfo);
7100                         return;
7101                 }
7102                 break;
7103         case S_COL_LOCKED:
7104                 if (MSG_IS_LOCKED(msginfo->flags)) {
7105                         summary_unlock_row(summaryview, row);
7106                         summary_status_show(summaryview);
7107                 }
7108                 else {
7109                         summary_lock_row(summaryview, row);
7110                         summary_status_show(summaryview);
7111                 }
7112                 break;
7113         default:
7114                 break;
7115         }
7116
7117         list = messageview_get_msgview_list();
7118         for (cur = list; cur != NULL; cur = cur->next) {
7119                 msgview = (MessageView *) cur->data;
7120
7121                 if (msgview->new_window && msgview->update_needed) {
7122                         MsgInfo *new_msginfo = summary_get_selected_msg(summaryview);
7123                         messageview_show(msgview, new_msginfo, msgview->all_headers);
7124                         msgview->update_needed = FALSE;
7125                 }
7126         }
7127
7128         if (summaryview->display_msg) {
7129                 summaryview->display_msg = FALSE;
7130                 if (summaryview->displayed != row) {
7131                         summary_display_msg(summaryview, row);
7132                         if (marked_unread) {
7133                                 summary_mark_row_as_unread(summaryview, row);
7134                                 summary_status_show(summaryview);
7135                         }
7136                         return;
7137                 }
7138         }
7139
7140         if (marked_unread) {
7141                 summary_mark_row_as_unread(summaryview, row);
7142                 summary_status_show(summaryview);
7143         }
7144
7145         summary_set_menu_sensitive(summaryview);
7146         toolbar_main_set_sensitive(summaryview->mainwin);
7147 }
7148
7149 static void summary_col_resized(GtkCMCList *clist, gint column, gint width,
7150                                 SummaryView *summaryview)
7151 {
7152         SummaryColumnType type = summaryview->col_state[column].type;
7153
7154         prefs_common.summary_col_size[type] = width;
7155 }
7156
7157
7158 /*
7159  * \brief get List of msginfo selected in SummaryView
7160  *
7161  * \param summaryview
7162  *
7163  * \return GSList holding MsgInfo
7164  */
7165 GSList *summary_get_selection(SummaryView *summaryview)
7166 {
7167         GList *sel = NULL;
7168         GSList *msginfo_list = NULL;
7169
7170         cm_return_val_if_fail(summaryview != NULL, NULL);
7171
7172         sel = GTK_CMCLIST(summaryview->ctree)->selection;
7173
7174         cm_return_val_if_fail(sel != NULL, NULL);
7175
7176         for ( ; sel != NULL; sel = sel->next)
7177                 msginfo_list =
7178                         g_slist_prepend(msginfo_list,
7179                                        gtk_cmctree_node_get_row_data(GTK_CMCTREE(summaryview->ctree),
7180                                                                    GTK_CMCTREE_NODE(sel->data)));
7181         return g_slist_reverse(msginfo_list);
7182 }
7183
7184 /*
7185  * \brief get number of messages currently selected in SummaryView
7186  *
7187  * \param summaryview
7188  *
7189  * \return number of messages currently selected
7190  */
7191 guint summary_get_selection_count(SummaryView *summaryview)
7192 {
7193         cm_return_val_if_fail(summaryview != NULL, 0);
7194         return g_list_length(GTK_CMCLIST(summaryview->ctree)->selection);
7195 }
7196
7197 static void summary_sort_by_column_click(SummaryView *summaryview,
7198                                          FolderSortKey sort_key)
7199 {
7200         GtkCMCTreeNode *node = NULL;
7201         START_TIMING("");
7202         if (summaryview->sort_key == sort_key)
7203                 summary_sort(summaryview, sort_key,
7204                              summaryview->sort_type == SORT_ASCENDING
7205                              ? SORT_DESCENDING : SORT_ASCENDING);
7206         else
7207                 summary_sort(summaryview, sort_key, SORT_ASCENDING);
7208
7209         node = GTK_CMCTREE_NODE(GTK_CMCLIST(summaryview->ctree)->row_list);
7210
7211         summary_freeze(summaryview);
7212         if (prefs_common.bold_unread) {
7213                 while (node) {
7214                         GtkCMCTreeNode *next = GTK_CMCTREE_NODE_NEXT(node);
7215                         if (GTK_CMCTREE_ROW(node)->children)
7216                                 summary_set_row_marks(summaryview, node);
7217                         node = next;
7218                 }
7219         }
7220         summary_thaw(summaryview);
7221         END_TIMING();
7222 }
7223
7224 static void summary_mark_clicked(GtkWidget *button, SummaryView *summaryview)
7225 {
7226         summary_sort_by_column_click(summaryview, SORT_BY_MARK);
7227 }
7228
7229 static void summary_status_clicked(GtkWidget *button, SummaryView *summaryview)
7230 {
7231         summary_sort_by_column_click(summaryview, SORT_BY_STATUS);
7232 }
7233
7234 static void summary_mime_clicked(GtkWidget *button, SummaryView *summaryview)
7235 {
7236         summary_sort_by_column_click(summaryview, SORT_BY_MIME);
7237 }
7238
7239 static void summary_num_clicked(GtkWidget *button, SummaryView *summaryview)
7240 {
7241         summary_sort_by_column_click(summaryview, SORT_BY_NUMBER);
7242 }
7243
7244 static void summary_size_clicked(GtkWidget *button, SummaryView *summaryview)
7245 {
7246         summary_sort_by_column_click(summaryview, SORT_BY_SIZE);
7247 }
7248
7249 static void summary_date_clicked(GtkWidget *button, SummaryView *summaryview)
7250 {
7251         if (summaryview->sort_key == SORT_BY_THREAD_DATE)
7252                 summary_sort_by_column_click(summaryview, SORT_BY_THREAD_DATE);
7253         else
7254                 summary_sort_by_column_click(summaryview, SORT_BY_DATE);
7255 }
7256
7257 static void summary_from_clicked(GtkWidget *button, SummaryView *summaryview)
7258 {
7259         if (summaryview->col_state[summaryview->col_pos[S_COL_FROM]].visible)
7260                 summary_sort_by_column_click(summaryview, SORT_BY_FROM);
7261         else
7262                 summary_sort_by_column_click(summaryview, SORT_BY_TO);
7263 }
7264
7265 static void summary_to_clicked(GtkWidget *button, SummaryView *summaryview)
7266 {
7267         if (summaryview->col_state[summaryview->col_pos[S_COL_TO]].visible)
7268                 summary_sort_by_column_click(summaryview, SORT_BY_TO);
7269         else
7270                 summary_sort_by_column_click(summaryview, SORT_BY_FROM);
7271 }
7272
7273 static void summary_subject_clicked(GtkWidget *button,
7274                                     SummaryView *summaryview)
7275 {
7276         summary_sort_by_column_click(summaryview, SORT_BY_SUBJECT);
7277 }
7278
7279 static void summary_score_clicked(GtkWidget *button,
7280                                   SummaryView *summaryview)
7281 {
7282         summary_sort_by_column_click(summaryview, SORT_BY_SCORE);
7283 }
7284
7285 static void summary_locked_clicked(GtkWidget *button,
7286                                    SummaryView *summaryview)
7287 {
7288         summary_sort_by_column_click(summaryview, SORT_BY_LOCKED);
7289 }
7290
7291 static void summary_tags_clicked(GtkWidget *button,
7292                                    SummaryView *summaryview)
7293 {
7294         summary_sort_by_column_click(summaryview, SORT_BY_TAGS);
7295 }
7296
7297 static void summary_start_drag(GtkWidget *widget, gint button, GdkEvent *event,
7298                                SummaryView *summaryview)
7299 {
7300         GdkDragContext *context;
7301
7302         cm_return_if_fail(summaryview != NULL);
7303         cm_return_if_fail(summaryview->folder_item != NULL);
7304         cm_return_if_fail(summaryview->folder_item->folder != NULL);
7305
7306         if (summaryview->selected == NULL) return;
7307
7308         context = gtk_drag_begin(widget, summaryview->target_list,
7309                                  GDK_ACTION_MOVE|GDK_ACTION_COPY|GDK_ACTION_DEFAULT, button, event);
7310         gtk_drag_set_icon_default(context);
7311         if (prefs_common.layout_mode == SMALL_LAYOUT) {
7312                 GtkWidget *paned = gtk_widget_get_parent(GTK_WIDGET_PTR(summaryview));
7313                 if (paned && GTK_IS_PANED(paned)) {
7314                         mainwindow_reset_paned(GTK_PANED(paned));
7315                 }
7316         }
7317 }
7318
7319 static gboolean summary_return_to_list(void *data)
7320 {
7321         SummaryView *summaryview = (SummaryView *)data;
7322         mainwindow_enter_folder(summaryview->mainwin);
7323         return FALSE;
7324 }
7325
7326 static void summary_drag_end       (GtkWidget       *widget,
7327                                    GdkDragContext   *drag_context,
7328                                    SummaryView      *summaryview)
7329 {
7330         if (prefs_common.layout_mode == SMALL_LAYOUT) {
7331                 g_timeout_add(250, summary_return_to_list, summaryview);
7332         }
7333 }
7334
7335 static void summary_drag_data_get(GtkWidget        *widget,
7336                                   GdkDragContext   *drag_context,
7337                                   GtkSelectionData *selection_data,
7338                                   guint             info,
7339                                   guint             time,
7340                                   SummaryView      *summaryview)
7341 {
7342         if (info == TARGET_MAIL_URI_LIST) {
7343                 GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
7344                 GList *cur;
7345                 MsgInfo *msginfo;
7346                 gchar *mail_list = NULL, *tmp1, *tmp2;
7347
7348                 for (cur = GTK_CMCLIST(ctree)->selection;
7349                      cur != NULL && cur->data != NULL; cur = cur->next) {
7350                         msginfo = gtk_cmctree_node_get_row_data
7351                                 (ctree, GTK_CMCTREE_NODE(cur->data));
7352                         tmp2 = procmsg_get_message_file(msginfo);
7353                         if (!tmp2) continue;
7354                         if (msginfo->subject) {
7355                                 gchar *san_subject = g_strdup(msginfo->subject);
7356                                 gchar *dest = NULL;
7357                                 subst_for_filename(san_subject);
7358                                 dest = g_strdup_printf("%s%s%s.%d.txt",
7359                                                 get_tmp_dir(),
7360                                                 G_DIR_SEPARATOR_S,
7361                                                 san_subject, msginfo->msgnum);
7362                                 g_free(san_subject);
7363                                 san_subject = g_filename_from_utf8(dest, -1, NULL, NULL, NULL);
7364                                 g_free(dest);
7365                                 dest = san_subject;
7366                                 if (copy_file(tmp2, dest, TRUE) == 0) {
7367                                         g_free(tmp2);
7368                                         tmp2 = dest;
7369                                 }
7370                         }
7371                         tmp1 = g_filename_to_uri(tmp2, NULL, NULL);
7372                         g_free(tmp2);
7373                         tmp2 = g_strconcat(tmp1, "\r\n", NULL);
7374                         g_free(tmp1);
7375                         tmp1 = tmp2;
7376
7377                         if (!mail_list) {
7378                                 mail_list = tmp1;
7379                         } else {
7380                                 tmp2 = g_strconcat(mail_list, tmp1, NULL);
7381                                 g_free(mail_list);
7382                                 g_free(tmp1);
7383                                 mail_list = tmp2;
7384                         }
7385                 }
7386
7387                 if (mail_list != NULL) {
7388                         gtk_selection_data_set(selection_data,
7389                                                gtk_selection_data_get_target(selection_data), 8,
7390                                                mail_list, strlen(mail_list));
7391                         g_free(mail_list);
7392                 }
7393         } else if (info == TARGET_DUMMY) {
7394                 if (GTK_CMCLIST(summaryview->ctree)->selection)
7395                         gtk_selection_data_set(selection_data,
7396                                                gtk_selection_data_get_target(selection_data), 8,
7397                                                "Dummy-Summaryview",
7398                                                strlen("Dummy-Summaryview")+1);
7399         } else if (info == TARGET_MAIL_CM_PATH_LIST) {
7400                 /* content: folder_item_identifier\nmsgid1\nmsgid2\nmsgid3 */
7401
7402                 GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
7403                 GList *cur;
7404                 MsgInfo *msginfo;
7405                 gchar *path_list = NULL;
7406
7407                 /* identifier */
7408                 if(GTK_CMCLIST(ctree)->selection != NULL) {
7409                         msginfo = gtk_cmctree_node_get_row_data(ctree, GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->selection->data));
7410             if(msginfo && msginfo->folder)
7411               path_list = folder_item_get_identifier(msginfo->folder);
7412                 }
7413
7414                 for (cur = GTK_CMCLIST(ctree)->selection;
7415                      cur != NULL && cur->data != NULL; cur = cur->next) {
7416                         gchar *tmp;
7417
7418                         msginfo = gtk_cmctree_node_get_row_data(ctree, GTK_CMCTREE_NODE(cur->data));
7419             if(!msginfo)
7420               continue;
7421                         tmp = path_list;
7422                         path_list = g_strconcat(path_list, "\n", (msginfo->msgid ? msginfo->msgid : "unknown"), NULL);
7423                         g_free(tmp);
7424                 }
7425
7426                 if (path_list != NULL) {
7427                         gtk_selection_data_set(selection_data,
7428                                                gtk_selection_data_get_target(selection_data), 8,
7429                                                path_list, strlen(path_list));
7430                         g_free(path_list);
7431                 }
7432     }
7433 }
7434
7435 static gboolean summary_drag_motion_cb(GtkWidget      *widget,
7436                                           GdkDragContext *context,
7437                                           gint            x,
7438                                           gint            y,
7439                                           guint           time,
7440                                           SummaryView    *summaryview)
7441 {
7442         FolderItem *item = summaryview->folder_item;
7443         if (!(item && item->folder && folder_item_parent(item) != NULL
7444                     && FOLDER_CLASS(item->folder)->add_msg != NULL)) {
7445                 gdk_drag_status(context, 0, time);
7446                 return FALSE;
7447         } else if (gtk_drag_get_source_widget(context) ==
7448                 mainwindow_get_mainwindow()->folderview->ctree) {
7449                 /* no folders */
7450                 gdk_drag_status(context, 0, time);
7451                 return FALSE;
7452         } else if (gtk_drag_get_source_widget(context) ==
7453                 summaryview->ctree) {
7454                 /* not from same folder */
7455                 gdk_drag_status(context, 0, time);
7456                 return FALSE;
7457         } else {
7458                 gdk_drag_status(context, GDK_ACTION_COPY, time);
7459                 return TRUE;
7460         }
7461 }
7462
7463 static void summary_drag_data_received(GtkWidget        *widget,
7464                                         GdkDragContext   *drag_context,
7465                                         gint              x,
7466                                         gint              y,
7467                                         GtkSelectionData *data,
7468                                         guint             info,
7469                                         guint             time,
7470                                         SummaryView       *summaryview)
7471 {
7472         if (info == TARGET_MAIL_URI_LIST) {
7473                 FolderItem *item = summaryview->folder_item;
7474                 if (!item) {
7475                         gtk_drag_finish(drag_context, FALSE, FALSE, time);
7476                         return;
7477                 } else {
7478                         folderview_finish_dnd(gtk_selection_data_get_data(data),
7479                                 drag_context, time, item);
7480                 }
7481         }
7482 }
7483
7484
7485 /* custom compare functions for sorting */
7486
7487 static gint summary_cmp_by_date(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 = (msginfo1->date_t - msginfo2->date_t);
7497         if (res == 0)
7498                 res = msginfo1->msgnum - msginfo2->msgnum;
7499         return res;
7500 }
7501
7502 #define CMP_FUNC_DEF(func_name, val)                                     \
7503 static gint func_name(GtkCMCList *clist,                                 \
7504                       gconstpointer ptr1, gconstpointer ptr2)            \
7505 {                                                                        \
7506         MsgInfo *msginfo1 = ((GtkCMCListRow *)ptr1)->data;               \
7507         MsgInfo *msginfo2 = ((GtkCMCListRow *)ptr2)->data;               \
7508         gint res;                                                        \
7509         if (!msginfo1 || !msginfo2)                                      \
7510                 return -1;                                               \
7511                                                                          \
7512         res = (val);                                                     \
7513         return (res != 0) ? res:summary_cmp_by_date(clist, ptr1, ptr2);  \
7514 }
7515
7516 CMP_FUNC_DEF(summary_cmp_by_mark,
7517              MSG_IS_MARKED(msginfo1->flags) - MSG_IS_MARKED(msginfo2->flags))
7518 CMP_FUNC_DEF(summary_cmp_by_status,
7519              (-(MSG_IS_SPAM(msginfo1->flags))+(MSG_IS_UNREAD(msginfo1->flags)<<1)+(MSG_IS_NEW(msginfo1->flags)<<2))
7520              - (-(MSG_IS_SPAM(msginfo2->flags))+(MSG_IS_UNREAD(msginfo2->flags)<<1)+(MSG_IS_NEW(msginfo2->flags)<<2)) )
7521 CMP_FUNC_DEF(summary_cmp_by_mime,
7522              MSG_IS_WITH_ATTACHMENT(msginfo1->flags) - MSG_IS_WITH_ATTACHMENT(msginfo2->flags))
7523 CMP_FUNC_DEF(summary_cmp_by_label,
7524              MSG_GET_COLORLABEL(msginfo1->flags) -
7525              MSG_GET_COLORLABEL(msginfo2->flags))
7526 CMP_FUNC_DEF(summary_cmp_by_locked,
7527              MSG_IS_LOCKED(msginfo1->flags) - MSG_IS_LOCKED(msginfo2->flags))
7528
7529 CMP_FUNC_DEF(summary_cmp_by_num, msginfo1->msgnum - msginfo2->msgnum)
7530 CMP_FUNC_DEF(summary_cmp_by_size, msginfo1->size - msginfo2->size)
7531
7532 #undef CMP_FUNC_DEF
7533
7534 static gint summary_cmp_by_subject(GtkCMCList *clist,
7535                                    gconstpointer ptr1,
7536                                    gconstpointer ptr2)
7537 {
7538         MsgInfo *msginfo1 = ((GtkCMCListRow *)ptr1)->data;
7539         MsgInfo *msginfo2 = ((GtkCMCListRow *)ptr2)->data;
7540         gint res;
7541
7542         if (!msginfo1->subject)
7543                 return (msginfo2->subject != NULL);
7544         if (!msginfo2->subject)
7545                 return -1;
7546
7547         res = subject_compare_for_sort
7548                 (msginfo1->subject, msginfo2->subject);
7549         return (res != 0)? res: summary_cmp_by_date(clist, ptr1, ptr2);
7550 }
7551
7552 static gint summary_cmp_by_thread_date(GtkCMCList *clist,
7553                                    gconstpointer ptr1,
7554                                    gconstpointer ptr2)
7555 {
7556         MsgInfo *msginfo1 = ((GtkCMCListRow *)ptr1)->data;
7557         MsgInfo *msginfo2 = ((GtkCMCListRow *)ptr2)->data;
7558         gint thread_diff = msginfo1->thread_date - msginfo2->thread_date;
7559
7560         if (msginfo1->thread_date > 0 && msginfo2->thread_date > 0)
7561                 return thread_diff;
7562         else
7563                 return msginfo1->date_t - msginfo2->date_t;
7564 }
7565
7566 static gint summary_cmp_by_from(GtkCMCList *clist, gconstpointer ptr1,
7567                                 gconstpointer ptr2)
7568 {
7569         const gchar *str1, *str2;
7570         const GtkCMCListRow *r1 = (const GtkCMCListRow *) ptr1;
7571         const GtkCMCListRow *r2 = (const GtkCMCListRow *) ptr2;
7572         MsgInfo *msginfo1 = ((GtkCMCListRow *)ptr1)->data;
7573         MsgInfo *msginfo2 = ((GtkCMCListRow *)ptr2)->data;
7574         const SummaryView *sv = g_object_get_data(G_OBJECT(clist), "summaryview");
7575         gint res;
7576
7577         cm_return_val_if_fail(sv, -1);
7578         if (sv->col_state[sv->col_pos[S_COL_FROM]].visible) {
7579                 str1 = GTK_CMCELL_TEXT(r1->cell[sv->col_pos[S_COL_FROM]])->text;
7580                 str2 = GTK_CMCELL_TEXT(r2->cell[sv->col_pos[S_COL_FROM]])->text;
7581         } else {
7582                 str1 = msginfo1->from;
7583                 str2 = msginfo2->from;
7584         }
7585
7586         if (!str1)
7587                 return str2 != NULL;
7588
7589         if (!str2)
7590                 return -1;
7591
7592         res = g_utf8_collate(str1, str2);
7593         return (res != 0)? res: summary_cmp_by_date(clist, ptr1, ptr2);
7594 }
7595
7596 static gint summary_cmp_by_to(GtkCMCList *clist, gconstpointer ptr1,
7597                                 gconstpointer ptr2)
7598 {
7599         const gchar *str1, *str2;
7600         const GtkCMCListRow *r1 = (const GtkCMCListRow *) ptr1;
7601         const GtkCMCListRow *r2 = (const GtkCMCListRow *) ptr2;
7602         MsgInfo *msginfo1 = ((GtkCMCListRow *)ptr1)->data;
7603         MsgInfo *msginfo2 = ((GtkCMCListRow *)ptr2)->data;
7604         const SummaryView *sv = g_object_get_data(G_OBJECT(clist), "summaryview");
7605         gint res;
7606         cm_return_val_if_fail(sv, -1);
7607
7608         if (sv->col_state[sv->col_pos[S_COL_TO]].visible) {
7609                 str1 = GTK_CMCELL_TEXT(r1->cell[sv->col_pos[S_COL_TO]])->text;
7610                 str2 = GTK_CMCELL_TEXT(r2->cell[sv->col_pos[S_COL_TO]])->text;
7611         } else {
7612                 str1 = msginfo1->to;
7613                 str2 = msginfo2->to;
7614         }
7615
7616         if (!str1)
7617                 return str2 != NULL;
7618
7619         if (!str2)
7620                 return -1;
7621
7622         res = g_utf8_collate(str1, str2);
7623         return (res != 0)? res: summary_cmp_by_date(clist, ptr1, ptr2);
7624 }
7625
7626 static gint summary_cmp_by_tags(GtkCMCList *clist, gconstpointer ptr1,
7627                                 gconstpointer ptr2)
7628 {
7629         gchar *str1, *str2;
7630         const GtkCMCListRow *r1 = (const GtkCMCListRow *) ptr1;
7631         const GtkCMCListRow *r2 = (const GtkCMCListRow *) ptr2;
7632         const SummaryView *sv = g_object_get_data(G_OBJECT(clist), "summaryview");
7633         MsgInfo *msginfo1 = ((GtkCMCListRow *)ptr1)->data;
7634         MsgInfo *msginfo2 = ((GtkCMCListRow *)ptr2)->data;
7635         gint res;
7636         cm_return_val_if_fail(sv, -1);
7637
7638         if (sv->col_state[sv->col_pos[S_COL_TAGS]].visible) {
7639                 str1 = g_strdup(GTK_CMCELL_TEXT(r1->cell[sv->col_pos[S_COL_TAGS]])->text);
7640                 str2 = g_strdup(GTK_CMCELL_TEXT(r2->cell[sv->col_pos[S_COL_TAGS]])->text);
7641         } else {
7642                 str1 = procmsg_msginfo_get_tags_str(msginfo1);
7643                 str2 = procmsg_msginfo_get_tags_str(msginfo2);
7644         }
7645
7646         if (!str1) {
7647                 res = (str2 != NULL);
7648                 g_free(str2);
7649                 return res;
7650         }
7651         if (!str2) {
7652                 g_free(str1);
7653                 return -1;
7654         }
7655
7656         res = g_utf8_collate(str1, str2);
7657         g_free(str1);
7658         g_free(str2);
7659         return (res != 0)? res: summary_cmp_by_date(clist, ptr1, ptr2);
7660 }
7661
7662 static gint summary_cmp_by_simplified_subject
7663         (GtkCMCList *clist, gconstpointer ptr1, gconstpointer ptr2)
7664 {
7665         const FolderItemPrefs *prefs;
7666         const gchar *str1, *str2;
7667         const GtkCMCListRow *r1 = (const GtkCMCListRow *) ptr1;
7668         const GtkCMCListRow *r2 = (const GtkCMCListRow *) ptr2;
7669         const MsgInfo *msginfo1 = r1->data;
7670         const MsgInfo *msginfo2 = r2->data;
7671         const SummaryView *sv = g_object_get_data(G_OBJECT(clist), "summaryview");
7672         gint res;
7673
7674         cm_return_val_if_fail(sv, -1);
7675         cm_return_val_if_fail(msginfo1 != NULL && msginfo2 != NULL, -1);
7676
7677         if (sv->col_state[sv->col_pos[S_COL_SUBJECT]].visible) {
7678                 str1 = GTK_CMCELL_TEXT(r1->cell[sv->col_pos[S_COL_SUBJECT]])->text;
7679                 str2 = GTK_CMCELL_TEXT(r2->cell[sv->col_pos[S_COL_SUBJECT]])->text;
7680         } else {
7681                 str1 = msginfo1->subject;
7682                 str2 = msginfo2->subject;
7683         }
7684
7685         if (!str1)
7686                 return str2 != NULL;
7687
7688         if (!str2)
7689                 return -1;
7690
7691         prefs = msginfo1->folder->prefs;
7692         if (!prefs)
7693                 prefs = msginfo2->folder->prefs;
7694         if (!prefs)
7695                 return -1;
7696
7697         res = subject_compare_for_sort(str1, str2);
7698         return (res != 0)? res: summary_cmp_by_date(clist, ptr1, ptr2);
7699 }
7700
7701 static gint summary_cmp_by_score(GtkCMCList *clist,
7702                                  gconstpointer ptr1, gconstpointer ptr2)
7703 {
7704         MsgInfo *msginfo1 = ((GtkCMCListRow *)ptr1)->data;
7705         MsgInfo *msginfo2 = ((GtkCMCListRow *)ptr2)->data;
7706         int diff;
7707
7708         /* if score are equal, sort by date */
7709
7710         diff = msginfo1->score - msginfo2->score;
7711         if (diff != 0)
7712                 return diff;
7713         else
7714                 return summary_cmp_by_date(clist, ptr1, ptr2);
7715 }
7716
7717 static void summary_ignore_thread_func_mark_unread(GtkCMCTree *ctree, GtkCMCTreeNode *row, gpointer data)
7718 {
7719         MsgInfo *msginfo;
7720
7721         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
7722         cm_return_if_fail(msginfo);
7723
7724         summary_msginfo_unset_flags(msginfo, MSG_WATCH_THREAD, 0);
7725         summary_msginfo_change_flags(msginfo, MSG_IGNORE_THREAD, 0, MSG_NEW | MSG_UNREAD, 0);
7726
7727         debug_print("Message %d is marked as ignore thread\n", msginfo->msgnum);
7728 }
7729
7730 static void summary_ignore_thread_func_set_row(GtkCMCTree *ctree, GtkCMCTreeNode *row, gpointer data)
7731 {
7732         SummaryView *summaryview = (SummaryView *) data;
7733         MsgInfo *msginfo;
7734
7735         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
7736         cm_return_if_fail(msginfo);
7737
7738         summary_set_row_marks(summaryview, row);
7739         debug_print("Message %d update in row view\n", msginfo->msgnum);
7740 }
7741
7742 void summary_ignore_thread(SummaryView *summaryview)
7743 {
7744         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
7745         GList *cur;
7746         gboolean froze = FALSE;
7747
7748         START_LONG_OPERATION(summaryview, FALSE);
7749         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
7750                 gtk_cmctree_pre_recursive(ctree, GTK_CMCTREE_NODE(cur->data),
7751                                         GTK_CMCTREE_FUNC(summary_ignore_thread_func_mark_unread),
7752                                         summaryview);
7753
7754         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
7755                 gtk_cmctree_pre_recursive(ctree, GTK_CMCTREE_NODE(cur->data),
7756                                         GTK_CMCTREE_FUNC(summary_ignore_thread_func_set_row),
7757                                         summaryview);
7758
7759         END_LONG_OPERATION(summaryview);
7760
7761         summary_status_show(summaryview);
7762 }
7763
7764 static void summary_unignore_thread_func(GtkCMCTree *ctree, GtkCMCTreeNode *row, gpointer data)
7765 {
7766         SummaryView *summaryview = (SummaryView *) data;
7767         MsgInfo *msginfo;
7768
7769         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
7770         cm_return_if_fail(msginfo);
7771
7772         summary_msginfo_unset_flags(msginfo, MSG_IGNORE_THREAD, 0);
7773
7774         summary_set_row_marks(summaryview, row);
7775         debug_print("Message %d is marked as unignore thread\n",
7776             msginfo->msgnum);
7777 }
7778
7779 void summary_unignore_thread(SummaryView *summaryview)
7780 {
7781         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
7782         GList *cur;
7783         gboolean froze = FALSE;
7784
7785         START_LONG_OPERATION(summaryview, FALSE);
7786         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
7787                 gtk_cmctree_pre_recursive(ctree, GTK_CMCTREE_NODE(cur->data),
7788                                         GTK_CMCTREE_FUNC(summary_unignore_thread_func),
7789                                         summaryview);
7790
7791         END_LONG_OPERATION(summaryview);
7792
7793         summary_status_show(summaryview);
7794 }
7795
7796 static void summary_check_ignore_thread_func
7797                 (GtkCMCTree *ctree, GtkCMCTreeNode *row, gpointer data)
7798 {
7799         MsgInfo *msginfo;
7800         gint *found_ignore = (gint *) data;
7801
7802         if (*found_ignore) return;
7803         else {
7804                 msginfo = gtk_cmctree_node_get_row_data(ctree, row);
7805                 *found_ignore = msginfo && MSG_IS_IGNORE_THREAD(msginfo->flags);
7806         }
7807 }
7808
7809 void summary_toggle_ignore_thread(SummaryView *summaryview)
7810 {
7811         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
7812         GList *cur;
7813         gint found_ignore = 0;
7814
7815         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
7816                 gtk_cmctree_pre_recursive(ctree, GTK_CMCTREE_NODE(cur->data),
7817                                         GTK_CMCTREE_FUNC(summary_check_ignore_thread_func),
7818                                         &found_ignore);
7819
7820         if (found_ignore)
7821                 summary_unignore_thread(summaryview);
7822         else
7823                 summary_ignore_thread(summaryview);
7824 }
7825
7826 static void summary_watch_thread_func(GtkCMCTree *ctree, GtkCMCTreeNode *row, gpointer data)
7827 {
7828         SummaryView *summaryview = (SummaryView *) data;
7829         MsgInfo *msginfo;
7830
7831         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
7832         cm_return_if_fail(msginfo);
7833
7834         summary_msginfo_change_flags(msginfo, MSG_WATCH_THREAD, 0, MSG_IGNORE_THREAD, 0);
7835
7836         summary_set_row_marks(summaryview, row);
7837         debug_print("Message %d is marked as watch thread\n",
7838             msginfo->msgnum);
7839 }
7840
7841 void summary_watch_thread(SummaryView *summaryview)
7842 {
7843         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
7844         GList *cur;
7845         gboolean froze = FALSE;
7846
7847         START_LONG_OPERATION(summaryview, FALSE);
7848         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
7849                 gtk_cmctree_pre_recursive(ctree, GTK_CMCTREE_NODE(cur->data),
7850                                         GTK_CMCTREE_FUNC(summary_watch_thread_func),
7851                                         summaryview);
7852
7853         END_LONG_OPERATION(summaryview);
7854
7855         summary_status_show(summaryview);
7856 }
7857
7858 static void summary_unwatch_thread_func(GtkCMCTree *ctree, GtkCMCTreeNode *row, gpointer data)
7859 {
7860         SummaryView *summaryview = (SummaryView *) data;
7861         MsgInfo *msginfo;
7862
7863         msginfo = gtk_cmctree_node_get_row_data(ctree, row);
7864         cm_return_if_fail(msginfo);
7865
7866         summary_msginfo_unset_flags(msginfo, MSG_WATCH_THREAD, 0);
7867
7868         summary_set_row_marks(summaryview, row);
7869         debug_print("Message %d is marked as unwatch thread\n",
7870             msginfo->msgnum);
7871 }
7872
7873 void summary_unwatch_thread(SummaryView *summaryview)
7874 {
7875         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
7876         GList *cur;
7877         gboolean froze = FALSE;
7878
7879         START_LONG_OPERATION(summaryview, FALSE);
7880         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
7881                 gtk_cmctree_pre_recursive(ctree, GTK_CMCTREE_NODE(cur->data),
7882                                         GTK_CMCTREE_FUNC(summary_unwatch_thread_func),
7883                                         summaryview);
7884
7885         END_LONG_OPERATION(summaryview);
7886
7887         summary_status_show(summaryview);
7888 }
7889
7890 static void summary_check_watch_thread_func
7891                 (GtkCMCTree *ctree, GtkCMCTreeNode *row, gpointer data)
7892 {
7893         MsgInfo *msginfo;
7894         gint *found_watch = (gint *) data;
7895
7896         if (*found_watch) return;
7897         else {
7898                 msginfo = gtk_cmctree_node_get_row_data(ctree, row);
7899                 *found_watch = msginfo && MSG_IS_WATCH_THREAD(msginfo->flags);
7900         }
7901 }
7902
7903 void summary_toggle_watch_thread(SummaryView *summaryview)
7904 {
7905         GtkCMCTree *ctree = GTK_CMCTREE(summaryview->ctree);
7906         GList *cur;
7907         gint found_watch = 0;
7908
7909         for (cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next)
7910                 gtk_cmctree_pre_recursive(ctree, GTK_CMCTREE_NODE(cur->data),
7911                                         GTK_CMCTREE_FUNC(summary_check_watch_thread_func),
7912                                         &found_watch);
7913
7914         if (found_watch)
7915                 summary_unwatch_thread(summaryview);
7916         else
7917                 summary_watch_thread(summaryview);
7918 }
7919
7920
7921 void summary_toggle_show_read_messages(SummaryView *summaryview)
7922 {
7923         FolderItemUpdateData source;
7924         if (summaryview->folder_item->hide_read_msgs)
7925                 summaryview->folder_item->hide_read_msgs = 0;
7926         else
7927                 summaryview->folder_item->hide_read_msgs = 1;
7928
7929         source.item = summaryview->folder_item;
7930         source.update_flags = F_ITEM_UPDATE_NAME;
7931         source.msg = NULL;
7932         hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST, &source);
7933         summary_show(summaryview, summaryview->folder_item);
7934 }
7935
7936 void summary_toggle_show_del_messages(SummaryView *summaryview)
7937 {
7938         FolderItemUpdateData source;
7939         if (summaryview->folder_item->hide_del_msgs)
7940                 summaryview->folder_item->hide_del_msgs = 0;
7941         else
7942                 summaryview->folder_item->hide_del_msgs = 1;
7943
7944         source.item = summaryview->folder_item;
7945         source.update_flags = F_ITEM_UPDATE_NAME;
7946         source.msg = NULL;
7947         hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST, &source);
7948         summary_show(summaryview, summaryview->folder_item);
7949 }
7950
7951 void summary_toggle_show_read_threads(SummaryView *summaryview)
7952 {
7953         FolderItemUpdateData source;
7954         if (summaryview->folder_item->hide_read_threads)
7955                 summaryview->folder_item->hide_read_threads = 0;
7956         else
7957                 summaryview->folder_item->hide_read_threads = 1;
7958
7959         source.item = summaryview->folder_item;
7960         source.update_flags = F_ITEM_UPDATE_NAME;
7961         source.msg = NULL;
7962         hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST, &source);
7963         summary_show(summaryview, summaryview->folder_item);
7964 }
7965
7966 static void summary_set_hide_menu (SummaryView *summaryview,
7967                                    const gchar *menu_item,
7968                                    guint action)
7969 {
7970         GtkWidget *widget;
7971
7972         widget = gtk_ui_manager_get_widget(summaryview->mainwin->ui_manager, menu_item);
7973         cm_return_if_fail(widget != NULL);
7974
7975         g_object_set_data(G_OBJECT(widget), "dont_toggle",
7976                           GINT_TO_POINTER(1));
7977         gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(widget), action);
7978         g_object_set_data(G_OBJECT(widget), "dont_toggle",
7979                           GINT_TO_POINTER(0));
7980 }
7981
7982 void summary_reflect_prefs_pixmap_theme(SummaryView *summaryview)
7983 {
7984         GtkWidget *pixmap;
7985
7986         stock_pixbuf_gdk(STOCK_PIXMAP_MARK, &markxpm);
7987         stock_pixbuf_gdk(STOCK_PIXMAP_DELETED, &deletedxpm);
7988         stock_pixbuf_gdk(STOCK_PIXMAP_NEW, &newxpm);
7989         stock_pixbuf_gdk(STOCK_PIXMAP_UNREAD, &unreadxpm);
7990         stock_pixbuf_gdk(STOCK_PIXMAP_REPLIED, &repliedxpm);
7991         stock_pixbuf_gdk(STOCK_PIXMAP_FORWARDED, &forwardedxpm);
7992         stock_pixbuf_gdk(STOCK_PIXMAP_REPLIED_AND_FORWARDED, &repliedandforwardedxpm);
7993         stock_pixbuf_gdk(STOCK_PIXMAP_CLIP, &clipxpm);
7994         stock_pixbuf_gdk(STOCK_PIXMAP_LOCKED, &lockedxpm);
7995         stock_pixbuf_gdk(STOCK_PIXMAP_IGNORETHREAD, &ignorethreadxpm);
7996         stock_pixbuf_gdk(STOCK_PIXMAP_WATCHTHREAD, &watchthreadxpm);
7997         stock_pixbuf_gdk(STOCK_PIXMAP_CLIP_KEY, &clipkeyxpm);
7998         stock_pixbuf_gdk(STOCK_PIXMAP_KEY, &keyxpm);
7999         stock_pixbuf_gdk(STOCK_PIXMAP_KEY_SIGN, &keysignxpm);
8000         stock_pixbuf_gdk(STOCK_PIXMAP_GPG_SIGNED, &gpgsignedxpm);
8001         stock_pixbuf_gdk(STOCK_PIXMAP_CLIP_GPG_SIGNED, &clipgpgsignedxpm);
8002         stock_pixbuf_gdk(STOCK_PIXMAP_SPAM, &spamxpm);
8003         stock_pixbuf_gdk(STOCK_PIXMAP_MOVED, &movedxpm);
8004         stock_pixbuf_gdk(STOCK_PIXMAP_COPIED, &copiedxpm);
8005
8006         summary_set_folder_pixmap(summaryview, STOCK_PIXMAP_DIR_OPEN);
8007
8008         pixmap = stock_pixmap_widget(STOCK_PIXMAP_QUICKSEARCH);
8009         gtk_container_remove (GTK_CONTAINER(summaryview->toggle_search),
8010                               summaryview->quick_search_pixmap);
8011         gtk_container_add(GTK_CONTAINER(summaryview->toggle_search), pixmap);
8012         gtk_widget_show(pixmap);
8013         summaryview->quick_search_pixmap = pixmap;
8014
8015 #ifdef GENERIC_UMPC
8016         pixmap = stock_pixmap_widget(STOCK_PIXMAP_SELECTION);
8017         gtk_container_remove (GTK_CONTAINER(summaryview->multiple_sel_togbtn),
8018                               summaryview->multiple_sel_image);
8019         gtk_container_add(GTK_CONTAINER(summaryview->multiple_sel_togbtn), pixmap);
8020         gtk_widget_show(pixmap);
8021         summaryview->multiple_sel_togbtn = pixmap;
8022 #endif
8023
8024         folderview_unselect(summaryview->folderview);
8025         folderview_select(summaryview->folderview, summaryview->folder_item);
8026         summary_set_column_titles(summaryview);
8027 }
8028
8029 void summary_reflect_prefs_custom_colors(SummaryView *summaryview)
8030 {
8031         GtkMenuShell *menu;
8032         GList *children, *cur;
8033
8034         /* re-create colorlabel submenu */
8035         menu = GTK_MENU_SHELL(summaryview->colorlabel_menu);
8036         cm_return_if_fail(menu != NULL);
8037
8038         /* clear items. get item pointers. */
8039         children = gtk_container_get_children(GTK_CONTAINER(menu));
8040         for (cur = children; cur != NULL && cur->data != NULL; cur = cur->next) {
8041                 g_signal_handlers_disconnect_matched
8042                          (gtk_ui_manager_get_accel_group(summaryview->mainwin->ui_manager),
8043                          G_SIGNAL_MATCH_DATA|G_SIGNAL_MATCH_FUNC,
8044                          0, 0, NULL, mainwin_accel_changed_cb, cur->data);
8045                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(cur->data), NULL);
8046         }
8047         g_list_free(children);
8048         summary_colorlabel_menu_create(summaryview, TRUE);
8049 }
8050
8051 /*
8052  * Harvest addresses for selected messages in summary view.
8053  */
8054 void summary_harvest_address(SummaryView *summaryview)
8055 {
8056         GtkCMCTree *ctree = GTK_CMCTREE( summaryview->ctree );
8057         GList *cur;
8058         GList *msgList;
8059         MsgInfo *msginfo;
8060
8061         msgList = NULL;
8062         for( cur = GTK_CMCLIST(ctree)->selection; cur != NULL && cur->data != NULL; cur = cur->next ) {
8063                 msginfo = gtk_cmctree_node_get_row_data( ctree, GTK_CMCTREE_NODE(cur->data) );
8064                 if (!msginfo)
8065                         continue;
8066                 msgList = g_list_append( msgList, GUINT_TO_POINTER( msginfo->msgnum ) );
8067         }
8068
8069         addressbook_harvest( summaryview->folder_item, TRUE, msgList );
8070
8071         g_list_free( msgList );
8072 }
8073
8074 static regex_t *summary_compile_simplify_regexp(gchar *simplify_subject_regexp)
8075 {
8076         int err;
8077         gchar buf[BUFFSIZE];
8078         regex_t *preg = NULL;
8079
8080         preg = g_new0(regex_t, 1);
8081
8082         err = string_match_precompile(simplify_subject_regexp,
8083                                       preg, REG_EXTENDED);
8084         if (err) {
8085                 regerror(err, preg, buf, BUFFSIZE);
8086                 alertpanel_error(_("Regular expression (regexp) error:\n%s"), buf);
8087                 g_free(preg);
8088                 preg = NULL;
8089         }
8090
8091         return preg;
8092 }
8093 void summary_set_prefs_from_folderitem(SummaryView *summaryview, FolderItem *item)
8094 {
8095         FolderSortKey sort_key;
8096         FolderSortType sort_type;
8097         cm_return_if_fail(summaryview != NULL);
8098         cm_return_if_fail(item != NULL);
8099
8100         /* Subject simplification */
8101         if(summaryview->simplify_subject_preg) {
8102                 regfree(summaryview->simplify_subject_preg);
8103                 g_free(summaryview->simplify_subject_preg);
8104                 summaryview->simplify_subject_preg = NULL;
8105         }
8106         if(item->prefs && item->prefs->simplify_subject_regexp &&
8107            item->prefs->simplify_subject_regexp[0] && item->prefs->enable_simplify_subject)
8108                 summaryview->simplify_subject_preg = summary_compile_simplify_regexp(item->prefs->simplify_subject_regexp);
8109
8110         /* Sorting */
8111         sort_key = item->sort_key;
8112         sort_type = item->sort_type;
8113
8114         folder_get_sort_type(item->folder, &sort_key, &sort_type);
8115
8116         summaryview->sort_key = sort_key;
8117         summaryview->sort_type = sort_type;
8118
8119         /* Threading */
8120         summaryview->threaded = item->threaded;
8121         summaryview->thread_collapsed = item->thread_collapsed;
8122
8123         /* Scoring */
8124 }
8125
8126 void summary_save_prefs_to_folderitem(SummaryView *summaryview, FolderItem *item)
8127 {
8128         /* Sorting */
8129         item->sort_key = summaryview->sort_key;
8130         item->sort_type = summaryview->sort_type;
8131
8132         /* Threading */
8133         item->threaded = summaryview->threaded;
8134         item->thread_collapsed = summaryview->thread_collapsed;
8135 }
8136
8137 static gboolean summary_update_msg(gpointer source, gpointer data)
8138 {
8139         MsgInfoUpdate *msginfo_update = (MsgInfoUpdate *) source;
8140         SummaryView *summaryview = (SummaryView *)data;
8141         GtkCMCTreeNode *node;
8142
8143         cm_return_val_if_fail(msginfo_update != NULL, TRUE);
8144         cm_return_val_if_fail(summaryview != NULL, FALSE);
8145
8146         if (msginfo_update->msginfo->folder != summaryview->folder_item)
8147                 return FALSE;
8148
8149         if (msginfo_update->flags & MSGINFO_UPDATE_FLAGS) {
8150                 node = gtk_cmctree_find_by_row_data(
8151                                 GTK_CMCTREE(summaryview->ctree), NULL,
8152                                 msginfo_update->msginfo);
8153
8154                 if (node)
8155                         summary_set_row_marks(summaryview, node);
8156         }
8157
8158         return FALSE;
8159 }
8160
8161 void summary_update_unread(SummaryView *summaryview, FolderItem *removed_item)
8162 {
8163         guint new, unread, unreadmarked, marked, total;
8164         guint replied, forwarded, locked, ignored, watched;
8165         static gboolean tips_initialized = FALSE;
8166
8167         if (prefs_common.layout_mode != SMALL_LAYOUT) {
8168                 if (tips_initialized) {
8169                         summary_set_folder_pixmap(summaryview, STOCK_PIXMAP_DIR_OPEN);
8170                         CLAWS_SET_TIP(summaryview->folder_pixmap_eventbox,
8171                              NULL);
8172                         tips_initialized = FALSE;
8173                 }
8174                 return;
8175         }
8176         folder_count_total_msgs(&new, &unread, &unreadmarked, &marked, &total,
8177                                 &replied, &forwarded, &locked, &ignored,
8178                                 &watched);
8179         if (removed_item) {
8180                 total -= removed_item->total_msgs;
8181                 new -= removed_item->new_msgs;
8182                 unread -= removed_item->unread_msgs;
8183         }
8184
8185         if (new > 0 || unread > 0) {
8186                 tips_initialized = TRUE;
8187                 summary_set_folder_pixmap(summaryview, STOCK_PIXMAP_DIR_OPEN_HRM);
8188                 CLAWS_SET_TIP(summaryview->folder_pixmap_eventbox,
8189                              _("Go back to the folder list (You have unread messages)"));
8190         } else {
8191                 tips_initialized = TRUE;
8192                 summary_set_folder_pixmap(summaryview, STOCK_PIXMAP_DIR_OPEN);
8193                 CLAWS_SET_TIP(summaryview->folder_pixmap_eventbox,
8194                              _("Go back to the folder list"));
8195         }
8196 }
8197
8198 static gboolean summary_update_folder_item_hook(gpointer source, gpointer data)
8199 {
8200         FolderItemUpdateData *hookdata = (FolderItemUpdateData *)source;
8201         SummaryView *summaryview = (SummaryView *)data;
8202
8203         cm_return_val_if_fail(hookdata != NULL, FALSE);
8204         cm_return_val_if_fail(hookdata->item != NULL, FALSE);
8205         cm_return_val_if_fail(summaryview != NULL, FALSE);
8206
8207         if (hookdata->item == summaryview->folder_item &&
8208             hookdata->update_flags & F_ITEM_UPDATE_NAME) {
8209                 gchar *name = folder_item_get_name(hookdata->item);
8210                 gtk_label_set_text(GTK_LABEL(summaryview->statlabel_folder), name);
8211                 g_free(name);
8212         }
8213         summary_update_unread(summaryview, NULL);
8214
8215         return FALSE;
8216 }
8217
8218 static gboolean summary_update_folder_hook(gpointer source, gpointer data)
8219 {
8220         FolderUpdateData *hookdata;
8221         SummaryView *summaryview = (SummaryView *)data;
8222         hookdata = source;
8223         if (hookdata->update_flags & FOLDER_REMOVE_FOLDERITEM) {
8224                 summary_update_unread(summaryview, hookdata->item);
8225         } else
8226                 summary_update_unread(summaryview, NULL);
8227
8228         return FALSE;
8229 }
8230
8231 /*!
8232  *\brief        change summaryview to display your answer(s) to a message
8233  *
8234  *\param        summaryview The SummaryView ;)
8235  *\param        msginfo The message for which answers are searched
8236  *
8237  */
8238 static void summary_find_answers (SummaryView *summaryview, MsgInfo *msg)
8239 {
8240         FolderItem *sent_folder = NULL;
8241         PrefsAccount *account = NULL;
8242         GtkCMCTreeNode *node = NULL;
8243         char *buf = NULL;
8244         if (msg == NULL || msg->msgid == NULL)
8245                 return;
8246
8247         account = account_get_reply_account(msg, prefs_common.reply_account_autosel);
8248         if (account == NULL)
8249                 return;
8250         sent_folder = account_get_special_folder
8251                                 (account, F_OUTBOX);
8252
8253         buf = g_strdup_printf("inreplyto matchcase \"%s\"", msg->msgid);
8254
8255         if (sent_folder != summaryview->folder_item) {
8256                 folderview_select(summaryview->mainwin->folderview, sent_folder);
8257         }
8258
8259         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(summaryview->toggle_search), TRUE);
8260
8261         quicksearch_set(summaryview->quicksearch, ADVANCED_SEARCH_EXTENDED, buf);
8262         g_free(buf);
8263
8264         node = gtk_cmctree_node_nth(GTK_CMCTREE(summaryview->ctree), 0);
8265         if (node)
8266                 summary_select_node(summaryview, node, OPEN_SELECTED_ON_SEARCH_RESULTS);
8267 }
8268
8269 gint summaryview_export_mbox_list(SummaryView *summaryview)
8270 /* return values: -2 skipped, -1 error, 0 OK */
8271 {
8272         GSList *list = summary_get_selected_msg_list(summaryview);
8273         gchar *mbox = filesel_select_file_save(_("Export to mbox file"), NULL);
8274         gint ret;
8275
8276         if (mbox == NULL)
8277                 return -2;
8278         if (list == NULL)
8279                 return -1;
8280
8281         ret = export_list_to_mbox(list, mbox);
8282
8283         g_slist_free(list);
8284         g_free(mbox);
8285
8286         return ret;
8287 }
8288
8289 void summaryview_lock(SummaryView *summaryview, FolderItem *item)
8290 {
8291         if (!summaryview || !summaryview->folder_item || !item) {
8292                 return;
8293         }
8294
8295         if (summaryview->folder_item->folder == item->folder) {
8296                 gtk_widget_set_sensitive(summaryview->ctree, FALSE);
8297         }
8298 }
8299 void summaryview_unlock(SummaryView *summaryview, FolderItem *item)
8300 {
8301         gtk_widget_set_sensitive(summaryview->ctree, TRUE);
8302 }