[balsa] Declare LibBalsaMailbox derivable
- From: Peter Bloomfield <peterb src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [balsa] Declare LibBalsaMailbox derivable
- Date: Thu, 4 Jul 2019 02:43:19 +0000 (UTC)
commit 362d76faa0029167f4dbb75a484620c7b7e255cb
Author: Peter Bloomfield <PeterBloomfield bellsouth net>
Date: Wed Jul 3 22:39:26 2019 -0400
Declare LibBalsaMailbox derivable
Use G_DECLARE_DERIVABLE_TYPE to declare LibBalsaMailbox
and provide and use the necessary getters and setters.
Also move mailbox locking to a GRecMutex in the
LibBalsaMailboxPrivate structure, instead of our home-brewed
lock.
* libbalsa/filter-file.c (libbalsa_mailbox_filters_load_config),
(libbalsa_mailbox_filters_save_config):
* libbalsa/libbalsa.c:
* libbalsa/mailbox-filter.c (config_mailbox_filters_load):
* libbalsa/mailbox.c (libbalsa_mailbox_class_init),
(libbalsa_mailbox_init), (libbalsa_mailbox_dispose),
(get_from_field), (libbalsa_mailbox_index_entry_clear),
(libbalsa_mailbox_index_set_flags), (libbalsa_mailbox_finalize),
(libbalsa_mailbox_free_mindex), (libbalsa_mailbox_open),
(libbalsa_mailbox_is_open), (libbalsa_mailbox_close),
(libbalsa_mailbox_set_unread_messages_flag),
(libbalsa_mailbox_check), (lbm_changed_idle_cb),
(lbm_changed_schedule_idle), (libbalsa_mailbox_changed),
(lbm_run_filters_on_reception_idle_cb),
(libbalsa_mailbox_run_filters_on_reception),
(libbalsa_mailbox_save_config),
(libbalsa_mailbox_real_messages_copy),
(libbalsa_mailbox_real_sort), (libbalsa_mailbox_real_save_config),
(libbalsa_mailbox_real_load_config),
(libbalsa_mailbox_type_from_path), (lbm_node_has_unseen_child),
(lbm_msgno_changed_expunged_cb), (lbm_msgno_row_changed),
(lbm_msgnos_changed_idle_cb), (lbm_msgno_changed),
(libbalsa_mailbox_msgno_changed), (lbm_need_threading_idle_cb),
(libbalsa_mailbox_msgno_inserted),
(libbalsa_mailbox_msgno_filt_in), (libbalsa_mailbox_msgno_removed),
(libbalsa_mailbox_msgno_filt_out), (lbm_msgno_filt_check),
(libbalsa_mailbox_msgno_filt_check),
(libbalsa_mailbox_search_iter_view), (libbalsa_mailbox_msgno_find),
(libbalsa_mailbox_sync_storage), (lbm_cache_message),
(libbalsa_mailbox_get_message),
(libbalsa_mailbox_messages_change_flags),
(libbalsa_mailbox_set_view_filter),
(libbalsa_mailbox_make_view_filter_persistent),
(libbalsa_mailbox_real_can_do), (lbm_check_and_sort),
(lbm_set_threading), (libbalsa_mailbox_view_free), (lbm_get_view),
(libbalsa_mailbox_set_identity_name),
(libbalsa_mailbox_set_threading_type),
(libbalsa_mailbox_set_subject_gather),
(libbalsa_mailbox_set_sort_type),
(libbalsa_mailbox_set_sort_field), (libbalsa_mailbox_set_show),
(libbalsa_mailbox_set_subscribe), (libbalsa_mailbox_set_exposed),
(libbalsa_mailbox_set_open), (libbalsa_mailbox_set_filter),
(libbalsa_mailbox_set_crypto_mode), (libbalsa_mailbox_set_unread),
(libbalsa_mailbox_set_total), (libbalsa_mailbox_set_mtime),
(libbalsa_mailbox_set_position),
(libbalsa_mailbox_get_identity_name),
(libbalsa_mailbox_get_threading_type),
(libbalsa_mailbox_get_subject_gather),
(libbalsa_mailbox_get_sort_type),
(libbalsa_mailbox_get_sort_field), (libbalsa_mailbox_get_show),
(libbalsa_mailbox_get_subscribe), (libbalsa_mailbox_get_exposed),
(libbalsa_mailbox_get_open), (libbalsa_mailbox_get_filter),
(libbalsa_mailbox_get_crypto_mode), (libbalsa_mailbox_get_unread),
(libbalsa_mailbox_get_total), (libbalsa_mailbox_get_mtime),
(libbalsa_mailbox_get_position), (mailbox_model_init),
(mailbox_model_get_flags), (mailbox_model_get_n_columns),
(mailbox_model_get_column_type), (mailbox_model_get_iter),
(mailbox_model_get_path_helper), (mailbox_model_get_path),
(lbm_get_index_entry_expunged_cb), (lbm_get_index_entry_real),
(lbm_get_index_entry), (mailbox_model_get_value),
(mailbox_model_iter_next), (mailbox_model_iter_children),
(mailbox_model_iter_has_child), (mailbox_model_iter_n_children),
(mailbox_model_iter_nth_child), (mailbox_model_iter_parent),
(mailbox_drag_source_init), (mailbox_row_draggable),
(mailbox_drag_data_delete), (mailbox_drag_data_get),
(mailbox_sortable_init), (mailbox_compare_from),
(mailbox_compare_subject), (mailbox_compare_date),
(mailbox_get_thread_date_traverse_func), (mailbox_get_thread_date),
(mailbox_compare_thread_date), (mailbox_compare_size),
(mailbox_compare_func), (lbm_has_valid_index_entry), (lbm_sort),
(mailbox_get_sort_column_id), (mailbox_set_sort_column_id),
(mailbox_set_sort_func), (mailbox_set_default_sort_func),
(mailbox_has_default_sort_func),
(libbalsa_mailbox_unlink_and_prepend), (lbm_update_msg_tree),
(lbm_set_msg_tree), (libbalsa_mailbox_set_msg_tree),
(lbm_try_reassemble), (libbalsa_mailbox_try_reassemble),
(libbalsa_mailbox_msgno_get_status),
(libbalsa_mailbox_msgno_get_subject),
(libbalsa_mailbox_msgno_update_attach), (lbm_check_idle),
(lbm_queue_check), (libbalsa_mailbox_search_iter_step),
(libbalsa_mailbox_can_move_duplicates),
(libbalsa_mailbox_move_duplicates), (libbalsa_mailbox_lock_store),
(libbalsa_mailbox_unlock_store), (libbalsa_mailbox_cache_message),
(lbm_set_color), (libbalsa_mailbox_set_foreground),
(libbalsa_mailbox_set_background),
(libbalsa_mailbox_test_can_reach), (libbalsa_mailbox_get_filters),
(libbalsa_mailbox_get_name), (libbalsa_mailbox_get_url),
(libbalsa_mailbox_get_unread_messages),
(libbalsa_mailbox_get_first_unread),
(libbalsa_mailbox_get_view_filter),
(libbalsa_mailbox_get_msg_tree),
(libbalsa_mailbox_get_msg_tree_changed),
(libbalsa_mailbox_get_state), (libbalsa_mailbox_get_index_entry),
(libbalsa_mailbox_get_view), (libbalsa_mailbox_get_stamp),
(libbalsa_mailbox_get_open_ref), (libbalsa_mailbox_get_readonly),
(libbalsa_mailbox_get_config_prefix),
(libbalsa_mailbox_get_has_unread_messages),
(libbalsa_mailbox_clear_unread_messages),
(libbalsa_mailbox_set_filters), (libbalsa_mailbox_set_url),
(libbalsa_mailbox_set_first_unread),
(libbalsa_mailbox_set_msg_tree_changed),
(libbalsa_mailbox_set_is_directory),
(libbalsa_mailbox_set_readonly),
(libbalsa_mailbox_set_no_reassemble), (libbalsa_mailbox_set_name),
(libbalsa_mailbox_set_view),
(libbalsa_mailbox_set_has_unread_messages),
(libbalsa_mailbox_set_config_prefix),
(libbalsa_mailbox_add_to_unread_messages), (libbalsa_lock_mailbox),
(libbalsa_unlock_mailbox):
* libbalsa/mailbox.h:
* libbalsa/mailbox_imap.c (message_info_from_msgno),
(libbalsa_mailbox_imap_init), (libbalsa_mailbox_imap_finalize),
(libbalsa_mailbox_imap_update_url), (mi_get_imsg),
(idle_unread_update_cb), (imap_exists_idle),
(libbalsa_mailbox_imap_get_selected_handle), (lbm_imap_get_unseen),
(libbalsa_mailbox_imap_open),
(libbalsa_mailbox_imap_get_matchings),
(libbalsa_mailbox_imap_load_config),
(libbalsa_mailbox_imap_force_disconnect),
(libbalsa_mailbox_imap_reconnect), (lbmi_get_imap_sort_key),
(libbalsa_mailbox_imap_set_threading), (lbmi_compare_func),
(libbalsa_mailbox_imap_sort):
* libbalsa/mailbox_local.c (libbalsa_mailbox_local_init),
(libbalsa_mailbox_local_set_path),
(libbalsa_mailbox_local_load_message),
(libbalsa_mailbox_local_load_config), (lbm_local_save_tree),
(lbm_local_restore_tree), (lbm_local_save_tree_real),
(libbalsa_mailbox_local_close_mailbox), (message_match_real),
(lbml_load_messages_idle_cb), (lbml_set_threading),
(libbalsa_mailbox_local_set_threading),
(lbm_local_update_view_filter),
(libbalsa_mailbox_local_prepare_threading), (lbml_info_setup),
(lbml_thread_messages), (lbml_unthread_message),
(lbml_threading_flat), (lbm_local_sync_real),
(libbalsa_mailbox_local_messages_change_flags):
* libbalsa/mailbox_local.h:
* libbalsa/mailbox_maildir.c (libbalsa_mailbox_maildir_new),
(lbm_maildir_remove_files), (lbm_maildir_parse),
(libbalsa_mailbox_maildir_open), (libbalsa_mailbox_maildir_check),
(libbalsa_mailbox_maildir_sync):
* libbalsa/mailbox_mbox.c (libbalsa_mailbox_mbox_new), (mbox_lock),
(mbox_unlock), (libbalsa_mailbox_mbox_open),
(libbalsa_mailbox_mbox_check), (libbalsa_mailbox_mbox_sync):
* libbalsa/mailbox_mh.c (libbalsa_mailbox_mh_new),
(lbm_mh_parse_mailbox), (libbalsa_mailbox_mh_open),
(libbalsa_mailbox_mh_check), (libbalsa_mailbox_mh_sync):
* libbalsa/mailbox_pop3.c (libbalsa_mailbox_pop3_new),
(message_cb), (libbalsa_mailbox_pop3_startup), (update_msg_list),
(libbalsa_mailbox_pop3_check), (libbalsa_mailbox_pop3_set_inbox),
(libbalsa_mailbox_pop3_set_msg_size_limit):
* libbalsa/message.c (libbalsa_message_change_flags):
* libbalsa/send.c (lbs_message_queue_real),
(lbs_check_reachable_cb), (balsa_send_message_success):
* libinit_balsa/assistant_page_directory.c (unconditional_mailbox):
* libinit_balsa/assistant_page_user.c (create_pop3_mbx):
* src/balsa-app.c (find_url), (balsa_get_short_mailbox_name),
(ba_remove_children_mailbox_nodes):
* src/balsa-index.c (bndx_scroll_on_open_idle),
(bndx_mailbox_row_inserted_cb), (bndx_mailbox_changed_idle),
(bndx_do_popup), (balsa_index_transfer), (balsa_index_expunge):
* src/balsa-mblist.c (bmbl_mailbox_changed_cb),
(bmbl_store_redraw_mbnode), (bmbl_node_style), (bmbl_mru_menu),
(bmbl_mru_selected_cb), (bmbl_mru_activated_cb):
* src/balsa-message.c (balsa_message_set),
(balsa_message_copy_part):
* src/filter-edit-callbacks.c (update_filters_mailbox):
* src/filter-run-callbacks.c (save_filters),
(fr_apply_selected_pressed_func), (fr_apply_selected_pressed),
(fr_apply_now_pressed), (fr_add_pressed_func):
* src/filter-run-dialog.c (balsa_filter_run_dialog_new),
(filters_run_dialog):
* src/folder-conf.c (browse_button_cb),
(folder_conf_imap_sub_node):
* src/mailbox-conf.c (mailbox_conf_delete), (update_pop_mailbox),
(mailbox_conf_update), (mailbox_conf_add),
(local_mailbox_dialog_cb), (create_local_mailbox_dialog),
(create_pop_mailbox_dialog), (mailbox_conf_view_check):
* src/mailbox-node.c (balsa_mailbox_node_dispose),
(load_mailbox_view), (imap_scan_attach_mailbox),
(balsa_mailbox_node_new_from_mailbox),
(balsa_mailbox_local_append), (bmbn_scan_children_idle),
(remove_special_mailbox_by_url), (add_local_mailbox):
* src/main-window.c (bw_enable_mailbox_menus),
(bw_enable_message_menus), (bw_notebook_label_new),
(balsa_window_real_open_mbnode), (bw_check_mailbox_progress_cb),
(bw_check_mailbox_list), (check_new_messages_count),
(bw_mailbox_check), (bw_notebook_switch_page_cb),
(balsa_window_set_statusbar), (balsa_window_next_unread):
* src/main.c (initial_open_unread_mailboxes), (initial_open_inbox),
(balsa_get_stats), (scan_mailboxes_idle_cb), (periodic_expunge_cb):
* src/message-window.c (mw_set_buttons_sensitive),
(message_window_new):
* src/pref-manager.c (update_view_defaults), (add_other_server),
(update_mail_servers):
* src/save-restore.c (mailbox_section_path),
(config_mailbox_set_as_special), (config_mailbox_delete),
(config_mailbox_init), (config_mailbox_filters_save):
* src/save-restore.h:
* src/sendmsg-window.c (sw_delete_draft), (create_info_pane),
(send_message_handler):
ChangeLog | 211 ++++
libbalsa/filter-file.c | 80 +-
libbalsa/libbalsa.c | 53 -
libbalsa/mailbox-filter.c | 5 +-
libbalsa/mailbox.c | 1633 ++++++++++++++++++++----------
libbalsa/mailbox.h | 144 ++-
libbalsa/mailbox_imap.c | 110 +-
libbalsa/mailbox_local.c | 156 +--
libbalsa/mailbox_local.h | 4 +-
libbalsa/mailbox_maildir.c | 30 +-
libbalsa/mailbox_mbox.c | 28 +-
libbalsa/mailbox_mh.c | 19 +-
libbalsa/mailbox_pop3.c | 96 +-
libbalsa/message.c | 4 +-
libbalsa/send.c | 15 +-
libinit_balsa/assistant_page_directory.c | 20 +-
libinit_balsa/assistant_page_user.c | 7 +-
src/balsa-app.c | 23 +-
src/balsa-index.c | 42 +-
src/balsa-mblist.c | 22 +-
src/balsa-message.c | 8 +-
src/filter-edit-callbacks.c | 16 +-
src/filter-run-callbacks.c | 16 +-
src/filter-run-dialog.c | 13 +-
src/folder-conf.c | 13 +-
src/mailbox-conf.c | 102 +-
src/mailbox-node.c | 53 +-
src/main-window.c | 51 +-
src/main.c | 12 +-
src/message-window.c | 8 +-
src/pref-manager.c | 11 +-
src/save-restore.c | 51 +-
src/save-restore.h | 2 +-
src/sendmsg-window.c | 14 +-
34 files changed, 1953 insertions(+), 1119 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index 68034b294..b43a738de 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,214 @@
+2019-07-03 Peter Bloomfield <pbloomfield bellsouth net>
+
+ Use G_DECLARE_DERIVABLE_TYPE to declare LibBalsaMailbox
+
+ and provide and use the necessary getters and setters.
+
+ Also move mailbox locking to a GRecMutex in the
+ LibBalsaMailboxPrivate structure, instead of our home-brewed
+ lock.
+
+ * libbalsa/filter-file.c (libbalsa_mailbox_filters_load_config),
+ (libbalsa_mailbox_filters_save_config):
+ * libbalsa/libbalsa.c:
+ * libbalsa/mailbox-filter.c (config_mailbox_filters_load):
+ * libbalsa/mailbox.c (libbalsa_mailbox_class_init),
+ (libbalsa_mailbox_init), (libbalsa_mailbox_dispose),
+ (get_from_field), (libbalsa_mailbox_index_entry_clear),
+ (libbalsa_mailbox_index_set_flags), (libbalsa_mailbox_finalize),
+ (libbalsa_mailbox_free_mindex), (libbalsa_mailbox_open),
+ (libbalsa_mailbox_is_open), (libbalsa_mailbox_close),
+ (libbalsa_mailbox_set_unread_messages_flag),
+ (libbalsa_mailbox_check), (lbm_changed_idle_cb),
+ (lbm_changed_schedule_idle), (libbalsa_mailbox_changed),
+ (lbm_run_filters_on_reception_idle_cb),
+ (libbalsa_mailbox_run_filters_on_reception),
+ (libbalsa_mailbox_save_config),
+ (libbalsa_mailbox_real_messages_copy),
+ (libbalsa_mailbox_real_sort), (libbalsa_mailbox_real_save_config),
+ (libbalsa_mailbox_real_load_config),
+ (libbalsa_mailbox_type_from_path), (lbm_node_has_unseen_child),
+ (lbm_msgno_changed_expunged_cb), (lbm_msgno_row_changed),
+ (lbm_msgnos_changed_idle_cb), (lbm_msgno_changed),
+ (libbalsa_mailbox_msgno_changed), (lbm_need_threading_idle_cb),
+ (libbalsa_mailbox_msgno_inserted),
+ (libbalsa_mailbox_msgno_filt_in), (libbalsa_mailbox_msgno_removed),
+ (libbalsa_mailbox_msgno_filt_out), (lbm_msgno_filt_check),
+ (libbalsa_mailbox_msgno_filt_check),
+ (libbalsa_mailbox_search_iter_view), (libbalsa_mailbox_msgno_find),
+ (libbalsa_mailbox_sync_storage), (lbm_cache_message),
+ (libbalsa_mailbox_get_message),
+ (libbalsa_mailbox_messages_change_flags),
+ (libbalsa_mailbox_set_view_filter),
+ (libbalsa_mailbox_make_view_filter_persistent),
+ (libbalsa_mailbox_real_can_do), (lbm_check_and_sort),
+ (lbm_set_threading), (libbalsa_mailbox_view_free), (lbm_get_view),
+ (libbalsa_mailbox_set_identity_name),
+ (libbalsa_mailbox_set_threading_type),
+ (libbalsa_mailbox_set_subject_gather),
+ (libbalsa_mailbox_set_sort_type),
+ (libbalsa_mailbox_set_sort_field), (libbalsa_mailbox_set_show),
+ (libbalsa_mailbox_set_subscribe), (libbalsa_mailbox_set_exposed),
+ (libbalsa_mailbox_set_open), (libbalsa_mailbox_set_filter),
+ (libbalsa_mailbox_set_crypto_mode), (libbalsa_mailbox_set_unread),
+ (libbalsa_mailbox_set_total), (libbalsa_mailbox_set_mtime),
+ (libbalsa_mailbox_set_position),
+ (libbalsa_mailbox_get_identity_name),
+ (libbalsa_mailbox_get_threading_type),
+ (libbalsa_mailbox_get_subject_gather),
+ (libbalsa_mailbox_get_sort_type),
+ (libbalsa_mailbox_get_sort_field), (libbalsa_mailbox_get_show),
+ (libbalsa_mailbox_get_subscribe), (libbalsa_mailbox_get_exposed),
+ (libbalsa_mailbox_get_open), (libbalsa_mailbox_get_filter),
+ (libbalsa_mailbox_get_crypto_mode), (libbalsa_mailbox_get_unread),
+ (libbalsa_mailbox_get_total), (libbalsa_mailbox_get_mtime),
+ (libbalsa_mailbox_get_position), (mailbox_model_init),
+ (mailbox_model_get_flags), (mailbox_model_get_n_columns),
+ (mailbox_model_get_column_type), (mailbox_model_get_iter),
+ (mailbox_model_get_path_helper), (mailbox_model_get_path),
+ (lbm_get_index_entry_expunged_cb), (lbm_get_index_entry_real),
+ (lbm_get_index_entry), (mailbox_model_get_value),
+ (mailbox_model_iter_next), (mailbox_model_iter_children),
+ (mailbox_model_iter_has_child), (mailbox_model_iter_n_children),
+ (mailbox_model_iter_nth_child), (mailbox_model_iter_parent),
+ (mailbox_drag_source_init), (mailbox_row_draggable),
+ (mailbox_drag_data_delete), (mailbox_drag_data_get),
+ (mailbox_sortable_init), (mailbox_compare_from),
+ (mailbox_compare_subject), (mailbox_compare_date),
+ (mailbox_get_thread_date_traverse_func), (mailbox_get_thread_date),
+ (mailbox_compare_thread_date), (mailbox_compare_size),
+ (mailbox_compare_func), (lbm_has_valid_index_entry), (lbm_sort),
+ (mailbox_get_sort_column_id), (mailbox_set_sort_column_id),
+ (mailbox_set_sort_func), (mailbox_set_default_sort_func),
+ (mailbox_has_default_sort_func),
+ (libbalsa_mailbox_unlink_and_prepend), (lbm_update_msg_tree),
+ (lbm_set_msg_tree), (libbalsa_mailbox_set_msg_tree),
+ (lbm_try_reassemble), (libbalsa_mailbox_try_reassemble),
+ (libbalsa_mailbox_msgno_get_status),
+ (libbalsa_mailbox_msgno_get_subject),
+ (libbalsa_mailbox_msgno_update_attach), (lbm_check_idle),
+ (lbm_queue_check), (libbalsa_mailbox_search_iter_step),
+ (libbalsa_mailbox_can_move_duplicates),
+ (libbalsa_mailbox_move_duplicates), (libbalsa_mailbox_lock_store),
+ (libbalsa_mailbox_unlock_store), (libbalsa_mailbox_cache_message),
+ (lbm_set_color), (libbalsa_mailbox_set_foreground),
+ (libbalsa_mailbox_set_background),
+ (libbalsa_mailbox_test_can_reach), (libbalsa_mailbox_get_filters),
+ (libbalsa_mailbox_get_name), (libbalsa_mailbox_get_url),
+ (libbalsa_mailbox_get_unread_messages),
+ (libbalsa_mailbox_get_first_unread),
+ (libbalsa_mailbox_get_view_filter),
+ (libbalsa_mailbox_get_msg_tree),
+ (libbalsa_mailbox_get_msg_tree_changed),
+ (libbalsa_mailbox_get_state), (libbalsa_mailbox_get_index_entry),
+ (libbalsa_mailbox_get_view), (libbalsa_mailbox_get_stamp),
+ (libbalsa_mailbox_get_open_ref), (libbalsa_mailbox_get_readonly),
+ (libbalsa_mailbox_get_config_prefix),
+ (libbalsa_mailbox_get_has_unread_messages),
+ (libbalsa_mailbox_clear_unread_messages),
+ (libbalsa_mailbox_set_filters), (libbalsa_mailbox_set_url),
+ (libbalsa_mailbox_set_first_unread),
+ (libbalsa_mailbox_set_msg_tree_changed),
+ (libbalsa_mailbox_set_is_directory),
+ (libbalsa_mailbox_set_readonly),
+ (libbalsa_mailbox_set_no_reassemble), (libbalsa_mailbox_set_name),
+ (libbalsa_mailbox_set_view),
+ (libbalsa_mailbox_set_has_unread_messages),
+ (libbalsa_mailbox_set_config_prefix),
+ (libbalsa_mailbox_add_to_unread_messages), (libbalsa_lock_mailbox),
+ (libbalsa_unlock_mailbox):
+ * libbalsa/mailbox.h:
+ * libbalsa/mailbox_imap.c (message_info_from_msgno),
+ (libbalsa_mailbox_imap_init), (libbalsa_mailbox_imap_finalize),
+ (libbalsa_mailbox_imap_update_url), (mi_get_imsg),
+ (idle_unread_update_cb), (imap_exists_idle),
+ (libbalsa_mailbox_imap_get_selected_handle), (lbm_imap_get_unseen),
+ (libbalsa_mailbox_imap_open),
+ (libbalsa_mailbox_imap_get_matchings),
+ (libbalsa_mailbox_imap_load_config),
+ (libbalsa_mailbox_imap_force_disconnect),
+ (libbalsa_mailbox_imap_reconnect), (lbmi_get_imap_sort_key),
+ (libbalsa_mailbox_imap_set_threading), (lbmi_compare_func),
+ (libbalsa_mailbox_imap_sort):
+ * libbalsa/mailbox_local.c (libbalsa_mailbox_local_init),
+ (libbalsa_mailbox_local_set_path),
+ (libbalsa_mailbox_local_load_message),
+ (libbalsa_mailbox_local_load_config), (lbm_local_save_tree),
+ (lbm_local_restore_tree), (lbm_local_save_tree_real),
+ (libbalsa_mailbox_local_close_mailbox), (message_match_real),
+ (lbml_load_messages_idle_cb), (lbml_set_threading),
+ (libbalsa_mailbox_local_set_threading),
+ (lbm_local_update_view_filter),
+ (libbalsa_mailbox_local_prepare_threading), (lbml_info_setup),
+ (lbml_thread_messages), (lbml_unthread_message),
+ (lbml_threading_flat), (lbm_local_sync_real),
+ (libbalsa_mailbox_local_messages_change_flags):
+ * libbalsa/mailbox_local.h:
+ * libbalsa/mailbox_maildir.c (libbalsa_mailbox_maildir_new),
+ (lbm_maildir_remove_files), (lbm_maildir_parse),
+ (libbalsa_mailbox_maildir_open), (libbalsa_mailbox_maildir_check),
+ (libbalsa_mailbox_maildir_sync):
+ * libbalsa/mailbox_mbox.c (libbalsa_mailbox_mbox_new), (mbox_lock),
+ (mbox_unlock), (libbalsa_mailbox_mbox_open),
+ (libbalsa_mailbox_mbox_check), (libbalsa_mailbox_mbox_sync):
+ * libbalsa/mailbox_mh.c (libbalsa_mailbox_mh_new),
+ (lbm_mh_parse_mailbox), (libbalsa_mailbox_mh_open),
+ (libbalsa_mailbox_mh_check), (libbalsa_mailbox_mh_sync):
+ * libbalsa/mailbox_pop3.c (libbalsa_mailbox_pop3_new),
+ (message_cb), (libbalsa_mailbox_pop3_startup), (update_msg_list),
+ (libbalsa_mailbox_pop3_check), (libbalsa_mailbox_pop3_set_inbox),
+ (libbalsa_mailbox_pop3_set_msg_size_limit):
+ * libbalsa/message.c (libbalsa_message_change_flags):
+ * libbalsa/send.c (lbs_message_queue_real),
+ (lbs_check_reachable_cb), (balsa_send_message_success):
+ * libinit_balsa/assistant_page_directory.c (unconditional_mailbox):
+ * libinit_balsa/assistant_page_user.c (create_pop3_mbx):
+ * src/balsa-app.c (find_url), (balsa_get_short_mailbox_name),
+ (ba_remove_children_mailbox_nodes):
+ * src/balsa-index.c (bndx_scroll_on_open_idle),
+ (bndx_mailbox_row_inserted_cb), (bndx_mailbox_changed_idle),
+ (bndx_do_popup), (balsa_index_transfer), (balsa_index_expunge):
+ * src/balsa-mblist.c (bmbl_mailbox_changed_cb),
+ (bmbl_store_redraw_mbnode), (bmbl_node_style), (bmbl_mru_menu),
+ (bmbl_mru_selected_cb), (bmbl_mru_activated_cb):
+ * src/balsa-message.c (balsa_message_set),
+ (balsa_message_copy_part):
+ * src/filter-edit-callbacks.c (update_filters_mailbox):
+ * src/filter-run-callbacks.c (save_filters),
+ (fr_apply_selected_pressed_func), (fr_apply_selected_pressed),
+ (fr_apply_now_pressed), (fr_add_pressed_func):
+ * src/filter-run-dialog.c (balsa_filter_run_dialog_new),
+ (filters_run_dialog):
+ * src/folder-conf.c (browse_button_cb),
+ (folder_conf_imap_sub_node):
+ * src/mailbox-conf.c (mailbox_conf_delete), (update_pop_mailbox),
+ (mailbox_conf_update), (mailbox_conf_add),
+ (local_mailbox_dialog_cb), (create_local_mailbox_dialog),
+ (create_pop_mailbox_dialog), (mailbox_conf_view_check):
+ * src/mailbox-node.c (balsa_mailbox_node_dispose),
+ (load_mailbox_view), (imap_scan_attach_mailbox),
+ (balsa_mailbox_node_new_from_mailbox),
+ (balsa_mailbox_local_append), (bmbn_scan_children_idle),
+ (remove_special_mailbox_by_url), (add_local_mailbox):
+ * src/main-window.c (bw_enable_mailbox_menus),
+ (bw_enable_message_menus), (bw_notebook_label_new),
+ (balsa_window_real_open_mbnode), (bw_check_mailbox_progress_cb),
+ (bw_check_mailbox_list), (check_new_messages_count),
+ (bw_mailbox_check), (bw_notebook_switch_page_cb),
+ (balsa_window_set_statusbar), (balsa_window_next_unread):
+ * src/main.c (initial_open_unread_mailboxes), (initial_open_inbox),
+ (balsa_get_stats), (scan_mailboxes_idle_cb), (periodic_expunge_cb):
+ * src/message-window.c (mw_set_buttons_sensitive),
+ (message_window_new):
+ * src/pref-manager.c (update_view_defaults), (add_other_server),
+ (update_mail_servers):
+ * src/save-restore.c (mailbox_section_path),
+ (config_mailbox_set_as_special), (config_mailbox_delete),
+ (config_mailbox_init), (config_mailbox_filters_save):
+ * src/save-restore.h:
+ * src/sendmsg-window.c (sw_delete_draft), (create_info_pane),
+ (send_message_handler):
+
2019-06-30 Albrecht Dreß <albrecht dress arcor de>
Small LDAP address book improvements
diff --git a/libbalsa/filter-file.c b/libbalsa/filter-file.c
index 07951c322..33cb52602 100644
--- a/libbalsa/filter-file.c
+++ b/libbalsa/filter-file.c
@@ -110,45 +110,51 @@ libbalsa_filter_save_config(LibBalsaFilter * fil)
void
libbalsa_mailbox_filters_load_config(LibBalsaMailbox* mbox)
{
- gint i,nb_filters;
- gchar **filters_names=NULL;
- LibBalsaFilter* fil;
+ gint i, nb_filters;
+ gchar **filters_names = NULL;
gboolean def;
- GSList * lst;
+ GSList *lst;
+ GSList *filters;
+
+ filters = libbalsa_mailbox_get_filters(mbox);
/* We load the associated filters */
- libbalsa_conf_get_vector_with_default(MAILBOX_FILTERS_KEY,&nb_filters,
- &filters_names,&def);
+ libbalsa_conf_get_vector_with_default(MAILBOX_FILTERS_KEY,
+ &nb_filters, &filters_names, &def);
if (!def) {
- for(i=0;i<nb_filters;i++) {
+ for(i = 0; i < nb_filters; i++) {
+ LibBalsaFilter *fil;
+
fil = libbalsa_filter_get_by_name(filters_names[i]);
- if (fil) {
- LibBalsaMailboxFilter* mf = g_new(LibBalsaMailboxFilter,1);
+ if (fil != NULL) {
+ LibBalsaMailboxFilter *mf = g_new(LibBalsaMailboxFilter, 1);
mf->actual_filter = fil;
- mbox->filters=g_slist_prepend(mbox->filters, mf);
+ filters = g_slist_prepend(filters, mf);
}
else
libbalsa_information(LIBBALSA_INFORMATION_WARNING,
_("Invalid filters %s for mailbox %s"),
- filters_names[i], mbox->name);
+ filters_names[i], libbalsa_mailbox_get_name(mbox));
}
- mbox->filters=g_slist_reverse(mbox->filters);
+ libbalsa_mailbox_set_filters(mbox, g_slist_reverse(filters));
}
g_strfreev(filters_names);
+
if (!def) {
libbalsa_conf_get_vector_with_default(MAILBOX_FILTERS_WHEN_KEY,
- &nb_filters,&filters_names,&def);
- if (def)
- for(lst=mbox->filters;lst;lst=g_slist_next(lst))
+ &nb_filters, &filters_names, &def);
+ if (def) {
+ for(lst = filters; lst != NULL; lst = lst->next)
FILTER_WHEN_SETFLAG((LibBalsaMailboxFilter*)lst->data,
FILTER_WHEN_NEVER);
- else {
- lst=mbox->filters;
- for (i=0;i<nb_filters && lst;i++) {
- ((LibBalsaMailboxFilter*)lst->data)->when =
- atoi(filters_names[i]);
- lst=g_slist_next(lst);
+ } else {
+ lst = filters;
+ for (i = 0; i < nb_filters && lst != NULL; i++) {
+ LibBalsaMailboxFilter *mf = lst->data;
+
+ mf->when = atoi(filters_names[i]);
+ lst = lst->next;
}
}
g_strfreev(filters_names);
@@ -162,41 +168,41 @@ libbalsa_mailbox_filters_load_config(LibBalsaMailbox* mbox)
void
libbalsa_mailbox_filters_save_config(LibBalsaMailbox * mbox)
{
- gint i,nb_filters=0;
- gchar ** filters_names;
- GSList * fil,* names=NULL,* lst;
+ gint i, nb_filters = 0;
+ gchar **filters_names;
+ GSList *fil, *names = NULL, *lst;
/* First we construct a list containing the names of associated filters
* Note : in all the following we never copy the filters name, so we don't have to (and me must not!)
free any gchar *
* That's why we only free g_slist and gchar **
*/
- for(fil=mbox->filters;fil;fil=g_slist_next(fil)) {
+ for (fil = libbalsa_mailbox_get_filters(mbox); fil != NULL; fil = fil->next) {
names=g_slist_prepend(names,
((LibBalsaMailboxFilter*)fil->data)->actual_filter->name);
nb_filters++;
}
names=g_slist_reverse(names);
/* Second we construct the vector of gchar * */
- filters_names=g_new(gchar *,nb_filters);
- lst=names;
- for(i=0; i<nb_filters; i++) {
- filters_names[i]=(gchar*)lst->data;
- lst=g_slist_next(lst);
+ filters_names = g_new(gchar *, nb_filters);
+ lst = names;
+ for(i = 0; i < nb_filters; i++) {
+ filters_names[i] = (gchar*) lst->data;
+ lst = lst->next;
}
g_slist_free(names);
- libbalsa_conf_set_vector(MAILBOX_FILTERS_KEY,nb_filters,
- (const gchar**)filters_names);
+ libbalsa_conf_set_vector(MAILBOX_FILTERS_KEY, nb_filters,
+ (const gchar **) filters_names);
- fil=mbox->filters;
- for (i=0;i<nb_filters;i++) {
+ fil = libbalsa_mailbox_get_filters(mbox);
+ for (i = 0; i < nb_filters; i++) {
filters_names[i]=
g_strdup_printf("%d",
((LibBalsaMailboxFilter*)fil->data)->when);
- fil=g_slist_next(fil);
+ fil = fil->next;
}
libbalsa_conf_set_vector(MAILBOX_FILTERS_WHEN_KEY,nb_filters,
- (const gchar**)filters_names);
- for (i=0;i<nb_filters;i++)
+ (const gchar **) filters_names);
+ for (i = 0; i < nb_filters; i++)
g_free(filters_names[i]);
g_free(filters_names);
}
diff --git a/libbalsa/libbalsa.c b/libbalsa/libbalsa.c
index accb20dbc..b3c6a9a8a 100644
--- a/libbalsa/libbalsa.c
+++ b/libbalsa/libbalsa.c
@@ -659,59 +659,6 @@ libbalsa_am_i_subthread(void)
return g_thread_self() != main_thread_id;
}
-
-#include "libbalsa_private.h" /* for prototypes */
-static GMutex mailbox_mutex;
-static GCond mailbox_cond;
-
-/* Lock/unlock a mailbox; no argument checking--we'll assume the caller
- * took care of that.
- */
-#define LIBBALSA_DEBUG_THREADS FALSE
-void
-libbalsa_lock_mailbox(LibBalsaMailbox * mailbox)
-{
- GThread *thread_id = g_thread_self();
-
- g_mutex_lock(&mailbox_mutex);
-
- if (mailbox->thread_id && mailbox->thread_id != thread_id)
- while (mailbox->lock)
- g_cond_wait(&mailbox_cond, &mailbox_mutex);
-
- /* We'll assume that no-one would destroy a mailbox while we've been
- * trying to lock it. If they have, we have larger problems than
- * this reference! */
- mailbox->lock++;
- mailbox->thread_id = thread_id;
-
- g_mutex_unlock(&mailbox_mutex);
-}
-
-void
-libbalsa_unlock_mailbox(LibBalsaMailbox * mailbox)
-{
- GThread *self;
-
- self = g_thread_self();
-
- g_mutex_lock(&mailbox_mutex);
-
- if (mailbox->lock == 0 || self != mailbox->thread_id) {
- g_warning("Not holding mailbox lock!!!");
- g_mutex_unlock(&mailbox_mutex);
- return;
- }
-
- if(--mailbox->lock == 0) {
- mailbox->thread_id = 0;
- g_cond_broadcast(&mailbox_cond);
- }
-
- g_mutex_unlock(&mailbox_mutex);
-}
-
-
/* Initialized by the front end. */
void (*libbalsa_progress_set_text) (LibBalsaProgress * progress,
const gchar * text, guint total);
diff --git a/libbalsa/mailbox-filter.c b/libbalsa/mailbox-filter.c
index 6d3551ed2..b13c7d1b3 100644
--- a/libbalsa/mailbox-filter.c
+++ b/libbalsa/mailbox-filter.c
@@ -97,9 +97,12 @@ mailbox_filters_section_lookup(const gchar * name)
void
config_mailbox_filters_load(LibBalsaMailbox * mbox)
{
+ const gchar *url;
gchar * group;
- group = mailbox_filters_section_lookup(mbox->url ? mbox->url : mbox->name);
+ url = libbalsa_mailbox_get_url(mbox);
+ group = mailbox_filters_section_lookup(url != NULL ? url :
+ libbalsa_mailbox_get_name(mbox));
if (group) {
libbalsa_conf_push_group(group);
g_free(group);
diff --git a/libbalsa/mailbox.c b/libbalsa/mailbox.c
index 68bb42cc8..6454db90d 100644
--- a/libbalsa/mailbox.c
+++ b/libbalsa/mailbox.c
@@ -38,8 +38,6 @@
#include <glib/gi18n.h>
/* Class functions */
-static void libbalsa_mailbox_class_init(LibBalsaMailboxClass * klass);
-static void libbalsa_mailbox_init(LibBalsaMailbox * mailbox);
static void libbalsa_mailbox_dispose(GObject * object);
static void libbalsa_mailbox_finalize(GObject * object);
@@ -49,9 +47,9 @@ static gboolean
libbalsa_mailbox_real_messages_copy(LibBalsaMailbox * mailbox,
GArray * msgnos,
LibBalsaMailbox * dest, GError **err);
-static gboolean libbalsa_mailbox_real_can_do(LibBalsaMailbox* mbox,
+static gboolean libbalsa_mailbox_real_can_do(LibBalsaMailbox* mailbox,
enum LibBalsaMailboxCapability c);
-static void libbalsa_mailbox_real_sort(LibBalsaMailbox* mbox,
+static void libbalsa_mailbox_real_sort(LibBalsaMailbox* mailbox,
GArray *sort_array);
static gboolean libbalsa_mailbox_real_can_match(LibBalsaMailbox *mailbox,
LibBalsaCondition *condition);
@@ -90,79 +88,96 @@ enum {
LAST_MODEL_SIGNAL
};
-static GObjectClass *parent_class = NULL;
static guint libbalsa_mailbox_signals[LAST_SIGNAL];
-static guint libbalsa_mbox_model_signals[LAST_MODEL_SIGNAL];
+static guint libbalsa_mailbox_model_signals[LAST_MODEL_SIGNAL];
/* GtkTreeModel function prototypes */
-static void mbox_model_init(GtkTreeModelIface *iface);
+static void mailbox_model_init(GtkTreeModelIface *iface);
/* GtkTreeDragSource function prototypes */
-static void mbox_drag_source_init(GtkTreeDragSourceIface *iface);
+static void mailbox_drag_source_init(GtkTreeDragSourceIface *iface);
/* GtkTreeSortable function prototypes */
-static void mbox_sortable_init(GtkTreeSortableIface *iface);
+static void mailbox_sortable_init(GtkTreeSortableIface *iface);
-GType
-libbalsa_mailbox_get_type(void)
-{
- static GType mailbox_type = 0;
-
- if (!mailbox_type) {
- static const GTypeInfo mailbox_info = {
- sizeof(LibBalsaMailboxClass),
- NULL, /* base_init */
- NULL, /* base_finalize */
- (GClassInitFunc) libbalsa_mailbox_class_init,
- NULL, /* class_finalize */
- NULL, /* class_data */
- sizeof(LibBalsaMailbox),
- 0, /* n_preallocs */
- (GInstanceInitFunc) libbalsa_mailbox_init
- };
-
- static const GInterfaceInfo mbox_model_info = {
- (GInterfaceInitFunc) mbox_model_init,
- NULL,
- NULL
- };
+typedef struct _LibBalsaMailboxPrivate LibBalsaMailboxPrivate;
+struct _LibBalsaMailboxPrivate {
+ gint stamp; /* used to determine iterators' validity. Increased on each
+ * modification of mailbox. */
- static const GInterfaceInfo mbox_drag_source_info = {
- (GInterfaceInitFunc) mbox_drag_source_init,
- NULL,
- NULL
- };
-
- static const GInterfaceInfo mbox_sortable_info = {
- (GInterfaceInitFunc) mbox_sortable_init,
- NULL,
- NULL
- };
+ gchar *config_prefix; /* unique string identifying mailbox */
+ /* in the config file */
+ gchar *name; /* displayed name for a special mailbox; */
+ /* Isn't it a GUI thing? */
+ gchar *url; /* Unique resource locator, file://, imap:// etc */
+ guint open_ref;
- mailbox_type =
- g_type_register_static(G_TYPE_OBJECT, "LibBalsaMailbox",
- &mailbox_info, 0);
- g_type_add_interface_static(mailbox_type,
- GTK_TYPE_TREE_MODEL,
- &mbox_model_info);
- g_type_add_interface_static(mailbox_type,
- GTK_TYPE_TREE_DRAG_SOURCE,
- &mbox_drag_source_info);
- g_type_add_interface_static(mailbox_type,
- GTK_TYPE_TREE_SORTABLE,
- &mbox_sortable_info);
- }
+ GRecMutex rec_mutex;
+
+ gboolean is_directory;
+ gboolean readonly;
+
+ GPtrArray *mindex; /* the basic message index used for index
+ * displaying/columns of GtkTreeModel interface
+ * and NOTHING else. */
+ GNode *msg_tree; /* the possibly filtered tree of messages */
+ LibBalsaCondition *view_filter; /* to choose a subset of messages
+ * to be displayed, e.g., only
+ * undeleted. */
+ LibBalsaCondition *persistent_view_filter; /* the part of the view
+ * filter that will persist
+ * to the next time the
+ * mailbox is opened */
+ gboolean view_filter_pending; /* a view filter has been set
+ * but the view has not been updated */
+
+ /* info fields */
+ gboolean has_unread_messages;
+ glong unread_messages; /* number of unread messages in the mailbox */
+ unsigned first_unread; /* set to 0 if there is no unread present.
+ * used for automatical scrolling down on opening.
+ */
+ /* Associated filters (struct mailbox_filter) */
+ GSList * filters;
+ gboolean filters_loaded;
- return mailbox_type;
-}
+ LibBalsaMailboxView *view;
+ LibBalsaMailboxState state;
+
+ /* Whether to reassemble a message from its parts. */
+ gboolean no_reassemble;
+
+ /* Whether the tree has been changed since some event. */
+ gboolean msg_tree_changed;
+
+ /* Array of msgnos that need to be displayed. */
+ GArray *msgnos_pending;
+ /* Array of msgnos that have been changed. */
+ GArray *msgnos_changed;
+
+ guint changed_idle_id;
+ guint queue_check_idle_id;
+ guint need_threading_idle_id;
+ guint run_filters_idle_id;
+};
+
+G_DEFINE_TYPE_WITH_CODE(LibBalsaMailbox,
+ libbalsa_mailbox,
+ G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE(GTK_TYPE_TREE_MODEL,
+ mailbox_model_init)
+ G_IMPLEMENT_INTERFACE(GTK_TYPE_TREE_DRAG_SOURCE,
+ mailbox_drag_source_init)
+ G_IMPLEMENT_INTERFACE(GTK_TYPE_TREE_SORTABLE,
+ mailbox_sortable_init)
+ G_ADD_PRIVATE(LibBalsaMailbox)
+ )
static void
libbalsa_mailbox_class_init(LibBalsaMailboxClass * klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
- parent_class = g_type_class_peek_parent(klass);
-
/* This signal is emitted by the mailbox when new messages are
retrieved (check mail or opening of the mailbox). This is used
by GUI to sync on the mailbox content (see BalsaIndex)
@@ -235,28 +250,29 @@ libbalsa_mailbox_class_init(LibBalsaMailboxClass * klass)
static void
libbalsa_mailbox_init(LibBalsaMailbox * mailbox)
{
- mailbox->lock = FALSE;
- mailbox->is_directory = FALSE;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
- mailbox->config_prefix = NULL;
- mailbox->name = NULL;
- mailbox->url = NULL;
+ g_rec_mutex_init(&priv->rec_mutex);
+ priv->is_directory = FALSE;
- mailbox->open_ref = 0;
- mailbox->has_unread_messages = FALSE;
- mailbox->unread_messages = 0;
+ priv->config_prefix = NULL;
+ priv->name = NULL;
+ priv->url = NULL;
- mailbox->readonly = FALSE;
- mailbox->disconnected = FALSE;
+ priv->open_ref = 0;
+ priv->has_unread_messages = FALSE;
+ priv->unread_messages = 0;
- mailbox->filters=NULL;
- mailbox->filters_loaded = FALSE;
- mailbox->view=NULL;
- /* mailbox->stamp is incremented before we use it, so it won't be
+ priv->readonly = FALSE;
+
+ priv->filters=NULL;
+ priv->filters_loaded = FALSE;
+ priv->view=NULL;
+ /* priv->stamp is incremented before we use it, so it won't be
* zero for a long, long time... */
- mailbox->stamp = g_random_int() / 2;
+ priv->stamp = g_random_int() / 2;
- mailbox->no_reassemble = FALSE;
+ priv->no_reassemble = FALSE;
}
/*
@@ -269,17 +285,20 @@ static void
libbalsa_mailbox_dispose(GObject * object)
{
LibBalsaMailbox *mailbox = LIBBALSA_MAILBOX(object);
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
- while (mailbox->open_ref > 0)
+ while (priv->open_ref > 0)
libbalsa_mailbox_close(mailbox, FALSE);
- G_OBJECT_CLASS(parent_class)->dispose(object);
+ G_OBJECT_CLASS(libbalsa_mailbox_parent_class)->dispose(object);
}
static gchar*
get_from_field(LibBalsaMessage *message)
{
+ LibBalsaMailbox *mailbox = message->mailbox;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
InternetAddressList *address_list = NULL;
const gchar *name_str = NULL;
gboolean append_dots = FALSE;
@@ -288,8 +307,8 @@ get_from_field(LibBalsaMessage *message)
g_return_val_if_fail(message->mailbox, NULL);
if (message->headers) {
- if (message->mailbox->view &&
- message->mailbox->view->show == LB_MAILBOX_SHOW_TO)
+ if (priv->view &&
+ priv->view->show == LB_MAILBOX_SHOW_TO)
address_list = message->headers->to_list;
else
address_list = message->headers->from;
@@ -383,12 +402,14 @@ lbm_index_entry_free(LibBalsaMailboxIndexEntry *entry)
void
libbalsa_mailbox_index_entry_clear(LibBalsaMailbox * mailbox, guint msgno)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
g_return_if_fail(msgno > 0);
- if (msgno <= mailbox->mindex->len) {
+ if (msgno <= priv->mindex->len) {
LibBalsaMailboxIndexEntry **entry = (LibBalsaMailboxIndexEntry **)
- & g_ptr_array_index(mailbox->mindex, msgno - 1);
+ & g_ptr_array_index(priv->mindex, msgno - 1);
lbm_index_entry_free(*entry);
*entry = NULL;
@@ -403,12 +424,13 @@ void
libbalsa_mailbox_index_set_flags(LibBalsaMailbox *mailbox,
unsigned msgno, LibBalsaMessageFlag f)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
LibBalsaMailboxIndexEntry *entry;
- if (msgno > mailbox->mindex->len)
+ if (msgno > priv->mindex->len)
return;
- entry = g_ptr_array_index(mailbox->mindex, msgno-1);
+ entry = g_ptr_array_index(priv->mindex, msgno-1);
if (VALID_ENTRY(entry)) {
entry->status_icon =
libbalsa_get_icon_from_flags(f);
@@ -429,71 +451,69 @@ static void lbm_get_index_entry_expunged_cb(LibBalsaMailbox * mailbox,
static void
libbalsa_mailbox_finalize(GObject * object)
{
- LibBalsaMailbox *mailbox;
-
- g_return_if_fail(object != NULL);
+ LibBalsaMailbox *mailbox = LIBBALSA_MAILBOX(object);
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
- mailbox = LIBBALSA_MAILBOX(object);
- g_free(mailbox->config_prefix);
- mailbox->config_prefix = NULL;
+ g_free(priv->config_prefix);
+ priv->config_prefix = NULL;
- g_free(mailbox->name);
- mailbox->name = NULL;
+ g_free(priv->name);
+ priv->name = NULL;
- g_free(mailbox->url);
- mailbox->url = NULL;
+ g_free(priv->url);
+ priv->url = NULL;
- libbalsa_condition_unref(mailbox->view_filter);
- mailbox->view_filter = NULL;
+ libbalsa_condition_unref(priv->view_filter);
+ priv->view_filter = NULL;
- libbalsa_condition_unref(mailbox->persistent_view_filter);
- mailbox->persistent_view_filter = NULL;
+ libbalsa_condition_unref(priv->persistent_view_filter);
+ priv->persistent_view_filter = NULL;
- g_slist_free_full(mailbox->filters, g_free);
- mailbox->filters = NULL;
- mailbox->filters_loaded = FALSE;
+ g_slist_free_full(priv->filters, g_free);
+ priv->filters = NULL;
+ priv->filters_loaded = FALSE;
- if (mailbox->msgnos_pending) {
+ if (priv->msgnos_pending) {
g_signal_handlers_disconnect_by_func(mailbox,
lbm_get_index_entry_expunged_cb,
- mailbox->msgnos_pending);
- g_array_free(mailbox->msgnos_pending, TRUE);
- mailbox->msgnos_pending = NULL;
+ priv->msgnos_pending);
+ g_array_free(priv->msgnos_pending, TRUE);
+ priv->msgnos_pending = NULL;
}
- if (mailbox->msgnos_changed) {
+ if (priv->msgnos_changed) {
g_signal_handlers_disconnect_by_func(mailbox,
lbm_msgno_changed_expunged_cb,
- mailbox->msgnos_changed);
- g_array_free(mailbox->msgnos_changed, TRUE);
- mailbox->msgnos_changed = NULL;
+ priv->msgnos_changed);
+ g_array_free(priv->msgnos_changed, TRUE);
+ priv->msgnos_changed = NULL;
}
- libbalsa_mailbox_view_free(mailbox->view);
- mailbox->view = NULL;
+ libbalsa_mailbox_view_free(priv->view);
+ priv->view = NULL;
- if (mailbox->changed_idle_id) {
- g_source_remove(mailbox->changed_idle_id);
- mailbox->changed_idle_id = 0;
+ if (priv->changed_idle_id) {
+ g_source_remove(priv->changed_idle_id);
+ priv->changed_idle_id = 0;
}
- if (mailbox->queue_check_idle_id) {
- g_source_remove(mailbox->queue_check_idle_id);
- mailbox->queue_check_idle_id = 0;
+ if (priv->queue_check_idle_id) {
+ g_source_remove(priv->queue_check_idle_id);
+ priv->queue_check_idle_id = 0;
}
- if (mailbox->need_threading_idle_id) {
- g_source_remove(mailbox->need_threading_idle_id);
- mailbox->need_threading_idle_id = 0;
+ if (priv->need_threading_idle_id) {
+ g_source_remove(priv->need_threading_idle_id);
+ priv->need_threading_idle_id = 0;
}
- if (mailbox->run_filters_idle_id) {
- g_source_remove(mailbox->run_filters_idle_id);
- mailbox->run_filters_idle_id = 0;
+ if (priv->run_filters_idle_id) {
+ g_source_remove(priv->run_filters_idle_id);
+ priv->run_filters_idle_id = 0;
}
- G_OBJECT_CLASS(parent_class)->finalize(object);
+ G_OBJECT_CLASS(libbalsa_mailbox_parent_class)->finalize(object);
}
/* Create a new mailbox by loading it from a config entry... */
@@ -558,9 +578,11 @@ libbalsa_mailbox_new_from_config(const gchar * group, gboolean is_special)
static void
libbalsa_mailbox_free_mindex(LibBalsaMailbox *mailbox)
{
- if (mailbox->mindex != NULL) {
- g_ptr_array_free(mailbox->mindex, TRUE);
- mailbox->mindex = NULL;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ if (priv->mindex != NULL) {
+ g_ptr_array_free(priv->mindex, TRUE);
+ priv->mindex = NULL;
}
}
@@ -569,6 +591,7 @@ static gboolean lbm_set_threading(LibBalsaMailbox * mailbox);
gboolean
libbalsa_mailbox_open(LibBalsaMailbox * mailbox, GError **err)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
gboolean retval;
g_return_val_if_fail(mailbox != NULL, FALSE);
@@ -576,27 +599,27 @@ libbalsa_mailbox_open(LibBalsaMailbox * mailbox, GError **err)
libbalsa_lock_mailbox(mailbox);
- if (mailbox->open_ref > 0) {
- mailbox->open_ref++;
+ if (priv->open_ref > 0) {
+ priv->open_ref++;
libbalsa_mailbox_check(mailbox);
retval = TRUE;
} else {
LibBalsaMailboxState saved_state;
- mailbox->stamp++;
- if(mailbox->mindex) g_warning("mindex set - I leak memory");
- mailbox->mindex =
+ priv->stamp++;
+ if(priv->mindex) g_warning("mindex set - I leak memory");
+ priv->mindex =
g_ptr_array_new_with_free_func((GDestroyNotify) lbm_index_entry_free);
- saved_state = mailbox->state;
- mailbox->state = LB_MAILBOX_STATE_OPENING;
+ saved_state = priv->state;
+ priv->state = LB_MAILBOX_STATE_OPENING;
retval =
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->open_mailbox(mailbox, err);
if(retval) {
- mailbox->open_ref++;
- mailbox->state = LB_MAILBOX_STATE_OPEN;
+ priv->open_ref++;
+ priv->state = LB_MAILBOX_STATE_OPEN;
} else {
- mailbox->state = saved_state;
+ priv->state = saved_state;
libbalsa_mailbox_free_mindex(mailbox);
}
}
@@ -609,16 +632,20 @@ libbalsa_mailbox_open(LibBalsaMailbox * mailbox, GError **err)
gboolean
libbalsa_mailbox_is_open(LibBalsaMailbox *mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
g_return_val_if_fail(mailbox != NULL, FALSE);
g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), FALSE);
- return mailbox->open_ref>0; /* this will break unlisted mailbox types */
+ return priv->open_ref>0; /* this will break unlisted mailbox types */
}
void
libbalsa_mailbox_close(LibBalsaMailbox * mailbox, gboolean expunge)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
g_return_if_fail(mailbox != NULL);
g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
g_return_if_fail(MAILBOX_OPEN(mailbox));
@@ -626,18 +653,18 @@ libbalsa_mailbox_close(LibBalsaMailbox * mailbox, gboolean expunge)
g_object_ref(mailbox);
libbalsa_lock_mailbox(mailbox);
- if (--mailbox->open_ref == 0) {
- mailbox->state = LB_MAILBOX_STATE_CLOSING;
+ if (--priv->open_ref == 0) {
+ priv->state = LB_MAILBOX_STATE_CLOSING;
/* do not try expunging read-only mailboxes, it's a waste of time */
- expunge = expunge && !mailbox->readonly;
+ expunge = expunge && !priv->readonly;
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->close_mailbox(mailbox, expunge);
- if(mailbox->msg_tree) {
- g_node_destroy(mailbox->msg_tree);
- mailbox->msg_tree = NULL;
+ if(priv->msg_tree) {
+ g_node_destroy(priv->msg_tree);
+ priv->msg_tree = NULL;
}
libbalsa_mailbox_free_mindex(mailbox);
- mailbox->stamp++;
- mailbox->state = LB_MAILBOX_STATE_CLOSED;
+ priv->stamp++;
+ priv->state = LB_MAILBOX_STATE_CLOSED;
}
libbalsa_unlock_mailbox(mailbox);
@@ -648,10 +675,12 @@ void
libbalsa_mailbox_set_unread_messages_flag(LibBalsaMailbox * mailbox,
gboolean has_unread)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
g_return_if_fail(mailbox != NULL);
g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
- mailbox->has_unread_messages = (has_unread != FALSE);
+ priv->has_unread_messages = (has_unread != FALSE);
libbalsa_mailbox_changed(mailbox);
}
@@ -686,15 +715,17 @@ libbalsa_mailbox_progress_notify(LibBalsaMailbox *mailbox,
void
libbalsa_mailbox_check(LibBalsaMailbox * mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
g_return_if_fail(mailbox != NULL);
g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
libbalsa_lock_mailbox(mailbox);
- if (mailbox->queue_check_idle_id) {
+ if (priv->queue_check_idle_id) {
/* Remove scheduled idle callback. */
- g_source_remove(mailbox->queue_check_idle_id);
- mailbox->queue_check_idle_id = 0;
+ g_source_remove(priv->queue_check_idle_id);
+ priv->queue_check_idle_id = 0;
}
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->check(mailbox);
@@ -705,9 +736,11 @@ libbalsa_mailbox_check(LibBalsaMailbox * mailbox)
static gboolean
lbm_changed_idle_cb(LibBalsaMailbox * mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
libbalsa_lock_mailbox(mailbox);
g_signal_emit(mailbox, libbalsa_mailbox_signals[CHANGED], 0);
- mailbox->changed_idle_id = 0;
+ priv->changed_idle_id = 0;
libbalsa_unlock_mailbox(mailbox);
return G_SOURCE_REMOVE;
@@ -716,9 +749,11 @@ lbm_changed_idle_cb(LibBalsaMailbox * mailbox)
static void
lbm_changed_schedule_idle(LibBalsaMailbox * mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
libbalsa_lock_mailbox(mailbox);
- if (!mailbox->changed_idle_id)
- mailbox->changed_idle_id =
+ if (!priv->changed_idle_id)
+ priv->changed_idle_id =
g_idle_add((GSourceFunc) lbm_changed_idle_cb, mailbox);
libbalsa_unlock_mailbox(mailbox);
}
@@ -726,11 +761,13 @@ lbm_changed_schedule_idle(LibBalsaMailbox * mailbox)
void
libbalsa_mailbox_changed(LibBalsaMailbox * mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
libbalsa_lock_mailbox(mailbox);
if (!g_signal_has_handler_pending
(mailbox, libbalsa_mailbox_signals[CHANGED], 0, TRUE)) {
/* No one cares, so don't set any message counts--that might
- * cause mailbox->view to be created. */
+ * cause priv->view to be created. */
libbalsa_unlock_mailbox(mailbox);
return;
}
@@ -740,11 +777,11 @@ libbalsa_mailbox_changed(LibBalsaMailbox * mailbox)
libbalsa_mailbox_set_total(mailbox,
libbalsa_mailbox_total_messages
(mailbox));
- libbalsa_mailbox_set_unread(mailbox, mailbox->unread_messages);
- } else if (mailbox->has_unread_messages
+ libbalsa_mailbox_set_unread(mailbox, priv->unread_messages);
+ } else if (priv->has_unread_messages
&& libbalsa_mailbox_get_unread(mailbox) <= 0) {
/* Mail has arrived in a closed mailbox since our last check;
- * total is unknown, but mailbox->has_unread_messages is valid. */
+ * total is unknown, but priv->has_unread_messages is valid. */
libbalsa_mailbox_set_total(mailbox, -1);
libbalsa_mailbox_set_unread(mailbox, 1);
}
@@ -803,6 +840,7 @@ libbalsa_mailbox_can_match(LibBalsaMailbox * mailbox,
static gboolean
lbm_run_filters_on_reception_idle_cb(LibBalsaMailbox * mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GSList *filters;
guint progress_count;
GSList *lst;
@@ -814,14 +852,14 @@ lbm_run_filters_on_reception_idle_cb(LibBalsaMailbox * mailbox)
libbalsa_lock_mailbox(mailbox);
- mailbox->run_filters_idle_id = 0;
+ priv->run_filters_idle_id = 0;
- if (!mailbox->filters_loaded) {
+ if (!priv->filters_loaded) {
config_mailbox_filters_load(mailbox);
- mailbox->filters_loaded = TRUE;
+ priv->filters_loaded = TRUE;
}
- filters = libbalsa_mailbox_filters_when(mailbox->filters,
+ filters = libbalsa_mailbox_filters_when(priv->filters,
FILTER_WHEN_INCOMING);
if (filters == NULL) {
@@ -855,7 +893,7 @@ lbm_run_filters_on_reception_idle_cb(LibBalsaMailbox * mailbox)
(TRUE,
LIBBALSA_MESSAGE_FLAG_DELETED));
- text = g_strdup_printf(_("Applying filter rules to %s"), mailbox->name);
+ text = g_strdup_printf(_("Applying filter rules to %s"), priv->name);
total = libbalsa_mailbox_total_messages(mailbox);
progress_total = progress_count * total;
libbalsa_progress_set_text(&progress, text, progress_total);
@@ -910,9 +948,11 @@ lbm_run_filters_on_reception_idle_cb(LibBalsaMailbox * mailbox)
void
libbalsa_mailbox_run_filters_on_reception(LibBalsaMailbox * mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
- mailbox->run_filters_idle_id =
+ priv->run_filters_idle_id =
g_idle_add((GSourceFunc) lbm_run_filters_on_reception_idle_cb, mailbox);
}
@@ -920,14 +960,16 @@ void
libbalsa_mailbox_save_config(LibBalsaMailbox * mailbox,
const gchar * group)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
g_return_if_fail(mailbox != NULL);
g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
/* These are incase this section was used for another
* type of mailbox that has now been deleted...
*/
- g_free(mailbox->config_prefix);
- mailbox->config_prefix = g_strdup(group);
+ g_free(priv->config_prefix);
+ priv->config_prefix = g_strdup(group);
libbalsa_conf_private_remove_group(group);
libbalsa_conf_remove_group(group);
@@ -1013,6 +1055,8 @@ libbalsa_mailbox_real_messages_copy(LibBalsaMailbox * mailbox,
GArray * msgnos,
LibBalsaMailbox * dest, GError ** err)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+ LibBalsaMailboxPrivate *dest_priv = libbalsa_mailbox_get_instance_private(dest);
gchar *text;
guint successfully_copied;
struct MsgCopyData mcd;
@@ -1021,8 +1065,8 @@ libbalsa_mailbox_real_messages_copy(LibBalsaMailbox * mailbox,
g_return_val_if_fail(LIBBALSA_IS_MAILBOX(dest), FALSE);
g_return_val_if_fail(dest != mailbox, FALSE);
- text = g_strdup_printf(_("Copying from %s to %s"), mailbox->name,
- dest->name);
+ text = g_strdup_printf(_("Copying from %s to %s"), priv->name,
+ dest_priv->name);
mcd.progress = LIBBALSA_PROGRESS_INIT;
libbalsa_progress_set_text(&mcd.progress, text, msgnos->len);
g_free(text);
@@ -1049,40 +1093,40 @@ libbalsa_mailbox_real_messages_copy(LibBalsaMailbox * mailbox,
return successfully_copied == msgnos->len;
}
-static gint mbox_compare_func(const SortTuple * a,
+static gint mailbox_compare_func(const SortTuple * a,
const SortTuple * b,
- LibBalsaMailbox * mbox);
+ LibBalsaMailbox * mailbox);
static void
-libbalsa_mailbox_real_sort(LibBalsaMailbox* mbox, GArray *sort_array)
+libbalsa_mailbox_real_sort(LibBalsaMailbox* mailbox, GArray *sort_array)
{
/* Sort the array */
g_array_sort_with_data(sort_array,
- (GCompareDataFunc) mbox_compare_func, mbox);
+ (GCompareDataFunc) mailbox_compare_func, mailbox);
}
static void
libbalsa_mailbox_real_save_config(LibBalsaMailbox * mailbox,
const gchar * group)
{
- g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
libbalsa_conf_set_string("Type",
g_type_name(G_OBJECT_TYPE(mailbox)));
- libbalsa_conf_set_string("Name", mailbox->name);
+ libbalsa_conf_set_string("Name", priv->name);
}
static void
libbalsa_mailbox_real_load_config(LibBalsaMailbox * mailbox,
const gchar * group)
{
- g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
- g_free(mailbox->config_prefix);
- mailbox->config_prefix = g_strdup(group);
+ g_free(priv->config_prefix);
+ priv->config_prefix = g_strdup(group);
- g_free(mailbox->name);
- mailbox->name = libbalsa_conf_get_string("Name=Mailbox");
+ g_free(priv->name);
+ priv->name = libbalsa_conf_get_string("Name=Mailbox");
}
static gboolean
@@ -1148,7 +1192,7 @@ libbalsa_mailbox_type_from_path(const gchar * path)
return LIBBALSA_TYPE_MAILBOX_MH;
} else {
- /* Minimal check for an mbox */
+ /* Minimal check for an mailbox */
gint fd;
if ((fd = open(path, O_RDONLY)) >= 0) {
@@ -1178,7 +1222,7 @@ lbm_node_has_unseen_child(LibBalsaMailbox * lmm, GNode * node)
{
for (node = node->children; node; node = node->next) {
LibBalsaMailboxIndexEntry *entry =
- /* g_ptr_array_index(lmm->mindex, msgno - 1); ?? */
+ /* g_ptr_array_index(priv->mindex, msgno - 1); ?? */
lbm_get_index_entry(lmm, GPOINTER_TO_UINT(node->data));
if ((entry && entry->unseen) || lbm_node_has_unseen_child(lmm, node))
return TRUE;
@@ -1186,7 +1230,7 @@ lbm_node_has_unseen_child(LibBalsaMailbox * lmm, GNode * node)
return FALSE;
}
-/* Protects access to mailbox->msgnos_changed; may be locked
+/* Protects access to priv->msgnos_changed; may be locked
* with or without the gdk lock, so WE MUST NOT GRAB THE GDK LOCK WHILE
* HOLDING IT. */
@@ -1198,8 +1242,10 @@ static void lbm_update_msgnos(LibBalsaMailbox * mailbox, guint seqno,
static void
lbm_msgno_changed_expunged_cb(LibBalsaMailbox * mailbox, guint seqno)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
g_mutex_lock(&msgnos_changed_lock);
- lbm_update_msgnos(mailbox, seqno, mailbox->msgnos_changed);
+ lbm_update_msgnos(mailbox, seqno, priv->msgnos_changed);
g_mutex_unlock(&msgnos_changed_lock);
}
@@ -1208,17 +1254,19 @@ static void
lbm_msgno_row_changed(LibBalsaMailbox * mailbox, guint msgno,
GtkTreeIter * iter)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
if (!iter->user_data)
iter->user_data =
- g_node_find(mailbox->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL,
+ g_node_find(priv->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL,
GUINT_TO_POINTER(msgno));
if (iter->user_data) {
GtkTreePath *path;
- iter->stamp = mailbox->stamp;
+ iter->stamp = priv->stamp;
path = gtk_tree_model_get_path(GTK_TREE_MODEL(mailbox), iter);
- g_signal_emit(mailbox, libbalsa_mbox_model_signals[ROW_CHANGED], 0,
+ g_signal_emit(mailbox, libbalsa_mailbox_model_signals[ROW_CHANGED], 0,
path, iter);
gtk_tree_path_free(path);
}
@@ -1228,27 +1276,28 @@ lbm_msgno_row_changed(LibBalsaMailbox * mailbox, guint msgno,
static gboolean
lbm_msgnos_changed_idle_cb(LibBalsaMailbox * mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
guint i;
- if (!mailbox->msgnos_changed)
+ if (!priv->msgnos_changed)
return FALSE;
#define DEBUG FALSE
#if DEBUG
- g_print("%s %s %d requested\n", __func__, mailbox->name,
- mailbox->msgnos_changed->len);
+ g_print("%s %s %d requested\n", __func__, priv->name,
+ priv->msgnos_changed->len);
#endif
g_mutex_lock(&msgnos_changed_lock);
- for (i = 0; i < mailbox->msgnos_changed->len; i++) {
- guint msgno = g_array_index(mailbox->msgnos_changed, guint, i);
+ for (i = 0; i < priv->msgnos_changed->len; i++) {
+ guint msgno = g_array_index(priv->msgnos_changed, guint, i);
GtkTreeIter iter;
if (!MAILBOX_OPEN(mailbox))
break;
#if DEBUG
- g_print("%s %s msgno %d\n", __func__, mailbox->name, msgno);
+ g_print("%s %s msgno %d\n", __func__, priv->name, msgno);
#endif
g_mutex_unlock(&msgnos_changed_lock);
iter.user_data = NULL;
@@ -1257,10 +1306,10 @@ lbm_msgnos_changed_idle_cb(LibBalsaMailbox * mailbox)
}
#if DEBUG
- g_print("%s %s %d processed\n", __func__, mailbox->name,
- mailbox->msgnos_changed->len);
+ g_print("%s %s %d processed\n", __func__, priv->name,
+ priv->msgnos_changed->len);
#endif
- mailbox->msgnos_changed->len = 0;
+ priv->msgnos_changed->len = 0;
g_mutex_unlock(&msgnos_changed_lock);
g_object_unref(mailbox);
@@ -1272,27 +1321,29 @@ static void
lbm_msgno_changed(LibBalsaMailbox * mailbox, guint seqno,
GtkTreeIter * iter)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
if (libbalsa_am_i_subthread()) {
g_mutex_lock(&msgnos_changed_lock);
- if (!mailbox->msgnos_changed) {
- mailbox->msgnos_changed =
+ if (!priv->msgnos_changed) {
+ priv->msgnos_changed =
g_array_new(FALSE, FALSE, sizeof(guint));
g_signal_connect(mailbox, "message-expunged",
G_CALLBACK(lbm_msgno_changed_expunged_cb),
NULL);
}
- if (mailbox->msgnos_changed->len == 0)
+ if (priv->msgnos_changed->len == 0)
g_idle_add((GSourceFunc) lbm_msgnos_changed_idle_cb,
g_object_ref(mailbox));
- g_array_append_val(mailbox->msgnos_changed, seqno);
+ g_array_append_val(priv->msgnos_changed, seqno);
g_mutex_unlock(&msgnos_changed_lock);
/* Not calling lbm_msgno_row_changed, so we must make sure
* iter->user_data is set: */
if (!iter->user_data)
iter->user_data =
- g_node_find(mailbox->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL,
+ g_node_find(priv->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL,
GUINT_TO_POINTER(seqno));
return;
}
@@ -1303,9 +1354,10 @@ lbm_msgno_changed(LibBalsaMailbox * mailbox, guint seqno,
void
libbalsa_mailbox_msgno_changed(LibBalsaMailbox * mailbox, guint seqno)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GtkTreeIter iter;
- if (!mailbox->msg_tree) {
+ if (!priv->msg_tree) {
return;
}
@@ -1325,10 +1377,12 @@ libbalsa_mailbox_msgno_changed(LibBalsaMailbox * mailbox, guint seqno)
static gboolean
lbm_need_threading_idle_cb(LibBalsaMailbox *mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
libbalsa_lock_mailbox(mailbox);
lbm_set_threading(mailbox);
- mailbox->need_threading_idle_id = 0;
+ priv->need_threading_idle_id = 0;
libbalsa_unlock_mailbox(mailbox);
@@ -1339,63 +1393,65 @@ void
libbalsa_mailbox_msgno_inserted(LibBalsaMailbox *mailbox, guint seqno,
GNode * parent, GNode ** sibling)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GtkTreeIter iter;
GtkTreePath *path;
- if (!mailbox->msg_tree)
+ if (!priv->msg_tree)
return;
#undef SANITY_CHECK
#ifdef SANITY_CHECK
- g_return_if_fail(!g_node_find(mailbox->msg_tree,
+ g_return_if_fail(!g_node_find(priv->msg_tree,
G_PRE_ORDER, G_TRAVERSE_ALL,
GUINT_TO_POINTER(seqno)));
#endif
/* Insert node into the message tree before getting path. */
iter.user_data = g_node_new(GUINT_TO_POINTER(seqno));
- iter.stamp = mailbox->stamp;
+ iter.stamp = priv->stamp;
*sibling = g_node_insert_after(parent, *sibling, iter.user_data);
if (g_signal_has_handler_pending(mailbox,
- libbalsa_mbox_model_signals
+ libbalsa_mailbox_model_signals
[ROW_INSERTED], 0, FALSE)) {
path = gtk_tree_model_get_path(GTK_TREE_MODEL(mailbox), &iter);
- g_signal_emit(mailbox, libbalsa_mbox_model_signals[ROW_INSERTED],
+ g_signal_emit(mailbox, libbalsa_mailbox_model_signals[ROW_INSERTED],
0, path, &iter);
gtk_tree_path_free(path);
}
libbalsa_lock_mailbox(mailbox);
- if (mailbox->need_threading_idle_id == 0) {
- mailbox->need_threading_idle_id =
+ if (priv->need_threading_idle_id == 0) {
+ priv->need_threading_idle_id =
g_idle_add((GSourceFunc) lbm_need_threading_idle_cb, mailbox);
}
libbalsa_unlock_mailbox(mailbox);
- mailbox->msg_tree_changed = TRUE;
+ priv->msg_tree_changed = TRUE;
}
static void
libbalsa_mailbox_msgno_filt_in(LibBalsaMailbox *mailbox, guint seqno)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GtkTreeIter iter;
GtkTreePath *path;
- if (!mailbox->msg_tree) {
+ if (!priv->msg_tree) {
return;
}
/* Insert node into the message tree before getting path. */
iter.user_data = g_node_new(GUINT_TO_POINTER(seqno));
- iter.stamp = mailbox->stamp;
- g_node_prepend(mailbox->msg_tree, iter.user_data);
+ iter.stamp = priv->stamp;
+ g_node_prepend(priv->msg_tree, iter.user_data);
path = gtk_tree_model_get_path(GTK_TREE_MODEL(mailbox), &iter);
- g_signal_emit(mailbox, libbalsa_mbox_model_signals[ROW_INSERTED], 0,
+ g_signal_emit(mailbox, libbalsa_mailbox_model_signals[ROW_INSERTED], 0,
path, &iter);
gtk_tree_path_free(path);
- mailbox->msg_tree_changed = TRUE;
+ priv->msg_tree_changed = TRUE;
lbm_changed_schedule_idle(mailbox);
}
@@ -1422,6 +1478,7 @@ decrease_post(GNode *node, gpointer data)
void
libbalsa_mailbox_msgno_removed(LibBalsaMailbox * mailbox, guint seqno)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GtkTreeIter iter;
GtkTreePath *path;
struct remove_data dt;
@@ -1431,7 +1488,7 @@ libbalsa_mailbox_msgno_removed(LibBalsaMailbox * mailbox, guint seqno)
g_signal_emit(mailbox, libbalsa_mailbox_signals[MESSAGE_EXPUNGED],
0, seqno);
- if (!mailbox->msg_tree) {
+ if (!priv->msg_tree) {
return;
}
@@ -1439,13 +1496,13 @@ libbalsa_mailbox_msgno_removed(LibBalsaMailbox * mailbox, guint seqno)
dt.seqno = seqno;
dt.node = NULL;
- g_node_traverse(mailbox->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
+ g_node_traverse(priv->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
decrease_post, &dt);
- if (seqno <= mailbox->mindex->len)
- g_ptr_array_remove_index(mailbox->mindex, seqno - 1);
+ if (seqno <= priv->mindex->len)
+ g_ptr_array_remove_index(priv->mindex, seqno - 1);
- mailbox->msg_tree_changed = TRUE;
+ priv->msg_tree_changed = TRUE;
if (!dt.node) {
/* It's ok, apparently the view did not include this message */
@@ -1453,7 +1510,7 @@ libbalsa_mailbox_msgno_removed(LibBalsaMailbox * mailbox, guint seqno)
}
iter.user_data = dt.node;
- iter.stamp = mailbox->stamp;
+ iter.stamp = priv->stamp;
path = gtk_tree_model_get_path(GTK_TREE_MODEL(mailbox), &iter);
/* First promote any children to the node's parent; we'll insert
@@ -1469,51 +1526,52 @@ libbalsa_mailbox_msgno_removed(LibBalsaMailbox * mailbox, guint seqno)
/* Notify the tree-view about the new location of the child. */
iter.user_data = child;
- g_signal_emit(mailbox, libbalsa_mbox_model_signals[ROW_INSERTED], 0,
+ g_signal_emit(mailbox, libbalsa_mailbox_model_signals[ROW_INSERTED], 0,
path, &iter);
if (child->children)
g_signal_emit(mailbox,
- libbalsa_mbox_model_signals[ROW_HAS_CHILD_TOGGLED],
+ libbalsa_mailbox_model_signals[ROW_HAS_CHILD_TOGGLED],
0, path, &iter);
gtk_tree_path_next(path);
}
libbalsa_lock_mailbox(mailbox);
- if (mailbox->need_threading_idle_id == 0) {
- mailbox->need_threading_idle_id =
+ if (priv->need_threading_idle_id == 0) {
+ priv->need_threading_idle_id =
g_idle_add((GSourceFunc) lbm_need_threading_idle_cb, mailbox);
}
libbalsa_unlock_mailbox(mailbox);
/* Now it's safe to destroy the node. */
g_node_destroy(dt.node);
- g_signal_emit(mailbox, libbalsa_mbox_model_signals[ROW_DELETED], 0, path);
+ g_signal_emit(mailbox, libbalsa_mailbox_model_signals[ROW_DELETED], 0, path);
if (parent->parent && !parent->children) {
gtk_tree_path_up(path);
iter.user_data = parent;
g_signal_emit(mailbox,
- libbalsa_mbox_model_signals[ROW_HAS_CHILD_TOGGLED], 0,
+ libbalsa_mailbox_model_signals[ROW_HAS_CHILD_TOGGLED], 0,
path, &iter);
}
gtk_tree_path_free(path);
- mailbox->stamp++;
+ priv->stamp++;
}
static void
libbalsa_mailbox_msgno_filt_out(LibBalsaMailbox * mailbox, GNode * node)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GtkTreeIter iter;
GtkTreePath *path;
GNode *child, *parent;
- if (!mailbox->msg_tree) {
+ if (!priv->msg_tree) {
return;
}
iter.user_data = node;
- iter.stamp = mailbox->stamp;
+ iter.stamp = priv->stamp;
path = gtk_tree_model_get_path(GTK_TREE_MODEL(mailbox), &iter);
/* First promote any children to the node's parent; we'll insert
@@ -1529,31 +1587,31 @@ libbalsa_mailbox_msgno_filt_out(LibBalsaMailbox * mailbox, GNode * node)
/* Notify the tree-view about the new location of the child. */
iter.user_data = child;
- g_signal_emit(mailbox, libbalsa_mbox_model_signals[ROW_INSERTED], 0,
+ g_signal_emit(mailbox, libbalsa_mailbox_model_signals[ROW_INSERTED], 0,
path, &iter);
if (child->children)
g_signal_emit(mailbox,
- libbalsa_mbox_model_signals[ROW_HAS_CHILD_TOGGLED],
+ libbalsa_mailbox_model_signals[ROW_HAS_CHILD_TOGGLED],
0, path, &iter);
gtk_tree_path_next(path);
}
/* Now it's safe to destroy the node. */
g_node_destroy(node);
- g_signal_emit(mailbox, libbalsa_mbox_model_signals[ROW_DELETED], 0, path);
+ g_signal_emit(mailbox, libbalsa_mailbox_model_signals[ROW_DELETED], 0, path);
if (parent->parent && !parent->children) {
gtk_tree_path_up(path);
iter.user_data = parent;
g_signal_emit(mailbox,
- libbalsa_mbox_model_signals[ROW_HAS_CHILD_TOGGLED], 0,
+ libbalsa_mailbox_model_signals[ROW_HAS_CHILD_TOGGLED], 0,
path, &iter);
}
gtk_tree_path_free(path);
- mailbox->stamp++;
+ priv->stamp++;
- mailbox->msg_tree_changed = TRUE;
+ priv->msg_tree_changed = TRUE;
lbm_changed_schedule_idle(mailbox);
}
@@ -1570,12 +1628,13 @@ lbm_msgno_filt_check(LibBalsaMailbox * mailbox, guint seqno,
LibBalsaMailboxSearchIter * search_iter,
gboolean hold_selected)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
gboolean match;
GNode *node;
match = search_iter ?
libbalsa_mailbox_message_match(mailbox, seqno, search_iter) : TRUE;
- node = g_node_find(mailbox->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL,
+ node = g_node_find(priv->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL,
GUINT_TO_POINTER(seqno));
if (node) {
if (!match) {
@@ -1628,9 +1687,11 @@ libbalsa_mailbox_msgno_filt_check(LibBalsaMailbox * mailbox, guint seqno,
LibBalsaMailboxSearchIter * search_iter,
gboolean hold_selected)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
- if (!mailbox->msg_tree) {
+ if (!priv->msg_tree) {
return;
}
@@ -1671,9 +1732,11 @@ libbalsa_mailbox_search_iter_new(LibBalsaCondition * condition)
LibBalsaMailboxSearchIter *
libbalsa_mailbox_search_iter_view(LibBalsaMailbox * mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), NULL);
- return libbalsa_mailbox_search_iter_new(mailbox->view_filter);
+ return libbalsa_mailbox_search_iter_new(priv->view_filter);
}
/* Increment reference count of a LibBalsaMailboxSearchIter, if it is
@@ -1761,17 +1824,18 @@ gboolean
libbalsa_mailbox_msgno_find(LibBalsaMailbox * mailbox, guint seqno,
GtkTreePath ** path, GtkTreeIter * iter)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GtkTreeIter tmp_iter;
g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), FALSE);
g_return_val_if_fail(seqno > 0, FALSE);
- if (!mailbox->msg_tree || !(tmp_iter.user_data =
- g_node_find(mailbox->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL,
+ if (!priv->msg_tree || !(tmp_iter.user_data =
+ g_node_find(priv->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL,
GINT_TO_POINTER(seqno))))
return FALSE;
- tmp_iter.stamp = mailbox->stamp;
+ tmp_iter.stamp = priv->stamp;
if (path)
*path =
@@ -1885,11 +1949,12 @@ libbalsa_mailbox_total_messages(LibBalsaMailbox * mailbox)
gboolean
libbalsa_mailbox_sync_storage(LibBalsaMailbox * mailbox, gboolean expunge)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
gboolean retval = TRUE;
g_return_val_if_fail(mailbox != NULL, FALSE);
g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), FALSE);
- g_return_val_if_fail(!mailbox->readonly, TRUE);
+ g_return_val_if_fail(!priv->readonly, TRUE);
libbalsa_lock_mailbox(mailbox);
@@ -1910,15 +1975,16 @@ static void
lbm_cache_message(LibBalsaMailbox * mailbox, guint msgno,
LibBalsaMessage * message)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
LibBalsaMailboxIndexEntry *entry;
- if (mailbox->mindex->len < msgno)
- g_ptr_array_set_size(mailbox->mindex, msgno);
+ if (priv->mindex->len < msgno)
+ g_ptr_array_set_size(priv->mindex, msgno);
- entry = g_ptr_array_index(mailbox->mindex, msgno - 1);
+ entry = g_ptr_array_index(priv->mindex, msgno - 1);
if (!entry) {
- g_ptr_array_index(mailbox->mindex, msgno - 1) =
+ g_ptr_array_index(priv->mindex, msgno - 1) =
entry = g_new(LibBalsaMailboxIndexEntry, 1);
lbm_index_entry_populate_from_msg(entry, message);
} else if (entry->idle_pending)
@@ -1928,6 +1994,7 @@ lbm_cache_message(LibBalsaMailbox * mailbox, guint msgno,
LibBalsaMessage *
libbalsa_mailbox_get_message(LibBalsaMailbox * mailbox, guint msgno)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
LibBalsaMessage *message;
g_return_val_if_fail(mailbox != NULL, NULL);
@@ -1937,7 +2004,7 @@ libbalsa_mailbox_get_message(LibBalsaMailbox * mailbox, guint msgno)
if (!MAILBOX_OPEN(mailbox)) {
g_message(_("libbalsa_mailbox_get_message: mailbox %s is closed"),
- mailbox->name);
+ priv->name);
libbalsa_unlock_mailbox(mailbox);
return NULL;
}
@@ -1950,7 +2017,7 @@ libbalsa_mailbox_get_message(LibBalsaMailbox * mailbox, guint msgno)
message = LIBBALSA_MAILBOX_GET_CLASS(mailbox)->get_message(mailbox,
msgno);
- if (message && mailbox->mindex)
+ if (message && priv->mindex)
/* Cache the message info, if we do not already have it. */
lbm_cache_message(mailbox, msgno, message);
@@ -2046,6 +2113,7 @@ libbalsa_mailbox_messages_change_flags(LibBalsaMailbox * mailbox,
LibBalsaMessageFlag set,
LibBalsaMessageFlag clear)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
gboolean retval;
guint i;
gboolean real_flag;
@@ -2053,7 +2121,7 @@ libbalsa_mailbox_messages_change_flags(LibBalsaMailbox * mailbox,
g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), FALSE);
real_flag = (set | clear) & LIBBALSA_MESSAGE_FLAGS_REAL;
- g_return_val_if_fail(!mailbox->readonly || !real_flag, FALSE);
+ g_return_val_if_fail(!priv->readonly || !real_flag, FALSE);
if (msgnos->len == 0)
return TRUE;
@@ -2064,7 +2132,7 @@ libbalsa_mailbox_messages_change_flags(LibBalsaMailbox * mailbox,
retval = LIBBALSA_MAILBOX_GET_CLASS(mailbox)->
messages_change_flags(mailbox, msgnos, set, clear);
- if (retval && mailbox->mindex && mailbox->view_filter) {
+ if (retval && priv->mindex && priv->view_filter) {
LibBalsaMailboxSearchIter *iter_view =
libbalsa_mailbox_search_iter_view(mailbox);
for (i = 0; i < msgnos->len; i++) {
@@ -2163,21 +2231,22 @@ libbalsa_mailbox_set_view_filter(LibBalsaMailbox *mailbox,
LibBalsaCondition *cond,
gboolean update_immediately)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
gboolean retval = FALSE;
libbalsa_lock_mailbox(mailbox);
- if (!libbalsa_condition_compare(mailbox->view_filter, cond))
- mailbox->view_filter_pending = TRUE;
+ if (!libbalsa_condition_compare(priv->view_filter, cond))
+ priv->view_filter_pending = TRUE;
- libbalsa_condition_unref(mailbox->view_filter);
- mailbox->view_filter = libbalsa_condition_ref(cond);
+ libbalsa_condition_unref(priv->view_filter);
+ priv->view_filter = libbalsa_condition_ref(cond);
- if (update_immediately && mailbox->view_filter_pending) {
+ if (update_immediately && priv->view_filter_pending) {
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->update_view_filter(mailbox,
cond);
retval = lbm_set_threading(mailbox);
- mailbox->view_filter_pending = FALSE;
+ priv->view_filter_pending = FALSE;
}
libbalsa_unlock_mailbox(mailbox);
@@ -2188,9 +2257,11 @@ libbalsa_mailbox_set_view_filter(LibBalsaMailbox *mailbox,
void
libbalsa_mailbox_make_view_filter_persistent(LibBalsaMailbox * mailbox)
{
- libbalsa_condition_unref(mailbox->persistent_view_filter);
- mailbox->persistent_view_filter =
- libbalsa_condition_ref(mailbox->view_filter);
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ libbalsa_condition_unref(priv->persistent_view_filter);
+ priv->persistent_view_filter =
+ libbalsa_condition_ref(priv->view_filter);
}
/* Test message flags. */
@@ -2212,7 +2283,7 @@ libbalsa_mailbox_msgno_has_flags(LibBalsaMailbox * mailbox, guint msgno,
some of them may be expensive under certain circumstances and are
best avoided. */
static gboolean
-libbalsa_mailbox_real_can_do(LibBalsaMailbox* mbox,
+libbalsa_mailbox_real_can_do(LibBalsaMailbox* mailbox,
enum LibBalsaMailboxCapability cap)
{
return TRUE;
@@ -2226,13 +2297,15 @@ libbalsa_mailbox_can_do(LibBalsaMailbox *mailbox,
}
-static void lbm_sort(LibBalsaMailbox * mbox, GNode * parent);
+static void lbm_sort(LibBalsaMailbox * mailbox, GNode * parent);
static void
lbm_check_and_sort(LibBalsaMailbox * mailbox)
{
- if (mailbox->msg_tree)
- lbm_sort(mailbox, mailbox->msg_tree);
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ if (priv->msg_tree)
+ lbm_sort(mailbox, priv->msg_tree);
libbalsa_mailbox_changed(mailbox);
}
@@ -2249,11 +2322,13 @@ lbm_set_threading_idle_cb(LibBalsaMailbox * mailbox)
static gboolean
lbm_set_threading(LibBalsaMailbox * mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
if (!MAILBOX_OPEN(mailbox))
return FALSE;
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->set_threading(mailbox,
- mailbox->view->threading_type);
+ priv->view->threading_type);
if (libbalsa_am_i_subthread()) {
g_idle_add((GSourceFunc) lbm_set_threading_idle_cb, g_object_ref(mailbox));
} else {
@@ -2313,7 +2388,7 @@ libbalsa_mailbox_view_new(void)
void
libbalsa_mailbox_view_free(LibBalsaMailboxView * view)
{
- if (!view)
+ if (view == NULL)
return;
g_free(view->identity_name);
@@ -2324,13 +2399,15 @@ libbalsa_mailbox_view_free(LibBalsaMailboxView * view)
static LibBalsaMailboxView *
lbm_get_view(LibBalsaMailbox * mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
if (!mailbox)
return &libbalsa_mailbox_view_default;
- if (!mailbox->view)
- mailbox->view = libbalsa_mailbox_view_new();
+ if (!priv->view)
+ priv->view = libbalsa_mailbox_view_new();
- return mailbox->view;
+ return priv->view;
}
/* Set methods; NULL mailbox is valid, and changes the default value. */
@@ -2339,7 +2416,10 @@ gboolean
libbalsa_mailbox_set_identity_name(LibBalsaMailbox * mailbox,
const gchar * identity_name)
{
- LibBalsaMailboxView *view = lbm_get_view(mailbox);
+ LibBalsaMailboxView *view;
+
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), FALSE);
+ view = lbm_get_view(mailbox);
if (g_strcmp0(view->identity_name, identity_name) != 0) {
g_free(view->identity_name);
@@ -2358,6 +2438,9 @@ libbalsa_mailbox_set_threading_type(LibBalsaMailbox * mailbox,
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
+ g_return_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox));
+ view = lbm_get_view(mailbox);
+
if (view->threading_type != threading_type) {
view->threading_type = threading_type;
if (mailbox)
@@ -2371,6 +2454,9 @@ libbalsa_mailbox_set_subject_gather(LibBalsaMailbox * mailbox,
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
+ g_return_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox));
+ view = lbm_get_view(mailbox);
+
if (view->subject_gather != subject_gather) {
view->subject_gather = subject_gather;
if (mailbox != NULL)
@@ -2384,6 +2470,9 @@ libbalsa_mailbox_set_sort_type(LibBalsaMailbox * mailbox,
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
+ g_return_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox));
+ view = lbm_get_view(mailbox);
+
if (view->sort_type != sort_type) {
view->sort_type = sort_type;
if (mailbox)
@@ -2397,6 +2486,9 @@ libbalsa_mailbox_set_sort_field(LibBalsaMailbox * mailbox,
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
+ g_return_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox));
+ view = lbm_get_view(mailbox);
+
if (view->sort_field != sort_field) {
view->sort_field_prev = view->sort_field;
view->sort_field = sort_field;
@@ -2410,10 +2502,13 @@ libbalsa_mailbox_set_show(LibBalsaMailbox * mailbox, LibBalsaMailboxShow show)
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), FALSE);
+ view = lbm_get_view(mailbox);
+
if (view->show != show) {
/* Don't set not in sync if we're just replacing UNSET with the
* default. */
- if (mailbox && view->show != LB_MAILBOX_SHOW_UNSET)
+ if (mailbox != NULL && view->show != LB_MAILBOX_SHOW_UNSET)
view->in_sync = 0;
view->show = show;
return TRUE;
@@ -2427,6 +2522,9 @@ libbalsa_mailbox_set_subscribe(LibBalsaMailbox * mailbox,
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), FALSE);
+ view = lbm_get_view(mailbox);
+
if (view->subscribe != subscribe) {
/* Don't set not in sync if we're just replacing UNSET with the
* default. */
@@ -2443,6 +2541,9 @@ libbalsa_mailbox_set_exposed(LibBalsaMailbox * mailbox, gboolean exposed)
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
+ g_return_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox));
+ view = lbm_get_view(mailbox);
+
if (view->exposed != exposed) {
view->exposed = exposed ? 1 : 0;
if (mailbox)
@@ -2455,6 +2556,9 @@ libbalsa_mailbox_set_open(LibBalsaMailbox * mailbox, gboolean open)
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
+ g_return_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox));
+ view = lbm_get_view(mailbox);
+
if (view->open != open) {
view->open = open ? 1 : 0;
if (mailbox != NULL) {
@@ -2470,6 +2574,9 @@ libbalsa_mailbox_set_filter(LibBalsaMailbox * mailbox, gint filter)
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
+ g_return_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox));
+ view = lbm_get_view(mailbox);
+
if (view->filter != filter) {
view->filter = filter;
if (mailbox)
@@ -2481,16 +2588,19 @@ gboolean
libbalsa_mailbox_set_crypto_mode(LibBalsaMailbox * mailbox,
LibBalsaChkCryptoMode gpg_chk_mode)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
LibBalsaMailboxView *view;
- g_return_val_if_fail(mailbox != NULL && mailbox->view != NULL, FALSE);
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), FALSE);
+ g_return_val_if_fail(priv->view != NULL, FALSE);
- view = mailbox->view;
+ view = priv->view;
if (view->gpg_chk_mode != gpg_chk_mode) {
view->gpg_chk_mode = gpg_chk_mode;
return TRUE;
- } else
+ } else {
return FALSE;
+ }
}
void
@@ -2499,7 +2609,7 @@ libbalsa_mailbox_set_unread(LibBalsaMailbox * mailbox, gint unread)
LibBalsaMailboxView *view;
/* Changing the default is not allowed. */
- g_return_if_fail(mailbox != NULL);
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
view = lbm_get_view(mailbox);
view->used = 1;
@@ -2516,7 +2626,7 @@ libbalsa_mailbox_set_total(LibBalsaMailbox * mailbox, gint total)
LibBalsaMailboxView *view;
/* Changing the default is not allowed. */
- g_return_if_fail(mailbox != NULL);
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
view = lbm_get_view(mailbox);
@@ -2532,7 +2642,7 @@ libbalsa_mailbox_set_mtime(LibBalsaMailbox * mailbox, time_t mtime)
LibBalsaMailboxView *view;
/* Changing the default is not allowed. */
- g_return_if_fail(mailbox != NULL);
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
view = lbm_get_view(mailbox);
@@ -2548,7 +2658,7 @@ libbalsa_mailbox_set_position(LibBalsaMailbox * mailbox, gint position)
LibBalsaMailboxView *view;
/* Changing the default is not allowed. */
- g_return_if_fail(mailbox != NULL);
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
view = lbm_get_view(mailbox);
view->used = 1;
@@ -2566,8 +2676,12 @@ libbalsa_mailbox_set_position(LibBalsaMailbox * mailbox, gint position)
const gchar *
libbalsa_mailbox_get_identity_name(LibBalsaMailbox * mailbox)
{
- return (mailbox && mailbox->view) ?
- mailbox->view->identity_name :
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), NULL);
+
+ return (mailbox != NULL && priv->view != NULL) ?
+ priv->view->identity_name :
libbalsa_mailbox_view_default.identity_name;
}
@@ -2575,16 +2689,24 @@ libbalsa_mailbox_get_identity_name(LibBalsaMailbox * mailbox)
LibBalsaMailboxThreadingType
libbalsa_mailbox_get_threading_type(LibBalsaMailbox * mailbox)
{
- return (mailbox && mailbox->view) ?
- mailbox->view->threading_type :
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), 0);
+
+ return (mailbox != NULL && priv->view != NULL) ?
+ priv->view->threading_type :
libbalsa_mailbox_view_default.threading_type;
}
gboolean
libbalsa_mailbox_get_subject_gather(LibBalsaMailbox * mailbox)
{
- return (mailbox != NULL && mailbox->view != NULL) ?
- mailbox->view->subject_gather :
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), FALSE);
+
+ return (mailbox != NULL && priv->view != NULL) ?
+ priv->view->subject_gather :
libbalsa_mailbox_view_default.subject_gather;
}
@@ -2592,90 +2714,139 @@ libbalsa_mailbox_get_subject_gather(LibBalsaMailbox * mailbox)
LibBalsaMailboxSortType
libbalsa_mailbox_get_sort_type(LibBalsaMailbox * mailbox)
{
- return (mailbox && mailbox->view) ?
- mailbox->view->sort_type : libbalsa_mailbox_view_default.sort_type;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), 0);
+
+ return (mailbox != NULL && priv->view != NULL) ?
+ priv->view->sort_type : libbalsa_mailbox_view_default.sort_type;
}
LibBalsaMailboxSortFields
libbalsa_mailbox_get_sort_field(LibBalsaMailbox * mailbox)
{
- return (mailbox && mailbox->view) ?
- mailbox->view->sort_field :
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), 0);
+
+ return (mailbox != NULL && priv->view != NULL) ?
+ priv->view->sort_field :
libbalsa_mailbox_view_default.sort_field;
}
LibBalsaMailboxShow
libbalsa_mailbox_get_show(LibBalsaMailbox * mailbox)
{
- return (mailbox && mailbox->view) ?
- mailbox->view->show : libbalsa_mailbox_view_default.show;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), 0);
+
+ return (mailbox != NULL && priv->view != NULL) ?
+ priv->view->show : libbalsa_mailbox_view_default.show;
}
LibBalsaMailboxSubscribe
libbalsa_mailbox_get_subscribe(LibBalsaMailbox * mailbox)
{
- return (mailbox && mailbox->view) ?
- mailbox->view->subscribe : libbalsa_mailbox_view_default.subscribe;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), 0);
+
+ return (mailbox != NULL && priv->view != NULL) ?
+ priv->view->subscribe : libbalsa_mailbox_view_default.subscribe;
}
gboolean
libbalsa_mailbox_get_exposed(LibBalsaMailbox * mailbox)
{
- return (mailbox && mailbox->view) ?
- mailbox->view->exposed : libbalsa_mailbox_view_default.exposed;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), FALSE);
+
+ return (mailbox != NULL && priv->view != NULL) ?
+ priv->view->exposed : libbalsa_mailbox_view_default.exposed;
}
gboolean
libbalsa_mailbox_get_open(LibBalsaMailbox * mailbox)
{
- return (mailbox && mailbox->view) ?
- mailbox->view->open : libbalsa_mailbox_view_default.open;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), FALSE);
+
+ return (mailbox != NULL && priv->view != NULL) ?
+ priv->view->open : libbalsa_mailbox_view_default.open;
}
gint
libbalsa_mailbox_get_filter(LibBalsaMailbox * mailbox)
{
- return (mailbox && mailbox->view) ?
- mailbox->view->filter : libbalsa_mailbox_view_default.filter;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), 0);
+
+ return (mailbox != NULL && priv->view != NULL) ?
+ priv->view->filter : libbalsa_mailbox_view_default.filter;
}
LibBalsaChkCryptoMode
libbalsa_mailbox_get_crypto_mode(LibBalsaMailbox * mailbox)
{
- return (mailbox && mailbox->view) ?
- mailbox->view->gpg_chk_mode :
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), 0);
+
+ return (mailbox != NULL && priv->view != NULL) ?
+ priv->view->gpg_chk_mode :
libbalsa_mailbox_view_default.gpg_chk_mode;
}
gint
libbalsa_mailbox_get_unread(LibBalsaMailbox * mailbox)
{
- if (mailbox && mailbox->view) {
- mailbox->view->used = 1;
- return mailbox->view->unread;
- } else
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), 0);
+
+ if (mailbox != NULL && priv->view != NULL) {
+ priv->view->used = 1;
+ return priv->view->unread;
+ } else {
return libbalsa_mailbox_view_default.unread;
+ }
}
gint
libbalsa_mailbox_get_total(LibBalsaMailbox * mailbox)
{
- return (mailbox && mailbox->view) ?
- mailbox->view->total : libbalsa_mailbox_view_default.total;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), 0);
+
+ return (mailbox != NULL && priv->view != NULL) ?
+ priv->view->total : libbalsa_mailbox_view_default.total;
}
time_t
libbalsa_mailbox_get_mtime(LibBalsaMailbox * mailbox)
{
- return (mailbox && mailbox->view) ?
- mailbox->view->mtime : libbalsa_mailbox_view_default.mtime;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), 0);
+
+ return (mailbox != NULL && priv->view != NULL) ?
+ priv->view->mtime : libbalsa_mailbox_view_default.mtime;
}
gint
libbalsa_mailbox_get_position(LibBalsaMailbox * mailbox)
{
- return (mailbox != NULL && mailbox->view != NULL) ?
- mailbox->view->position : libbalsa_mailbox_view_default.position;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox), 0);
+
+ return (mailbox != NULL && priv->view != NULL) ?
+ priv->view->position : libbalsa_mailbox_view_default.position;
}
/* End of get methods. */
@@ -2692,108 +2863,108 @@ libbalsa_mailbox_get_position(LibBalsaMailbox * mailbox)
((iter)!= NULL && \
(iter)->user_data != NULL && \
LIBBALSA_IS_MAILBOX(tree_model) && \
- ((LibBalsaMailbox *) tree_model)->stamp == (iter)->stamp)
+ ((LibBalsaMailboxPrivate *) libbalsa_mailbox_get_instance_private(((LibBalsaMailbox *)
tree_model)))->stamp == (iter)->stamp)
#define VALIDATE_ITER(iter, tree_model) \
- ((iter)->stamp = ((LibBalsaMailbox *) tree_model)->stamp)
+ ((iter)->stamp = ((LibBalsaMailboxPrivate *) libbalsa_mailbox_get_instance_private((LibBalsaMailbox *)
tree_model))->stamp)
#define INVALIDATE_ITER(iter) ((iter)->stamp = 0)
-static GtkTreeModelFlags mbox_model_get_flags (GtkTreeModel *tree_model);
-static gint mbox_model_get_n_columns (GtkTreeModel *tree_model);
-static GType mbox_model_get_column_type (GtkTreeModel *tree_model,
+static GtkTreeModelFlags mailbox_model_get_flags (GtkTreeModel *tree_model);
+static gint mailbox_model_get_n_columns (GtkTreeModel *tree_model);
+static GType mailbox_model_get_column_type (GtkTreeModel *tree_model,
gint index);
-static gboolean mbox_model_get_iter (GtkTreeModel *tree_model,
+static gboolean mailbox_model_get_iter (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreePath *path);
-static GtkTreePath *mbox_model_get_path (GtkTreeModel *tree_model,
+static GtkTreePath *mailbox_model_get_path (GtkTreeModel *tree_model,
GtkTreeIter *iter);
-static void mbox_model_get_value (GtkTreeModel *tree_model,
+static void mailbox_model_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
gint column,
GValue *value);
-static gboolean mbox_model_iter_next (GtkTreeModel *tree_model,
+static gboolean mailbox_model_iter_next (GtkTreeModel *tree_model,
GtkTreeIter *iter);
-static gboolean mbox_model_iter_children (GtkTreeModel *tree_model,
+static gboolean mailbox_model_iter_children (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent);
-static gboolean mbox_model_iter_has_child (GtkTreeModel *tree_model,
+static gboolean mailbox_model_iter_has_child (GtkTreeModel *tree_model,
GtkTreeIter *iter);
-static gint mbox_model_iter_n_children (GtkTreeModel *tree_model,
+static gint mailbox_model_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter);
-static gboolean mbox_model_iter_nth_child (GtkTreeModel *tree_model,
+static gboolean mailbox_model_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
gint n);
-static gboolean mbox_model_iter_parent (GtkTreeModel *tree_model,
+static gboolean mailbox_model_iter_parent (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *child);
-static GType mbox_model_col_type[LB_MBOX_N_COLS];
+static GType mailbox_model_col_type[LB_MBOX_N_COLS];
static void
-mbox_model_init(GtkTreeModelIface *iface)
-{
- iface->get_flags = mbox_model_get_flags;
- iface->get_n_columns = mbox_model_get_n_columns;
- iface->get_column_type = mbox_model_get_column_type;
- iface->get_iter = mbox_model_get_iter;
- iface->get_path = mbox_model_get_path;
- iface->get_value = mbox_model_get_value;
- iface->iter_next = mbox_model_iter_next;
- iface->iter_children = mbox_model_iter_children;
- iface->iter_has_child = mbox_model_iter_has_child;
- iface->iter_n_children = mbox_model_iter_n_children;
- iface->iter_nth_child = mbox_model_iter_nth_child;
- iface->iter_parent = mbox_model_iter_parent;
-
- mbox_model_col_type[LB_MBOX_MSGNO_COL] = G_TYPE_UINT;
- mbox_model_col_type[LB_MBOX_MARKED_COL] = GDK_TYPE_PIXBUF;
- mbox_model_col_type[LB_MBOX_ATTACH_COL] = GDK_TYPE_PIXBUF;
- mbox_model_col_type[LB_MBOX_FROM_COL] = G_TYPE_STRING;
- mbox_model_col_type[LB_MBOX_SUBJECT_COL] = G_TYPE_STRING;
- mbox_model_col_type[LB_MBOX_DATE_COL] = G_TYPE_STRING;
- mbox_model_col_type[LB_MBOX_SIZE_COL] = G_TYPE_STRING;
- mbox_model_col_type[LB_MBOX_WEIGHT_COL] = G_TYPE_INT;
- mbox_model_col_type[LB_MBOX_STYLE_COL] = PANGO_TYPE_STYLE;
- mbox_model_col_type[LB_MBOX_FOREGROUND_COL] = G_TYPE_STRING;
- mbox_model_col_type[LB_MBOX_FOREGROUND_SET_COL] = G_TYPE_BOOLEAN;
- mbox_model_col_type[LB_MBOX_BACKGROUND_COL] = G_TYPE_STRING;
- mbox_model_col_type[LB_MBOX_BACKGROUND_SET_COL] = G_TYPE_BOOLEAN;
-
-
- libbalsa_mbox_model_signals[ROW_CHANGED] =
+mailbox_model_init(GtkTreeModelIface *iface)
+{
+ iface->get_flags = mailbox_model_get_flags;
+ iface->get_n_columns = mailbox_model_get_n_columns;
+ iface->get_column_type = mailbox_model_get_column_type;
+ iface->get_iter = mailbox_model_get_iter;
+ iface->get_path = mailbox_model_get_path;
+ iface->get_value = mailbox_model_get_value;
+ iface->iter_next = mailbox_model_iter_next;
+ iface->iter_children = mailbox_model_iter_children;
+ iface->iter_has_child = mailbox_model_iter_has_child;
+ iface->iter_n_children = mailbox_model_iter_n_children;
+ iface->iter_nth_child = mailbox_model_iter_nth_child;
+ iface->iter_parent = mailbox_model_iter_parent;
+
+ mailbox_model_col_type[LB_MBOX_MSGNO_COL] = G_TYPE_UINT;
+ mailbox_model_col_type[LB_MBOX_MARKED_COL] = GDK_TYPE_PIXBUF;
+ mailbox_model_col_type[LB_MBOX_ATTACH_COL] = GDK_TYPE_PIXBUF;
+ mailbox_model_col_type[LB_MBOX_FROM_COL] = G_TYPE_STRING;
+ mailbox_model_col_type[LB_MBOX_SUBJECT_COL] = G_TYPE_STRING;
+ mailbox_model_col_type[LB_MBOX_DATE_COL] = G_TYPE_STRING;
+ mailbox_model_col_type[LB_MBOX_SIZE_COL] = G_TYPE_STRING;
+ mailbox_model_col_type[LB_MBOX_WEIGHT_COL] = G_TYPE_INT;
+ mailbox_model_col_type[LB_MBOX_STYLE_COL] = PANGO_TYPE_STYLE;
+ mailbox_model_col_type[LB_MBOX_FOREGROUND_COL] = G_TYPE_STRING;
+ mailbox_model_col_type[LB_MBOX_FOREGROUND_SET_COL] = G_TYPE_BOOLEAN;
+ mailbox_model_col_type[LB_MBOX_BACKGROUND_COL] = G_TYPE_STRING;
+ mailbox_model_col_type[LB_MBOX_BACKGROUND_SET_COL] = G_TYPE_BOOLEAN;
+
+
+ libbalsa_mailbox_model_signals[ROW_CHANGED] =
g_signal_lookup("row-changed", GTK_TYPE_TREE_MODEL);
- libbalsa_mbox_model_signals[ROW_DELETED] =
+ libbalsa_mailbox_model_signals[ROW_DELETED] =
g_signal_lookup("row-deleted", GTK_TYPE_TREE_MODEL);
- libbalsa_mbox_model_signals[ROW_HAS_CHILD_TOGGLED] =
+ libbalsa_mailbox_model_signals[ROW_HAS_CHILD_TOGGLED] =
g_signal_lookup("row-has-child-toggled", GTK_TYPE_TREE_MODEL);
- libbalsa_mbox_model_signals[ROW_INSERTED] =
+ libbalsa_mailbox_model_signals[ROW_INSERTED] =
g_signal_lookup("row-inserted", GTK_TYPE_TREE_MODEL);
- libbalsa_mbox_model_signals[ROWS_REORDERED] =
+ libbalsa_mailbox_model_signals[ROWS_REORDERED] =
g_signal_lookup("rows-reordered", GTK_TYPE_TREE_MODEL);
}
static GtkTreeModelFlags
-mbox_model_get_flags(GtkTreeModel *tree_model)
+mailbox_model_get_flags(GtkTreeModel *tree_model)
{
return 0;
}
static gint
-mbox_model_get_n_columns(GtkTreeModel *tree_model)
+mailbox_model_get_n_columns(GtkTreeModel *tree_model)
{
return LB_MBOX_N_COLS;
}
static GType
-mbox_model_get_column_type(GtkTreeModel *tree_model, gint index)
+mailbox_model_get_column_type(GtkTreeModel *tree_model, gint index)
{
g_return_val_if_fail(index>=0 && index <LB_MBOX_N_COLS, G_TYPE_BOOLEAN);
- return mbox_model_col_type[index];
+ return mailbox_model_col_type[index];
}
static gboolean
-mbox_model_get_iter(GtkTreeModel *tree_model,
+mailbox_model_get_iter(GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreePath *path)
{
@@ -2809,12 +2980,12 @@ mbox_model_get_iter(GtkTreeModel *tree_model,
g_return_val_if_fail(depth > 0, FALSE);
- if (!mbox_model_iter_nth_child(tree_model, iter, NULL, indices[0]))
+ if (!mailbox_model_iter_nth_child(tree_model, iter, NULL, indices[0]))
return FALSE;
for (i = 1; i < depth; i++) {
parent = *iter;
- if (!mbox_model_iter_nth_child(tree_model, iter, &parent,
+ if (!mailbox_model_iter_nth_child(tree_model, iter, &parent,
indices[i]))
return FALSE;
}
@@ -2823,7 +2994,7 @@ mbox_model_get_iter(GtkTreeModel *tree_model,
}
static GtkTreePath *
-mbox_model_get_path_helper(GNode * node, GNode * msg_tree)
+mailbox_model_get_path_helper(GNode * node, GNode * msg_tree)
{
GtkTreePath *path = gtk_tree_path_new();
@@ -2844,8 +3015,10 @@ mbox_model_get_path_helper(GNode * node, GNode * msg_tree)
}
static GtkTreePath *
-mbox_model_get_path(GtkTreeModel * tree_model, GtkTreeIter * iter)
+mailbox_model_get_path(GtkTreeModel * tree_model, GtkTreeIter * iter)
{
+ LibBalsaMailbox *mailbox = (LibBalsaMailbox *) tree_model;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GNode *node;
#ifdef SANITY_CHECK
GNode *parent_node;
@@ -2862,12 +3035,10 @@ mbox_model_get_path(GtkTreeModel * tree_model, GtkTreeIter * iter)
g_return_val_if_fail(node->parent != NULL, NULL);
- return mbox_model_get_path_helper(node,
- LIBBALSA_MAILBOX(tree_model)->
- msg_tree);
+ return mailbox_model_get_path_helper(node, priv->msg_tree);
}
-/* mbox_model_get_value:
+/* mailbox_model_get_value:
FIXME: still includes some debugging code in case fetching the
message failed.
*/
@@ -2876,36 +3047,39 @@ static GdkPixbuf *status_icons[LIBBALSA_MESSAGE_STATUS_ICONS_NUM];
static GdkPixbuf *attach_icons[LIBBALSA_MESSAGE_ATTACH_ICONS_NUM];
-/* Protects access to mailbox->msgnos_pending; */
+/* Protects access to priv->msgnos_pending; */
static GMutex get_index_entry_lock;
static void
lbm_get_index_entry_expunged_cb(LibBalsaMailbox * mailbox, guint seqno)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
g_mutex_lock(&get_index_entry_lock);
- lbm_update_msgnos(mailbox, seqno, mailbox->msgnos_pending);
+ lbm_update_msgnos(mailbox, seqno, priv->msgnos_pending);
g_mutex_unlock(&get_index_entry_lock);
}
static void
lbm_get_index_entry_real(LibBalsaMailbox * mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
guint i;
#if DEBUG
- g_print("%s %s %d requested\n", __func__, mailbox->name,
- mailbox->msgnos_pending->len);
+ g_print("%s %s %d requested\n", __func__, priv->name,
+ priv->msgnos_pending->len);
#endif
g_mutex_lock(&get_index_entry_lock);
- for (i = 0; i < mailbox->msgnos_pending->len; i++) {
- guint msgno = g_array_index(mailbox->msgnos_pending, guint, i);
+ for (i = 0; i < priv->msgnos_pending->len; i++) {
+ guint msgno = g_array_index(priv->msgnos_pending, guint, i);
LibBalsaMessage *message;
if (!MAILBOX_OPEN(mailbox))
break;
#if DEBUG
- g_print("%s %s msgno %d\n", __func__, mailbox->name, msgno);
+ g_print("%s %s msgno %d\n", __func__, priv->name, msgno);
#endif
g_mutex_unlock(&get_index_entry_lock);
if ((message = libbalsa_mailbox_get_message(mailbox, msgno)))
@@ -2916,10 +3090,10 @@ lbm_get_index_entry_real(LibBalsaMailbox * mailbox)
}
#if DEBUG
- g_print("%s %s %d processed\n", __func__, mailbox->name,
- mailbox->msgnos_pending->len);
+ g_print("%s %s %d processed\n", __func__, priv->name,
+ priv->msgnos_pending->len);
#endif
- mailbox->msgnos_pending->len = 0;
+ priv->msgnos_pending->len = 0;
g_mutex_unlock(&get_index_entry_lock);
g_object_unref(mailbox);
@@ -2929,26 +3103,27 @@ lbm_get_index_entry_real(LibBalsaMailbox * mailbox)
static LibBalsaMailboxIndexEntry *
lbm_get_index_entry(LibBalsaMailbox * lmm, guint msgno)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(lmm);
LibBalsaMailboxIndexEntry *entry;
- if (!lmm->mindex)
+ if (!priv->mindex)
return NULL;
- if (lmm->mindex->len < msgno )
- g_ptr_array_set_size(lmm->mindex, msgno);
+ if (priv->mindex->len < msgno )
+ g_ptr_array_set_size(priv->mindex, msgno);
- entry = g_ptr_array_index(lmm->mindex, msgno - 1);
+ entry = g_ptr_array_index(priv->mindex, msgno - 1);
if (entry)
return entry->idle_pending ? NULL : entry;
g_mutex_lock(&get_index_entry_lock);
- if (!lmm->msgnos_pending) {
- lmm->msgnos_pending = g_array_new(FALSE, FALSE, sizeof(guint));
+ if (!priv->msgnos_pending) {
+ priv->msgnos_pending = g_array_new(FALSE, FALSE, sizeof(guint));
g_signal_connect(lmm, "message-expunged",
G_CALLBACK(lbm_get_index_entry_expunged_cb), NULL);
}
- if (!lmm->msgnos_pending->len) {
+ if (!priv->msgnos_pending->len) {
GThread *get_index_entry_thread;
g_object_ref(lmm);
@@ -2959,10 +3134,10 @@ lbm_get_index_entry(LibBalsaMailbox * lmm, guint msgno)
g_thread_unref(get_index_entry_thread);
}
- g_array_append_val(lmm->msgnos_pending, msgno);
+ g_array_append_val(priv->msgnos_pending, msgno);
/* Make sure we have a "pending" index entry before releasing the
* lock. */
- g_ptr_array_index(lmm->mindex, msgno - 1) =
+ g_ptr_array_index(priv->mindex, msgno - 1) =
lbm_index_entry_new_pending();
g_mutex_unlock(&get_index_entry_lock);
@@ -2971,7 +3146,7 @@ lbm_get_index_entry(LibBalsaMailbox * lmm, guint msgno)
gchar **libbalsa_mailbox_date_format;
static void
-mbox_model_get_value(GtkTreeModel *tree_model,
+mailbox_model_get_value(GtkTreeModel *tree_model,
GtkTreeIter *iter,
gint column,
GValue *value)
@@ -2983,9 +3158,9 @@ mbox_model_get_value(GtkTreeModel *tree_model,
g_return_if_fail(VALID_ITER(iter, tree_model));
g_return_if_fail(column >= 0 &&
- column < (int) G_N_ELEMENTS(mbox_model_col_type));
+ column < (int) G_N_ELEMENTS(mailbox_model_col_type));
- g_value_init (value, mbox_model_col_type[column]);
+ g_value_init (value, mailbox_model_col_type[column]);
msgno = GPOINTER_TO_UINT( ((GNode*)iter->user_data)->data );
if(column == LB_MBOX_MSGNO_COL) {
@@ -3062,7 +3237,7 @@ mbox_model_get_value(GtkTreeModel *tree_model,
}
static gboolean
-mbox_model_iter_next(GtkTreeModel *tree_model,
+mailbox_model_iter_next(GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
GNode *node;
@@ -3080,18 +3255,19 @@ mbox_model_iter_next(GtkTreeModel *tree_model,
}
static gboolean
-mbox_model_iter_children(GtkTreeModel *tree_model,
+mailbox_model_iter_children(GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent)
{
+ LibBalsaMailboxPrivate *priv =
+ libbalsa_mailbox_get_instance_private(((LibBalsaMailbox *) tree_model));
GNode *node;
INVALIDATE_ITER(iter);
g_return_val_if_fail(parent == NULL ||
VALID_ITER(parent, tree_model), FALSE);
- node = parent ? parent->user_data
- : LIBBALSA_MAILBOX(tree_model)->msg_tree;
+ node = parent ? parent->user_data : priv->msg_tree;
node = node->children;
if (node) {
iter->user_data = node;
@@ -3102,7 +3278,7 @@ mbox_model_iter_children(GtkTreeModel *tree_model,
}
static gboolean
-mbox_model_iter_has_child(GtkTreeModel * tree_model,
+mailbox_model_iter_has_child(GtkTreeModel * tree_model,
GtkTreeIter * iter)
{
GNode *node;
@@ -3116,38 +3292,40 @@ mbox_model_iter_has_child(GtkTreeModel * tree_model,
}
static gint
-mbox_model_iter_n_children(GtkTreeModel *tree_model,
+mailbox_model_iter_n_children(GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
+ LibBalsaMailboxPrivate *priv =
+ libbalsa_mailbox_get_instance_private(((LibBalsaMailbox *) tree_model));
GNode *node;
g_return_val_if_fail(iter == NULL || VALID_ITER(iter, tree_model), 0);
- node = iter ? iter->user_data
- : LIBBALSA_MAILBOX(tree_model)->msg_tree;
+ node = iter ? iter->user_data : priv->msg_tree;
return node ? g_node_n_children(node) : 0;
}
static gboolean
-mbox_model_iter_nth_child(GtkTreeModel * tree_model,
+mailbox_model_iter_nth_child(GtkTreeModel * tree_model,
GtkTreeIter * iter,
GtkTreeIter * parent,
gint n)
{
+ LibBalsaMailboxPrivate *priv =
+ libbalsa_mailbox_get_instance_private(((LibBalsaMailbox *) tree_model));
GNode *node;
INVALIDATE_ITER(iter);
- if(!LIBBALSA_MAILBOX(tree_model)->msg_tree)
+ if(!priv->msg_tree)
return FALSE; /* really, this should be never called when
* msg_tree == NULL but the FALSE response is
* fair as well and only a bit dirtier.
* I have more critical problems to debug now. */
g_return_val_if_fail(parent == NULL
- ||VALID_ITER(parent, tree_model), FALSE);
+ || VALID_ITER(parent, tree_model), FALSE);
- node = parent ? parent->user_data
- : LIBBALSA_MAILBOX(tree_model)->msg_tree;
+ node = parent ? parent->user_data : priv->msg_tree;
if(!node) /* the tree has been destroyed already (mailbox has been
* closed), there is nothing to iterate over. This happens
* only if mailbox is closed but a view is still active.
@@ -3164,10 +3342,12 @@ mbox_model_iter_nth_child(GtkTreeModel * tree_model,
}
static gboolean
-mbox_model_iter_parent(GtkTreeModel * tree_model,
+mailbox_model_iter_parent(GtkTreeModel * tree_model,
GtkTreeIter * iter,
GtkTreeIter * child)
{
+ LibBalsaMailboxPrivate *priv =
+ libbalsa_mailbox_get_instance_private(((LibBalsaMailbox *) tree_model));
GNode *node;
INVALIDATE_ITER(iter);
@@ -3176,7 +3356,7 @@ mbox_model_iter_parent(GtkTreeModel * tree_model,
node = child->user_data;
node = node->parent;
- if (node && node != LIBBALSA_MAILBOX(tree_model)->msg_tree) {
+ if (node && node != priv->msg_tree) {
iter->user_data = node;
VALIDATE_ITER(iter, tree_model);
return TRUE;
@@ -3270,20 +3450,20 @@ void libbalsa_mailbox_set_encr_icon(GdkPixbuf * pixbuf)
* GtkTreeDragSource implementation functions. *
* =================================================================== */
-static gboolean mbox_row_draggable(GtkTreeDragSource * drag_source,
+static gboolean mailbox_row_draggable(GtkTreeDragSource * drag_source,
GtkTreePath * path);
-static gboolean mbox_drag_data_delete(GtkTreeDragSource * drag_source,
+static gboolean mailbox_drag_data_delete(GtkTreeDragSource * drag_source,
GtkTreePath * path);
-static gboolean mbox_drag_data_get(GtkTreeDragSource * drag_source,
+static gboolean mailbox_drag_data_get(GtkTreeDragSource * drag_source,
GtkTreePath * path,
GtkSelectionData * selection_data);
static void
-mbox_drag_source_init(GtkTreeDragSourceIface * iface)
+mailbox_drag_source_init(GtkTreeDragSourceIface * iface)
{
- iface->row_draggable = mbox_row_draggable;
- iface->drag_data_delete = mbox_drag_data_delete;
- iface->drag_data_get = mbox_drag_data_get;
+ iface->row_draggable = mailbox_row_draggable;
+ iface->drag_data_delete = mailbox_drag_data_delete;
+ iface->drag_data_get = mailbox_drag_data_get;
}
/* These three methods are apparently never called, so what they return
@@ -3291,14 +3471,14 @@ mbox_drag_source_init(GtkTreeDragSourceIface * iface)
* return if they were ever called.
*/
static gboolean
-mbox_row_draggable(GtkTreeDragSource * drag_source, GtkTreePath * path)
+mailbox_row_draggable(GtkTreeDragSource * drag_source, GtkTreePath * path)
{
/* All rows are valid sources. */
return TRUE;
}
static gboolean
-mbox_drag_data_delete(GtkTreeDragSource * drag_source, GtkTreePath * path)
+mailbox_drag_data_delete(GtkTreeDragSource * drag_source, GtkTreePath * path)
{
/* The "drag-data-received" callback handles deleting messages that
* are dragged out of the mailbox, so we don't. */
@@ -3306,7 +3486,7 @@ mbox_drag_data_delete(GtkTreeDragSource * drag_source, GtkTreePath * path)
}
static gboolean
-mbox_drag_data_get(GtkTreeDragSource * drag_source, GtkTreePath * path,
+mailbox_drag_data_get(GtkTreeDragSource * drag_source, GtkTreePath * path,
GtkSelectionData * selection_data)
{
/* The "drag-data-get" callback passes the list of selected messages
@@ -3318,48 +3498,48 @@ mbox_drag_data_get(GtkTreeDragSource * drag_source, GtkTreePath * path,
* GtkTreeSortable implementation functions. *
* =================================================================== */
-static gboolean mbox_get_sort_column_id(GtkTreeSortable * sortable,
+static gboolean mailbox_get_sort_column_id(GtkTreeSortable * sortable,
gint * sort_column_id,
GtkSortType * order);
-static void mbox_set_sort_column_id(GtkTreeSortable * sortable,
+static void mailbox_set_sort_column_id(GtkTreeSortable * sortable,
gint sort_column_id,
GtkSortType order);
-static void mbox_set_sort_func(GtkTreeSortable * sortable,
+static void mailbox_set_sort_func(GtkTreeSortable * sortable,
gint sort_column_id,
GtkTreeIterCompareFunc func, gpointer data,
GDestroyNotify destroy);
-static void mbox_set_default_sort_func(GtkTreeSortable * sortable,
+static void mailbox_set_default_sort_func(GtkTreeSortable * sortable,
GtkTreeIterCompareFunc func,
gpointer data,
GDestroyNotify destroy);
-static gboolean mbox_has_default_sort_func(GtkTreeSortable * sortable);
+static gboolean mailbox_has_default_sort_func(GtkTreeSortable * sortable);
static void
-mbox_sortable_init(GtkTreeSortableIface * iface)
+mailbox_sortable_init(GtkTreeSortableIface * iface)
{
- iface->get_sort_column_id = mbox_get_sort_column_id;
- iface->set_sort_column_id = mbox_set_sort_column_id;
- iface->set_sort_func = mbox_set_sort_func;
- iface->set_default_sort_func = mbox_set_default_sort_func;
- iface->has_default_sort_func = mbox_has_default_sort_func;
+ iface->get_sort_column_id = mailbox_get_sort_column_id;
+ iface->set_sort_column_id = mailbox_set_sort_column_id;
+ iface->set_sort_func = mailbox_set_sort_func;
+ iface->set_default_sort_func = mailbox_set_default_sort_func;
+ iface->has_default_sort_func = mailbox_has_default_sort_func;
}
static gint
-mbox_compare_from(LibBalsaMailboxIndexEntry * message_a,
+mailbox_compare_from(LibBalsaMailboxIndexEntry * message_a,
LibBalsaMailboxIndexEntry * message_b)
{
return g_ascii_strcasecmp(message_a->from, message_b->from);
}
static gint
-mbox_compare_subject(LibBalsaMailboxIndexEntry * message_a,
+mailbox_compare_subject(LibBalsaMailboxIndexEntry * message_a,
LibBalsaMailboxIndexEntry * message_b)
{
return g_ascii_strcasecmp(message_a->subject, message_b->subject);
}
static gint
-mbox_compare_date(LibBalsaMailboxIndexEntry * message_a,
+mailbox_compare_date(LibBalsaMailboxIndexEntry * message_a,
LibBalsaMailboxIndexEntry * message_b)
{
return message_a->msg_date - message_b->msg_date;
@@ -3368,21 +3548,21 @@ mbox_compare_date(LibBalsaMailboxIndexEntry * message_a,
/* Thread date stuff */
typedef struct {
- time_t thread_date;
- LibBalsaMailbox *mbox;
+ time_t thread_date;
+ LibBalsaMailboxPrivate *priv;
} LibBalsaMailboxThreadDateInfo;
static gboolean
-mbox_get_thread_date_traverse_func(GNode *node,
- gpointer data)
+mailbox_get_thread_date_traverse_func(GNode *node,
+ gpointer data)
{
LibBalsaMailboxThreadDateInfo *info = data;
guint msgno;
LibBalsaMailboxIndexEntry *message;
if ((msgno = GPOINTER_TO_UINT(node->data)) > 0 &&
- msgno <= info->mbox->mindex->len &&
- (message = g_ptr_array_index(info->mbox->mindex, msgno - 1)) != NULL) {
+ msgno <= info->priv->mindex->len &&
+ (message = g_ptr_array_index(info->priv->mindex, msgno - 1)) != NULL) {
time_t msg_date = message->msg_date;
if (msg_date > info->thread_date)
@@ -3397,14 +3577,16 @@ mbox_get_thread_date_traverse_func(GNode *node,
}
static time_t
-mbox_get_thread_date(const SortTuple *tuple,
- LibBalsaMailbox *mbox)
+mailbox_get_thread_date(const SortTuple *tuple,
+ LibBalsaMailbox *mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
if (tuple->thread_date == 0) {
- LibBalsaMailboxThreadDateInfo info = { 0, mbox };
+ LibBalsaMailboxThreadDateInfo info = { 0, priv };
g_node_traverse(tuple->node, G_IN_ORDER, G_TRAVERSE_ALL, -1,
- mbox_get_thread_date_traverse_func, &info);
+ mailbox_get_thread_date_traverse_func, &info);
/* Cast away the 'const' qualifier so that we can cache the
* thread date: */
@@ -3415,60 +3597,61 @@ mbox_get_thread_date(const SortTuple *tuple,
}
static gint
-mbox_compare_thread_date(const SortTuple *a,
+mailbox_compare_thread_date(const SortTuple *a,
const SortTuple *b,
- LibBalsaMailbox *mbox)
+ LibBalsaMailbox *mailbox)
{
- return mbox_get_thread_date(a, mbox) - mbox_get_thread_date(b, mbox);
+ return mailbox_get_thread_date(a, mailbox) - mailbox_get_thread_date(b, mailbox);
}
/* End of thread date stuff */
static gint
-mbox_compare_size(LibBalsaMailboxIndexEntry * message_a,
+mailbox_compare_size(LibBalsaMailboxIndexEntry * message_a,
LibBalsaMailboxIndexEntry * message_b)
{
return message_a->size - message_b->size;
}
static gint
-mbox_compare_func(const SortTuple * a,
+mailbox_compare_func(const SortTuple * a,
const SortTuple * b,
- LibBalsaMailbox * mbox)
+ LibBalsaMailbox * mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
guint msgno_a;
guint msgno_b;
gint retval;
msgno_a = GPOINTER_TO_UINT(a->node->data);
msgno_b = GPOINTER_TO_UINT(b->node->data);
- if (mbox->view->sort_field == LB_MAILBOX_SORT_NO)
+ if (priv->view->sort_field == LB_MAILBOX_SORT_NO)
retval = msgno_a - msgno_b;
else {
LibBalsaMailboxIndexEntry *message_a;
LibBalsaMailboxIndexEntry *message_b;
- message_a = g_ptr_array_index(mbox->mindex, msgno_a - 1);
- message_b = g_ptr_array_index(mbox->mindex, msgno_b - 1);
+ message_a = g_ptr_array_index(priv->mindex, msgno_a - 1);
+ message_b = g_ptr_array_index(priv->mindex, msgno_b - 1);
if (!(VALID_ENTRY(message_a) && VALID_ENTRY(message_b)))
return 0;
- switch (mbox->view->sort_field) {
+ switch (priv->view->sort_field) {
case LB_MAILBOX_SORT_SENDER:
- retval = mbox_compare_from(message_a, message_b);
+ retval = mailbox_compare_from(message_a, message_b);
break;
case LB_MAILBOX_SORT_SUBJECT:
- retval = mbox_compare_subject(message_a, message_b);
+ retval = mailbox_compare_subject(message_a, message_b);
break;
case LB_MAILBOX_SORT_DATE:
retval =
- mbox->view->threading_type == LB_MAILBOX_THREADING_FLAT
- ? mbox_compare_date(message_a, message_b)
- : mbox_compare_thread_date(a, b, mbox);
+ priv->view->threading_type == LB_MAILBOX_THREADING_FLAT
+ ? mailbox_compare_date(message_a, message_b)
+ : mailbox_compare_thread_date(a, b, mailbox);
break;
case LB_MAILBOX_SORT_SIZE:
- retval = mbox_compare_size(message_a, message_b);
+ retval = mailbox_compare_size(message_a, message_b);
break;
default:
retval = 0;
@@ -3477,21 +3660,21 @@ mbox_compare_func(const SortTuple * a,
if (retval == 0) {
/* resolve ties using previous sort column */
- switch (mbox->view->sort_field_prev) {
+ switch (priv->view->sort_field_prev) {
case LB_MAILBOX_SORT_SENDER:
- retval = mbox_compare_from(message_a, message_b);
+ retval = mailbox_compare_from(message_a, message_b);
break;
case LB_MAILBOX_SORT_SUBJECT:
- retval = mbox_compare_subject(message_a, message_b);
+ retval = mailbox_compare_subject(message_a, message_b);
break;
case LB_MAILBOX_SORT_DATE:
retval =
- mbox->view->threading_type == LB_MAILBOX_THREADING_FLAT
- ? mbox_compare_date(message_a, message_b)
- : mbox_compare_thread_date(a, b, mbox);
+ priv->view->threading_type == LB_MAILBOX_THREADING_FLAT
+ ? mailbox_compare_date(message_a, message_b)
+ : mailbox_compare_thread_date(a, b, mailbox);
break;
case LB_MAILBOX_SORT_SIZE:
- retval = mbox_compare_size(message_a, message_b);
+ retval = mailbox_compare_size(message_a, message_b);
break;
default:
retval = 0;
@@ -3500,7 +3683,7 @@ mbox_compare_func(const SortTuple * a,
}
}
- if (mbox->view->sort_type == LB_MAILBOX_SORT_TYPE_DESC) {
+ if (priv->view->sort_type == LB_MAILBOX_SORT_TYPE_DESC) {
retval = -retval;
}
@@ -3516,26 +3699,28 @@ mbox_compare_func(const SortTuple * a,
static gboolean
lbm_has_valid_index_entry(LibBalsaMailbox * mailbox, guint msgno)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
LibBalsaMailboxIndexEntry *entry;
- if (msgno > mailbox->mindex->len)
+ if (msgno > priv->mindex->len)
return FALSE;
- entry = g_ptr_array_index(mailbox->mindex, msgno - 1);
+ entry = g_ptr_array_index(priv->mindex, msgno - 1);
return VALID_ENTRY(entry);
}
static void
-lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
+lbm_sort(LibBalsaMailbox * mailbox, GNode * parent)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GArray *sort_array;
GPtrArray *node_array;
GNode *node, *tmp_node, *prev;
guint i, j;
- gboolean sort_no = mbox->view->sort_field == LB_MAILBOX_SORT_NO;
+ gboolean sort_no = priv->view->sort_field == LB_MAILBOX_SORT_NO;
#if !defined(LOCAL_MAILBOX_SORTED_JUST_ONCE_ON_OPENING)
- gboolean can_sort_all = sort_no || LIBBALSA_IS_MAILBOX_IMAP(mbox);
+ gboolean can_sort_all = sort_no || LIBBALSA_IS_MAILBOX_IMAP(mailbox);
#else
gboolean can_sort_all = 1;
#endif
@@ -3544,7 +3729,7 @@ lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
return;
if (node->next == NULL) {
- lbm_sort(mbox, node);
+ lbm_sort(mailbox, node);
return;
}
@@ -3554,7 +3739,7 @@ lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
SortTuple sort_tuple;
guint msgno = GPOINTER_TO_UINT(tmp_node->data);
- if (can_sort_all || lbm_has_valid_index_entry(mbox, msgno)) {
+ if (can_sort_all || lbm_has_valid_index_entry(mailbox, msgno)) {
/* We have the sort fields. */
sort_tuple.offset = node_array->len;
sort_tuple.node = tmp_node;
@@ -3567,10 +3752,10 @@ lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
if (sort_array->len <= 1) {
g_array_free(sort_array, TRUE);
g_ptr_array_free(node_array, TRUE);
- lbm_sort(mbox, node);
+ lbm_sort(mailbox, node);
return;
}
- LIBBALSA_MAILBOX_GET_CLASS(mbox)->sort(mbox, sort_array);
+ LIBBALSA_MAILBOX_GET_CLASS(mailbox)->sort(mailbox, sort_array);
/* Step through the nodes in original order. */
prev = NULL;
@@ -3579,7 +3764,7 @@ lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
tmp_node = g_ptr_array_index(node_array, i);
msgno = GPOINTER_TO_UINT(tmp_node->data);
- if (can_sort_all || lbm_has_valid_index_entry(mbox, msgno)) {
+ if (can_sort_all || lbm_has_valid_index_entry(mailbox, msgno)) {
/* This is one of the nodes we sorted: find out which one
* goes here. */
g_assert(j < sort_array->len);
@@ -3592,7 +3777,7 @@ lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
else
node = parent->children = tmp_node;
tmp_node->prev = prev;
- mbox->msg_tree_changed = TRUE;
+ priv->msg_tree_changed = TRUE;
} else
g_assert(prev == NULL || prev->next == tmp_node);
prev = tmp_node;
@@ -3610,17 +3795,17 @@ lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
i = j = 0;
for (tmp_node = node; tmp_node; tmp_node = tmp_node->next) {
guint msgno = GPOINTER_TO_UINT(tmp_node->data);
- new_order[j] = can_sort_all || lbm_has_valid_index_entry(mbox, msgno)
+ new_order[j] = can_sort_all || lbm_has_valid_index_entry(mailbox, msgno)
? g_array_index(sort_array, SortTuple, i++).offset
: j;
j++;
}
- iter.stamp = mbox->stamp;
+ iter.stamp = priv->stamp;
iter.user_data = parent;
- path = parent->parent ? mbox_model_get_path(GTK_TREE_MODEL(mbox), &iter)
+ path = parent->parent ? mailbox_model_get_path(GTK_TREE_MODEL(mailbox), &iter)
: gtk_tree_path_new();
- gtk_tree_model_rows_reordered(GTK_TREE_MODEL(mbox),
+ gtk_tree_model_rows_reordered(GTK_TREE_MODEL(mailbox),
path, &iter, new_order);
gtk_tree_path_free(path);
g_free(new_order);
@@ -3630,21 +3815,22 @@ lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
g_ptr_array_free(node_array, TRUE);
for (tmp_node = node; tmp_node; tmp_node = tmp_node->next)
- lbm_sort(mbox, tmp_node);
+ lbm_sort(mailbox, tmp_node);
}
/* called from gtk-tree-view-column */
static gboolean
-mbox_get_sort_column_id(GtkTreeSortable * sortable,
+mailbox_get_sort_column_id(GtkTreeSortable * sortable,
gint * sort_column_id,
GtkSortType * order)
{
- LibBalsaMailbox *mbox = (LibBalsaMailbox *) sortable;
+ LibBalsaMailbox *mailbox = (LibBalsaMailbox *) sortable;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
g_return_val_if_fail(LIBBALSA_IS_MAILBOX(sortable), FALSE);
if (sort_column_id) {
- switch (mbox->view->sort_field) {
+ switch (priv->view->sort_field) {
default:
case LB_MAILBOX_SORT_NO:
*sort_column_id = LB_MBOX_MSGNO_COL;
@@ -3665,7 +3851,7 @@ mbox_get_sort_column_id(GtkTreeSortable * sortable,
}
if (order)
- *order = (mbox->view->sort_type ==
+ *order = (priv->view->sort_type ==
LB_MAILBOX_SORT_TYPE_DESC ? GTK_SORT_DESCENDING :
GTK_SORT_ASCENDING);
@@ -3674,18 +3860,19 @@ mbox_get_sort_column_id(GtkTreeSortable * sortable,
/* called from gtk-tree-view-column */
static void
-mbox_set_sort_column_id(GtkTreeSortable * sortable,
+mailbox_set_sort_column_id(GtkTreeSortable * sortable,
gint sort_column_id,
GtkSortType order)
{
- LibBalsaMailbox *mbox = (LibBalsaMailbox *) sortable;
+ LibBalsaMailbox *mailbox = (LibBalsaMailbox *) sortable;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
LibBalsaMailboxView *view;
LibBalsaMailboxSortFields new_field;
LibBalsaMailboxSortType new_type;
g_return_if_fail(LIBBALSA_IS_MAILBOX(sortable));
- view = mbox->view;
+ view = priv->view;
switch (sort_column_id) {
default:
@@ -3724,21 +3911,21 @@ mbox_set_sort_column_id(GtkTreeSortable * sortable,
if (new_field != LB_MAILBOX_SORT_NO) {
gboolean rc;
- rc = libbalsa_mailbox_prepare_threading(mbox, 0);
+ rc = libbalsa_mailbox_prepare_threading(mailbox, 0);
if (!rc)
/* Prepare-threading failed--perhaps mailbox was closed. */
return;
}
- libbalsa_lock_mailbox(mbox);
- lbm_sort(mbox, mbox->msg_tree);
- libbalsa_unlock_mailbox(mbox);
+ libbalsa_lock_mailbox(mailbox);
+ lbm_sort(mailbox, priv->msg_tree);
+ libbalsa_unlock_mailbox(mailbox);
- libbalsa_mailbox_changed(mbox);
+ libbalsa_mailbox_changed(mailbox);
}
static void
-mbox_set_sort_func(GtkTreeSortable * sortable,
+mailbox_set_sort_func(GtkTreeSortable * sortable,
gint sort_column_id,
GtkTreeIterCompareFunc func,
gpointer data, GDestroyNotify destroy)
@@ -3747,7 +3934,7 @@ mbox_set_sort_func(GtkTreeSortable * sortable,
}
static void
-mbox_set_default_sort_func(GtkTreeSortable * sortable,
+mailbox_set_default_sort_func(GtkTreeSortable * sortable,
GtkTreeIterCompareFunc func,
gpointer data, GDestroyNotify destroy)
{
@@ -3756,7 +3943,7 @@ mbox_set_default_sort_func(GtkTreeSortable * sortable,
/* called from gtk-tree-view-column */
static gboolean
-mbox_has_default_sort_func(GtkTreeSortable * sortable)
+mailbox_has_default_sort_func(GtkTreeSortable * sortable)
{
return FALSE;
}
@@ -3766,6 +3953,7 @@ void
libbalsa_mailbox_unlink_and_prepend(LibBalsaMailbox * mailbox,
GNode * node, GNode * parent)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GtkTreeIter iter;
GtkTreePath *path;
GNode *current_parent;
@@ -3776,21 +3964,21 @@ libbalsa_mailbox_unlink_and_prepend(LibBalsaMailbox * mailbox,
g_return_if_fail(!parent || !g_node_is_ancestor(node, parent));
#endif
- iter.stamp = mailbox->stamp;
+ iter.stamp = priv->stamp;
- path = mbox_model_get_path_helper(node, mailbox->msg_tree);
+ path = mailbox_model_get_path_helper(node, priv->msg_tree);
current_parent = node->parent;
g_node_unlink(node);
if (path) {
- /* The node was in mailbox->msg_tree. */
+ /* The node was in priv->msg_tree. */
g_signal_emit(mailbox,
- libbalsa_mbox_model_signals[ROW_DELETED], 0, path);
+ libbalsa_mailbox_model_signals[ROW_DELETED], 0, path);
if (!current_parent->children) {
/* It was the last child. */
gtk_tree_path_up(path);
iter.user_data = current_parent;
g_signal_emit(mailbox,
- libbalsa_mbox_model_signals[ROW_HAS_CHILD_TOGGLED],
+ libbalsa_mailbox_model_signals[ROW_HAS_CHILD_TOGGLED],
0, path, &iter);
}
gtk_tree_path_free(path);
@@ -3802,28 +3990,28 @@ libbalsa_mailbox_unlink_and_prepend(LibBalsaMailbox * mailbox,
}
g_node_prepend(parent, node);
- path = mbox_model_get_path_helper(parent, mailbox->msg_tree);
+ path = mailbox_model_get_path_helper(parent, priv->msg_tree);
if (path) {
- /* The parent is in mailbox->msg_tree. */
+ /* The parent is in priv->msg_tree. */
if (!node->next) {
/* It is the first child. */
iter.user_data = parent;
g_signal_emit(mailbox,
- libbalsa_mbox_model_signals[ROW_HAS_CHILD_TOGGLED],
+ libbalsa_mailbox_model_signals[ROW_HAS_CHILD_TOGGLED],
0, path, &iter);
}
gtk_tree_path_down(path);
iter.user_data = node;
g_signal_emit(mailbox,
- libbalsa_mbox_model_signals[ROW_INSERTED], 0,
+ libbalsa_mailbox_model_signals[ROW_INSERTED], 0,
path, &iter);
if (node->children)
g_signal_emit(mailbox,
- libbalsa_mbox_model_signals[ROW_HAS_CHILD_TOGGLED],
+ libbalsa_mailbox_model_signals[ROW_HAS_CHILD_TOGGLED],
0, path, &iter);
gtk_tree_path_free(path);
- mailbox->msg_tree_changed = TRUE;
+ priv->msg_tree_changed = TRUE;
}
}
@@ -3913,6 +4101,7 @@ lbm_update_msg_tree_move(GNode * new_node,
static void
lbm_update_msg_tree(LibBalsaMailbox * mailbox, GNode * new_tree)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
struct lbm_update_msg_tree_info mti;
mti.mailbox = mailbox;
@@ -3924,13 +4113,13 @@ lbm_update_msg_tree(LibBalsaMailbox * mailbox, GNode * new_tree)
g_node_traverse(new_tree, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
(GNodeTraverseFunc) lbm_update_msg_tree_populate, &mti);
/* Remove deadwood. */
- g_node_traverse(mailbox->msg_tree, G_POST_ORDER, G_TRAVERSE_ALL, -1,
+ g_node_traverse(priv->msg_tree, G_POST_ORDER, G_TRAVERSE_ALL, -1,
(GNodeTraverseFunc) lbm_update_msg_tree_prune, &mti);
/* Clear the nodes array and repopulate it with nodes in the current
* tree. */
memset(mti.nodes, 0, sizeof(GNode *) * mti.total);
- g_node_traverse(mailbox->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
+ g_node_traverse(priv->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
(GNodeTraverseFunc) lbm_update_msg_tree_populate, &mti);
/* Check parent-child relationships. */
g_node_traverse(new_tree, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
@@ -3942,26 +4131,27 @@ lbm_update_msg_tree(LibBalsaMailbox * mailbox, GNode * new_tree)
static void
lbm_set_msg_tree(LibBalsaMailbox * mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GtkTreeIter iter;
GNode *node;
GtkTreePath *path;
- iter.stamp = ++mailbox->stamp;
+ iter.stamp = ++priv->stamp;
- if (!mailbox->msg_tree)
+ if (!priv->msg_tree)
return;
path = gtk_tree_path_new();
gtk_tree_path_down(path);
- for (node = mailbox->msg_tree->children; node; node = node->next) {
+ for (node = priv->msg_tree->children; node; node = node->next) {
iter.user_data = node;
g_signal_emit(mailbox,
- libbalsa_mbox_model_signals[ROW_INSERTED], 0, path,
+ libbalsa_mailbox_model_signals[ROW_INSERTED], 0, path,
&iter);
if (node->children)
g_signal_emit(mailbox,
- libbalsa_mbox_model_signals
+ libbalsa_mailbox_model_signals
[ROW_HAS_CHILD_TOGGLED], 0, path, &iter);
gtk_tree_path_next(path);
}
@@ -3972,17 +4162,19 @@ lbm_set_msg_tree(LibBalsaMailbox * mailbox)
void
libbalsa_mailbox_set_msg_tree(LibBalsaMailbox * mailbox, GNode * new_tree)
{
- if (mailbox->msg_tree && mailbox->msg_tree->children) {
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ if (priv->msg_tree && priv->msg_tree->children) {
lbm_update_msg_tree(mailbox, new_tree);
g_node_destroy(new_tree);
} else {
- if (mailbox->msg_tree)
- g_node_destroy(mailbox->msg_tree);
- mailbox->msg_tree = new_tree;
+ if (priv->msg_tree)
+ g_node_destroy(priv->msg_tree);
+ priv->msg_tree = new_tree;
lbm_set_msg_tree(mailbox);
}
- mailbox->msg_tree_changed = TRUE;
+ priv->msg_tree_changed = TRUE;
}
static GMimeMessage *
@@ -4031,6 +4223,7 @@ lbm_try_reassemble_func(GMimeObject * parent, GMimeObject * mime_part,
static void
lbm_try_reassemble(LibBalsaMailbox * mailbox, const gchar * id)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
gchar *text;
guint total_messages;
LibBalsaProgress progress;
@@ -4040,7 +4233,7 @@ lbm_try_reassemble(LibBalsaMailbox * mailbox, const gchar * id)
GArray *messages = g_array_new(FALSE, FALSE, sizeof(guint));
text = g_strdup_printf(_("Searching %s for partial messages"),
- mailbox->name);
+ priv->name);
total_messages = libbalsa_mailbox_total_messages(mailbox);
libbalsa_progress_set_text(&progress, text, total_messages);
g_free(text);
@@ -4180,9 +4373,10 @@ void
libbalsa_mailbox_try_reassemble(LibBalsaMailbox * mailbox,
const gchar * id)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GSList *ids;
- if (mailbox->no_reassemble)
+ if (priv->no_reassemble)
return;
ids = g_object_get_data(G_OBJECT(mailbox), LBM_TRY_REASSEMBLE_IDS);
@@ -4236,8 +4430,9 @@ libbalsa_mailbox_unregister_msgnos(LibBalsaMailbox * mailbox,
LibBalsaMessageStatus
libbalsa_mailbox_msgno_get_status(LibBalsaMailbox * mailbox, guint msgno)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
LibBalsaMailboxIndexEntry *entry =
- g_ptr_array_index(mailbox->mindex, msgno - 1);
+ g_ptr_array_index(priv->mindex, msgno - 1);
return VALID_ENTRY(entry) ?
entry->status_icon : LIBBALSA_MESSAGE_STATUS_ICONS_NUM;
}
@@ -4245,8 +4440,9 @@ libbalsa_mailbox_msgno_get_status(LibBalsaMailbox * mailbox, guint msgno)
const gchar *
libbalsa_mailbox_msgno_get_subject(LibBalsaMailbox * mailbox, guint msgno)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
LibBalsaMailboxIndexEntry *entry =
- g_ptr_array_index(mailbox->mindex, msgno - 1);
+ g_ptr_array_index(priv->mindex, msgno - 1);
return VALID_ENTRY(entry) ? entry->subject : NULL;
}
@@ -4255,13 +4451,14 @@ void
libbalsa_mailbox_msgno_update_attach(LibBalsaMailbox * mailbox,
guint msgno, LibBalsaMessage * message)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
LibBalsaMailboxIndexEntry *entry;
LibBalsaMessageAttach attach_icon;
- if (!mailbox || !mailbox->mindex || mailbox->mindex->len < msgno)
+ if (!mailbox || !priv->mindex || priv->mindex->len < msgno)
return;
- entry = g_ptr_array_index(mailbox->mindex, msgno - 1);
+ entry = g_ptr_array_index(priv->mindex, msgno - 1);
if (!VALID_ENTRY(entry))
return;
@@ -4289,6 +4486,7 @@ lbm_check_real(LibBalsaMailbox * mailbox)
static gboolean
lbm_check_idle(LibBalsaMailbox * mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GThread *check_thread;
check_thread = g_thread_new("lbm_check_real", (GThreadFunc) lbm_check_real,
@@ -4296,7 +4494,7 @@ lbm_check_idle(LibBalsaMailbox * mailbox)
g_thread_unref(check_thread);
libbalsa_lock_mailbox(mailbox);
- mailbox->queue_check_idle_id = 0;
+ priv->queue_check_idle_id = 0;
libbalsa_unlock_mailbox(mailbox);
return FALSE;
@@ -4305,9 +4503,11 @@ lbm_check_idle(LibBalsaMailbox * mailbox)
static void
lbm_queue_check(LibBalsaMailbox * mailbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
libbalsa_lock_mailbox(mailbox);
- if (!mailbox->queue_check_idle_id)
- mailbox->queue_check_idle_id =
+ if (!priv->queue_check_idle_id)
+ priv->queue_check_idle_id =
g_idle_add((GSourceFunc) lbm_check_idle, mailbox);
libbalsa_unlock_mailbox(mailbox);
}
@@ -4328,13 +4528,16 @@ libbalsa_mailbox_search_iter_step(LibBalsaMailbox * mailbox,
gboolean forward,
guint stop_msgno)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GNode *node;
gboolean retval = FALSE;
gint total;
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), FALSE);
+
node = iter->user_data;
if (!node)
- node = mailbox->msg_tree;
+ node = priv->msg_tree;
total = libbalsa_mailbox_total_messages(mailbox);
for (;;) {
@@ -4369,6 +4572,8 @@ libbalsa_mailbox_search_iter_step(LibBalsaMailbox * mailbox,
gboolean
libbalsa_mailbox_can_move_duplicates(LibBalsaMailbox * mailbox)
{
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), FALSE);
+
return LIBBALSA_MAILBOX_GET_CLASS(mailbox)->duplicate_msgnos != NULL;
}
@@ -4376,14 +4581,17 @@ gint
libbalsa_mailbox_move_duplicates(LibBalsaMailbox * mailbox,
LibBalsaMailbox * dest, GError ** err)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GArray *msgnos = NULL;
gint retval;
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), 0);
+
if (libbalsa_mailbox_can_move_duplicates(mailbox))
msgnos =
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->duplicate_msgnos(mailbox);
- if (mailbox->state == LB_MAILBOX_STATE_CLOSED) {
+ if (priv->state == LB_MAILBOX_STATE_CLOSED) {
/* duplicate msgnos was interrupted */
g_set_error(err, LIBBALSA_MAILBOX_ERROR,
LIBBALSA_MAILBOX_DUPLICATES_ERROR,
@@ -4408,17 +4616,17 @@ libbalsa_mailbox_move_duplicates(LibBalsaMailbox * mailbox,
}
/* Lock and unlock the mail store. NULL mailbox is not an error. */
-void
+void
libbalsa_mailbox_lock_store(LibBalsaMailbox * mailbox)
{
- if (mailbox)
+ if (LIBBALSA_IS_MAILBOX(mailbox))
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->lock_store(mailbox, TRUE);
}
-void
+void
libbalsa_mailbox_unlock_store(LibBalsaMailbox * mailbox)
{
- if (mailbox)
+ if (LIBBALSA_IS_MAILBOX(mailbox))
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->lock_store(mailbox, FALSE);
}
@@ -4426,8 +4634,11 @@ void
libbalsa_mailbox_cache_message(LibBalsaMailbox * mailbox, guint msgno,
LibBalsaMessage * message)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
- if (!mailbox->mindex)
+
+ if (!priv->mindex)
return;
g_return_if_fail(msgno > 0);
g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
@@ -4439,18 +4650,19 @@ static void
lbm_set_color(LibBalsaMailbox * mailbox, GArray * msgnos,
const gchar * color, gboolean foreground)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
guint i;
for (i = 0; i < msgnos->len; i++) {
guint msgno = g_array_index(msgnos, guint, i);
LibBalsaMailboxIndexEntry *entry;
- if (msgno > mailbox->mindex->len)
+ if (msgno > priv->mindex->len)
return;
- entry = g_ptr_array_index(mailbox->mindex, msgno - 1);
+ entry = g_ptr_array_index(priv->mindex, msgno - 1);
if (!entry)
- entry = g_ptr_array_index(mailbox->mindex, msgno - 1) =
+ entry = g_ptr_array_index(priv->mindex, msgno - 1) =
g_new0(LibBalsaMailboxIndexEntry, 1);
if (foreground) {
@@ -4469,6 +4681,8 @@ void
libbalsa_mailbox_set_foreground(LibBalsaMailbox * mailbox, GArray * msgnos,
const gchar * color)
{
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
lbm_set_color(mailbox, msgnos, color, TRUE);
}
@@ -4476,6 +4690,8 @@ void
libbalsa_mailbox_set_background(LibBalsaMailbox * mailbox, GArray * msgnos,
const gchar * color)
{
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
lbm_set_color(mailbox, msgnos, color, FALSE);
}
@@ -4483,5 +4699,342 @@ void libbalsa_mailbox_test_can_reach(LibBalsaMailbox * mailbox,
LibBalsaCanReachCallback * cb,
gpointer cb_data)
{
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->test_can_reach(mailbox, cb, cb_data);
}
+
+/*
+ * Getters
+ */
+
+GSList *
+libbalsa_mailbox_get_filters(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), NULL);
+
+ return priv->filters;
+}
+
+const gchar *
+libbalsa_mailbox_get_name(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), NULL);
+
+ return priv->name;
+}
+
+const gchar *
+libbalsa_mailbox_get_url(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), NULL);
+
+ return priv->url;
+}
+
+glong
+libbalsa_mailbox_get_unread_messages(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), 0);
+
+ return priv->unread_messages;
+}
+
+guint
+libbalsa_mailbox_get_first_unread(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), 0);
+
+ return priv->first_unread;
+}
+
+LibBalsaCondition *
+libbalsa_mailbox_get_view_filter(LibBalsaMailbox * mailbox,
+ gboolean persistent)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), NULL);
+
+ return persistent ? priv->persistent_view_filter : priv->view_filter;
+}
+
+GNode *
+libbalsa_mailbox_get_msg_tree(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), NULL);
+
+ return priv->msg_tree;
+}
+
+gboolean
+libbalsa_mailbox_get_msg_tree_changed(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), FALSE);
+
+ return priv->msg_tree_changed;
+}
+
+LibBalsaMailboxState
+libbalsa_mailbox_get_state(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), 0);
+
+ return priv->state;
+}
+
+LibBalsaMailboxIndexEntry *
+libbalsa_mailbox_get_index_entry(LibBalsaMailbox * mailbox, guint msgno)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), NULL);
+
+ return (LibBalsaMailboxIndexEntry *) g_ptr_array_index(priv->mindex, msgno - 1);
+}
+
+LibBalsaMailboxView *
+libbalsa_mailbox_get_view(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), NULL);
+
+ return priv->view;
+}
+
+gint
+libbalsa_mailbox_get_stamp(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), 0);
+
+ return priv->stamp;
+}
+
+guint
+libbalsa_mailbox_get_open_ref(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), 0);
+
+ return priv->open_ref;
+}
+
+gboolean
+libbalsa_mailbox_get_readonly(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), FALSE);
+
+ return priv->readonly;
+}
+
+const gchar *
+libbalsa_mailbox_get_config_prefix(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), NULL);
+
+ return priv->config_prefix;
+}
+
+gboolean
+libbalsa_mailbox_get_has_unread_messages(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), FALSE);
+
+ return priv->has_unread_messages;
+}
+
+/*
+ * Setters
+ */
+
+void
+libbalsa_mailbox_clear_unread_messages(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
+ priv->unread_messages = 0;
+}
+
+void
+libbalsa_mailbox_set_filters(LibBalsaMailbox * mailbox, GSList * filters)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
+ g_slist_free_full(priv->filters, g_free);
+ priv->filters = filters;
+}
+
+void
+libbalsa_mailbox_set_url(LibBalsaMailbox * mailbox, const gchar * url)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
+ g_free(priv->url);
+ priv->url = g_strdup(url);
+}
+
+void
+libbalsa_mailbox_set_first_unread(LibBalsaMailbox * mailbox, guint first)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
+ if (priv->first_unread == 0 || priv->first_unread > first)
+ priv->first_unread = first;
+}
+
+void
+libbalsa_mailbox_set_msg_tree_changed(LibBalsaMailbox * mailbox, gboolean changed)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
+ priv->msg_tree_changed = changed;
+}
+
+void
+libbalsa_mailbox_set_is_directory(LibBalsaMailbox * mailbox, gboolean is_directory)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
+ priv->is_directory = is_directory;
+}
+
+void
+libbalsa_mailbox_set_readonly(LibBalsaMailbox * mailbox, gboolean readonly)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
+ priv->readonly = readonly;
+}
+
+void
+libbalsa_mailbox_set_no_reassemble(LibBalsaMailbox * mailbox, gboolean no_reassemble)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
+ priv->no_reassemble = no_reassemble;
+}
+
+void
+libbalsa_mailbox_set_name(LibBalsaMailbox * mailbox, const gchar * name)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
+ g_free(priv->name);
+ priv->name = g_strdup(name);
+}
+
+void
+libbalsa_mailbox_set_view(LibBalsaMailbox * mailbox, LibBalsaMailboxView * view)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
+ libbalsa_mailbox_view_free(priv->view);
+ priv->view = view;
+}
+
+void
+libbalsa_mailbox_set_has_unread_messages(LibBalsaMailbox * mailbox,
+ gboolean has_unread_messages)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
+ priv->has_unread_messages = has_unread_messages;
+}
+
+void
+libbalsa_mailbox_set_config_prefix(LibBalsaMailbox * mailbox,
+ const gchar * config_prefix)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
+ g_free(priv->config_prefix);
+ priv->config_prefix = g_strdup(config_prefix);
+}
+
+/*
+ * Incrementers
+ */
+
+void
+libbalsa_mailbox_add_to_unread_messages(LibBalsaMailbox * mailbox, glong count)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
+ priv->unread_messages += count;
+}
+
+/*
+ * Locking
+ */
+
+void
+libbalsa_lock_mailbox(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
+ g_rec_mutex_lock(&priv->rec_mutex);
+}
+
+void
+libbalsa_unlock_mailbox(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
+
+ g_rec_mutex_unlock(&priv->rec_mutex);
+}
diff --git a/libbalsa/mailbox.h b/libbalsa/mailbox.h
index 7253f8d81..3e0f9149e 100644
--- a/libbalsa/mailbox.h
+++ b/libbalsa/mailbox.h
@@ -28,24 +28,19 @@
#include <gdk/gdk.h>
#include <gmime/gmime.h>
-#define LIBBALSA_TYPE_MAILBOX \
- (libbalsa_mailbox_get_type())
-#define LIBBALSA_MAILBOX(obj) \
- (G_TYPE_CHECK_INSTANCE_CAST ((obj), LIBBALSA_TYPE_MAILBOX, LibBalsaMailbox))
-#define LIBBALSA_MAILBOX_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_CAST ((klass), LIBBALSA_TYPE_MAILBOX, \
- LibBalsaMailboxClass))
-#define LIBBALSA_IS_MAILBOX(obj) \
- (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LIBBALSA_TYPE_MAILBOX))
-#define LIBBALSA_IS_MAILBOX_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_TYPE ((klass), LIBBALSA_TYPE_MAILBOX))
-#define LIBBALSA_MAILBOX_GET_CLASS(mailbox) \
- (G_TYPE_INSTANCE_GET_CLASS ((mailbox), LIBBALSA_TYPE_MAILBOX, \
- LibBalsaMailboxClass))
-
-#define MAILBOX_OPEN(mailbox) (mailbox->state != LB_MAILBOX_STATE_CLOSED)
-
-#define MAILBOX_CLOSED(mailbox) (mailbox->state == LB_MAILBOX_STATE_CLOSED)
+#define LIBBALSA_TYPE_MAILBOX (libbalsa_mailbox_get_type())
+
+G_DECLARE_DERIVABLE_TYPE(LibBalsaMailbox,
+ libbalsa_mailbox,
+ LIBBALSA,
+ MAILBOX,
+ GObject)
+
+#define MAILBOX_OPEN(mailbox) \
+ (libbalsa_mailbox_get_state(mailbox) != LB_MAILBOX_STATE_CLOSED)
+
+#define MAILBOX_CLOSED(mailbox) \
+ (libbalsa_mailbox_get_state(mailbox) == LB_MAILBOX_STATE_CLOSED)
#define RETURN_IF_MAILBOX_CLOSED(mailbox)\
do {\
@@ -144,7 +139,6 @@ enum LibBalsaMailboxCapability {
/*
* structures
*/
-typedef struct _LibBalsaMailboxClass LibBalsaMailboxClass;
typedef struct _LibBalsaMailboxView LibBalsaMailboxView;
struct _LibBalsaMailboxView {
@@ -183,70 +177,6 @@ struct _LibBalsaMailboxView {
int position; /* Position in the notebook */
};
-struct _LibBalsaMailbox {
- GObject object;
- gint stamp; /* used to determine iterators' validity. Increased on each
- * modification of mailbox. */
-
- gchar *config_prefix; /* unique string identifying mailbox */
- /* in the config file */
- gchar *name; /* displayed name for a special mailbox; */
- /* Isn't it a GUI thing? */
- gchar *url; /* Unique resource locator, file://, imap:// etc */
- guint open_ref;
-
- int lock; /* 0 if mailbox is unlocked; */
- /* >0 if mailbox is (recursively locked). */
- GThread *thread_id; /* id of thread that locked the mailbox */
- gboolean is_directory;
- gboolean readonly;
- gboolean disconnected;
-
- GPtrArray *mindex; /* the basic message index used for index
- * displaying/columns of GtkTreeModel interface
- * and NOTHING else. */
- GNode *msg_tree; /* the possibly filtered tree of messages;
- * gdk lock MUST BE HELD when accessing. */
- LibBalsaCondition *view_filter; /* to choose a subset of messages
- * to be displayed, e.g., only
- * undeleted. */
- LibBalsaCondition *persistent_view_filter; /* the part of the view
- * filter that will persist
- * to the next time the
- * mailbox is opened */
- gboolean view_filter_pending; /* a view filter has been set
- * but the view has not been updated */
-
- /* info fields */
- gboolean has_unread_messages;
- glong unread_messages; /* number of unread messages in the mailbox */
- unsigned first_unread; /* set to 0 if there is no unread present.
- * used for automatical scrolling down on opening.
- */
- /* Associated filters (struct mailbox_filter) */
- GSList * filters;
- gboolean filters_loaded;
-
- LibBalsaMailboxView *view;
- LibBalsaMailboxState state;
-
- /* Whether to reassemble a message from its parts. */
- gboolean no_reassemble;
-
- /* Whether the tree has been changed since some event. */
- gboolean msg_tree_changed;
-
- /* Array of msgnos that need to be displayed. */
- GArray *msgnos_pending;
- /* Array of msgnos that have been changed. */
- GArray *msgnos_changed;
-
- guint changed_idle_id;
- guint queue_check_idle_id;
- guint need_threading_idle_id;
- guint run_filters_idle_id;
-};
-
/* Search iter */
struct _LibBalsaMailboxSearchIter {
gint ref_count;
@@ -330,8 +260,6 @@ struct _LibBalsaMailboxClass {
gpointer cb_data);
};
-GType libbalsa_mailbox_get_type(void);
-
LibBalsaMailbox *libbalsa_mailbox_new_from_config(const gchar *prefix,
gboolean
is_special);
@@ -670,4 +598,50 @@ typedef enum {
extern gchar **libbalsa_mailbox_date_format;
+/*
+ * Getters
+ */
+GSList * libbalsa_mailbox_get_filters(LibBalsaMailbox * mailbox);
+const gchar * libbalsa_mailbox_get_name(LibBalsaMailbox * mailbox);
+const gchar * libbalsa_mailbox_get_url(LibBalsaMailbox * mailbox);
+glong libbalsa_mailbox_get_unread_messages(LibBalsaMailbox * mailbox);
+guint libbalsa_mailbox_get_first_unread(LibBalsaMailbox * mailbox);
+LibBalsaCondition * libbalsa_mailbox_get_view_filter(LibBalsaMailbox * mailbox,
+ gboolean persistent);
+GNode * libbalsa_mailbox_get_msg_tree(LibBalsaMailbox * mailbox);
+gboolean libbalsa_mailbox_get_msg_tree_changed(LibBalsaMailbox * mailbox);
+LibBalsaMailboxState libbalsa_mailbox_get_state(LibBalsaMailbox * mailbox);
+LibBalsaMailboxIndexEntry *libbalsa_mailbox_get_index_entry(LibBalsaMailbox * mailbox,
+ guint msgno);
+LibBalsaMailboxView * libbalsa_mailbox_get_view(LibBalsaMailbox * mailbox);
+gint libbalsa_mailbox_get_stamp(LibBalsaMailbox * mailbox);
+guint libbalsa_mailbox_get_open_ref(LibBalsaMailbox * mailbox);
+gboolean libbalsa_mailbox_get_readonly(LibBalsaMailbox * mailbox);
+const gchar * libbalsa_mailbox_get_config_prefix(LibBalsaMailbox * mailbox);
+gboolean libbalsa_mailbox_get_has_unread_messages(LibBalsaMailbox * mailbox);
+
+/*
+ * Setters
+ */
+void libbalsa_mailbox_clear_unread_messages(LibBalsaMailbox * mailbox);
+void libbalsa_mailbox_set_filters(LibBalsaMailbox * mailbox, GSList * filters);
+void libbalsa_mailbox_set_url(LibBalsaMailbox * mailbox, const gchar * url);
+void libbalsa_mailbox_set_first_unread(LibBalsaMailbox * mailbox, guint first);
+void libbalsa_mailbox_set_msg_tree_changed(LibBalsaMailbox * mailbox, gboolean changed);
+void libbalsa_mailbox_set_is_directory(LibBalsaMailbox * mailbox, gboolean is_directory);
+void libbalsa_mailbox_set_readonly(LibBalsaMailbox * mailbox, gboolean readonly);
+void libbalsa_mailbox_set_no_reassemble(LibBalsaMailbox * mailbox,
+ gboolean no_reassemble);
+void libbalsa_mailbox_set_name(LibBalsaMailbox * mailbox, const gchar * name);
+void libbalsa_mailbox_set_view(LibBalsaMailbox * mailbox, LibBalsaMailboxView * view);
+void libbalsa_mailbox_set_has_unread_messages(LibBalsaMailbox * mailbox,
+ gboolean has_unread_messages);
+void libbalsa_mailbox_set_config_prefix(LibBalsaMailbox * mailbox,
+ const gchar * config_prefix);
+
+/*
+ * Incrementers
+ */
+void libbalsa_mailbox_add_to_unread_messages(LibBalsaMailbox * mailbox, glong count);
+
#endif /* __LIBBALSA_MAILBOX_H__ */
diff --git a/libbalsa/mailbox_imap.c b/libbalsa/mailbox_imap.c
index 1d351af43..e3e91794c 100644
--- a/libbalsa/mailbox_imap.c
+++ b/libbalsa/mailbox_imap.c
@@ -78,6 +78,8 @@ struct _LibBalsaMailboxImap {
ImapAclType rights; /* RFC 4314 'myrights' */
GList *acls; /* RFC 4314 acl's */
+
+ gboolean disconnected;
};
struct _LibBalsaMailboxImapClass {
@@ -189,7 +191,7 @@ static struct message_info *message_info_from_msgno(
if (msgno > mimap->messages_info->len) {
printf("%s %s msgno %d > messages_info len %d\n", __func__,
- LIBBALSA_MAILBOX(mimap)->name, msgno,
+ libbalsa_mailbox_get_name(LIBBALSA_MAILBOX(mimap)), msgno,
mimap->messages_info->len);
msg_info = NULL;
} else
@@ -298,6 +300,7 @@ libbalsa_mailbox_imap_init(LibBalsaMailboxImap * mailbox)
mailbox->handle_refs = 0;
mailbox->sort_ranks = g_array_new(FALSE, FALSE, sizeof(guint));
mailbox->sort_field = -1; /* Initially invalid. */
+ mailbox->disconnected = FALSE;
}
/* libbalsa_mailbox_imap_finalize:
@@ -315,7 +318,7 @@ libbalsa_mailbox_imap_finalize(GObject * object)
mailbox = LIBBALSA_MAILBOX_IMAP(object);
- g_assert(LIBBALSA_MAILBOX(mailbox)->open_ref == 0);
+ g_assert(libbalsa_mailbox_get_open_ref(LIBBALSA_MAILBOX(mailbox)) == 0);
remote = LIBBALSA_MAILBOX_REMOTE(object);
g_free(mailbox->path); mailbox->path = NULL;
@@ -358,9 +361,11 @@ void
libbalsa_mailbox_imap_update_url(LibBalsaMailboxImap* mailbox)
{
LibBalsaServer *s = LIBBALSA_MAILBOX_REMOTE_SERVER(mailbox);
+ gchar *url;
- g_free(LIBBALSA_MAILBOX(mailbox)->url);
- LIBBALSA_MAILBOX(mailbox)->url = libbalsa_imap_url(s, mailbox->path);
+ url = libbalsa_imap_url(s, mailbox->path);
+ libbalsa_mailbox_set_url(LIBBALSA_MAILBOX(mailbox), url);
+ g_free(url);
}
void
@@ -715,6 +720,7 @@ mi_get_imsg(LibBalsaMailboxImap *mimap, unsigned msgno)
ImapMessage* imsg;
struct collect_seq_data csd;
ImapResponse rc;
+ GNode *msg_tree;
/* This test too weak: I can imagine unsolicited ENVELOPE
* responses sent from server that wil create the ImapMessage
@@ -725,8 +731,10 @@ mi_get_imsg(LibBalsaMailboxImap *mimap, unsigned msgno)
csd.msgno_arr = g_malloc(MAX_CHUNK_LENGTH*sizeof(csd.msgno_arr[0]));
csd.cnt = 0;
csd.has_it = 0;
- if(LIBBALSA_MAILBOX(mimap)->msg_tree) {
- g_node_traverse(LIBBALSA_MAILBOX(mimap)->msg_tree,
+
+ msg_tree = libbalsa_mailbox_get_msg_tree(LIBBALSA_MAILBOX(mimap));
+ if (msg_tree != NULL) {
+ g_node_traverse(msg_tree,
G_PRE_ORDER, G_TRAVERSE_ALL, -1, collect_seq_cb,
&csd);
if(csd.cnt>MAX_CHUNK_LENGTH) csd.cnt = MAX_CHUNK_LENGTH;
@@ -771,12 +779,12 @@ idle_unread_update_cb(LibBalsaMailbox *mailbox)
glong unread;
libbalsa_lock_mailbox(mailbox);
- unread = mailbox->unread_messages;
+ unread = libbalsa_mailbox_get_unread_messages(mailbox);
lbm_imap_get_unseen(LIBBALSA_MAILBOX_IMAP(mailbox));
- if(unread != mailbox->unread_messages)
+ if(unread != libbalsa_mailbox_get_unread_messages(mailbox))
libbalsa_mailbox_set_unread_messages_flag(mailbox,
- mailbox->unread_messages>0);
+ libbalsa_mailbox_get_unread_messages(mailbox)>0);
LIBBALSA_MAILBOX_IMAP(mailbox)->unread_update_id = 0;
libbalsa_unlock_mailbox(mailbox);
return FALSE;
@@ -824,6 +832,7 @@ imap_exists_idle(gpointer data)
LibBalsaMailboxImap *mimap = (LibBalsaMailboxImap*)data;
LibBalsaMailbox *mailbox = LIBBALSA_MAILBOX(mimap);
unsigned cnt;
+ GNode *msg_tree;
libbalsa_lock_mailbox(mailbox);
@@ -867,12 +876,13 @@ imap_exists_idle(gpointer data)
}
}
- if (mailbox->msg_tree)
- sibling = g_node_last_child(mailbox->msg_tree);
+ msg_tree = libbalsa_mailbox_get_msg_tree(LIBBALSA_MAILBOX(mimap));
+ if (msg_tree != NULL)
+ sibling = g_node_last_child(msg_tree);
for(i=mimap->messages_info->len+1; i <= cnt; i++) {
g_array_append_val(mimap->messages_info, a);
g_ptr_array_add(mimap->msgids, NULL);
- libbalsa_mailbox_msgno_inserted(mailbox, i, mailbox->msg_tree,
+ libbalsa_mailbox_msgno_inserted(mailbox, i, msg_tree,
&sibling);
}
++mimap->search_stamp;
@@ -975,6 +985,7 @@ libbalsa_mailbox_imap_get_selected_handle(LibBalsaMailboxImap *mimap,
LibBalsaImapServer *imap_server;
ImapResponse rc;
unsigned uidval;
+ gboolean readonly;
g_return_val_if_fail(LIBBALSA_MAILBOX_IMAP(mimap), NULL);
@@ -990,8 +1001,8 @@ libbalsa_mailbox_imap_get_selected_handle(LibBalsaMailboxImap *mimap,
return NULL;
}
II(rc,mimap->handle,
- imap_mbox_select(mimap->handle, mimap->path,
- &(LIBBALSA_MAILBOX(mimap)->readonly)));
+ imap_mbox_select(mimap->handle, mimap->path, &readonly));
+ libbalsa_mailbox_set_readonly(LIBBALSA_MAILBOX(mimap), readonly);
if (rc != IMR_OK) {
gchar *msg = imap_mbox_handle_get_last_msg(mimap->handle);
g_set_error(err, LIBBALSA_MAILBOX_ERROR, LIBBALSA_MAILBOX_OPEN_ERROR,
@@ -1006,7 +1017,7 @@ libbalsa_mailbox_imap_get_selected_handle(LibBalsaMailboxImap *mimap,
if (imap_mbox_get_my_rights(mimap->handle, &mimap->rights, FALSE) ==
IMR_OK) {
if (!IMAP_RIGHTS_CAN_WRITE(mimap->rights))
- LIBBALSA_MAILBOX(mimap)->readonly = TRUE;
+ libbalsa_mailbox_set_readonly(LIBBALSA_MAILBOX(mimap), TRUE);
if (mimap->rights & IMAP_ACL_ADMIN)
imap_mbox_get_acl(mimap->handle, mimap->path, &mimap->acls);
}
@@ -1036,26 +1047,29 @@ lbm_imap_get_unseen(LibBalsaMailboxImap * mimap)
{
LibBalsaMailbox *mailbox;
guint i, count, total;
+ guint first_unread;
if (!mimap->handle)
return;
mailbox = LIBBALSA_MAILBOX(mimap);
total = imap_mbox_handle_get_exists(mimap->handle);
- mailbox->first_unread = total;
+ first_unread = total;
for(i=count=0; i<total; i++) {
if(imap_mbox_handle_msgno_has_flags(mimap->handle,
i+1,
0, IMSGF_SEEN|IMSGF_DELETED)) {
count++;
- if(mailbox->first_unread>i)
- mailbox->first_unread = i+1;
+ if (first_unread > i)
+ first_unread = i + 1;
}
}
- if(count == 0)
- mailbox->first_unread = 0;
- mailbox->unread_messages = count;
+ if (count == 0)
+ first_unread = 0;
+ libbalsa_mailbox_set_first_unread(mailbox, first_unread);
+ libbalsa_mailbox_clear_unread_messages(mailbox);
+ libbalsa_mailbox_add_to_unread_messages(mailbox, count);
libbalsa_mailbox_set_unread_messages_flag(mailbox, count > 0);
}
@@ -1077,13 +1091,13 @@ libbalsa_mailbox_imap_open(LibBalsaMailbox * mailbox, GError **err)
mimap->handle = libbalsa_mailbox_imap_get_selected_handle(mimap, err);
if (!mimap->handle) {
- mimap->opened = FALSE;
- mailbox->disconnected = TRUE;
+ mimap->opened = FALSE;
+ mimap->disconnected = TRUE;
return FALSE;
}
- mimap->opened = TRUE;
- mailbox->disconnected = FALSE;
+ mimap->opened = TRUE;
+ mimap->disconnected = FALSE;
total_messages = imap_mbox_handle_get_exists(mimap->handle);
mimap->messages_info = g_array_sized_new(FALSE, TRUE,
sizeof(struct message_info),
@@ -1109,17 +1123,19 @@ libbalsa_mailbox_imap_open(LibBalsaMailbox * mailbox, GError **err)
g_object_set_data(G_OBJECT(mailbox), "cache-manager", NULL);
}
- mailbox->first_unread = imap_mbox_handle_first_unseen(mimap->handle);
+ libbalsa_mailbox_set_first_unread(mailbox,
+ imap_mbox_handle_first_unseen(mimap->handle));
libbalsa_mailbox_run_filters_on_reception(mailbox);
lbm_imap_get_unseen(mimap);
if (mimap->search_stamp)
++mimap->search_stamp;
else
- mimap->search_stamp = mailbox->stamp;
+ mimap->search_stamp = libbalsa_mailbox_get_stamp(mailbox);
#ifdef DEBUG
g_print(_("%s: Opening %s Refcount: %d\n"),
- "LibBalsaMailboxImap", mailbox->name, mailbox->open_ref);
+ "LibBalsaMailboxImap", libbalsa_mailbox_get_name(mailbox),
+ libbalsa_mailbox_get_open_ref(mailbox));
#endif
return TRUE;
}
@@ -1609,7 +1625,7 @@ GHashTable * libbalsa_mailbox_imap_get_matchings(LibBalsaMailboxImap* mbox,
libbalsa_information(LIBBALSA_INFORMATION_DEBUG,
_("IMAP SEARCH command failed for mailbox %s\n"
"falling back to default searching method"),
- LIBBALSA_MAILBOX(mbox)->url);
+ libbalsa_mailbox_get_url(LIBBALSA_MAILBOX(mbox)));
}
result = cbdata->res;
@@ -1674,7 +1690,7 @@ libbalsa_mailbox_imap_load_config(LibBalsaMailbox * mailbox,
libbalsa_information(LIBBALSA_INFORMATION_WARNING,
_("No path found for mailbox “%s”, "
"using “%s”"),
- mailbox->name, mimap->path);
+ libbalsa_mailbox_get_name(mailbox), mimap->path);
}
remote = LIBBALSA_MAILBOX_REMOTE(mailbox);
@@ -1716,11 +1732,10 @@ libbalsa_mailbox_imap_force_disconnect(LibBalsaMailboxImap* mimap)
g_return_if_fail(mimap != NULL);
if (mimap->handle) {/* we do not attempt to reconnect here */
- printf("Disconnecting %s (%u)\n", LIBBALSA_MAILBOX(mimap)->name,
- (unsigned)time(NULL));
+ const gchar *name = libbalsa_mailbox_get_name(LIBBALSA_MAILBOX(mimap));
+ printf("Disconnecting %s (%u)\n", name, (unsigned)time(NULL));
imap_handle_force_disconnect(mimap->handle);
- printf("Disconnected %s (%u)\n", LIBBALSA_MAILBOX(mimap)->name,
- (unsigned)time(NULL));
+ printf("Disconnected %s (%u)\n", name, (unsigned)time(NULL));
}
}
@@ -1731,15 +1746,17 @@ libbalsa_mailbox_imap_reconnect(LibBalsaMailboxImap* mimap)
if (mimap->handle &&
imap_mbox_is_disconnected (mimap->handle)) {
+ gboolean readonly;
+
printf("Reconnecting %s (%u)\n",
libbalsa_server_get_host(LIBBALSA_MAILBOX_REMOTE_SERVER(mimap)),
(unsigned)time(NULL));
- if (imap_mbox_handle_reconnect
- (mimap->handle, &(LIBBALSA_MAILBOX(mimap)->readonly))
- == IMAP_SUCCESS)
+ if (imap_mbox_handle_reconnect(mimap->handle, &readonly) == IMAP_SUCCESS) {
printf("Reconnected %s (%u)\n",
libbalsa_server_get_host(LIBBALSA_MAILBOX_REMOTE_SERVER(mimap)),
(unsigned)time(NULL));
+ }
+ libbalsa_mailbox_set_readonly(LIBBALSA_MAILBOX(mimap), readonly);
}
}
@@ -3139,11 +3156,11 @@ lbmi_get_imap_sort_key(LibBalsaMailbox *mbox)
{
ImapSortKey key = (ImapSortKey) LB_MBOX_FROM_COL;
- switch (mbox->view->sort_field) {
+ switch (libbalsa_mailbox_get_view(mbox)->sort_field) {
default:
case LB_MAILBOX_SORT_NO: key = IMSO_MSGNO; break;
case LB_MAILBOX_SORT_SENDER:
- key = mbox->view->show == LB_MAILBOX_SHOW_TO
+ key = libbalsa_mailbox_get_view(mbox)->show == LB_MAILBOX_SHOW_TO
? IMSO_TO : IMSO_FROM; break;
case LB_MAILBOX_SORT_SUBJECT: key = IMSO_SUBJECT; break;
case LB_MAILBOX_SORT_DATE: key = IMSO_DATE; break;
@@ -3160,10 +3177,11 @@ libbalsa_mailbox_imap_set_threading(LibBalsaMailbox *mailbox,
LibBalsaMailboxImap *mimap = LIBBALSA_MAILBOX_IMAP(mailbox);
GNode * new_tree = NULL;
guint msgno;
- ImapSearchKey *filter = lbmi_build_imap_query(mailbox->view_filter, NULL);
+ ImapSearchKey *filter =
+ lbmi_build_imap_query(libbalsa_mailbox_get_view_filter(mailbox, FALSE), NULL);
ImapResponse rc;
- mailbox->view->threading_type = thread_type;
+ libbalsa_mailbox_get_view(mailbox)->threading_type = thread_type;
switch(thread_type) {
case LB_MAILBOX_THREADING_SIMPLE:
case LB_MAILBOX_THREADING_JWZ:
@@ -3182,7 +3200,7 @@ libbalsa_mailbox_imap_set_threading(LibBalsaMailbox *mailbox,
II(rc,mimap->handle,
imap_mbox_sort_filter(mimap->handle,
lbmi_get_imap_sort_key(mailbox),
- mailbox->view->sort_type ==
+ libbalsa_mailbox_get_view(mailbox)->sort_type ==
LB_MAILBOX_SORT_TYPE_ASC,
filter));
if(rc == IMR_OK)
@@ -3237,7 +3255,7 @@ lbmi_compare_func(const SortTuple * a,
retval = g_array_index(mimap->sort_ranks, guint, seqnoa - 1) -
g_array_index(mimap->sort_ranks, guint, seqnob - 1);
- return mbox->view->sort_type == LB_MAILBOX_SORT_TYPE_ASC ?
+ return libbalsa_mailbox_get_view(mbox)->sort_type == LB_MAILBOX_SORT_TYPE_ASC ?
retval : -retval;
}
@@ -3247,7 +3265,7 @@ libbalsa_mailbox_imap_sort(LibBalsaMailbox *mbox, GArray *array)
LibBalsaMailboxImap *mimap;
mimap = LIBBALSA_MAILBOX_IMAP(mbox);
- if (mimap->sort_field != mbox->view->sort_field) {
+ if (mimap->sort_field != libbalsa_mailbox_get_view(mbox)->sort_field) {
/* Cached ranks are invalid. */
unsigned *msgno_arr;
guint i, len;
@@ -3256,7 +3274,7 @@ libbalsa_mailbox_imap_sort(LibBalsaMailbox *mbox, GArray *array)
msgno_arr = g_malloc(len * sizeof(unsigned));
for (i = 0; i < len; i++)
msgno_arr[i] = i + 1;
- if (mbox->view->sort_field != LB_MAILBOX_SORT_NO) {
+ if (libbalsa_mailbox_get_view(mbox)->sort_field != LB_MAILBOX_SORT_NO) {
ImapResponse rc;
/* Server-side sort of the whole mailbox. */
II(rc, LIBBALSA_MAILBOX_IMAP(mbox)->handle,
@@ -3269,7 +3287,7 @@ libbalsa_mailbox_imap_sort(LibBalsaMailbox *mbox, GArray *array)
g_array_index(mimap->sort_ranks, guint, msgno_arr[i] - 1) = i;
g_free(msgno_arr);
/* Validate the cache. */
- mimap->sort_field = mbox->view->sort_field;
+ mimap->sort_field = libbalsa_mailbox_get_view(mbox)->sort_field;
}
g_array_sort_with_data(array, (GCompareDataFunc) lbmi_compare_func,
mimap);
diff --git a/libbalsa/mailbox_local.c b/libbalsa/mailbox_local.c
index d32fd346f..0507ea603 100644
--- a/libbalsa/mailbox_local.c
+++ b/libbalsa/mailbox_local.c
@@ -40,7 +40,7 @@
static LibBalsaMailboxClass *parent_class = NULL;
static void libbalsa_mailbox_local_class_init(LibBalsaMailboxLocalClass *klass);
-static void libbalsa_mailbox_local_init(LibBalsaMailboxLocal * mailbox);
+static void libbalsa_mailbox_local_init(LibBalsaMailboxLocal * local);
static void libbalsa_mailbox_local_finalize(GObject * object);
static void libbalsa_mailbox_local_changed(LibBalsaMailbox * mailbox);
@@ -192,13 +192,13 @@ libbalsa_mailbox_local_class_init(LibBalsaMailboxLocalClass * klass)
}
static void
-libbalsa_mailbox_local_init(LibBalsaMailboxLocal * mailbox)
+libbalsa_mailbox_local_init(LibBalsaMailboxLocal * local)
{
- mailbox->sync_id = 0;
- mailbox->sync_time = 0;
- mailbox->sync_cnt = 0;
- mailbox->thread_id = 0;
- mailbox->save_tree_id = 0;
+ local->sync_id = 0;
+ local->sync_time = 0;
+ local->sync_cnt = 0;
+ local->thread_id = 0;
+ local->save_tree_id = 0;
}
LibBalsaMailbox *
@@ -230,9 +230,10 @@ libbalsa_mailbox_local_new(const gchar * path, gboolean create)
FIXME: proper suport for maildir and mh
*/
gint
-libbalsa_mailbox_local_set_path(LibBalsaMailboxLocal * mailbox,
+libbalsa_mailbox_local_set_path(LibBalsaMailboxLocal * local,
const gchar * path, gboolean create)
{
+ LibBalsaMailbox *mailbox = LIBBALSA_MAILBOX(local);
int i;
LibBalsaMailboxLocalClass *klass;
@@ -242,7 +243,7 @@ libbalsa_mailbox_local_set_path(LibBalsaMailboxLocal * mailbox,
klass = LIBBALSA_MAILBOX_LOCAL_GET_CLASS(mailbox);
g_assert(klass != NULL);
- if (LIBBALSA_MAILBOX(mailbox)->url != NULL) {
+ if (libbalsa_mailbox_get_url(mailbox) != NULL) {
const gchar *cur_path = libbalsa_mailbox_local_get_path(mailbox);
if (strcmp(path, cur_path) == 0)
return 0;
@@ -255,11 +256,15 @@ libbalsa_mailbox_local_set_path(LibBalsaMailboxLocal * mailbox,
/* update mailbox data */
if (i == 0) {
- if (klass->set_path)
- klass->set_path(mailbox, path);
- g_free(LIBBALSA_MAILBOX(mailbox)->url);
- LIBBALSA_MAILBOX(mailbox)->url =
- g_strconcat("file://", path, NULL);
+ gchar *url;
+
+ if (klass->set_path != NULL)
+ klass->set_path(local, path);
+
+ url = g_strconcat("file://", path, NULL);
+ libbalsa_mailbox_set_url(mailbox, url);
+ g_free(url);
+
return 0;
} else
return errno ? errno : -1;
@@ -325,16 +330,16 @@ libbalsa_mailbox_local_load_message(LibBalsaMailboxLocal * local,
LibBalsaMailboxLocalMessageInfo *
msg_info)
{
- LibBalsaMailbox *mbx = LIBBALSA_MAILBOX(local);
+ LibBalsaMailbox *mailbox = LIBBALSA_MAILBOX(local);
+ LibBalsaCondition *view_filter;
gboolean match;
msg_info->loaded = TRUE;
if ((msg_info->flags & LIBBALSA_MESSAGE_FLAG_NEW)
&& !(msg_info->flags & LIBBALSA_MESSAGE_FLAG_DELETED)) {
- mbx->unread_messages++;
- if (mbx->first_unread == 0)
- mbx->first_unread = msgno;
+ libbalsa_mailbox_add_to_unread_messages(mailbox, 1);
+ libbalsa_mailbox_set_first_unread(mailbox, msgno);
}
if (msg_info->flags & LIBBALSA_MESSAGE_FLAG_RECENT) {
@@ -344,19 +349,20 @@ libbalsa_mailbox_local_load_message(LibBalsaMailboxLocal * local,
lbm_local_get_message_with_msg_info(local, msgno, msg_info);
if (libbalsa_message_is_partial(msg_info->message, &id)) {
- libbalsa_mailbox_try_reassemble(mbx, id);
+ libbalsa_mailbox_try_reassemble(mailbox, id);
g_free(id);
}
}
- if (!mbx->view_filter)
+ view_filter = libbalsa_mailbox_get_view_filter(mailbox, FALSE);
+ if (view_filter == NULL)
match = TRUE;
- else if (!libbalsa_condition_is_flag_only(mbx->view_filter,
- mbx, msgno, &match))
- match = message_match_real(mbx, msgno, mbx->view_filter);
+ else if (!libbalsa_condition_is_flag_only(view_filter,
+ mailbox, msgno, &match))
+ match = message_match_real(mailbox, msgno, view_filter);
if (match)
- libbalsa_mailbox_msgno_inserted(mbx, msgno, mbx->msg_tree,
+ libbalsa_mailbox_msgno_inserted(mailbox, msgno, libbalsa_mailbox_get_msg_tree(mailbox),
sibling);
}
@@ -445,14 +451,14 @@ static void
libbalsa_mailbox_local_load_config(LibBalsaMailbox * mailbox,
const gchar * prefix)
{
- gchar* path;
- g_return_if_fail(LIBBALSA_IS_MAILBOX_LOCAL(mailbox));
-
- g_free(mailbox->url);
+ gchar *path;
+ gchar *url;
path = libbalsa_conf_get_string("Path");
- mailbox->url = g_strconcat("file://", path, NULL);
+ url = g_strconcat("file://", path, NULL);
g_free(path);
+ libbalsa_mailbox_set_url(mailbox, url);
+ g_free(url);
if (LIBBALSA_MAILBOX_CLASS(parent_class)->load_config)
LIBBALSA_MAILBOX_CLASS(parent_class)->load_config(mailbox, prefix);
@@ -528,17 +534,19 @@ static void
lbm_local_save_tree(LibBalsaMailboxLocal * local)
{
LibBalsaMailbox *mailbox = LIBBALSA_MAILBOX(local);
+ GNode *msg_tree;
gchar *filename;
LibBalsaMailboxLocalSaveTreeInfo save_info;
GError *err = NULL;
- if (!mailbox->msg_tree || !mailbox->msg_tree_changed)
+ if ((msg_tree = libbalsa_mailbox_get_msg_tree(mailbox)) == NULL ||
+ !libbalsa_mailbox_get_msg_tree_changed(mailbox))
return;
- mailbox->msg_tree_changed = FALSE;
+ libbalsa_mailbox_set_msg_tree_changed(mailbox, FALSE);
filename = lbm_local_get_cache_filename(local);
- if (!mailbox->msg_tree->children
+ if (msg_tree->children == NULL
|| (libbalsa_mailbox_get_threading_type(mailbox) ==
LB_MAILBOX_THREADING_FLAT
&& libbalsa_mailbox_get_sort_field(mailbox) ==
@@ -556,7 +564,7 @@ lbm_local_save_tree(LibBalsaMailboxLocal * local)
&save_info);
/* Pre-order is required for the file to be created correctly. */
- g_node_traverse(mailbox->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
+ g_node_traverse(msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
(GNodeTraverseFunc) lbm_local_save_tree_func,
&save_info);
@@ -576,6 +584,7 @@ static gboolean
lbm_local_restore_tree(LibBalsaMailboxLocal * local, guint * total)
{
LibBalsaMailbox *mailbox = LIBBALSA_MAILBOX(local);
+ const gchar *mailbox_name;
gchar *filename;
gchar *name;
struct stat st;
@@ -589,7 +598,8 @@ lbm_local_restore_tree(LibBalsaMailboxLocal * local, guint * total)
guint);
filename = lbm_local_get_cache_filename(local);
- name = mailbox->name ? g_strdup(mailbox->name) :
+ mailbox_name = libbalsa_mailbox_get_name(mailbox);
+ name = mailbox_name != NULL ? g_strdup(mailbox_name) :
g_path_get_basename(libbalsa_mailbox_local_get_path(local));
if (stat(filename, &st) < 0
@@ -634,7 +644,7 @@ lbm_local_restore_tree(LibBalsaMailboxLocal * local, guint * total)
*total = info->value.total;
seen = g_new0(guint8, *total);
- parent = mailbox->msg_tree;
+ parent = libbalsa_mailbox_get_msg_tree(mailbox);
sibling = NULL;
get_info = LIBBALSA_MAILBOX_LOCAL_GET_CLASS(local)->get_info;
while (++info < (LibBalsaMailboxLocalTreeInfo *) (contents + length)) {
@@ -662,7 +672,7 @@ lbm_local_restore_tree(LibBalsaMailboxLocal * local, guint * total)
/* Check one level higher. */
sibling = parent;
parent = parent->parent;
- if (!parent) {
+ if (parent != NULL) {
/* We got to the root without finding the parent. */
libbalsa_information(LIBBALSA_INFORMATION_DEBUG,
_("Cache file for mailbox %s "
@@ -682,12 +692,9 @@ lbm_local_restore_tree(LibBalsaMailboxLocal * local, guint * total)
if (libbalsa_mailbox_msgno_has_flags(mailbox, info->msgno,
LIBBALSA_MESSAGE_FLAG_NEW,
- LIBBALSA_MESSAGE_FLAG_DELETED))
- {
- ++mailbox->unread_messages;
- if (mailbox->first_unread == 0 ||
- mailbox->first_unread > info->msgno)
- mailbox->first_unread = info->msgno;
+ LIBBALSA_MESSAGE_FLAG_DELETED)) {
+ libbalsa_mailbox_add_to_unread_messages(mailbox, 1);
+ libbalsa_mailbox_set_first_unread(mailbox, info->msgno);
}
}
@@ -705,7 +712,7 @@ lbm_local_save_tree_real(LibBalsaMailboxLocal * local)
libbalsa_lock_mailbox(mailbox);
- if (MAILBOX_OPEN(mailbox) && mailbox->msg_tree_changed)
+ if (MAILBOX_OPEN(mailbox) && libbalsa_mailbox_get_msg_tree_changed(mailbox))
lbm_local_save_tree(local);
local->save_tree_id = 0;
@@ -749,7 +756,7 @@ libbalsa_mailbox_local_close_mailbox(LibBalsaMailbox * mailbox,
/* Restore the persistent view before saving the tree. */
libbalsa_mailbox_set_view_filter(mailbox,
- mailbox->persistent_view_filter, TRUE);
+ libbalsa_mailbox_get_view_filter(mailbox, TRUE), TRUE);
if (local->thread_id) {
g_source_remove(local->thread_id);
@@ -822,7 +829,7 @@ message_match_real(LibBalsaMailbox *mailbox, guint msgno,
gboolean match = FALSE;
gboolean is_refed = FALSE;
LibBalsaMailboxIndexEntry *entry =
- g_ptr_array_index(mailbox->mindex, msgno-1);
+ libbalsa_mailbox_get_index_entry(mailbox, msgno);
LibBalsaMailboxLocalInfo *info =
msgno <= local->threading_info->len ?
g_ptr_array_index(local->threading_info, msgno - 1) : NULL;
@@ -830,12 +837,12 @@ message_match_real(LibBalsaMailbox *mailbox, guint msgno,
/* We may be able to match the msgno from info cached in entry or
* info; if those are NULL, we'll need to fetch the message, so we
* fetch it here, and that will also populate entry and info. */
- if (!entry || !info) {
+ if (entry == NULL || info == NULL) {
message = libbalsa_mailbox_get_message(mailbox, msgno);
- if (!message)
+ if (message == NULL)
return FALSE;
libbalsa_mailbox_local_cache_message(local, msgno, message);
- entry = g_ptr_array_index(mailbox->mindex, msgno-1);
+ entry = libbalsa_mailbox_get_index_entry(mailbox, msgno);
info = g_ptr_array_index(local->threading_info, msgno - 1);
}
@@ -964,10 +971,12 @@ message_match_real(LibBalsaMailbox *mailbox, guint msgno,
case CONDITION_NONE:
break;
}
- if(message) {
- if(is_refed) libbalsa_message_body_unref(message);
+ if (message != NULL) {
+ if (is_refed)
+ libbalsa_message_body_unref(message);
g_object_unref(message);
}
+
return cond->negate ? !match : match;
}
static gboolean
@@ -1028,9 +1037,10 @@ libbalsa_mailbox_local_cache_message(LibBalsaMailboxLocal * local,
static gboolean
lbml_load_messages_idle_cb(LibBalsaMailbox * mailbox)
{
+ LibBalsaMailboxLocal *local;
+ GNode *msg_tree;
guint msgno;
guint new_messages;
- LibBalsaMailboxLocal *local;
guint lastno;
GNode *lastn;
LibBalsaMailboxLocalMessageInfo *(*get_info) (LibBalsaMailboxLocal *,
@@ -1040,7 +1050,8 @@ lbml_load_messages_idle_cb(LibBalsaMailbox * mailbox)
local = (LibBalsaMailboxLocal *) mailbox;
local->load_messages_id = 0;
- if (!mailbox->msg_tree) {
+ msg_tree = libbalsa_mailbox_get_msg_tree(mailbox);
+ if (msg_tree == NULL) {
/* Mailbox is closed, or no view has been created. */
libbalsa_unlock_mailbox(mailbox);
return FALSE;
@@ -1049,7 +1060,7 @@ lbml_load_messages_idle_cb(LibBalsaMailbox * mailbox)
lastno = libbalsa_mailbox_total_messages(mailbox);
msgno = local->msgno;
new_messages = lastno - msgno;
- lastn = g_node_last_child(mailbox->msg_tree);
+ lastn = g_node_last_child(msg_tree);
get_info = LIBBALSA_MAILBOX_LOCAL_GET_CLASS(local)->get_info;
while (++msgno <= lastno){
LibBalsaMailboxLocalMessageInfo *msg_info = get_info(local, msgno);
@@ -1061,11 +1072,10 @@ lbml_load_messages_idle_cb(LibBalsaMailbox * mailbox)
msg_info->message);
}
- if (new_messages) {
+ if (new_messages > 0) {
libbalsa_mailbox_run_filters_on_reception(mailbox);
libbalsa_mailbox_set_unread_messages_flag(mailbox,
- mailbox->
- unread_messages > 0);
+ libbalsa_mailbox_get_unread_messages(mailbox) > 0);
}
libbalsa_unlock_mailbox(mailbox);
@@ -1109,7 +1119,7 @@ static void
lbml_set_threading(LibBalsaMailbox * mailbox,
LibBalsaMailboxThreadingType thread_type)
{
- if (mailbox->msg_tree == NULL)
+ if (libbalsa_mailbox_get_msg_tree(mailbox) == NULL)
return;
switch (thread_type) {
@@ -1151,7 +1161,7 @@ libbalsa_mailbox_local_set_threading(LibBalsaMailbox * mailbox,
#if defined(DEBUG_LOADING_AND_THREADING)
printf("before load_messages: time=%lu\n", (unsigned long) time(NULL));
#endif
- if (!mailbox->msg_tree) { /* first reference */
+ if (libbalsa_mailbox_get_msg_tree(mailbox) == NULL) { /* first reference */
guint total = 0;
gboolean natural = (thread_type == LB_MAILBOX_THREADING_FLAT
&& libbalsa_mailbox_get_sort_field(mailbox) ==
@@ -1163,7 +1173,7 @@ libbalsa_mailbox_local_set_threading(LibBalsaMailbox * mailbox,
libbalsa_mailbox_set_msg_tree(mailbox, g_node_new(NULL));
total = 0;
}
- mailbox->msg_tree_changed = FALSE;
+ libbalsa_mailbox_set_msg_tree_changed(mailbox, FALSE);
if (total < libbalsa_mailbox_total_messages(mailbox)) {
if (!natural)
@@ -1229,7 +1239,7 @@ lbm_local_update_view_filter(LibBalsaMailbox * mailbox,
&& !libbalsa_condition_is_flag_only(view_filter, NULL, 0, NULL)) {
gchar *text;
- text = g_strdup_printf(_("Filtering %s"), mailbox->name);
+ text = g_strdup_printf(_("Filtering %s"), libbalsa_mailbox_get_name(mailbox));
libbalsa_progress_set_text(&progress, text, total);
g_free(text);
is_flag_only = FALSE;
@@ -1314,7 +1324,7 @@ libbalsa_mailbox_local_prepare_threading(LibBalsaMailbox * mailbox,
libbalsa_lock_mailbox(mailbox);
libbalsa_mailbox_local_set_threading_info(local);
- text = g_strdup_printf(_("Preparing %s"), mailbox->name);
+ text = g_strdup_printf(_("Preparing %s"), libbalsa_mailbox_get_name(mailbox));
total = libbalsa_mailbox_total_messages(mailbox);
libbalsa_progress_set_text(&progress, text, total - start);
g_free(text);
@@ -1451,7 +1461,7 @@ static void
lbml_info_setup(LibBalsaMailbox * mailbox, ThreadingInfo * ti)
{
ti->mailbox = mailbox;
- ti->root = g_node_new(mailbox->msg_tree);
+ ti->root = g_node_new(libbalsa_mailbox_get_msg_tree(mailbox));
ti->id_table = g_hash_table_new(g_str_hash, g_str_equal);
ti->subject_table = NULL;
}
@@ -1480,7 +1490,8 @@ lbml_thread_messages(LibBalsaMailbox * mailbox, gboolean subject_gather)
lbml_info_setup(mailbox, &ti);
/* Traverse the mailbox's msg_tree, to build the second tree. */
- g_node_traverse(mailbox->msg_tree, G_POST_ORDER, G_TRAVERSE_ALL, -1,
+ g_node_traverse(libbalsa_mailbox_get_msg_tree(mailbox),
+ G_POST_ORDER, G_TRAVERSE_ALL, -1,
(GNodeTraverseFunc) lbml_set_parent, &ti);
/* Prune the second tree. */
g_node_traverse(ti.root, G_POST_ORDER, G_TRAVERSE_ALL, -1,
@@ -1991,8 +2002,12 @@ lbml_clear_empty(GNode * msg_tree)
static gboolean
lbml_unthread_message(GNode * node, LibBalsaMailbox * mailbox)
{
- if (node->parent != NULL && node->parent != mailbox->msg_tree)
- libbalsa_mailbox_unlink_and_prepend(mailbox, node, mailbox->msg_tree);
+ if (node->parent != NULL) {
+ GNode *msg_tree = libbalsa_mailbox_get_msg_tree(mailbox);
+
+ if (node->parent != msg_tree)
+ libbalsa_mailbox_unlink_and_prepend(mailbox, node, msg_tree);
+ }
return FALSE;
}
@@ -2000,7 +2015,8 @@ lbml_unthread_message(GNode * node, LibBalsaMailbox * mailbox)
static void
lbml_threading_flat(LibBalsaMailbox * mailbox)
{
- g_node_traverse(mailbox->msg_tree, G_POST_ORDER, G_TRAVERSE_ALL, -1,
+ g_node_traverse(libbalsa_mailbox_get_msg_tree(mailbox),
+ G_POST_ORDER, G_TRAVERSE_ALL, -1,
(GNodeTraverseFunc) lbml_unthread_message, mailbox);
}
@@ -2073,7 +2089,7 @@ lbm_local_sync_real(LibBalsaMailboxLocal * local)
!libbalsa_mailbox_sync_storage(mailbox, FALSE)) /* cannot sync */
libbalsa_information(LIBBALSA_INFORMATION_WARNING,
_("Failed to sync mailbox “%s”"),
- mailbox->name);
+ libbalsa_mailbox_get_name(mailbox));
local->sync_time += time(NULL)-tstart;
local->sync_cnt++;
libbalsa_unlock_mailbox(mailbox);
@@ -2202,15 +2218,15 @@ libbalsa_mailbox_local_messages_change_flags(LibBalsaMailbox * mailbox,
is_unread_undeleted =
(msg_info->flags & LIBBALSA_MESSAGE_FLAG_NEW)
&& !(msg_info->flags & LIBBALSA_MESSAGE_FLAG_DELETED);
- mailbox->unread_messages +=
- is_unread_undeleted - was_unread_undeleted;
+ libbalsa_mailbox_add_to_unread_messages(mailbox,
+ is_unread_undeleted - was_unread_undeleted);
}
}
libbalsa_unlock_mailbox(mailbox);
if (changed > 0) {
libbalsa_mailbox_set_unread_messages_flag(mailbox,
- mailbox->unread_messages
+ libbalsa_mailbox_get_unread_messages(mailbox)
> 0);
lbm_local_sync_queue(local);
}
diff --git a/libbalsa/mailbox_local.h b/libbalsa/mailbox_local.h
index 89d9988e3..c5e7df76a 100644
--- a/libbalsa/mailbox_local.h
+++ b/libbalsa/mailbox_local.h
@@ -101,8 +101,8 @@ gint libbalsa_mailbox_local_set_path(LibBalsaMailboxLocal * mailbox,
void libbalsa_mailbox_local_set_threading_info(LibBalsaMailboxLocal *
local);
-#define libbalsa_mailbox_local_get_path(mbox) \
- ((const gchar *) (LIBBALSA_MAILBOX(mbox))->url+7)
+#define libbalsa_mailbox_local_get_path(local) \
+ (libbalsa_mailbox_get_url((LibBalsaMailbox*)local)+7)
void libbalsa_mailbox_local_load_messages(LibBalsaMailbox * mailbox,
guint last_msgno);
diff --git a/libbalsa/mailbox_maildir.c b/libbalsa/mailbox_maildir.c
index de3a64ee7..ff35c20a2 100644
--- a/libbalsa/mailbox_maildir.c
+++ b/libbalsa/mailbox_maildir.c
@@ -264,7 +264,7 @@ libbalsa_mailbox_maildir_new(const gchar * path, gboolean create)
mailbox = g_object_new(LIBBALSA_TYPE_MAILBOX_MAILDIR, NULL);
- mailbox->is_directory = TRUE;
+ libbalsa_mailbox_set_is_directory(mailbox, TRUE);
if (libbalsa_mailbox_local_set_path(LIBBALSA_MAILBOX_LOCAL(mailbox),
path, create) != 0) {
@@ -326,8 +326,10 @@ static void
lbm_maildir_remove_files(LibBalsaMailboxLocal *mailbox)
{
const gchar* path;
+
g_return_if_fail(LIBBALSA_IS_MAILBOX_MAILDIR(mailbox));
- path = libbalsa_mailbox_local_get_path(mailbox);
+
+ path = libbalsa_mailbox_local_get_path((LibBalsaMailboxLocal *) mailbox);
g_print("DELETE MAILDIR\n");
if (!libbalsa_delete_directory_contents(path)) {
@@ -386,6 +388,7 @@ static LibBalsaMessageFlag parse_filename(const gchar *subdir,
static void lbm_maildir_parse(LibBalsaMailboxMaildir * mdir,
const gchar *subdir, guint * fileno)
{
+ const gchar *local_path;
gchar *path;
GDir *dir;
GHashTable *messages_info;
@@ -396,8 +399,8 @@ static void lbm_maildir_parse(LibBalsaMailboxMaildir * mdir,
LibBalsaMessageFlag flags;
LibBalsaMailbox *mailbox = (LibBalsaMailbox *) mdir;
- path = g_build_filename(libbalsa_mailbox_local_get_path(mailbox),
- subdir, NULL);
+ local_path = libbalsa_mailbox_local_get_path((LibBalsaMailboxLocal *) mailbox);
+ path = g_build_filename(local_path, subdir, NULL);
dir = g_dir_open(path, 0, NULL);
g_free(path);
if (dir == NULL)
@@ -477,7 +480,7 @@ libbalsa_mailbox_maildir_open(LibBalsaMailbox * mailbox, GError **err)
g_return_val_if_fail(LIBBALSA_IS_MAILBOX_MAILDIR(mailbox), FALSE);
mdir = LIBBALSA_MAILBOX_MAILDIR(mailbox);
- path = libbalsa_mailbox_local_get_path(mailbox);
+ path = libbalsa_mailbox_local_get_path((LibBalsaMailboxLocal *) mailbox);
if (stat(path, &st) == -1) {
g_set_error(err, LIBBALSA_MAILBOX_ERROR, LIBBALSA_MAILBOX_OPEN_ERROR,
@@ -492,16 +495,17 @@ libbalsa_mailbox_maildir_open(LibBalsaMailbox * mailbox, GError **err)
if (stat(mdir->tmpdir, &st) != -1)
libbalsa_mailbox_set_mtime(mailbox, st.st_mtime);
- mailbox->readonly =
+ libbalsa_mailbox_set_readonly(mailbox,
!(access(mdir->curdir, W_OK) == 0 &&
access(mdir->newdir, W_OK) == 0 &&
- access(mdir->tmpdir, W_OK) == 0);
+ access(mdir->tmpdir, W_OK) == 0));
- mailbox->unread_messages = 0;
+ libbalsa_mailbox_clear_unread_messages(mailbox);
lbm_maildir_parse_subdirs(mdir);
#ifdef DEBUG
g_print(_("%s: Opening %s Refcount: %d\n"),
- "LibBalsaMailboxMaildir", mailbox->name, mailbox->open_ref);
+ "LibBalsaMailboxMaildir", libbalsa_mailbox_get_name(mailbox),
+ libbalsa_mailbox_get_open_ref(mailbox));
#endif
return TRUE;
}
@@ -570,7 +574,7 @@ libbalsa_mailbox_maildir_check(LibBalsaMailbox * mailbox)
}
/* Was any message removed? */
- path = libbalsa_mailbox_local_get_path(mailbox);
+ path = libbalsa_mailbox_local_get_path((LibBalsaMailboxLocal *) mailbox);
renumber = mdir->msgno_2_msg_info->len + 1;
for (msgno = 1; msgno <= mdir->msgno_2_msg_info->len; ) {
gchar *filename;
@@ -748,7 +752,7 @@ libbalsa_mailbox_maildir_sync(LibBalsaMailbox * mailbox, gboolean expunge)
* record mtime of dirs
*/
LibBalsaMailboxMaildir *mdir = LIBBALSA_MAILBOX_MAILDIR(mailbox);
- const gchar *path = libbalsa_mailbox_local_get_path(mailbox);
+ const gchar *path = libbalsa_mailbox_local_get_path((LibBalsaMailboxLocal *) mailbox);
GSList *removed_list = NULL;
gboolean ok = TRUE;
GSList *l;
@@ -771,7 +775,7 @@ libbalsa_mailbox_maildir_sync(LibBalsaMailbox * mailbox, gboolean expunge)
continue;
}
- if (mailbox->state == LB_MAILBOX_STATE_CLOSING)
+ if (libbalsa_mailbox_get_state(mailbox) == LB_MAILBOX_STATE_CLOSING)
msg_info->local_info.flags &= ~LIBBALSA_MESSAGE_FLAG_RECENT;
if (((msg_info->local_info.flags & LIBBALSA_MESSAGE_FLAG_RECENT)
&& strcmp(msg_info->subdir, "new") != 0)
@@ -813,7 +817,7 @@ libbalsa_mailbox_maildir_sync(LibBalsaMailbox * mailbox, gboolean expunge)
/* Reparse, to get the fileno entries right. */
lbm_maildir_parse_subdirs(mdir);
- mailbox->msg_tree_changed = TRUE;
+ libbalsa_mailbox_set_msg_tree_changed(mailbox, TRUE);
if (stat(mdir->tmpdir, &st) == 0)
libbalsa_mailbox_set_mtime(mailbox, st.st_mtime);
diff --git a/libbalsa/mailbox_mbox.c b/libbalsa/mailbox_mbox.c
index f7248ceb2..01b3315f7 100644
--- a/libbalsa/mailbox_mbox.c
+++ b/libbalsa/mailbox_mbox.c
@@ -223,7 +223,7 @@ libbalsa_mailbox_mbox_new(const gchar * path, gboolean create)
mailbox = g_object_new(LIBBALSA_TYPE_MAILBOX_MBOX, NULL);
- mailbox->is_directory = FALSE;
+ libbalsa_mailbox_set_is_directory(mailbox, FALSE);
if (libbalsa_mailbox_local_set_path(LIBBALSA_MAILBOX_LOCAL(mailbox),
path, create) != 0) {
@@ -319,14 +319,16 @@ libbalsa_mailbox_mbox_remove_files(LibBalsaMailboxLocal *mailbox)
static int mbox_lock(LibBalsaMailbox * mailbox, GMimeStream *stream)
{
- const gchar *path = libbalsa_mailbox_local_get_path(mailbox);
+ const gchar *path =
+ libbalsa_mailbox_local_get_path(LIBBALSA_MAILBOX_LOCAL(mailbox));
int fd = GMIME_STREAM_FS(stream)->fd;
return libbalsa_lock_file(path, fd, FALSE, TRUE, 1);
}
static void mbox_unlock(LibBalsaMailbox * mailbox, GMimeStream *stream)
{
- const gchar *path = libbalsa_mailbox_local_get_path(mailbox);
+ const gchar *path =
+ libbalsa_mailbox_local_get_path(LIBBALSA_MAILBOX_LOCAL(mailbox));
int fd = GMIME_STREAM_FS(stream)->fd;
libbalsa_unlock_file(path, fd, 1);
}
@@ -679,11 +681,12 @@ libbalsa_mailbox_mbox_open(LibBalsaMailbox * mailbox, GError **err)
LibBalsaMailboxMbox *mbox = LIBBALSA_MAILBOX_MBOX(mailbox);
struct stat st;
const gchar* path;
+ gboolean readonly;
int fd;
GMimeStream *gmime_stream;
time_t t0;
- path = libbalsa_mailbox_local_get_path(mailbox);
+ path = libbalsa_mailbox_local_get_path(LIBBALSA_MAILBOX_LOCAL(mailbox));
if (stat(path, &st) == -1) {
g_set_error(err, LIBBALSA_MAILBOX_ERROR, LIBBALSA_MAILBOX_OPEN_ERROR,
@@ -691,8 +694,9 @@ libbalsa_mailbox_mbox_open(LibBalsaMailbox * mailbox, GError **err)
return FALSE;
}
- mailbox->readonly = access (path, W_OK);
- fd = open(path, mailbox->readonly ? O_RDONLY : O_RDWR);
+ readonly = access (path, W_OK);
+ libbalsa_mailbox_set_readonly(mailbox, readonly);
+ fd = open(path, readonly ? O_RDONLY : O_RDWR);
if (fd == -1) {
g_set_error(err, LIBBALSA_MAILBOX_ERROR, LIBBALSA_MAILBOX_OPEN_ERROR,
_("Cannot open mailbox."));
@@ -730,7 +734,7 @@ libbalsa_mailbox_mbox_open(LibBalsaMailbox * mailbox, GError **err)
mbox->msgno_2_msg_info =
g_ptr_array_new_with_free_func((GDestroyNotify) free_message_info);
- mailbox->unread_messages = 0;
+ libbalsa_mailbox_clear_unread_messages(mailbox);
time(&t0);
if (st.st_size > 0) {
@@ -979,7 +983,7 @@ libbalsa_mailbox_mbox_check(LibBalsaMailbox * mailbox)
g_assert(LIBBALSA_IS_MAILBOX_MBOX(mailbox));
mbox = LIBBALSA_MAILBOX_MBOX(mailbox);
- path = libbalsa_mailbox_local_get_path(mailbox);
+ path = libbalsa_mailbox_local_get_path(LIBBALSA_MAILBOX_LOCAL(mailbox));
if (mbox->gmime_stream ?
fstat(GMIME_STREAM_FS(mbox->gmime_stream)->fd, &st) :
stat(path, &st)) {
@@ -1076,7 +1080,7 @@ libbalsa_mailbox_mbox_check(LibBalsaMailbox * mailbox)
if ((msg_info->local_info.flags & LIBBALSA_MESSAGE_FLAG_NEW)
&& !(msg_info->local_info.flags & LIBBALSA_MESSAGE_FLAG_DELETED))
- --mailbox->unread_messages;
+ libbalsa_mailbox_add_to_unread_messages(mailbox, -1);
/* We must drop the mime-stream lock to call
* libbalsa_mailbox_local_msgno_removed(), as it will grab the
@@ -1432,7 +1436,7 @@ libbalsa_mailbox_mbox_sync(LibBalsaMailbox * mailbox, gboolean expunge)
return TRUE;
mbox_stream = mbox->gmime_stream;
- path = libbalsa_mailbox_local_get_path(mailbox);
+ path = libbalsa_mailbox_local_get_path(LIBBALSA_MAILBOX_LOCAL(mailbox));
/* lock mailbox file */
if (mbox_lock(mailbox, mbox_stream) != 0)
@@ -1457,7 +1461,7 @@ libbalsa_mailbox_mbox_sync(LibBalsaMailbox * mailbox, gboolean expunge)
for (i = j = 0; i < messages; i++)
{
msg_info = message_info_from_msgno(mbox, i + 1);
- if (mailbox->state == LB_MAILBOX_STATE_CLOSING)
+ if (libbalsa_mailbox_get_state(mailbox) == LB_MAILBOX_STATE_CLOSING)
msg_info->local_info.flags &= ~LIBBALSA_MESSAGE_FLAG_RECENT;
if (expunge && (msg_info->local_info.flags & LIBBALSA_MESSAGE_FLAG_DELETED))
break;
@@ -1643,7 +1647,7 @@ libbalsa_mailbox_mbox_sync(LibBalsaMailbox * mailbox, gboolean expunge)
unlink(tempfile); /* remove partial copy of the mailbox */
g_free(tempfile);
- if (mailbox->state == LB_MAILBOX_STATE_CLOSING) {
+ if (libbalsa_mailbox_get_state(mailbox) == LB_MAILBOX_STATE_CLOSING) {
/* Just shorten the msg_info array. */
for (j = first; j < mbox->msgno_2_msg_info->len; ) {
msg_info = message_info_from_msgno(mbox, j + 1);
diff --git a/libbalsa/mailbox_mh.c b/libbalsa/mailbox_mh.c
index ac1261db9..840f11f15 100644
--- a/libbalsa/mailbox_mh.c
+++ b/libbalsa/mailbox_mh.c
@@ -221,7 +221,7 @@ libbalsa_mailbox_mh_new(const gchar * path, gboolean create)
mailbox = g_object_new(LIBBALSA_TYPE_MAILBOX_MH, NULL);
- mailbox->is_directory = TRUE;
+ libbalsa_mailbox_set_is_directory(mailbox, TRUE);
if (libbalsa_mailbox_local_set_path(LIBBALSA_MAILBOX_LOCAL(mailbox),
path, create) != 0) {
@@ -340,7 +340,7 @@ lbm_mh_parse_mailbox(LibBalsaMailboxMh * mh, gboolean add_msg_info)
GDir *dir;
const gchar *filename;
- path = libbalsa_mailbox_local_get_path(mh);
+ path = libbalsa_mailbox_local_get_path((LibBalsaMailboxLocal *) mh);
if ((dir = g_dir_open(path, 0, NULL)) == NULL)
return;
@@ -515,7 +515,7 @@ libbalsa_mailbox_mh_open(LibBalsaMailbox * mailbox, GError **err)
struct stat st;
const gchar* path;
- path = libbalsa_mailbox_local_get_path(mailbox);
+ path = libbalsa_mailbox_local_get_path((LibBalsaMailboxLocal *) mailbox);
if (stat(path, &st) == -1) {
g_set_error(err, LIBBALSA_MAILBOX_ERROR, LIBBALSA_MAILBOX_OPEN_ERROR,
@@ -531,8 +531,8 @@ libbalsa_mailbox_mh_open(LibBalsaMailbox * mailbox, GError **err)
mh->msgno_2_msg_info = g_ptr_array_new();
mh->last_fileno = 0;
- mailbox->readonly = access (path, W_OK);
- mailbox->unread_messages = 0;
+ libbalsa_mailbox_set_readonly(mailbox, access(path, W_OK));
+ libbalsa_mailbox_clear_unread_messages(mailbox);
lbm_mh_parse_both(mh);
#ifdef DEBUG
@@ -613,7 +613,8 @@ libbalsa_mailbox_mh_check(LibBalsaMailbox * mailbox)
{
struct stat st, st_sequences;
LibBalsaMailboxMh *mh = LIBBALSA_MAILBOX_MH(mailbox);
- const gchar *path = libbalsa_mailbox_local_get_path(mailbox);
+ const gchar *path =
+ libbalsa_mailbox_local_get_path((LibBalsaMailboxLocal *) mailbox);
int modified = 0;
guint renumber, msgno;
struct message_info *msg_info;
@@ -819,14 +820,14 @@ libbalsa_mailbox_mh_sync(LibBalsaMailbox * mailbox, gboolean expunge)
recent.first = recent.last = -1;
recent.line = g_mime_stream_mem_new();
- path = libbalsa_mailbox_local_get_path(mailbox);
+ path = libbalsa_mailbox_local_get_path((LibBalsaMailboxLocal *) mailbox);
msgno = 1;
while (msgno <= mh->msgno_2_msg_info->len) {
msg_info = lbm_mh_message_info_from_msgno(mh, msgno);
if (msg_info->local_info.flags == LIBBALSA_MESSAGE_FLAG_INVALID)
msg_info->local_info.flags = msg_info->orig_flags;
- if (mailbox->state == LB_MAILBOX_STATE_CLOSING)
+ if (libbalsa_mailbox_get_state(mailbox) == LB_MAILBOX_STATE_CLOSING)
msg_info->local_info.flags &= ~LIBBALSA_MESSAGE_FLAG_RECENT;
if (expunge && (msg_info->local_info.flags
@@ -891,7 +892,7 @@ libbalsa_mailbox_mh_sync(LibBalsaMailbox * mailbox, gboolean expunge)
}
/* open tempfile */
- path = libbalsa_mailbox_local_get_path(mailbox);
+ path = libbalsa_mailbox_local_get_path((LibBalsaMailboxLocal *) mailbox);
fd = libbalsa_mailbox_mh_open_temp(path, &name_used);
if (fd == -1)
{
diff --git a/libbalsa/mailbox_pop3.c b/libbalsa/mailbox_pop3.c
index 12270fe2a..b6436f262 100644
--- a/libbalsa/mailbox_pop3.c
+++ b/libbalsa/mailbox_pop3.c
@@ -148,11 +148,11 @@ libbalsa_mailbox_pop3_finalize(GObject * object)
LibBalsaMailboxPop3*
libbalsa_mailbox_pop3_new(void)
{
- LibBalsaMailboxPop3 *mailbox;
+ LibBalsaMailboxPop3 *mailbox_pop3;
- mailbox = g_object_new(LIBBALSA_TYPE_MAILBOX_POP3, NULL);
+ mailbox_pop3 = g_object_new(LIBBALSA_TYPE_MAILBOX_POP3, NULL);
- return mailbox;
+ return mailbox_pop3;
}
@@ -431,16 +431,26 @@ message_cb(const gchar *buffer,
notify_progress(fd);
if (fd->filter_path == NULL) {
- GError *add_err = NULL;
+ GError *add_err = NULL;
+ LibBalsaMailbox *mailbox;
+ LibBalsaMailbox *inbox;
+
+ mailbox = fd->mailbox;
+ inbox = LIBBALSA_MAILBOX_POP3(mailbox)->inbox;
g_mime_stream_reset(fd->handler->mbx_stream);
- result = libbalsa_mailbox_add_message(LIBBALSA_MAILBOX_POP3(fd->mailbox)->inbox,
fd->handler->mbx_stream,
- LIBBALSA_MESSAGE_FLAG_NEW | LIBBALSA_MESSAGE_FLAG_RECENT, &add_err);
+ result =
+ libbalsa_mailbox_add_message(inbox, fd->handler->mbx_stream,
+ LIBBALSA_MESSAGE_FLAG_NEW |
+ LIBBALSA_MESSAGE_FLAG_RECENT,
+ &add_err);
if (!result) {
libbalsa_information(LIBBALSA_INFORMATION_WARNING, _("Error appending message %d from
%s to %s: %s"),
- info->id, fd->mailbox->name, LIBBALSA_MAILBOX_POP3(fd->mailbox)->inbox->name,
- (add_err != NULL) ? add_err->message : "?");
- g_error_free(add_err);
+ info->id,
+ libbalsa_mailbox_get_name(mailbox),
+ libbalsa_mailbox_get_name(inbox),
+ add_err != NULL ? add_err->message : "?");
+ g_clear_error(&add_err);
}
}
@@ -462,11 +472,12 @@ message_cb(const gchar *buffer,
static NetClientPop *
-libbalsa_mailbox_pop3_startup(LibBalsaServer *server,
- const LibBalsaMailboxPop3 *mbox,
- const gchar *name,
- GList **msg_list)
+libbalsa_mailbox_pop3_startup(LibBalsaServer *server,
+ LibBalsaMailboxPop3 *mailbox_pop3,
+ const gchar *name,
+ GList **msg_list)
{
+ LibBalsaMailbox *mailbox = (LibBalsaMailbox *) mailbox_pop3;
NetClientCryptMode security;
const gchar *host;
NetClientPop *pop;
@@ -477,9 +488,9 @@ libbalsa_mailbox_pop3_startup(LibBalsaServer *server,
security = libbalsa_server_get_security(server);
host = libbalsa_server_get_host(server);
if (security == NET_CLIENT_CRYPT_ENCRYPTED) {
- pop = net_client_pop_new(host, 995U, security, mbox->enable_pipe);
+ pop = net_client_pop_new(host, 995U, security, mailbox_pop3->enable_pipe);
} else {
- pop = net_client_pop_new(host, 110U, security, mbox->enable_pipe);
+ pop = net_client_pop_new(host, 110U, security, mailbox_pop3->enable_pipe);
}
if (pop == NULL) {
return NULL;
@@ -488,7 +499,7 @@ libbalsa_mailbox_pop3_startup(LibBalsaServer *server,
/* configure the mailbox connection; allow all (including plain text) auth methods even for
unencrypted connections so using
* e.g. popfile on localhost is possible, i.e. the user is responsible for choosing a proper security
mode */
allow_auth = NET_CLIENT_POP_AUTH_ALL;
- if (mbox->disable_apop) {
+ if (mailbox_pop3->disable_apop) {
allow_auth &= ~NET_CLIENT_POP_AUTH_APOP;
}
net_client_pop_allow_auth(pop, TRUE, allow_auth);
@@ -518,7 +529,7 @@ libbalsa_mailbox_pop3_startup(LibBalsaServer *server,
g_signal_connect(G_OBJECT(pop), "auth", G_CALLBACK(libbalsa_server_get_auth), server);
/* connect server */
- libbalsa_mailbox_progress_notify(LIBBALSA_MAILBOX(mbox), LIBBALSA_NTFY_INIT, INFINITY, _("Connecting
%s…"), host);
+ libbalsa_mailbox_progress_notify(mailbox, LIBBALSA_NTFY_INIT, INFINITY, _("Connecting %s…"), host);
if (!net_client_pop_connect(pop, NULL, &error)) {
libbalsa_information(LIBBALSA_INFORMATION_ERROR, _("POP3 mailbox %s: cannot connect %s: %s"),
name, host,
error->message);
@@ -533,8 +544,8 @@ libbalsa_mailbox_pop3_startup(LibBalsaServer *server,
}
/* load message list */
- libbalsa_mailbox_progress_notify(LIBBALSA_MAILBOX(mbox), LIBBALSA_NTFY_UPDATE, INFINITY, _("List
messages…"));
- if (!net_client_pop_list(pop, msg_list, !mbox->delete_from_server, &error)) {
+ libbalsa_mailbox_progress_notify(mailbox, LIBBALSA_NTFY_UPDATE, INFINITY, _("List messages…"));
+ if (!net_client_pop_list(pop, msg_list, !mailbox_pop3->delete_from_server, &error)) {
libbalsa_information(LIBBALSA_INFORMATION_ERROR, _("POP3 mailbox %s error: %s"), name,
error->message);
g_error_free(error);
net_client_shutdown(NET_CLIENT(pop));
@@ -548,10 +559,10 @@ libbalsa_mailbox_pop3_startup(LibBalsaServer *server,
static GList *
update_msg_list(struct fetch_data *fd,
- const LibBalsaMailboxPop3 *mbox,
- GHashTable **current_uids,
- LibBalsaServer *server,
- GList *msg_list)
+ const LibBalsaMailboxPop3 *mailbox_pop3,
+ GHashTable **current_uids,
+ LibBalsaServer *server,
+ GList *msg_list)
{
GHashTable *uids = NULL;
gchar *uid_prefix = NULL;
@@ -559,7 +570,7 @@ update_msg_list(struct fetch_data *fd,
GList *p;
/* load uid's if messages shall be left on the server */
- if (!mbox->delete_from_server) {
+ if (!mailbox_pop3->delete_from_server) {
uid_prefix = g_strconcat(libbalsa_server_get_user(server), "@",
libbalsa_server_get_host(server), NULL);
prefix_len = strlen(uid_prefix);
@@ -577,7 +588,8 @@ update_msg_list(struct fetch_data *fd,
GList* next = p->next;
/* check for oversized message */
- if ((mbox->msg_size_limit > 0) && (msg_info->size >= (gsize) mbox->msg_size_limit)) {
+ if ((mailbox_pop3->msg_size_limit > 0) &&
+ (msg_info->size >= (gsize) mailbox_pop3->msg_size_limit)) {
gchar *size_str;
size_str = libbalsa_size_to_gchar(msg_info->size);
@@ -588,7 +600,7 @@ update_msg_list(struct fetch_data *fd,
}
/* check if we already know this message */
- if (!skip && !mbox->delete_from_server) {
+ if (!skip && !mailbox_pop3->delete_from_server) {
gchar *full_uid = g_strconcat(uid_prefix, " ", msg_info->uid, NULL);
g_hash_table_insert(*current_uids, full_uid, GINT_TO_POINTER(1));
@@ -609,7 +621,7 @@ update_msg_list(struct fetch_data *fd,
}
/* copy all keys /not/ starting with the prefix from the old to the current hash table, and drop the
old table */
- if (!mbox->delete_from_server && (msg_list != NULL)) {
+ if (!mailbox_pop3->delete_from_server && (msg_list != NULL)) {
GHashTableIter iter;
gpointer key;
@@ -633,19 +645,20 @@ update_msg_list(struct fetch_data *fd,
static void
libbalsa_mailbox_pop3_check(LibBalsaMailbox * mailbox)
{
- LibBalsaMailboxPop3 *mbox = LIBBALSA_MAILBOX_POP3(mailbox);
+ LibBalsaMailboxPop3 *mailbox_pop3 = LIBBALSA_MAILBOX_POP3(mailbox);
LibBalsaServer *server;
NetClientPop *pop;
GList *msg_list;
- if (!mbox->check || (mbox->inbox == NULL)) {
+ if (!mailbox_pop3->check || (mailbox_pop3->inbox == NULL)) {
return;
}
- server = LIBBALSA_MAILBOX_REMOTE_SERVER(mbox);
+ server = LIBBALSA_MAILBOX_REMOTE_SERVER(mailbox_pop3);
/* open the mailbox connection and get the messages list (note: initiates the progress dialogue) */
- pop = libbalsa_mailbox_pop3_startup(server, mbox, mailbox->name, &msg_list);
+ pop = libbalsa_mailbox_pop3_startup(server, mailbox_pop3,
+ libbalsa_mailbox_get_name(mailbox), &msg_list);
/* proceed on success only */
if (pop != NULL) {
@@ -661,7 +674,8 @@ libbalsa_mailbox_pop3_check(LibBalsaMailbox * mailbox)
/* nothing to do if no messages are on the server */
if (msg_list != NULL) {
/* load uid's if messages shall be left on the server */
- msg_list = update_msg_list(&fd, mbox, ¤t_uids, server, msg_list);
+ msg_list = update_msg_list(&fd, mailbox_pop3, ¤t_uids,
+ server, msg_list);
}
/* download messages unless the list is empty */
@@ -673,13 +687,13 @@ libbalsa_mailbox_pop3_check(LibBalsaMailbox * mailbox)
ngettext("%lu new message (%s)", "%lu new messages (%s)", fd.total_messages),
(unsigned long) fd.total_messages, fd.total_size_msg);
- if (mbox->filter) {
- fd.filter_path = mbox->filter_cmd;
+ if (mailbox_pop3->filter) {
+ fd.filter_path = mailbox_pop3->filter_cmd;
}
if (result) {
result = net_client_pop_retr(pop, msg_list, message_cb, &fd, &err);
- if (result && mbox->delete_from_server) {
+ if (result && mailbox_pop3->delete_from_server) {
libbalsa_mailbox_progress_notify(mailbox, LIBBALSA_NTFY_UPDATE,
INFINITY,
_("Deleting messages on server…"));
result = net_client_pop_dele(pop, msg_list, &err);
@@ -692,7 +706,7 @@ libbalsa_mailbox_pop3_check(LibBalsaMailbox * mailbox)
}
/* store uid list */
- if (result && !mbox->delete_from_server) {
+ if (result && !mailbox_pop3->delete_from_server) {
gchar *uid_prefix =
g_strconcat(libbalsa_server_get_user(server), "@",
libbalsa_server_get_host(server), NULL);
@@ -776,18 +790,18 @@ void
libbalsa_mailbox_pop3_set_inbox(LibBalsaMailbox *mailbox,
LibBalsaMailbox *inbox)
{
- LibBalsaMailboxPop3 *pop;
+ LibBalsaMailboxPop3 *mailbox_pop3;
g_return_if_fail(LIBBALSA_IS_MAILBOX_POP3(mailbox));
- pop = LIBBALSA_MAILBOX_POP3(mailbox);
+ mailbox_pop3 = LIBBALSA_MAILBOX_POP3(mailbox);
- pop->inbox=inbox;
+ mailbox_pop3->inbox=inbox;
}
void
-libbalsa_mailbox_pop3_set_msg_size_limit(LibBalsaMailboxPop3 *pop,
+libbalsa_mailbox_pop3_set_msg_size_limit(LibBalsaMailboxPop3 *mailbox_pop3,
gint sz_limit)
{
- pop->msg_size_limit = sz_limit;
+ mailbox_pop3->msg_size_limit = sz_limit;
}
diff --git a/libbalsa/message.c b/libbalsa/message.c
index 2f56e104b..fc061cbfe 100644
--- a/libbalsa/message.c
+++ b/libbalsa/message.c
@@ -606,11 +606,11 @@ libbalsa_message_change_flags(LibBalsaMessage * message,
g_return_if_fail(LIBBALSA_IS_MAILBOX(message->mailbox));
g_return_if_fail(message->msgno > 0);
- if (message->mailbox->readonly) {
+ if (libbalsa_mailbox_get_readonly(message->mailbox)) {
libbalsa_information(LIBBALSA_INFORMATION_WARNING,
_("Mailbox (%s) is read-only: "
"cannot change flags."),
- message->mailbox->name);
+ libbalsa_mailbox_get_name(message->mailbox));
return;
}
diff --git a/libbalsa/send.c b/libbalsa/send.c
index b206157c9..e83846dc0 100644
--- a/libbalsa/send.c
+++ b/libbalsa/send.c
@@ -437,7 +437,7 @@ lbs_message_queue_real(LibBalsaMessage *message,
if (fccbox != NULL) {
g_mime_object_set_header(GMIME_OBJECT(message->mime_msg), "X-Balsa-Fcc",
- fccbox->url);
+ libbalsa_mailbox_get_url(fccbox));
}
g_mime_object_set_header(GMIME_OBJECT(message->mime_msg), "X-Balsa-DSN",
message->request_dsn ? "1" : "0");
@@ -637,7 +637,7 @@ lbs_check_reachable_cb(GObject *object,
_("Cannot reach SMTP server %s (%s), any queued message will remain in %s."),
libbalsa_smtp_server_get_name(smtp_server),
libbalsa_server_get_host(LIBBALSA_SERVER(smtp_server)),
- send_info->outbox->name);
+ libbalsa_mailbox_get_name(send_info->outbox));
}
if (!thread_started) {
@@ -937,20 +937,23 @@ balsa_send_message_success(MessageQueueItem *mqi,
if (fccurl != NULL) {
LibBalsaMailbox *fccbox = info->finder(fccurl);
+ const gchar *fccname = libbalsa_mailbox_get_name(fccbox);
GError *err = NULL;
if (!info->no_dialog) {
libbalsa_progress_dialog_update(&send_progress_dialog, info->progress_id,
FALSE, NAN,
- _("Save message in %s…"), fccbox->name);
+ _("Save message in %s…"), fccname);
}
libbalsa_message_change_flags(mqi->orig, 0, LIBBALSA_MESSAGE_FLAG_NEW |
LIBBALSA_MESSAGE_FLAG_FLAGGED);
libbalsa_mailbox_sync_storage(mqi->orig->mailbox, FALSE);
remove = libbalsa_message_copy(mqi->orig, fccbox, &err);
if (!remove) {
- libbalsa_information(LIBBALSA_INFORMATION_ERROR, _("Saving sent message to %s
failed: %s"), fccbox->name,
- err ? err->message : "?");
- g_clear_error(&err);
+ libbalsa_information(LIBBALSA_INFORMATION_ERROR,
+ _("Saving sent message to %s failed: %s"),
+ fccname,
+ err != NULL ? err->message : "?");
+ g_clear_error(&err);
}
}
diff --git a/libinit_balsa/assistant_page_directory.c b/libinit_balsa/assistant_page_directory.c
index 7499884ce..b99c65767 100644
--- a/libinit_balsa/assistant_page_directory.c
+++ b/libinit_balsa/assistant_page_directory.c
@@ -141,14 +141,18 @@ unconditional_mailbox(const gchar * path, const gchar * prettyname,
if (*box == NULL) {
if (strcmp("/var/spool/mail/", path)) {
char tmp[32] = "/tmp/balsa.XXXXXX";
+
/* Don't fail if you can't create the spool mailbox. */
close(mkstemp(tmp));
- *box = libbalsa_mailbox_local_new(tmp, FALSE);
- if (*box) {
- free((*box)->url);
- (*box)->url = g_strdup_printf("file://%s",path);
- }
- unlink(tmp);
+ *box = libbalsa_mailbox_local_new(tmp, FALSE);
+ if (*box != NULL) {
+ gchar *mailbox_url;
+
+ mailbox_url = g_strdup_printf("file://%s", path);
+ libbalsa_mailbox_set_url(*box, mailbox_url);
+ g_free(mailbox_url);
+ }
+ unlink(tmp);
}
}
if ( *box == NULL) {
@@ -159,11 +163,11 @@ unconditional_mailbox(const gchar * path, const gchar * prettyname,
return;
}
- (*box)->name = g_strdup(gettext(prettyname));
+ libbalsa_mailbox_set_name(*box, gettext(prettyname));
config_mailbox_add(*box, (char *) prettyname);
if (box == &balsa_app.outbox)
- (*box)->no_reassemble = TRUE;
+ libbalsa_mailbox_set_no_reassemble(*box, TRUE);
}
static void
diff --git a/libinit_balsa/assistant_page_user.c b/libinit_balsa/assistant_page_user.c
index 0bd26f321..5f9a92117 100644
--- a/libinit_balsa/assistant_page_user.c
+++ b/libinit_balsa/assistant_page_user.c
@@ -200,12 +200,17 @@ create_pop3_mbx(const gchar *name, const gchar* host, gint security,
LibBalsaMailboxPop3 *pop = libbalsa_mailbox_pop3_new();
LibBalsaMailbox *mbx = LIBBALSA_MAILBOX(pop);
LibBalsaServer *server = LIBBALSA_MAILBOX_REMOTE_SERVER(pop);
+ gchar *mailbox_name;
libbalsa_server_set_username(server, login);
libbalsa_server_set_password(server, passwd, FALSE);
libbalsa_server_set_host(server, host, security);
libbalsa_server_set_remember_password(server, remember);
- mbx->name = g_strdup(name && *name ? name : host);
+
+ mailbox_name = g_strdup(name && *name ? name : host);
+ libbalsa_mailbox_set_name(mbx, mailbox_name);
+ g_free(mailbox_name);
+
pop->check = TRUE;
pop->disable_apop = FALSE;
pop->delete_from_server = TRUE;
diff --git a/src/balsa-app.c b/src/balsa-app.c
index 35d4418f5..ca5c9e86d 100644
--- a/src/balsa-app.c
+++ b/src/balsa-app.c
@@ -680,7 +680,8 @@ find_url(GtkTreeModel * model, GtkTreePath * path, GtkTreeIter * iter,
LibBalsaMailbox *mailbox;
gtk_tree_model_get(model, iter, 0, &mbnode, -1);
- if ((mailbox = mbnode->mailbox) && !strcmp(mailbox->url, bf->data)) {
+ if ((mailbox = mbnode->mailbox) != NULL &&
+ strcmp(libbalsa_mailbox_get_url(mailbox), bf->data) == 0) {
bf->mbnode = mbnode;
return TRUE;
}
@@ -746,16 +747,22 @@ gchar*
balsa_get_short_mailbox_name(const gchar *url)
{
BalsaMailboxNode *mbnode;
+ gchar *short_name;
+
+ if ((mbnode = balsa_find_url(url)) != NULL && mbnode->mailbox != NULL) {
+ const gchar *name = libbalsa_mailbox_get_name(mbnode->mailbox);
- if ((mbnode = balsa_find_url(url)) && mbnode->mailbox) {
if (mbnode->server) {
- return g_strconcat(libbalsa_server_get_host(mbnode->server), ":",
- mbnode->mailbox->name, NULL);
+ short_name = g_strconcat(libbalsa_server_get_host(mbnode->server), ":",
+ name, NULL);
} else {
- return g_strdup(mbnode->mailbox->name);
+ short_name = g_strdup(name);
}
+ } else {
+ short_name = g_strdup(url);
}
- return g_strdup(url);
+
+ return short_name;
}
struct balsa_find_iter_by_data_info {
@@ -838,10 +845,10 @@ ba_remove_children_mailbox_nodes(GtkTreeModel * model, GtkTreeIter * parent,
} else {
printf("sparing %s %s\n",
mbnode->mailbox ? "mailbox" : "folder ",
- mbnode->mailbox ? mbnode->mailbox->name : mbnode->name);
+ mbnode->mailbox ? libbalsa_mailbox_get_name(mbnode->mailbox) : mbnode->name);
valid = gtk_tree_model_iter_next(model, &iter);
}
- g_object_unref(mbnode);
+ g_object_unref(mbnode);
} while (valid);
}
diff --git a/src/balsa-index.c b/src/balsa-index.c
index 04249ee78..aa22a05cc 100644
--- a/src/balsa-index.c
+++ b/src/balsa-index.c
@@ -808,6 +808,7 @@ static gboolean
bndx_scroll_on_open_idle(BalsaIndex *index)
{
LibBalsaMailbox *mailbox;
+ guint first_unread;
GtkTreeView *tree_view = GTK_TREE_VIEW(index);
GtkTreePath *path;
gpointer view_on_open;
@@ -817,10 +818,11 @@ bndx_scroll_on_open_idle(BalsaIndex *index)
balsa_index_update_tree(index, balsa_app.expand_tree);
mailbox = index->mailbox_node->mailbox;
- if (mailbox->first_unread) {
- unsigned msgno = mailbox->first_unread;
- mailbox->first_unread = 0;
- if(!libbalsa_mailbox_msgno_find(mailbox, msgno, &path, NULL))
+ first_unread = libbalsa_mailbox_get_first_unread(mailbox);
+ if (first_unread > 0) {
+ unsigned msgno = first_unread;
+ libbalsa_mailbox_set_first_unread(mailbox, 0);
+ if (!libbalsa_mailbox_msgno_find(mailbox, msgno, &path, NULL))
return FALSE; /* Oops! */
} else {
/* we want to scroll to the last one in current order. The
@@ -901,7 +903,7 @@ bndx_mailbox_row_inserted_cb(LibBalsaMailbox * mailbox, GtkTreePath * path,
{
guint msgno;
- if (mailbox->state != LB_MAILBOX_STATE_OPEN)
+ if (libbalsa_mailbox_get_state(mailbox) != LB_MAILBOX_STATE_OPEN)
return;
gtk_tree_model_get(GTK_TREE_MODEL(mailbox), iter,
@@ -1361,6 +1363,7 @@ static gboolean
bndx_mailbox_changed_idle(BalsaIndex * bindex)
{
LibBalsaMailbox *mailbox;
+ guint first_unread;
GtkTreePath *path;
if (bndx_clear_if_last_ref(&bindex))
@@ -1369,12 +1372,13 @@ bndx_mailbox_changed_idle(BalsaIndex * bindex)
bindex->has_mailbox_changed_idle = FALSE;
mailbox = bindex->mailbox_node->mailbox;
- if (mailbox->first_unread
- && libbalsa_mailbox_msgno_find(mailbox, mailbox->first_unread,
+ first_unread = libbalsa_mailbox_get_first_unread(mailbox);
+ if (first_unread > 0
+ && libbalsa_mailbox_msgno_find(mailbox, first_unread,
&path, NULL)) {
bndx_expand_to_row(bindex, path);
gtk_tree_path_free(path);
- mailbox->first_unread = 0;
+ libbalsa_mailbox_set_first_unread(mailbox, 0);
}
if (bndx_find_current_msgno(bindex, &path, NULL)) {
@@ -1939,6 +1943,7 @@ bndx_do_popup(BalsaIndex * index, GdkEventButton * event)
gboolean any_not_deleted = FALSE;
GArray *selected = balsa_index_selected_msgnos_new(index);
guint i;
+ gboolean readonly;
BALSA_DEBUG();
@@ -1961,17 +1966,18 @@ bndx_do_popup(BalsaIndex * index, GdkEventButton * event)
g_list_free(l);
mailbox = index->mailbox_node->mailbox;
+ readonly = libbalsa_mailbox_get_readonly(mailbox);
gtk_widget_set_sensitive(index->delete_item,
- any_not_deleted && !mailbox->readonly);
+ any_not_deleted && !readonly);
gtk_widget_set_sensitive(index->undelete_item,
- any_deleted && !mailbox->readonly);
+ any_deleted && !readonly);
gtk_widget_set_sensitive(index->move_to_trash_item,
any && mailbox != balsa_app.trash
- && !mailbox->readonly);
+ && !readonly);
gtk_widget_set_sensitive(index->toggle_item,
- any && !mailbox->readonly);
+ any && !readonly);
gtk_widget_set_sensitive(index->move_to_item,
- any && !mailbox->readonly);
+ any && !readonly);
submenu =
balsa_mblist_mru_menu(GTK_WINDOW
@@ -2124,6 +2130,7 @@ balsa_index_transfer(BalsaIndex *index, GArray * msgnos,
gboolean success;
LibBalsaMailbox *from_mailbox;
GError *e = NULL;
+ const gchar *to_name;
if (msgnos->len == 0)
return;
@@ -2133,13 +2140,14 @@ balsa_index_transfer(BalsaIndex *index, GArray * msgnos,
libbalsa_mailbox_messages_copy(from_mailbox, msgnos, to_mailbox, &e) :
libbalsa_mailbox_messages_move(from_mailbox, msgnos, to_mailbox, &e);
+ to_name = libbalsa_mailbox_get_name(to_mailbox);
if (!success) {
balsa_information
(LIBBALSA_INFORMATION_WARNING,
ngettext("Failed to copy %d message to mailbox “%s”: %s",
"Failed to copy %d messages to mailbox “%s”: %s",
msgnos->len),
- msgnos->len, to_mailbox->name, e ? e->message : "?");
+ msgnos->len, to_name, e ? e->message : "?");
return;
}
@@ -2149,7 +2157,7 @@ balsa_index_transfer(BalsaIndex *index, GArray * msgnos,
enable_empty_trash(balsa_app.main_window, TRASH_FULL);
balsa_information(LIBBALSA_INFORMATION_MESSAGE,
copy ? _("Copied to “%s”.")
- : _("Moved to “%s”."), to_mailbox->name);
+ : _("Moved to “%s”."), to_name);
if (!copy)
/* Note when message was flagged as deleted, for use in
* auto-expunge. */
@@ -2245,14 +2253,14 @@ balsa_index_expunge(BalsaIndex * index)
g_return_if_fail(index != NULL);
mailbox = index->mailbox_node->mailbox;
- if (mailbox->readonly)
+ if (libbalsa_mailbox_get_readonly(mailbox))
return;
rc = libbalsa_mailbox_sync_storage(mailbox, TRUE);
if (!rc)
balsa_information(LIBBALSA_INFORMATION_WARNING,
_("Committing mailbox %s failed."),
- mailbox->name);
+ libbalsa_mailbox_get_name(mailbox));
}
/* Message window */
diff --git a/src/balsa-mblist.c b/src/balsa-mblist.c
index 5270bf717..8adf44767 100644
--- a/src/balsa-mblist.c
+++ b/src/balsa-mblist.c
@@ -1030,6 +1030,7 @@ static void
bmbl_mailbox_changed_cb(LibBalsaMailbox * mailbox, gpointer data)
{
struct update_mbox_data *umd;
+ LibBalsaMailboxState state;
g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
@@ -1046,8 +1047,9 @@ bmbl_mailbox_changed_cb(LibBalsaMailbox * mailbox, gpointer data)
g_idle_add((GSourceFunc) update_mailbox_idle, umd);
}
- umd->notify = (mailbox->state == LB_MAILBOX_STATE_OPEN
- || mailbox->state == LB_MAILBOX_STATE_CLOSED);
+ state = libbalsa_mailbox_get_state(mailbox);
+ umd->notify = (state == LB_MAILBOX_STATE_OPEN
+ || state == LB_MAILBOX_STATE_CLOSED);
G_UNLOCK(mblist_update);
}
@@ -1337,7 +1339,7 @@ bmbl_store_redraw_mbnode(GtkTreeIter * iter, BalsaMailboxNode * mbnode)
? BALSA_PIXMAP_MBOX_TRAY_FULL
: BALSA_PIXMAP_MBOX_TRAY_EMPTY;
- name = mailbox->name;
+ name = libbalsa_mailbox_get_name(mailbox);
/* Make sure the show column is set before showing the
* mailbox in the list. */
@@ -1480,12 +1482,14 @@ bmbl_node_style(GtkTreeModel * model, GtkTreeIter * iter)
mailbox == balsa_app.draftbox || mailbox == balsa_app.trash)) {
const gchar *icon;
const gchar *name;
+ const gchar *mailbox_name;
gchar *tmp = NULL;
PangoWeight weight;
/* Set the style appropriate for unread_messages; we do this
* even if the state hasn't changed, because we might be
* rerendering after hiding or showing the info columns. */
+ mailbox_name = libbalsa_mailbox_get_name(mailbox);
if (unread_messages > 0) {
gboolean display_info;
@@ -1495,16 +1499,16 @@ bmbl_node_style(GtkTreeModel * model, GtkTreeIter * iter)
(G_OBJECT(model),
BALSA_MBLIST_DISPLAY_INFO));
name = (!display_info && total_messages >= 0) ?
- (tmp = g_strdup_printf("%s (%d)", mailbox->name,
+ (tmp = g_strdup_printf("%s (%d)", mailbox_name,
unread_messages))
- : mailbox->name;
+ : mailbox_name;
weight = PANGO_WEIGHT_BOLD;
mbnode->style |= MBNODE_STYLE_NEW_MAIL;
} else {
icon = (mailbox == balsa_app.inbox) ?
BALSA_PIXMAP_MBOX_IN : BALSA_PIXMAP_MBOX_TRAY_EMPTY;
- name = mailbox->name;
+ name = mailbox_name;
weight = PANGO_WEIGHT_NORMAL;
mbnode->style &= ~MBNODE_STYLE_NEW_MAIL;
}
@@ -1751,7 +1755,7 @@ bmbl_mru_menu(GtkWindow * window, GList ** url_list,
if (mailbox || (allow_empty && !*url)) {
mru = bmbl_mru_new(url_list, user_func, user_data, url);
item =
- gtk_menu_item_new_with_label(mailbox ? mailbox->name : "");
+ gtk_menu_item_new_with_label(mailbox ? libbalsa_mailbox_get_name(mailbox) : "");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_signal_connect_data(item, "activate",
G_CALLBACK(bmbl_mru_activate_cb), mru,
@@ -1948,7 +1952,7 @@ bmbl_mru_selected_cb(GtkTreeSelection * selection, gpointer data)
model = gtk_tree_view_get_model(tree_view);
gtk_tree_model_get_iter(model, &iter, path);
gtk_tree_model_get(model, &iter, 0, &mbnode, -1);
- ((BalsaMBListMRUEntry *) data)->url = g_strdup(mbnode->mailbox->url);
+ ((BalsaMBListMRUEntry *) data)->url = g_strdup(libbalsa_mailbox_get_url(mbnode->mailbox));
g_object_unref(mbnode);
bmbl_mru_activate_cb(NULL, data);
@@ -1982,7 +1986,7 @@ bmbl_mru_activated_cb(GtkTreeView * tree_view, GtkTreePath * path,
if (mbnode->mailbox) {
((BalsaMBListMRUEntry *) data)->url =
- g_strdup(mbnode->mailbox->url);
+ g_strdup(libbalsa_mailbox_get_url(mbnode->mailbox));
bmbl_mru_activate_cb(NULL, data);
gtk_dialog_response(GTK_DIALOG
diff --git a/src/balsa-message.c b/src/balsa-message.c
index 23b33335e..de456b3b5 100644
--- a/src/balsa-message.c
+++ b/src/balsa-message.c
@@ -1174,7 +1174,7 @@ balsa_message_set(BalsaMessage * bm, LibBalsaMailbox * mailbox, guint msgno)
balsa_information(LIBBALSA_INFORMATION_WARNING,
_("Could not access message %u "
"in mailbox “%s”."),
- msgno, mailbox->name);
+ msgno, libbalsa_mailbox_get_name(mailbox));
return FALSE;
}
@@ -1186,7 +1186,7 @@ balsa_message_set(BalsaMessage * bm, LibBalsaMailbox * mailbox, guint msgno)
balsa_information(LIBBALSA_INFORMATION_WARNING,
_("Could not access message %u "
"in mailbox “%s”."),
- (unsigned int) message->msgno, mailbox->name);
+ (unsigned int) message->msgno, libbalsa_mailbox_get_name(mailbox));
return FALSE;
}
@@ -1252,7 +1252,7 @@ balsa_message_set(BalsaMessage * bm, LibBalsaMailbox * mailbox, guint msgno)
/*
* emit read message
*/
- if (is_new && !mailbox->readonly)
+ if (is_new && !libbalsa_mailbox_get_readonly(mailbox))
libbalsa_mailbox_msgno_change_flags(mailbox, message->msgno, 0,
LIBBALSA_MESSAGE_FLAG_NEW);
@@ -1664,7 +1664,7 @@ balsa_message_copy_part(const gchar *url, LibBalsaMessageBody *part)
if (!libbalsa_mailbox_add_message(mailbox, stream, 0, &err)) {
libbalsa_information(LIBBALSA_INFORMATION_ERROR,
_("Appending message to %s failed: %s"),
- mailbox->name,
+ libbalsa_mailbox_get_name(mailbox),
err ? err->message : "?");
g_clear_error(&err);
}
diff --git a/src/filter-edit-callbacks.c b/src/filter-edit-callbacks.c
index b16593e5e..96c2dd8f2 100644
--- a/src/filter-edit-callbacks.c
+++ b/src/filter-edit-callbacks.c
@@ -1327,6 +1327,8 @@ update_filters_mailbox(GtkTreeModel * model, GtkTreePath * path,
{
BalsaMailboxNode *mbnode;
LibBalsaMailbox *mailbox;
+ const gchar *mailbox_url;
+ const gchar *mailbox_name;
gchar *tmp;
gtk_tree_model_get(model, iter, 0, &mbnode, -1);
@@ -1336,15 +1338,19 @@ update_filters_mailbox(GtkTreeModel * model, GtkTreePath * path,
return FALSE;
/* First we free the filters list (which is now obsolete) */
- g_slist_free_full(mailbox->filters, g_free);
- mailbox->filters = NULL;
+ libbalsa_mailbox_set_filters(mailbox, NULL);
+
/* Second we replace old filters name by the new ones
* Note : deleted filters are also removed */
if (!filters_names_changes)
return FALSE;
- tmp = mailbox_filters_section_lookup(mailbox->url ?
- mailbox->url : mailbox->name);
- if (tmp) {
+
+ mailbox_url = libbalsa_mailbox_get_url(mailbox);
+ mailbox_name = libbalsa_mailbox_get_name(mailbox);
+ tmp = mailbox_filters_section_lookup(mailbox_url ?
+ mailbox_url : mailbox_name);
+
+ if (tmp != NULL) {
gchar **filters_names = NULL;
gboolean def;
gint nb_filters;
diff --git a/src/filter-run-callbacks.c b/src/filter-run-callbacks.c
index 1e85469c7..0e85aa75e 100644
--- a/src/filter-run-callbacks.c
+++ b/src/filter-run-callbacks.c
@@ -146,8 +146,8 @@ static
void save_filters(BalsaFilterRunDialog * p)
{
if (p->filters_modified) {
- g_slist_free_full(p->mbox->filters, g_free);
- p->mbox->filters=build_selected_filters_list(p->selected_filters,FALSE);
+ libbalsa_mailbox_set_filters(p->mbox,
+ build_selected_filters_list(p->selected_filters, FALSE));
config_mailbox_filters_save(p->mbox);
p->filters_modified=FALSE;
}
@@ -218,7 +218,7 @@ fr_apply_selected_pressed_func(GtkTreeModel * model, GtkTreePath * path,
if (fil->action == FILTER_RUN
|| fil->action == FILTER_TRASH
|| (fil->action == FILTER_COLOR && fil->action_string[0])
- || strcmp(fil->action_string, p->mbox->url) != 0)
+ || strcmp(fil->action_string, libbalsa_mailbox_get_url(p->mbox)) != 0)
p->filters = g_slist_append(p->filters, fil);
}
@@ -242,7 +242,7 @@ fr_apply_selected_pressed(BalsaFilterRunDialog * p)
else
balsa_information(LIBBALSA_INFORMATION_MESSAGE,
_("Filter applied to “%s”."),
- p->mbox->name);
+ libbalsa_mailbox_get_name(p->mbox));
g_slist_free(p->filters);
}
@@ -264,7 +264,7 @@ fr_apply_now_pressed(BalsaFilterRunDialog* p)
else
balsa_information(LIBBALSA_INFORMATION_MESSAGE,
_("Filter applied to “%s”."),
- p->mbox->name);
+ libbalsa_mailbox_get_name(p->mbox));
}
static void
@@ -278,7 +278,7 @@ fr_add_pressed_func(GtkTreeModel * model, GtkTreePath * path,
if (fil->action == FILTER_RUN
|| fil->action == FILTER_TRASH
|| (fil->action == FILTER_COLOR && fil->action_string[0])
- || strcmp(fil->action_string, p->mbox->url) != 0) {
+ || strcmp(fil->action_string, libbalsa_mailbox_get_url(p->mbox)) != 0) {
/* Ok we can add the filter to this mailbox, there is no recursion problem */
LibBalsaMailboxFilter *mf = g_new(LibBalsaMailboxFilter, 1);
GtkTreeModel *sel_model =
@@ -306,7 +306,7 @@ fr_add_pressed_func(GtkTreeModel * model, GtkTreePath * path,
"the filter “%s” is “%s”.\n"
"You can’t associate it with the same "
"mailbox (that causes recursion)."),
- fil->name, p->mbox->name);
+ fil->name, libbalsa_mailbox_get_name(p->mbox));
if (!libbalsa_mailbox_can_match(p->mbox, fil->condition))
balsa_information(LIBBALSA_INFORMATION_WARNING,
@@ -316,7 +316,7 @@ fr_add_pressed_func(GtkTreeModel * model, GtkTreePath * path,
" regular expressions match with IMAP mailboxes,"
" it is done by a very slow method; if possible, use substring match"
" instead."),
- fil->name, p->mbox->name);
+ fil->name, libbalsa_mailbox_get_name(p->mbox));
}
void
diff --git a/src/filter-run-dialog.c b/src/filter-run-dialog.c
index 0631a312d..70651cbb1 100644
--- a/src/filter-run-dialog.c
+++ b/src/filter-run-dialog.c
@@ -180,6 +180,7 @@ balsa_filter_run_dialog_new(LibBalsaMailbox * mbox, GtkWindow * parent)
BalsaFilterRunDialog *p;
gchar * dialog_title;
gboolean use_headerbar = TRUE;
+ GSList *filters;
g_return_val_if_fail(mbox, NULL);
@@ -193,18 +194,19 @@ balsa_filter_run_dialog_new(LibBalsaMailbox * mbox, GtkWindow * parent)
p->mbox=mbox;
libbalsa_mailbox_open(p->mbox, NULL);
dialog_title=g_strconcat(_("Filters of Mailbox: "),
- p->mbox->name,NULL);
+ libbalsa_mailbox_get_name(p->mbox),NULL);
gtk_window_set_title(GTK_WINDOW(p),dialog_title);
gtk_window_set_role(GTK_WINDOW(p), "filter-run");
g_free(dialog_title);
/* Load associated filters if needed */
- if (!p->mbox->filters)
+ if (libbalsa_mailbox_get_filters(p->mbox) == NULL)
config_mailbox_filters_load(p->mbox);
/* Populate the lists */
- populate_available_filters_list(p->available_filters,mbox->filters);
- populate_selected_filters_list(p->selected_filters,mbox->filters);
+ filters = libbalsa_mailbox_get_filters(mbox);
+ populate_available_filters_list(p->available_filters, filters);
+ populate_selected_filters_list(p->selected_filters, filters);
return GTK_WIDGET(p);
}
@@ -491,7 +493,8 @@ filters_run_dialog(LibBalsaMailbox * mbox,
/* We look for an existing dialog box for this mailbox */
for (lst = fr_dialogs_opened; lst; lst = g_list_next(lst)) {
BalsaFilterRunDialog *dialog = lst->data;
- if (strcmp(dialog->mbox->url, mbox->url) == 0)
+ if (strcmp(libbalsa_mailbox_get_url(dialog->mbox),
+ libbalsa_mailbox_get_url(mbox)) == 0)
break;
}
if (lst) {
diff --git a/src/folder-conf.c b/src/folder-conf.c
index 7d6f3ce98..e6cfe48cf 100644
--- a/src/folder-conf.c
+++ b/src/folder-conf.c
@@ -72,7 +72,7 @@ struct _SubfolderDialogData {
FOLDER_CONF_COMMON;
BalsaMailboxConfView *mcv;
GtkWidget *parent_folder, *folder_name, *host_label;
- gchar *old_folder, *old_parent;
+ const gchar *old_folder, *old_parent;
BalsaMailboxNode *parent; /* (new) parent of the mbnode. */
/* Used for renaming and creation */
};
@@ -585,7 +585,8 @@ browse_button_cb(GtkWidget *widget,
GtkWidget *treeview;
gchar *label_str;
- label_str = g_strdup_printf(_("Select parent folder of “%s”"), sdd->mbnode->mailbox->name);
+ label_str = g_strdup_printf(_("Select parent folder of “%s”"),
+ libbalsa_mailbox_get_name(sdd->mbnode->mailbox));
dialog = create_imap_folder_dialog(sdd->mbnode->server, GTK_WINDOW(sdd->dialog), "IMAPSelectParent",
FALSE,
_("Select parent folder"), label_str, &sdd->store, &treeview);
g_free(label_str);
@@ -799,7 +800,7 @@ folder_conf_imap_sub_node(BalsaMailboxNode * mn)
return;
}
sdd->parent = mn->parent;
- sdd->old_folder = mn->mailbox->name;
+ sdd->old_folder = libbalsa_mailbox_get_name(mn->mailbox);
sdd->old_parent = sdd->mbnode ? sdd->mbnode->parent->dir : NULL;
sdd->dialog =
@@ -882,20 +883,22 @@ folder_conf_imap_sub_node(BalsaMailboxNode * mn)
GString *rights_str;
gchar * rights;
gchar * quotas;
+ gboolean readonly;
++row;
(void) libbalsa_create_grid_label(_("Permissions:"), grid, row);
/* mailbox closed: no detailed permissions available */
+ readonly = libbalsa_mailbox_get_readonly(mn->mailbox);
if (!libbalsa_mailbox_imap_is_connected(LIBBALSA_MAILBOX_IMAP(mn->mailbox))) {
- rights_str = g_string_new(std_acls[mn->mailbox->readonly ? 1 : 3]);
+ rights_str = g_string_new(std_acls[readonly ? 1 : 3]);
rights_str =
g_string_append(rights_str,
_("\ndetailed permissions are available only for open folders"));
} else {
rights = libbalsa_imap_get_rights(LIBBALSA_MAILBOX_IMAP(mn->mailbox));
if (!rights) {
- rights_str = g_string_new(std_acls[mn->mailbox->readonly ? 1 : 3]);
+ rights_str = g_string_new(std_acls[readonly ? 1 : 3]);
rights_str =
g_string_append(rights_str,
_("\nthe server does not support ACLs"));
diff --git a/src/mailbox-conf.c b/src/mailbox-conf.c
index 8af6bff42..265cd0b33 100644
--- a/src/mailbox-conf.c
+++ b/src/mailbox-conf.c
@@ -183,7 +183,7 @@ mailbox_conf_delete(BalsaMailboxNode * mbnode)
LIBBALSA_INFORMATION_ERROR,
_("Mailbox “%s” is used by Balsa and I cannot remove it.\n"
"If you really want to remove it, assign its function\n"
- "to some other mailbox."), mailbox->name);
+ "to some other mailbox."), libbalsa_mailbox_get_name(mailbox));
return;
}
@@ -201,13 +201,14 @@ mailbox_conf_delete(BalsaMailboxNode * mbnode)
"on disk you may “Add Mailbox” "
"to access the mailbox again.\n"
"What would you like to do?"),
- mailbox->name);
+ libbalsa_mailbox_get_name(mailbox));
gtk_dialog_add_buttons(GTK_DIALOG(ask),
_("Remove from _list"), 0,
_("Remove from list and _disk"), 1,
_("_Cancel"), GTK_RESPONSE_CANCEL,
NULL);
- } else if (LIBBALSA_IS_MAILBOX_IMAP(mailbox) && !mailbox->config_prefix) {
+ } else if (LIBBALSA_IS_MAILBOX_IMAP(mailbox) &&
+ libbalsa_mailbox_get_config_prefix(mailbox) == NULL) {
/* deleting remote IMAP mailbox in a folder set */
ask = gtk_message_dialog_new(GTK_WINDOW(balsa_app.main_window), 0,
GTK_MESSAGE_QUESTION,
@@ -223,7 +224,7 @@ mailbox_conf_delete(BalsaMailboxNode * mbnode)
"later to add a mailbox "
"with this name.\n"
"What would you like to do?"),
- mailbox->name, mailbox->name);
+ libbalsa_mailbox_get_name(mailbox), libbalsa_mailbox_get_name(mailbox));
gtk_dialog_add_buttons(GTK_DIALOG(ask),
_("_Remove from server"), 0,
_("_Cancel"), GTK_RESPONSE_CANCEL,
@@ -239,7 +240,7 @@ mailbox_conf_delete(BalsaMailboxNode * mbnode)
"later to access "
"this mailbox again.\n"
"What would you like to do?"),
- mailbox->name);
+ libbalsa_mailbox_get_name(mailbox));
gtk_dialog_add_buttons(GTK_DIALOG(ask),
_("_Remove from list"), 0,
_("_Cancel"), GTK_RESPONSE_CANCEL,
@@ -259,7 +260,7 @@ mailbox_conf_delete(BalsaMailboxNode * mbnode)
return;
/* Save the mailbox URL */
- url = g_strdup(mailbox->url ? mailbox->url : mailbox->name);
+ url = g_strdup(libbalsa_mailbox_get_url(mailbox) ? libbalsa_mailbox_get_url(mailbox) :
libbalsa_mailbox_get_name(mailbox));
/* Delete it from the config file and internal nodes */
config_mailbox_delete(mailbox);
@@ -269,7 +270,8 @@ mailbox_conf_delete(BalsaMailboxNode * mbnode)
balsa_mblist_close_mailbox(mailbox);
/* Remove mailbox on IMAP server */
- if (LIBBALSA_IS_MAILBOX_IMAP(mailbox) && !mailbox->config_prefix) {
+ if (LIBBALSA_IS_MAILBOX_IMAP(mailbox) &&
+ libbalsa_mailbox_get_config_prefix(mailbox) == NULL) {
GError *err = NULL;
BalsaMailboxNode *parent = mbnode->parent;
if(libbalsa_imap_delete_folder(LIBBALSA_MAILBOX_IMAP(mailbox),
@@ -482,27 +484,32 @@ check_for_blank_fields(GtkWidget G_GNUC_UNUSED *widget,
static void
update_pop_mailbox(MailboxConfWindow *mcw)
{
- LibBalsaMailboxPop3 *mailbox;
+ LibBalsaMailboxPop3 *pop3;
+ LibBalsaMailbox *mailbox;
LibBalsaServer *server;
+ gchar *name;
- mailbox = LIBBALSA_MAILBOX_POP3(mcw->mailbox);
- server = LIBBALSA_MAILBOX_REMOTE_SERVER(mailbox);
+ pop3 = LIBBALSA_MAILBOX_POP3(mcw->mailbox);
+ server = LIBBALSA_MAILBOX_REMOTE_SERVER(pop3);
+ mailbox = (LibBalsaMailbox *) pop3;
/* basic data */
- g_free(LIBBALSA_MAILBOX(mailbox)->name);
- LIBBALSA_MAILBOX(mailbox)->name =
g_strdup(libbalsa_server_cfg_get_name(mcw->mb_data.pop3.server_cfg));
+ name = g_strdup(libbalsa_server_cfg_get_name(mcw->mb_data.pop3.server_cfg));
+ libbalsa_mailbox_set_name(mailbox, name);
+ g_free(name);
+
libbalsa_server_cfg_assign_server(mcw->mb_data.pop3.server_cfg, server);
libbalsa_server_config_changed(server);
- mailbox->check = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mcw->mb_data.pop3.check));
- mailbox->delete_from_server = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
(mcw->mb_data.pop3.delete_from_server));
- mailbox->filter = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mcw->mb_data.pop3.filter));
- g_free(mailbox->filter_cmd);
- mailbox->filter_cmd = g_strdup(gtk_entry_get_text(GTK_ENTRY(mcw->mb_data.pop3.filter_cmd)));
+ pop3->check = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mcw->mb_data.pop3.check));
+ pop3->delete_from_server = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON
(mcw->mb_data.pop3.delete_from_server));
+ pop3->filter = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mcw->mb_data.pop3.filter));
+ g_free(pop3->filter_cmd);
+ pop3->filter_cmd = g_strdup(gtk_entry_get_text(GTK_ENTRY(mcw->mb_data.pop3.filter_cmd)));
/* advanced settings */
- mailbox->disable_apop =
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mcw->mb_data.pop3.disable_apop));
- mailbox->enable_pipe = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mcw->mb_data.pop3.enable_pipe));
+ pop3->disable_apop = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mcw->mb_data.pop3.disable_apop));
+ pop3->enable_pipe = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mcw->mb_data.pop3.enable_pipe));
}
/* conf_update_mailbox:
@@ -526,8 +533,9 @@ mailbox_conf_update(MailboxConfWindow *mcw)
mbnode = balsa_find_mailbox(mailbox);
filename =
gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(mcw->window));
- path = g_strdup(libbalsa_mailbox_local_get_path(mailbox));
- if (strcmp(filename, path)) {
+ path =
+ g_strdup(libbalsa_mailbox_local_get_path((LibBalsaMailboxLocal *) mailbox));
+ if (strcmp(filename, path) != 0) {
/* rename */
int i;
gchar *file_dir, *path_dir;
@@ -564,13 +572,12 @@ mailbox_conf_update(MailboxConfWindow *mcw)
name = mcw->mb_data.local.mailbox_name ?
gtk_editable_get_chars(GTK_EDITABLE(mcw->mb_data.local.mailbox_name), 0, -1)
: g_path_get_basename(filename);
- if (strcmp(name, mailbox->name)) {
+ if (strcmp(name, libbalsa_mailbox_get_name(mailbox)) != 0) {
/* Change name. */
- g_free(mailbox->name);
- mailbox->name = name;
+ libbalsa_mailbox_set_name(mailbox, name);
balsa_mblist_mailbox_node_redraw(mbnode);
- } else
- g_free(name);
+ }
+ g_free(name);
g_object_unref(mbnode);
g_free(filename);
@@ -581,7 +588,7 @@ mailbox_conf_update(MailboxConfWindow *mcw)
g_assert_not_reached();
}
- if (mailbox->config_prefix)
+ if (libbalsa_mailbox_get_config_prefix(mailbox) != NULL)
config_mailbox_update(mailbox);
if (LIBBALSA_IS_MAILBOX_POP3(mcw->mailbox))
@@ -603,9 +610,9 @@ mailbox_conf_add(MailboxConfWindow * mcw)
if ( LIBBALSA_IS_MAILBOX_LOCAL(mcw->mailbox) ) {
LibBalsaMailboxLocal *ml = LIBBALSA_MAILBOX_LOCAL(mcw->mailbox);
gchar *path;
+ gchar *basename;
- path =
- gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(mcw->window));
+ path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(mcw->window));
if (libbalsa_mailbox_local_set_path(ml, path, TRUE) != 0) {
g_free(path);
@@ -618,9 +625,12 @@ mailbox_conf_add(MailboxConfWindow * mcw)
!libbalsa_path_is_below_dir(path,
balsa_app.local_mail_directory);
g_debug("Save to config: %d", save_to_config);
- mcw->mailbox->name = g_path_get_basename(path);
+ basename = g_path_get_basename(path);
g_free(path);
+ libbalsa_mailbox_set_name(mcw->mailbox, basename);
+ g_free(basename);
+
balsa_mailbox_local_append(mcw->mailbox);
}
mbnode = balsa_mailbox_node_new_from_mailbox(mcw->mailbox);
@@ -684,13 +694,13 @@ local_mailbox_dialog_cb(GtkWidget *widget,
if (filename != NULL) {
gboolean changed = TRUE;
- if (mcw->mailbox != NULL) {
- changed = (g_strcmp0(filename, mcw->mailbox->url) != 0);
- }
+
+ if (mcw->mailbox != NULL)
+ changed = g_strcmp0(filename, libbalsa_mailbox_get_url(mcw->mailbox)) != 0;
g_free(filename);
- if (changed) {
+
+ if (changed)
check_for_blank_fields(widget, mcw);
- }
}
}
@@ -729,7 +739,7 @@ create_local_mailbox_dialog(MailboxConfWindow *mcw)
#endif
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), grid);
- if (mcw->mailbox != NULL && mcw->mailbox->url != NULL) {
+ if (mcw->mailbox != NULL && libbalsa_mailbox_get_url(mcw->mailbox) != NULL) {
const gchar *path = libbalsa_mailbox_local_get_path(LIBBALSA_MAILBOX_LOCAL(mcw->mailbox));
gchar *basename = g_path_get_basename(path);
@@ -743,14 +753,14 @@ create_local_mailbox_dialog(MailboxConfWindow *mcw)
G_CALLBACK(local_mailbox_dialog_cb), mcw);
size_group = libbalsa_create_size_group(dialog);
- if (mcw->mailbox->config_prefix) {
+ if (libbalsa_mailbox_get_config_prefix(mcw->mailbox) != NULL) {
GtkWidget *label;
label = libbalsa_create_grid_label(_("_Mailbox Name:"), grid, ++row);
mcw->mb_data.local.mailbox_name =
libbalsa_create_grid_entry(grid,
G_CALLBACK(check_for_blank_fields),
- mcw, row, mcw->mailbox->name, label);
+ mcw, row, libbalsa_mailbox_get_name(mcw->mailbox), label);
gtk_size_group_add_widget(size_group, label);
} else {
mcw->mb_data.local.mailbox_name = NULL;
@@ -784,7 +794,9 @@ create_pop_mailbox_dialog(MailboxConfWindow *mcw)
libbalsa_macosx_menu_for_parent(mcw->window, GTK_WINDOW(balsa_app.main_window));
#endif
- mcw->mb_data.pop3.server_cfg = libbalsa_server_cfg_new(LIBBALSA_MAILBOX_REMOTE_SERVER(mailbox),
mailbox->name);
+ mcw->mb_data.pop3.server_cfg =
+ libbalsa_server_cfg_new(LIBBALSA_MAILBOX_REMOTE_SERVER(mailbox),
+ libbalsa_mailbox_get_name(mailbox));
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(mcw->window))),
GTK_WIDGET(mcw->mb_data.pop3.server_cfg));
g_signal_connect(mcw->mb_data.pop3.server_cfg, "changed", G_CALLBACK(check_for_blank_fields), mcw);
@@ -991,6 +1003,7 @@ mailbox_conf_view_check(BalsaMailboxConfView * view_info,
LibBalsaMailbox * mailbox)
{
gboolean changed;
+ LibBalsaMailboxView *view;
GtkComboBox *combo_box;
GtkTreeIter iter;
gint active;
@@ -1001,12 +1014,11 @@ mailbox_conf_view_check(BalsaMailboxConfView * view_info,
changed = FALSE;
- libbalsa_mailbox_view_free(mailbox->view);
- mailbox->view = config_load_mailbox_view(mailbox->url);
- if (!mailbox->view) {
- /* The mailbox may not have its URL yet */
- mailbox->view = libbalsa_mailbox_view_new();
- }
+ view = config_load_mailbox_view(libbalsa_mailbox_get_url(mailbox));
+ /* The mailbox may not have its URL yet: */
+ if (view == NULL)
+ view = libbalsa_mailbox_view_new();
+ libbalsa_mailbox_set_view(mailbox, view);
combo_box = GTK_COMBO_BOX(view_info->identity_combo_box);
if (gtk_combo_box_get_active_iter(combo_box, &iter)) {
diff --git a/src/mailbox-node.c b/src/mailbox-node.c
index df81991a8..b48af5493 100644
--- a/src/mailbox-node.c
+++ b/src/mailbox-node.c
@@ -192,10 +192,11 @@ balsa_mailbox_node_dispose(GObject * object)
BalsaMailboxNode *mn = BALSA_MAILBOX_NODE(object);
LibBalsaMailbox *mailbox = mn->mailbox;
- if (mailbox) {
+ if (mailbox != NULL) {
if (!LIBBALSA_IS_MAILBOX_POP3(mailbox)) {
libbalsa_mailbox_set_open(mailbox, libbalsa_mailbox_is_open(mailbox));
- config_save_mailbox_view(mailbox->url, mailbox->view);
+ config_save_mailbox_view(libbalsa_mailbox_get_url(mailbox),
+ libbalsa_mailbox_get_view(mailbox));
if (balsa_app.main_window != NULL)
balsa_window_close_mbnode(balsa_app.main_window, mn);
}
@@ -402,8 +403,10 @@ load_mailbox_view(BalsaMailboxNode * mbnode)
{
LibBalsaMailbox *mailbox = mbnode->mailbox;
- if (!mailbox->view)
- mailbox->view = config_load_mailbox_view(mailbox->url);
+ if (!libbalsa_mailbox_get_view(mailbox))
+ libbalsa_mailbox_set_view(mailbox,
+ config_load_mailbox_view
+ (libbalsa_mailbox_get_url(mailbox)));
}
static gboolean
@@ -428,9 +431,10 @@ imap_scan_attach_mailbox(BalsaMailboxNode * mbnode, imap_scan_item * isi)
libbalsa_mailbox_remote_set_server(LIBBALSA_MAILBOX_REMOTE(m),
mbnode->server);
libbalsa_mailbox_imap_set_path(m, isi->fn);
- g_debug("imap_scan_attach_mailbox: add mbox of name %s (full path %s)", isi->fn, mailbox->url);
- /* avoid allocating the name again: */
- mailbox->name = mbnode->name;
+ g_debug("imap_scan_attach_mailbox: add mbox of name %s (full path %s)", isi->fn,
+ libbalsa_mailbox_get_url(mailbox));
+ libbalsa_mailbox_set_name(mailbox, mbnode->name);
+ g_free(mbnode->name);
mbnode->name = NULL;
mbnode->mailbox = mailbox;
load_mailbox_view(mbnode);
@@ -441,7 +445,7 @@ imap_scan_attach_mailbox(BalsaMailboxNode * mbnode, imap_scan_item * isi)
*isi->special = mailbox;
g_object_add_weak_pointer(G_OBJECT(m), (gpointer *) isi->special);
if (isi->special == &balsa_app.outbox)
- mailbox->no_reassemble = TRUE;
+ libbalsa_mailbox_set_no_reassemble(mailbox, TRUE);
}
return TRUE;
@@ -560,7 +564,8 @@ balsa_mailbox_node_new_from_mailbox(LibBalsaMailbox * mb)
if (LIBBALSA_IS_MAILBOX_MH(mb) || LIBBALSA_IS_MAILBOX_MAILDIR(mb)) {
/* Mh and Maildir mailboxes are directories, and may be nested,
* so we need to be able to append a subtree. */
- mbn->name = g_strdup(libbalsa_mailbox_local_get_path(mb));
+ mbn->name =
+ g_strdup(libbalsa_mailbox_local_get_path((LibBalsaMailboxLocal *) mb));
mbn->dir = g_strdup(mbn->name);
g_signal_connect(G_OBJECT(mbn), "append-subtree",
G_CALLBACK(read_dir_cb), NULL);
@@ -718,7 +723,7 @@ balsa_mailbox_local_append(LibBalsaMailbox* mbx)
g_return_if_fail(LIBBALSA_IS_MAILBOX_LOCAL(mbx));
- dir = g_strdup(libbalsa_mailbox_local_get_path(mbx));
+ dir = g_strdup(libbalsa_mailbox_local_get_path((LibBalsaMailboxLocal *) mbx));
while (dir[1] /* i.e. dir != "/" */
&& !(parent = find_dir(dir))) {
gchar* tmp = g_path_get_dirname(dir);
@@ -866,17 +871,19 @@ bmbn_scan_children_idle(BalsaMailboxNode ** mbnode)
gboolean has_unread_messages = FALSE;
if (mn->mailbox)
- has_unread_messages = mn->mailbox->has_unread_messages;
+ has_unread_messages =
+ libbalsa_mailbox_get_has_unread_messages(mn->mailbox);
balsa_mailbox_node_rescan(mn);
if (!l->data)
continue;
if (mn->mailbox)
- mn->mailbox->has_unread_messages = has_unread_messages;
+ libbalsa_mailbox_set_has_unread_messages
+ (mn->mailbox, has_unread_messages);
mn->scanned = TRUE;
} else if (balsa_app.debug)
g_print("%s: %s “%s” was already scanned\n", __func__,
mn->mailbox ? "mailbox" : "folder",
- mn->mailbox ? mn->mailbox->name : mn->name);
+ mn->mailbox ? libbalsa_mailbox_get_name(mn->mailbox) : mn->name);
g_object_remove_weak_pointer(G_OBJECT(mn), & l->data);
}
g_slist_free(list);
@@ -1140,28 +1147,28 @@ remove_mailbox_from_nodes(LibBalsaMailbox* mailbox)
mbnode = balsa_mailbox_node_new_from_mailbox(mailbox);
return mbnode;
}
-
-static BalsaMailboxNode *
+
+static BalsaMailboxNode *
remove_special_mailbox_by_url(const gchar* url, LibBalsaMailbox *** special)
{
LibBalsaMailbox **mailbox;
- if (g_strcmp0(url, balsa_app.trash->url) == 0)
+ if (g_strcmp0(url, libbalsa_mailbox_get_url(balsa_app.trash)) == 0)
mailbox = &balsa_app.trash;
- else if (g_strcmp0(url, balsa_app.inbox->url) == 0)
+ else if (g_strcmp0(url, libbalsa_mailbox_get_url(balsa_app.inbox)) == 0)
mailbox = &balsa_app.inbox;
- else if (g_strcmp0(url, balsa_app.outbox->url) == 0)
+ else if (g_strcmp0(url, libbalsa_mailbox_get_url(balsa_app.outbox)) == 0)
mailbox = &balsa_app.outbox;
- else if (g_strcmp0(url, balsa_app.sentbox->url) == 0)
+ else if (g_strcmp0(url, libbalsa_mailbox_get_url(balsa_app.sentbox)) == 0)
mailbox = &balsa_app.sentbox;
- else if (g_strcmp0(url, balsa_app.draftbox->url) == 0)
+ else if (g_strcmp0(url, libbalsa_mailbox_get_url(balsa_app.draftbox)) == 0)
mailbox = &balsa_app.draftbox;
else
mailbox = NULL;
if (special)
*special = mailbox;
-
+
return mailbox ? remove_mailbox_from_nodes(*mailbox) : NULL;
}
@@ -1203,13 +1210,13 @@ add_local_mailbox(BalsaMailboxNode *root, const gchar * name,
g_warning("Not accessible mailbox %s", path);
return NULL;
}
- mailbox->name = g_strdup(name);
+ libbalsa_mailbox_set_name(mailbox, name);
mbnode = balsa_mailbox_node_new_from_mailbox(mailbox);
if (balsa_app.debug)
g_print(_("Local mailbox %s loaded as: %s\n"),
- mailbox->name,
+ libbalsa_mailbox_get_name(mailbox),
g_type_name(G_OBJECT_TYPE(mailbox)));
if (balsa_app.check_mail_upon_startup
&& libbalsa_mailbox_get_subscribe(mailbox) !=
diff --git a/src/main-window.c b/src/main-window.c
index f2ddfd8ba..9257f81a1 100644
--- a/src/main-window.c
+++ b/src/main-window.c
@@ -2407,7 +2407,7 @@ bw_enable_mailbox_menus(BalsaWindow * window, BalsaIndex * index)
}
bw_action_set_enabled(window, "mailbox-expunge",
/* cppcheck-suppress nullPointer */
- mailbox && !mailbox->readonly);
+ mailbox && !libbalsa_mailbox_get_readonly(mailbox));
bw_actions_set_enabled(window, mailbox_actions,
G_N_ELEMENTS(mailbox_actions), enable);
@@ -2481,7 +2481,8 @@ bw_enable_message_menus(BalsaWindow * window, guint msgno)
bw_actions_set_enabled(window, message_actions,
G_N_ELEMENTS(message_actions), enable);
- enable_mod = (enable && !bindex->mailbox_node->mailbox->readonly);
+ enable_mod =
+ (enable && !libbalsa_mailbox_get_readonly(bindex->mailbox_node->mailbox));
bw_actions_set_enabled(window, modify_message_actions,
G_N_ELEMENTS(modify_message_actions),
enable_mod);
@@ -2732,7 +2733,7 @@ bw_notebook_label_new(BalsaMailboxNode * mbnode)
box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
- lab = gtk_label_new(mbnode->mailbox->name);
+ lab = gtk_label_new(libbalsa_mailbox_get_name(mbnode->mailbox));
gtk_widget_set_name(lab, "balsa-notebook-tab-label");
/* Try to make text not bold: */
@@ -2777,7 +2778,7 @@ bw_notebook_label_new(BalsaMailboxNode * mbnode)
gtk_widget_show_all(box);
- gtk_widget_set_tooltip_text(box, mbnode->mailbox->url);
+ gtk_widget_set_tooltip_text(box, libbalsa_mailbox_get_url(mbnode->mailbox));
return box;
}
@@ -2952,7 +2953,7 @@ balsa_window_real_open_mbnode(BalsaWindow * window,
(balsa_app.layout_type == LAYOUT_WIDE_SCREEN)
? BALSA_INDEX_NARROW : BALSA_INDEX_WIDE);
- message = g_strdup_printf(_("Opening %s"), mailbox->name);
+ message = g_strdup_printf(_("Opening %s"), libbalsa_mailbox_get_name(mailbox));
balsa_window_increase_activity(window, message);
info = g_new(BalsaWindowRealOpenMbnodeInfo, 1);
@@ -3192,7 +3193,7 @@ bw_check_mailbox_progress_cb(LibBalsaMailbox* mailbox, gint action, gdouble frac
{
gchar *progress_id;
- progress_id = g_strdup_printf("POP3: %s", mailbox->name);
+ progress_id = g_strdup_printf("POP3: %s", libbalsa_mailbox_get_name(mailbox));
if (action == LIBBALSA_NTFY_INIT) {
libbalsa_progress_dialog_ensure(&progress_dialog, _("Checking Mail…"),
GTK_WINDOW(balsa_app.main_window), progress_id);
}
@@ -3249,7 +3250,7 @@ bw_check_mailbox_list(struct check_messages_thread_info *info, GList *mailbox_li
g_signal_connect(G_OBJECT(mailbox), "progress-notify",
G_CALLBACK(bw_check_mailbox_progress_cb), mailbox);
}
bw_pop_mbox->thread = g_thread_new(NULL, (GThreadFunc) bw_check_mailbox, mailbox);
- g_debug("launched thread %p for checking POP3 mailbox %s", bw_pop_mbox->thread, mailbox->name);
+ g_debug("launched thread %p for checking POP3 mailbox %s", bw_pop_mbox->thread,
libbalsa_mailbox_get_name(mailbox));
check_mbx = g_list_prepend(check_mbx, bw_pop_mbox);
}
@@ -3392,10 +3393,10 @@ check_new_messages_count(LibBalsaMailbox * mailbox, gboolean notify)
if (notify) {
gint num_new, has_new;
- num_new = mailbox->unread_messages - info->unread_messages;
+ num_new = libbalsa_mailbox_get_unread_messages(mailbox) - info->unread_messages;
if (num_new < 0)
num_new = 0;
- has_new = mailbox->has_unread_messages - info->has_unread_messages;
+ has_new = libbalsa_mailbox_get_has_unread_messages(mailbox) - info->has_unread_messages;
if (has_new < 0)
has_new = 0;
@@ -3403,8 +3404,8 @@ check_new_messages_count(LibBalsaMailbox * mailbox, gboolean notify)
bw_display_new_mail_notification(num_new, has_new);
}
- info->unread_messages = mailbox->unread_messages;
- info->has_unread_messages = mailbox->has_unread_messages;
+ info->unread_messages = libbalsa_mailbox_get_unread_messages(mailbox);
+ info->has_unread_messages = libbalsa_mailbox_get_has_unread_messages(mailbox);
}
/* this one is called only in the threaded code */
@@ -3416,7 +3417,7 @@ bw_mailbox_check(LibBalsaMailbox * mailbox, struct check_messages_thread_info *i
if (libbalsa_mailbox_get_subscribe(mailbox) == LB_MAILBOX_SUBSCRIBE_NO)
return;
- g_debug("checking mailbox %s", mailbox->name);
+ g_debug("checking mailbox %s", libbalsa_mailbox_get_name(mailbox));
if (LIBBALSA_IS_MAILBOX_IMAP(mailbox)) {
if ((info->window != NULL) && !info->window->network_available) {
return;
@@ -3424,12 +3425,12 @@ bw_mailbox_check(LibBalsaMailbox * mailbox, struct check_messages_thread_info *i
if (info->with_progress_dialog) {
libbalsa_progress_dialog_update(&progress_dialog, _("Mailboxes"), FALSE, INFINITY,
- _("IMAP mailbox: %s"), mailbox->url);
+ _("IMAP mailbox: %s"), libbalsa_mailbox_get_url(mailbox));
}
} else if (LIBBALSA_IS_MAILBOX_LOCAL(mailbox)) {
if (info->with_progress_dialog) {
libbalsa_progress_dialog_update(&progress_dialog, _("Mailboxes"), FALSE, INFINITY,
- _("Local mailbox: %s"), mailbox->name);
+ _("Local mailbox: %s"), libbalsa_mailbox_get_name(mailbox));
}
} else {
g_assert_not_reached();
@@ -4139,12 +4140,12 @@ bw_notebook_switch_page_cb(GtkWidget * notebook,
time(&index->mailbox_node->last_use);
mailbox = index->mailbox_node->mailbox;
- if (mailbox->name) {
- if (mailbox->readonly) {
+ if (libbalsa_mailbox_get_name(mailbox)) {
+ if (libbalsa_mailbox_get_readonly(mailbox)) {
title =
- g_strdup_printf(_("Balsa: %s (read-only)"), mailbox->name);
+ g_strdup_printf(_("Balsa: %s (read-only)"), libbalsa_mailbox_get_name(mailbox));
} else {
- title = g_strdup_printf(_("Balsa: %s"), mailbox->name);
+ title = g_strdup_printf(_("Balsa: %s"), libbalsa_mailbox_get_name(mailbox));
}
gtk_window_set_title(GTK_WINDOW(window), title);
g_free(title);
@@ -4170,7 +4171,7 @@ bw_notebook_switch_page_cb(GtkWidget * notebook,
balsa_index_ensure_visible(index);
g_free(balsa_app.current_mailbox_url);
- balsa_app.current_mailbox_url = g_strdup(mailbox->url);
+ balsa_app.current_mailbox_url = g_strdup(libbalsa_mailbox_get_url(mailbox));
}
static void
@@ -4701,19 +4702,19 @@ void
balsa_window_set_statusbar(BalsaWindow * window, LibBalsaMailbox * mailbox)
{
gint total_messages = libbalsa_mailbox_total_messages(mailbox);
- gint unread_messages = mailbox->unread_messages;
+ gint unread_messages = libbalsa_mailbox_get_unread_messages(mailbox);
gint hidden_messages;
GString *desc = g_string_new(NULL);
GtkStatusbar *statusbar;
guint context_id;
hidden_messages =
- mailbox->msg_tree ? total_messages -
- (g_node_n_nodes(mailbox->msg_tree, G_TRAVERSE_ALL) - 1) : 0;
+ libbalsa_mailbox_get_msg_tree(mailbox) ? total_messages -
+ (g_node_n_nodes(libbalsa_mailbox_get_msg_tree(mailbox), G_TRAVERSE_ALL) - 1) : 0;
/* xgettext: this is the first part of the message
* "Shown mailbox: %s with %d messages, %d new, %d hidden". */
- g_string_append_printf(desc, _("Shown mailbox: %s "), mailbox->name);
+ g_string_append_printf(desc, _("Shown mailbox: %s "), libbalsa_mailbox_get_name(mailbox));
if (total_messages > 0) {
/* xgettext: this is the second part of the message
* "Shown mailbox: %s with %d messages, %d new, %d hidden". */
@@ -4778,13 +4779,13 @@ balsa_window_next_unread(BalsaWindow * window)
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_YES_NO,
_("The next unread message is in %s"),
- mailbox->name);
+ libbalsa_mailbox_get_name(mailbox));
#if HAVE_MACOSX_DESKTOP
libbalsa_macosx_menu_for_parent(dialog, GTK_WINDOW(window));
#endif
gtk_message_dialog_format_secondary_text
(GTK_MESSAGE_DIALOG(dialog),
- _("Do you want to select %s?"), mailbox->name);
+ _("Do you want to select %s?"), libbalsa_mailbox_get_name(mailbox));
gtk_dialog_set_default_response(GTK_DIALOG(dialog),
GTK_RESPONSE_YES);
response = gtk_dialog_run(GTK_DIALOG(dialog));
diff --git a/src/main.c b/src/main.c
index cf56175d9..e0029ee25 100644
--- a/src/main.c
+++ b/src/main.c
@@ -169,7 +169,7 @@ initial_open_unread_mailboxes()
for (l = gl; l; l = l->next) {
LibBalsaMailbox *mailbox = LIBBALSA_MAILBOX(l->data);
- printf("opening %s..\n", mailbox->name);
+ printf("opening %s..\n", libbalsa_mailbox_get_name(mailbox));
balsa_mblist_open_mailbox(mailbox);
}
g_list_free(gl);
@@ -184,7 +184,7 @@ initial_open_inbox()
if (!balsa_app.inbox)
return FALSE;
- printf("opening %s..\n", balsa_app.inbox->name);
+ printf("opening %s..\n", libbalsa_mailbox_get_name(balsa_app.inbox));
balsa_mblist_open_mailbox_hidden(balsa_app.inbox);
return FALSE;
@@ -197,7 +197,7 @@ balsa_get_stats(long *unread, long *unsent)
if (balsa_app.inbox && libbalsa_mailbox_open(balsa_app.inbox, NULL)) {
/* set threading type to load messages */
libbalsa_mailbox_set_threading(balsa_app.inbox);
- *unread = balsa_app.inbox->unread_messages;
+ *unread = libbalsa_mailbox_get_unread_messages(balsa_app.inbox);
libbalsa_mailbox_close(balsa_app.inbox, FALSE);
} else *unread = -1;
if(balsa_app.draftbox && libbalsa_mailbox_open(balsa_app.outbox, NULL)){
@@ -260,7 +260,7 @@ scan_mailboxes_idle_cb()
gl = balsa_mblist_find_all_unread_mboxes(NULL);
for (l = gl; l; l = l->next) {
LibBalsaMailbox *mailbox = l->data;
- g_ptr_array_add(url_array, g_strdup(mailbox->url));
+ g_ptr_array_add(url_array, g_strdup(libbalsa_mailbox_get_url(mailbox)));
}
g_list_free(gl);
}
@@ -290,7 +290,7 @@ scan_mailboxes_idle_cb()
}
if (cmd_open_inbox || balsa_app.open_inbox_upon_startup) {
- g_ptr_array_add(url_array, g_strdup(balsa_app.inbox->url));
+ g_ptr_array_add(url_array, g_strdup(libbalsa_mailbox_get_url(balsa_app.inbox)));
}
if (url_array->len) {
@@ -343,7 +343,7 @@ periodic_expunge_cb(void)
for (l = list; l; l = l->next) {
BalsaMailboxNode *mbnode = l->data;
if (mbnode->mailbox && libbalsa_mailbox_is_open(mbnode->mailbox)
- && !mbnode->mailbox->readonly) {
+ && !libbalsa_mailbox_get_readonly(mbnode->mailbox)) {
time_t tm = time(NULL);
if (tm-mbnode->last_use > balsa_app.expunge_timeout)
libbalsa_mailbox_sync_storage(mbnode->mailbox, TRUE);
diff --git a/src/message-window.c b/src/message-window.c
index b9ee2e118..aec53beac 100644
--- a/src/message-window.c
+++ b/src/message-window.c
@@ -320,7 +320,7 @@ mw_set_buttons_sensitive(MessageWindow * mw)
enable = index && balsa_index_previous_msgno(index, current_msgno) > 0;
mw_set_enabled(mw, "previous-message", enable);
- enable = index && index->mailbox_node->mailbox->unread_messages > 0;
+ enable = index && libbalsa_mailbox_get_unread_messages(index->mailbox_node->mailbox) > 0;
mw_set_enabled(mw, "next-unread", enable);
enable = index
@@ -845,7 +845,7 @@ message_window_new(LibBalsaMailbox * mailbox, guint msgno)
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(destroy_message_window), mw);
-
+
mw->bindex = balsa_find_index_by_mailbox(mailbox);
g_object_weak_ref(G_OBJECT(mw->bindex), mw_bindex_closed_cb, mw);
g_signal_connect_swapped(G_OBJECT(mw->bindex), "index-changed",
@@ -863,14 +863,14 @@ message_window_new(LibBalsaMailbox * mailbox, guint msgno)
&move_menu);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(move_menu), submenu);
- if (mailbox->readonly) {
+ if (libbalsa_mailbox_get_readonly(mailbox)) {
gtk_widget_set_sensitive(move_menu, FALSE);
mw_disable_trash(mw);
}
if (mailbox == balsa_app.trash)
mw_disable_trash(mw);
mw->bmessage = balsa_message_new();
-
+
gtk_box_pack_start(GTK_BOX(vbox), mw->bmessage, TRUE, TRUE, 0);
gtk_widget_show(vbox);
diff --git a/src/pref-manager.c b/src/pref-manager.c
index fb7b8ac7a..0fdb525e9 100644
--- a/src/pref-manager.c
+++ b/src/pref-manager.c
@@ -331,7 +331,10 @@ update_view_defaults(const gchar * group, const gchar * url,
LibBalsaMailboxView *view;
mailbox = balsa_find_mailbox_by_url(url);
- view = mailbox ? mailbox->view : config_load_mailbox_view(url);
+ view =
+ mailbox !=
+ NULL ? libbalsa_mailbox_get_view(mailbox) :
+ config_load_mailbox_view(url);
if (!view)
return FALSE;
@@ -975,7 +978,7 @@ static void
add_other_server(BalsaMailboxNode * mbnode, GtkTreeModel * model)
{
gchar *protocol = NULL;
- gchar *name = NULL;
+ const gchar *name = NULL;
gboolean append = FALSE;
if (mbnode) {
@@ -983,7 +986,7 @@ add_other_server(BalsaMailboxNode * mbnode, GtkTreeModel * model)
if (mailbox) {
if (LIBBALSA_IS_MAILBOX_IMAP(mailbox)) {
protocol = "IMAP";
- name = mailbox->name;
+ name = libbalsa_mailbox_get_name(mailbox);
append = TRUE;
}
} else
@@ -3591,7 +3594,7 @@ update_mail_servers(void)
gtk_list_store_append(GTK_LIST_STORE(model), &iter);
gtk_list_store_set(GTK_LIST_STORE(model), &iter,
MS_PROT_COLUMN, protocol,
- MS_NAME_COLUMN, mbnode->mailbox->name,
+ MS_NAME_COLUMN, libbalsa_mailbox_get_name(mbnode->mailbox),
MS_DATA_COLUMN, mbnode, -1);
}
/*
diff --git a/src/save-restore.c b/src/save-restore.c
index f9b3b96f0..c87b34ea2 100644
--- a/src/save-restore.c
+++ b/src/save-restore.c
@@ -74,10 +74,16 @@ static inline gboolean is_special_name(const gchar *name);
g_strdup(BALSA_MAILBOX_NODE(mn)->config_prefix) : \
config_get_unused_group(FOLDER_SECTION_PREFIX)
-#define mailbox_section_path(mbox) \
- LIBBALSA_MAILBOX(mbox)->config_prefix ? \
- g_strdup(LIBBALSA_MAILBOX(mbox)->config_prefix) : \
- config_get_unused_group(MAILBOX_SECTION_PREFIX)
+static gchar *
+mailbox_section_path(LibBalsaMailbox * mailbox)
+{
+ const gchar *config_prefix =
+ libbalsa_mailbox_get_config_prefix(mailbox);
+
+ return config_prefix != NULL ?
+ g_strdup(config_prefix) :
+ config_get_unused_group(MAILBOX_SECTION_PREFIX);
+}
static gchar *
address_book_section_path(LibBalsaAddressBook *address_book)
@@ -273,17 +279,19 @@ config_mailbox_set_as_special(LibBalsaMailbox * mailbox, specialType which)
default:
return;
}
- if ((old_mailbox = *special)) {
+ if ((old_mailbox = *special) != NULL) {
+ gchar *basename;
+
*special = NULL;
- g_free(old_mailbox->config_prefix);
- old_mailbox->config_prefix = NULL;
+ libbalsa_mailbox_set_config_prefix(old_mailbox, NULL);
- g_free(old_mailbox->name);
- old_mailbox->name = g_path_get_basename(old_mailbox->url);
+ basename = g_path_get_basename(libbalsa_mailbox_get_url(old_mailbox));
+ libbalsa_mailbox_set_name(old_mailbox, basename);
+ g_free(basename);
if (!LIBBALSA_IS_MAILBOX_LOCAL(old_mailbox)
|| !libbalsa_path_is_below_dir(libbalsa_mailbox_local_get_path
- (old_mailbox),
+ ((LibBalsaMailboxLocal *) old_mailbox),
balsa_app.local_mail_directory))
config_mailbox_add(old_mailbox, NULL);
@@ -295,8 +303,7 @@ config_mailbox_set_as_special(LibBalsaMailbox * mailbox, specialType which)
g_object_unref(mbnode);
}
config_mailbox_delete(mailbox);
- g_free(mailbox->name);
- mailbox->name = g_strdup(specialNames[which]);
+ libbalsa_mailbox_set_name(mailbox, specialNames[which]);
config_mailbox_add(mailbox, specialNames[which]);
*special = mailbox;
@@ -309,7 +316,8 @@ config_mailbox_set_as_special(LibBalsaMailbox * mailbox, specialType which)
switch(which) {
case SPECIAL_SENT:
- balsa_mblist_mru_add(&balsa_app.fcc_mru, mailbox->url); break;
+ balsa_mblist_mru_add(&balsa_app.fcc_mru, libbalsa_mailbox_get_url(mailbox));
+ break;
case SPECIAL_TRASH:
libbalsa_filters_set_trash(balsa_app.trash); break;
default: break;
@@ -390,7 +398,8 @@ gint config_folder_add(BalsaMailboxNode * mbnode, const char *key_arg)
} /* config_mailbox_add */
/* removes from the configuration only */
-gint config_mailbox_delete(const LibBalsaMailbox * mailbox)
+gint
+config_mailbox_delete(LibBalsaMailbox * mailbox)
{
gchar *tmp; /* the key in the mailbox section name */
gint res;
@@ -488,7 +497,7 @@ config_mailbox_init(const gchar * prefix)
special = &balsa_app.inbox;
else if (strcmp(OUTBOX_NAME, key) == 0) {
special = &balsa_app.outbox;
- mailbox->no_reassemble = TRUE;
+ libbalsa_mailbox_set_no_reassemble(mailbox, TRUE);
} else if (strcmp(SENTBOX_NAME, key) == 0)
special = &balsa_app.sentbox;
else if (strcmp(DRAFTS_NAME, key) == 0)
@@ -1982,11 +1991,15 @@ config_filters_save(void)
void
config_mailbox_filters_save(LibBalsaMailbox * mbox)
{
+ const gchar *url;
gchar * tmp;
- g_return_if_fail(mbox);
- tmp = mailbox_filters_section_lookup(mbox->url ? mbox->url : mbox->name);
- if (!mbox->filters) {
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mbox));
+
+ url = libbalsa_mailbox_get_url(mbox);
+ tmp = mailbox_filters_section_lookup(url !=NULL ? url :
+ libbalsa_mailbox_get_name(mbox));
+ if (libbalsa_mailbox_get_filters(mbox) == NULL) {
if (tmp) {
libbalsa_conf_remove_group(tmp);
g_free(tmp);
@@ -1998,7 +2011,7 @@ config_mailbox_filters_save(LibBalsaMailbox * mbox)
tmp=config_get_unused_group(MAILBOX_FILTERS_SECTION_PREFIX);
libbalsa_conf_push_group(tmp);
g_free(tmp);
- libbalsa_conf_set_string(MAILBOX_FILTERS_URL_KEY,mbox->url);
+ libbalsa_conf_set_string(MAILBOX_FILTERS_URL_KEY, url);
}
else {
libbalsa_conf_push_group(tmp);
diff --git a/src/save-restore.h b/src/save-restore.h
index f6bb24587..1fa9497c7 100644
--- a/src/save-restore.h
+++ b/src/save-restore.h
@@ -47,7 +47,7 @@ void config_defclient_save(void);
gchar *mailbox_get_pkey(const LibBalsaMailbox * mbox);
gint config_mailbox_add(LibBalsaMailbox * mailbox, const char *key_arg);
-gint config_mailbox_delete(const LibBalsaMailbox * mailbox);
+gint config_mailbox_delete(LibBalsaMailbox * mailbox);
gint config_mailbox_update(LibBalsaMailbox * mailbox);
gint config_folder_add(BalsaMailboxNode * mbnode, const char *key_arg);
diff --git a/src/sendmsg-window.c b/src/sendmsg-window.c
index dc2618cfc..f0293ad85 100644
--- a/src/sendmsg-window.c
+++ b/src/sendmsg-window.c
@@ -486,8 +486,11 @@ address_book_response(GtkWidget * ab, gint response,
static void
sw_delete_draft(BalsaSendmsg * bsmsg)
{
- LibBalsaMessage *message = bsmsg->draft_message;
- if (message && message->mailbox && !message->mailbox->readonly)
+ LibBalsaMessage *message;
+
+ message = bsmsg->draft_message;
+ if (message != NULL && message->mailbox != NULL
+ && !libbalsa_mailbox_get_readonly(message->mailbox))
libbalsa_message_change_flags(message,
LIBBALSA_MESSAGE_FLAG_DELETED, 0);
}
@@ -2589,8 +2592,9 @@ create_info_pane(BalsaSendmsg * bsmsg)
#undef REPLY_TO_ROW
/* fcc: mailbox folder where the message copy will be written to */
- if (!balsa_app.fcc_mru)
- balsa_mblist_mru_add(&balsa_app.fcc_mru, balsa_app.sentbox->url);
+ if (balsa_app.fcc_mru == NULL)
+ balsa_mblist_mru_add(&balsa_app.fcc_mru,
+ libbalsa_mailbox_get_url(balsa_app.sentbox));
balsa_mblist_mru_add(&balsa_app.fcc_mru, "");
if (balsa_app.copy_to_sentbox) {
/* move the NULL option to the bottom */
@@ -5511,7 +5515,7 @@ send_message_handler(BalsaSendmsg * bsmsg, gboolean queue_only)
bsmsg->flow, &error);
if (result == LIBBALSA_MESSAGE_CREATE_OK) {
if (bsmsg->parent_message && bsmsg->parent_message->mailbox
- && !bsmsg->parent_message->mailbox->readonly)
+ && !libbalsa_mailbox_get_readonly(bsmsg->parent_message->mailbox))
libbalsa_message_reply(bsmsg->parent_message);
sw_delete_draft(bsmsg);
}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
