/*
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
- * Copyright (C) 1999-2006 Hiroyuki Yamamoto and the Sylpheed-Claws team
+ * Copyright (C) 1999-2007 Hiroyuki Yamamoto and the Claws Mail team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
*/
#include "defs.h"
#include "partial_download.h"
#include "prefs_folder_column.h"
#include "filtering.h"
+#include "quicksearch.h"
+#include "manual.h"
+#include "timing.h"
+#include "log.h"
#define COL_FOLDER_WIDTH 150
#define COL_NUM_WIDTH 32
static GdkPixmap *readxpm;
static GdkBitmap *readxpmmask;
-
static void folderview_select_node (FolderView *folderview,
GtkCTreeNode *node);
static void folderview_set_folders (FolderView *folderview);
guint action,
GtkWidget *widget);
+static void folderview_send_queue_cb (FolderView *folderview,
+ guint action,
+ GtkWidget *widget);
+
static void folderview_search_cb (FolderView *folderview,
guint action,
GtkWidget *widget);
+static void folderview_run_processing_cb(FolderView *folderview,
+ guint action,
+ GtkWidget *widget);
static void folderview_property_cb (FolderView *folderview,
guint action,
GdkDragContext *drag_context,
FolderView *folderview);
-void folderview_create_folder_node (FolderView *folderview,
+static void folderview_create_folder_node (FolderView *folderview,
FolderItem *item);
-gboolean folderview_update_folder (gpointer source,
+static gboolean folderview_update_folder (gpointer source,
gpointer userdata);
-gboolean folderview_update_item_claws (gpointer source,
+static gboolean folderview_update_item_claws (gpointer source,
gpointer data);
static void folderview_processing_cb(FolderView *folderview, guint action,
GtkWidget *widget);
+static void folderview_set_sens_and_popup_menu(FolderView *folderview, gint row,
+ GdkEventButton *event);
GHashTable *folderview_popups;
static GtkItemFactoryEntry folderview_common_popup_entries[] =
{
{N_("/Mark all re_ad"), NULL, mark_all_read_cb, 0, NULL},
+ {"/---", NULL, NULL, 0, "<Separator>"},
+ {N_("/Run processing rules"), NULL, folderview_run_processing_cb, 0, NULL},
{N_("/_Search folder..."), NULL, folderview_search_cb, 0, NULL},
{N_("/_Properties..."), NULL, folderview_property_cb, 0, NULL},
{N_("/Process_ing..."), NULL, folderview_processing_cb, 0, NULL},
};
static GtkItemFactoryEntry folder_view_trash_popup_entries[] = {
- {N_("/------"), NULL, NULL, 0, "<Separator>"},
+ {"/------trashsep", NULL, NULL, 0, "<Separator>"},
{N_("/Empty _trash..."), NULL, folderview_empty_trash_cb, 0, NULL},
};
+static GtkItemFactoryEntry folder_view_queue_popup_entries[] = {
+ {"/------queuesep", NULL, NULL, 0, "<Separator>"},
+ {N_("/Send _queue..."), NULL, folderview_send_queue_cb, 0, NULL},
+};
+
GtkTargetEntry folderview_drag_types[] =
{
- {"sylpheed-claws/internal", GTK_TARGET_SAME_APP, TARGET_DUMMY},
+ {"claws-mail/internal", GTK_TARGET_SAME_APP, TARGET_DUMMY},
{"text/uri-list", 0, TARGET_MAIL_URI_LIST}
};
static void folderview_column_set_titles(FolderView *folderview)
{
GtkWidget *ctree = folderview->ctree;
+ GtkWidget *label_folder;
GtkWidget *label_new;
GtkWidget *label_unread;
GtkWidget *label_total;
+ GtkWidget *hbox_folder;
GtkWidget *hbox_new;
GtkWidget *hbox_unread;
GtkWidget *hbox_total;
gint *col_pos = folderview->col_pos;
-
+
debug_print("setting titles...\n");
gtk_widget_realize(folderview->ctree);
gtk_widget_show_all(folderview->scrolledwin);
&unreadxpm, &unreadxpmmask);
stock_pixmap_gdk(ctree, STOCK_PIXMAP_READ,
&readxpm, &readxpmmask);
-
- label_new = gtk_pixmap_new(newxpm, newxpmmask);
- label_unread = gtk_pixmap_new(unreadxpm, unreadxpmmask);
- label_total = gtk_pixmap_new(readxpm, readxpmmask);
-
+
+ label_folder = gtk_label_new(_("Folder"));
+ label_new = gtk_image_new_from_pixmap(newxpm, newxpmmask);
+ label_unread = gtk_image_new_from_pixmap(unreadxpm, unreadxpmmask);
+ label_total = gtk_image_new_from_pixmap(readxpm, readxpmmask);
+
+ gtk_clist_column_titles_active(GTK_CLIST(ctree));
+
+ hbox_folder = gtk_hbox_new(FALSE, 4);
hbox_new = gtk_hbox_new(FALSE, 4);
hbox_unread = gtk_hbox_new(FALSE, 4);
hbox_total = gtk_hbox_new(FALSE, 4);
/* left justified */
+ gtk_box_pack_start(GTK_BOX(hbox_folder), label_folder, TRUE, TRUE, 0);
+ gtk_misc_set_alignment (GTK_MISC (label_folder), 0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox_new), label_new, TRUE, TRUE, 0);
gtk_misc_set_alignment (GTK_MISC (label_new), 1, 0.5);
gtk_box_pack_start(GTK_BOX(hbox_unread), label_unread, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox_total), label_total, TRUE, TRUE, 0);
gtk_misc_set_alignment (GTK_MISC (label_total), 1, 0.5);
+ gtk_widget_show_all(hbox_folder);
gtk_widget_show_all(hbox_new);
gtk_widget_show_all(hbox_unread);
gtk_widget_show_all(hbox_total);
+#ifdef MAEMO
+ gtk_widget_set_size_request(hbox_new, -1, 20);
+ gtk_widget_set_size_request(hbox_unread, -1, 20);
+ gtk_widget_set_size_request(hbox_total, -1, 20);
+#endif
+
+ gtk_clist_set_column_widget(GTK_CLIST(ctree),col_pos[F_COL_FOLDER],hbox_folder);
gtk_clist_set_column_widget(GTK_CLIST(ctree),col_pos[F_COL_NEW],hbox_new);
gtk_clist_set_column_widget(GTK_CLIST(ctree),col_pos[F_COL_UNREAD],hbox_unread);
gtk_clist_set_column_widget(GTK_CLIST(ctree),col_pos[F_COL_TOTAL],hbox_total);
+
+#ifdef MAEMO
+ GTK_EVENTS_FLUSH();
+#endif
+
+ gtk_sctree_set_column_tooltip(GTK_SCTREE(ctree), col_pos[F_COL_NEW], _("New"));
+ gtk_sctree_set_column_tooltip(GTK_SCTREE(ctree), col_pos[F_COL_UNREAD], _("Unread"));
+ gtk_sctree_set_column_tooltip(GTK_SCTREE(ctree), col_pos[F_COL_TOTAL], _("Total"));
}
-GtkWidget *folderview_ctree_create(FolderView *folderview)
+static gboolean folderview_popup_menu(GtkWidget *widget, gpointer data)
+{
+ FolderView *folderview = (FolderView *)data;
+ GdkEventButton event;
+ if (folderview_get_selected_item(folderview) == NULL)
+ return FALSE;
+
+ event.button = 3;
+ event.time = gtk_get_current_event_time();
+
+ folderview_set_sens_and_popup_menu(folderview, -1,
+ &event);
+
+ return TRUE;
+}
+
+
+static GtkWidget *folderview_ctree_create(FolderView *folderview)
{
GtkWidget *ctree;
gint *col_pos;
titles[col_pos[F_COL_FOLDER]] = _("Folder");
titles[col_pos[F_COL_NEW]] = _("New");
titles[col_pos[F_COL_UNREAD]] = _("Unread");
+ /* TRANSLATORS: This in Number sign in American style */
titles[col_pos[F_COL_TOTAL]] = _("#");
ctree = gtk_sctree_new_with_titles(N_FOLDER_COLS, col_pos[F_COL_FOLDER],
titles);
-
+
+ if (prefs_common.show_col_headers == FALSE)
+ gtk_clist_column_titles_hide(GTK_CLIST(ctree));
+
+
gtk_clist_set_selection_mode(GTK_CLIST(ctree), GTK_SELECTION_BROWSE);
gtk_clist_set_column_justification(GTK_CLIST(ctree), col_pos[F_COL_NEW],
GTK_JUSTIFY_RIGHT);
gtk_clist_set_column_justification(GTK_CLIST(ctree),
col_pos[F_COL_TOTAL],
GTK_JUSTIFY_RIGHT);
- gtk_ctree_set_line_style(GTK_CTREE(ctree), GTK_CTREE_LINES_DOTTED);
- gtk_ctree_set_expander_style(GTK_CTREE(ctree),
+ if (prefs_common.enable_dotted_lines) {
+ gtk_ctree_set_line_style(GTK_CTREE(ctree), GTK_CTREE_LINES_DOTTED);
+ gtk_ctree_set_expander_style(GTK_CTREE(ctree),
GTK_CTREE_EXPANDER_SQUARE);
+ } else {
+ gtk_ctree_set_line_style(GTK_CTREE(ctree), GTK_CTREE_LINES_NONE);
+ gtk_ctree_set_expander_style(GTK_CTREE(ctree),
+ GTK_CTREE_EXPANDER_TRIANGLE);
+ }
+
+ gtk_sctree_set_stripes(GTK_SCTREE(ctree), prefs_common.use_stripes_in_summaries);
+ gtk_sctree_set_recursive_expand(GTK_SCTREE(ctree), FALSE);
+
gtk_ctree_set_indent(GTK_CTREE(ctree), CTREE_INDENT);
gtk_clist_set_compare_func(GTK_CLIST(ctree), folderview_clist_compare);
g_signal_connect(G_OBJECT(ctree), "button_press_event",
G_CALLBACK(folderview_button_pressed),
folderview);
+#ifndef MAEMO
+ g_signal_connect(G_OBJECT(ctree), "popup-menu",
+ G_CALLBACK(folderview_popup_menu), folderview);
+#else
+ gtk_widget_tap_and_hold_setup(GTK_WIDGET(ctree), NULL, NULL,
+ GTK_TAP_AND_HOLD_NONE | GTK_TAP_AND_HOLD_NO_INTERNALS);
+ g_signal_connect(G_OBJECT(ctree), "tap-and-hold",
+ G_CALLBACK(folderview_popup_menu), folderview);
+#endif
g_signal_connect(G_OBJECT(ctree), "button_release_event",
G_CALLBACK(folderview_button_released),
folderview);
g_signal_connect(G_OBJECT(ctree), "tree_select_row",
G_CALLBACK(folderview_selected), folderview);
+#ifndef MAEMO
+ /* drag-n-dropping folders on maemo is impractical as this
+ * opens the folder almost everytime */
g_signal_connect(G_OBJECT(ctree), "start_drag",
G_CALLBACK(folderview_start_drag), folderview);
+#endif
g_signal_connect(G_OBJECT(ctree), "drag_data_get",
G_CALLBACK(folderview_drag_data_get),
folderview);
folderview->target_list = gtk_target_list_new(folderview_drag_types, 2);
folderview_list = g_list_append(folderview_list, folderview);
+ folderview->deferred_refresh_id = -1;
return folderview;
}
}
}
+static gboolean folderview_defer_set(gpointer data)
+{
+ FolderView *folderview = (FolderView *)data;
+ MainWindow *mainwin = folderview->mainwin;
+
+ if (!mainwin)
+ return FALSE;
+ if (mainwin->lock_count)
+ return TRUE;
+
+ printf("doing deferred folderview_set now\n");
+ folderview_set(folderview);
+
+ folderview->deferred_refresh_id = -1;
+ return FALSE;
+}
+
void folderview_set(FolderView *folderview)
{
GtkCTree *ctree = GTK_CTREE(folderview->ctree);
MainWindow *mainwin = folderview->mainwin;
+ FolderItem *sel_item = NULL, *op_item = NULL;
if (!mainwin)
return;
+ if (mainwin->lock_count) {
+ if (folderview->deferred_refresh_id == -1)
+ folderview->deferred_refresh_id =
+ g_timeout_add(500, folderview_defer_set, folderview);
+ printf("deferred folderview_set\n");
+ return;
+ }
+
+ inc_lock();
debug_print("Setting folder info...\n");
STATUSBAR_PUSH(mainwin, _("Setting folder info..."));
main_window_cursor_wait(mainwin);
+ if (folderview->selected)
+ sel_item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
+ if (folderview->opened)
+ op_item = gtk_ctree_node_get_row_data(ctree, folderview->opened);
+
folderview->selected = NULL;
folderview->opened = NULL;
gtk_clist_freeze(GTK_CLIST(ctree));
gtk_clist_clear(GTK_CLIST(ctree));
- gtk_clist_thaw(GTK_CLIST(ctree));
- gtk_clist_freeze(GTK_CLIST(ctree));
folderview_set_folders(folderview);
+ if (sel_item)
+ folderview->selected = gtk_ctree_find_by_row_data(ctree, NULL, sel_item);
+ if (op_item)
+ folderview->opened = gtk_ctree_find_by_row_data(ctree, NULL, op_item);
+
gtk_clist_thaw(GTK_CLIST(ctree));
main_window_cursor_normal(mainwin);
STATUSBAR_POP(mainwin);
+ inc_unlock();
}
void folderview_set_all(void)
if (item == NULL)
return;
- if (prefs_common.ask_mark_all_read) {
+ if (folderview->summaryview->folder_item != item
+ && prefs_common.ask_mark_all_read) {
val = alertpanel_full(_("Mark all as read"),
_("Do you really want to mark all mails in this "
"folder as read ?"), GTK_STOCK_NO, GTK_STOCK_YES, NULL,
- TRUE, NULL, ALERT_QUESTION, G_ALERTALTERNATE);
+ TRUE, NULL, ALERT_QUESTION, G_ALERTDEFAULT);
- if (val == G_ALERTDEFAULT ||
- val == (G_ALERTDEFAULT|G_ALERTDISABLE))
+ if ((val & ~G_ALERTDISABLE) != G_ALERTALTERNATE)
return;
- else if (val == (G_ALERTALTERNATE|G_ALERTDISABLE))
+ else if (val & G_ALERTDISABLE)
prefs_common.ask_mark_all_read = FALSE;
}
-
+
summary_lock(folderview->summaryview);
folder_item_update_freeze();
if (folderview->summaryview->folder_item == item)
- gtk_clist_freeze(GTK_CLIST(folderview->summaryview->ctree));
+ summary_freeze(folderview->summaryview);
folderutils_mark_all_read(item);
if (folderview->summaryview->folder_item == item)
- gtk_clist_thaw(GTK_CLIST(folderview->summaryview->ctree));
+ summary_thaw(folderview->summaryview);
folder_item_update_thaw();
summary_unlock(folderview->summaryview);
}
g_return_if_fail(node != NULL);
+ if (folderview->open_folder) {
+ return;
+ }
+
folderview->open_folder = TRUE;
gtkut_ctree_set_focus_row(ctree, node);
gtk_ctree_select(ctree, node);
if (folderview->summaryview->folder_item &&
folderview->summaryview->folder_item->total_msgs > 0)
- gtk_widget_grab_focus(folderview->summaryview->ctree);
+ summary_grab_focus(folderview->summaryview);
else
gtk_widget_grab_focus(folderview->ctree);
folderview->selected = folderview->opened = NULL;
}
+static GtkCTreeNode *folderview_find_next_marked(GtkCTree *ctree,
+ GtkCTreeNode *node)
+{
+ FolderItem *item;
+
+ if (node)
+ node = gtkut_ctree_node_next(ctree, node);
+ else
+ node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list);
+
+ for (; node != NULL; node = gtkut_ctree_node_next(ctree, node)) {
+ item = gtk_ctree_node_get_row_data(ctree, node);
+ if (item && item->marked_msgs > 0 && item->stype != F_TRASH)
+ return node;
+ }
+
+ return NULL;
+}
+
+void folderview_select_next_marked(FolderView *folderview)
+{
+ GtkCTree *ctree = GTK_CTREE(folderview->ctree);
+ GtkCTreeNode *node = NULL;
+ EntryAction last_summary_select_prio = prefs_common.summary_select_prio[0];
+ gboolean last_open = prefs_common.always_show_msg;
+
+ prefs_common.summary_select_prio[0] = ACTION_MARKED;
+ prefs_common.always_show_msg = TRUE;
+
+ if ((node = folderview_find_next_marked(ctree, folderview->opened))
+ != NULL) {
+ folderview_select_node(folderview, node);
+ goto out;
+ }
+
+ if (!folderview->opened ||
+ folderview->opened == GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list)) {
+ goto out;
+ }
+ /* search again from the first node */
+ if ((node = folderview_find_next_marked(ctree, NULL)) != NULL)
+ folderview_select_node(folderview, node);
+
+out:
+ prefs_common.summary_select_prio[0] = last_summary_select_prio;
+ prefs_common.always_show_msg = last_open;
+}
+
static GtkCTreeNode *folderview_find_next_unread(GtkCTree *ctree,
GtkCTreeNode *node)
{
return NULL;
}
-void folderview_select_next_unread(FolderView *folderview)
+void folderview_select_next_unread(FolderView *folderview, gboolean force_open)
{
GtkCTree *ctree = GTK_CTREE(folderview->ctree);
GtkCTreeNode *node = NULL;
+ EntryAction last_summary_select_prio = prefs_common.summary_select_prio[0];
+ gboolean last_open = prefs_common.always_show_msg;
+
+ prefs_common.summary_select_prio[0] = ACTION_UNREAD;
+ prefs_common.always_show_msg = force_open ? TRUE : last_open;
if ((node = folderview_find_next_unread(ctree, folderview->opened))
!= NULL) {
folderview_select_node(folderview, node);
- return;
+ goto out;
}
if (!folderview->opened ||
- folderview->opened == GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list))
- return;
+ folderview->opened == GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list)) {
+ goto out;
+ }
/* search again from the first node */
if ((node = folderview_find_next_unread(ctree, NULL)) != NULL)
folderview_select_node(folderview, node);
+
+out:
+ prefs_common.summary_select_prio[0] = last_summary_select_prio;
+ prefs_common.always_show_msg = last_open;
}
static GtkCTreeNode *folderview_find_next_new(GtkCTree *ctree,
{
GtkCTree *ctree = GTK_CTREE(folderview->ctree);
GtkCTreeNode *node = NULL;
+ EntryAction last_summary_select_prio = prefs_common.summary_select_prio[0];
+ gboolean last_open = prefs_common.always_show_msg;
+
+ prefs_common.summary_select_prio[0] = ACTION_NEW;
+ prefs_common.always_show_msg = TRUE;
if ((node = folderview_find_next_new(ctree, folderview->opened))
!= NULL) {
folderview_select_node(folderview, node);
- return;
+ goto out;
}
if (!folderview->opened ||
- folderview->opened == GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list))
- return;
+ folderview->opened == GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list)) {
+ goto out;
+ }
/* search again from the first node */
if ((node = folderview_find_next_new(ctree, NULL)) != NULL)
folderview_select_node(folderview, node);
+
+out:
+ prefs_common.summary_select_prio[0] = last_summary_select_prio;
+ prefs_common.always_show_msg = last_open;
}
FolderItem *folderview_get_selected_item(FolderView *folderview)
return gtk_ctree_node_get_row_data(ctree, folderview->selected);
}
-void folderview_update_msg_num(FolderView *folderview, GtkCTreeNode *row)
-{
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
- static GtkCTreeNode *prev_row = NULL;
- FolderItem *item;
- gint new, unread, total;
- gchar *new_str, *unread_str, *total_str;
- gint *col_pos = folderview->col_pos;
-
- if (!row) return;
-
- item = gtk_ctree_node_get_row_data(ctree, row);
- if (!item) return;
-
- gtk_ctree_node_get_text(ctree, row, col_pos[F_COL_NEW], &new_str);
- gtk_ctree_node_get_text(ctree, row, col_pos[F_COL_UNREAD], &unread_str);
- gtk_ctree_node_get_text(ctree, row, col_pos[F_COL_TOTAL], &total_str);
- new = atoi(new_str);
- unread = atoi(unread_str);
- total = atoi(total_str);
-
- prev_row = row;
-
- folderview_update_node(folderview, row);
-}
-
-void folderview_append_item(FolderItem *item)
-{
- GList *list;
-
- g_return_if_fail(item != NULL);
- g_return_if_fail(item->folder != NULL);
- if (folder_item_parent(item)) return;
-
- for (list = folderview_list; list != NULL; list = list->next) {
- FolderView *folderview = (FolderView *)list->data;
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
- GtkCTreeNode *node, *child;
- gint *col_pos = folderview->col_pos;
-
- node = gtk_ctree_find_by_row_data(ctree, NULL,
- folder_item_parent(item));
- if (node) {
- child = gtk_ctree_find_by_row_data(ctree, node, item);
- if (!child) {
- gchar *text[N_FOLDER_COLS] =
- {NULL, "0", "0", "0"};
-
- gtk_clist_freeze(GTK_CLIST(ctree));
-
- text[col_pos[F_COL_FOLDER]] = item->name;
- child = gtk_sctree_insert_node
- (ctree, node, NULL, text,
- FOLDER_SPACING,
- folderxpm, folderxpmmask,
- folderopenxpm, folderopenxpmmask,
- FALSE, FALSE);
- gtk_ctree_node_set_row_data(ctree, child, item);
- gtk_ctree_expand(ctree, node);
- folderview_update_node(folderview, child);
- folderview_sort_folders(folderview, node,
- item->folder);
-
- gtk_clist_thaw(GTK_CLIST(ctree));
- }
- }
- }
-}
-
static void folderview_set_folders(FolderView *folderview)
{
GList *list;
-
list = folder_get_list();
- for (; list != NULL; list = list->next)
+ for (; list != NULL; list = list->next) {
folderview_append_folder(folderview, FOLDER(list->data));
+ }
}
+static gchar *get_scan_str(FolderItem *item)
+{
+ if (item->path)
+ return g_strdup_printf(_("Scanning folder %s%c%s ..."),
+ item->folder->name, G_DIR_SEPARATOR,
+ item->path);
+ else
+ return g_strdup_printf(_("Scanning folder %s ..."),
+ item->folder->name);
+}
static void folderview_scan_tree_func(Folder *folder, FolderItem *item,
gpointer data)
{
GList *list;
-
for (list = folderview_list; list != NULL; list = list->next) {
FolderView *folderview = (FolderView *)list->data;
MainWindow *mainwin = folderview->mainwin;
- gchar *str;
-
- if (item->path)
- str = g_strdup_printf(_("Scanning folder %s%c%s ..."),
- item->folder->name, G_DIR_SEPARATOR,
- item->path);
- else
- str = g_strdup_printf(_("Scanning folder %s ..."),
- item->folder->name);
+ gchar *str = get_scan_str(item);
STATUSBAR_PUSH(mainwin, str);
STATUSBAR_POP(mainwin);
void folderview_rescan_tree(Folder *folder, gboolean rebuild)
{
GtkWidget *window;
+ MainWindow *mainwin = mainwindow_get_mainwindow();
+ FolderView *folderview = NULL;
+ GtkAdjustment *pos = NULL;
+ gint height = 0;
g_return_if_fail(folder != NULL);
else
window = label_window_create(_("Scanning folder tree..."));
+ if (mainwin)
+ folderview = mainwin->folderview;
+
+ if (folderview) {
+ pos = gtk_scrolled_window_get_vadjustment(
+ GTK_SCROLLED_WINDOW(folderview->scrolledwin));
+ height = pos->value;
+ }
+
folder_set_ui_func(folder, folderview_scan_tree_func, NULL);
folder_scan_tree(folder, rebuild);
folder_set_ui_func(folder, NULL, NULL);
folderview_set_all();
- gtk_widget_destroy(window);
+ if (folderview) {
+ pos = gtk_scrolled_window_get_vadjustment(
+ GTK_SCROLLED_WINDOW(folderview->scrolledwin));
+ gtk_adjustment_set_value(pos, height);
+ }
+ label_window_destroy(window);
+ inc_unlock();
+}
+
+void folderview_fast_rescan_tree(Folder *folder)
+{
+ GtkWidget *window;
+ MainWindow *mainwin = mainwindow_get_mainwindow();
+ FolderView *folderview = NULL;
+ GtkAdjustment *pos = NULL;
+ gint height = 0;
+
+ g_return_if_fail(folder != NULL);
+
+ if (!folder->klass->scan_tree) return;
+
+ inc_lock();
+
+ window = label_window_create(_("Scanning folder tree..."));
+
+ if (mainwin)
+ folderview = mainwin->folderview;
+
+ if (folderview) {
+ pos = gtk_scrolled_window_get_vadjustment(
+ GTK_SCROLLED_WINDOW(folderview->scrolledwin));
+ height = pos->value;
+ }
+
+ folder_set_ui_func(folder, folderview_scan_tree_func, NULL);
+ folder_fast_scan_tree(folder);
+ folder_set_ui_func(folder, NULL, NULL);
+
+ folderview_set_all();
+
+ if (folderview) {
+ pos = gtk_scrolled_window_get_vadjustment(
+ GTK_SCROLLED_WINDOW(folderview->scrolledwin));
+ gtk_adjustment_set_value(pos, height);
+ }
+ label_window_destroy(window);
inc_unlock();
}
for (node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list);
node != NULL; node = gtkut_ctree_node_next(ctree, node)) {
+ gchar *str = NULL;
item = gtk_ctree_node_get_row_data(ctree, node);
if (!item || !item->path || !item->folder) continue;
if (item->no_select) continue;
if (folder && folder != item->folder) continue;
if (!folder && !FOLDER_IS_LOCAL(item->folder)) continue;
if (!item->prefs->newmailcheck) continue;
+ if (item->processing_pending == TRUE) {
+ debug_print("skipping %s, processing pending\n",
+ item->path ? item->path : item->name);
+ continue;
+ }
+
+ str = get_scan_str(item);
+
+ STATUSBAR_PUSH(folderview->mainwin, str);
+ GTK_EVENTS_FLUSH();
+ g_free(str);
folderview_scan_tree_func(item->folder, item, NULL);
former_new = item->new_msgs;
former_unread = item->unread_msgs;
former_total = item->total_msgs;
- if (folder_item_scan(item) < 0) {
- summaryview_unlock(folderview->summaryview, item);
- if (folder && !FOLDER_IS_LOCAL(folder))
- break;
+ if (item->folder->klass->scan_required &&
+ (item->folder->klass->scan_required(item->folder, item) ||
+ item->folder->inbox == item ||
+ item->opened == TRUE ||
+ item->processing_pending == TRUE)) {
+ if (folder_item_scan(item) < 0) {
+ if (folder) {
+ summaryview_unlock(folderview->summaryview, item);
+ if (FOLDER_TYPE(item->folder) == F_NEWS || FOLDER_IS_LOCAL(folder)) {
+ log_error(LOG_PROTOCOL, _("Couldn't scan folder %s\n"),
+ item->path ? item->path:item->name);
+ STATUSBAR_POP(folderview->mainwin);
+ continue;
+ } else if (!FOLDER_IS_LOCAL(folder)) {
+ STATUSBAR_POP(folderview->mainwin);
+ break;
+ }
+ }
+ }
+ } else if (!item->folder->klass->scan_required) {
+ if (folder_item_scan(item) < 0) {
+ summaryview_unlock(folderview->summaryview, item);
+ if (folder && !FOLDER_IS_LOCAL(folder)) {
+ STATUSBAR_POP(folderview->mainwin);
+ break;
+ }
+ }
}
-
if (former_new != item->new_msgs ||
former_unread != item->unread_msgs ||
former_total != item->total_msgs)
new_msgs += item->new_msgs;
former_new_msgs += former_new;
+ STATUSBAR_POP(folderview->mainwin);
}
main_window_unlock(folderview->mainwin);
folder_write_list();
folderview_set_all();
- gtk_widget_destroy(window);
+ label_window_destroy(window);
main_window_unlock(folderview->mainwin);
inc_unlock();
}
mask = openmask = searchmask;
}
- if (folder_has_parent_of_type(item, F_QUEUE) && item->total_msgs > 0 &&
- prefs_common.display_folder_unread) {
- str = g_strdup_printf("%s (%d%s)", name, item->total_msgs,
- add_unread_mark ? "+" : "");
- gtk_sctree_set_node_info(ctree, node, str, FOLDER_SPACING,
- xpm, mask, openxpm, openmask,
- FALSE, GTK_CTREE_ROW(node)->expanded);
- g_free(str);
- } else if (((item->unread_msgs > 0 || add_unread_mark) &&
- prefs_common.display_folder_unread)
- || add_sub_match_mark) {
-
- if (item->unread_msgs > 0)
- str = g_strdup_printf("%s (%d%s%s)", name, item->unread_msgs,
- add_unread_mark || add_sub_match_mark ? "+" : "",
- item->unreadmarked_msgs > 0 ? "!":"");
- else
- str = g_strdup_printf("%s (+)", name);
- gtk_sctree_set_node_info(ctree, node, str, FOLDER_SPACING,
- xpm, mask, openxpm, openmask,
- FALSE, GTK_CTREE_ROW(node)->expanded);
- g_free(str);
+ str = NULL;
+ if (prefs_common.display_folder_unread) {
+ if (folder_has_parent_of_type(item, F_QUEUE)) {
+ /* only total_msgs matters here */
+ if (item->total_msgs > 0) {
+ /* show total number (should be equal to the unread number)
+ and signs if any */
+ str = g_strdup_printf("%s (%d%s%s)",
+ name, item->total_msgs,
+ (add_unread_mark || add_sub_match_mark) ? "+" : "",
+ (item->unreadmarked_msgs > 0) ? "!" : "");
+ }
} else {
- str = g_strdup_printf("%s%s", name,
- item->unreadmarked_msgs > 0 ? " (!)":"");
-
+ if (prefs_common.display_folder_unread == 1) {
+ if (item->unread_msgs > 0) {
+ /* show unread number and signs */
+ str = g_strdup_printf("%s (%d%s%s)",
+ name, item->unread_msgs,
+ (add_unread_mark || add_sub_match_mark) ? "+" : "",
+ (item->unreadmarked_msgs > 0) ? "!" : "");
+ }
+ } else {
+ if (item->total_msgs > 0) {
+ /* show unread number, total number and signs if any */
+ str = g_strdup_printf("%s (%d/%d%s%s)",
+ name, item->unread_msgs, item->total_msgs,
+ (add_unread_mark || add_sub_match_mark) ? "+" : "",
+ (item->unreadmarked_msgs > 0) ? "!" : "");
+ }
+ }
+ }
+ if ((str == NULL) &&
+ (add_unread_mark || add_sub_match_mark || (item->unreadmarked_msgs > 0))) {
+ /* no unread/total numbers, but at least one sign */
+ str = g_strdup_printf("%s (%s%s)",
+ name,
+ (add_unread_mark || add_sub_match_mark) ? "+" : "",
+ (item->unreadmarked_msgs > 0) ? "!" : "");
+ }
+ }
+ if (str == NULL) {
+ /* last fallback, folder name only or with ! sign */
+ str = g_strdup_printf("%s%s",
+ name, (item->unreadmarked_msgs > 0) ? " (!)" : "");
+ }
gtk_sctree_set_node_info(ctree, node, str, FOLDER_SPACING,
xpm, mask, openxpm, openmask,
FALSE, GTK_CTREE_ROW(node)->expanded);
g_free(str);
- }
g_free(name);
if (!folder_item_parent(item)) {
gtk_ctree_node_set_text(ctree, node, col_pos[F_COL_UNREAD], "-");
gtk_ctree_node_set_text(ctree, node, col_pos[F_COL_TOTAL], "-");
} else {
- gtk_ctree_node_set_text(ctree, node, col_pos[F_COL_NEW], itos(item->new_msgs));
- gtk_ctree_node_set_text(ctree, node, col_pos[F_COL_UNREAD], itos(item->unread_msgs));
- gtk_ctree_node_set_text(ctree, node, col_pos[F_COL_TOTAL], itos(item->total_msgs));
+ gtk_ctree_node_set_text(ctree, node, col_pos[F_COL_NEW], item->new_msgs > 0 ? itos(item->new_msgs) : prefs_common.zero_replacement);
+ gtk_ctree_node_set_text(ctree, node, col_pos[F_COL_UNREAD], item->unread_msgs > 0 ? itos(item->unread_msgs) : prefs_common.zero_replacement);
+ gtk_ctree_node_set_text(ctree, node, col_pos[F_COL_TOTAL], item->total_msgs > 0 ? itos(item->total_msgs) : prefs_common.zero_replacement);
}
if (folder_has_parent_of_type(item, F_OUTBOX) ||
color_style->fg[GTK_STATE_NORMAL] = gdk_color;
style = color_style;
} else if (use_color) {
- gtkut_convert_int_to_gdk_color(prefs_common.color_new, &gdk_color);
- bold_color_style = gtk_style_copy(bold_style);
- bold_color_style->fg[GTK_STATE_NORMAL] = gdk_color;
style = bold_color_style;
} else
style = bold_style;
style = bold_tgtfold_style;
}
} else if (use_color) {
- GdkColor gdk_color;
-
- gtkut_convert_int_to_gdk_color(prefs_common.color_new, &gdk_color);
- style = gtk_style_copy(normal_color_style);
- style->fg[GTK_STATE_NORMAL] = gdk_color;
+ style = normal_color_style;
gtk_ctree_node_set_foreground(ctree, node,
&folderview->color_new);
} else if (item->op_count > 0) {
folderview_update_node(folderview, node);
}
-#if !CLAWS /* keep it here for syncs */
-void folderview_update_item(FolderItem *item, gboolean update_summary)
-{
- GList *list;
- FolderView *folderview;
- GtkCTree *ctree;
- GtkCTreeNode *node;
-
- g_return_if_fail(item != NULL);
-
- for (list = folderview_list; list != NULL; list = list->next) {
- folderview = (FolderView *)list->data;
- ctree = GTK_CTREE(folderview->ctree);
-
- node = gtk_ctree_find_by_row_data(ctree, NULL, item);
- if (node) {
- folderview_update_node(folderview, node);
- if (update_summary && folderview->opened == node)
- summary_show(folderview->summaryview,
- item, FALSE);
- }
- }
-}
-#endif
-
void folderview_update_search_icon(FolderItem *item, gboolean matches)
{
GList *list;
}
}
-gboolean folderview_update_item_claws(gpointer source, gpointer data)
+static gboolean folderview_update_item_claws(gpointer source, gpointer data)
{
FolderItemUpdateData *update_info = (FolderItemUpdateData *)source;
FolderView *folderview = (FolderView *)data;
ctree = GTK_CTREE(folderview->ctree);
node = gtk_ctree_find_by_row_data(ctree, NULL, update_info->item);
+
if (node) {
if (update_info->update_flags & (F_ITEM_UPDATE_MSGCNT | F_ITEM_UPDATE_NAME))
folderview_update_node(folderview, node);
- if ((update_info->update_flags & F_ITEM_UPDATE_CONTENT) && (folderview->opened == node))
- summary_show(folderview->summaryview, update_info->item);
+
+ if ((update_info->update_flags & F_ITEM_UPDATE_CONTENT) &&
+ update_info->item == folderview->summaryview->folder_item &&
+ update_info->item != NULL)
+ if (!quicksearch_is_active(folderview->summaryview->quicksearch))
+ summary_show(folderview->summaryview, update_info->item);
}
return FALSE;
}
-static void folderview_update_item_foreach_func(gpointer key, gpointer val,
- gpointer data)
-{
- /* CLAWS: share this joy with other hook functions ... */
- folder_item_update((FolderItem *)key,
- (FolderItemUpdateFlags)GPOINTER_TO_INT(data));
-}
-
-void folderview_update_item_foreach(GHashTable *table, gboolean update_summary)
-{
- GList *list;
- FolderItemUpdateFlags flags;
-
- flags = update_summary ? F_ITEM_UPDATE_CONTENT | F_ITEM_UPDATE_MSGCNT
- : 0;
- for (list = folderview_list; list != NULL; list = list->next)
- g_hash_table_foreach(table, folderview_update_item_foreach_func,
- GINT_TO_POINTER(flags));
-}
-
static gboolean folderview_gnode_func(GtkCTree *ctree, guint depth,
GNode *gnode, GtkCTreeNode *cnode,
gpointer data)
GtkCTree *ctree = GTK_CTREE(folderview->ctree);
GtkCTreeNode *prev = NULL;
+ gtk_clist_freeze(GTK_CLIST(ctree));
gtk_sctree_sort_recursive(ctree, root);
-
- if (root && GTK_CTREE_ROW(root)->parent) return;
-
+ if (root && GTK_CTREE_ROW(root)->parent) {
+ gtk_clist_thaw(GTK_CLIST(ctree));
+ return;
+ }
set_special_folder(ctree, folder->inbox, root, &prev);
set_special_folder(ctree, folder->outbox, root, &prev);
set_special_folder(ctree, folder->draft, root, &prev);
set_special_folder(ctree, folder->queue, root, &prev);
set_special_folder(ctree, folder->trash, root, &prev);
+ gtk_clist_thaw(GTK_CLIST(ctree));
}
static void folderview_append_folder(FolderView *folderview, Folder *folder)
g_return_if_fail(folder != NULL);
- root = gtk_ctree_insert_gnode(ctree, NULL, NULL, folder->node,
+ root = gtk_sctree_insert_gnode(ctree, NULL, NULL, folder->node,
folderview_gnode_func, folderview);
gtk_ctree_pre_recursive(ctree, root, folderview_expand_func,
folderview);
}
/* callback functions */
-
-static gboolean folderview_button_pressed(GtkWidget *ctree, GdkEventButton *event,
- FolderView *folderview)
+static void folderview_set_sens_and_popup_menu(FolderView *folderview, gint row,
+ GdkEventButton *event)
{
- GtkCList *clist = GTK_CLIST(ctree);
- gint prev_row = -1, row = -1, column = -1;
+ GtkCList *clist = GTK_CLIST(folderview->ctree);
FolderItem *item;
Folder *folder;
FolderViewPopup *fpopup;
GtkItemFactory *fpopup_factory;
GtkWidget *popup;
- FolderItem *special_trash = NULL;
+ FolderItem *special_trash = NULL, *special_queue = NULL;
PrefsAccount *ac;
- if (!event) return FALSE;
-
- if (event->button == 1 || event->button == 2) {
- folderview->open_folder = TRUE;
-
- if (event->type == GDK_2BUTTON_PRESS) {
- if (clist->selection) {
- GtkCTreeNode *node;
-
- node = GTK_CTREE_NODE(clist->selection->data);
- if (node)
- gtk_ctree_toggle_expansion(
- GTK_CTREE(ctree),
- node);
- }
- }
- return FALSE;
- }
-
- if (event->button == 2 || event->button == 3) {
- /* right clicked */
- if (clist->selection) {
- GtkCTreeNode *node;
-
- node = GTK_CTREE_NODE(clist->selection->data);
- if (node)
- prev_row = gtkut_ctree_get_nth_from_node
- (GTK_CTREE(ctree), node);
- }
-
- if (!gtk_clist_get_selection_info(clist, event->x, event->y,
- &row, &column))
- return FALSE;
- if (prev_row != row) {
- gtk_clist_unselect_all(clist);
- if (event->button == 2)
- folderview_select_node
- (folderview,
- gtk_ctree_node_nth(GTK_CTREE(ctree),
- row));
- else
- gtk_clist_select_row(clist, row, column);
- }
- }
-
- if (event->button != 3) return FALSE;
+ if (row > 0)
+ item = gtk_clist_get_row_data(clist, row);
+ else
+ item = folderview_get_selected_item(folderview);
- item = gtk_clist_get_row_data(clist, row);
- g_return_val_if_fail(item != NULL, FALSE);
- g_return_val_if_fail(item->folder != NULL, FALSE);
+ g_return_if_fail(item != NULL);
+ g_return_if_fail(item->folder != NULL);
folder = item->folder;
fpopup = g_hash_table_lookup(folderview_popups, folder->klass->idstr);
if (fpopup->set_sensitivity != NULL)
fpopup->set_sensitivity(fpopup_factory, item);
- if (NULL != (ac = account_find_from_item(item)))
+ if (NULL != (ac = account_find_from_item(item))) {
special_trash = account_get_special_folder(ac, F_TRASH);
-
+ special_queue = account_get_special_folder(ac, F_QUEUE);
+ }
+
if ((item == folder->trash || item == special_trash
|| folder_has_parent_of_type(item, F_TRASH)) &&
gtk_item_factory_get_item(fpopup_factory, "/Empty trash...") == NULL) {
gtk_item_factory_delete_entry(fpopup_factory, &folder_view_trash_popup_entries[1]);
}
+ if ((item == folder->queue || item == special_queue
+ || folder_has_parent_of_type(item, F_QUEUE)) &&
+ gtk_item_factory_get_item(fpopup_factory, "/Send queue...") == NULL) {
+ gtk_item_factory_create_item(fpopup_factory, &folder_view_queue_popup_entries[0], folderview, 1);
+ gtk_item_factory_create_item(fpopup_factory, &folder_view_queue_popup_entries[1], folderview, 1);
+ } else if (item != folder->queue && (special_queue == NULL || item != special_queue)
+ && !folder_has_parent_of_type(item, F_QUEUE)) {
+ gtk_item_factory_delete_entry(fpopup_factory, &folder_view_queue_popup_entries[0]);
+ gtk_item_factory_delete_entry(fpopup_factory, &folder_view_queue_popup_entries[1]);
+ }
+
#define SET_SENS(name, sens) \
menu_set_sensitive(fpopup_factory, name, sens)
SET_SENS("/Mark all read", item->unread_msgs >= 1);
SET_SENS("/Search folder...", item->total_msgs >= 1 &&
folderview->selected == folderview->opened);
- SET_SENS("/Properties...", item->node->parent != NULL);
+ SET_SENS("/Run processing rules", item->prefs->processing &&
+ item->total_msgs >= 1);
+ SET_SENS("/Properties...", TRUE);
SET_SENS("/Processing...", item->node->parent != NULL);
if (item == folder->trash || item == special_trash
|| folder_has_parent_of_type(item, F_TRASH)) {
SET_SENS("/Empty trash...", msglist != NULL);
procmsg_msg_list_free(msglist);
}
+ if (item == folder->queue || item == special_queue
+ || folder_has_parent_of_type(item, F_QUEUE)) {
+ GSList *msglist = folder_item_get_msg_list(item);
+ SET_SENS("/Send queue...", msglist != NULL);
+ procmsg_msg_list_free(msglist);
+ }
#undef SET_SENS
popup = gtk_item_factory_get_widget(fpopup_factory, fpopup->path);
gtk_menu_popup(GTK_MENU(popup), NULL, NULL, NULL, NULL,
event->button, event->time);
+
+}
+
+static gboolean folderview_button_pressed(GtkWidget *ctree, GdkEventButton *event,
+ FolderView *folderview)
+{
+ GtkCList *clist = GTK_CLIST(ctree);
+ gint prev_row = -1, row = -1, column = -1;
+
+ if (!event) return FALSE;
+
+ if (event->button == 1 || event->button == 2) {
+ if (!gtk_ctree_is_hot_spot (GTK_CTREE(clist), event->x, event->y))
+ folderview->open_folder = TRUE;
+
+ if (event->type == GDK_2BUTTON_PRESS) {
+ if (clist->selection) {
+ GtkCTreeNode *node;
+
+ node = GTK_CTREE_NODE(clist->selection->data);
+ if (node) {
+ gtk_ctree_toggle_expansion(
+ GTK_CTREE(ctree),
+ node);
+ folderview->open_folder = FALSE;
+ }
+ }
+ }
+ return FALSE;
+ }
+
+ if (event->button == 2 || event->button == 3) {
+ /* right clicked */
+ if (clist->selection) {
+ GtkCTreeNode *node;
+
+ node = GTK_CTREE_NODE(clist->selection->data);
+ if (node)
+ prev_row = gtkut_ctree_get_nth_from_node
+ (GTK_CTREE(ctree), node);
+ }
+
+ if (!gtk_clist_get_selection_info(clist, event->x, event->y,
+ &row, &column))
+ return FALSE;
+ if (prev_row != row) {
+ gtk_clist_unselect_all(clist);
+ if (event->button == 2)
+ folderview_select_node
+ (folderview,
+ gtk_ctree_node_nth(GTK_CTREE(ctree),
+ row));
+ else
+ gtk_clist_select_row(clist, row, column);
+ }
+ }
+
+ if (event->button != 3) return FALSE;
+
+ folderview_set_sens_and_popup_menu(folderview, row, event);
return FALSE;
}
return FALSE;
switch (event->keyval) {
+ case GDK_Right:
+#ifndef MAEMO
case GDK_Return:
+ case GDK_KP_Enter:
+#endif
if (folderview->selected) {
folderview_select_node(folderview,
folderview->selected);
}
break;
+#ifdef MAEMO
+ case GDK_Return:
+ if (folderview->selected && GTK_CTREE_ROW(folderview->selected)->children) {
+ gtk_ctree_toggle_expansion(
+ GTK_CTREE(folderview->ctree),
+ folderview->selected);
+ }
+ break;
+#endif
case GDK_space:
if (folderview->selected) {
if (folderview->opened == folderview->selected &&
(!folderview->summaryview->folder_item ||
folderview->summaryview->folder_item->total_msgs == 0))
- folderview_select_next_unread(folderview);
+ folderview_select_next_unread(folderview, TRUE);
else
folderview_select_node(folderview,
folderview->selected);
return FALSE;
}
+typedef struct _PostponedSelectData
+{
+ GtkCTree *ctree;
+ GtkCTreeNode *row;
+ gint column;
+ FolderView *folderview;
+} PostponedSelectData;
+
+static gboolean postpone_select(void *data)
+{
+ PostponedSelectData *psdata = (PostponedSelectData *)data;
+ debug_print("trying again\n");
+ psdata->folderview->open_folder = TRUE;
+ main_window_cursor_normal(psdata->folderview->mainwin);
+ STATUSBAR_POP(psdata->folderview->mainwin);
+ folderview_selected(psdata->ctree, psdata->row,
+ psdata->column, psdata->folderview);
+ g_free(psdata);
+ return FALSE;
+}
+
+void folderview_close_opened(FolderView *folderview)
+{
+ if (folderview->opened) {
+ FolderItem *olditem;
+
+ olditem = gtk_ctree_node_get_row_data(GTK_CTREE(folderview->ctree),
+ folderview->opened);
+ if (olditem) {
+ gchar *buf = g_strdup_printf(_("Closing Folder %s..."),
+ olditem->path ? olditem->path:olditem->name);
+ /* will be null if we just moved the previously opened folder */
+ STATUSBAR_PUSH(folderview->mainwin, buf);
+ main_window_cursor_wait(folderview->mainwin);
+ g_free(buf);
+ summary_save_prefs_to_folderitem(folderview->summaryview, olditem);
+ summary_show(folderview->summaryview, NULL);
+ folder_item_close(olditem);
+ main_window_cursor_normal(folderview->mainwin);
+ STATUSBAR_POP(folderview->mainwin);
+ }
+ }
+
+ if (folderview->opened &&
+ !GTK_CTREE_ROW(folderview->opened)->children)
+ gtk_ctree_collapse(GTK_CTREE(folderview->ctree), folderview->opened);
+
+ folderview->opened = NULL;
+}
static void folderview_selected(GtkCTree *ctree, GtkCTreeNode *row,
gint column, FolderView *folderview)
{
gboolean opened;
FolderItem *item;
gchar *buf;
-
+ int res = 0;
+ GtkCTreeNode *old_opened = folderview->opened;
+ START_TIMING("");
folderview->selected = row;
+ debug_print("newly selected %p, opened %p\n", folderview->selected,
+ folderview->opened);
if (folderview->opened == row) {
folderview->open_folder = FALSE;
+ END_TIMING();
return;
}
if (!can_select || summary_is_locked(folderview->summaryview)) {
- gtkut_ctree_set_focus_row(ctree, folderview->opened);
- gtk_ctree_select(ctree, folderview->opened);
+ if (folderview->opened) {
+ gtkut_ctree_set_focus_row(ctree, folderview->opened);
+ gtk_ctree_select(ctree, folderview->opened);
+ }
+ folderview->open_folder = FALSE;
+ END_TIMING();
return;
}
- if (!folderview->open_folder) return;
-
+ if (!folderview->open_folder) {
+ END_TIMING();
+ return;
+ }
item = gtk_ctree_node_get_row_data(ctree, row);
- if (!item || item->no_select) return;
+ if (!item || item->no_select) {
+ END_TIMING();
+ folderview->open_folder = FALSE;
+ return;
+ }
can_select = FALSE;
/* Save cache for old folder */
/* We don't want to lose all caches if sylpheed crashed */
- if (folderview->opened) {
- FolderItem *olditem;
-
- olditem = gtk_ctree_node_get_row_data(ctree, folderview->opened);
- if (olditem) {
- /* will be null if we just moved the previously opened folder */
- summary_save_prefs_to_folderitem(folderview->summaryview, olditem);
- summary_show(folderview->summaryview, NULL);
- folder_item_close(olditem);
- }
- }
-
+ /* resets folderview->opened to NULL */
+ folderview_close_opened(folderview);
+
/* CLAWS: set compose button type: news folder items
* always have a news folder as parent */
if (item->folder)
if (!GTK_CTREE_ROW(row)->children)
gtk_ctree_expand(ctree, row);
- if (folderview->opened &&
- !GTK_CTREE_ROW(folderview->opened)->children)
- gtk_ctree_collapse(ctree, folderview->opened);
/* ungrab the mouse event */
if (GTK_WIDGET_HAS_GRAB(ctree)) {
main_window_cursor_wait(folderview->mainwin);
- if (folder_item_open(item) != 0) {
+ res = folder_item_open(item);
+ if (res == -1) {
main_window_cursor_normal(folderview->mainwin);
STATUSBAR_POP(folderview->mainwin);
folderview->open_folder = FALSE;
can_select = TRUE;
-
+ END_TIMING();
return;
- }
+ } else if (res == -2) {
+ PostponedSelectData *data = g_new0(PostponedSelectData, 1);
+ data->ctree = ctree;
+ data->row = row;
+ data->column = column;
+ data->folderview = folderview;
+ debug_print("postponing open of %s till end of scan\n",
+ item->path ? item->path:item->name);
+ folderview->open_folder = FALSE;
+ can_select = TRUE;
+ g_timeout_add(500, postpone_select, data);
+ END_TIMING();
+ return;
+ }
main_window_cursor_normal(folderview->mainwin);
summary_set_prefs_from_folderitem(folderview->summaryview, item);
opened = summary_show(folderview->summaryview, item);
- folder_clean_cache_memory();
+ folder_clean_cache_memory(item);
if (!opened) {
- gtkut_ctree_set_focus_row(ctree, folderview->opened);
- gtk_ctree_select(ctree, folderview->opened);
+ gtkut_ctree_set_focus_row(ctree, old_opened);
+ gtk_ctree_select(ctree, old_opened);
+ folderview->opened = old_opened;
} else {
folderview->opened = row;
if (gtk_ctree_node_is_visible(ctree, row)
folderview->open_folder = FALSE;
can_select = TRUE;
+ END_TIMING();
}
static void folderview_tree_expanded(GtkCTree *ctree, GtkCTreeNode *node,
prefs_common.folder_col_size[type] = width;
}
-void folderview_create_folder_node_recursive(FolderView *folderview, FolderItem *item)
+static void folderview_create_folder_node_recursive(FolderView *folderview, FolderItem *item)
{
GNode *srcnode;
}
}
-void folderview_create_folder_node(FolderView *folderview, FolderItem *item)
+static void folderview_create_folder_node(FolderView *folderview, FolderItem *item)
{
GtkCTree *ctree = GTK_CTREE(folderview->ctree);
gchar *text[N_FOLDER_COLS] = {NULL, "0", "0", "0"};
folder_item_remove_all_msg(item);
}
+static void folderview_send_queue_cb(FolderView *folderview, guint action,
+ GtkWidget *widget)
+{
+ GtkCTree *ctree = GTK_CTREE(folderview->ctree);
+ FolderItem *item;
+ FolderItem *special_queue = NULL;
+ PrefsAccount *ac;
+ gchar *errstr = NULL;
+
+ if (!folderview->selected) return;
+ item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
+ g_return_if_fail(item != NULL);
+ g_return_if_fail(item->folder != NULL);
+
+ if (NULL != (ac = account_find_from_item(item)))
+ special_queue = account_get_special_folder(ac, F_QUEUE);
+
+ if (item != item->folder->queue && item != special_queue
+ && !folder_has_parent_of_type(item, F_QUEUE)) return;
+
+ if (procmsg_queue_is_empty(item))
+ return;
+
+ if (prefs_common.work_offline)
+ if (alertpanel(_("Offline warning"),
+ _("You're working offline. Override?"),
+ GTK_STOCK_NO, GTK_STOCK_YES,
+ NULL) != G_ALERTALTERNATE)
+ return;
+
+ /* ask for confirmation before sending queued messages only
+ in online mode and if there is at least one message queued
+ in any of the folder queue
+ */
+ if (prefs_common.confirm_send_queued_messages) {
+ if (!prefs_common.work_offline) {
+ if (alertpanel(_("Send queued messages"),
+ _("Send all queued messages?"),
+ GTK_STOCK_CANCEL, _("_Send"),
+ NULL) != G_ALERTALTERNATE)
+ return;
+ }
+ }
+
+ if (procmsg_send_queue(item, prefs_common.savemsg, &errstr) < 0) {
+ if (!errstr)
+ alertpanel_error_log(_("Some errors occurred while "
+ "sending queued messages."));
+ else {
+ gchar *tmp = g_strdup_printf(_("Some errors occurred "
+ "while sending queued messages:\n%s"), errstr);
+ g_free(errstr);
+ alertpanel_error_log(tmp);
+ g_free(tmp);
+ }
+ }
+}
+
static void folderview_search_cb(FolderView *folderview, guint action,
GtkWidget *widget)
{
summary_search(folderview->summaryview);
}
+static void folderview_run_processing_cb(FolderView *folderview, guint action,
+ GtkWidget *widget)
+{
+ GtkCTree *ctree = GTK_CTREE(folderview->ctree);
+ FolderItem *item;
+
+ if (!folderview->selected) return;
+
+ item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
+ g_return_if_fail(item != NULL);
+ g_return_if_fail(item->folder != NULL);
+
+ folder_item_apply_processing(item);
+}
+
static void folderview_property_cb(FolderView *folderview, guint action,
GtkWidget *widget)
{
g_return_if_fail(item != NULL);
g_return_if_fail(item->folder != NULL);
- if (folder_item_parent(item) == NULL)
- return;
-
prefs_folder_item_open(item);
}
}
void folderview_move_folder(FolderView *folderview, FolderItem *from_folder,
- FolderItem *to_folder)
+ FolderItem *to_folder, gboolean copy)
{
FolderItem *from_parent = NULL;
FolderItem *new_folder = NULL;
from_parent = folder_item_parent(from_folder);
if (prefs_common.warn_dnd) {
- buf = g_strdup_printf(_("Do you really want to make folder '%s' a "
- "sub-folder of '%s' ?"), from_folder->name,
- to_folder->name);
- status = alertpanel_full(_("Move folder"), buf,
+ buf = g_strdup_printf(copy ? _("Do you really want to copy folder '%s' in '%s' ?"):
+ _("Do you really want to make folder '%s' a subfolder of '%s' ?"),
+ from_folder->name, to_folder->name);
+ status = alertpanel_full(copy ? _("Copy folder"):_("Move folder"), buf,
GTK_STOCK_NO, GTK_STOCK_YES, NULL, TRUE,
NULL, ALERT_QUESTION, G_ALERTDEFAULT);
g_free(buf);
- if (status != G_ALERTALTERNATE
- && status != (G_ALERTALTERNATE | G_ALERTDISABLE))
+ if ((status & ~G_ALERTDISABLE) != G_ALERTALTERNATE)
return;
- if (status & G_ALERTDISABLE)
+ else if (status & G_ALERTDISABLE)
prefs_common.warn_dnd = FALSE;
}
- buf = g_strdup_printf(_("Moving %s to %s..."), from_folder->name, to_folder->name);
+ buf = g_strdup_printf(copy ? _("Copying %s to %s..."):_("Moving %s to %s..."),
+ from_folder->name, to_folder->name);
STATUSBAR_PUSH(folderview->mainwin, buf);
g_free(buf);
summary_clear_all(folderview->summaryview);
gtk_widget_set_sensitive(GTK_WIDGET(folderview->ctree), FALSE);
inc_lock();
main_window_cursor_wait(folderview->mainwin);
- statusbar_verbosity_set(TRUE);
+
+ statusbar_verbosity_set(FALSE);
folder_item_update_freeze();
- if ((status = folder_item_move_to(from_folder, to_folder, &new_folder)) == F_MOVE_OK) {
+ if ((status = folder_item_move_to(from_folder, to_folder, &new_folder, copy)) == F_MOVE_OK) {
statusbar_verbosity_set(FALSE);
main_window_cursor_normal(folderview->mainwin);
STATUSBAR_POP(folderview->mainwin);
alertpanel_error(_("Source and destination are the same."));
break;
case F_MOVE_FAILED_DEST_IS_CHILD:
- alertpanel_error(_("Can't move a folder to one of its children."));
+ alertpanel_error(copy ? _("Can't copy a folder to one of its children."):
+ _("Can't move a folder to one of its children."));
break;
case F_MOVE_FAILED_DEST_OUTSIDE_MAILBOX:
- alertpanel_error(_("Folder moving cannot be done between different mailboxes."));
+ alertpanel_error(_("A folder cannot be moved between different mailboxes."));
break;
default:
- alertpanel_error(_("Move failed!"));
+ alertpanel_error(copy ? _("Copy failed!"):_("Move failed!"));
break;
}
}
FolderItem *item1 = ((GtkCListRow *)ptr1)->data;
FolderItem *item2 = ((GtkCListRow *)ptr2)->data;
+ if (item1->order > 0 && item2->order > 0) // if we have an order item, use it
+ {
+ return item1->order - item2->order;
+ }
+
+ // if only one folder has an order it comes first
+ if (item1->order > 0)
+ {
+ return -1;
+ }
+ if (item2->order > 0)
+ {
+ return 1;
+ }
+
if (!item1->name)
return (item2->name != NULL);
if (!item2->name)
title = g_strdup_printf (_("Processing configuration for folder %s"), id);
g_free (id);
- prefs_filtering_open(&item->prefs->processing, title, NULL, NULL);
+ prefs_filtering_open(&item->prefs->processing, title,
+ MANUAL_ANCHOR_PROCESSING, NULL, NULL, FALSE);
g_free (title);
}
void folderview_reflect_prefs_pixmap_theme(FolderView *folderview)
{
/* force reinit */
- if (last_font)
- g_free(last_font);
+ g_free(last_font);
last_font = NULL;
}
if (last_font && !strcmp(last_font, NORMAL_FONT))
update_font = FALSE;
- if (last_font)
- g_free(last_font);
-
+ g_free(last_font);
last_font = g_strdup(NORMAL_FONT);
if (update_font) {
GTK_CTREE(folderview->ctree), NULL, item);
folderview_select(folderview, item);
+ folderview->open_folder = FALSE;
folderview->selected = node;
}
static void drag_state_stop(FolderView *folderview)
{
if (folderview->drag_timer)
- gtk_timeout_remove(folderview->drag_timer);
+ g_source_remove(folderview->drag_timer);
folderview->drag_timer = 0;
folderview->drag_node = NULL;
}
* we need to call drag_state_stop() */
drag_state_stop(folderview);
/* request expansion */
- if (0 != (folderview->drag_timer = gtk_timeout_add
+ if (0 != (folderview->drag_timer = g_timeout_add
(prefs_common.hover_timeout,
(GtkFunction)folderview_defer_expand,
folderview))) {
}
}
-gboolean folderview_update_folder(gpointer source, gpointer userdata)
+static gboolean folderview_update_folder(gpointer source, gpointer userdata)
{
FolderUpdateData *hookdata;
FolderView *folderview;
GtkCTreeNode *node;
node = gtk_ctree_find_by_row_data(GTK_CTREE(ctree), NULL, hookdata->item);
- if (node != NULL)
+ if (node != NULL) {
gtk_ctree_remove_node(GTK_CTREE(ctree), node);
+ if (folderview->selected == node)
+ folderview->selected = NULL;
+ if (folderview->opened == node)
+ folderview->opened = NULL;
+ }
} else if (hookdata->update_flags & (FOLDER_TREE_CHANGED | FOLDER_ADD_FOLDER | FOLDER_REMOVE_FOLDER))
folderview_set(folderview);
src_item = folderview->summaryview->folder_item;
srcwidget = gtk_drag_get_source_widget(context);
- if (srcwidget == folderview->summaryview->ctree) {
+ if (srcwidget == summary_get_main_widget(folderview->summaryview)) {
/* comes from summaryview */
/* we are copying messages, so only accept folder items that are not
the source item, are no root items and can copy messages */
if (item && item->folder && folder_item_parent(item) != NULL && src_item &&
- src_item != item && FOLDER_CLASS(item->folder)->copy_msg != NULL)
+ src_item != item && FOLDER_CLASS(item->folder)->copy_msg != NULL &&
+ FOLDER_TYPE(item->folder) != F_UNKNOWN)
acceptable = TRUE;
} else if (srcwidget == folderview->ctree) {
/* comes from folderview */
the source items and can copy messages and create folder items */
if (item && item->folder && src_item && src_item != item &&
FOLDER_CLASS(item->folder)->copy_msg != NULL &&
- FOLDER_CLASS(item->folder)->create_folder != NULL)
+ FOLDER_CLASS(item->folder)->create_folder != NULL &&
+ ((FOLDER_TYPE(item->folder) != F_UNKNOWN && FOLDER_TYPE(src_item->folder) != F_UNKNOWN)
+ || item->folder == src_item->folder))
acceptable = TRUE;
} else {
/* comes from another app */
/* we are adding messages, so only accept folder items that are
no root items and can copy messages */
if (item && item->folder && folder_item_parent(item) != NULL
- && FOLDER_CLASS(item->folder)->add_msg != NULL)
+ && FOLDER_CLASS(item->folder)->add_msg != NULL &&
+ FOLDER_TYPE(item->folder) != F_UNKNOWN)
acceptable = TRUE;
}
}
if (!(item && item->folder && folder_item_parent(item) != NULL
&& FOLDER_CLASS(item->folder)->add_msg != NULL))
{
- gtk_drag_finish(drag_context, FALSE, FALSE, time);
+ gtk_drag_finish(drag_context, FALSE, FALSE, time);
+ debug_print("item doesn't fit\n");
return;
}
if (!list) {
- gtk_drag_finish(drag_context, FALSE, FALSE, time);
+ gtk_drag_finish(drag_context, FALSE, FALSE, time);
+ debug_print("list is empty\n");
return;
}
for (tmp = list; tmp != NULL; tmp = tmp->next) {
info->msginfo = NULL;
info->file = (gchar *)tmp->data;
msglist = g_slist_prepend(msglist, info);
+ debug_print("file is a mail\n");
+ } else {
+ debug_print("file isn't a mail\n");
}
}
if (msglist) {
/* comes from folderview */
char *source;
gboolean folder_is_normal = TRUE;
+ gboolean copy = (drag_context->action == GDK_ACTION_COPY);
source = data->data + 17;
if (gtk_clist_get_selection_info
return;
}
- folderview_move_folder(folderview, src_item, item);
+ folderview_move_folder(folderview, src_item, item, copy);
gtk_drag_finish(drag_context, TRUE, TRUE, time);
}
folderview->nodes_to_recollapse = NULL;
node = gtk_ctree_node_nth(GTK_CTREE(widget), row);
if (!node) {
- gtk_drag_finish(drag_context, FALSE, FALSE, time);
+ gtk_drag_finish(drag_context, FALSE, FALSE, time);
+ debug_print("no node\n");
return;
}
item = gtk_ctree_node_get_row_data(GTK_CTREE(widget), node);
if (!item) {
gtk_drag_finish(drag_context, FALSE, FALSE, time);
+ debug_print("no item\n");
return;
}
folderview_finish_dnd(data->data, drag_context, time, item);
projects / claws.git / blobdiff