src/folderview.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2001 Hiroyuki Yamamoto
   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 2 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, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "defs.h"
  21
  22 #include <glib.h>
  23 #include <gdk/gdkkeysyms.h>
  24 #include <gtk/gtkwidget.h>
  25 #include <gtk/gtkscrolledwindow.h>
  26 #include <gtk/gtkctree.h>
  27 #include <gtk/gtkcontainer.h>
  28 #include <gtk/gtkclist.h>
  29 #include <gtk/gtkstyle.h>
  30 #include <gtk/gtksignal.h>
  31 #include <gtk/gtkmain.h>
  32 #include <gtk/gtkstatusbar.h>
  33 #include <gtk/gtkmenu.h>
  34 #include <gtk/gtkmenuitem.h>
  35 #include <gtk/gtkitemfactory.h>
  36 #include <stdio.h>
  37 #include <string.h>
  38 #include <stdlib.h>
  39
  40 #include "intl.h"
  41 #include "main.h"
  42 #include "mainwindow.h"
  43 #include "folderview.h"
  44 #include "summaryview.h"
  45 #include "summary_search.h"
  46 #include "inputdialog.h"
  47 #include "grouplistdialog.h"
  48 #include "manage_window.h"
  49 #include "alertpanel.h"
  50 #include "menu.h"
  51 #include "procmsg.h"
  52 #include "utils.h"
  53 #include "gtkutils.h"
  54 #include "prefs_common.h"
  55 #include "prefs_account.h"
  56 #include "account.h"
  57 #include "folder.h"
  58 #include "inc.h"
  59
  60 #include "pixmaps/inbox.xpm"
  61 #include "pixmaps/outbox.xpm"
  62 #include "pixmaps/dir-close.xpm"
  63 #include "pixmaps/dir-open.xpm"
  64 #include "pixmaps/dir-open-hrm.xpm"
  65 #include "pixmaps/trash.xpm"
  66
  67 typedef enum
  68 {
  69         COL_FOLDER      = 0,
  70         COL_NEW         = 1,
  71         COL_UNREAD      = 2,
  72         COL_TOTAL       = 3
  73 } FolderColumnPos;
  74
  75 #define N_FOLDER_COLS           4
  76 #define COL_FOLDER_WIDTH        150
  77 #define COL_NUM_WIDTH           32
  78
  79 #define STATUSBAR_PUSH(mainwin, str) \
  80 { \
  81         gtk_statusbar_push(GTK_STATUSBAR(mainwin->statusbar), \
  82                            mainwin->folderview_cid, str); \
  83         gtkut_widget_wait_for_draw(mainwin->hbox_stat); \
  84 }
  85
  86 #define STATUSBAR_POP(mainwin) \
  87 { \
  88         gtk_statusbar_pop(GTK_STATUSBAR(mainwin->statusbar), \
  89                           mainwin->folderview_cid); \
  90 }
  91
  92 static GList *folderview_list = NULL;
  93
  94 static GdkFont *normalfont;
  95 static GdkFont *boldfont;
  96
  97 static GtkStyle *normal_style;
  98 static GtkStyle *normal_color_style;
  99 static GtkStyle *bold_style;
 100 static GtkStyle *bold_color_style;
 101 static GtkStyle *bold_tgtfold_style;
 102
 103 static GdkPixmap *inboxxpm;
 104 static GdkBitmap *inboxxpmmask;
 105 static GdkPixmap *outboxxpm;
 106 static GdkBitmap *outboxxpmmask;
 107 static GdkPixmap *folderxpm;
 108 static GdkBitmap *folderxpmmask;
 109 static GdkPixmap *folderopenxpm;
 110 static GdkBitmap *folderopenxpmmask;
 111 static GdkPixmap *folderopenhrmxpm;
 112 static GdkBitmap *folderopenhrmxpmmask;
 113 static GdkPixmap *trashxpm;
 114 static GdkBitmap *trashxpmmask;
 115
 116 static void folderview_select_node       (FolderView    *folderview,
 117                                           GtkCTreeNode  *node);
 118 static void folderview_set_folders       (FolderView    *folderview);
 119 static void folderview_sort_folders      (FolderView    *folderview,
 120                                           GtkCTreeNode  *root,
 121                                           Folder        *folder);
 122 static void folderview_append_folder     (FolderView    *folderview,
 123                                           Folder        *folder);
 124 static void folderview_update_node       (FolderView    *folderview,
 125                                           GtkCTreeNode  *node);
 126
 127 static GtkCTreeNode *folderview_find_by_name    (GtkCTree       *ctree,
 128                                                  GtkCTreeNode   *node,
 129                                                  const gchar    *name);
 130
 131 static gint folderview_compare_name     (gconstpointer   a,
 132                                          gconstpointer   b);
 133
 134 /* callback functions */
 135 static void folderview_button_pressed   (GtkWidget      *ctree,
 136                                          GdkEventButton *event,
 137                                          FolderView     *folderview);
 138 static void folderview_button_released  (GtkWidget      *ctree,
 139                                          GdkEventButton *event,
 140                                          FolderView     *folderview);
 141 static void folderview_key_pressed      (GtkWidget      *widget,
 142                                          GdkEventKey    *event,
 143                                          FolderView     *folderview);
 144 static void folderview_selected         (GtkCTree       *ctree,
 145                                          GtkCTreeNode   *row,
 146                                          gint            column,
 147                                          FolderView     *folderview);
 148 static void folderview_tree_expanded    (GtkCTree       *ctree,
 149                                          GtkCTreeNode   *node,
 150                                          FolderView     *folderview);
 151 static void folderview_tree_collapsed   (GtkCTree       *ctree,
 152                                          GtkCTreeNode   *node,
 153                                          FolderView     *folderview);
 154 static void folderview_popup_close      (GtkMenuShell   *menu_shell,
 155                                          FolderView     *folderview);
 156 static void folderview_col_resized      (GtkCList       *clist,
 157                                          gint            column,
 158                                          gint            width,
 159                                          FolderView     *folderview);
 160
 161 static void folderview_update_tree_cb   (FolderView     *folderview,
 162                                          guint           action,
 163                                          GtkWidget      *widget);
 164
 165 static void folderview_new_folder_cb    (FolderView     *folderview,
 166                                          guint           action,
 167                                          GtkWidget      *widget);
 168 static void folderview_new_mbox_folder_cb(FolderView *folderview,
 169                                           guint action,
 170                                           GtkWidget *widget);
 171 static void folderview_rename_folder_cb (FolderView     *folderview,
 172                                          guint           action,
 173                                          GtkWidget      *widget);
 174 static void folderview_rename_mbox_folder_cb(FolderView *folderview,
 175                                              guint action,
 176                                              GtkWidget *widget);
 177 static void folderview_delete_folder_cb (FolderView     *folderview,
 178                                          guint           action,
 179                                          GtkWidget      *widget);
 180 static void folderview_remove_mailbox_cb(FolderView     *folderview,
 181                                          guint           action,
 182                                          GtkWidget      *widget);
 183
 184 static void folderview_new_imap_folder_cb(FolderView    *folderview,
 185                                           guint          action,
 186                                           GtkWidget     *widget);
 187 static void folderview_rm_imap_folder_cb (FolderView    *folderview,
 188                                           guint          action,
 189                                           GtkWidget     *widget);
 190 static void folderview_rm_imap_server_cb (FolderView    *folderview,
 191                                           guint          action,
 192                                           GtkWidget     *widget);
 193
 194 static void folderview_new_news_group_cb(FolderView     *folderview,
 195                                          guint           action,
 196                                          GtkWidget      *widget);
 197 static void folderview_rm_news_group_cb (FolderView     *folderview,
 198                                          guint           action,
 199                                          GtkWidget      *widget);
 200 static void folderview_rm_news_server_cb(FolderView     *folderview,
 201                                          guint           action,
 202                                          GtkWidget      *widget);
 203
 204 static void folderview_search_cb        (FolderView     *folderview,
 205                                          guint           action,
 206                                          GtkWidget      *widget);
 207
 208 static gboolean folderview_drag_motion_cb(GtkWidget      *widget,
 209                                           GdkDragContext *context,
 210                                           gint            x,
 211                                           gint            y,
 212                                           guint           time,
 213                                           FolderView     *folderview);
 214 static void folderview_drag_leave_cb     (GtkWidget        *widget,
 215                                           GdkDragContext   *context,
 216                                           guint             time,
 217                                           FolderView       *folderview);
 218 static void folderview_drag_received_cb  (GtkWidget        *widget,
 219                                           GdkDragContext   *drag_context,
 220                                           gint              x,
 221                                           gint              y,
 222                                           GtkSelectionData *data,
 223                                           guint             info,
 224                                           guint             time,
 225                                           FolderView       *folderview);
 226 static void folderview_scoring_cb(FolderView *folderview, guint action,
 227                                   GtkWidget *widget);
 228 static void folderview_processing_cb(FolderView *folderview, guint action,
 229                                      GtkWidget *widget);
 230 static void folderview_property_cb(FolderView *folderview, guint action, GtkWidget *widget);
 231
 232 static GtkItemFactoryEntry folderview_mbox_popup_entries[] =
 233 {
 234         {N_("/Create _new folder..."),  NULL, folderview_new_mbox_folder_cb,    0, NULL},
 235         {N_("/_Rename folder..."),      NULL, folderview_rename_mbox_folder_cb, 0, NULL},
 236         {N_("/_Delete folder"),         NULL, folderview_delete_folder_cb, 0, NULL},
 237         {N_("/---"),                    NULL, NULL, 0, "<Separator>"},
 238         {N_("/Remove _mailbox"),        NULL, folderview_remove_mailbox_cb, 0, NULL},
 239         {N_("/---"),                    NULL, NULL, 0, "<Separator>"},
 240         {N_("/_Property..."),           NULL, NULL, 0, NULL},
 241         {N_("/_Processing..."),         NULL, folderview_processing_cb, 0, NULL},
 242         {N_("/_Scoring..."),            NULL, folderview_scoring_cb, 0, NULL}
 243 };
 244
 245 static GtkItemFactoryEntry folderview_mail_popup_entries[] =
 246 {
 247         {N_("/Create _new folder..."),  NULL, folderview_new_folder_cb,    0, NULL},
 248         {N_("/_Rename folder..."),      NULL, folderview_rename_folder_cb, 0, NULL},
 249         {N_("/_Delete folder"),         NULL, folderview_delete_folder_cb, 0, NULL},
 250         {N_("/---"),                    NULL, NULL, 0, "<Separator>"},
 251         {N_("/_Update folder tree"),    NULL, folderview_update_tree_cb, 0, NULL},
 252         {N_("/R_escan folder tree"),    NULL, folderview_update_tree_cb, 1, NULL},
 253         {N_("/---"),                    NULL, NULL, 0, "<Separator>"},
 254         {N_("/Remove _mailbox"),        NULL, folderview_remove_mailbox_cb, 0, NULL},
 255         {N_("/---"),                    NULL, NULL, 0, "<Separator>"},
 256         {N_("/_Search folder..."),      NULL, folderview_search_cb, 0, NULL},
 257         {N_("/_Property..."),           NULL, folderview_property_cb, 0, NULL},
 258         {N_("/_Processing..."),         NULL, folderview_processing_cb, 0, NULL},
 259         {N_("/S_coring..."),            NULL, folderview_scoring_cb, 0, NULL}
 260 };
 261
 262 static GtkItemFactoryEntry folderview_imap_popup_entries[] =
 263 {
 264         {N_("/Create _new folder..."),  NULL, folderview_new_imap_folder_cb, 0, NULL},
 265         {N_("/_Rename folder..."),      NULL, NULL, 0, NULL},
 266         {N_("/_Delete folder"),         NULL, folderview_rm_imap_folder_cb, 0, NULL},
 267         {N_("/---"),                    NULL, NULL, 0, "<Separator>"},
 268         {N_("/_Update folder tree"),    NULL, folderview_update_tree_cb, 0, NULL},
 269         {N_("/R_escan folder tree"),    NULL, folderview_update_tree_cb, 1, NULL},
 270         {N_("/---"),                    NULL, NULL, 0, "<Separator>"},
 271         {N_("/Remove _IMAP4 account"),  NULL, folderview_rm_imap_server_cb, 0, NULL},
 272         {N_("/---"),                    NULL, NULL, 0, "<Separator>"},
 273         {N_("/_Search folder..."),      NULL, folderview_search_cb, 0, NULL},
 274         {N_("/_Property..."),           NULL, NULL, 0, NULL},
 275         {N_("/_Processing..."),         NULL, folderview_processing_cb, 0, NULL},
 276         {N_("/S_coring..."),            NULL, folderview_scoring_cb, 0, NULL}
 277 };
 278
 279 static GtkItemFactoryEntry folderview_news_popup_entries[] =
 280 {
 281         {N_("/_Subscribe to newsgroup..."),
 282                                          NULL, folderview_new_news_group_cb, 0, NULL},
 283         {N_("/_Remove newsgroup"),       NULL, folderview_rm_news_group_cb, 0, NULL},
 284         {N_("/---"),                     NULL, NULL, 0, "<Separator>"},
 285         {N_("/Remove _news account"),    NULL, folderview_rm_news_server_cb, 0, NULL},
 286         {N_("/---"),                     NULL, NULL, 0, "<Separator>"},
 287         {N_("/_Search folder..."),       NULL, folderview_search_cb, 0, NULL},
 288         {N_("/_Property..."),            NULL, NULL, 0, NULL},
 289         {N_("/_Processing..."),          NULL, folderview_processing_cb, 0, NULL},
 290         {N_("/S_coring..."),            NULL, folderview_scoring_cb, 0, NULL}
 291 };
 292
 293
 294 FolderView *folderview_create(void)
 295 {
 296         FolderView *folderview;
 297         GtkWidget *scrolledwin;
 298         GtkWidget *ctree;
 299         gchar *titles[N_FOLDER_COLS] = {_("Folder"), _("New"),
 300                                         _("Unread"), _("#")};
 301         GtkWidget *mail_popup;
 302         GtkWidget *news_popup;
 303         GtkWidget *imap_popup;
 304         GtkWidget *mbox_popup;
 305         GtkItemFactory *mail_factory;
 306         GtkItemFactory *news_factory;
 307         GtkItemFactory *imap_factory;
 308         GtkItemFactory *mbox_factory;
 309         gint n_entries;
 310         gint i;
 311
 312         debug_print(_("Creating folder view...\n"));
 313         folderview = g_new0(FolderView, 1);
 314
 315         scrolledwin = gtk_scrolled_window_new(NULL, NULL);
 316         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
 317                                        GTK_POLICY_AUTOMATIC,
 318                                        GTK_POLICY_ALWAYS);
 319         gtk_widget_set_usize(scrolledwin,
 320                              prefs_common.folderview_width,
 321                              prefs_common.folderview_height);
 322
 323         ctree = gtk_ctree_new_with_titles(N_FOLDER_COLS, COL_FOLDER, titles);
 324         gtk_container_add(GTK_CONTAINER(scrolledwin), ctree);
 325         gtk_clist_set_selection_mode(GTK_CLIST(ctree), GTK_SELECTION_BROWSE);
 326         gtk_clist_set_column_justification(GTK_CLIST(ctree), COL_NEW,
 327                                            GTK_JUSTIFY_RIGHT);
 328         gtk_clist_set_column_justification(GTK_CLIST(ctree), COL_UNREAD,
 329                                            GTK_JUSTIFY_RIGHT);
 330         gtk_clist_set_column_justification(GTK_CLIST(ctree), COL_TOTAL,
 331                                            GTK_JUSTIFY_RIGHT);
 332         gtk_clist_set_column_width(GTK_CLIST(ctree), COL_FOLDER,
 333                                    prefs_common.folder_col_folder);
 334         gtk_clist_set_column_width(GTK_CLIST(ctree), COL_NEW,
 335                                    prefs_common.folder_col_new);
 336         gtk_clist_set_column_width(GTK_CLIST(ctree), COL_UNREAD,
 337                                    prefs_common.folder_col_unread);
 338         gtk_clist_set_column_width(GTK_CLIST(ctree), COL_TOTAL,
 339                                    prefs_common.folder_col_total);
 340         gtk_ctree_set_line_style(GTK_CTREE(ctree), GTK_CTREE_LINES_DOTTED);
 341         gtk_ctree_set_expander_style(GTK_CTREE(ctree),
 342                                      GTK_CTREE_EXPANDER_SQUARE);
 343         gtk_ctree_set_indent(GTK_CTREE(ctree), CTREE_INDENT);
 344
 345         /* don't let title buttons take key focus */
 346         for (i = 0; i < N_FOLDER_COLS; i++)
 347                 GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(ctree)->column[i].button,
 348                                        GTK_CAN_FOCUS);
 349
 350         /* popup menu */
 351         n_entries = sizeof(folderview_mail_popup_entries) /
 352                 sizeof(folderview_mail_popup_entries[0]);
 353         mail_popup = menu_create_items(folderview_mail_popup_entries,
 354                                        n_entries,
 355                                        "<MailFolder>", &mail_factory,
 356                                        folderview);
 357         n_entries = sizeof(folderview_imap_popup_entries) /
 358                 sizeof(folderview_imap_popup_entries[0]);
 359         imap_popup = menu_create_items(folderview_imap_popup_entries,
 360                                        n_entries,
 361                                        "<IMAPFolder>", &imap_factory,
 362                                        folderview);
 363         n_entries = sizeof(folderview_news_popup_entries) /
 364                 sizeof(folderview_news_popup_entries[0]);
 365         news_popup = menu_create_items(folderview_news_popup_entries,
 366                                        n_entries,
 367                                        "<NewsFolder>", &news_factory,
 368                                        folderview);
 369         n_entries = sizeof(folderview_mbox_popup_entries) /
 370                 sizeof(folderview_mbox_popup_entries[0]);
 371         mbox_popup = menu_create_items(folderview_mbox_popup_entries,
 372                                        n_entries,
 373                                        "<MailFolder>", &mbox_factory,
 374                                        folderview);
 375
 376         gtk_signal_connect(GTK_OBJECT(ctree), "key_press_event",
 377                            GTK_SIGNAL_FUNC(folderview_key_pressed),
 378                            folderview);
 379         gtk_signal_connect(GTK_OBJECT(ctree), "button_press_event",
 380                            GTK_SIGNAL_FUNC(folderview_button_pressed),
 381                            folderview);
 382         gtk_signal_connect(GTK_OBJECT(ctree), "button_release_event",
 383                            GTK_SIGNAL_FUNC(folderview_button_released),
 384                            folderview);
 385         gtk_signal_connect(GTK_OBJECT(ctree), "tree_select_row",
 386                            GTK_SIGNAL_FUNC(folderview_selected), folderview);
 387
 388         gtk_signal_connect_after(GTK_OBJECT(ctree), "tree_expand",
 389                                  GTK_SIGNAL_FUNC(folderview_tree_expanded),
 390                                  folderview);
 391         gtk_signal_connect_after(GTK_OBJECT(ctree), "tree_collapse",
 392                                  GTK_SIGNAL_FUNC(folderview_tree_collapsed),
 393                                  folderview);
 394
 395         gtk_signal_connect(GTK_OBJECT(ctree), "resize_column",
 396                            GTK_SIGNAL_FUNC(folderview_col_resized),
 397                            folderview);
 398
 399         gtk_signal_connect(GTK_OBJECT(mail_popup), "selection_done",
 400                            GTK_SIGNAL_FUNC(folderview_popup_close),
 401                            folderview);
 402         gtk_signal_connect(GTK_OBJECT(imap_popup), "selection_done",
 403                            GTK_SIGNAL_FUNC(folderview_popup_close),
 404                            folderview);
 405         gtk_signal_connect(GTK_OBJECT(news_popup), "selection_done",
 406                            GTK_SIGNAL_FUNC(folderview_popup_close),
 407                            folderview);
 408         gtk_signal_connect(GTK_OBJECT(mbox_popup), "selection_done",
 409                            GTK_SIGNAL_FUNC(folderview_popup_close),
 410                            folderview);
 411
 412         /* drop callback */
 413         gtk_drag_dest_set(ctree, GTK_DEST_DEFAULT_ALL &
 414                           ~GTK_DEST_DEFAULT_HIGHLIGHT,
 415                           summary_drag_types, 1,
 416                           GDK_ACTION_MOVE);
 417         gtk_signal_connect(GTK_OBJECT(ctree), "drag_motion",
 418                            GTK_SIGNAL_FUNC(folderview_drag_motion_cb),
 419                            folderview);
 420         gtk_signal_connect(GTK_OBJECT(ctree), "drag_leave",
 421                            GTK_SIGNAL_FUNC(folderview_drag_leave_cb),
 422                            folderview);
 423         gtk_signal_connect(GTK_OBJECT(ctree), "drag_data_received",
 424                            GTK_SIGNAL_FUNC(folderview_drag_received_cb),
 425                            folderview);
 426
 427         folderview->scrolledwin  = scrolledwin;
 428         folderview->ctree        = ctree;
 429         folderview->mail_popup   = mail_popup;
 430         folderview->mail_factory = mail_factory;
 431         folderview->imap_popup   = imap_popup;
 432         folderview->imap_factory = imap_factory;
 433         folderview->news_popup   = news_popup;
 434         folderview->news_factory = news_factory;
 435         folderview->mbox_popup   = mbox_popup;
 436         folderview->mbox_factory = mbox_factory;
 437
 438         gtk_widget_show_all(scrolledwin);
 439
 440         folderview_list = g_list_append(folderview_list, folderview);
 441
 442         return folderview;
 443 }
 444
 445 void folderview_init(FolderView *folderview)
 446 {
 447         GtkWidget *ctree = folderview->ctree;
 448
 449         PIXMAP_CREATE(ctree, inboxxpm, inboxxpmmask, inbox_xpm);
 450         PIXMAP_CREATE(ctree, outboxxpm, outboxxpmmask, outbox_xpm);
 451         PIXMAP_CREATE(ctree, folderxpm, folderxpmmask, dir_close_xpm);
 452         PIXMAP_CREATE(ctree, folderopenxpm, folderopenxpmmask, dir_open_xpm);
 453         PIXMAP_CREATE(ctree, folderopenhrmxpm, folderopenhrmxpmmask,
 454                       dir_open_hrm_xpm);
 455         PIXMAP_CREATE(ctree, trashxpm, trashxpmmask, trash_xpm);
 456
 457         if (!normalfont)
 458                 normalfont = gdk_fontset_load(NORMAL_FONT);
 459         if (!boldfont)
 460                 boldfont = gdk_fontset_load(BOLD_FONT);
 461
 462         if (!bold_style) {
 463                 bold_style = gtk_style_copy(gtk_widget_get_style(ctree));
 464                 bold_style->font = boldfont;
 465                 bold_color_style = gtk_style_copy(bold_style);
 466                 bold_color_style->fg[GTK_STATE_NORMAL] = folderview->color_new;
 467
 468                 bold_tgtfold_style = gtk_style_copy(bold_style);
 469                 bold_tgtfold_style->fg[GTK_STATE_NORMAL] = folderview->color_op;
 470         }
 471         if (!normal_style) {
 472                 normal_style = gtk_style_copy(gtk_widget_get_style(ctree));
 473                 normal_style->font = normalfont;
 474                 normal_color_style = gtk_style_copy(normal_style);
 475                 normal_color_style->fg[GTK_STATE_NORMAL] = folderview->color_new;
 476         }
 477 }
 478
 479 void folderview_set(FolderView *folderview)
 480 {
 481         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
 482         MainWindow *mainwin = folderview->mainwin;
 483
 484         debug_print(_("Setting folder info...\n"));
 485         STATUSBAR_PUSH(mainwin, _("Setting folder info..."));
 486
 487         main_window_cursor_wait(mainwin);
 488
 489         folderview->selected = NULL;
 490         folderview->opened = NULL;
 491
 492         gtk_clist_freeze(GTK_CLIST(ctree));
 493         gtk_clist_clear(GTK_CLIST(ctree));
 494         gtk_clist_thaw(GTK_CLIST(ctree));
 495         gtk_clist_freeze(GTK_CLIST(ctree));
 496
 497         folderview_set_folders(folderview);
 498
 499         gtk_clist_thaw(GTK_CLIST(ctree));
 500         main_window_cursor_normal(mainwin);
 501         STATUSBAR_POP(mainwin);
 502 }
 503
 504 void folderview_set_all(void)
 505 {
 506         GList *list;
 507
 508         for (list = folderview_list; list != NULL; list = list->next)
 509                 folderview_set((FolderView *)list->data);
 510 }
 511
 512 void folderview_select(FolderView *folderview, FolderItem *item)
 513 {
 514         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
 515         GtkCTreeNode *node;
 516         GtkCTreeNode *old_selected = folderview->selected;
 517
 518         if (!item) return;
 519
 520         node = gtk_ctree_find_by_row_data(ctree, NULL, item);
 521         if (node) folderview_select_node(folderview, node);
 522
 523         if (old_selected != node)
 524                 folder_update_op_count();
 525 }
 526
 527 static void folderview_select_node(FolderView *folderview, GtkCTreeNode *node)
 528 {
 529         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
 530
 531         g_return_if_fail(node != NULL);
 532
 533         folderview->open_folder = TRUE;
 534         gtk_ctree_select(ctree, node);
 535         gtkut_ctree_set_focus_row(ctree, node);
 536         if (folderview->summaryview->messages > 0)
 537                 gtk_widget_grab_focus(folderview->summaryview->ctree);
 538         else
 539                 gtk_widget_grab_focus(folderview->ctree);
 540
 541         gtkut_ctree_expand_parent_all(ctree, node);
 542 }
 543
 544 void folderview_unselect(FolderView *folderview)
 545 {
 546         if (folderview->opened && !GTK_CTREE_ROW(folderview->opened)->children)
 547                 gtk_ctree_collapse
 548                         (GTK_CTREE(folderview->ctree), folderview->opened);
 549
 550         folderview->selected = folderview->opened = NULL;
 551 }
 552
 553 static GtkCTreeNode *folderview_find_next_unread(GtkCTree *ctree,
 554                                                  GtkCTreeNode *node)
 555 {
 556         FolderItem *item;
 557
 558         if (node)
 559                 node = gtkut_ctree_node_next(ctree, node);
 560         else
 561                 node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list);
 562
 563         for (; node != NULL; node = gtkut_ctree_node_next(ctree, node)) {
 564                 item = gtk_ctree_node_get_row_data(ctree, node);
 565                 if (item && item->unread > 0 && item->stype != F_TRASH)
 566                         return node;
 567         }
 568
 569         return NULL;
 570 }
 571
 572 void folderview_select_next_unread(FolderView *folderview)
 573 {
 574         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
 575         GtkCTreeNode *node = NULL;
 576
 577         if ((node = folderview_find_next_unread(ctree, folderview->opened))
 578             != NULL) {
 579                 folderview_select_node(folderview, node);
 580                 return;
 581         }
 582
 583         if (!folderview->opened ||
 584             folderview->opened == GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list))
 585                 return;
 586         /* search again from the first node */
 587         if ((node = folderview_find_next_unread(ctree, NULL)) != NULL)
 588                 folderview_select_node(folderview, node);
 589 }
 590
 591 void folderview_update_msg_num(FolderView *folderview, GtkCTreeNode *row,
 592                                gint new, gint unread, gint total)
 593 {
 594         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
 595         static GtkCTreeNode *prev_row = NULL;
 596         FolderItem *item;
 597
 598         if (!row) return;
 599
 600         item = gtk_ctree_node_get_row_data(ctree, row);
 601         if (!item) return;
 602
 603         /* CLAWS: don't know why but this always seems to be true
 604          * when deleting messages. Somewhere claws does a folder
 605          * scan which sets all new, unread & total to the correct
 606          * values. It then enters this function, but leaves it
 607          * because new, unread and total are the same... */
 608 #ifndef CLAWS
 609         if (prev_row     == row    &&
 610             item->new    == new    &&
 611             item->unread == unread &&
 612             item->total  == total)
 613                 return;
 614 #endif
 615
 616         prev_row = row;
 617
 618         item->new    = new;
 619         item->unread = unread;
 620         item->total  = total;
 621
 622         folderview_update_node(folderview, row);
 623 }
 624
 625 static void folderview_set_folders(FolderView *folderview)
 626 {
 627         GList *list;
 628
 629         list = folder_get_list();
 630
 631         for (; list != NULL; list = list->next)
 632                 folderview_append_folder(folderview, FOLDER(list->data));
 633 }
 634
 635 static void folderview_scan_tree_func(Folder *folder, FolderItem *item,
 636                                       gpointer data)
 637 {
 638         GList *list;
 639         gchar *rootpath;
 640
 641         if (FOLDER_IS_LOCAL(folder))
 642                 rootpath = LOCAL_FOLDER(folder)->rootpath;
 643         else if (folder->type == F_IMAP && folder->account &&
 644                  folder->account->recv_server)
 645                 rootpath = folder->account->recv_server;
 646         else
 647                 return;
 648
 649         for (list = folderview_list; list != NULL; list = list->next) {
 650                 FolderView *folderview = (FolderView *)list->data;
 651                 MainWindow *mainwin = folderview->mainwin;
 652                 gchar *str;
 653
 654                 if (item->path)
 655                         str = g_strdup_printf(_("Scanning folder %s%c%s ..."),
 656                                               rootpath, G_DIR_SEPARATOR,
 657                                               item->path);
 658                 else
 659                         str = g_strdup_printf(_("Scanning folder %s ..."),
 660                                               rootpath);
 661
 662                 STATUSBAR_PUSH(mainwin, str);
 663                 STATUSBAR_POP(mainwin);
 664                 g_free(str);
 665         }
 666 }
 667
 668 static GtkWidget *label_window_create(const gchar *str)
 669 {
 670         GtkWidget *window;
 671         GtkWidget *label;
 672
 673         window = gtk_window_new(GTK_WINDOW_DIALOG);
 674         gtk_widget_set_usize(window, 380, 60);
 675         gtk_container_set_border_width(GTK_CONTAINER(window), 8);
 676         gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
 677         gtk_window_set_title(GTK_WINDOW(window), str);
 678         gtk_window_set_modal(GTK_WINDOW(window), TRUE);
 679         gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
 680         manage_window_set_transient(GTK_WINDOW(window));
 681
 682         label = gtk_label_new(str);
 683         gtk_container_add(GTK_CONTAINER(window), label);
 684         gtk_widget_show(label);
 685
 686         gtk_widget_show_now(window);
 687
 688         return window;
 689 }
 690
 691 void folderview_update_tree(Folder *folder)
 692 {
 693         GtkWidget *window;
 694
 695         g_return_if_fail(folder != NULL);
 696
 697         if (!folder->scan_tree) return;
 698
 699         inc_lock();
 700         window = label_window_create(_("Rescanning folder tree..."));
 701
 702         folder_set_ui_func(folder, folderview_scan_tree_func, NULL);
 703         folder->scan_tree(folder);
 704         folder_set_ui_func(folder, NULL, NULL);
 705
 706         folder_write_list();
 707         folderview_set_all();
 708
 709         gtk_widget_destroy(window);
 710         inc_unlock();
 711 }
 712
 713 void folderview_update_all(void)
 714 {
 715         GList *list;
 716         GtkWidget *window;
 717
 718         inc_lock();
 719         window = label_window_create(_("Rescanning all folder trees..."));
 720
 721         list = folder_get_list();
 722         for (; list != NULL; list = list->next) {
 723                 Folder *folder = list->data;
 724
 725                 if (!folder->scan_tree) continue;
 726                 folder_set_ui_func(folder, folderview_scan_tree_func, NULL);
 727                 folder->scan_tree(folder);
 728                 folder_set_ui_func(folder, NULL, NULL);
 729         }
 730
 731         folder_write_list();
 732         folderview_set_all();
 733         gtk_widget_destroy(window);
 734         inc_unlock();
 735 }
 736
 737 void folderview_update_all_node(void)
 738 {
 739         GList *list;
 740         FolderItem *item;
 741         FolderView *folderview;
 742         GtkCTree *ctree;
 743         GtkCTreeNode *node;
 744
 745         for (list = folderview_list; list != NULL; list = list->next) {
 746                 folderview = (FolderView *)list->data;
 747                 ctree = GTK_CTREE(folderview->ctree);
 748
 749                 inc_lock();
 750                 main_window_lock(folderview->mainwin);
 751                 gtk_widget_set_sensitive(folderview->ctree, FALSE);
 752
 753                 for (node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list);
 754                      node != NULL; node = gtkut_ctree_node_next(ctree, node)) {
 755                         item = gtk_ctree_node_get_row_data(ctree, node);
 756                         if (!item || !FOLDER_IS_LOCAL(item->folder) ||
 757                             !item->path)
 758                                 continue;
 759                         folderview_scan_tree_func(item->folder, item, NULL);
 760                         folder_item_scan(item);
 761                         folderview_update_node(folderview, node);
 762                 }
 763
 764                 gtk_widget_set_sensitive(folderview->ctree, TRUE);
 765                 main_window_unlock(folderview->mainwin);
 766                 inc_unlock();
 767         }
 768
 769         folder_write_list();
 770 }
 771
 772 static gboolean folderview_search_new_recursive(GtkCTree *ctree,
 773                                                 GtkCTreeNode *node)
 774 {
 775         FolderItem *item;
 776
 777         if (node) {
 778                 item = gtk_ctree_node_get_row_data(ctree, node);
 779                 if (item) {
 780                         if (item->new > 0 ||
 781                             (item->stype == F_QUEUE && item->total > 0))
 782                                 return TRUE;
 783                 }
 784                 node = GTK_CTREE_ROW(node)->children;
 785         } else
 786                 node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list);
 787
 788         while (node) {
 789                 if (folderview_search_new_recursive(ctree, node) == TRUE)
 790                         return TRUE;
 791                 node = GTK_CTREE_ROW(node)->sibling;
 792         }
 793
 794         return FALSE;
 795 }
 796
 797 static gboolean folderview_have_new_children(FolderView *folderview,
 798                                              GtkCTreeNode *node)
 799 {
 800         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
 801
 802         if (!node)
 803                 node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list);
 804         if (!node)
 805                 return FALSE;
 806
 807         node = GTK_CTREE_ROW(node)->children;
 808
 809         while (node) {
 810                 if (folderview_search_new_recursive(ctree, node) == TRUE)
 811                         return TRUE;
 812                 node = GTK_CTREE_ROW(node)->sibling;
 813         }
 814
 815         return FALSE;
 816 }
 817
 818 static gboolean folderview_search_unread_recursive(GtkCTree *ctree,
 819                                                    GtkCTreeNode *node)
 820 {
 821         FolderItem *item;
 822
 823         if (node) {
 824                 item = gtk_ctree_node_get_row_data(ctree, node);
 825                 if (item) {
 826                         if (item->unread > 0 ||
 827                             (item->stype == F_QUEUE && item->total > 0))
 828                                 return TRUE;
 829                 }
 830                 node = GTK_CTREE_ROW(node)->children;
 831         } else
 832                 node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list);
 833
 834         while (node) {
 835                 if (folderview_search_unread_recursive(ctree, node) == TRUE)
 836                         return TRUE;
 837                 node = GTK_CTREE_ROW(node)->sibling;
 838         }
 839
 840         return FALSE;
 841 }
 842
 843 static gboolean folderview_have_unread_children(FolderView *folderview,
 844                                                 GtkCTreeNode *node)
 845 {
 846         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
 847
 848         if (!node)
 849                 node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list);
 850         if (!node)
 851                 return FALSE;
 852
 853         node = GTK_CTREE_ROW(node)->children;
 854
 855         while (node) {
 856                 if (folderview_search_unread_recursive(ctree, node) == TRUE)
 857                         return TRUE;
 858                 node = GTK_CTREE_ROW(node)->sibling;
 859         }
 860
 861         return FALSE;
 862 }
 863
 864 static void folderview_update_node(FolderView *folderview, GtkCTreeNode *node)
 865 {
 866         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
 867         GtkStyle *style = NULL;
 868         FolderItem *item;
 869         GdkPixmap *xpm, *openxpm;
 870         GdkBitmap *mask, *openmask;
 871         gchar *name;
 872         gchar *str;
 873         gboolean add_unread_mark;
 874         gboolean use_bold, use_color;
 875
 876         item = gtk_ctree_node_get_row_data(ctree, node);
 877         g_return_if_fail(item != NULL);
 878
 879         switch (item->stype) {
 880         case F_INBOX:
 881                 xpm = openxpm = inboxxpm;
 882                 mask = openmask = inboxxpmmask;
 883                 name = g_strdup(_("Inbox"));
 884                 break;
 885         case F_OUTBOX:
 886                 xpm = openxpm = outboxxpm;
 887                 mask = openmask = outboxxpmmask;
 888                 name = g_strdup(_("Outbox"));
 889                 break;
 890         case F_QUEUE:
 891                 xpm = openxpm = outboxxpm;
 892                 mask = openmask = outboxxpmmask;
 893                 name = g_strdup(_("Queue"));
 894                 break;
 895         case F_TRASH:
 896                 xpm = openxpm = trashxpm;
 897                 mask = openmask = trashxpmmask;
 898                 name = g_strdup(_("Trash"));
 899                 break;
 900         case F_DRAFT:
 901                 xpm = folderxpm;
 902                 mask = folderxpmmask;
 903                 openxpm = folderopenxpm;
 904                 openmask = folderopenxpmmask;
 905                 name = g_strdup(_("Draft"));
 906                 break;
 907         default:
 908                 xpm = folderxpm;
 909                 mask = folderxpmmask;
 910                 if (item->hide_read_msgs) {
 911                         openxpm = folderopenhrmxpm;
 912                         openmask = folderopenhrmxpmmask;
 913                 } else {
 914                         openxpm = folderopenxpm;
 915                         openmask = folderopenxpmmask;
 916                 }
 917                 if (!item->parent) {
 918                         switch (item->folder->type) {
 919                         case F_MH:
 920                                 name = " (MH)"; break;
 921                         case F_MBOX:
 922                                 name = " (mbox)"; break;
 923                         case F_IMAP:
 924                                 name = " (IMAP4)"; break;
 925                         case F_NEWS:
 926                                 name = " (News)"; break;
 927                         default:
 928                                 name = "";
 929                         }
 930                         name = g_strconcat(item->name, name, NULL);
 931                 } else
 932                         name = g_strdup(item->name);
 933         }
 934
 935         if (!GTK_CTREE_ROW(node)->expanded &&
 936             folderview_have_unread_children(folderview, node))
 937                 add_unread_mark = TRUE;
 938         else
 939                 add_unread_mark = FALSE;
 940
 941         if (item->stype == F_QUEUE && item->total > 0 &&
 942             prefs_common.display_folder_unread) {
 943                 str = g_strdup_printf("%s (%d%s)", name, item->total,
 944                                       add_unread_mark ? "+" : "");
 945                 gtk_ctree_set_node_info(ctree, node, str, FOLDER_SPACING,
 946                                         xpm, mask, openxpm, openmask,
 947                                         FALSE, GTK_CTREE_ROW(node)->expanded);
 948                 g_free(str);
 949         } else if ((item->unread > 0 || add_unread_mark) &&
 950                  prefs_common.display_folder_unread) {
 951
 952                 if (item->unread > 0)
 953                         str = g_strdup_printf("%s (%d%s)", name, item->unread,
 954                                               add_unread_mark ? "+" : "");
 955                 else
 956                         str = g_strdup_printf("%s (+)", name);
 957                 gtk_ctree_set_node_info(ctree, node, str, FOLDER_SPACING,
 958                                         xpm, mask, openxpm, openmask,
 959                                         FALSE, GTK_CTREE_ROW(node)->expanded);
 960                 g_free(str);
 961         } else
 962                 gtk_ctree_set_node_info(ctree, node, name, FOLDER_SPACING,
 963                                         xpm, mask, openxpm, openmask,
 964                                         FALSE, GTK_CTREE_ROW(node)->expanded);
 965         g_free(name);
 966
 967         if (!item->parent) {
 968                 gtk_ctree_node_set_text(ctree, node, COL_NEW,    "-");
 969                 gtk_ctree_node_set_text(ctree, node, COL_UNREAD, "-");
 970                 gtk_ctree_node_set_text(ctree, node, COL_TOTAL,  "-");
 971         } else {
 972                 gtk_ctree_node_set_text(ctree, node, COL_NEW,    itos(item->new));
 973                 gtk_ctree_node_set_text(ctree, node, COL_UNREAD, itos(item->unread));
 974                 gtk_ctree_node_set_text(ctree, node, COL_TOTAL,  itos(item->total));
 975         }
 976
 977         if (item->stype == F_TRASH)
 978                 use_bold = use_color = FALSE;
 979         if (item->stype == F_QUEUE) {
 980                 /* highlight queue folder if there are any messages */
 981                 use_bold = use_color = (item->total > 0);
 982         } else {
 983                 /* if unread messages exist, print with bold font */
 984                 use_bold = (item->unread > 0) || add_unread_mark;
 985                 /* if new messages exist, print with colored letter */
 986                 use_color =
 987                         (item->new > 0) ||
 988                         (add_unread_mark &&
 989                          folderview_have_new_children(folderview, node));
 990         }
 991
 992         gtk_ctree_node_set_foreground(ctree, node, NULL);
 993
 994         if (use_bold && use_color)
 995                 style = bold_color_style;
 996         else if (use_bold) {
 997                 style = bold_style;
 998                 if (item->op_count > 0) {
 999                         style = bold_tgtfold_style;
1000                 }
1001         }
1002         else if (use_color) {
1003                 style = normal_color_style;
1004                 gtk_ctree_node_set_foreground(ctree, node,
1005                                               &folderview->color_new);
1006         }
1007         else if (item->op_count > 0) {
1008                 style = bold_tgtfold_style;
1009         } else {
1010                 style = normal_style;
1011         }
1012
1013         gtk_ctree_node_set_row_style(ctree, node, style);
1014
1015         if ((node = gtkut_ctree_find_collapsed_parent(ctree, node)) != NULL)
1016                 folderview_update_node(folderview, node);
1017 }
1018
1019 void folderview_update_item(FolderItem *item, gboolean update_summary)
1020 {
1021         GList *list;
1022         FolderView *folderview;
1023         GtkCTree *ctree;
1024         GtkCTreeNode *node;
1025
1026         g_return_if_fail(item != NULL);
1027
1028         for (list = folderview_list; list != NULL; list = list->next) {
1029                 folderview = (FolderView *)list->data;
1030                 ctree = GTK_CTREE(folderview->ctree);
1031
1032                 node = gtk_ctree_find_by_row_data(ctree, NULL, item);
1033                 if (node) {
1034                         folderview_update_node(folderview, node);
1035                         if (update_summary && folderview->opened == node)
1036                                 summary_show(folderview->summaryview,
1037                                              item, FALSE);
1038                 }
1039         }
1040 }
1041
1042 static void folderview_update_item_foreach_func(gpointer key, gpointer val,
1043                                                 gpointer data)
1044 {
1045         folderview_update_item((FolderItem *)key, FALSE);
1046 }
1047
1048 void folderview_update_item_foreach(GHashTable *table)
1049 {
1050         g_hash_table_foreach(table, folderview_update_item_foreach_func, NULL);
1051 }
1052
1053 static gboolean folderview_gnode_func(GtkCTree *ctree, guint depth,
1054                                       GNode *gnode, GtkCTreeNode *cnode,
1055                                       gpointer data)
1056 {
1057         FolderView *folderview = (FolderView *)data;
1058         FolderItem *item = FOLDER_ITEM(gnode->data);
1059
1060         g_return_val_if_fail(item != NULL, FALSE);
1061
1062         gtk_ctree_node_set_row_data(ctree, cnode, item);
1063         folderview_update_node(folderview, cnode);
1064
1065         return TRUE;
1066 }
1067
1068 static void folderview_expand_func(GtkCTree *ctree, GtkCTreeNode *node,
1069                                    gpointer data)
1070 {
1071         FolderView *folderview = (FolderView *)data;
1072         FolderItem *item;
1073
1074         if (GTK_CTREE_ROW(node)->children) {
1075                 item = gtk_ctree_node_get_row_data(ctree, node);
1076                 g_return_if_fail(item != NULL);
1077
1078                 if (!item->collapsed)
1079                         gtk_ctree_expand(ctree, node);
1080                 else
1081                         folderview_update_node(folderview, node);
1082         }
1083 }
1084
1085 #define SET_SPECIAL_FOLDER(ctree, item) \
1086 { \
1087         if (item) { \
1088                 GtkCTreeNode *node, *sibling; \
1089  \
1090                 node = gtk_ctree_find_by_row_data(ctree, root, item); \
1091                 if (!node) \
1092                         g_warning("%s not found.\n", item->path); \
1093                 else { \
1094                         if (!prev) \
1095                                 sibling = GTK_CTREE_ROW(root)->children; \
1096                         else \
1097                                 sibling = GTK_CTREE_ROW(prev)->sibling; \
1098                         if (node != sibling) \
1099                                 gtk_ctree_move(ctree, node, root, sibling); \
1100                 } \
1101  \
1102                 prev = node; \
1103         } \
1104 }
1105
1106 static void folderview_sort_folders(FolderView *folderview, GtkCTreeNode *root,
1107                                     Folder *folder)
1108 {
1109         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1110         GtkCTreeNode *prev = NULL;
1111
1112         gtk_ctree_sort_recursive(ctree, root);
1113
1114         if (GTK_CTREE_ROW(root)->parent) return;
1115
1116         SET_SPECIAL_FOLDER(ctree, folder->inbox);
1117         SET_SPECIAL_FOLDER(ctree, folder->outbox);
1118         SET_SPECIAL_FOLDER(ctree, folder->draft);
1119         SET_SPECIAL_FOLDER(ctree, folder->queue);
1120         SET_SPECIAL_FOLDER(ctree, folder->trash);
1121 }
1122
1123 static void folderview_append_folder(FolderView *folderview, Folder *folder)
1124 {
1125         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1126         GtkCTreeNode *root;
1127
1128         g_return_if_fail(folder != NULL);
1129
1130         root = gtk_ctree_insert_gnode(ctree, NULL, NULL, folder->node,
1131                                       folderview_gnode_func, folderview);
1132         gtk_ctree_pre_recursive(ctree, root, folderview_expand_func,
1133                                 folderview);
1134         folderview_sort_folders(folderview, root, folder);
1135 }
1136
1137 void folderview_new_folder(FolderView *folderview)
1138 {
1139         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1140         FolderItem *item;
1141
1142         if (!folderview->selected) return;
1143
1144         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
1145         g_return_if_fail(item != NULL);
1146         g_return_if_fail(item->folder != NULL);
1147
1148         switch (item->folder->type) {
1149         case F_MBOX:
1150                 folderview_new_mbox_folder_cb(folderview, 0, NULL);
1151                 break;
1152         case F_MH:
1153         case F_MAILDIR:
1154                 folderview_new_folder_cb(folderview, 0, NULL);
1155                 break;
1156         case F_IMAP:
1157                 folderview_new_imap_folder_cb(folderview, 0, NULL);
1158                 break;
1159         case F_NEWS:
1160         default:
1161                 break;
1162         }
1163 }
1164
1165 void folderview_rename_folder(FolderView *folderview)
1166 {
1167         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1168         FolderItem *item;
1169
1170         if (!folderview->selected) return;
1171
1172         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
1173         g_return_if_fail(item != NULL);
1174         g_return_if_fail(item->folder != NULL);
1175         if (!item->path) return;
1176         if (item->stype != F_NORMAL) return;
1177
1178         switch (item->folder->type) {
1179         case F_MBOX:
1180                 folderview_rename_mbox_folder_cb(folderview, 0, NULL);
1181         case F_MH:
1182         case F_MAILDIR:
1183                 folderview_rename_folder_cb(folderview, 0, NULL);
1184                 break;
1185         case F_IMAP:
1186         case F_NEWS:
1187         default:
1188                 break;
1189         }
1190 }
1191
1192 void folderview_delete_folder(FolderView *folderview)
1193 {
1194         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1195         FolderItem *item;
1196
1197         if (!folderview->selected) return;
1198
1199         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
1200         g_return_if_fail(item != NULL);
1201         g_return_if_fail(item->folder != NULL);
1202         if (!item->path) return;
1203         if (item->stype != F_NORMAL) return;
1204
1205         switch (item->folder->type) {
1206         case F_MH:
1207         case F_MBOX:
1208         case F_MAILDIR:
1209                 folderview_delete_folder_cb(folderview, 0, NULL);
1210                 break;
1211         case F_IMAP:
1212                 folderview_rm_imap_folder_cb(folderview, 0, NULL);
1213         case F_NEWS:
1214         default:
1215                 break;
1216         }
1217 }
1218
1219
1220 /* callback functions */
1221
1222 static void folderview_button_pressed(GtkWidget *ctree, GdkEventButton *event,
1223                                       FolderView *folderview)
1224 {
1225         GtkCList *clist = GTK_CLIST(ctree);
1226         gint prev_row = -1, row = -1, column = -1;
1227         FolderItem *item;
1228         Folder *folder;
1229         GtkWidget *popup;
1230         gboolean new_folder      = FALSE;
1231         gboolean rename_folder   = FALSE;
1232         gboolean delete_folder   = FALSE;
1233         gboolean update_tree     = FALSE;
1234         gboolean rescan_tree     = FALSE;
1235         gboolean remove_tree     = FALSE;
1236         gboolean folder_property = FALSE;
1237         gboolean folder_processing  = FALSE;
1238         gboolean folder_scoring  = FALSE;
1239         gboolean search_folder = FALSE;
1240
1241         if (!event) return;
1242
1243         if (event->button == 1) {
1244                 folderview->open_folder = TRUE;
1245                 return;
1246         }
1247
1248         if (event->button == 2 || event->button == 3) {
1249                 /* right clicked */
1250                 if (clist->selection) {
1251                         GtkCTreeNode *node;
1252
1253                         node = GTK_CTREE_NODE(clist->selection->data);
1254                         if (node)
1255                                 prev_row = gtkut_ctree_get_nth_from_node
1256                                         (GTK_CTREE(ctree), node);
1257                 }
1258
1259                 if (!gtk_clist_get_selection_info(clist, event->x, event->y,
1260                                                   &row, &column))
1261                         return;
1262                 if (prev_row != row) {
1263                         gtk_clist_unselect_all(clist);
1264                         if (event->button == 2)
1265                                 folderview_select_node
1266                                         (folderview,
1267                                          gtk_ctree_node_nth(GTK_CTREE(ctree),
1268                                                             row));
1269                         else
1270                                 gtk_clist_select_row(clist, row, column);
1271                 }
1272         }
1273
1274         if (event->button != 3) return;
1275
1276         item = gtk_clist_get_row_data(clist, row);
1277         g_return_if_fail(item != NULL);
1278         g_return_if_fail(item->folder != NULL);
1279         folder = item->folder;
1280
1281         if (folderview->mainwin->lock_count == 0) {
1282                 new_folder = TRUE;
1283                 if (item->parent == NULL)
1284                         update_tree = remove_tree = TRUE;
1285                 else
1286                         search_folder = TRUE;
1287                 if (FOLDER_IS_LOCAL(folder) || FOLDER_TYPE(folder) == F_IMAP || FOLDER_TYPE(folder) == F_MBOX) {
1288                         if (item->parent == NULL)
1289                                 update_tree = rescan_tree = TRUE;
1290                         else if (item->stype == F_NORMAL)
1291                                 rename_folder = delete_folder = folder_property = folder_scoring = folder_processing = TRUE;
1292                         else if (item->stype == F_INBOX)
1293                                 folder_property = folder_scoring = folder_processing = TRUE;
1294                         else if (item->stype == F_TRASH)
1295                                 folder_processing = TRUE;
1296                         else if (item->stype == F_OUTBOX)
1297                                 folder_processing = TRUE;
1298                 } else if (FOLDER_TYPE(folder) == F_NEWS) {
1299                         if (item->parent != NULL)
1300                                 delete_folder = folder_scoring = folder_processing = TRUE;
1301                 }
1302         }
1303
1304 #define SET_SENS(factory, name, sens) \
1305         menu_set_sensitive(folderview->factory, name, sens)
1306
1307         if (FOLDER_IS_LOCAL(folder)) {
1308                 popup = folderview->mail_popup;
1309                 menu_set_insensitive_all(GTK_MENU_SHELL(popup));
1310                 SET_SENS(mail_factory, "/Create new folder...", new_folder);
1311                 SET_SENS(mail_factory, "/Rename folder...", rename_folder);
1312                 SET_SENS(mail_factory, "/Delete folder", delete_folder);
1313                 SET_SENS(mail_factory, "/Update folder tree", update_tree);
1314                 SET_SENS(mail_factory, "/Rescan folder tree", rescan_tree);
1315                 SET_SENS(mail_factory, "/Remove mailbox", remove_tree);
1316                 SET_SENS(mail_factory, "/Property...", folder_property);
1317                 SET_SENS(mail_factory, "/Processing...", folder_processing);
1318                 SET_SENS(mail_factory, "/Scoring...", folder_scoring);
1319                 SET_SENS(mail_factory, "/Search messages...", search_folder);
1320         } else if (FOLDER_TYPE(folder) == F_IMAP) {
1321                 popup = folderview->imap_popup;
1322                 menu_set_insensitive_all(GTK_MENU_SHELL(popup));
1323                 SET_SENS(imap_factory, "/Create new folder...", new_folder);
1324                 SET_SENS(imap_factory, "/Rename folder...", rename_folder);
1325                 SET_SENS(imap_factory, "/Delete folder", delete_folder);
1326                 SET_SENS(imap_factory, "/Update folder tree", update_tree);
1327                 SET_SENS(imap_factory, "/Rescan folder tree", rescan_tree);
1328                 SET_SENS(imap_factory, "/Remove IMAP4 account", remove_tree);
1329                 SET_SENS(imap_factory, "/Processing...", folder_processing);
1330                 SET_SENS(imap_factory, "/Scoring...", folder_scoring);
1331                 SET_SENS(imap_factory, "/Search messages...", search_folder);
1332         } else if (FOLDER_TYPE(folder) == F_NEWS) {
1333                 popup = folderview->news_popup;
1334                 menu_set_insensitive_all(GTK_MENU_SHELL(popup));
1335                 SET_SENS(news_factory, "/Subscribe to newsgroup...", new_folder);
1336                 SET_SENS(news_factory, "/Remove newsgroup", delete_folder);
1337                 SET_SENS(news_factory, "/Remove news account", remove_tree);
1338                 SET_SENS(news_factory, "/Search messages...", search_folder);
1339                 SET_SENS(news_factory, "/Processing...", folder_processing);
1340                 SET_SENS(news_factory, "/Scoring...", folder_scoring);
1341         } else if (FOLDER_TYPE(folder) == F_MBOX) {
1342                 popup = folderview->mbox_popup;
1343                 menu_set_insensitive_all(GTK_MENU_SHELL(popup));
1344                 SET_SENS(mbox_factory, "/Create new folder...", new_folder);
1345                 SET_SENS(mbox_factory, "/Rename folder...", rename_folder);
1346                 SET_SENS(mbox_factory, "/Delete folder", delete_folder);
1347                 SET_SENS(mbox_factory, "/Processing...", folder_processing);
1348                 SET_SENS(mbox_factory, "/Scoring...", folder_scoring);
1349         } else
1350                 return;
1351
1352 #undef SET_SENS
1353
1354         gtk_menu_popup(GTK_MENU(popup), NULL, NULL, NULL, NULL,
1355                        event->button, event->time);
1356 }
1357
1358 static void folderview_button_released(GtkWidget *ctree, GdkEventButton *event,
1359                                        FolderView *folderview)
1360 {
1361         if (!event) return;
1362
1363         if (event->button == 1 && folderview->open_folder == FALSE &&
1364             folderview->opened != NULL) {
1365                 gtk_ctree_select(GTK_CTREE(ctree), folderview->opened);
1366                 gtkut_ctree_set_focus_row(GTK_CTREE(ctree),
1367                                           folderview->opened);
1368         }
1369 }
1370
1371 #define BREAK_ON_MODIFIER_KEY() \
1372         if ((event->state & (GDK_MOD1_MASK|GDK_CONTROL_MASK)) != 0) break
1373
1374 static void folderview_key_pressed(GtkWidget *widget, GdkEventKey *event,
1375                                    FolderView *folderview)
1376 {
1377         if (!event) return;
1378
1379         switch (event->keyval) {
1380         case GDK_Return:
1381         case GDK_space:
1382                 if (folderview->selected) {
1383                         folderview_select_node(folderview,
1384                                                folderview->selected);
1385                 }
1386                 break;
1387         case GDK_v:
1388         case GDK_V:
1389         case GDK_g:
1390         case GDK_G:
1391         case GDK_x:
1392         case GDK_X:
1393         case GDK_w:
1394         case GDK_D:
1395         case GDK_Q:
1396                 BREAK_ON_MODIFIER_KEY();
1397                 summary_pass_key_press_event(folderview->summaryview, event);
1398         default:
1399         }
1400 }
1401
1402 static void folderview_selected(GtkCTree *ctree, GtkCTreeNode *row,
1403                                 gint column, FolderView *folderview)
1404 {
1405         static gboolean can_select = TRUE;      /* exclusive lock */
1406         gboolean opened;
1407         FolderItem *item;
1408
1409         folderview->selected = row;
1410
1411         if (folderview->opened == row) {
1412                 folderview->open_folder = FALSE;
1413                 return;
1414         }
1415
1416         if (!can_select) {
1417                 gtk_ctree_select(ctree, folderview->opened);
1418                 gtkut_ctree_set_focus_row(ctree, folderview->opened);
1419                 return;
1420         }
1421
1422         if (!folderview->open_folder) return;
1423
1424         item = gtk_ctree_node_get_row_data(ctree, row);
1425         if (!item) return;
1426
1427         can_select = FALSE;
1428
1429         /* CLAWS: set compose button type: news folder items
1430          * always have a news folder as parent */
1431         if (item->folder)
1432                 main_window_toolbar_set_compose_button
1433                         (folderview->mainwin,
1434                          item->folder->type == F_NEWS ?
1435                          COMPOSEBUTTON_NEWS : COMPOSEBUTTON_MAIL);
1436
1437         if (item->path)
1438                 debug_print(_("Folder %s is selected\n"), item->path);
1439
1440         if (!GTK_CTREE_ROW(row)->children)
1441                 gtk_ctree_expand(ctree, row);
1442         if (folderview->opened &&
1443             !GTK_CTREE_ROW(folderview->opened)->children)
1444                 gtk_ctree_collapse(ctree, folderview->opened);
1445
1446         /* ungrab the mouse event */
1447         if (GTK_WIDGET_HAS_GRAB(ctree)) {
1448                 gtk_grab_remove(GTK_WIDGET(ctree));
1449                 if (gdk_pointer_is_grabbed())
1450                         gdk_pointer_ungrab(GDK_CURRENT_TIME);
1451         }
1452
1453         opened = summary_show(folderview->summaryview, item, FALSE);
1454
1455         if (!opened) {
1456                 gtk_ctree_select(ctree, folderview->opened);
1457                 gtkut_ctree_set_focus_row(ctree, folderview->opened);
1458         } else
1459                 folderview->opened = row;
1460
1461         folderview->open_folder = FALSE;
1462         can_select = TRUE;
1463 }
1464
1465 static void folderview_tree_expanded(GtkCTree *ctree, GtkCTreeNode *node,
1466                                      FolderView *folderview)
1467 {
1468         FolderItem *item;
1469
1470         item = gtk_ctree_node_get_row_data(ctree, node);
1471         g_return_if_fail(item != NULL);
1472         item->collapsed = FALSE;
1473         folderview_update_node(folderview, node);
1474 }
1475
1476 static void folderview_tree_collapsed(GtkCTree *ctree, GtkCTreeNode *node,
1477                                       FolderView *folderview)
1478 {
1479         FolderItem *item;
1480
1481         item = gtk_ctree_node_get_row_data(ctree, node);
1482         g_return_if_fail(item != NULL);
1483         item->collapsed= TRUE;
1484         folderview_update_node(folderview, node);
1485 }
1486
1487 static void folderview_popup_close(GtkMenuShell *menu_shell,
1488                                    FolderView *folderview)
1489 {
1490         if (!folderview->opened) return;
1491
1492         gtk_ctree_select(GTK_CTREE(folderview->ctree), folderview->opened);
1493         gtkut_ctree_set_focus_row(GTK_CTREE(folderview->ctree),
1494                                   folderview->opened);
1495 }
1496
1497 static void folderview_col_resized(GtkCList *clist, gint column, gint width,
1498                                    FolderView *folderview)
1499 {
1500         switch (column) {
1501         case COL_FOLDER:
1502                 prefs_common.folder_col_folder = width;
1503                 break;
1504         case COL_NEW:
1505                 prefs_common.folder_col_new = width;
1506                 break;
1507         case COL_UNREAD:
1508                 prefs_common.folder_col_unread = width;
1509                 break;
1510         case COL_TOTAL:
1511                 prefs_common.folder_col_total = width;
1512                 break;
1513         default:
1514         }
1515 }
1516
1517 static GtkCTreeNode *folderview_find_by_name(GtkCTree *ctree,
1518                                              GtkCTreeNode *node,
1519                                              const gchar *name)
1520 {
1521         FolderItem *item;
1522
1523         if (!node)
1524                 node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list);
1525         if (!node)
1526                 return NULL;
1527
1528         node = GTK_CTREE_ROW(node)->children;
1529
1530         while (node) {
1531                 item = gtk_ctree_node_get_row_data(ctree, node);
1532                 if (!folderview_compare_name(item, name))
1533                         return node;
1534                 node = GTK_CTREE_ROW(node)->sibling;
1535         }
1536
1537         return NULL;
1538 }
1539
1540 static void folderview_update_tree_cb(FolderView *folderview, guint action,
1541                                       GtkWidget *widget)
1542 {
1543         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1544         FolderItem *item;
1545
1546         if (!folderview->selected) return;
1547
1548         summary_show(folderview->summaryview, NULL, FALSE);
1549
1550         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
1551         g_return_if_fail(item != NULL);
1552         g_return_if_fail(item->folder != NULL);
1553
1554         if (action == 0)
1555                 folderview_update_all_node();
1556         else
1557                 folderview_update_tree(item->folder);
1558 }
1559
1560 static void folderview_new_folder_cb(FolderView *folderview, guint action,
1561                                      GtkWidget *widget)
1562 {
1563         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1564         gchar *text[N_FOLDER_COLS] = {NULL, "0", "0", "0"};
1565         FolderItem *item;
1566         FolderItem *new_item;
1567         gchar *new_folder;
1568         GtkCTreeNode *node;
1569
1570         if (!folderview->selected) return;
1571
1572         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
1573         g_return_if_fail(item != NULL);
1574         g_return_if_fail(item->folder != NULL);
1575
1576         new_folder = input_dialog(_("New folder"),
1577                                   _("Input the name of new folder:"),
1578                                   _("NewFolder"));
1579         if (!new_folder) return;
1580
1581         if (item->folder->type != F_MBOX) {
1582                 if (strchr(new_folder, G_DIR_SEPARATOR) != NULL) {
1583                         alertpanel_error(_("`%c' can't be included in folder name."),
1584                                          G_DIR_SEPARATOR);
1585                         g_free(new_folder);
1586                         return;
1587                 }
1588         }
1589
1590         /* find whether the directory already exists */
1591         if (folderview_find_by_name(ctree, folderview->selected, new_folder)) {
1592                 alertpanel_error(_("The folder `%s' already exists."),
1593                                  new_folder);
1594                 g_free(new_folder);
1595                 return;
1596         }
1597
1598         new_item = item->folder->create_folder(item->folder, item, new_folder);
1599         if (!new_item) {
1600                 alertpanel_error(_("The folder `%s' could not be created."),
1601                                  new_folder);
1602                 g_free(new_folder);
1603                 return;
1604         }
1605         g_free(new_folder);
1606
1607         gtk_clist_freeze(GTK_CLIST(ctree));
1608
1609         text[COL_FOLDER] = new_item->name;
1610         node = gtk_ctree_insert_node(ctree, folderview->selected, NULL, text,
1611                                      FOLDER_SPACING,
1612                                      folderxpm, folderxpmmask,
1613                                      folderopenxpm, folderopenxpmmask,
1614                                      FALSE, FALSE);
1615         gtk_ctree_expand(ctree, folderview->selected);
1616         gtk_ctree_node_set_row_data(ctree, node, new_item);
1617         folderview_sort_folders(folderview, folderview->selected, item->folder);
1618
1619         gtk_clist_thaw(GTK_CLIST(ctree));
1620
1621         folder_write_list();
1622 }
1623
1624 static void folderview_new_mbox_folder_cb(FolderView *folderview, guint action,
1625                                           GtkWidget *widget)
1626 {
1627         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1628         gchar *text[N_FOLDER_COLS] = {NULL, "0", "0", "0"};
1629         FolderItem *item;
1630         FolderItem *new_item;
1631         gchar *new_folder;
1632         GtkCTreeNode *node;
1633
1634         if (!folderview->selected) return;
1635
1636         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
1637         g_return_if_fail(item != NULL);
1638         g_return_if_fail(item->folder != NULL);
1639
1640         new_folder = input_dialog(_("New folder"),
1641                                   _("Input the name of new folder:"),
1642                                   _("NewFolder"));
1643         if (!new_folder) return;
1644
1645         /* find whether the directory already exists */
1646         if (folderview_find_by_name(ctree, folderview->selected, new_folder)) {
1647                 alertpanel_error(_("The folder `%s' already exists."),
1648                                  new_folder);
1649                 g_free(new_folder);
1650                 return;
1651         }
1652
1653         new_item = item->folder->create_folder(item->folder, item, new_folder);
1654         g_free(new_folder);
1655         if (!new_item) return;
1656
1657         gtk_clist_freeze(GTK_CLIST(ctree));
1658
1659         text[COL_FOLDER] = new_item->name;
1660         node = gtk_ctree_insert_node(ctree, folderview->selected, NULL, text,
1661                                      FOLDER_SPACING,
1662                                      folderxpm, folderxpmmask,
1663                                      folderopenxpm, folderopenxpmmask,
1664                                      FALSE, FALSE);
1665         gtk_ctree_expand(ctree, folderview->selected);
1666         gtk_ctree_node_set_row_data(ctree, node, new_item);
1667         folderview_sort_folders(folderview, folderview->selected, item->folder);
1668
1669         gtk_clist_thaw(GTK_CLIST(ctree));
1670
1671         folder_write_list();
1672 }
1673
1674 static void folderview_rename_folder_cb(FolderView *folderview, guint action,
1675                                         GtkWidget *widget)
1676 {
1677         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1678         FolderItem *item;
1679         gchar *new_folder;
1680         gchar *message;
1681
1682         if (!folderview->selected) return;
1683
1684         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
1685         g_return_if_fail(item != NULL);
1686         g_return_if_fail(item->path != NULL);
1687         g_return_if_fail(item->folder != NULL);
1688
1689         message = g_strdup_printf(_("Input new name for `%s':"),
1690                                   g_basename(item->path));
1691         new_folder = input_dialog(_("Rename folder"), message,
1692                                   g_basename(item->path));
1693         g_free(message);
1694         if (!new_folder) return;
1695
1696         if (strchr(new_folder, G_DIR_SEPARATOR) != NULL) {
1697                 alertpanel_error(_("`%c' can't be included in folder name."),
1698                                  G_DIR_SEPARATOR);
1699                 g_free(new_folder);
1700                 return;
1701         }
1702
1703         if (folderview_find_by_name
1704                 (ctree, GTK_CTREE_ROW(folderview->selected)->parent,
1705                  new_folder)) {
1706                 alertpanel_error(_("The folder `%s' already exists."),
1707                                  new_folder);
1708                 g_free(new_folder);
1709                 return;
1710         }
1711
1712         if (item->folder->rename_folder(item->folder, item, new_folder) < 0) {
1713                 g_free(new_folder);
1714                 return;
1715         }
1716         g_free(new_folder);
1717
1718         gtk_clist_freeze(GTK_CLIST(ctree));
1719
1720         folderview_update_node(folderview, folderview->selected);
1721         folderview_sort_folders(folderview,
1722                                 GTK_CTREE_ROW(folderview->selected)->parent,
1723                                 item->folder);
1724         if (folderview->opened == folderview->selected) {
1725                 if (!GTK_CTREE_ROW(folderview->opened)->children)
1726                         gtk_ctree_expand(ctree, folderview->opened);
1727                 summary_show(folderview->summaryview, item, FALSE);
1728         }
1729
1730         gtk_clist_thaw(GTK_CLIST(ctree));
1731
1732         folder_write_list();
1733 }
1734
1735 static void folderview_rename_mbox_folder_cb(FolderView *folderview,
1736                                              guint action,
1737                                              GtkWidget *widget)
1738 {
1739         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1740         FolderItem *item;
1741         gchar *new_folder;
1742         gchar *message;
1743
1744         if (!folderview->selected) return;
1745
1746         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
1747         g_return_if_fail(item != NULL);
1748         g_return_if_fail(item->path != NULL);
1749         g_return_if_fail(item->folder != NULL);
1750
1751         message = g_strdup_printf(_("Input new name for `%s':"),
1752                                   g_basename(item->path));
1753         new_folder = input_dialog(_("Rename folder"), message,
1754                                   g_basename(item->path));
1755         g_free(message);
1756         if (!new_folder) return;
1757
1758         if (folderview_find_by_name
1759                 (ctree, GTK_CTREE_ROW(folderview->selected)->parent,
1760                  new_folder)) {
1761                 alertpanel_error(_("The folder `%s' already exists."),
1762                                  new_folder);
1763                 g_free(new_folder);
1764                 return;
1765         }
1766
1767         if (item->folder->rename_folder(item->folder, item, new_folder) < 0) {
1768                 g_free(new_folder);
1769                 return;
1770         }
1771         g_free(new_folder);
1772
1773         gtk_clist_freeze(GTK_CLIST(ctree));
1774
1775         folderview_update_node(folderview, folderview->selected);
1776         folderview_sort_folders(folderview,
1777                                 GTK_CTREE_ROW(folderview->selected)->parent,
1778                                 item->folder);
1779         if (folderview->opened == folderview->selected) {
1780                 if (!GTK_CTREE_ROW(folderview->opened)->children)
1781                         gtk_ctree_expand(ctree, folderview->opened);
1782                 summary_show(folderview->summaryview, item, FALSE);
1783         }
1784
1785         gtk_clist_thaw(GTK_CLIST(ctree));
1786
1787         folder_write_list();
1788 }
1789
1790 static void folderview_delete_folder_cb(FolderView *folderview, guint action,
1791                                         GtkWidget *widget)
1792 {
1793         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1794         FolderItem *item;
1795         gchar *message;
1796         AlertValue avalue;
1797
1798         if (!folderview->selected) return;
1799
1800         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
1801         g_return_if_fail(item != NULL);
1802         g_return_if_fail(item->path != NULL);
1803         g_return_if_fail(item->folder != NULL);
1804
1805         message = g_strdup_printf
1806                 (_("All folder(s) and message(s) under `%s' will be deleted.\n"
1807                    "Do you really want to delete?"),
1808                  g_basename(item->path));
1809         avalue = alertpanel(_("Delete folder"), message,
1810                             _("Yes"), _("+No"), NULL);
1811         g_free(message);
1812         if (avalue != G_ALERTDEFAULT) return;
1813
1814         if (item->folder->remove_folder(item->folder, item) < 0) {
1815                 alertpanel_error(_("Can't remove the folder `%s'."),
1816                                  item->path);
1817                 return;
1818         }
1819
1820         if (folderview->opened == folderview->selected ||
1821             gtk_ctree_is_ancestor(ctree,
1822                                   folderview->selected,
1823                                   folderview->opened)) {
1824                 summary_clear_all(folderview->summaryview);
1825                 folderview->opened = NULL;
1826         }
1827
1828         gtk_ctree_remove_node(ctree, folderview->selected);
1829         folder_write_list();
1830 }
1831
1832 static void folderview_remove_mailbox_cb(FolderView *folderview, guint action,
1833                                          GtkWidget *widget)
1834 {
1835         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1836         GtkCTreeNode *node;
1837         FolderItem *item;
1838         gchar *message;
1839         AlertValue avalue;
1840
1841         if (!folderview->selected) return;
1842         node = folderview->selected;
1843         item = gtk_ctree_node_get_row_data(ctree, node);
1844         g_return_if_fail(item != NULL);
1845         g_return_if_fail(item->folder != NULL);
1846         if (item->parent) return;
1847
1848         message = g_strdup_printf
1849                 (_("Really remove the mailbox `%s' ?\n"
1850                    "(The messages are NOT deleted from disk)"),
1851                  item->folder->name);
1852         avalue = alertpanel(_("Remove folder"), message,
1853                             _("Yes"), _("+No"), NULL);
1854         g_free(message);
1855         if (avalue != G_ALERTDEFAULT) return;
1856
1857         folder_destroy(item->folder);
1858         summary_clear_all(folderview->summaryview);
1859         folderview_unselect(folderview);
1860         gtk_ctree_remove_node(ctree, node);
1861         folder_write_list();
1862 }
1863
1864 static void folderview_new_imap_folder_cb(FolderView *folderview, guint action,
1865                                           GtkWidget *widget)
1866 {
1867         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1868         gchar *text[N_FOLDER_COLS] = {NULL, "0", "0", "0"};
1869         GtkCTreeNode *node;
1870         FolderItem *item;
1871         FolderItem *new_item;
1872         gchar *new_folder;
1873         gchar *p;
1874
1875         if (!folderview->selected) return;
1876
1877         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
1878         g_return_if_fail(item != NULL);
1879         g_return_if_fail(item->folder != NULL);
1880         g_return_if_fail(item->folder->type == F_IMAP);
1881         g_return_if_fail(item->folder->account != NULL);
1882
1883         new_folder = input_dialog
1884                 (_("New folder"),
1885                  _("Input the name of new folder:\n"
1886                    "(if you want to create a folder to store subfolders,\n"
1887                    " append `/' at the end of the name)"),
1888                  _("NewFolder"));
1889         if (!new_folder) return;
1890
1891         if ((p = strchr(new_folder, G_DIR_SEPARATOR)) != NULL &&
1892             *(p + 1) != '\0') {
1893                 alertpanel_error(_("`%c' can't be included in folder name."),
1894                                  G_DIR_SEPARATOR);
1895                 g_free(new_folder);
1896                 return;
1897         }
1898
1899         /* find whether the directory already exists */
1900         if (folderview_find_by_name(ctree, folderview->selected, new_folder)) {
1901                 alertpanel_error(_("The folder `%s' already exists."),
1902                                  new_folder);
1903                 g_free(new_folder);
1904                 return;
1905         }
1906
1907         new_item = item->folder->create_folder(item->folder, item, new_folder);
1908         if (!new_item) {
1909                 alertpanel_error(_("Can't create the folder `%s'."),
1910                                  new_folder);
1911                 g_free(new_folder);
1912                 return;
1913         }
1914         g_free(new_folder);
1915
1916         gtk_clist_freeze(GTK_CLIST(ctree));
1917
1918         text[COL_FOLDER] = new_item->name;
1919         node = gtk_ctree_insert_node(ctree, folderview->selected, NULL, text,
1920                                      FOLDER_SPACING,
1921                                      folderxpm, folderxpmmask,
1922                                      folderopenxpm, folderopenxpmmask,
1923                                      FALSE, FALSE);
1924         gtk_ctree_expand(ctree, folderview->selected);
1925         gtk_ctree_node_set_row_data(ctree, node, new_item);
1926         folderview_sort_folders(folderview, folderview->selected, item->folder);
1927
1928         gtk_clist_thaw(GTK_CLIST(ctree));
1929
1930         folder_write_list();
1931 }
1932
1933 static void folderview_rm_imap_folder_cb(FolderView *folderview, guint action,
1934                                          GtkWidget *widget)
1935 {
1936         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1937         FolderItem *item;
1938         gchar *message;
1939         AlertValue avalue;
1940
1941         if (!folderview->selected) return;
1942
1943         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
1944         g_return_if_fail(item != NULL);
1945         g_return_if_fail(item->folder != NULL);
1946         g_return_if_fail(item->folder->type == F_IMAP);
1947         g_return_if_fail(item->folder->account != NULL);
1948
1949         message = g_strdup_printf(_("Really delete folder `%s'?"),
1950                                   g_basename(item->path));
1951         avalue = alertpanel(_("Delete folder"), message,
1952                             _("Yes"), _("+No"), NULL);
1953         g_free(message);
1954         if (avalue != G_ALERTDEFAULT) return;
1955
1956         if (item->folder->remove_folder(item->folder, item) < 0) {
1957                 alertpanel_error(_("Can't remove the folder `%s'."),
1958                                  item->path);
1959                 if (folderview->opened == folderview->selected)
1960                         summary_show(folderview->summaryview,
1961                                      folderview->summaryview->folder_item,
1962                                      FALSE);
1963                 return;
1964         }
1965
1966         if (folderview->opened == folderview->selected ||
1967             gtk_ctree_is_ancestor(ctree,
1968                                   folderview->selected,
1969                                   folderview->opened)) {
1970                 summary_clear_all(folderview->summaryview);
1971                 folderview->opened = NULL;
1972         }
1973
1974         gtk_ctree_remove_node(ctree, folderview->selected);
1975         folder_write_list();
1976 }
1977
1978 static void folderview_rm_imap_server_cb(FolderView *folderview, guint action,
1979                                          GtkWidget *widget)
1980 {
1981         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1982         FolderItem *item;
1983         gchar *message;
1984         AlertValue avalue;
1985
1986         if (!folderview->selected) return;
1987
1988         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
1989         g_return_if_fail(item != NULL);
1990         g_return_if_fail(item->folder != NULL);
1991         g_return_if_fail(item->folder->type == F_IMAP);
1992         g_return_if_fail(item->folder->account != NULL);
1993
1994         message = g_strdup_printf(_("Really delete IMAP4 account `%s'?"),
1995                                   item->folder->name);
1996         avalue = alertpanel(_("Delete IMAP4 account"), message,
1997                             _("Yes"), _("+No"), NULL);
1998         g_free(message);
1999
2000         if (avalue != G_ALERTDEFAULT) return;
2001
2002         if (folderview->opened == folderview->selected ||
2003             gtk_ctree_is_ancestor(ctree,
2004                                   folderview->selected,
2005                                   folderview->opened)) {
2006                 summary_clear_all(folderview->summaryview);
2007                 folderview->opened = NULL;
2008         }
2009
2010         account_destroy(item->folder->account);
2011         folder_destroy(item->folder);
2012         gtk_ctree_remove_node(ctree, folderview->selected);
2013         account_set_menu();
2014         main_window_reflect_prefs_all();
2015         folder_write_list();
2016 }
2017
2018 static void folderview_new_news_group_cb(FolderView *folderview, guint action,
2019                                          GtkWidget *widget)
2020 {
2021         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
2022         gchar *text[N_FOLDER_COLS] = {NULL, "0", "0", "0"};
2023         GtkCTreeNode *servernode, *node;
2024         Folder *folder;
2025         FolderItem *item;
2026         FolderItem *rootitem;
2027         FolderItem *newitem;
2028         GSList *new_subscr;
2029         GSList *cur;
2030         GNode *gnode;
2031
2032         if (!folderview->selected) return;
2033
2034         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
2035         g_return_if_fail(item != NULL);
2036         folder = item->folder;
2037         g_return_if_fail(folder != NULL);
2038         g_return_if_fail(folder->type == F_NEWS);
2039         g_return_if_fail(folder->account != NULL);
2040
2041         if (GTK_CTREE_ROW(folderview->selected)->parent != NULL)
2042                 servernode = GTK_CTREE_ROW(folderview->selected)->parent;
2043         else
2044                 servernode = folderview->selected;
2045
2046         rootitem = gtk_ctree_node_get_row_data(ctree, servernode);
2047
2048         new_subscr = grouplist_dialog(folder);
2049
2050         /* remove unsubscribed newsgroups */
2051         for (gnode = folder->node->children; gnode != NULL; ) {
2052                 GNode *next = gnode->next;
2053
2054                 item = FOLDER_ITEM(gnode->data);
2055                 if (g_slist_find_custom(new_subscr, item->name,
2056                                         (GCompareFunc)g_strcasecmp) != NULL) {
2057                         gnode = next;
2058                         continue;
2059                 }
2060
2061                 node = gtk_ctree_find_by_row_data(ctree, servernode, item);
2062                 if (!node) {
2063                         gnode = next;
2064                         continue;
2065                 }
2066
2067                 if (folderview->opened == node) {
2068                         summary_clear_all(folderview->summaryview);
2069                         folderview->opened = NULL;
2070                 }
2071
2072                 folder_item_remove(item);
2073                 gtk_ctree_remove_node(ctree, node);
2074
2075                 gnode = next;
2076         }
2077
2078         gtk_clist_freeze(GTK_CLIST(ctree));
2079
2080         /* add subscribed newsgroups */
2081         for (cur = new_subscr; cur != NULL; cur = cur->next) {
2082                 gchar *name = (gchar *)cur->data;
2083
2084                 if (folderview_find_by_name(ctree, servernode, name) != NULL)
2085                         continue;
2086
2087                 text[COL_FOLDER] = name;
2088                 node = gtk_ctree_insert_node(ctree, servernode, NULL, text,
2089                                              FOLDER_SPACING,
2090                                              folderxpm, folderxpmmask,
2091                                              folderopenxpm, folderopenxpmmask,
2092                                              FALSE, FALSE);
2093                 gtk_ctree_expand(ctree, servernode);
2094
2095                 newitem = folder_item_new(name, name);
2096                 folder_item_append(rootitem, newitem);
2097                 gtk_ctree_node_set_row_data(ctree, node, newitem);
2098         }
2099
2100         gtk_ctree_sort_node(ctree, servernode);
2101         gtk_clist_thaw(GTK_CLIST(ctree));
2102
2103         slist_free_strings(new_subscr);
2104         g_slist_free(new_subscr);
2105
2106         folder_write_list();
2107 }
2108
2109 static void folderview_rm_news_group_cb(FolderView *folderview, guint action,
2110                                         GtkWidget *widget)
2111 {
2112         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
2113         FolderItem *item;
2114         gchar *message;
2115         AlertValue avalue;
2116
2117         if (!folderview->selected) return;
2118
2119         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
2120         g_return_if_fail(item != NULL);
2121         g_return_if_fail(item->folder != NULL);
2122         g_return_if_fail(item->folder->type == F_NEWS);
2123         g_return_if_fail(item->folder->account != NULL);
2124
2125         message = g_strdup_printf(_("Really delete newsgroup `%s'?"),
2126                                   g_basename(item->path));
2127         avalue = alertpanel(_("Delete newsgroup"), message,
2128                             _("Yes"), _("+No"), NULL);
2129         g_free(message);
2130         if (avalue != G_ALERTDEFAULT) return;
2131
2132         if (folderview->opened == folderview->selected) {
2133                 summary_clear_all(folderview->summaryview);
2134                 folderview->opened = NULL;
2135         }
2136
2137         folder_item_remove(item);
2138         gtk_ctree_remove_node(ctree, folderview->selected);
2139         folder_write_list();
2140 }
2141
2142 static void folderview_rm_news_server_cb(FolderView *folderview, guint action,
2143                                          GtkWidget *widget)
2144 {
2145         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
2146         FolderItem *item;
2147         gchar *message;
2148         AlertValue avalue;
2149
2150         if (!folderview->selected) return;
2151
2152         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
2153         g_return_if_fail(item != NULL);
2154         g_return_if_fail(item->folder != NULL);
2155         g_return_if_fail(item->folder->type == F_NEWS);
2156         g_return_if_fail(item->folder->account != NULL);
2157
2158         message = g_strdup_printf(_("Really delete news account `%s'?"),
2159                                   item->folder->name);
2160         avalue = alertpanel(_("Delete news account"), message,
2161                             _("Yes"), _("+No"), NULL);
2162         g_free(message);
2163
2164         if (avalue != G_ALERTDEFAULT) return;
2165
2166         if (folderview->opened == folderview->selected ||
2167             gtk_ctree_is_ancestor(ctree,
2168                                   folderview->selected,
2169                                   folderview->opened)) {
2170                 summary_clear_all(folderview->summaryview);
2171                 folderview->opened = NULL;
2172         }
2173
2174         account_destroy(item->folder->account);
2175         folder_destroy(item->folder);
2176         gtk_ctree_remove_node(ctree, folderview->selected);
2177         account_set_menu();
2178         main_window_reflect_prefs_all();
2179         folder_write_list();
2180 }
2181
2182 static void folderview_search_cb(FolderView *folderview, guint action,
2183                                  GtkWidget *widget)
2184 {
2185         summary_search(folderview->summaryview);
2186 }
2187
2188 static gboolean folderview_drag_motion_cb(GtkWidget      *widget,
2189                                           GdkDragContext *context,
2190                                           gint            x,
2191                                           gint            y,
2192                                           guint           time,
2193                                           FolderView     *folderview)
2194 {
2195         gint row, column;
2196         FolderItem *item, *current_item;
2197         GtkCTreeNode *node = NULL;
2198         gboolean acceptable = FALSE;
2199
2200         if (gtk_clist_get_selection_info(GTK_CLIST(widget),
2201                                          x - 24, y - 24, &row, &column)) {
2202                 node = gtk_ctree_node_nth(GTK_CTREE(widget), row);
2203                 item = gtk_ctree_node_get_row_data(GTK_CTREE(widget), node);
2204                 current_item = folderview->summaryview->folder_item;
2205                 if (item != NULL &&
2206                     item->path != NULL &&
2207                     current_item != NULL &&
2208                     current_item != item) {
2209                         switch (item->folder->type){
2210                         case F_MH:
2211                                 if (current_item->folder->type == F_MH)
2212                                     acceptable = TRUE;
2213                                 break;
2214                         case F_IMAP:
2215                                 if (current_item->folder->account == item->folder->account)
2216                                     acceptable = TRUE;
2217                                 break;
2218                         default:
2219                         }
2220                 }
2221         }
2222
2223         if (acceptable) {
2224                 gtk_ctree_select(GTK_CTREE(widget), node);
2225                 gdk_drag_status(context, context->suggested_action, time);
2226         } else {
2227                 gtk_ctree_select(GTK_CTREE(widget), folderview->opened);
2228                 gdk_drag_status(context, 0, time);
2229         }
2230
2231         return acceptable;
2232 }
2233
2234 static void folderview_drag_leave_cb(GtkWidget      *widget,
2235                                      GdkDragContext *context,
2236                                      guint           time,
2237                                      FolderView     *folderview)
2238 {
2239         gtk_ctree_select(GTK_CTREE(widget), folderview->opened);
2240 }
2241
2242 static void folderview_drag_received_cb(GtkWidget        *widget,
2243                                         GdkDragContext   *drag_context,
2244                                         gint              x,
2245                                         gint              y,
2246                                         GtkSelectionData *data,
2247                                         guint             info,
2248                                         guint             time,
2249                                         FolderView       *folderview)
2250 {
2251         gint row, column;
2252         FolderItem *item;
2253         GtkCTreeNode *node;
2254
2255         if (gtk_clist_get_selection_info(GTK_CLIST(widget),
2256                                          x - 24, y - 24, &row, &column) == 0)
2257                 return;
2258
2259         node = gtk_ctree_node_nth(GTK_CTREE(widget), row);
2260         item = gtk_ctree_node_get_row_data(GTK_CTREE(widget), node);
2261         if (item != NULL) {
2262                 summary_move_selected_to(folderview->summaryview, item);
2263                 gtk_drag_finish(drag_context, TRUE, TRUE, time);
2264         } else
2265                 gtk_drag_finish(drag_context, FALSE, FALSE, time);
2266 }
2267
2268 static gint folderview_compare_name(gconstpointer a, gconstpointer b)
2269 {
2270         const FolderItem *item = a;
2271         const gchar *name = b;
2272
2273         if (!item->path) return -1;
2274         return strcmp2(g_basename(item->path), name);
2275 }
2276
2277 static void folderview_scoring_cb(FolderView *folderview, guint action,
2278                                    GtkWidget *widget)
2279 {
2280         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
2281         FolderItem *item;
2282
2283         if (!folderview->selected) return;
2284
2285         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
2286         g_return_if_fail(item != NULL);
2287         g_return_if_fail(item->folder != NULL);
2288
2289         prefs_scoring_open(item);
2290 }
2291
2292 static void folderview_processing_cb(FolderView *folderview, guint action,
2293                                      GtkWidget *widget)
2294 {
2295         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
2296         FolderItem *item;
2297
2298         if (!folderview->selected) return;
2299
2300         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
2301         g_return_if_fail(item != NULL);
2302         g_return_if_fail(item->folder != NULL);
2303
2304         prefs_filtering_open(item);
2305 }
2306
2307 static void folderview_property_cb(FolderView *folderview, guint action, GtkWidget *widget) {
2308         GtkCTree *ctree = GTK_CTREE(folderview->ctree);
2309         FolderItem *item;
2310
2311         if (!folderview->selected) return;
2312
2313         item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
2314         g_return_if_fail(item != NULL);
2315         g_return_if_fail(item->folder != NULL);
2316
2317         prefs_folder_item_create(item);
2318 }
2319
2320 void folderview_set_target_folder_color(gint color_op) {
2321         gint firstone = 1;
2322         GList *list;
2323         FolderView *folderview;
2324
2325         for (list = folderview_list; list != NULL; list = list->next) {
2326                 folderview = (FolderView *)list->data;
2327                 gtkut_convert_int_to_gdk_color(color_op, &folderview->color_op);
2328                 if (firstone) {
2329                         bold_tgtfold_style->fg[GTK_STATE_NORMAL] =
2330                                 folderview->color_op;
2331                         firstone = 0;
2332                 }
2333         }
2334 }