#include <glib.h>
#include <glib/gi18n.h>
#include <gdk/gdkkeysyms.h>
-#include <gtk/gtkwidget.h>
-#include <gtk/gtkscrolledwindow.h>
-#include <gtk/gtkctree.h>
-#include <gtk/gtkcontainer.h>
-#include <gtk/gtkclist.h>
-#include <gtk/gtkstyle.h>
-#include <gtk/gtksignal.h>
-#include <gtk/gtkmain.h>
-#include <gtk/gtkstatusbar.h>
-#include <gtk/gtkmenu.h>
-#include <gtk/gtkmenuitem.h>
-#include <gtk/gtkitemfactory.h>
+#include <gtk/gtk.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
static GdkBitmap *readxpmmask;
static void folderview_select_node (FolderView *folderview,
- GtkCTreeNode *node);
+ GtkCMCTreeNode *node);
static void folderview_set_folders (FolderView *folderview);
static void folderview_sort_folders (FolderView *folderview,
- GtkCTreeNode *root,
+ GtkCMCTreeNode *root,
Folder *folder);
static void folderview_append_folder (FolderView *folderview,
Folder *folder);
static void folderview_update_node (FolderView *folderview,
- GtkCTreeNode *node);
+ GtkCMCTreeNode *node);
-static gint folderview_clist_compare (GtkCList *clist,
+static gint folderview_clist_compare (GtkCMCList *clist,
gconstpointer ptr1,
gconstpointer ptr2);
static gboolean folderview_key_pressed (GtkWidget *widget,
GdkEventKey *event,
FolderView *folderview);
-static void folderview_selected (GtkCTree *ctree,
- GtkCTreeNode *row,
+static void folderview_selected (GtkCMCTree *ctree,
+ GtkCMCTreeNode *row,
gint column,
FolderView *folderview);
-static void folderview_tree_expanded (GtkCTree *ctree,
- GtkCTreeNode *node,
+static void folderview_tree_expanded (GtkCMCTree *ctree,
+ GtkCMCTreeNode *node,
FolderView *folderview);
-static void folderview_tree_collapsed (GtkCTree *ctree,
- GtkCTreeNode *node,
+static void folderview_tree_collapsed (GtkCMCTree *ctree,
+ GtkCMCTreeNode *node,
FolderView *folderview);
static void folderview_popup_close (GtkMenuShell *menu_shell,
FolderView *folderview);
-static void folderview_col_resized (GtkCList *clist,
+static void folderview_col_resized (GtkCMCList *clist,
gint column,
gint width,
FolderView *folderview);
-static void mark_all_read_cb (FolderView *folderview,
- guint action,
- GtkWidget *widget);
+static void mark_all_read_cb (GtkAction *action,
+ gpointer data);
-static void folderview_empty_trash_cb (FolderView *folderview,
- guint action,
- GtkWidget *widget);
+static void folderview_empty_trash_cb (GtkAction *action,
+ gpointer data);
-static void folderview_send_queue_cb (FolderView *folderview,
- guint action,
- GtkWidget *widget);
+static void folderview_send_queue_cb (GtkAction *action,
+ gpointer data);
-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_search_cb (GtkAction *action,
+ gpointer data);
+static void folderview_run_processing_cb(GtkAction *action,
+ gpointer data);
-static void folderview_property_cb (FolderView *folderview,
- guint action,
- GtkWidget *widget);
+static void folderview_property_cb (GtkAction *action,
+ gpointer data);
static gboolean folderview_drag_motion_cb(GtkWidget *widget,
GdkDragContext *context,
guint info,
guint time,
FolderView *folderview);
+#ifndef GENERIC_UMPC
static void folderview_start_drag (GtkWidget *widget, gint button, GdkEvent *event,
FolderView *folderview);
+#endif
static void folderview_drag_data_get (GtkWidget *widget,
GdkDragContext *drag_context,
GtkSelectionData *selection_data,
gpointer userdata);
static gboolean folderview_update_item_claws (gpointer source,
gpointer data);
-static void folderview_processing_cb(FolderView *folderview, guint action,
- GtkWidget *widget);
+static void folderview_processing_cb(GtkAction *action, gpointer data);
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[] = {
- {"/------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},
+static GtkActionEntry folderview_common_popup_entries[] =
+{
+ {"FolderViewPopup", NULL, "FolderViewPopup" },
+ {"FolderViewPopup/MarkAllRead", NULL, N_("Mark all re_ad"), NULL, NULL, G_CALLBACK(mark_all_read_cb) },
+ {"FolderViewPopup/---", NULL, "---" },
+ {"FolderViewPopup/RunProcessing", NULL, N_("R_un processing rules"), NULL, NULL, G_CALLBACK(folderview_run_processing_cb) },
+ {"FolderViewPopup/SearchFolder", NULL, N_("_Search folder..."), NULL, NULL, G_CALLBACK(folderview_search_cb) },
+ {"FolderViewPopup/Properties", NULL, N_("_Properties..."), NULL, NULL, G_CALLBACK(folderview_property_cb) },
+ {"FolderViewPopup/Processing", NULL, N_("Process_ing..."), NULL, NULL, G_CALLBACK(folderview_processing_cb) },
+ {"FolderViewPopup/EmptyTrash", NULL, N_("Empty _trash..."), NULL, NULL, G_CALLBACK(folderview_empty_trash_cb) },
+ {"FolderViewPopup/SendQueue", NULL, N_("Send _queue..."), NULL, NULL, G_CALLBACK(folderview_send_queue_cb) },
+
};
-
GtkTargetEntry folderview_drag_types[] =
{
{"claws-mail/internal", GTK_TARGET_SAME_APP, TARGET_DUMMY},
void folderview_initialize(void)
{
FolderViewPopup *fpopup;
- guint i, n_entries;
- GSList *entries = NULL;
fpopup = g_new0(FolderViewPopup, 1);
- n_entries = sizeof(folderview_common_popup_entries) /
- sizeof(folderview_common_popup_entries[0]);
- for (i = 0; i < n_entries; i++)
- entries = g_slist_append(entries, &folderview_common_popup_entries[i]);
-
fpopup->klass = "common";
fpopup->path = "<CommonFolder>";
- fpopup->entries = entries;
+ fpopup->entries = folderview_common_popup_entries;
+ fpopup->n_entries = G_N_ELEMENTS(folderview_common_popup_entries);
fpopup->set_sensitivity = NULL;
folderview_popups = g_hash_table_new(g_str_hash, g_str_equal);
g_hash_table_insert(folderview_popups, "common", fpopup);
}
-static GtkItemFactory *create_ifactory(FolderView *folderview, FolderViewPopup *fpopup)
+static GtkActionGroup *create_action_group(FolderView *folderview, FolderViewPopup *fpopup)
{
- GSList *entries;
- GtkItemFactory *factory;
FolderViewPopup *fpopup_common;
- GtkWidget *popup;
-
- factory = gtk_item_factory_new(GTK_TYPE_MENU, fpopup->path, NULL);
- gtk_item_factory_set_translate_func(factory, menu_translate,
- NULL, NULL);
-
- for (entries = fpopup->entries; entries != NULL; entries = g_slist_next(entries))
- gtk_item_factory_create_item(factory, entries->data, folderview, 1);
+ GtkActionGroup *action_group;
+
+ action_group = cm_menu_create_action_group(
+ fpopup->path,
+ fpopup->entries, fpopup->n_entries,
+ (gpointer)folderview);
+
+ if (fpopup->toggle_entries)
+ gtk_action_group_add_toggle_actions(action_group, fpopup->toggle_entries,
+ fpopup->n_toggle_entries,
+ (gpointer)folderview);
+ if (fpopup->radio_entries)
+ gtk_action_group_add_radio_actions(action_group, fpopup->radio_entries,
+ fpopup->n_radio_entries, fpopup->radio_default,
+ G_CALLBACK(fpopup->radio_callback),
+ (gpointer)folderview);
fpopup_common = g_hash_table_lookup(folderview_popups, "common");
- if (fpopup_common != fpopup)
- for (entries = fpopup_common->entries; entries != NULL; entries = g_slist_next(entries))
- gtk_item_factory_create_item(factory, entries->data, folderview, 1);
-
- popup = gtk_item_factory_get_widget(factory, fpopup->path);
- g_signal_connect(G_OBJECT(popup), "selection_done",
- G_CALLBACK(folderview_popup_close),
- folderview);
+ if (fpopup_common != fpopup) {
+ gtk_action_group_add_actions(action_group, fpopup_common->entries,
+ fpopup_common->n_entries,
+ (gpointer)folderview);
+ if (fpopup_common->toggle_entries)
+ gtk_action_group_add_toggle_actions(action_group, fpopup_common->toggle_entries,
+ fpopup_common->n_toggle_entries,
+ (gpointer)folderview);
+ if (fpopup_common->radio_entries)
+ gtk_action_group_add_radio_actions(action_group, fpopup_common->radio_entries,
+ fpopup_common->n_radio_entries, fpopup_common->radio_default,
+ G_CALLBACK(fpopup_common->radio_callback),
+ (gpointer)folderview);
+ }
- return factory;
+ return action_group;
}
-static void create_ifactories(gpointer key, gpointer value, gpointer data)
+static void create_action_groups(gpointer key, gpointer value, gpointer data)
{
FolderView *folderview = data;
FolderViewPopup *fpopup = value;
- GtkItemFactory *factory;
+ GtkActionGroup *group;
- factory = create_ifactory(folderview, fpopup);
- g_hash_table_insert(folderview->popups, fpopup->klass, factory);
+ group = create_action_group(folderview, fpopup);
+ g_hash_table_insert(folderview->popups, fpopup->klass, group);
}
static void folderview_column_set_titles(FolderView *folderview)
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));
+ gtk_cmclist_column_titles_active(GTK_CMCLIST(ctree));
hbox_folder = gtk_hbox_new(FALSE, 4);
hbox_new = gtk_hbox_new(FALSE, 4);
gtk_widget_show_all(hbox_unread);
gtk_widget_show_all(hbox_total);
-#ifdef MAEMO
+#ifdef GENERIC_UMPC
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);
+ gtk_cmclist_set_column_widget(GTK_CMCLIST(ctree),col_pos[F_COL_FOLDER],hbox_folder);
+ gtk_cmclist_set_column_widget(GTK_CMCLIST(ctree),col_pos[F_COL_NEW],hbox_new);
+ gtk_cmclist_set_column_widget(GTK_CMCLIST(ctree),col_pos[F_COL_UNREAD],hbox_unread);
+ gtk_cmclist_set_column_widget(GTK_CMCLIST(ctree),col_pos[F_COL_TOTAL],hbox_total);
-#ifdef MAEMO
+#ifdef GENERIC_UMPC
GTK_EVENTS_FLUSH();
#endif
titles);
if (prefs_common.show_col_headers == FALSE)
- gtk_clist_column_titles_hide(GTK_CLIST(ctree));
+ gtk_cmclist_column_titles_hide(GTK_CMCLIST(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_cmclist_set_selection_mode(GTK_CMCLIST(ctree), GTK_SELECTION_BROWSE);
+ gtk_cmclist_set_column_justification(GTK_CMCLIST(ctree), col_pos[F_COL_NEW],
GTK_JUSTIFY_RIGHT);
- gtk_clist_set_column_justification(GTK_CLIST(ctree),
+ gtk_cmclist_set_column_justification(GTK_CMCLIST(ctree),
col_pos[F_COL_UNREAD],
GTK_JUSTIFY_RIGHT);
- gtk_clist_set_column_justification(GTK_CLIST(ctree),
+ gtk_cmclist_set_column_justification(GTK_CMCLIST(ctree),
col_pos[F_COL_TOTAL],
GTK_JUSTIFY_RIGHT);
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);
+ gtk_cmctree_set_line_style(GTK_CMCTREE(ctree), GTK_CMCTREE_LINES_DOTTED);
+ gtk_cmctree_set_expander_style(GTK_CMCTREE(ctree),
+ GTK_CMCTREE_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_cmctree_set_line_style(GTK_CMCTREE(ctree), GTK_CMCTREE_LINES_NONE);
+ gtk_cmctree_set_expander_style(GTK_CMCTREE(ctree),
+ GTK_CMCTREE_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);
+ gtk_cmctree_set_indent(GTK_CMCTREE(ctree), CTREE_INDENT);
+ gtk_cmclist_set_compare_func(GTK_CMCLIST(ctree), folderview_clist_compare);
/* don't let title buttons take key focus */
for (i = 0; i < N_FOLDER_COLS; i++) {
- GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(ctree)->column[i].button,
+ GTK_WIDGET_UNSET_FLAGS(GTK_CMCLIST(ctree)->column[i].button,
GTK_CAN_FOCUS);
- gtk_clist_set_column_width(GTK_CLIST(ctree), col_pos[i],
+ gtk_cmclist_set_column_width(GTK_CMCLIST(ctree), col_pos[i],
prefs_common.folder_col_size[i]);
- gtk_clist_set_column_visibility
- (GTK_CLIST(ctree), i, col_state[i].visible);
+ gtk_cmclist_set_column_visibility
+ (GTK_CMCLIST(ctree), i, col_state[i].visible);
}
g_signal_connect(G_OBJECT(ctree), "key_press_event",
folderview);
g_signal_connect(G_OBJECT(ctree), "tree_select_row",
G_CALLBACK(folderview_selected), folderview);
-#ifndef MAEMO
+#ifndef GENERIC_UMPC
/* drag-n-dropping folders on maemo is impractical as this
* opens the folder almost everytime */
g_signal_connect(G_OBJECT(ctree), "start_drag",
void folderview_set_column_order(FolderView *folderview)
{
- GtkWidget *ctree;
+ GtkWidget *ctree = folderview->ctree;
FolderItem *item = folderview_get_selected_item(folderview);
+ FolderItem *sel_item = NULL, *op_item = NULL;
GtkWidget *scrolledwin = folderview->scrolledwin;
+ if (folderview->selected)
+ sel_item = gtk_cmctree_node_get_row_data(GTK_CMCTREE(ctree), folderview->selected);
+ if (folderview->opened)
+ op_item = gtk_cmctree_node_get_row_data(GTK_CMCTREE(ctree), folderview->opened);
+
debug_print("recreating tree...\n");
gtk_widget_destroy(folderview->ctree);
+
folderview->ctree = ctree = folderview_ctree_create(folderview);
gtk_scrolled_window_set_hadjustment(GTK_SCROLLED_WINDOW(scrolledwin),
- GTK_CLIST(ctree)->hadjustment);
+ GTK_CMCLIST(ctree)->hadjustment);
gtk_scrolled_window_set_vadjustment(GTK_SCROLLED_WINDOW(scrolledwin),
- GTK_CLIST(ctree)->vadjustment);
+ GTK_CMCLIST(ctree)->vadjustment);
gtk_widget_show(ctree);
+ if (sel_item)
+ folderview->selected = gtk_cmctree_find_by_row_data(GTK_CMCTREE(ctree), NULL, sel_item);
+ if (op_item)
+ folderview->opened = gtk_cmctree_find_by_row_data(GTK_CMCTREE(ctree), NULL, op_item);
+
folderview_set(folderview);
folderview_column_set_titles(folderview);
/* create popup factories */
folderview->popups = g_hash_table_new(g_str_hash, g_str_equal);
- g_hash_table_foreach(folderview_popups, create_ifactories, folderview);
+ g_hash_table_foreach(folderview_popups, create_action_groups, folderview);
folderview->ctree = ctree;
if (!bold_style) {
gtkut_convert_int_to_gdk_color(prefs_common.color_new, &gdk_color);
bold_style = gtk_style_copy(gtk_widget_get_style(ctree));
- pango_font_description_set_weight
- (bold_style->font_desc, PANGO_WEIGHT_BOLD);
+ if (prefs_common.derive_from_normal_font || !BOLD_FONT) {
+ pango_font_description_set_weight
+ (bold_style->font_desc, PANGO_WEIGHT_BOLD);
+ } else {
+ PangoFontDescription *font_desc;
+ font_desc = pango_font_description_from_string(BOLD_FONT);
+ if (font_desc) {
+ if (bold_style->font_desc)
+ pango_font_description_free
+ (bold_style->font_desc);
+ bold_style->font_desc = font_desc;
+ }
+ }
bold_color_style = gtk_style_copy(bold_style);
bold_color_style->fg[GTK_STATE_NORMAL] = gdk_color;
if (mainwin->lock_count)
return TRUE;
- printf("doing deferred folderview_set now\n");
+ debug_print("doing deferred folderview_set now\n");
folderview_set(folderview);
folderview->deferred_refresh_id = -1;
void folderview_set(FolderView *folderview)
{
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
+ GtkCMCTree *ctree = GTK_CMCTREE(folderview->ctree);
MainWindow *mainwin = folderview->mainwin;
FolderItem *sel_item = NULL, *op_item = NULL;
if (folderview->deferred_refresh_id == -1)
folderview->deferred_refresh_id =
g_timeout_add(500, folderview_defer_set, folderview);
- printf("deferred folderview_set\n");
+ debug_print("deferred folderview_set\n");
return;
}
main_window_cursor_wait(mainwin);
if (folderview->selected)
- sel_item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
+ sel_item = gtk_cmctree_node_get_row_data(ctree, folderview->selected);
if (folderview->opened)
- op_item = gtk_ctree_node_get_row_data(ctree, folderview->opened);
+ op_item = gtk_cmctree_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_cmclist_freeze(GTK_CMCLIST(ctree));
+ gtk_cmclist_clear(GTK_CMCLIST(ctree));
folderview_set_folders(folderview);
if (sel_item)
- folderview->selected = gtk_ctree_find_by_row_data(ctree, NULL, sel_item);
+ folderview->selected = gtk_cmctree_find_by_row_data(ctree, NULL, sel_item);
if (op_item)
- folderview->opened = gtk_ctree_find_by_row_data(ctree, NULL, op_item);
+ folderview->opened = gtk_cmctree_find_by_row_data(ctree, NULL, op_item);
- gtk_clist_thaw(GTK_CLIST(ctree));
+ gtk_cmclist_thaw(GTK_CMCLIST(ctree));
main_window_cursor_normal(mainwin);
STATUSBAR_POP(mainwin);
inc_unlock();
void folderview_select(FolderView *folderview, FolderItem *item)
{
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
- GtkCTreeNode *node;
- GtkCTreeNode *old_selected = folderview->selected;
+ GtkCMCTree *ctree = GTK_CMCTREE(folderview->ctree);
+ GtkCMCTreeNode *node;
+ GtkCMCTreeNode *old_selected = folderview->selected;
if (!item) return;
- node = gtk_ctree_find_by_row_data(ctree, NULL, item);
+ node = gtk_cmctree_find_by_row_data(ctree, NULL, item);
if (node) folderview_select_node(folderview, node);
if (old_selected != node)
folder_update_op_count();
}
-static void mark_all_read_cb(FolderView *folderview, guint action,
- GtkWidget *widget)
+static void mark_all_read_cb(GtkAction *action, gpointer data)
{
+ FolderView *folderview = (FolderView *)data;
FolderItem *item;
AlertValue val;
prefs_common.ask_mark_all_read = FALSE;
}
- summary_lock(folderview->summaryview);
+
folder_item_update_freeze();
- if (folderview->summaryview->folder_item == item)
+ if (folderview->summaryview->folder_item != item)
+ summary_lock(folderview->summaryview);
+ else
summary_freeze(folderview->summaryview);
+
folderutils_mark_all_read(item);
- if (folderview->summaryview->folder_item == item)
+
+ if (folderview->summaryview->folder_item != item)
+ summary_unlock(folderview->summaryview);
+ else
summary_thaw(folderview->summaryview);
folder_item_update_thaw();
- summary_unlock(folderview->summaryview);
}
-static void folderview_select_node(FolderView *folderview, GtkCTreeNode *node)
+static void folderview_select_node(FolderView *folderview, GtkCMCTreeNode *node)
{
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
+ GtkCMCTree *ctree = GTK_CMCTREE(folderview->ctree);
g_return_if_fail(node != NULL);
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_cmctree_select(ctree, node);
+ if ((folderview->summaryview->folder_item &&
+ folderview->summaryview->folder_item->total_msgs > 0) ||
+ prefs_common.layout_mode == SMALL_LAYOUT)
summary_grab_focus(folderview->summaryview);
else
gtk_widget_grab_focus(folderview->ctree);
void folderview_unselect(FolderView *folderview)
{
- if (folderview->opened && !GTK_CTREE_ROW(folderview->opened)->children)
- gtk_ctree_collapse
- (GTK_CTREE(folderview->ctree), folderview->opened);
+ if (folderview->opened && !GTK_CMCTREE_ROW(folderview->opened)->children)
+ gtk_cmctree_collapse
+ (GTK_CMCTREE(folderview->ctree), folderview->opened);
folderview->selected = folderview->opened = NULL;
}
-static GtkCTreeNode *folderview_find_next_marked(GtkCTree *ctree,
- GtkCTreeNode *node)
+static GtkCMCTreeNode *folderview_find_next_marked(GtkCMCTree *ctree,
+ GtkCMCTreeNode *node)
{
FolderItem *item;
if (node)
node = gtkut_ctree_node_next(ctree, node);
else
- node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list);
+ node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
for (; node != NULL; node = gtkut_ctree_node_next(ctree, node)) {
- item = gtk_ctree_node_get_row_data(ctree, node);
+ item = gtk_cmctree_node_get_row_data(ctree, node);
if (item && item->marked_msgs > 0 && item->stype != F_TRASH)
return node;
}
void folderview_select_next_marked(FolderView *folderview)
{
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
- GtkCTreeNode *node = NULL;
+ GtkCMCTree *ctree = GTK_CMCTREE(folderview->ctree);
+ GtkCMCTreeNode *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;
+ prefs_common.always_show_msg = OPENMSG_ALWAYS;
if ((node = folderview_find_next_marked(ctree, folderview->opened))
!= NULL) {
}
if (!folderview->opened ||
- folderview->opened == GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list)) {
+ folderview->opened == GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list)) {
goto out;
}
/* search again from the first node */
prefs_common.always_show_msg = last_open;
}
-static GtkCTreeNode *folderview_find_next_unread(GtkCTree *ctree,
- GtkCTreeNode *node)
+static GtkCMCTreeNode *folderview_find_next_unread(GtkCMCTree *ctree,
+ GtkCMCTreeNode *node)
{
FolderItem *item;
if (node)
node = gtkut_ctree_node_next(ctree, node);
else
- node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list);
+ node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
for (; node != NULL; node = gtkut_ctree_node_next(ctree, node)) {
- item = gtk_ctree_node_get_row_data(ctree, node);
+ item = gtk_cmctree_node_get_row_data(ctree, node);
if (item && item->unread_msgs > 0 && item->stype != F_TRASH)
return node;
}
void folderview_select_next_unread(FolderView *folderview, gboolean force_open)
{
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
- GtkCTreeNode *node = NULL;
+ GtkCMCTree *ctree = GTK_CMCTREE(folderview->ctree);
+ GtkCMCTreeNode *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;
+ prefs_common.always_show_msg = force_open ? OPENMSG_ALWAYS : last_open;
if ((node = folderview_find_next_unread(ctree, folderview->opened))
!= NULL) {
}
if (!folderview->opened ||
- folderview->opened == GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list)) {
+ folderview->opened == GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list)) {
goto out;
}
/* search again from the first node */
prefs_common.always_show_msg = last_open;
}
-static GtkCTreeNode *folderview_find_next_new(GtkCTree *ctree,
- GtkCTreeNode *node)
+static GtkCMCTreeNode *folderview_find_next_new(GtkCMCTree *ctree,
+ GtkCMCTreeNode *node)
{
FolderItem *item;
if (node)
node = gtkut_ctree_node_next(ctree, node);
else
- node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list);
+ node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
for (; node != NULL; node = gtkut_ctree_node_next(ctree, node)) {
- item = gtk_ctree_node_get_row_data(ctree, node);
+ item = gtk_cmctree_node_get_row_data(ctree, node);
if (item && item->new_msgs > 0 && item->stype != F_TRASH)
return node;
}
void folderview_select_next_new(FolderView *folderview)
{
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
- GtkCTreeNode *node = NULL;
+ GtkCMCTree *ctree = GTK_CMCTREE(folderview->ctree);
+ GtkCMCTreeNode *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;
+ prefs_common.always_show_msg = OPENMSG_ALWAYS;
if ((node = folderview_find_next_new(ctree, folderview->opened))
!= NULL) {
}
if (!folderview->opened ||
- folderview->opened == GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list)) {
+ folderview->opened == GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list)) {
goto out;
}
/* search again from the first node */
FolderItem *folderview_get_selected_item(FolderView *folderview)
{
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
+ GtkCMCTree *ctree = GTK_CMCTREE(folderview->ctree);
if (!folderview->selected) return NULL;
- return gtk_ctree_node_get_row_data(ctree, folderview->selected);
+ return gtk_cmctree_node_get_row_data(ctree, folderview->selected);
}
static void folderview_set_folders(FolderView *folderview)
pos = gtk_scrolled_window_get_vadjustment(
GTK_SCROLLED_WINDOW(folderview->scrolledwin));
gtk_adjustment_set_value(pos, height);
+ gtk_adjustment_changed(pos);
}
label_window_destroy(window);
inc_unlock();
pos = gtk_scrolled_window_get_vadjustment(
GTK_SCROLLED_WINDOW(folderview->scrolledwin));
gtk_adjustment_set_value(pos, height);
+ gtk_adjustment_changed(pos);
}
label_window_destroy(window);
inc_unlock();
GList *list;
FolderItem *item;
FolderView *folderview;
- GtkCTree *ctree;
- GtkCTreeNode *node;
+ GtkCMCTree *ctree;
+ GtkCMCTreeNode *node;
gint new_msgs = 0;
gint former_new_msgs = 0;
gint former_new = 0, former_unread = 0, former_total;
for (list = folderview_list; list != NULL; list = list->next) {
folderview = (FolderView *)list->data;
- ctree = GTK_CTREE(folderview->ctree);
-
+ ctree = GTK_CMCTREE(folderview->ctree);
+ folderview->scanning_folder = folder;
inc_lock();
main_window_lock(folderview->mainwin);
- for (node = GTK_CTREE_NODE(GTK_CLIST(ctree)->row_list);
+ for (node = GTK_CMCTREE_NODE(GTK_CMCLIST(ctree)->row_list);
node != NULL; node = gtkut_ctree_node_next(ctree, node)) {
gchar *str = NULL;
- item = gtk_ctree_node_get_row_data(ctree, node);
+ item = gtk_cmctree_node_get_row_data(ctree, node);
if (!item || !item->path || !item->folder) continue;
if (item->no_select) continue;
if (folder && folder != item->folder) continue;
item->path ? item->path : item->name);
continue;
}
+ if (item->scanning != ITEM_NOT_SCANNING) {
+ debug_print("skipping %s, scanning\n",
+ item->path ? item->path : item->name);
+ continue;
+ }
str = get_scan_str(item);
former_new_msgs += former_new;
STATUSBAR_POP(folderview->mainwin);
}
-
+ folderview->scanning_folder = NULL;
main_window_unlock(folderview->mainwin);
inc_unlock();
}
return folderview_have_marked_children_sub(folderview, item, FALSE);
}
-static void folderview_update_node(FolderView *folderview, GtkCTreeNode *node)
+static void folderview_update_node(FolderView *folderview, GtkCMCTreeNode *node)
{
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
+ GtkCMCTree *ctree = GTK_CMCTREE(folderview->ctree);
GtkStyle *style = NULL;
GtkStyle *color_style = NULL;
FolderItem *item;
gint *col_pos = folderview->col_pos;
SpecialFolderItemType stype;
- item = gtk_ctree_node_get_row_data(ctree, node);
+ item = gtk_cmctree_node_get_row_data(ctree, node);
g_return_if_fail(item != NULL);
- if (!GTK_CTREE_ROW(node)->expanded)
+ if (!GTK_CMCTREE_ROW(node)->expanded)
mark = folderview_have_marked_children(folderview, item);
else
mark = (item->marked_msgs != 0);
name = folder_item_get_name(item);
- if (!GTK_CTREE_ROW(node)->expanded) {
+ if (!GTK_CMCTREE_ROW(node)->expanded) {
add_unread_mark = folderview_have_unread_children(
folderview, item);
add_sub_match_mark = folderview_have_matching_children(
}
gtk_sctree_set_node_info(ctree, node, str, FOLDER_SPACING,
xpm, mask, openxpm, openmask,
- FALSE, GTK_CTREE_ROW(node)->expanded);
+ FALSE, GTK_CMCTREE_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_NEW], "-");
- gtk_ctree_node_set_text(ctree, node, col_pos[F_COL_UNREAD], "-");
- gtk_ctree_node_set_text(ctree, node, col_pos[F_COL_TOTAL], "-");
+ gtk_cmctree_node_set_text(ctree, node, col_pos[F_COL_NEW], "-");
+ gtk_cmctree_node_set_text(ctree, node, col_pos[F_COL_UNREAD], "-");
+ gtk_cmctree_node_set_text(ctree, node, col_pos[F_COL_TOTAL], "-");
} else {
- 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);
+ gtk_cmctree_node_set_text(ctree, node, col_pos[F_COL_NEW], item->new_msgs > 0 ? itos(item->new_msgs) : prefs_common.zero_replacement);
+ gtk_cmctree_node_set_text(ctree, node, col_pos[F_COL_UNREAD], item->unread_msgs > 0 ? itos(item->unread_msgs) : prefs_common.zero_replacement);
+ gtk_cmctree_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) ||
folderview_have_new_children(folderview, item));
}
- gtk_ctree_node_set_foreground(ctree, node, NULL);
+ gtk_cmctree_node_set_foreground(ctree, node, NULL);
if (use_bold) {
GdkColor gdk_color;
}
} else if (use_color) {
style = normal_color_style;
- gtk_ctree_node_set_foreground(ctree, node,
+ gtk_cmctree_node_set_foreground(ctree, node,
&folderview->color_new);
} else if (item->op_count > 0) {
style = bold_tgtfold_style;
style = normal_style;
}
- gtk_ctree_node_set_row_style(ctree, node, style);
+ gtk_cmctree_node_set_row_style(ctree, node, style);
if ((node = gtkut_ctree_find_collapsed_parent(ctree, node)) != NULL)
folderview_update_node(folderview, node);
{
GList *list;
FolderView *folderview;
- GtkCTree *ctree;
- GtkCTreeNode *node;
+ GtkCMCTree *ctree;
+ GtkCMCTreeNode *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);
+ ctree = GTK_CMCTREE(folderview->ctree);
- node = gtk_ctree_find_by_row_data(ctree, NULL, item);
+ node = gtk_cmctree_find_by_row_data(ctree, NULL, item);
if (node) {
item->search_match = matches;
folderview_update_node(folderview, node);
{
FolderItemUpdateData *update_info = (FolderItemUpdateData *)source;
FolderView *folderview = (FolderView *)data;
- GtkCTree *ctree;
- GtkCTreeNode *node;
+ GtkCMCTree *ctree;
+ GtkCMCTreeNode *node;
g_return_val_if_fail(update_info != NULL, TRUE);
g_return_val_if_fail(update_info->item != NULL, TRUE);
g_return_val_if_fail(folderview != NULL, FALSE);
- ctree = GTK_CTREE(folderview->ctree);
+ ctree = GTK_CMCTREE(folderview->ctree);
- node = gtk_ctree_find_by_row_data(ctree, NULL, update_info->item);
+ node = gtk_cmctree_find_by_row_data(ctree, NULL, update_info->item);
if (node) {
if (update_info->update_flags & (F_ITEM_UPDATE_MSGCNT | F_ITEM_UPDATE_NAME))
return FALSE;
}
-static gboolean folderview_gnode_func(GtkCTree *ctree, guint depth,
- GNode *gnode, GtkCTreeNode *cnode,
+static gboolean folderview_gnode_func(GtkCMCTree *ctree, guint depth,
+ GNode *gnode, GtkCMCTreeNode *cnode,
gpointer data)
{
FolderView *folderview = (FolderView *)data;
g_return_val_if_fail(item != NULL, FALSE);
- gtk_ctree_node_set_row_data(ctree, cnode, item);
+ gtk_cmctree_node_set_row_data(ctree, cnode, item);
folderview_update_node(folderview, cnode);
return TRUE;
}
-static void folderview_expand_func(GtkCTree *ctree, GtkCTreeNode *node,
+static void folderview_expand_func(GtkCMCTree *ctree, GtkCMCTreeNode *node,
gpointer data)
{
FolderView *folderview = (FolderView *)data;
FolderItem *item;
- if (GTK_CTREE_ROW(node)->children) {
- item = gtk_ctree_node_get_row_data(ctree, node);
+ if (GTK_CMCTREE_ROW(node)->children) {
+ item = gtk_cmctree_node_get_row_data(ctree, node);
g_return_if_fail(item != NULL);
if (!item->collapsed)
- gtk_ctree_expand(ctree, node);
+ gtk_cmctree_expand(ctree, node);
else
folderview_update_node(folderview, node);
}
}
-static void set_special_folder(GtkCTree *ctree, FolderItem *item,
- GtkCTreeNode *root, GtkCTreeNode **prev)
+static void set_special_folder(GtkCMCTree *ctree, FolderItem *item,
+ GtkCMCTreeNode *root, GtkCMCTreeNode **prev)
{
if (item) {
- GtkCTreeNode *node, *parent, *sibling;
+ GtkCMCTreeNode *node, *parent, *sibling;
- node = gtk_ctree_find_by_row_data(ctree, root, item);
+ node = gtk_cmctree_find_by_row_data(ctree, root, item);
if (!node)
g_warning("%s not found.\n", item->path);
else {
- parent = GTK_CTREE_ROW(node)->parent;
- if (*prev && parent == GTK_CTREE_ROW(*prev)->parent)
- sibling = GTK_CTREE_ROW(*prev)->sibling;
+ parent = GTK_CMCTREE_ROW(node)->parent;
+ if (*prev && parent == GTK_CMCTREE_ROW(*prev)->parent)
+ sibling = GTK_CMCTREE_ROW(*prev)->sibling;
else
- sibling = GTK_CTREE_ROW(parent)->children;
+ sibling = GTK_CMCTREE_ROW(parent)->children;
while (sibling) {
FolderItem *tmp;
- tmp = gtk_ctree_node_get_row_data
+ tmp = gtk_cmctree_node_get_row_data
(ctree, sibling);
if (tmp->stype != F_NORMAL)
- sibling = GTK_CTREE_ROW(sibling)->sibling;
+ sibling = GTK_CMCTREE_ROW(sibling)->sibling;
else
break;
}
if (node != sibling)
- gtk_ctree_move(ctree, node, parent, sibling);
+ gtk_cmctree_move(ctree, node, parent, sibling);
}
*prev = node;
}
}
-static void folderview_sort_folders(FolderView *folderview, GtkCTreeNode *root,
+static void folderview_sort_folders(FolderView *folderview, GtkCMCTreeNode *root,
Folder *folder)
{
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
- GtkCTreeNode *prev = NULL;
+ GtkCMCTree *ctree = GTK_CMCTREE(folderview->ctree);
+ GtkCMCTreeNode *prev = NULL;
- gtk_clist_freeze(GTK_CLIST(ctree));
+ gtk_cmclist_freeze(GTK_CMCLIST(ctree));
gtk_sctree_sort_recursive(ctree, root);
- if (root && GTK_CTREE_ROW(root)->parent) {
- gtk_clist_thaw(GTK_CLIST(ctree));
+ if (root && GTK_CMCTREE_ROW(root)->parent) {
+ gtk_cmclist_thaw(GTK_CMCLIST(ctree));
return;
}
set_special_folder(ctree, folder->inbox, 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));
+ gtk_cmclist_thaw(GTK_CMCLIST(ctree));
}
static void folderview_append_folder(FolderView *folderview, Folder *folder)
{
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
- GtkCTreeNode *root;
+ GtkCMCTree *ctree = GTK_CMCTREE(folderview->ctree);
+ GtkCMCTreeNode *root;
g_return_if_fail(folder != NULL);
root = gtk_sctree_insert_gnode(ctree, NULL, NULL, folder->node,
folderview_gnode_func, folderview);
- gtk_ctree_pre_recursive(ctree, root, folderview_expand_func,
+ gtk_cmctree_pre_recursive(ctree, root, folderview_expand_func,
folderview);
folderview_sort_folders(folderview, root, folder);
}
static void folderview_set_sens_and_popup_menu(FolderView *folderview, gint row,
GdkEventButton *event)
{
- GtkCList *clist = GTK_CLIST(folderview->ctree);
FolderItem *item;
Folder *folder;
FolderViewPopup *fpopup;
- GtkItemFactory *fpopup_factory;
+ GtkActionGroup *action_group;
GtkWidget *popup;
FolderItem *special_trash = NULL, *special_queue = NULL;
PrefsAccount *ac;
+ GtkUIManager *ui_manager = gtk_ui_manager_new();
+
+ if (folderview->ui_manager)
+ g_object_unref(folderview->ui_manager);
- if (row > 0)
- item = gtk_clist_get_row_data(clist, row);
- else
- item = folderview_get_selected_item(folderview);
+ folderview->ui_manager = ui_manager;
+ item = folderview_get_selected_item(folderview);
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 != NULL)
- fpopup_factory = g_hash_table_lookup(folderview->popups, folder->klass->idstr);
+ action_group = g_hash_table_lookup(folderview->popups, folder->klass->idstr);
else {
fpopup = g_hash_table_lookup(folderview_popups, "common");
- fpopup_factory = g_hash_table_lookup(folderview->popups, "common");
+ action_group = g_hash_table_lookup(folderview->popups, "common");
}
+
+ gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
+ MENUITEM_ADDUI_MANAGER(ui_manager, "/", "Popup", "Popup", GTK_UI_MANAGER_MENUBAR)
+ MENUITEM_ADDUI_MANAGER(ui_manager, "/Popup", "FolderViewPopup", "FolderViewPopup", GTK_UI_MANAGER_MENU)
+
+ if (fpopup->add_menuitems)
+ fpopup->add_menuitems(ui_manager, item);
+
+ MENUITEM_ADDUI_MANAGER(ui_manager, "/Popup/FolderViewPopup", "MarkAllRead", "FolderViewPopup/MarkAllRead", GTK_UI_MANAGER_MENUITEM)
+ MENUITEM_ADDUI_MANAGER(ui_manager, "/Popup/FolderViewPopup", "Separator1", "FolderViewPopup/---", GTK_UI_MANAGER_SEPARATOR)
+ MENUITEM_ADDUI_MANAGER(ui_manager, "/Popup/FolderViewPopup", "RunProcessing", "FolderViewPopup/RunProcessing", GTK_UI_MANAGER_MENUITEM)
+ MENUITEM_ADDUI_MANAGER(ui_manager, "/Popup/FolderViewPopup", "SearchFolder", "FolderViewPopup/SearchFolder", GTK_UI_MANAGER_MENUITEM)
+ MENUITEM_ADDUI_MANAGER(ui_manager, "/Popup/FolderViewPopup", "Properties", "FolderViewPopup/Properties", GTK_UI_MANAGER_MENUITEM)
+ MENUITEM_ADDUI_MANAGER(ui_manager, "/Popup/FolderViewPopup", "Processing", "FolderViewPopup/Processing", GTK_UI_MANAGER_MENUITEM)
if (fpopup->set_sensitivity != NULL)
- fpopup->set_sensitivity(fpopup_factory, item);
+ fpopup->set_sensitivity(ui_manager, item);
if (NULL != (ac = account_find_from_item(item))) {
special_trash = account_get_special_folder(ac, F_TRASH);
}
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_create_item(fpopup_factory, &folder_view_trash_popup_entries[0], folderview, 1);
- gtk_item_factory_create_item(fpopup_factory, &folder_view_trash_popup_entries[1], folderview, 1);
- } else if (item != folder->trash && (special_trash == NULL || item != special_trash)
- && !folder_has_parent_of_type(item, F_TRASH)) {
- gtk_item_factory_delete_entry(fpopup_factory, &folder_view_trash_popup_entries[0]);
- gtk_item_factory_delete_entry(fpopup_factory, &folder_view_trash_popup_entries[1]);
- }
+ || folder_has_parent_of_type(item, F_TRASH))) {
+ MENUITEM_ADDUI_MANAGER(ui_manager, "/Popup/FolderViewPopup", "SeparatorTrash", "FolderViewPopup/---", GTK_UI_MANAGER_SEPARATOR)
+ MENUITEM_ADDUI_MANAGER(ui_manager, "/Popup/FolderViewPopup", "EmptyTrash", "FolderViewPopup/EmptyTrash", GTK_UI_MANAGER_MENUITEM)
+ }
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]);
- }
+ || folder_has_parent_of_type(item, F_QUEUE))) {
+ MENUITEM_ADDUI_MANAGER(ui_manager, "/Popup/FolderViewPopup", "SeparatorQueue", "FolderViewPopup/---", GTK_UI_MANAGER_SEPARATOR)
+ MENUITEM_ADDUI_MANAGER(ui_manager, "/Popup/FolderViewPopup", "SendQueue", "FolderViewPopup/SendQueue", GTK_UI_MANAGER_MENUITEM)
+ }
#define SET_SENS(name, sens) \
- menu_set_sensitive(fpopup_factory, name, sens)
+ cm_menu_set_sensitive_full(ui_manager, "Popup/"name, sens)
- SET_SENS("/Mark all read", item->unread_msgs >= 1);
- SET_SENS("/Search folder...", item->total_msgs >= 1 &&
+ SET_SENS("FolderViewPopup/MarkAllRead", item->unread_msgs >= 1);
+ SET_SENS("FolderViewPopup/SearchFolder", item->total_msgs >= 1 &&
folderview->selected == folderview->opened);
- SET_SENS("/Run processing rules", item->prefs->processing &&
- item->total_msgs >= 1);
- SET_SENS("/Properties...", TRUE);
- SET_SENS("/Processing...", item->node->parent != NULL);
+ SET_SENS("FolderViewPopup/Properties", TRUE);
+
+ SET_SENS("FolderViewPopup/RunProcessing", item->prefs->processing &&
+ item->total_msgs >= 1 && !item->processing_pending);
+ SET_SENS("FolderViewPopup/Processing", item->node->parent != NULL &&
+ !item->no_select && !item->processing_pending);
+
if (item == folder->trash || item == special_trash
|| folder_has_parent_of_type(item, F_TRASH)) {
GSList *msglist = folder_item_get_msg_list(item);
- SET_SENS("/Empty trash...", msglist != NULL);
+ SET_SENS("FolderViewPopup/EmptyTrash", 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);
+ SET_SENS("FolderViewPopup/SendQueue", msglist != NULL);
procmsg_msg_list_free(msglist);
}
#undef SET_SENS
- popup = gtk_item_factory_get_widget(fpopup_factory, fpopup->path);
+ popup = gtk_menu_item_get_submenu(GTK_MENU_ITEM(
+ gtk_ui_manager_get_widget(ui_manager, "/Popup/FolderViewPopup")) );
+ g_signal_connect(G_OBJECT(popup), "selection_done",
+ G_CALLBACK(folderview_popup_close),
+ folderview);
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);
+ GtkCMCList *clist = GTK_CMCLIST(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))
+ if (!gtk_sctree_is_hot_spot (GTK_SCTREE(clist), event->x, event->y))
folderview->open_folder = TRUE;
if (event->type == GDK_2BUTTON_PRESS) {
if (clist->selection) {
- GtkCTreeNode *node;
+ GtkCMCTreeNode *node;
- node = GTK_CTREE_NODE(clist->selection->data);
+ node = GTK_CMCTREE_NODE(clist->selection->data);
if (node) {
- gtk_ctree_toggle_expansion(
- GTK_CTREE(ctree),
+ gtk_cmctree_toggle_expansion(
+ GTK_CMCTREE(ctree),
node);
folderview->open_folder = FALSE;
}
if (event->button == 2 || event->button == 3) {
/* right clicked */
if (clist->selection) {
- GtkCTreeNode *node;
+ GtkCMCTreeNode *node;
- node = GTK_CTREE_NODE(clist->selection->data);
+ node = GTK_CMCTREE_NODE(clist->selection->data);
if (node)
prev_row = gtkut_ctree_get_nth_from_node
- (GTK_CTREE(ctree), node);
+ (GTK_CMCTREE(ctree), node);
}
- if (!gtk_clist_get_selection_info(clist, event->x, event->y,
+ if (!gtk_cmclist_get_selection_info(clist, event->x, event->y,
&row, &column))
return FALSE;
if (prev_row != row) {
- gtk_clist_unselect_all(clist);
+ gtk_cmclist_unselect_all(clist);
if (event->button == 2)
folderview_select_node
(folderview,
- gtk_ctree_node_nth(GTK_CTREE(ctree),
+ gtk_cmctree_node_nth(GTK_CMCTREE(ctree),
row));
else
- gtk_clist_select_row(clist, row, column);
+ gtk_cmclist_select_row(clist, row, column);
}
}
static gboolean folderview_button_released(GtkWidget *ctree, GdkEventButton *event,
FolderView *folderview)
{
+ int row = -1, column = -1;
+
if (!event) return FALSE;
+ if (!gtk_cmclist_get_selection_info(GTK_CMCLIST(ctree), event->x, event->y,
+ &row, &column))
+ return FALSE;
if (event->button == 1 && folderview->open_folder == FALSE &&
folderview->opened != NULL) {
- gtkut_ctree_set_focus_row(GTK_CTREE(ctree),
+ gtkut_ctree_set_focus_row(GTK_CMCTREE(ctree),
folderview->opened);
- gtk_ctree_select(GTK_CTREE(ctree), folderview->opened);
+ gtk_cmctree_select(GTK_CMCTREE(ctree), folderview->opened);
}
return FALSE;
}
+#define BREAK_ON_MODIFIER_KEY() \
+ if ((event->state & (GDK_MOD1_MASK|GDK_CONTROL_MASK)) != 0) break
+
static gboolean folderview_key_pressed(GtkWidget *widget, GdkEventKey *event,
FolderView *folderview)
{
switch (event->keyval) {
case GDK_Right:
-#ifndef MAEMO
+#ifndef GENERIC_UMPC
case GDK_Return:
case GDK_KP_Enter:
#endif
folderview->selected);
}
break;
-#ifdef MAEMO
+#ifdef GENERIC_UMPC
case GDK_Return:
- if (folderview->selected && GTK_CTREE_ROW(folderview->selected)->children) {
- gtk_ctree_toggle_expansion(
- GTK_CTREE(folderview->ctree),
+ if (folderview->selected && GTK_CMCTREE_ROW(folderview->selected)->children) {
+ gtk_cmctree_toggle_expansion(
+ GTK_CMCTREE(folderview->ctree),
folderview->selected);
}
break;
#endif
case GDK_space:
+ BREAK_ON_MODIFIER_KEY();
if (folderview->selected) {
if (folderview->opened == folderview->selected &&
(!folderview->summaryview->folder_item ||
typedef struct _PostponedSelectData
{
- GtkCTree *ctree;
- GtkCTreeNode *row;
+ GtkCMCTree *ctree;
+ GtkCMCTreeNode *row;
gint column;
FolderView *folderview;
} PostponedSelectData;
if (folderview->opened) {
FolderItem *olditem;
- olditem = gtk_ctree_node_get_row_data(GTK_CTREE(folderview->ctree),
+ olditem = gtk_cmctree_node_get_row_data(GTK_CMCTREE(folderview->ctree),
folderview->opened);
if (olditem) {
gchar *buf = g_strdup_printf(_("Closing Folder %s..."),
folder_item_close(olditem);
main_window_cursor_normal(folderview->mainwin);
STATUSBAR_POP(folderview->mainwin);
+ if (olditem->folder->klass->item_closed)
+ olditem->folder->klass->item_closed(olditem);
+
}
}
if (folderview->opened &&
- !GTK_CTREE_ROW(folderview->opened)->children)
- gtk_ctree_collapse(GTK_CTREE(folderview->ctree), folderview->opened);
+ !GTK_CMCTREE_ROW(folderview->opened)->children)
+ gtk_cmctree_collapse(GTK_CMCTREE(folderview->ctree), folderview->opened);
folderview->opened = NULL;
}
-static void folderview_selected(GtkCTree *ctree, GtkCTreeNode *row,
+static void folderview_selected(GtkCMCTree *ctree, GtkCMCTreeNode *row,
gint column, FolderView *folderview)
{
static gboolean can_select = TRUE; /* exclusive lock */
FolderItem *item;
gchar *buf;
int res = 0;
- GtkCTreeNode *old_opened = folderview->opened;
+ GtkCMCTreeNode *old_opened = folderview->opened;
START_TIMING("");
folderview->selected = row;
return;
}
+ item = gtk_cmctree_node_get_row_data(ctree, row);
+ if (!item) {
+ END_TIMING();
+ folderview->open_folder = FALSE;
+ return;
+ }
+
if (!can_select || summary_is_locked(folderview->summaryview)) {
if (folderview->opened) {
gtkut_ctree_set_focus_row(ctree, folderview->opened);
- gtk_ctree_select(ctree, folderview->opened);
+ gtk_cmctree_select(ctree, folderview->opened);
}
folderview->open_folder = FALSE;
END_TIMING();
END_TIMING();
return;
}
- item = gtk_ctree_node_get_row_data(ctree, row);
- if (!item || item->no_select) {
- END_TIMING();
- folderview->open_folder = FALSE;
- return;
- }
can_select = FALSE;
if (item->path)
debug_print("Folder %s is selected\n", item->path);
- if (!GTK_CTREE_ROW(row)->children)
- gtk_ctree_expand(ctree, row);
+ if (!GTK_CMCTREE_ROW(row)->children)
+ gtk_cmctree_expand(ctree, row);
/* ungrab the mouse event */
if (GTK_WIDGET_HAS_GRAB(ctree)) {
}
/* Open Folder */
+ /* TODO: wwp: avoid displaying (null) in the status bar */
buf = g_strdup_printf(_("Opening Folder %s..."), item->path ?
item->path : "(null)");
debug_print("%s\n", buf);
main_window_cursor_wait(folderview->mainwin);
- res = folder_item_open(item);
- if (res == -1) {
+ if (folderview->scanning_folder == item->folder) {
+ res = -2;
+ } else {
+ res = folder_item_open(item);
+ }
+
+ if (res == -1 && item->no_select == FALSE) {
main_window_cursor_normal(folderview->mainwin);
STATUSBAR_POP(folderview->mainwin);
can_select = TRUE;
END_TIMING();
return;
- } else if (res == -2) {
+ } else if (res == -2 && item->no_select == FALSE) {
PostponedSelectData *data = g_new0(PostponedSelectData, 1);
data->ctree = ctree;
data->row = row;
if (!opened) {
gtkut_ctree_set_focus_row(ctree, old_opened);
- gtk_ctree_select(ctree, old_opened);
+ gtk_cmctree_select(ctree, old_opened);
folderview->opened = old_opened;
} else {
folderview->opened = row;
- if (gtk_ctree_node_is_visible(ctree, row)
+ if (gtk_cmctree_node_is_visible(ctree, row)
!= GTK_VISIBILITY_FULL)
- gtk_ctree_node_moveto(ctree, row, -1, 0.5, 0);
+ gtk_cmctree_node_moveto(ctree, row, -1, 0.5, 0);
}
STATUSBAR_POP(folderview->mainwin);
END_TIMING();
}
-static void folderview_tree_expanded(GtkCTree *ctree, GtkCTreeNode *node,
+static void folderview_tree_expanded(GtkCMCTree *ctree, GtkCMCTreeNode *node,
FolderView *folderview)
{
FolderItem *item;
- item = gtk_ctree_node_get_row_data(ctree, node);
+ item = gtk_cmctree_node_get_row_data(ctree, node);
g_return_if_fail(item != NULL);
item->collapsed = FALSE;
folderview_update_node(folderview, node);
}
-static void folderview_tree_collapsed(GtkCTree *ctree, GtkCTreeNode *node,
+static void folderview_tree_collapsed(GtkCMCTree *ctree, GtkCMCTreeNode *node,
FolderView *folderview)
{
FolderItem *item;
- item = gtk_ctree_node_get_row_data(ctree, node);
+ item = gtk_cmctree_node_get_row_data(ctree, node);
g_return_if_fail(item != NULL);
item->collapsed = TRUE;
folderview_update_node(folderview, node);
{
if (!folderview->opened) return;
- gtk_ctree_select(GTK_CTREE(folderview->ctree), folderview->opened);
+ gtk_cmctree_select(GTK_CMCTREE(folderview->ctree), folderview->opened);
}
-static void folderview_col_resized(GtkCList *clist, gint column, gint width,
+static void folderview_col_resized(GtkCMCList *clist, gint column, gint width,
FolderView *folderview)
{
FolderColumnType type = folderview->col_state[column].type;
static void folderview_create_folder_node(FolderView *folderview, FolderItem *item)
{
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
+ GtkCMCTree *ctree = GTK_CMCTREE(folderview->ctree);
gchar *text[N_FOLDER_COLS] = {NULL, "0", "0", "0"};
- GtkCTreeNode *node, *parent_node;
+ GtkCMCTreeNode *node, *parent_node;
gint *col_pos = folderview->col_pos;
FolderItemUpdateData hookdata;
- parent_node = gtk_ctree_find_by_row_data(ctree, NULL, folder_item_parent(item));
+ parent_node = gtk_cmctree_find_by_row_data(ctree, NULL, folder_item_parent(item));
if (parent_node == NULL)
return;
- gtk_clist_freeze(GTK_CLIST(ctree));
+ gtk_cmclist_freeze(GTK_CMCLIST(ctree));
text[col_pos[F_COL_FOLDER]] = item->name;
node = gtk_sctree_insert_node(ctree, parent_node, NULL, text,
folderxpm, folderxpmmask,
folderopenxpm, folderopenxpmmask,
FALSE, FALSE);
- gtk_ctree_expand(ctree, parent_node);
- gtk_ctree_node_set_row_data(ctree, node, item);
+ gtk_cmctree_expand(ctree, parent_node);
+ gtk_cmctree_node_set_row_data(ctree, node, item);
if (normal_style)
- gtk_ctree_node_set_row_style(ctree, node, normal_style);
+ gtk_cmctree_node_set_row_style(ctree, node, normal_style);
folderview_sort_folders(folderview, parent_node, item->folder);
hookdata.item = item;
hookdata.msg = NULL;
hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST, &hookdata);
- gtk_clist_thaw(GTK_CLIST(ctree));
+ gtk_cmclist_thaw(GTK_CMCLIST(ctree));
}
-static void folderview_empty_trash_cb(FolderView *folderview, guint action,
- GtkWidget *widget)
+static void folderview_empty_trash_cb(GtkAction *action, gpointer data)
{
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
+ FolderView *folderview = (FolderView *)data;
+ GtkCMCTree *ctree = GTK_CMCTREE(folderview->ctree);
FolderItem *item;
GSList *mlist = NULL;
GSList *cur = NULL;
PrefsAccount *ac;
if (!folderview->selected) return;
- item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
+ item = gtk_cmctree_node_get_row_data(ctree, folderview->selected);
g_return_if_fail(item != NULL);
g_return_if_fail(item->folder != NULL);
folder_item_remove_all_msg(item);
}
-static void folderview_send_queue_cb(FolderView *folderview, guint action,
- GtkWidget *widget)
+static void folderview_send_queue_cb(GtkAction *action, gpointer data)
{
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
+ FolderView *folderview = (FolderView *)data;
+ GtkCMCTree *ctree = GTK_CMCTREE(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);
+ item = gtk_cmctree_node_get_row_data(ctree, folderview->selected);
g_return_if_fail(item != NULL);
g_return_if_fail(item->folder != NULL);
alertpanel_error_log(_("Some errors occurred while "
"sending queued messages."));
else {
- gchar *tmp = g_strdup_printf(_("Some errors occurred "
+ alertpanel_error_log(_("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)
+static void folderview_search_cb(GtkAction *action, gpointer data)
{
+ FolderView *folderview = (FolderView *)data;
summary_search(folderview->summaryview);
}
-static void folderview_run_processing_cb(FolderView *folderview, guint action,
- GtkWidget *widget)
+static void folderview_run_processing_cb(GtkAction *action, gpointer data)
{
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
+ FolderView *folderview = (FolderView *)data;
+ GtkCMCTree *ctree = GTK_CMCTREE(folderview->ctree);
FolderItem *item;
if (!folderview->selected) return;
- item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
+ item = gtk_cmctree_node_get_row_data(ctree, folderview->selected);
g_return_if_fail(item != NULL);
g_return_if_fail(item->folder != NULL);
+ item->processing_pending = TRUE;
folder_item_apply_processing(item);
+ item->processing_pending = FALSE;
}
-static void folderview_property_cb(FolderView *folderview, guint action,
- GtkWidget *widget)
+static void folderview_property_cb(GtkAction *action, gpointer data)
{
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
+ FolderView *folderview = (FolderView *)data;
+ GtkCMCTree *ctree = GTK_CMCTREE(folderview->ctree);
FolderItem *item;
if (!folderview->selected) return;
- item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
+ item = gtk_cmctree_node_get_row_data(ctree, folderview->selected);
g_return_if_fail(item != NULL);
g_return_if_fail(item->folder != NULL);
prefs_folder_item_open(item);
}
-static void folderview_recollapse_nodes(FolderView *folderview, GtkCTreeNode *node)
+static void folderview_recollapse_nodes(FolderView *folderview, GtkCMCTreeNode *node)
{
GSList *list = NULL;
GSList *done = NULL;
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
+ GtkCMCTree *ctree = GTK_CMCTREE(folderview->ctree);
for (list = folderview->nodes_to_recollapse; list != NULL; list = g_slist_next(list)) {
- if (!gtkut_ctree_node_is_parent(GTK_CTREE_NODE(list->data), node)
+ if (!gtkut_ctree_node_is_parent(GTK_CMCTREE_NODE(list->data), node)
&& list->data != node) {
- gtk_ctree_collapse(ctree, GTK_CTREE_NODE(list->data));
- done = g_slist_append(done, GTK_CTREE_NODE(list->data));
+ gtk_cmctree_collapse(ctree, GTK_CMCTREE_NODE(list->data));
+ done = g_slist_append(done, GTK_CMCTREE_NODE(list->data));
}
}
for (list = done; list != NULL; list = g_slist_next(list)) {
{
FolderItem *from_parent = NULL;
FolderItem *new_folder = NULL;
- GtkCTreeNode *src_node = NULL;
+ GtkCMCTreeNode *src_node = NULL;
gchar *buf;
gint status;
g_return_if_fail(from_folder != NULL);
g_return_if_fail(to_folder != NULL);
- src_node = gtk_ctree_find_by_row_data(GTK_CTREE(folderview->ctree), NULL, from_folder);
+ src_node = gtk_cmctree_find_by_row_data(GTK_CMCTREE(folderview->ctree), NULL, from_folder);
from_parent = folder_item_parent(from_folder);
if (prefs_common.warn_dnd) {
buf = g_strdup_printf(copy ? _("Do you really want to copy folder '%s' in '%s' ?"):
- _("Do you really want to make folder '%s' a sub-folder of '%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,
folder_item_update_recursive(new_folder, F_ITEM_UPDATE_MSGCNT);
folderview_sort_folders(folderview,
- gtk_ctree_find_by_row_data(GTK_CTREE(folderview->ctree),
+ gtk_cmctree_find_by_row_data(GTK_CMCTREE(folderview->ctree),
NULL, to_folder), new_folder->folder);
folderview_select(folderview, new_folder);
} else {
gtk_widget_set_sensitive(GTK_WIDGET(folderview->ctree), TRUE);
}
-static gint folderview_clist_compare(GtkCList *clist,
+static gint folderview_clist_compare(GtkCMCList *clist,
gconstpointer ptr1, gconstpointer ptr2)
{
- FolderItem *item1 = ((GtkCListRow *)ptr1)->data;
- FolderItem *item2 = ((GtkCListRow *)ptr2)->data;
+ FolderItem *item1 = ((GtkCMCListRow *)ptr1)->data;
+ FolderItem *item2 = ((GtkCMCListRow *)ptr2)->data;
if (item1->order > 0 && item2->order > 0) // if we have an order item, use it
{
return g_utf8_collate(item1->name, item2->name);
}
-static void folderview_processing_cb(FolderView *folderview, guint action,
- GtkWidget *widget)
+static void folderview_processing_cb(GtkAction *action, gpointer data)
{
- GtkCTree *ctree = GTK_CTREE(folderview->ctree);
+ FolderView *folderview = (FolderView *)data;
+ GtkCMCTree *ctree = GTK_CMCTREE(folderview->ctree);
FolderItem *item;
gchar *id, *title;
if (!folderview->selected) return;
- item = gtk_ctree_node_get_row_data(ctree, folderview->selected);
+ item = gtk_cmctree_node_get_row_data(ctree, folderview->selected);
g_return_if_fail(item != NULL);
g_return_if_fail(item->folder != NULL);
}
}
-static gchar *last_font = NULL;
+static gchar *last_smallfont = NULL;
+static gchar *last_normalfont = NULL;
+static gchar *last_boldfont = NULL;
void folderview_reflect_prefs_pixmap_theme(FolderView *folderview)
{
/* force reinit */
- g_free(last_font);
- last_font = NULL;
-
+ g_free(last_smallfont);
+ last_smallfont = NULL;
+ g_free(last_normalfont);
+ last_normalfont = NULL;
+ g_free(last_boldfont);
+ last_boldfont = NULL;
}
void folderview_reflect_prefs(void)
{
- gboolean update_font = TRUE;
+ gboolean update_font = FALSE;
FolderView *folderview = mainwindow_get_mainwindow()->folderview;
FolderItem *item = folderview_get_selected_item(folderview);
GtkAdjustment *pos = gtk_scrolled_window_get_vadjustment(
GTK_SCROLLED_WINDOW(folderview->scrolledwin));
gint height = pos->value;
- if (last_font && !strcmp(last_font, NORMAL_FONT))
- update_font = FALSE;
+ if (!last_smallfont || strcmp(last_smallfont, SMALL_FONT) ||
+ !last_normalfont || strcmp(last_normalfont, NORMAL_FONT) ||
+ !last_boldfont || strcmp(last_boldfont, BOLD_FONT))
+ update_font = TRUE;
- g_free(last_font);
- last_font = g_strdup(NORMAL_FONT);
+ g_free(last_smallfont);
+ last_smallfont = g_strdup(SMALL_FONT);
+ g_free(last_normalfont);
+ last_normalfont = g_strdup(NORMAL_FONT);
+ g_free(last_boldfont);
+ last_boldfont = g_strdup(BOLD_FONT);
if (update_font) {
normal_style = normal_color_style = bold_style =
folderview_init(folderview);
}
- gtk_clist_freeze(GTK_CLIST(folderview->ctree));
+ gtk_cmclist_freeze(GTK_CMCLIST(folderview->ctree));
folderview_column_set_titles(folderview);
folderview_set_all();
G_CALLBACK(folderview_selected), folderview);
if (item) {
- GtkCTreeNode *node = gtk_ctree_find_by_row_data(
- GTK_CTREE(folderview->ctree), NULL, item);
+ GtkCMCTreeNode *node = gtk_cmctree_find_by_row_data(
+ GTK_CMCTREE(folderview->ctree), NULL, item);
folderview_select(folderview, item);
folderview->open_folder = FALSE;
pos = gtk_scrolled_window_get_vadjustment(
GTK_SCROLLED_WINDOW(folderview->scrolledwin));
gtk_adjustment_set_value(pos, height);
- gtk_clist_thaw(GTK_CLIST(folderview->ctree));
+ gtk_adjustment_changed(pos);
+ gtk_cmclist_thaw(GTK_CMCLIST(folderview->ctree));
}
static void drag_state_stop(FolderView *folderview)
if (folderview->drag_node) {
folderview_recollapse_nodes(folderview, folderview->drag_node);
if (folderview->drag_item->collapsed) {
- gtk_ctree_expand(GTK_CTREE(folderview->ctree), folderview->drag_node);
+ gtk_cmctree_expand(GTK_CMCTREE(folderview->ctree), folderview->drag_node);
folderview->nodes_to_recollapse = g_slist_append
(folderview->nodes_to_recollapse, folderview->drag_node);
}
return FALSE;
}
-static void drag_state_start(FolderView *folderview, GtkCTreeNode *node, FolderItem *item)
+static void drag_state_start(FolderView *folderview, GtkCMCTreeNode *node, FolderItem *item)
{
/* the idea is that we call drag_state_start() whenever we want expansion to
* start after 'prefs_common.hover_time' msecs. if we want to cancel expansion,
folderview->drag_item = item;
}
}
-
+#ifndef GENERIC_UMPC
static void folderview_start_drag(GtkWidget *widget, gint button, GdkEvent *event,
FolderView *folderview)
{
GDK_ACTION_MOVE|GDK_ACTION_COPY|GDK_ACTION_DEFAULT, button, event);
gtk_drag_set_icon_default(context);
}
-
+#endif
static void folderview_drag_data_get(GtkWidget *widget,
GdkDragContext *drag_context,
GtkSelectionData *selection_data,
GList *cur;
gchar *source = NULL;
if (info == TARGET_DUMMY) {
- for (cur = GTK_CLIST(folderview->ctree)->selection;
+ for (cur = GTK_CMCLIST(folderview->ctree)->selection;
cur != NULL; cur = cur->next) {
- item = gtk_ctree_node_get_row_data
- (GTK_CTREE(folderview->ctree),
- GTK_CTREE_NODE(cur->data));
+ item = gtk_cmctree_node_get_row_data
+ (GTK_CMCTREE(folderview->ctree),
+ GTK_CMCTREE_NODE(cur->data));
if (item) {
source = g_strdup_printf ("FROM_OTHER_FOLDER%s", folder_item_get_identifier(item));
gtk_selection_data_set(selection_data,
if (hookdata->update_flags & FOLDER_ADD_FOLDERITEM)
folderview_create_folder_node(folderview, hookdata->item);
else if (hookdata->update_flags & FOLDER_RENAME_FOLDERITEM) {
- GtkCTreeNode *node = gtk_ctree_find_by_row_data(GTK_CTREE(ctree),
+ GtkCMCTreeNode *node = gtk_cmctree_find_by_row_data(GTK_CMCTREE(ctree),
NULL, folder_item_parent(hookdata->item));
folderview_sort_folders(folderview, node, hookdata->folder);
} else if (hookdata->update_flags & FOLDER_REMOVE_FOLDERITEM) {
- GtkCTreeNode *node;
+ GtkCMCTreeNode *node;
- node = gtk_ctree_find_by_row_data(GTK_CTREE(ctree), NULL, hookdata->item);
+ node = gtk_cmctree_find_by_row_data(GTK_CMCTREE(ctree), NULL, hookdata->item);
if (node != NULL) {
- gtk_ctree_remove_node(GTK_CTREE(ctree), node);
+ gtk_cmctree_remove_node(GTK_CMCTREE(ctree), node);
if (folderview->selected == node)
folderview->selected = NULL;
if (folderview->opened == node)
{
gint row, column;
FolderItem *item = NULL, *src_item = NULL;
- GtkCTreeNode *node = NULL;
+ GtkCMCTreeNode *node = NULL;
gboolean acceptable = FALSE;
GtkAdjustment *pos = gtk_scrolled_window_get_vadjustment(
GTK_SCROLLED_WINDOW(folderview->scrolledwin));
int height = (int)pos->page_size;
int total_height = (int)pos->upper;
int vpos = (int) pos->value;
-
- if (gtk_clist_get_selection_info
- (GTK_CLIST(widget), x - 24, y - 24, &row, &column)) {
+ int offset = prefs_common.show_col_headers ? 24:0;
+
+ if (gtk_cmclist_get_selection_info
+ (GTK_CMCLIST(widget), x - offset, y - offset, &row, &column)) {
GtkWidget *srcwidget;
- if (y > height - 24 && height + vpos < total_height)
- gtk_adjustment_set_value(pos, (vpos+5 > height ? height : vpos+5));
-
- if (y < 48 && y > 0)
+ if (y > height - 24 && height + vpos < total_height) {
+ gtk_adjustment_set_value(pos, (vpos+5 > total_height ? total_height : vpos+5));
+ gtk_adjustment_changed(pos);
+ }
+ if (y < 48 && y > 0) {
gtk_adjustment_set_value(pos, (vpos-5 < 0 ? 0 : vpos-5));
+ gtk_adjustment_changed(pos);
+ }
- node = gtk_ctree_node_nth(GTK_CTREE(widget), row);
- item = gtk_ctree_node_get_row_data(GTK_CTREE(widget), node);
+ node = gtk_cmctree_node_nth(GTK_CMCTREE(widget), row);
+ item = gtk_cmctree_node_get_row_data(GTK_CMCTREE(widget), node);
src_item = folderview->summaryview->folder_item;
srcwidget = gtk_drag_get_source_widget(context);
g_signal_handlers_block_by_func
(G_OBJECT(widget),
G_CALLBACK(folderview_selected), folderview);
- gtk_ctree_select(GTK_CTREE(widget), node);
+ gtk_cmctree_select(GTK_CMCTREE(widget), node);
g_signal_handlers_unblock_by_func
(G_OBJECT(widget),
G_CALLBACK(folderview_selected), folderview);
GDK_ACTION_COPY : GDK_ACTION_MOVE) , time);
} else {
if (folderview->opened)
- gtk_ctree_select(GTK_CTREE(widget), folderview->opened);
+ gtk_cmctree_select(GTK_CMCTREE(widget), folderview->opened);
gdk_drag_status(context, 0, time);
}
FolderView *folderview)
{
drag_state_stop(folderview);
- gtk_ctree_select(GTK_CTREE(widget), folderview->opened);
+ gtk_cmctree_select(GTK_CMCTREE(widget), folderview->opened);
}
static void free_info (gpointer stuff, gpointer data)
{
gint row, column;
FolderItem *item = NULL, *src_item;
- GtkCTreeNode *node;
+ GtkCMCTreeNode *node;
+ int offset = prefs_common.show_col_headers ? 24:0;
if (info == TARGET_DUMMY) {
drag_state_stop(folderview);
if ((void *)strstr(data->data, "FROM_OTHER_FOLDER") != (void *)data->data) {
/* comes from summaryview */
- if (gtk_clist_get_selection_info
- (GTK_CLIST(widget), x - 24, y - 24, &row, &column) == 0)
+ if (gtk_cmclist_get_selection_info
+ (GTK_CMCLIST(widget), x - offset, y - offset, &row, &column) == 0)
return;
- node = gtk_ctree_node_nth(GTK_CTREE(widget), row);
- item = gtk_ctree_node_get_row_data(GTK_CTREE(widget), node);
+ node = gtk_cmctree_node_nth(GTK_CMCTREE(widget), row);
+ item = gtk_cmctree_node_get_row_data(GTK_CMCTREE(widget), node);
src_item = folderview->summaryview->folder_item;
+ if (item->no_select) {
+ alertpanel_error(_("The destination folder can only be used to "
+ "store subfolders."));
+ return;
+ }
/* re-check (due to acceptable possibly set for folder moves */
if (!(item && item->folder && item->path && !item->no_select &&
src_item && src_item != item && FOLDER_CLASS(item->folder)->copy_msg != NULL)) {
gboolean copy = (drag_context->action == GDK_ACTION_COPY);
source = data->data + 17;
- if (gtk_clist_get_selection_info
- (GTK_CLIST(widget), x - 24, y - 24, &row, &column) == 0
+ if (gtk_cmclist_get_selection_info
+ (GTK_CMCLIST(widget), x - offset, y - offset, &row, &column) == 0
|| *source == 0) {
gtk_drag_finish(drag_context, FALSE, FALSE, time);
return;
}
- node = gtk_ctree_node_nth(GTK_CTREE(widget), row);
- item = gtk_ctree_node_get_row_data(GTK_CTREE(widget), node);
+ node = gtk_cmctree_node_nth(GTK_CMCTREE(widget), row);
+ item = gtk_cmctree_node_get_row_data(GTK_CMCTREE(widget), node);
src_item = folder_find_item_from_identifier(source);
folder_is_normal =
!folder_has_parent_of_type(src_item, F_DRAFT) &&
!folder_has_parent_of_type(src_item, F_QUEUE) &&
!folder_has_parent_of_type(src_item, F_TRASH);
- if (!item || item->no_select || !src_item
- || !folder_is_normal) {
+ if (!item || !src_item || !folder_is_normal) {
gtk_drag_finish(drag_context, FALSE, FALSE, time);
return;
}
}
folderview->nodes_to_recollapse = NULL;
} else if (info == TARGET_MAIL_URI_LIST) {
- if (gtk_clist_get_selection_info
- (GTK_CLIST(widget), x - 24, y - 24, &row, &column) == 0)
+ if (gtk_cmclist_get_selection_info
+ (GTK_CMCLIST(widget), x - offset, y - offset, &row, &column) == 0)
return;
- node = gtk_ctree_node_nth(GTK_CTREE(widget), row);
+ node = gtk_cmctree_node_nth(GTK_CMCTREE(widget), row);
if (!node) {
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);
+ item = gtk_cmctree_node_get_row_data(GTK_CMCTREE(widget), node);
if (!item) {
gtk_drag_finish(drag_context, FALSE, FALSE, time);
debug_print("no item\n");
for (folderviews = folderview_list; folderviews != NULL; folderviews = g_list_next(folderviews)) {
FolderView *folderview = folderviews->data;
- GtkItemFactory *factory;
+ GtkActionGroup *factory;
- factory = create_ifactory(folderview, fpopup);
+ factory = create_action_group(folderview, fpopup);
g_hash_table_insert(folderview->popups, fpopup->klass, factory);
}
g_hash_table_insert(folderview_popups, fpopup->klass, fpopup);
{
GList *folderviews;
+
for (folderviews = folderview_list; folderviews != NULL; folderviews = g_list_next(folderviews)) {
FolderView *folderview = folderviews->data;
projects / claws.git / blobdiff