2 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 1999-2007 Hiroyuki Yamamoto and the Claws Mail team
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 3 of the License, or
8 * (at your option) any later version.
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.
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include <glib/gi18n.h>
24 #include <gdk/gdkkeysyms.h>
25 #include <gtk/gtkwidget.h>
26 #include <gtk/gtkscrolledwindow.h>
27 #include <gtk/gtkctree.h>
28 #include <gtk/gtkcontainer.h>
29 #include <gtk/gtkclist.h>
30 #include <gtk/gtkstyle.h>
31 #include <gtk/gtksignal.h>
32 #include <gtk/gtkmain.h>
33 #include <gtk/gtkstatusbar.h>
34 #include <gtk/gtkmenu.h>
35 #include <gtk/gtkmenuitem.h>
36 #include <gtk/gtkitemfactory.h>
42 #include "mainwindow.h"
43 #include "folderview.h"
44 #include "summaryview.h"
45 #include "summary_search.h"
46 #include "inputdialog.h"
47 #include "manage_window.h"
48 #include "alertpanel.h"
50 #include "stock_pixmap.h"
54 #include "prefs_common.h"
55 #include "prefs_account.h"
56 #include "prefs_filtering.h"
57 #include "prefs_folder_item.h"
60 #include "foldersel.h"
62 #include "statusbar.h"
64 #include "folderutils.h"
65 #include "partial_download.h"
66 #include "prefs_folder_column.h"
67 #include "filtering.h"
68 #include "quicksearch.h"
73 #define COL_FOLDER_WIDTH 150
74 #define COL_NUM_WIDTH 32
76 static GList *folderview_list = NULL;
78 static GtkStyle *normal_style;
79 static GtkStyle *normal_color_style;
80 static GtkStyle *bold_style;
81 static GtkStyle *bold_color_style;
82 static GtkStyle *bold_tgtfold_style;
84 static GdkPixmap *inboxxpm;
85 static GdkBitmap *inboxxpmmask;
86 static GdkPixmap *inboxhrmxpm;
87 static GdkBitmap *inboxhrmxpmmask;
88 static GdkPixmap *inboxopenxpm;
89 static GdkBitmap *inboxopenxpmmask;
90 static GdkPixmap *inboxopenhrmxpm;
91 static GdkBitmap *inboxopenhrmxpmmask;
92 static GdkPixmap *outboxxpm;
93 static GdkBitmap *outboxxpmmask;
94 static GdkPixmap *outboxhrmxpm;
95 static GdkBitmap *outboxhrmxpmmask;
96 static GdkPixmap *outboxopenxpm;
97 static GdkBitmap *outboxopenxpmmask;
98 static GdkPixmap *outboxopenhrmxpm;
99 static GdkBitmap *outboxopenhrmxpmmask;
100 static GdkPixmap *folderxpm;
101 static GdkBitmap *folderxpmmask;
102 static GdkPixmap *folderhrmxpm;
103 static GdkBitmap *folderhrmxpmmask;
104 static GdkPixmap *folderopenxpm;
105 static GdkBitmap *folderopenxpmmask;
106 static GdkPixmap *folderopenhrmxpm;
107 static GdkBitmap *folderopenhrmxpmmask;
108 static GdkPixmap *trashopenxpm;
109 static GdkBitmap *trashopenxpmmask;
110 static GdkPixmap *trashopenhrmxpm;
111 static GdkBitmap *trashopenhrmxpmmask;
112 static GdkPixmap *trashxpm;
113 static GdkBitmap *trashxpmmask;
114 static GdkPixmap *trashhrmxpm;
115 static GdkBitmap *trashhrmxpmmask;
116 static GdkPixmap *queuexpm;
117 static GdkBitmap *queuexpmmask;
118 static GdkPixmap *queuehrmxpm;
119 static GdkBitmap *queuehrmxpmmask;
120 static GdkPixmap *queueopenxpm;
121 static GdkBitmap *queueopenxpmmask;
122 static GdkPixmap *queueopenhrmxpm;
123 static GdkBitmap *queueopenhrmxpmmask;
124 static GdkPixmap *draftsxpm;
125 static GdkBitmap *draftsxpmmask;
126 static GdkPixmap *draftsopenxpm;
127 static GdkBitmap *draftsopenxpmmask;
128 static GdkPixmap *noselectxpm;
129 static GdkBitmap *noselectxpmmask;
131 static GdkPixmap *m_inboxxpm;
132 static GdkBitmap *m_inboxxpmmask;
133 static GdkPixmap *m_inboxhrmxpm;
134 static GdkBitmap *m_inboxhrmxpmmask;
135 static GdkPixmap *m_inboxopenxpm;
136 static GdkBitmap *m_inboxopenxpmmask;
137 static GdkPixmap *m_inboxopenhrmxpm;
138 static GdkBitmap *m_inboxopenhrmxpmmask;
139 static GdkPixmap *m_outboxxpm;
140 static GdkBitmap *m_outboxxpmmask;
141 static GdkPixmap *m_outboxhrmxpm;
142 static GdkBitmap *m_outboxhrmxpmmask;
143 static GdkPixmap *m_outboxopenxpm;
144 static GdkBitmap *m_outboxopenxpmmask;
145 static GdkPixmap *m_outboxopenhrmxpm;
146 static GdkBitmap *m_outboxopenhrmxpmmask;
147 static GdkPixmap *m_folderxpm;
148 static GdkBitmap *m_folderxpmmask;
149 static GdkPixmap *m_folderhrmxpm;
150 static GdkBitmap *m_folderhrmxpmmask;
151 static GdkPixmap *m_folderopenxpm;
152 static GdkBitmap *m_folderopenxpmmask;
153 static GdkPixmap *m_folderopenhrmxpm;
154 static GdkBitmap *m_folderopenhrmxpmmask;
155 static GdkPixmap *m_trashopenxpm;
156 static GdkBitmap *m_trashopenxpmmask;
157 static GdkPixmap *m_trashopenhrmxpm;
158 static GdkBitmap *m_trashopenhrmxpmmask;
159 static GdkPixmap *m_trashxpm;
160 static GdkBitmap *m_trashxpmmask;
161 static GdkPixmap *m_trashhrmxpm;
162 static GdkBitmap *m_trashhrmxpmmask;
163 static GdkPixmap *m_queuexpm;
164 static GdkBitmap *m_queuexpmmask;
165 static GdkPixmap *m_queuehrmxpm;
166 static GdkBitmap *m_queuehrmxpmmask;
167 static GdkPixmap *m_queueopenxpm;
168 static GdkBitmap *m_queueopenxpmmask;
169 static GdkPixmap *m_queueopenhrmxpm;
170 static GdkBitmap *m_queueopenhrmxpmmask;
171 static GdkPixmap *m_draftsxpm;
172 static GdkBitmap *m_draftsxpmmask;
173 static GdkPixmap *m_draftsopenxpm;
174 static GdkBitmap *m_draftsopenxpmmask;
176 static GdkPixmap *newxpm;
177 static GdkBitmap *newxpmmask;
178 static GdkPixmap *unreadxpm;
179 static GdkBitmap *unreadxpmmask;
180 static GdkPixmap *readxpm;
181 static GdkBitmap *readxpmmask;
183 static void folderview_select_node (FolderView *folderview,
185 static void folderview_set_folders (FolderView *folderview);
186 static void folderview_sort_folders (FolderView *folderview,
189 static void folderview_append_folder (FolderView *folderview,
191 static void folderview_update_node (FolderView *folderview,
194 static gint folderview_clist_compare (GtkCList *clist,
198 /* callback functions */
199 static gboolean folderview_button_pressed (GtkWidget *ctree,
200 GdkEventButton *event,
201 FolderView *folderview);
202 static gboolean folderview_button_released (GtkWidget *ctree,
203 GdkEventButton *event,
204 FolderView *folderview);
205 static gboolean folderview_key_pressed (GtkWidget *widget,
207 FolderView *folderview);
208 static void folderview_selected (GtkCTree *ctree,
211 FolderView *folderview);
212 static void folderview_tree_expanded (GtkCTree *ctree,
214 FolderView *folderview);
215 static void folderview_tree_collapsed (GtkCTree *ctree,
217 FolderView *folderview);
218 static void folderview_popup_close (GtkMenuShell *menu_shell,
219 FolderView *folderview);
220 static void folderview_col_resized (GtkCList *clist,
223 FolderView *folderview);
225 static void mark_all_read_cb (FolderView *folderview,
229 static void folderview_empty_trash_cb (FolderView *folderview,
233 static void folderview_send_queue_cb (FolderView *folderview,
237 static void folderview_search_cb (FolderView *folderview,
240 static void folderview_run_processing_cb(FolderView *folderview,
244 static void folderview_property_cb (FolderView *folderview,
248 static gboolean folderview_drag_motion_cb(GtkWidget *widget,
249 GdkDragContext *context,
253 FolderView *folderview);
254 static void folderview_drag_leave_cb (GtkWidget *widget,
255 GdkDragContext *context,
257 FolderView *folderview);
258 static void folderview_drag_received_cb (GtkWidget *widget,
259 GdkDragContext *drag_context,
262 GtkSelectionData *data,
265 FolderView *folderview);
266 static void folderview_start_drag (GtkWidget *widget, gint button, GdkEvent *event,
267 FolderView *folderview);
268 static void folderview_drag_data_get (GtkWidget *widget,
269 GdkDragContext *drag_context,
270 GtkSelectionData *selection_data,
273 FolderView *folderview);
274 static void folderview_drag_end_cb (GtkWidget *widget,
275 GdkDragContext *drag_context,
276 FolderView *folderview);
278 static void folderview_create_folder_node (FolderView *folderview,
280 static gboolean folderview_update_folder (gpointer source,
282 static gboolean folderview_update_item_claws (gpointer source,
284 static void folderview_processing_cb(FolderView *folderview, guint action,
286 static void folderview_set_sens_and_popup_menu(FolderView *folderview, gint row,
287 GdkEventButton *event);
289 GHashTable *folderview_popups;
291 static GtkItemFactoryEntry folderview_common_popup_entries[] =
293 {N_("/Mark all re_ad"), NULL, mark_all_read_cb, 0, NULL},
294 {"/---", NULL, NULL, 0, "<Separator>"},
295 {N_("/Run processing rules"), NULL, folderview_run_processing_cb, 0, NULL},
296 {N_("/_Search folder..."), NULL, folderview_search_cb, 0, NULL},
297 {N_("/_Properties..."), NULL, folderview_property_cb, 0, NULL},
298 {N_("/Process_ing..."), NULL, folderview_processing_cb, 0, NULL},
301 static GtkItemFactoryEntry folder_view_trash_popup_entries[] = {
302 {"/------trashsep", NULL, NULL, 0, "<Separator>"},
303 {N_("/Empty _trash..."), NULL, folderview_empty_trash_cb, 0, NULL},
306 static GtkItemFactoryEntry folder_view_queue_popup_entries[] = {
307 {"/------queuesep", NULL, NULL, 0, "<Separator>"},
308 {N_("/Send _queue..."), NULL, folderview_send_queue_cb, 0, NULL},
312 GtkTargetEntry folderview_drag_types[] =
314 {"claws-mail/internal", GTK_TARGET_SAME_APP, TARGET_DUMMY},
315 {"text/uri-list", 0, TARGET_MAIL_URI_LIST}
318 void folderview_initialize(void)
320 FolderViewPopup *fpopup;
322 GSList *entries = NULL;
324 fpopup = g_new0(FolderViewPopup, 1);
326 n_entries = sizeof(folderview_common_popup_entries) /
327 sizeof(folderview_common_popup_entries[0]);
328 for (i = 0; i < n_entries; i++)
329 entries = g_slist_append(entries, &folderview_common_popup_entries[i]);
331 fpopup->klass = "common";
332 fpopup->path = "<CommonFolder>";
333 fpopup->entries = entries;
334 fpopup->set_sensitivity = NULL;
336 folderview_popups = g_hash_table_new(g_str_hash, g_str_equal);
337 g_hash_table_insert(folderview_popups, "common", fpopup);
340 static GtkItemFactory *create_ifactory(FolderView *folderview, FolderViewPopup *fpopup)
343 GtkItemFactory *factory;
344 FolderViewPopup *fpopup_common;
347 factory = gtk_item_factory_new(GTK_TYPE_MENU, fpopup->path, NULL);
348 gtk_item_factory_set_translate_func(factory, menu_translate,
351 for (entries = fpopup->entries; entries != NULL; entries = g_slist_next(entries))
352 gtk_item_factory_create_item(factory, entries->data, folderview, 1);
354 fpopup_common = g_hash_table_lookup(folderview_popups, "common");
355 if (fpopup_common != fpopup)
356 for (entries = fpopup_common->entries; entries != NULL; entries = g_slist_next(entries))
357 gtk_item_factory_create_item(factory, entries->data, folderview, 1);
359 popup = gtk_item_factory_get_widget(factory, fpopup->path);
360 g_signal_connect(G_OBJECT(popup), "selection_done",
361 G_CALLBACK(folderview_popup_close),
367 static void create_ifactories(gpointer key, gpointer value, gpointer data)
369 FolderView *folderview = data;
370 FolderViewPopup *fpopup = value;
371 GtkItemFactory *factory;
373 factory = create_ifactory(folderview, fpopup);
374 g_hash_table_insert(folderview->popups, fpopup->klass, factory);
377 static void folderview_column_set_titles(FolderView *folderview)
379 GtkWidget *ctree = folderview->ctree;
380 GtkWidget *label_folder;
381 GtkWidget *label_new;
382 GtkWidget *label_unread;
383 GtkWidget *label_total;
384 GtkWidget *hbox_folder;
386 GtkWidget *hbox_unread;
387 GtkWidget *hbox_total;
388 gint *col_pos = folderview->col_pos;
390 debug_print("setting titles...\n");
391 gtk_widget_realize(folderview->ctree);
392 gtk_widget_show_all(folderview->scrolledwin);
394 /* CLAWS: titles for "New" and "Unread" show new & unread pixmaps
395 * instead text (text overflows making them unreadable and ugly) */
396 stock_pixmap_gdk(ctree, STOCK_PIXMAP_NEW,
397 &newxpm, &newxpmmask);
398 stock_pixmap_gdk(ctree, STOCK_PIXMAP_UNREAD,
399 &unreadxpm, &unreadxpmmask);
400 stock_pixmap_gdk(ctree, STOCK_PIXMAP_READ,
401 &readxpm, &readxpmmask);
403 label_folder = gtk_label_new(_("Folder"));
404 label_new = gtk_image_new_from_pixmap(newxpm, newxpmmask);
405 label_unread = gtk_image_new_from_pixmap(unreadxpm, unreadxpmmask);
406 label_total = gtk_image_new_from_pixmap(readxpm, readxpmmask);
408 gtk_clist_column_titles_active(GTK_CLIST(ctree));
410 hbox_folder = gtk_hbox_new(FALSE, 4);
411 hbox_new = gtk_hbox_new(FALSE, 4);
412 hbox_unread = gtk_hbox_new(FALSE, 4);
413 hbox_total = gtk_hbox_new(FALSE, 4);
416 gtk_box_pack_start(GTK_BOX(hbox_folder), label_folder, TRUE, TRUE, 0);
417 gtk_misc_set_alignment (GTK_MISC (label_folder), 0, 0.5);
418 gtk_box_pack_start(GTK_BOX(hbox_new), label_new, TRUE, TRUE, 0);
419 gtk_misc_set_alignment (GTK_MISC (label_new), 1, 0.5);
420 gtk_box_pack_start(GTK_BOX(hbox_unread), label_unread, TRUE, TRUE, 0);
421 gtk_misc_set_alignment (GTK_MISC (label_unread), 1, 0.5);
422 gtk_box_pack_start(GTK_BOX(hbox_total), label_total, TRUE, TRUE, 0);
423 gtk_misc_set_alignment (GTK_MISC (label_total), 1, 0.5);
425 gtk_widget_show_all(hbox_folder);
426 gtk_widget_show_all(hbox_new);
427 gtk_widget_show_all(hbox_unread);
428 gtk_widget_show_all(hbox_total);
431 gtk_widget_set_size_request(hbox_new, -1, 20);
432 gtk_widget_set_size_request(hbox_unread, -1, 20);
433 gtk_widget_set_size_request(hbox_total, -1, 20);
436 gtk_clist_set_column_widget(GTK_CLIST(ctree),col_pos[F_COL_FOLDER],hbox_folder);
437 gtk_clist_set_column_widget(GTK_CLIST(ctree),col_pos[F_COL_NEW],hbox_new);
438 gtk_clist_set_column_widget(GTK_CLIST(ctree),col_pos[F_COL_UNREAD],hbox_unread);
439 gtk_clist_set_column_widget(GTK_CLIST(ctree),col_pos[F_COL_TOTAL],hbox_total);
445 gtk_sctree_set_column_tooltip(GTK_SCTREE(ctree), col_pos[F_COL_NEW], _("New"));
446 gtk_sctree_set_column_tooltip(GTK_SCTREE(ctree), col_pos[F_COL_UNREAD], _("Unread"));
447 gtk_sctree_set_column_tooltip(GTK_SCTREE(ctree), col_pos[F_COL_TOTAL], _("Total"));
450 static gboolean folderview_popup_menu(GtkWidget *widget, gpointer data)
452 FolderView *folderview = (FolderView *)data;
453 GdkEventButton event;
454 if (folderview_get_selected_item(folderview) == NULL)
458 event.time = gtk_get_current_event_time();
460 folderview_set_sens_and_popup_menu(folderview, -1,
467 static GtkWidget *folderview_ctree_create(FolderView *folderview)
471 FolderColumnState *col_state;
472 FolderColumnType type;
473 gchar *titles[N_FOLDER_COLS];
475 GtkWidget *scrolledwin = folderview->scrolledwin;
477 debug_print("creating tree...\n");
478 memset(titles, 0, sizeof(titles));
480 col_state = prefs_folder_column_get_config();
481 memset(titles, 0, sizeof(titles));
483 col_pos = folderview->col_pos;
485 for (i = 0; i < N_FOLDER_COLS; i++) {
486 folderview->col_state[i] = col_state[i];
487 type = col_state[i].type;
491 titles[col_pos[F_COL_FOLDER]] = _("Folder");
492 titles[col_pos[F_COL_NEW]] = _("New");
493 titles[col_pos[F_COL_UNREAD]] = _("Unread");
494 /* TRANSLATORS: This in Number sign in American style */
495 titles[col_pos[F_COL_TOTAL]] = _("#");
497 ctree = gtk_sctree_new_with_titles(N_FOLDER_COLS, col_pos[F_COL_FOLDER],
500 if (prefs_common.show_col_headers == FALSE)
501 gtk_clist_column_titles_hide(GTK_CLIST(ctree));
504 gtk_clist_set_selection_mode(GTK_CLIST(ctree), GTK_SELECTION_BROWSE);
505 gtk_clist_set_column_justification(GTK_CLIST(ctree), col_pos[F_COL_NEW],
507 gtk_clist_set_column_justification(GTK_CLIST(ctree),
508 col_pos[F_COL_UNREAD],
510 gtk_clist_set_column_justification(GTK_CLIST(ctree),
511 col_pos[F_COL_TOTAL],
513 if (prefs_common.enable_dotted_lines) {
514 gtk_ctree_set_line_style(GTK_CTREE(ctree), GTK_CTREE_LINES_DOTTED);
515 gtk_ctree_set_expander_style(GTK_CTREE(ctree),
516 GTK_CTREE_EXPANDER_SQUARE);
518 gtk_ctree_set_line_style(GTK_CTREE(ctree), GTK_CTREE_LINES_NONE);
519 gtk_ctree_set_expander_style(GTK_CTREE(ctree),
520 GTK_CTREE_EXPANDER_TRIANGLE);
523 gtk_sctree_set_stripes(GTK_SCTREE(ctree), prefs_common.use_stripes_in_summaries);
524 gtk_sctree_set_recursive_expand(GTK_SCTREE(ctree), FALSE);
526 gtk_ctree_set_indent(GTK_CTREE(ctree), CTREE_INDENT);
527 gtk_clist_set_compare_func(GTK_CLIST(ctree), folderview_clist_compare);
529 /* don't let title buttons take key focus */
530 for (i = 0; i < N_FOLDER_COLS; i++) {
531 GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(ctree)->column[i].button,
533 gtk_clist_set_column_width(GTK_CLIST(ctree), col_pos[i],
534 prefs_common.folder_col_size[i]);
535 gtk_clist_set_column_visibility
536 (GTK_CLIST(ctree), i, col_state[i].visible);
539 g_signal_connect(G_OBJECT(ctree), "key_press_event",
540 G_CALLBACK(folderview_key_pressed),
542 g_signal_connect(G_OBJECT(ctree), "button_press_event",
543 G_CALLBACK(folderview_button_pressed),
546 g_signal_connect(G_OBJECT(ctree), "popup-menu",
547 G_CALLBACK(folderview_popup_menu), folderview);
549 gtk_widget_tap_and_hold_setup(GTK_WIDGET(ctree), NULL, NULL,
550 GTK_TAP_AND_HOLD_NONE | GTK_TAP_AND_HOLD_NO_INTERNALS);
551 g_signal_connect(G_OBJECT(ctree), "tap-and-hold",
552 G_CALLBACK(folderview_popup_menu), folderview);
554 g_signal_connect(G_OBJECT(ctree), "button_release_event",
555 G_CALLBACK(folderview_button_released),
557 g_signal_connect(G_OBJECT(ctree), "tree_select_row",
558 G_CALLBACK(folderview_selected), folderview);
560 /* drag-n-dropping folders on maemo is impractical as this
561 * opens the folder almost everytime */
562 g_signal_connect(G_OBJECT(ctree), "start_drag",
563 G_CALLBACK(folderview_start_drag), folderview);
565 g_signal_connect(G_OBJECT(ctree), "drag_data_get",
566 G_CALLBACK(folderview_drag_data_get),
569 g_signal_connect_after(G_OBJECT(ctree), "tree_expand",
570 G_CALLBACK(folderview_tree_expanded),
572 g_signal_connect_after(G_OBJECT(ctree), "tree_collapse",
573 G_CALLBACK(folderview_tree_collapsed),
576 g_signal_connect(G_OBJECT(ctree), "resize_column",
577 G_CALLBACK(folderview_col_resized),
581 gtk_drag_dest_set(ctree, GTK_DEST_DEFAULT_ALL & ~GTK_DEST_DEFAULT_HIGHLIGHT,
582 folderview_drag_types, 2,
583 GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_DEFAULT);
584 g_signal_connect(G_OBJECT(ctree), "drag_motion",
585 G_CALLBACK(folderview_drag_motion_cb),
587 g_signal_connect(G_OBJECT(ctree), "drag_leave",
588 G_CALLBACK(folderview_drag_leave_cb),
590 g_signal_connect(G_OBJECT(ctree), "drag_data_received",
591 G_CALLBACK(folderview_drag_received_cb),
593 g_signal_connect(G_OBJECT(ctree), "drag_end",
594 G_CALLBACK(folderview_drag_end_cb),
597 gtk_container_add(GTK_CONTAINER(scrolledwin), ctree);
602 void folderview_set_column_order(FolderView *folderview)
605 FolderItem *item = folderview_get_selected_item(folderview);
606 GtkWidget *scrolledwin = folderview->scrolledwin;
608 debug_print("recreating tree...\n");
609 gtk_widget_destroy(folderview->ctree);
611 folderview->ctree = ctree = folderview_ctree_create(folderview);
612 gtk_scrolled_window_set_hadjustment(GTK_SCROLLED_WINDOW(scrolledwin),
613 GTK_CLIST(ctree)->hadjustment);
614 gtk_scrolled_window_set_vadjustment(GTK_SCROLLED_WINDOW(scrolledwin),
615 GTK_CLIST(ctree)->vadjustment);
616 gtk_widget_show(ctree);
618 folderview_set(folderview);
619 folderview_column_set_titles(folderview);
621 folderview_select(folderview,item);
624 FolderView *folderview_create(void)
626 FolderView *folderview;
627 GtkWidget *scrolledwin;
630 debug_print("Creating folder view...\n");
631 folderview = g_new0(FolderView, 1);
633 scrolledwin = gtk_scrolled_window_new(NULL, NULL);
634 gtk_scrolled_window_set_policy
635 (GTK_SCROLLED_WINDOW(scrolledwin),
636 GTK_POLICY_AUTOMATIC,
637 prefs_common.folderview_vscrollbar_policy);
638 gtk_widget_set_size_request(scrolledwin,
639 prefs_common.folderview_width,
640 prefs_common.folderview_height);
642 folderview->scrolledwin = scrolledwin;
643 ctree = folderview_ctree_create(folderview);
645 /* create popup factories */
646 folderview->popups = g_hash_table_new(g_str_hash, g_str_equal);
647 g_hash_table_foreach(folderview_popups, create_ifactories, folderview);
649 folderview->ctree = ctree;
651 folderview->folder_update_callback_id =
652 hooks_register_hook(FOLDER_UPDATE_HOOKLIST, folderview_update_folder, (gpointer) folderview);
653 folderview->folder_item_update_callback_id =
654 hooks_register_hook(FOLDER_ITEM_UPDATE_HOOKLIST, folderview_update_item_claws, (gpointer) folderview);
656 gtk_widget_show_all(scrolledwin);
658 folderview->target_list = gtk_target_list_new(folderview_drag_types, 2);
659 folderview_list = g_list_append(folderview_list, folderview);
660 folderview->deferred_refresh_id = -1;
665 void folderview_init(FolderView *folderview)
667 GtkWidget *ctree = folderview->ctree;
670 stock_pixmap_gdk(ctree, STOCK_PIXMAP_INBOX_CLOSE, &inboxxpm, &inboxxpmmask);
671 stock_pixmap_gdk(ctree, STOCK_PIXMAP_INBOX_CLOSE_HRM, &inboxhrmxpm, &inboxhrmxpmmask);
672 stock_pixmap_gdk(ctree, STOCK_PIXMAP_INBOX_OPEN, &inboxopenxpm, &inboxopenxpmmask);
673 stock_pixmap_gdk(ctree, STOCK_PIXMAP_INBOX_OPEN_HRM, &inboxopenhrmxpm, &inboxopenhrmxpmmask);
674 stock_pixmap_gdk(ctree, STOCK_PIXMAP_OUTBOX_CLOSE, &outboxxpm, &outboxxpmmask);
675 stock_pixmap_gdk(ctree, STOCK_PIXMAP_OUTBOX_CLOSE_HRM, &outboxhrmxpm, &outboxhrmxpmmask);
676 stock_pixmap_gdk(ctree, STOCK_PIXMAP_OUTBOX_OPEN, &outboxopenxpm, &outboxopenxpmmask);
677 stock_pixmap_gdk(ctree, STOCK_PIXMAP_OUTBOX_OPEN_HRM, &outboxopenhrmxpm, &outboxopenhrmxpmmask);
678 stock_pixmap_gdk(ctree, STOCK_PIXMAP_DIR_CLOSE, &folderxpm, &folderxpmmask);
679 stock_pixmap_gdk(ctree, STOCK_PIXMAP_DIR_CLOSE_HRM, &folderhrmxpm, &folderhrmxpmmask);
680 stock_pixmap_gdk(ctree, STOCK_PIXMAP_DIR_OPEN, &folderopenxpm, &folderopenxpmmask);
681 stock_pixmap_gdk(ctree, STOCK_PIXMAP_DIR_OPEN_HRM, &folderopenhrmxpm, &folderopenhrmxpmmask);
682 stock_pixmap_gdk(ctree, STOCK_PIXMAP_TRASH_OPEN, &trashopenxpm, &trashopenxpmmask);
683 stock_pixmap_gdk(ctree, STOCK_PIXMAP_TRASH_OPEN_HRM, &trashopenhrmxpm, &trashopenhrmxpmmask);
684 stock_pixmap_gdk(ctree, STOCK_PIXMAP_TRASH_CLOSE, &trashxpm, &trashxpmmask);
685 stock_pixmap_gdk(ctree, STOCK_PIXMAP_TRASH_CLOSE_HRM, &trashhrmxpm, &trashhrmxpmmask);
686 stock_pixmap_gdk(ctree, STOCK_PIXMAP_QUEUE_CLOSE, &queuexpm, &queuexpmmask);
687 stock_pixmap_gdk(ctree, STOCK_PIXMAP_QUEUE_CLOSE_HRM, &queuehrmxpm, &queuehrmxpmmask);
688 stock_pixmap_gdk(ctree, STOCK_PIXMAP_QUEUE_OPEN, &queueopenxpm, &queueopenxpmmask);
689 stock_pixmap_gdk(ctree, STOCK_PIXMAP_QUEUE_OPEN_HRM, &queueopenhrmxpm, &queueopenhrmxpmmask);
690 stock_pixmap_gdk(ctree, STOCK_PIXMAP_DRAFTS_CLOSE, &draftsxpm, &draftsxpmmask);
691 stock_pixmap_gdk(ctree, STOCK_PIXMAP_DRAFTS_OPEN, &draftsopenxpm, &draftsopenxpmmask);
692 stock_pixmap_gdk(ctree, STOCK_PIXMAP_DIR_NOSELECT, &noselectxpm, &noselectxpmmask);
694 stock_pixmap_gdk(ctree, STOCK_PIXMAP_INBOX_CLOSE_MARK, &m_inboxxpm, &m_inboxxpmmask);
695 stock_pixmap_gdk(ctree, STOCK_PIXMAP_INBOX_CLOSE_HRM_MARK, &m_inboxhrmxpm, &m_inboxhrmxpmmask);
696 stock_pixmap_gdk(ctree, STOCK_PIXMAP_INBOX_OPEN_MARK, &m_inboxopenxpm, &m_inboxopenxpmmask);
697 stock_pixmap_gdk(ctree, STOCK_PIXMAP_INBOX_OPEN_HRM_MARK, &m_inboxopenhrmxpm, &m_inboxopenhrmxpmmask);
698 stock_pixmap_gdk(ctree, STOCK_PIXMAP_OUTBOX_CLOSE_MARK, &m_outboxxpm, &m_outboxxpmmask);
699 stock_pixmap_gdk(ctree, STOCK_PIXMAP_OUTBOX_CLOSE_HRM_MARK, &m_outboxhrmxpm, &m_outboxhrmxpmmask);
700 stock_pixmap_gdk(ctree, STOCK_PIXMAP_OUTBOX_OPEN_MARK, &m_outboxopenxpm, &m_outboxopenxpmmask);
701 stock_pixmap_gdk(ctree, STOCK_PIXMAP_OUTBOX_OPEN_HRM_MARK, &m_outboxopenhrmxpm, &m_outboxopenhrmxpmmask);
702 stock_pixmap_gdk(ctree, STOCK_PIXMAP_DIR_CLOSE_MARK, &m_folderxpm, &m_folderxpmmask);
703 stock_pixmap_gdk(ctree, STOCK_PIXMAP_DIR_CLOSE_HRM_MARK, &m_folderhrmxpm, &m_folderhrmxpmmask);
704 stock_pixmap_gdk(ctree, STOCK_PIXMAP_DIR_OPEN_MARK, &m_folderopenxpm, &m_folderopenxpmmask);
705 stock_pixmap_gdk(ctree, STOCK_PIXMAP_DIR_OPEN_HRM_MARK, &m_folderopenhrmxpm, &m_folderopenhrmxpmmask);
706 stock_pixmap_gdk(ctree, STOCK_PIXMAP_TRASH_OPEN_MARK, &m_trashopenxpm, &m_trashopenxpmmask);
707 stock_pixmap_gdk(ctree, STOCK_PIXMAP_TRASH_OPEN_HRM_MARK, &m_trashopenhrmxpm, &m_trashopenhrmxpmmask);
708 stock_pixmap_gdk(ctree, STOCK_PIXMAP_TRASH_CLOSE_MARK, &m_trashxpm, &m_trashxpmmask);
709 stock_pixmap_gdk(ctree, STOCK_PIXMAP_TRASH_CLOSE_HRM_MARK, &m_trashhrmxpm, &m_trashhrmxpmmask);
710 stock_pixmap_gdk(ctree, STOCK_PIXMAP_QUEUE_CLOSE_MARK, &m_queuexpm, &m_queuexpmmask);
711 stock_pixmap_gdk(ctree, STOCK_PIXMAP_QUEUE_CLOSE_HRM_MARK, &m_queuehrmxpm, &m_queuehrmxpmmask);
712 stock_pixmap_gdk(ctree, STOCK_PIXMAP_QUEUE_OPEN_MARK, &m_queueopenxpm, &m_queueopenxpmmask);
713 stock_pixmap_gdk(ctree, STOCK_PIXMAP_QUEUE_OPEN_HRM_MARK, &m_queueopenhrmxpm, &m_queueopenhrmxpmmask);
714 stock_pixmap_gdk(ctree, STOCK_PIXMAP_DRAFTS_CLOSE_MARK, &m_draftsxpm, &m_draftsxpmmask);
715 stock_pixmap_gdk(ctree, STOCK_PIXMAP_DRAFTS_OPEN_MARK, &m_draftsopenxpm, &m_draftsopenxpmmask);
718 PangoFontDescription *font_desc;
719 normal_style = gtk_style_copy(gtk_widget_get_style(ctree));
720 font_desc = pango_font_description_from_string(NORMAL_FONT);
722 if (normal_style->font_desc)
723 pango_font_description_free
724 (normal_style->font_desc);
725 normal_style->font_desc = font_desc;
727 gtkut_convert_int_to_gdk_color(prefs_common.color_new, &gdk_color);
728 normal_color_style = gtk_style_copy(normal_style);
729 normal_color_style->fg[GTK_STATE_NORMAL] = gdk_color;
731 gtk_widget_set_style(ctree, normal_style);
735 gtkut_convert_int_to_gdk_color(prefs_common.color_new, &gdk_color);
736 bold_style = gtk_style_copy(gtk_widget_get_style(ctree));
737 pango_font_description_set_weight
738 (bold_style->font_desc, PANGO_WEIGHT_BOLD);
739 bold_color_style = gtk_style_copy(bold_style);
740 bold_color_style->fg[GTK_STATE_NORMAL] = gdk_color;
742 bold_tgtfold_style = gtk_style_copy(bold_style);
743 bold_tgtfold_style->fg[GTK_STATE_NORMAL] = folderview->color_op;
747 static gboolean folderview_defer_set(gpointer data)
749 FolderView *folderview = (FolderView *)data;
750 MainWindow *mainwin = folderview->mainwin;
754 if (mainwin->lock_count)
757 g_print("doing deferred folderview_set now\n");
758 folderview_set(folderview);
760 folderview->deferred_refresh_id = -1;
764 void folderview_set(FolderView *folderview)
766 GtkCTree *ctree = GTK_CTREE(folderview->ctree);
767 MainWindow *mainwin = folderview->mainwin;
768 FolderItem *sel_item = NULL, *op_item = NULL;
773 if (mainwin->lock_count) {
774 if (folderview->deferred_refresh_id == -1)
775 folderview->deferred_refresh_id =
776 g_timeout_add(500, folderview_defer_set, folderview);
777 g_print("deferred folderview_set\n");
782 debug_print("Setting folder info...\n");
783 STATUSBAR_PUSH(mainwin, _("Setting folder info..."));
785 main_window_cursor_wait(mainwin);
787 if (folderview->selected)
788 sel_item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
789 if (folderview->opened)
790 op_item = gtk_ctree_node_get_row_data(ctree, folderview->opened);
792 folderview->selected = NULL;
793 folderview->opened = NULL;
795 gtk_clist_freeze(GTK_CLIST(ctree));
796 gtk_clist_clear(GTK_CLIST(ctree));
798 folderview_set_folders(folderview);
801 folderview->selected = gtk_ctree_find_by_row_data(ctree, NULL, sel_item);
803 folderview->opened = gtk_ctree_find_by_row_data(ctree, NULL, op_item);
805 gtk_clist_thaw(GTK_CLIST(ctree));
806 main_window_cursor_normal(mainwin);
807 STATUSBAR_POP(mainwin);
811 void folderview_set_all(void)
815 for (list = folderview_list; list != NULL; list = list->next)
816 folderview_set((FolderView *)list->data);
819 void folderview_select(FolderView *folderview, FolderItem *item)
821 GtkCTree *ctree = GTK_CTREE(folderview->ctree);
823 GtkCTreeNode *old_selected = folderview->selected;
827 node = gtk_ctree_find_by_row_data(ctree, NULL, item);
828 if (node) folderview_select_node(folderview, node);
830 if (old_selected != node)
831 folder_update_op_count();
834 static void mark_all_read_cb(FolderView *folderview, guint action,
840 item = folderview_get_selected_item(folderview);
844 if (folderview->summaryview->folder_item != item
845 && prefs_common.ask_mark_all_read) {
846 val = alertpanel_full(_("Mark all as read"),
847 _("Do you really want to mark all mails in this "
848 "folder as read ?"), GTK_STOCK_NO, GTK_STOCK_YES, NULL,
849 TRUE, NULL, ALERT_QUESTION, G_ALERTDEFAULT);
851 if ((val & ~G_ALERTDISABLE) != G_ALERTALTERNATE)
853 else if (val & G_ALERTDISABLE)
854 prefs_common.ask_mark_all_read = FALSE;
857 summary_lock(folderview->summaryview);
858 folder_item_update_freeze();
859 if (folderview->summaryview->folder_item == item)
860 summary_freeze(folderview->summaryview);
861 folderutils_mark_all_read(item);
862 if (folderview->summaryview->folder_item == item)
863 summary_thaw(folderview->summaryview);
864 folder_item_update_thaw();
865 summary_unlock(folderview->summaryview);
868 static void folderview_select_node(FolderView *folderview, GtkCTreeNode *node)
870 GtkCTree *ctree = GTK_CTREE(folderview->ctree);
872 g_return_if_fail(node != NULL);
874 if (folderview->open_folder) {
878 folderview->open_folder = TRUE;
879 gtkut_ctree_set_focus_row(ctree, node);
880 gtk_ctree_select(ctree, node);
881 if (folderview->summaryview->folder_item &&
882 folderview->summaryview->folder_item->total_msgs > 0)
883 summary_grab_focus(folderview->summaryview);
885 gtk_widget_grab_focus(folderview->ctree);
887 gtkut_ctree_expand_parent_all(ctree, node);
890 void folderview_unselect(FolderView *folderview)
892 if (folderview->opened && !GTK_CTREE_ROW(folderview->opened)->children)
894 (GTK_CTREE(folderview->ctree), folderview->opened);
896 folderview->selected = folderview->opened = NULL;
899 static GtkCTreeNode *folderview_find_next_marked(GtkCTree *ctree,
905 node = gtkut_ctree_node_next(ctree, node);
907 node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list);
909 for (; node != NULL; node = gtkut_ctree_node_next(ctree, node)) {
910 item = gtk_ctree_node_get_row_data(ctree, node);
911 if (item && item->marked_msgs > 0 && item->stype != F_TRASH)
918 void folderview_select_next_marked(FolderView *folderview)
920 GtkCTree *ctree = GTK_CTREE(folderview->ctree);
921 GtkCTreeNode *node = NULL;
922 EntryAction last_summary_select_prio = prefs_common.summary_select_prio[0];
923 gboolean last_open = prefs_common.always_show_msg;
925 prefs_common.summary_select_prio[0] = ACTION_MARKED;
926 prefs_common.always_show_msg = TRUE;
928 if ((node = folderview_find_next_marked(ctree, folderview->opened))
930 folderview_select_node(folderview, node);
934 if (!folderview->opened ||
935 folderview->opened == GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list)) {
938 /* search again from the first node */
939 if ((node = folderview_find_next_marked(ctree, NULL)) != NULL)
940 folderview_select_node(folderview, node);
943 prefs_common.summary_select_prio[0] = last_summary_select_prio;
944 prefs_common.always_show_msg = last_open;
947 static GtkCTreeNode *folderview_find_next_unread(GtkCTree *ctree,
953 node = gtkut_ctree_node_next(ctree, node);
955 node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list);
957 for (; node != NULL; node = gtkut_ctree_node_next(ctree, node)) {
958 item = gtk_ctree_node_get_row_data(ctree, node);
959 if (item && item->unread_msgs > 0 && item->stype != F_TRASH)
966 void folderview_select_next_unread(FolderView *folderview, gboolean force_open)
968 GtkCTree *ctree = GTK_CTREE(folderview->ctree);
969 GtkCTreeNode *node = NULL;
970 EntryAction last_summary_select_prio = prefs_common.summary_select_prio[0];
971 gboolean last_open = prefs_common.always_show_msg;
973 prefs_common.summary_select_prio[0] = ACTION_UNREAD;
974 prefs_common.always_show_msg = force_open ? TRUE : last_open;
976 if ((node = folderview_find_next_unread(ctree, folderview->opened))
978 folderview_select_node(folderview, node);
982 if (!folderview->opened ||
983 folderview->opened == GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list)) {
986 /* search again from the first node */
987 if ((node = folderview_find_next_unread(ctree, NULL)) != NULL)
988 folderview_select_node(folderview, node);
991 prefs_common.summary_select_prio[0] = last_summary_select_prio;
992 prefs_common.always_show_msg = last_open;
995 static GtkCTreeNode *folderview_find_next_new(GtkCTree *ctree,
1001 node = gtkut_ctree_node_next(ctree, node);
1003 node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list);
1005 for (; node != NULL; node = gtkut_ctree_node_next(ctree, node)) {
1006 item = gtk_ctree_node_get_row_data(ctree, node);
1007 if (item && item->new_msgs > 0 && item->stype != F_TRASH)
1014 void folderview_select_next_new(FolderView *folderview)
1016 GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1017 GtkCTreeNode *node = NULL;
1018 EntryAction last_summary_select_prio = prefs_common.summary_select_prio[0];
1019 gboolean last_open = prefs_common.always_show_msg;
1021 prefs_common.summary_select_prio[0] = ACTION_NEW;
1022 prefs_common.always_show_msg = TRUE;
1024 if ((node = folderview_find_next_new(ctree, folderview->opened))
1026 folderview_select_node(folderview, node);
1030 if (!folderview->opened ||
1031 folderview->opened == GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list)) {
1034 /* search again from the first node */
1035 if ((node = folderview_find_next_new(ctree, NULL)) != NULL)
1036 folderview_select_node(folderview, node);
1039 prefs_common.summary_select_prio[0] = last_summary_select_prio;
1040 prefs_common.always_show_msg = last_open;
1043 FolderItem *folderview_get_selected_item(FolderView *folderview)
1045 GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1047 if (!folderview->selected) return NULL;
1048 return gtk_ctree_node_get_row_data(ctree, folderview->selected);
1051 static void folderview_set_folders(FolderView *folderview)
1054 list = folder_get_list();
1056 for (; list != NULL; list = list->next) {
1057 folderview_append_folder(folderview, FOLDER(list->data));
1061 static gchar *get_scan_str(FolderItem *item)
1064 return g_strdup_printf(_("Scanning folder %s%c%s ..."),
1065 item->folder->name, G_DIR_SEPARATOR,
1068 return g_strdup_printf(_("Scanning folder %s ..."),
1069 item->folder->name);
1071 static void folderview_scan_tree_func(Folder *folder, FolderItem *item,
1075 for (list = folderview_list; list != NULL; list = list->next) {
1076 FolderView *folderview = (FolderView *)list->data;
1077 MainWindow *mainwin = folderview->mainwin;
1078 gchar *str = get_scan_str(item);
1080 STATUSBAR_PUSH(mainwin, str);
1081 STATUSBAR_POP(mainwin);
1086 void folderview_rescan_tree(Folder *folder, gboolean rebuild)
1089 MainWindow *mainwin = mainwindow_get_mainwindow();
1090 FolderView *folderview = NULL;
1091 GtkAdjustment *pos = NULL;
1094 g_return_if_fail(folder != NULL);
1096 if (!folder->klass->scan_tree) return;
1099 alertpanel_full(_("Rebuild folder tree"),
1100 _("Rebuilding the folder tree will remove "
1101 "local caches. Do you want to continue?"),
1102 GTK_STOCK_NO, GTK_STOCK_YES, NULL, FALSE,
1103 NULL, ALERT_WARNING, G_ALERTDEFAULT)
1104 != G_ALERTALTERNATE) {
1110 window = label_window_create(_("Rebuilding folder tree..."));
1112 window = label_window_create(_("Scanning folder tree..."));
1115 folderview = mainwin->folderview;
1118 pos = gtk_scrolled_window_get_vadjustment(
1119 GTK_SCROLLED_WINDOW(folderview->scrolledwin));
1120 height = pos->value;
1123 folder_set_ui_func(folder, folderview_scan_tree_func, NULL);
1124 folder_scan_tree(folder, rebuild);
1125 folder_set_ui_func(folder, NULL, NULL);
1127 folderview_set_all();
1130 pos = gtk_scrolled_window_get_vadjustment(
1131 GTK_SCROLLED_WINDOW(folderview->scrolledwin));
1132 gtk_adjustment_set_value(pos, height);
1134 label_window_destroy(window);
1138 void folderview_fast_rescan_tree(Folder *folder)
1141 MainWindow *mainwin = mainwindow_get_mainwindow();
1142 FolderView *folderview = NULL;
1143 GtkAdjustment *pos = NULL;
1146 g_return_if_fail(folder != NULL);
1148 if (!folder->klass->scan_tree) return;
1152 window = label_window_create(_("Scanning folder tree..."));
1155 folderview = mainwin->folderview;
1158 pos = gtk_scrolled_window_get_vadjustment(
1159 GTK_SCROLLED_WINDOW(folderview->scrolledwin));
1160 height = pos->value;
1163 folder_set_ui_func(folder, folderview_scan_tree_func, NULL);
1164 folder_fast_scan_tree(folder);
1165 folder_set_ui_func(folder, NULL, NULL);
1167 folderview_set_all();
1170 pos = gtk_scrolled_window_get_vadjustment(
1171 GTK_SCROLLED_WINDOW(folderview->scrolledwin));
1172 gtk_adjustment_set_value(pos, height);
1174 label_window_destroy(window);
1178 /** folderview_check_new()
1179 * Scan and update the folder and return the
1180 * count the number of new messages since last check.
1181 * \param folder the folder to check for new messages
1182 * \return the number of new messages since last check
1184 gint folderview_check_new(Folder *folder)
1188 FolderView *folderview;
1192 gint former_new_msgs = 0;
1193 gint former_new = 0, former_unread = 0, former_total;
1195 for (list = folderview_list; list != NULL; list = list->next) {
1196 folderview = (FolderView *)list->data;
1197 ctree = GTK_CTREE(folderview->ctree);
1200 main_window_lock(folderview->mainwin);
1202 for (node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list);
1203 node != NULL; node = gtkut_ctree_node_next(ctree, node)) {
1205 item = gtk_ctree_node_get_row_data(ctree, node);
1206 if (!item || !item->path || !item->folder) continue;
1207 if (item->no_select) continue;
1208 if (folder && folder != item->folder) continue;
1209 if (!folder && !FOLDER_IS_LOCAL(item->folder)) continue;
1210 if (!item->prefs->newmailcheck) continue;
1211 if (item->processing_pending == TRUE) {
1212 debug_print("skipping %s, processing pending\n",
1213 item->path ? item->path : item->name);
1217 str = get_scan_str(item);
1219 STATUSBAR_PUSH(folderview->mainwin, str);
1223 folderview_scan_tree_func(item->folder, item, NULL);
1224 former_new = item->new_msgs;
1225 former_unread = item->unread_msgs;
1226 former_total = item->total_msgs;
1228 if (item->folder->klass->scan_required &&
1229 (item->folder->klass->scan_required(item->folder, item) ||
1230 item->folder->inbox == item ||
1231 item->opened == TRUE ||
1232 item->processing_pending == TRUE)) {
1233 if (folder_item_scan(item) < 0) {
1235 summaryview_unlock(folderview->summaryview, item);
1236 if (FOLDER_TYPE(item->folder) == F_NEWS || FOLDER_IS_LOCAL(folder)) {
1237 log_error(LOG_PROTOCOL, _("Couldn't scan folder %s\n"),
1238 item->path ? item->path:item->name);
1239 STATUSBAR_POP(folderview->mainwin);
1241 } else if (!FOLDER_IS_LOCAL(folder)) {
1242 STATUSBAR_POP(folderview->mainwin);
1247 } else if (!item->folder->klass->scan_required) {
1248 if (folder_item_scan(item) < 0) {
1249 summaryview_unlock(folderview->summaryview, item);
1250 if (folder && !FOLDER_IS_LOCAL(folder)) {
1251 STATUSBAR_POP(folderview->mainwin);
1256 if (former_new != item->new_msgs ||
1257 former_unread != item->unread_msgs ||
1258 former_total != item->total_msgs)
1259 folderview_update_node(folderview, node);
1261 new_msgs += item->new_msgs;
1262 former_new_msgs += former_new;
1263 STATUSBAR_POP(folderview->mainwin);
1266 main_window_unlock(folderview->mainwin);
1270 folder_write_list();
1271 /* Number of new messages since last check is the just the difference
1272 * between former_new_msgs and new_msgs. If new_msgs is less than
1273 * former_new_msgs, that would mean another session accessed the folder
1274 * and the result is not well defined.
1276 new_msgs = (former_new_msgs < new_msgs ? new_msgs - former_new_msgs : 0);
1280 void folderview_check_new_all(void)
1284 FolderView *folderview;
1286 folderview = (FolderView *)folderview_list->data;
1289 main_window_lock(folderview->mainwin);
1290 window = label_window_create
1291 (_("Checking for new messages in all folders..."));
1293 list = folder_get_list();
1294 for (; list != NULL; list = list->next) {
1295 Folder *folder = list->data;
1297 folderview_check_new(folder);
1300 folder_write_list();
1301 folderview_set_all();
1303 label_window_destroy(window);
1304 main_window_unlock(folderview->mainwin);
1308 static gboolean folderview_have_new_children_sub(FolderView *folderview,
1314 if (!item || !item->folder || !item->folder->node)
1317 node = item->folder->node;
1319 node = g_node_find(node, G_PRE_ORDER, G_TRAVERSE_ALL, item);
1320 node = node->children;
1323 (item->new_msgs > 0 ||
1324 (folder_has_parent_of_type(item, F_QUEUE) && item->total_msgs > 0))) {
1328 while (node != NULL) {
1329 if (node && node->data) {
1330 FolderItem *next_item = (FolderItem*) node->data;
1332 if (folderview_have_new_children_sub(folderview,
1341 static gboolean folderview_have_new_children(FolderView *folderview,
1344 return folderview_have_new_children_sub(folderview, item, FALSE);
1347 static gboolean folderview_have_unread_children_sub(FolderView *folderview,
1353 if (!item || !item->folder || !item->folder->node)
1356 node = item->folder->node;
1358 node = g_node_find(node, G_PRE_ORDER, G_TRAVERSE_ALL, item);
1359 node = node->children;
1362 (item->unread_msgs > 0 ||
1363 (folder_has_parent_of_type(item, F_QUEUE) && item->total_msgs > 0))) {
1367 while (node != NULL) {
1368 if (node && node->data) {
1369 FolderItem *next_item = (FolderItem*) node->data;
1371 if (folderview_have_unread_children_sub(folderview,
1381 static gboolean folderview_have_unread_children(FolderView *folderview,
1384 return folderview_have_unread_children_sub(folderview, item, FALSE);
1387 static gboolean folderview_have_matching_children_sub(FolderView *folderview,
1393 if (!item || !item->folder || !item->folder->node)
1396 node = item->folder->node;
1398 node = g_node_find(node, G_PRE_ORDER, G_TRAVERSE_ALL, item);
1399 node = node->children;
1401 if (in_sub && item->search_match){
1405 while (node != NULL) {
1406 if (node && node->data) {
1407 FolderItem *next_item = (FolderItem*) node->data;
1409 if (folderview_have_matching_children_sub(folderview,
1419 static gboolean folderview_have_matching_children(FolderView *folderview,
1422 return folderview_have_matching_children_sub(folderview, item, FALSE);
1425 static gboolean folderview_have_marked_children_sub(FolderView *folderview,
1431 if (!item || !item->folder || !item->folder->node)
1434 node = item->folder->node;
1436 node = g_node_find(node, G_PRE_ORDER, G_TRAVERSE_ALL, item);
1437 node = node->children;
1439 if (item->marked_msgs != 0) {
1443 while (node != NULL) {
1444 if (node && node->data) {
1445 FolderItem *next_item = (FolderItem*) node->data;
1447 if (folderview_have_marked_children_sub(folderview,
1456 static gboolean folderview_have_marked_children(FolderView *folderview,
1459 return folderview_have_marked_children_sub(folderview, item, FALSE);
1462 static void folderview_update_node(FolderView *folderview, GtkCTreeNode *node)
1464 GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1465 GtkStyle *style = NULL;
1466 GtkStyle *color_style = NULL;
1468 GdkPixmap *xpm, *openxpm;
1469 GdkBitmap *mask, *openmask;
1470 static GdkPixmap *searchicon;
1471 static GdkBitmap *searchmask;
1472 gboolean mark = FALSE;
1475 gboolean add_unread_mark;
1476 gboolean add_sub_match_mark;
1477 gboolean use_bold, use_color;
1478 gint *col_pos = folderview->col_pos;
1479 SpecialFolderItemType stype;
1481 item = gtk_ctree_node_get_row_data(ctree, node);
1482 g_return_if_fail(item != NULL);
1484 if (!GTK_CTREE_ROW(node)->expanded)
1485 mark = folderview_have_marked_children(folderview, item);
1487 mark = (item->marked_msgs != 0);
1489 stype = item->stype;
1490 if (stype == F_NORMAL) {
1491 if (folder_has_parent_of_type(item, F_TRASH))
1493 else if (folder_has_parent_of_type(item, F_DRAFT))
1495 else if (folder_has_parent_of_type(item, F_OUTBOX))
1497 else if (folder_has_parent_of_type(item, F_QUEUE))
1502 if (item->hide_read_msgs) {
1503 xpm = mark?m_inboxhrmxpm:inboxhrmxpm;
1504 mask = mark?m_inboxhrmxpmmask:inboxhrmxpmmask;
1505 openxpm = mark?m_inboxopenhrmxpm:inboxopenhrmxpm;
1506 openmask = mark?m_inboxopenhrmxpmmask:inboxopenhrmxpmmask;
1508 xpm = mark?m_inboxxpm:inboxxpm;
1509 mask = mark?m_inboxxpmmask:inboxxpmmask;
1510 openxpm = mark?m_inboxopenxpm:inboxopenxpm;
1511 openmask = mark?m_inboxopenxpmmask:inboxopenxpmmask;
1515 if (item->hide_read_msgs) {
1516 xpm = mark?m_outboxhrmxpm:outboxhrmxpm;
1517 mask = mark?m_outboxhrmxpmmask:outboxhrmxpmmask;
1518 openxpm = mark?m_outboxopenhrmxpm:outboxopenhrmxpm;
1519 openmask = mark?m_outboxopenhrmxpmmask:outboxopenhrmxpmmask;
1521 xpm = mark?m_outboxxpm:outboxxpm;
1522 mask = mark?m_outboxxpmmask:outboxxpmmask;
1523 openxpm = mark?m_outboxopenxpm:outboxopenxpm;
1524 openmask = mark?m_outboxopenxpmmask:outboxopenxpmmask;
1528 if (item->hide_read_msgs) {
1529 xpm = mark?m_queuehrmxpm:queuehrmxpm;
1530 mask = mark?m_queuehrmxpmmask:queuehrmxpmmask;
1531 openxpm = mark?m_queueopenhrmxpm:queueopenhrmxpm;
1532 openmask = mark?m_queueopenhrmxpmmask:queueopenhrmxpmmask;
1534 xpm = mark?m_queuexpm:queuexpm;
1535 mask = mark?m_queuexpmmask:queuexpmmask;
1536 openxpm = mark?m_queueopenxpm:queueopenxpm;
1537 openmask = mark?m_queueopenxpmmask:queueopenxpmmask;
1541 if (item->hide_read_msgs) {
1542 xpm = mark?m_trashhrmxpm:trashhrmxpm;
1543 mask = mark?m_trashhrmxpmmask:trashhrmxpmmask;
1544 openxpm = mark?m_trashopenhrmxpm:trashopenhrmxpm;
1545 openmask = mark?m_trashopenhrmxpmmask:trashopenhrmxpmmask;
1547 xpm = mark?m_trashxpm:trashxpm;
1548 mask = mark?m_trashxpmmask:trashxpmmask;
1549 openxpm = mark?m_trashopenxpm:trashopenxpm;
1550 openmask = mark?m_trashopenxpmmask:trashopenxpmmask;
1554 xpm = mark?m_draftsxpm:draftsxpm;
1555 mask = mark?m_draftsxpmmask:draftsxpmmask;
1556 openxpm = mark?m_draftsopenxpm:draftsopenxpm;
1557 openmask = mark?m_draftsopenxpmmask:draftsopenxpmmask;
1560 if (item->hide_read_msgs) {
1561 xpm = mark?m_folderhrmxpm:folderhrmxpm;
1562 mask = mark?m_folderhrmxpmmask:folderhrmxpmmask;
1563 openxpm = mark?m_folderopenhrmxpm:folderopenhrmxpm;
1564 openmask = mark?m_folderopenhrmxpmmask:folderopenhrmxpmmask;
1566 xpm = mark?m_folderxpm:folderxpm;
1567 mask = mark?m_folderxpmmask:folderxpmmask;
1568 openxpm = mark?m_folderopenxpm:folderopenxpm;
1569 openmask = mark?m_folderopenxpmmask:folderopenxpmmask;
1573 if (item->no_select) {
1574 xpm = openxpm = noselectxpm;
1575 mask = openmask = noselectxpmmask;
1578 name = folder_item_get_name(item);
1580 if (!GTK_CTREE_ROW(node)->expanded) {
1581 add_unread_mark = folderview_have_unread_children(
1583 add_sub_match_mark = folderview_have_matching_children(
1586 add_unread_mark = FALSE;
1587 add_sub_match_mark = FALSE;
1590 if (item->search_match) {
1592 stock_pixmap_gdk(folderview->ctree, STOCK_PIXMAP_QUICKSEARCH,
1593 &searchicon, &searchmask);
1595 xpm = openxpm = searchicon;
1596 mask = openmask = searchmask;
1600 if (prefs_common.display_folder_unread) {
1601 if (folder_has_parent_of_type(item, F_QUEUE)) {
1602 /* only total_msgs matters here */
1603 if (item->total_msgs > 0) {
1604 /* show total number (should be equal to the unread number)
1606 str = g_strdup_printf("%s (%d%s%s)",
1607 name, item->total_msgs,
1608 (add_unread_mark || add_sub_match_mark) ? "+" : "",
1609 (item->unreadmarked_msgs > 0) ? "!" : "");
1612 if (prefs_common.display_folder_unread == 1) {
1613 if (item->unread_msgs > 0) {
1614 /* show unread number and signs */
1615 str = g_strdup_printf("%s (%d%s%s)",
1616 name, item->unread_msgs,
1617 (add_unread_mark || add_sub_match_mark) ? "+" : "",
1618 (item->unreadmarked_msgs > 0) ? "!" : "");
1621 if (item->total_msgs > 0) {
1622 /* show unread number, total number and signs if any */
1623 str = g_strdup_printf("%s (%d/%d%s%s)",
1624 name, item->unread_msgs, item->total_msgs,
1625 (add_unread_mark || add_sub_match_mark) ? "+" : "",
1626 (item->unreadmarked_msgs > 0) ? "!" : "");
1630 if ((str == NULL) &&
1631 (add_unread_mark || add_sub_match_mark || (item->unreadmarked_msgs > 0))) {
1632 /* no unread/total numbers, but at least one sign */
1633 str = g_strdup_printf("%s (%s%s)",
1635 (add_unread_mark || add_sub_match_mark) ? "+" : "",
1636 (item->unreadmarked_msgs > 0) ? "!" : "");
1640 /* last fallback, folder name only or with ! sign */
1641 str = g_strdup_printf("%s%s",
1642 name, (item->unreadmarked_msgs > 0) ? " (!)" : "");
1644 gtk_sctree_set_node_info(ctree, node, str, FOLDER_SPACING,
1645 xpm, mask, openxpm, openmask,
1646 FALSE, GTK_CTREE_ROW(node)->expanded);
1650 if (!folder_item_parent(item)) {
1651 gtk_ctree_node_set_text(ctree, node, col_pos[F_COL_NEW], "-");
1652 gtk_ctree_node_set_text(ctree, node, col_pos[F_COL_UNREAD], "-");
1653 gtk_ctree_node_set_text(ctree, node, col_pos[F_COL_TOTAL], "-");
1655 gtk_ctree_node_set_text(ctree, node, col_pos[F_COL_NEW], item->new_msgs > 0 ? itos(item->new_msgs) : prefs_common.zero_replacement);
1656 gtk_ctree_node_set_text(ctree, node, col_pos[F_COL_UNREAD], item->unread_msgs > 0 ? itos(item->unread_msgs) : prefs_common.zero_replacement);
1657 gtk_ctree_node_set_text(ctree, node, col_pos[F_COL_TOTAL], item->total_msgs > 0 ? itos(item->total_msgs) : prefs_common.zero_replacement);
1660 if (folder_has_parent_of_type(item, F_OUTBOX) ||
1661 folder_has_parent_of_type(item, F_DRAFT) ||
1662 folder_has_parent_of_type(item, F_TRASH)) {
1663 use_bold = use_color = FALSE;
1664 } else if (folder_has_parent_of_type(item, F_QUEUE)) {
1665 /* highlight queue folder if there are any messages */
1666 use_bold = use_color = (item->total_msgs > 0);
1668 /* if unread messages exist, print with bold font */
1669 use_bold = (item->unread_msgs > 0|| item->new_msgs > 0)
1671 /* if new messages exist, print with colored letter */
1673 (item->new_msgs > 0) ||
1675 folderview_have_new_children(folderview, item));
1678 gtk_ctree_node_set_foreground(ctree, node, NULL);
1683 if (item->prefs->color > 0 && !use_color) {
1684 gtkut_convert_int_to_gdk_color(item->prefs->color, &gdk_color);
1685 color_style = gtk_style_copy(bold_style);
1686 color_style->fg[GTK_STATE_NORMAL] = gdk_color;
1687 style = color_style;
1688 } else if (use_color) {
1689 style = bold_color_style;
1692 if (item->op_count > 0) {
1693 style = bold_tgtfold_style;
1695 } else if (use_color) {
1696 style = normal_color_style;
1697 gtk_ctree_node_set_foreground(ctree, node,
1698 &folderview->color_new);
1699 } else if (item->op_count > 0) {
1700 style = bold_tgtfold_style;
1701 } else if (item->prefs->color > 0) {
1703 gtkut_convert_int_to_gdk_color(item->prefs->color, &gdk_color);
1704 color_style = gtk_style_copy(normal_style);
1705 color_style->fg[GTK_STATE_NORMAL] = gdk_color;
1706 style = color_style;
1708 style = normal_style;
1711 gtk_ctree_node_set_row_style(ctree, node, style);
1713 if ((node = gtkut_ctree_find_collapsed_parent(ctree, node)) != NULL)
1714 folderview_update_node(folderview, node);
1717 void folderview_update_search_icon(FolderItem *item, gboolean matches)
1720 FolderView *folderview;
1724 g_return_if_fail(item != NULL);
1726 for (list = folderview_list; list != NULL; list = list->next) {
1727 folderview = (FolderView *)list->data;
1728 ctree = GTK_CTREE(folderview->ctree);
1730 node = gtk_ctree_find_by_row_data(ctree, NULL, item);
1732 item->search_match = matches;
1733 folderview_update_node(folderview, node);
1738 static gboolean folderview_update_item_claws(gpointer source, gpointer data)
1740 FolderItemUpdateData *update_info = (FolderItemUpdateData *)source;
1741 FolderView *folderview = (FolderView *)data;
1744 g_return_val_if_fail(update_info != NULL, TRUE);
1745 g_return_val_if_fail(update_info->item != NULL, TRUE);
1746 g_return_val_if_fail(folderview != NULL, FALSE);
1748 ctree = GTK_CTREE(folderview->ctree);
1750 node = gtk_ctree_find_by_row_data(ctree, NULL, update_info->item);
1753 if (update_info->update_flags & (F_ITEM_UPDATE_MSGCNT | F_ITEM_UPDATE_NAME))
1754 folderview_update_node(folderview, node);
1756 if ((update_info->update_flags & F_ITEM_UPDATE_CONTENT) &&
1757 update_info->item == folderview->summaryview->folder_item &&
1758 update_info->item != NULL)
1759 if (!quicksearch_is_active(folderview->summaryview->quicksearch))
1760 summary_show(folderview->summaryview, update_info->item);
1766 static gboolean folderview_gnode_func(GtkCTree *ctree, guint depth,
1767 GNode *gnode, GtkCTreeNode *cnode,
1770 FolderView *folderview = (FolderView *)data;
1771 FolderItem *item = FOLDER_ITEM(gnode->data);
1773 g_return_val_if_fail(item != NULL, FALSE);
1775 gtk_ctree_node_set_row_data(ctree, cnode, item);
1776 folderview_update_node(folderview, cnode);
1781 static void folderview_expand_func(GtkCTree *ctree, GtkCTreeNode *node,
1784 FolderView *folderview = (FolderView *)data;
1787 if (GTK_CTREE_ROW(node)->children) {
1788 item = gtk_ctree_node_get_row_data(ctree, node);
1789 g_return_if_fail(item != NULL);
1791 if (!item->collapsed)
1792 gtk_ctree_expand(ctree, node);
1794 folderview_update_node(folderview, node);
1798 static void set_special_folder(GtkCTree *ctree, FolderItem *item,
1799 GtkCTreeNode *root, GtkCTreeNode **prev)
1802 GtkCTreeNode *node, *parent, *sibling;
1804 node = gtk_ctree_find_by_row_data(ctree, root, item);
1806 g_warning("%s not found.\n", item->path);
1808 parent = GTK_CTREE_ROW(node)->parent;
1809 if (*prev && parent == GTK_CTREE_ROW(*prev)->parent)
1810 sibling = GTK_CTREE_ROW(*prev)->sibling;
1812 sibling = GTK_CTREE_ROW(parent)->children;
1816 tmp = gtk_ctree_node_get_row_data
1818 if (tmp->stype != F_NORMAL)
1819 sibling = GTK_CTREE_ROW(sibling)->sibling;
1823 if (node != sibling)
1824 gtk_ctree_move(ctree, node, parent, sibling);
1831 static void folderview_sort_folders(FolderView *folderview, GtkCTreeNode *root,
1834 GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1835 GtkCTreeNode *prev = NULL;
1837 gtk_clist_freeze(GTK_CLIST(ctree));
1838 gtk_sctree_sort_recursive(ctree, root);
1839 if (root && GTK_CTREE_ROW(root)->parent) {
1840 gtk_clist_thaw(GTK_CLIST(ctree));
1843 set_special_folder(ctree, folder->inbox, root, &prev);
1844 set_special_folder(ctree, folder->outbox, root, &prev);
1845 set_special_folder(ctree, folder->draft, root, &prev);
1846 set_special_folder(ctree, folder->queue, root, &prev);
1847 set_special_folder(ctree, folder->trash, root, &prev);
1848 gtk_clist_thaw(GTK_CLIST(ctree));
1851 static void folderview_append_folder(FolderView *folderview, Folder *folder)
1853 GtkCTree *ctree = GTK_CTREE(folderview->ctree);
1856 g_return_if_fail(folder != NULL);
1858 root = gtk_sctree_insert_gnode(ctree, NULL, NULL, folder->node,
1859 folderview_gnode_func, folderview);
1860 gtk_ctree_pre_recursive(ctree, root, folderview_expand_func,
1862 folderview_sort_folders(folderview, root, folder);
1865 /* callback functions */
1866 static void folderview_set_sens_and_popup_menu(FolderView *folderview, gint row,
1867 GdkEventButton *event)
1869 GtkCList *clist = GTK_CLIST(folderview->ctree);
1872 FolderViewPopup *fpopup;
1873 GtkItemFactory *fpopup_factory;
1875 FolderItem *special_trash = NULL, *special_queue = NULL;
1879 item = gtk_clist_get_row_data(clist, row);
1881 item = folderview_get_selected_item(folderview);
1883 g_return_if_fail(item != NULL);
1884 g_return_if_fail(item->folder != NULL);
1885 folder = item->folder;
1887 fpopup = g_hash_table_lookup(folderview_popups, folder->klass->idstr);
1889 fpopup_factory = g_hash_table_lookup(folderview->popups, folder->klass->idstr);
1891 fpopup = g_hash_table_lookup(folderview_popups, "common");
1892 fpopup_factory = g_hash_table_lookup(folderview->popups, "common");
1895 if (fpopup->set_sensitivity != NULL)
1896 fpopup->set_sensitivity(fpopup_factory, item);
1898 if (NULL != (ac = account_find_from_item(item))) {
1899 special_trash = account_get_special_folder(ac, F_TRASH);
1900 special_queue = account_get_special_folder(ac, F_QUEUE);
1903 if ((item == folder->trash || item == special_trash
1904 || folder_has_parent_of_type(item, F_TRASH)) &&
1905 gtk_item_factory_get_item(fpopup_factory, "/Empty trash...") == NULL) {
1906 gtk_item_factory_create_item(fpopup_factory, &folder_view_trash_popup_entries[0], folderview, 1);
1907 gtk_item_factory_create_item(fpopup_factory, &folder_view_trash_popup_entries[1], folderview, 1);
1908 } else if (item != folder->trash && (special_trash == NULL || item != special_trash)
1909 && !folder_has_parent_of_type(item, F_TRASH)) {
1910 gtk_item_factory_delete_entry(fpopup_factory, &folder_view_trash_popup_entries[0]);
1911 gtk_item_factory_delete_entry(fpopup_factory, &folder_view_trash_popup_entries[1]);
1914 if ((item == folder->queue || item == special_queue
1915 || folder_has_parent_of_type(item, F_QUEUE)) &&
1916 gtk_item_factory_get_item(fpopup_factory, "/Send queue...") == NULL) {
1917 gtk_item_factory_create_item(fpopup_factory, &folder_view_queue_popup_entries[0], folderview, 1);
1918 gtk_item_factory_create_item(fpopup_factory, &folder_view_queue_popup_entries[1], folderview, 1);
1919 } else if (item != folder->queue && (special_queue == NULL || item != special_queue)
1920 && !folder_has_parent_of_type(item, F_QUEUE)) {
1921 gtk_item_factory_delete_entry(fpopup_factory, &folder_view_queue_popup_entries[0]);
1922 gtk_item_factory_delete_entry(fpopup_factory, &folder_view_queue_popup_entries[1]);
1925 #define SET_SENS(name, sens) \
1926 menu_set_sensitive(fpopup_factory, name, sens)
1928 SET_SENS("/Download messages", !item->no_select);
1929 SET_SENS("/Mark all read", item->unread_msgs >= 1);
1930 SET_SENS("/Search folder...", item->total_msgs >= 1 &&
1931 folderview->selected == folderview->opened);
1932 SET_SENS("/Run processing rules", item->prefs->processing &&
1933 item->total_msgs >= 1);
1934 SET_SENS("/Properties...", !item->no_select);
1935 SET_SENS("/Processing...", item->node->parent != NULL && !item->no_select);
1936 if (item == folder->trash || item == special_trash
1937 || folder_has_parent_of_type(item, F_TRASH)) {
1938 GSList *msglist = folder_item_get_msg_list(item);
1939 SET_SENS("/Empty trash...", msglist != NULL);
1940 procmsg_msg_list_free(msglist);
1942 if (item == folder->queue || item == special_queue
1943 || folder_has_parent_of_type(item, F_QUEUE)) {
1944 GSList *msglist = folder_item_get_msg_list(item);
1945 SET_SENS("/Send queue...", msglist != NULL);
1946 procmsg_msg_list_free(msglist);
1950 popup = gtk_item_factory_get_widget(fpopup_factory, fpopup->path);
1951 gtk_menu_popup(GTK_MENU(popup), NULL, NULL, NULL, NULL,
1952 event->button, event->time);
1957 static gboolean folderview_button_pressed(GtkWidget *ctree, GdkEventButton *event,
1958 FolderView *folderview)
1960 GtkCList *clist = GTK_CLIST(ctree);
1961 gint prev_row = -1, row = -1, column = -1;
1963 if (!event) return FALSE;
1965 if (event->button == 1 || event->button == 2) {
1966 if (!gtk_ctree_is_hot_spot (GTK_CTREE(clist), event->x, event->y))
1967 folderview->open_folder = TRUE;
1969 if (event->type == GDK_2BUTTON_PRESS) {
1970 if (clist->selection) {
1973 node = GTK_CTREE_NODE(clist->selection->data);
1975 gtk_ctree_toggle_expansion(
1978 folderview->open_folder = FALSE;
1985 if (event->button == 2 || event->button == 3) {
1987 if (clist->selection) {
1990 node = GTK_CTREE_NODE(clist->selection->data);
1992 prev_row = gtkut_ctree_get_nth_from_node
1993 (GTK_CTREE(ctree), node);
1996 if (!gtk_clist_get_selection_info(clist, event->x, event->y,
1999 if (prev_row != row) {
2000 gtk_clist_unselect_all(clist);
2001 if (event->button == 2)
2002 folderview_select_node
2004 gtk_ctree_node_nth(GTK_CTREE(ctree),
2007 gtk_clist_select_row(clist, row, column);
2011 if (event->button != 3) return FALSE;
2013 folderview_set_sens_and_popup_menu(folderview, row, event);
2017 static gboolean folderview_button_released(GtkWidget *ctree, GdkEventButton *event,
2018 FolderView *folderview)
2020 if (!event) return FALSE;
2022 if (event->button == 1 && folderview->open_folder == FALSE &&
2023 folderview->opened != NULL) {
2024 gtkut_ctree_set_focus_row(GTK_CTREE(ctree),
2025 folderview->opened);
2026 gtk_ctree_select(GTK_CTREE(ctree), folderview->opened);
2032 static gboolean folderview_key_pressed(GtkWidget *widget, GdkEventKey *event,
2033 FolderView *folderview)
2035 if (!event) return FALSE;
2037 if (quicksearch_has_focus(folderview->summaryview->quicksearch))
2040 switch (event->keyval) {
2046 if (folderview->selected) {
2047 folderview_select_node(folderview,
2048 folderview->selected);
2053 if (folderview->selected && GTK_CTREE_ROW(folderview->selected)->children) {
2054 gtk_ctree_toggle_expansion(
2055 GTK_CTREE(folderview->ctree),
2056 folderview->selected);
2061 if (folderview->selected) {
2062 if (folderview->opened == folderview->selected &&
2063 (!folderview->summaryview->folder_item ||
2064 folderview->summaryview->folder_item->total_msgs == 0))
2065 folderview_select_next_unread(folderview, TRUE);
2067 folderview_select_node(folderview,
2068 folderview->selected);
2078 typedef struct _PostponedSelectData
2083 FolderView *folderview;
2084 } PostponedSelectData;
2086 static gboolean postpone_select(void *data)
2088 PostponedSelectData *psdata = (PostponedSelectData *)data;
2089 debug_print("trying again\n");
2090 psdata->folderview->open_folder = TRUE;
2091 main_window_cursor_normal(psdata->folderview->mainwin);
2092 STATUSBAR_POP(psdata->folderview->mainwin);
2093 folderview_selected(psdata->ctree, psdata->row,
2094 psdata->column, psdata->folderview);
2099 void folderview_close_opened(FolderView *folderview)
2101 if (folderview->opened) {
2102 FolderItem *olditem;
2104 olditem = gtk_ctree_node_get_row_data(GTK_CTREE(folderview->ctree),
2105 folderview->opened);
2107 gchar *buf = g_strdup_printf(_("Closing Folder %s..."),
2108 olditem->path ? olditem->path:olditem->name);
2109 /* will be null if we just moved the previously opened folder */
2110 STATUSBAR_PUSH(folderview->mainwin, buf);
2111 main_window_cursor_wait(folderview->mainwin);
2113 summary_save_prefs_to_folderitem(folderview->summaryview, olditem);
2114 summary_show(folderview->summaryview, NULL);
2115 folder_item_close(olditem);
2116 main_window_cursor_normal(folderview->mainwin);
2117 STATUSBAR_POP(folderview->mainwin);
2121 if (folderview->opened &&
2122 !GTK_CTREE_ROW(folderview->opened)->children)
2123 gtk_ctree_collapse(GTK_CTREE(folderview->ctree), folderview->opened);
2125 folderview->opened = NULL;
2127 static void folderview_selected(GtkCTree *ctree, GtkCTreeNode *row,
2128 gint column, FolderView *folderview)
2130 static gboolean can_select = TRUE; /* exclusive lock */
2135 GtkCTreeNode *old_opened = folderview->opened;
2137 folderview->selected = row;
2139 debug_print("newly selected %p, opened %p\n", folderview->selected,
2140 folderview->opened);
2141 if (folderview->opened == row) {
2142 folderview->open_folder = FALSE;
2147 if (!can_select || summary_is_locked(folderview->summaryview)) {
2148 if (folderview->opened) {
2149 gtkut_ctree_set_focus_row(ctree, folderview->opened);
2150 gtk_ctree_select(ctree, folderview->opened);
2152 folderview->open_folder = FALSE;
2157 if (!folderview->open_folder) {
2161 item = gtk_ctree_node_get_row_data(ctree, row);
2164 folderview->open_folder = FALSE;
2170 /* Save cache for old folder */
2171 /* We don't want to lose all caches if sylpheed crashed */
2172 /* resets folderview->opened to NULL */
2173 folderview_close_opened(folderview);
2175 /* CLAWS: set compose button type: news folder items
2176 * always have a news folder as parent */
2178 toolbar_set_compose_button
2179 (folderview->mainwin->toolbar,
2180 FOLDER_TYPE(item->folder) == F_NEWS ?
2181 COMPOSEBUTTON_NEWS : COMPOSEBUTTON_MAIL);
2184 debug_print("Folder %s is selected\n", item->path);
2186 if (!GTK_CTREE_ROW(row)->children)
2187 gtk_ctree_expand(ctree, row);
2189 /* ungrab the mouse event */
2190 if (GTK_WIDGET_HAS_GRAB(ctree)) {
2191 gtk_grab_remove(GTK_WIDGET(ctree));
2192 if (gdk_pointer_is_grabbed())
2193 gdk_pointer_ungrab(GDK_CURRENT_TIME);
2197 /* TODO: wwp: avoid displaying (null) in the status bar */
2198 buf = g_strdup_printf(_("Opening Folder %s..."), item->path ?
2199 item->path : "(null)");
2200 debug_print("%s\n", buf);
2201 STATUSBAR_PUSH(folderview->mainwin, buf);
2204 main_window_cursor_wait(folderview->mainwin);
2206 res = folder_item_open(item);
2207 if (res == -1 && item->no_select == FALSE) {
2208 main_window_cursor_normal(folderview->mainwin);
2209 STATUSBAR_POP(folderview->mainwin);
2211 alertpanel_error(_("Folder could not be opened."));
2213 folderview->open_folder = FALSE;
2217 } else if (res == -2 && item->no_select == FALSE) {
2218 PostponedSelectData *data = g_new0(PostponedSelectData, 1);
2219 data->ctree = ctree;
2221 data->column = column;
2222 data->folderview = folderview;
2223 debug_print("postponing open of %s till end of scan\n",
2224 item->path ? item->path:item->name);
2225 folderview->open_folder = FALSE;
2227 g_timeout_add(500, postpone_select, data);
2232 main_window_cursor_normal(folderview->mainwin);
2235 summary_set_prefs_from_folderitem(folderview->summaryview, item);
2236 opened = summary_show(folderview->summaryview, item);
2238 folder_clean_cache_memory(item);
2241 gtkut_ctree_set_focus_row(ctree, old_opened);
2242 gtk_ctree_select(ctree, old_opened);
2243 folderview->opened = old_opened;
2245 folderview->opened = row;
2246 if (gtk_ctree_node_is_visible(ctree, row)
2247 != GTK_VISIBILITY_FULL)
2248 gtk_ctree_node_moveto(ctree, row, -1, 0.5, 0);
2251 STATUSBAR_POP(folderview->mainwin);
2253 folderview->open_folder = FALSE;
2258 static void folderview_tree_expanded(GtkCTree *ctree, GtkCTreeNode *node,
2259 FolderView *folderview)
2263 item = gtk_ctree_node_get_row_data(ctree, node);
2264 g_return_if_fail(item != NULL);
2265 item->collapsed = FALSE;
2266 folderview_update_node(folderview, node);
2269 static void folderview_tree_collapsed(GtkCTree *ctree, GtkCTreeNode *node,
2270 FolderView *folderview)
2274 item = gtk_ctree_node_get_row_data(ctree, node);
2275 g_return_if_fail(item != NULL);
2276 item->collapsed = TRUE;
2277 folderview_update_node(folderview, node);
2280 static void folderview_popup_close(GtkMenuShell *menu_shell,
2281 FolderView *folderview)
2283 if (!folderview->opened) return;
2285 gtk_ctree_select(GTK_CTREE(folderview->ctree), folderview->opened);
2288 static void folderview_col_resized(GtkCList *clist, gint column, gint width,
2289 FolderView *folderview)
2291 FolderColumnType type = folderview->col_state[column].type;
2293 prefs_common.folder_col_size[type] = width;
2296 static void folderview_create_folder_node_recursive(FolderView *folderview, FolderItem *item)
2300 folderview_create_folder_node(folderview, item);
2302 if (!item || !item->folder || !item->folder->node)
2305 srcnode = item->folder->node;
2306 srcnode = g_node_find(srcnode, G_PRE_ORDER, G_TRAVERSE_ALL, item);
2307 srcnode = srcnode->children;
2308 while (srcnode != NULL) {
2309 if (srcnode && srcnode->data) {
2310 FolderItem *next_item = (FolderItem*) srcnode->data;
2311 folderview_create_folder_node_recursive(folderview, next_item);
2313 srcnode = srcnode->next;
2317 static void folderview_create_folder_node(FolderView *folderview, FolderItem *item)
2319 GtkCTree *ctree = GTK_CTREE(folderview->ctree);
2320 gchar *text[N_FOLDER_COLS] = {NULL, "0", "0", "0"};
2321 GtkCTreeNode *node, *parent_node;
2322 gint *col_pos = folderview->col_pos;
2323 FolderItemUpdateData hookdata;
2325 parent_node = gtk_ctree_find_by_row_data(ctree, NULL, folder_item_parent(item));
2326 if (parent_node == NULL)
2329 gtk_clist_freeze(GTK_CLIST(ctree));
2331 text[col_pos[F_COL_FOLDER]] = item->name;
2332 node = gtk_sctree_insert_node(ctree, parent_node, NULL, text,
2334 folderxpm, folderxpmmask,
2335 folderopenxpm, folderopenxpmmask,
2337 gtk_ctree_expand(ctree, parent_node);
2338 gtk_ctree_node_set_row_data(ctree, node, item);
2340 gtk_ctree_node_set_row_style(ctree, node, normal_style);
2341 folderview_sort_folders(folderview, parent_node, item->folder);
2343 hookdata.item = item;
2344 hookdata.update_flags = F_ITEM_UPDATE_NAME;
2345 hookdata.msg = NULL;
2346 hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST, &hookdata);
2348 gtk_clist_thaw(GTK_CLIST(ctree));
2351 static void folderview_empty_trash_cb(FolderView *folderview, guint action,
2354 GtkCTree *ctree = GTK_CTREE(folderview->ctree);
2356 GSList *mlist = NULL;
2358 FolderItem *special_trash = NULL;
2361 if (!folderview->selected) return;
2362 item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
2363 g_return_if_fail(item != NULL);
2364 g_return_if_fail(item->folder != NULL);
2366 if (NULL != (ac = account_find_from_item(item)))
2367 special_trash = account_get_special_folder(ac, F_TRASH);
2369 if (item != item->folder->trash && item != special_trash
2370 && !folder_has_parent_of_type(item, F_TRASH)) return;
2372 if (prefs_common.ask_on_clean) {
2373 if (alertpanel(_("Empty trash"),
2374 _("Delete all messages in trash?"),
2375 GTK_STOCK_CANCEL, _("+_Empty trash"), NULL) != G_ALERTALTERNATE)
2379 mlist = folder_item_get_msg_list(item);
2381 for (cur = mlist ; cur != NULL ; cur = cur->next) {
2382 MsgInfo * msginfo = (MsgInfo *) cur->data;
2383 if (MSG_IS_LOCKED(msginfo->flags))
2385 /* is it partially received? (partial_recv isn't cached) */
2386 if (msginfo->total_size != 0 &&
2387 msginfo->size != (off_t)msginfo->total_size)
2388 partial_mark_for_delete(msginfo);
2390 procmsg_msg_list_free(mlist);
2392 folder_item_remove_all_msg(item);
2395 static void folderview_send_queue_cb(FolderView *folderview, guint action,
2398 GtkCTree *ctree = GTK_CTREE(folderview->ctree);
2400 FolderItem *special_queue = NULL;
2402 gchar *errstr = NULL;
2404 if (!folderview->selected) return;
2405 item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
2406 g_return_if_fail(item != NULL);
2407 g_return_if_fail(item->folder != NULL);
2409 if (NULL != (ac = account_find_from_item(item)))
2410 special_queue = account_get_special_folder(ac, F_QUEUE);
2412 if (item != item->folder->queue && item != special_queue
2413 && !folder_has_parent_of_type(item, F_QUEUE)) return;
2415 if (procmsg_queue_is_empty(item))
2418 if (prefs_common.work_offline)
2419 if (alertpanel(_("Offline warning"),
2420 _("You're working offline. Override?"),
2421 GTK_STOCK_NO, GTK_STOCK_YES,
2422 NULL) != G_ALERTALTERNATE)
2425 /* ask for confirmation before sending queued messages only
2426 in online mode and if there is at least one message queued
2427 in any of the folder queue
2429 if (prefs_common.confirm_send_queued_messages) {
2430 if (!prefs_common.work_offline) {
2431 if (alertpanel(_("Send queued messages"),
2432 _("Send all queued messages?"),
2433 GTK_STOCK_CANCEL, _("_Send"),
2434 NULL) != G_ALERTALTERNATE)
2439 if (procmsg_send_queue(item, prefs_common.savemsg, &errstr) < 0) {
2441 alertpanel_error_log(_("Some errors occurred while "
2442 "sending queued messages."));
2444 gchar *tmp = g_strdup_printf(_("Some errors occurred "
2445 "while sending queued messages:\n%s"), errstr);
2447 alertpanel_error_log(tmp);
2453 static void folderview_search_cb(FolderView *folderview, guint action,
2456 summary_search(folderview->summaryview);
2459 static void folderview_run_processing_cb(FolderView *folderview, guint action,
2462 GtkCTree *ctree = GTK_CTREE(folderview->ctree);
2465 if (!folderview->selected) return;
2467 item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
2468 g_return_if_fail(item != NULL);
2469 g_return_if_fail(item->folder != NULL);
2471 folder_item_apply_processing(item);
2474 static void folderview_property_cb(FolderView *folderview, guint action,
2477 GtkCTree *ctree = GTK_CTREE(folderview->ctree);
2480 if (!folderview->selected) return;
2482 item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
2483 g_return_if_fail(item != NULL);
2484 g_return_if_fail(item->folder != NULL);
2486 prefs_folder_item_open(item);
2489 static void folderview_recollapse_nodes(FolderView *folderview, GtkCTreeNode *node)
2491 GSList *list = NULL;
2492 GSList *done = NULL;
2493 GtkCTree *ctree = GTK_CTREE(folderview->ctree);
2495 for (list = folderview->nodes_to_recollapse; list != NULL; list = g_slist_next(list)) {
2496 if (!gtkut_ctree_node_is_parent(GTK_CTREE_NODE(list->data), node)
2497 && list->data != node) {
2498 gtk_ctree_collapse(ctree, GTK_CTREE_NODE(list->data));
2499 done = g_slist_append(done, GTK_CTREE_NODE(list->data));
2502 for (list = done; list != NULL; list = g_slist_next(list)) {
2503 folderview->nodes_to_recollapse = g_slist_remove(folderview->nodes_to_recollapse,
2509 void folderview_move_folder(FolderView *folderview, FolderItem *from_folder,
2510 FolderItem *to_folder, gboolean copy)
2512 FolderItem *from_parent = NULL;
2513 FolderItem *new_folder = NULL;
2514 GtkCTreeNode *src_node = NULL;
2518 g_return_if_fail(folderview != NULL);
2519 g_return_if_fail(from_folder != NULL);
2520 g_return_if_fail(to_folder != NULL);
2522 src_node = gtk_ctree_find_by_row_data(GTK_CTREE(folderview->ctree), NULL, from_folder);
2523 from_parent = folder_item_parent(from_folder);
2525 if (prefs_common.warn_dnd) {
2526 buf = g_strdup_printf(copy ? _("Do you really want to copy folder '%s' in '%s' ?"):
2527 _("Do you really want to make folder '%s' a subfolder of '%s' ?"),
2528 from_folder->name, to_folder->name);
2529 status = alertpanel_full(copy ? _("Copy folder"):_("Move folder"), buf,
2530 GTK_STOCK_NO, GTK_STOCK_YES, NULL, TRUE,
2531 NULL, ALERT_QUESTION, G_ALERTDEFAULT);
2534 if ((status & ~G_ALERTDISABLE) != G_ALERTALTERNATE)
2536 else if (status & G_ALERTDISABLE)
2537 prefs_common.warn_dnd = FALSE;
2540 buf = g_strdup_printf(copy ? _("Copying %s to %s..."):_("Moving %s to %s..."),
2541 from_folder->name, to_folder->name);
2542 STATUSBAR_PUSH(folderview->mainwin, buf);
2544 summary_clear_all(folderview->summaryview);
2545 folderview->opened = NULL;
2546 folderview->selected = NULL;
2547 gtk_widget_set_sensitive(GTK_WIDGET(folderview->ctree), FALSE);
2549 main_window_cursor_wait(folderview->mainwin);
2551 statusbar_verbosity_set(FALSE);
2552 folder_item_update_freeze();
2553 if ((status = folder_item_move_to(from_folder, to_folder, &new_folder, copy)) == F_MOVE_OK) {
2554 statusbar_verbosity_set(FALSE);
2555 main_window_cursor_normal(folderview->mainwin);
2556 STATUSBAR_POP(folderview->mainwin);
2557 folder_item_update_thaw();
2558 folder_item_update_recursive(new_folder, F_ITEM_UPDATE_MSGCNT);
2560 folderview_sort_folders(folderview,
2561 gtk_ctree_find_by_row_data(GTK_CTREE(folderview->ctree),
2562 NULL, to_folder), new_folder->folder);
2563 folderview_select(folderview, new_folder);
2565 statusbar_verbosity_set(FALSE);
2566 main_window_cursor_normal(folderview->mainwin);
2567 STATUSBAR_POP(folderview->mainwin);
2568 folder_item_update_thaw();
2570 case F_MOVE_FAILED_DEST_IS_PARENT:
2571 alertpanel_error(_("Source and destination are the same."));
2573 case F_MOVE_FAILED_DEST_IS_CHILD:
2574 alertpanel_error(copy ? _("Can't copy a folder to one of its children."):
2575 _("Can't move a folder to one of its children."));
2577 case F_MOVE_FAILED_DEST_OUTSIDE_MAILBOX:
2578 alertpanel_error(_("A folder cannot be moved between different mailboxes."));
2581 alertpanel_error(copy ? _("Copy failed!"):_("Move failed!"));
2586 gtk_widget_set_sensitive(GTK_WIDGET(folderview->ctree), TRUE);
2589 static gint folderview_clist_compare(GtkCList *clist,
2590 gconstpointer ptr1, gconstpointer ptr2)
2592 FolderItem *item1 = ((GtkCListRow *)ptr1)->data;
2593 FolderItem *item2 = ((GtkCListRow *)ptr2)->data;
2595 if (item1->order > 0 && item2->order > 0) // if we have an order item, use it
2597 return item1->order - item2->order;
2600 // if only one folder has an order it comes first
2601 if (item1->order > 0)
2605 if (item2->order > 0)
2611 return (item2->name != NULL);
2615 return g_utf8_collate(item1->name, item2->name);
2618 static void folderview_processing_cb(FolderView *folderview, guint action,
2621 GtkCTree *ctree = GTK_CTREE(folderview->ctree);
2625 if (!folderview->selected) return;
2627 item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
2628 g_return_if_fail(item != NULL);
2629 g_return_if_fail(item->folder != NULL);
2631 id = folder_item_get_identifier(item);
2632 title = g_strdup_printf (_("Processing configuration for folder %s"), id);
2635 prefs_filtering_open(&item->prefs->processing, title,
2636 MANUAL_ANCHOR_PROCESSING, NULL, NULL, FALSE);
2640 void folderview_set_target_folder_color(gint color_op)
2644 FolderView *folderview;
2646 for (list = folderview_list; list != NULL; list = list->next) {
2647 folderview = (FolderView *)list->data;
2648 gtkut_convert_int_to_gdk_color(color_op, &folderview->color_op);
2650 bold_tgtfold_style->fg[GTK_STATE_NORMAL] =
2651 folderview->color_op;
2657 static gchar *last_font = NULL;
2658 void folderview_reflect_prefs_pixmap_theme(FolderView *folderview)
2666 void folderview_reflect_prefs(void)
2668 gboolean update_font = TRUE;
2669 FolderView *folderview = mainwindow_get_mainwindow()->folderview;
2670 FolderItem *item = folderview_get_selected_item(folderview);
2671 GtkAdjustment *pos = gtk_scrolled_window_get_vadjustment(
2672 GTK_SCROLLED_WINDOW(folderview->scrolledwin));
2673 gint height = pos->value;
2675 if (last_font && !strcmp(last_font, NORMAL_FONT))
2676 update_font = FALSE;
2679 last_font = g_strdup(NORMAL_FONT);
2682 normal_style = normal_color_style = bold_style =
2683 bold_color_style = bold_tgtfold_style = NULL;
2685 folderview_init(folderview);
2687 gtk_clist_freeze(GTK_CLIST(folderview->ctree));
2688 folderview_column_set_titles(folderview);
2689 folderview_set_all();
2691 g_signal_handlers_block_by_func
2692 (G_OBJECT(folderview->ctree),
2693 G_CALLBACK(folderview_selected), folderview);
2696 GtkCTreeNode *node = gtk_ctree_find_by_row_data(
2697 GTK_CTREE(folderview->ctree), NULL, item);
2699 folderview_select(folderview, item);
2700 folderview->open_folder = FALSE;
2701 folderview->selected = node;
2704 g_signal_handlers_unblock_by_func
2705 (G_OBJECT(folderview->ctree),
2706 G_CALLBACK(folderview_selected), folderview);
2708 pos = gtk_scrolled_window_get_vadjustment(
2709 GTK_SCROLLED_WINDOW(folderview->scrolledwin));
2710 gtk_adjustment_set_value(pos, height);
2711 gtk_clist_thaw(GTK_CLIST(folderview->ctree));
2714 static void drag_state_stop(FolderView *folderview)
2716 if (folderview->drag_timer)
2717 g_source_remove(folderview->drag_timer);
2718 folderview->drag_timer = 0;
2719 folderview->drag_node = NULL;
2722 static gint folderview_defer_expand(FolderView *folderview)
2724 if (folderview->drag_node) {
2725 folderview_recollapse_nodes(folderview, folderview->drag_node);
2726 if (folderview->drag_item->collapsed) {
2727 gtk_ctree_expand(GTK_CTREE(folderview->ctree), folderview->drag_node);
2728 folderview->nodes_to_recollapse = g_slist_append
2729 (folderview->nodes_to_recollapse, folderview->drag_node);
2732 folderview->drag_item = NULL;
2733 folderview->drag_timer = 0;
2737 static void drag_state_start(FolderView *folderview, GtkCTreeNode *node, FolderItem *item)
2739 /* the idea is that we call drag_state_start() whenever we want expansion to
2740 * start after 'prefs_common.hover_time' msecs. if we want to cancel expansion,
2741 * we need to call drag_state_stop() */
2742 drag_state_stop(folderview);
2743 /* request expansion */
2744 if (0 != (folderview->drag_timer = g_timeout_add
2745 (prefs_common.hover_timeout,
2746 (GtkFunction)folderview_defer_expand,
2748 folderview->drag_node = node;
2749 folderview->drag_item = item;
2753 static void folderview_start_drag(GtkWidget *widget, gint button, GdkEvent *event,
2754 FolderView *folderview)
2756 GdkDragContext *context;
2758 g_return_if_fail(folderview != NULL);
2759 if (folderview->selected == NULL) return;
2760 if (folderview->nodes_to_recollapse)
2761 g_slist_free(folderview->nodes_to_recollapse);
2762 folderview->nodes_to_recollapse = NULL;
2763 context = gtk_drag_begin(widget, folderview->target_list,
2764 GDK_ACTION_MOVE|GDK_ACTION_COPY|GDK_ACTION_DEFAULT, button, event);
2765 gtk_drag_set_icon_default(context);
2768 static void folderview_drag_data_get(GtkWidget *widget,
2769 GdkDragContext *drag_context,
2770 GtkSelectionData *selection_data,
2773 FolderView *folderview)
2777 gchar *source = NULL;
2778 if (info == TARGET_DUMMY) {
2779 for (cur = GTK_CLIST(folderview->ctree)->selection;
2780 cur != NULL; cur = cur->next) {
2781 item = gtk_ctree_node_get_row_data
2782 (GTK_CTREE(folderview->ctree),
2783 GTK_CTREE_NODE(cur->data));
2785 source = g_strdup_printf ("FROM_OTHER_FOLDER%s", folder_item_get_identifier(item));
2786 gtk_selection_data_set(selection_data,
2787 selection_data->target, 8,
2788 source, strlen(source));
2794 g_warning("unknown info %d\n", info);
2798 static gboolean folderview_update_folder(gpointer source, gpointer userdata)
2800 FolderUpdateData *hookdata;
2801 FolderView *folderview;
2805 folderview = (FolderView *) userdata;
2806 g_return_val_if_fail(hookdata != NULL, FALSE);
2807 g_return_val_if_fail(folderview != NULL, FALSE);
2809 ctree = folderview->ctree;
2810 g_return_val_if_fail(ctree != NULL, FALSE);
2812 if (hookdata->update_flags & FOLDER_ADD_FOLDERITEM)
2813 folderview_create_folder_node(folderview, hookdata->item);
2814 else if (hookdata->update_flags & FOLDER_RENAME_FOLDERITEM) {
2815 GtkCTreeNode *node = gtk_ctree_find_by_row_data(GTK_CTREE(ctree),
2816 NULL, folder_item_parent(hookdata->item));
2817 folderview_sort_folders(folderview, node, hookdata->folder);
2818 } else if (hookdata->update_flags & FOLDER_REMOVE_FOLDERITEM) {
2821 node = gtk_ctree_find_by_row_data(GTK_CTREE(ctree), NULL, hookdata->item);
2823 gtk_ctree_remove_node(GTK_CTREE(ctree), node);
2824 if (folderview->selected == node)
2825 folderview->selected = NULL;
2826 if (folderview->opened == node)
2827 folderview->opened = NULL;
2829 } else if (hookdata->update_flags & (FOLDER_TREE_CHANGED | FOLDER_ADD_FOLDER | FOLDER_REMOVE_FOLDER))
2830 folderview_set(folderview);
2835 static gboolean folderview_drag_motion_cb(GtkWidget *widget,
2836 GdkDragContext *context,
2840 FolderView *folderview)
2843 FolderItem *item = NULL, *src_item = NULL;
2844 GtkCTreeNode *node = NULL;
2845 gboolean acceptable = FALSE;
2846 GtkAdjustment *pos = gtk_scrolled_window_get_vadjustment(
2847 GTK_SCROLLED_WINDOW(folderview->scrolledwin));
2848 int height = (int)pos->page_size;
2849 int total_height = (int)pos->upper;
2850 int vpos = (int) pos->value;
2852 if (gtk_clist_get_selection_info
2853 (GTK_CLIST(widget), x - 24, y - 24, &row, &column)) {
2854 GtkWidget *srcwidget;
2856 if (y > height - 24 && height + vpos < total_height)
2857 gtk_adjustment_set_value(pos, (vpos+5 > height ? height : vpos+5));
2859 if (y < 48 && y > 0)
2860 gtk_adjustment_set_value(pos, (vpos-5 < 0 ? 0 : vpos-5));
2862 node = gtk_ctree_node_nth(GTK_CTREE(widget), row);
2863 item = gtk_ctree_node_get_row_data(GTK_CTREE(widget), node);
2864 src_item = folderview->summaryview->folder_item;
2866 srcwidget = gtk_drag_get_source_widget(context);
2867 if (srcwidget == summary_get_main_widget(folderview->summaryview)) {
2868 /* comes from summaryview */
2869 /* we are copying messages, so only accept folder items that are not
2870 the source item, are no root items and can copy messages */
2871 if (item && item->folder && folder_item_parent(item) != NULL && src_item &&
2872 src_item != item && FOLDER_CLASS(item->folder)->copy_msg != NULL &&
2873 FOLDER_TYPE(item->folder) != F_UNKNOWN)
2875 } else if (srcwidget == folderview->ctree) {
2876 /* comes from folderview */
2877 /* we are moving folder items, only accept folders that are not
2878 the source items and can copy messages and create folder items */
2879 if (item && item->folder && src_item && src_item != item &&
2880 FOLDER_CLASS(item->folder)->copy_msg != NULL &&
2881 FOLDER_CLASS(item->folder)->create_folder != NULL &&
2882 ((FOLDER_TYPE(item->folder) != F_UNKNOWN && FOLDER_TYPE(src_item->folder) != F_UNKNOWN)
2883 || item->folder == src_item->folder))
2886 /* comes from another app */
2887 /* we are adding messages, so only accept folder items that are
2888 no root items and can copy messages */
2889 if (item && item->folder && folder_item_parent(item) != NULL
2890 && FOLDER_CLASS(item->folder)->add_msg != NULL &&
2891 FOLDER_TYPE(item->folder) != F_UNKNOWN)
2896 if (acceptable || (src_item && src_item == item))
2897 drag_state_start(folderview, node, item);
2900 g_signal_handlers_block_by_func
2902 G_CALLBACK(folderview_selected), folderview);
2903 gtk_ctree_select(GTK_CTREE(widget), node);
2904 g_signal_handlers_unblock_by_func
2906 G_CALLBACK(folderview_selected), folderview);
2907 gdk_drag_status(context,
2908 (context->actions == GDK_ACTION_COPY ?
2909 GDK_ACTION_COPY : GDK_ACTION_MOVE) , time);
2911 if (folderview->opened)
2912 gtk_ctree_select(GTK_CTREE(widget), folderview->opened);
2913 gdk_drag_status(context, 0, time);
2919 static void folderview_drag_leave_cb(GtkWidget *widget,
2920 GdkDragContext *context,
2922 FolderView *folderview)
2924 drag_state_stop(folderview);
2925 gtk_ctree_select(GTK_CTREE(widget), folderview->opened);
2928 static void free_info (gpointer stuff, gpointer data)
2933 void folderview_finish_dnd(const gchar *data, GdkDragContext *drag_context,
2934 guint time, FolderItem *item)
2937 GSList *msglist = NULL;
2938 list = uri_list_extract_filenames(data);
2939 if (!(item && item->folder && folder_item_parent(item) != NULL
2940 && FOLDER_CLASS(item->folder)->add_msg != NULL))
2942 gtk_drag_finish(drag_context, FALSE, FALSE, time);
2943 debug_print("item doesn't fit\n");
2947 gtk_drag_finish(drag_context, FALSE, FALSE, time);
2948 debug_print("list is empty\n");
2951 for (tmp = list; tmp != NULL; tmp = tmp->next) {
2952 MsgFileInfo *info = NULL;
2954 if (file_is_email((gchar *)tmp->data)) {
2955 info = g_new0(MsgFileInfo, 1);
2956 info->msginfo = NULL;
2957 info->file = (gchar *)tmp->data;
2958 msglist = g_slist_prepend(msglist, info);
2959 debug_print("file is a mail\n");
2961 debug_print("file isn't a mail\n");
2965 msglist = g_slist_reverse(msglist);
2966 folder_item_add_msgs(item, msglist, FALSE);
2967 g_slist_foreach(msglist, free_info, NULL);
2968 g_slist_free(msglist);
2969 gtk_drag_finish(drag_context, TRUE, FALSE, time);
2971 gtk_drag_finish(drag_context, FALSE, FALSE, time);
2973 list_free_strings(list);
2977 static void folderview_drag_received_cb(GtkWidget *widget,
2978 GdkDragContext *drag_context,
2981 GtkSelectionData *data,
2984 FolderView *folderview)
2987 FolderItem *item = NULL, *src_item;
2990 if (info == TARGET_DUMMY) {
2991 drag_state_stop(folderview);
2992 if ((void *)strstr(data->data, "FROM_OTHER_FOLDER") != (void *)data->data) {
2993 /* comes from summaryview */
2994 if (gtk_clist_get_selection_info
2995 (GTK_CLIST(widget), x - 24, y - 24, &row, &column) == 0)
2998 node = gtk_ctree_node_nth(GTK_CTREE(widget), row);
2999 item = gtk_ctree_node_get_row_data(GTK_CTREE(widget), node);
3000 src_item = folderview->summaryview->folder_item;
3002 if (item->no_select) {
3003 alertpanel_error(_("The destination folder can only be used to "
3004 "store subfolders."));
3007 /* re-check (due to acceptable possibly set for folder moves */
3008 if (!(item && item->folder && item->path && !item->no_select &&
3009 src_item && src_item != item && FOLDER_CLASS(item->folder)->copy_msg != NULL)) {
3012 if (item && src_item) {
3013 switch (drag_context->action) {
3014 case GDK_ACTION_COPY:
3015 summary_copy_selected_to(folderview->summaryview, item);
3016 gtk_drag_finish(drag_context, TRUE, FALSE, time);
3018 case GDK_ACTION_MOVE:
3019 case GDK_ACTION_DEFAULT:
3021 if (FOLDER_CLASS(src_item->folder)->remove_msg == NULL)
3022 summary_copy_selected_to(folderview->summaryview, item);
3024 summary_move_selected_to(folderview->summaryview, item);
3025 gtk_drag_finish(drag_context, TRUE, TRUE, time);
3028 gtk_drag_finish(drag_context, FALSE, FALSE, time);
3030 /* comes from folderview */
3032 gboolean folder_is_normal = TRUE;
3033 gboolean copy = (drag_context->action == GDK_ACTION_COPY);
3035 source = data->data + 17;
3036 if (gtk_clist_get_selection_info
3037 (GTK_CLIST(widget), x - 24, y - 24, &row, &column) == 0
3039 gtk_drag_finish(drag_context, FALSE, FALSE, time);
3042 node = gtk_ctree_node_nth(GTK_CTREE(widget), row);
3043 item = gtk_ctree_node_get_row_data(GTK_CTREE(widget), node);
3044 src_item = folder_find_item_from_identifier(source);
3048 src_item->stype == F_NORMAL &&
3049 !folder_has_parent_of_type(src_item, F_OUTBOX) &&
3050 !folder_has_parent_of_type(src_item, F_DRAFT) &&
3051 !folder_has_parent_of_type(src_item, F_QUEUE) &&
3052 !folder_has_parent_of_type(src_item, F_TRASH);
3053 if (!item || !src_item || !folder_is_normal) {
3054 gtk_drag_finish(drag_context, FALSE, FALSE, time);
3058 folderview_move_folder(folderview, src_item, item, copy);
3059 gtk_drag_finish(drag_context, TRUE, TRUE, time);
3061 folderview->nodes_to_recollapse = NULL;
3062 } else if (info == TARGET_MAIL_URI_LIST) {
3063 if (gtk_clist_get_selection_info
3064 (GTK_CLIST(widget), x - 24, y - 24, &row, &column) == 0)
3067 node = gtk_ctree_node_nth(GTK_CTREE(widget), row);
3069 gtk_drag_finish(drag_context, FALSE, FALSE, time);
3070 debug_print("no node\n");
3073 item = gtk_ctree_node_get_row_data(GTK_CTREE(widget), node);
3075 gtk_drag_finish(drag_context, FALSE, FALSE, time);
3076 debug_print("no item\n");
3079 folderview_finish_dnd(data->data, drag_context, time, item);
3083 static void folderview_drag_end_cb(GtkWidget *widget,
3084 GdkDragContext *drag_context,
3085 FolderView *folderview)
3087 drag_state_stop(folderview);
3088 g_slist_free(folderview->nodes_to_recollapse);
3089 folderview->nodes_to_recollapse = NULL;
3092 void folderview_register_popup(FolderViewPopup *fpopup)
3096 for (folderviews = folderview_list; folderviews != NULL; folderviews = g_list_next(folderviews)) {
3097 FolderView *folderview = folderviews->data;
3098 GtkItemFactory *factory;
3100 factory = create_ifactory(folderview, fpopup);
3101 g_hash_table_insert(folderview->popups, fpopup->klass, factory);
3103 g_hash_table_insert(folderview_popups, fpopup->klass, fpopup);
3106 void folderview_unregister_popup(FolderViewPopup *fpopup)
3110 for (folderviews = folderview_list; folderviews != NULL; folderviews = g_list_next(folderviews)) {
3111 FolderView *folderview = folderviews->data;
3113 g_hash_table_remove(folderview->popups, fpopup->klass);
3115 g_hash_table_remove(folderview_popups, fpopup->klass);