[balsa/wip/gtk4: 243/351] mailbox: Declare it derivable
- From: Peter Bloomfield <peterb src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [balsa/wip/gtk4: 243/351] mailbox: Declare it derivable
- Date: Wed, 23 May 2018 21:37:23 +0000 (UTC)
commit 9edbf2c177e063f60c2cde2dd640174e2153642b
Author: Peter Bloomfield <PeterBloomfield bellsouth net>
Date: Sun Mar 25 13:00:08 2018 -0400
mailbox: Declare it derivable
Use G_DECLARE_DERIVABLE_TYPE for LibBalsaMailbox, make it
private, and provide a complete set of getters and setters.
libbalsa/filter-file.c | 22 +-
libbalsa/libbalsa.c | 53 --
libbalsa/mailbox-filter.c | 5 +-
libbalsa/mailbox.c | 1065 +++++++++++++++++++++---------
libbalsa/mailbox.h | 143 ++---
libbalsa/mailbox_imap.c | 107 ++--
libbalsa/mailbox_local.c | 127 +++--
libbalsa/mailbox_local.h | 3 +-
libbalsa/mailbox_maildir.c | 30 +-
libbalsa/mailbox_mbox.c | 28 +-
libbalsa/mailbox_mh.c | 19 +-
libbalsa/mailbox_pop3.c | 157 +++--
libbalsa/message.c | 4 +-
libbalsa/send.c | 19 +-
libinit_balsa/assistant_page_directory.c | 20 +-
libinit_balsa/assistant_page_user.c | 2 +-
src/balsa-app.c | 11 +-
src/balsa-index.c | 38 +-
src/balsa-mblist.c | 19 +-
src/balsa-message.c | 8 +-
src/balsa-mime-widget-text.c | 3 +-
src/filter-edit-callbacks.c | 8 +-
src/filter-run-callbacks.c | 17 +-
src/filter-run-dialog.c | 13 +-
src/folder-conf.c | 10 +-
src/mailbox-conf.c | 73 ++-
src/mailbox-node.c | 53 +-
src/main-window.c | 51 +-
src/main.c | 17 +-
src/message-window.c | 5 +-
src/pref-manager.c | 11 +-
src/save-restore.c | 54 +-
src/save-restore.h | 2 +-
src/sendmsg-window.c | 14 +-
34 files changed, 1346 insertions(+), 865 deletions(-)
---
diff --git a/libbalsa/filter-file.c b/libbalsa/filter-file.c
index d0c874e..d50dbc2 100644
--- a/libbalsa/filter-file.c
+++ b/libbalsa/filter-file.c
@@ -115,6 +115,9 @@ libbalsa_mailbox_filters_load_config(LibBalsaMailbox* mbox)
LibBalsaFilter* fil;
gboolean def;
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,
@@ -126,25 +129,26 @@ libbalsa_mailbox_filters_load_config(LibBalsaMailbox* mbox)
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 != NULL; lst = lst->next)
+ if (def) {
+ for(lst = filters; lst != NULL; lst = lst->next)
FILTER_WHEN_SETFLAG((LibBalsaMailboxFilter*)lst->data,
FILTER_WHEN_NEVER);
- else {
- lst=mbox->filters;
+ } else {
+ lst = filters;
for (i=0;i<nb_filters && lst != NULL;i++) {
((LibBalsaMailboxFilter*)lst->data)->when =
atoi(filters_names[i]);
@@ -170,7 +174,7 @@ libbalsa_mailbox_filters_save_config(LibBalsaMailbox * mbox)
* 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 != NULL; fil = fil->next) {
+ 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++;
@@ -187,7 +191,7 @@ libbalsa_mailbox_filters_save_config(LibBalsaMailbox * mbox)
libbalsa_conf_set_vector(MAILBOX_FILTERS_KEY,nb_filters,
(const gchar**)filters_names);
- fil=mbox->filters;
+ fil=libbalsa_mailbox_get_filters(mbox);
for (i=0;i<nb_filters;i++) {
filters_names[i]=
g_strdup_printf("%d",
diff --git a/libbalsa/libbalsa.c b/libbalsa/libbalsa.c
index 7b0b461..f8ca04d 100644
--- a/libbalsa/libbalsa.c
+++ b/libbalsa/libbalsa.c
@@ -723,59 +723,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 6647021..efe083d 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 3a8046c..a4209f4 100644
--- a/libbalsa/mailbox.c
+++ b/libbalsa/mailbox.c
@@ -104,58 +104,77 @@ static void mbox_drag_source_init(GtkTreeDragSourceIface *iface);
/* GtkTreeSortable function prototypes */
static void mbox_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;
+};
+
+G_DEFINE_TYPE_WITH_CODE(LibBalsaMailbox,
+ libbalsa_mailbox,
+ G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE(GTK_TYPE_TREE_MODEL,
+ mbox_model_init)
+ G_IMPLEMENT_INTERFACE(GTK_TYPE_TREE_DRAG_SOURCE,
+ mbox_drag_source_init)
+ G_IMPLEMENT_INTERFACE(GTK_TYPE_TREE_SORTABLE,
+ mbox_sortable_init)
+ G_ADD_PRIVATE(LibBalsaMailbox)
+ )
static void
libbalsa_mailbox_class_init(LibBalsaMailboxClass * klass)
@@ -236,28 +255,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);
+
+ g_rec_mutex_init(&priv->rec_mutex);
+ priv->is_directory = FALSE;
- mailbox->config_prefix = NULL;
- mailbox->name = NULL;
- mailbox->url = NULL;
+ priv->config_prefix = NULL;
+ priv->name = NULL;
+ priv->url = NULL;
- mailbox->open_ref = 0;
- mailbox->has_unread_messages = FALSE;
- mailbox->unread_messages = 0;
+ priv->open_ref = 0;
+ priv->has_unread_messages = FALSE;
+ priv->unread_messages = 0;
- mailbox->readonly = FALSE;
- mailbox->disconnected = FALSE;
+ priv->readonly = FALSE;
- mailbox->filters=NULL;
- mailbox->filters_loaded = FALSE;
- mailbox->view=NULL;
- /* mailbox->stamp is incremented before we use it, so it won't be
+ 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;
}
/*
@@ -274,29 +294,32 @@ 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)
+ g_rec_mutex_clear(&priv->rec_mutex);
+
+ while (priv->open_ref > 0)
libbalsa_mailbox_close(mailbox, FALSE);
- if (mailbox->msgnos_pending != NULL) {
+ if (priv->msgnos_pending != NULL) {
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 != NULL) {
+ if (priv->msgnos_changed != NULL) {
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_clear_source_id(&mailbox->changed_idle_id);
- libbalsa_clear_source_id(&mailbox->queue_check_idle_id);
- libbalsa_clear_source_id(&mailbox->need_threading_idle_id);
+ libbalsa_clear_source_id(&priv->changed_idle_id);
+ libbalsa_clear_source_id(&priv->queue_check_idle_id);
+ libbalsa_clear_source_id(&priv->need_threading_idle_id);
G_OBJECT_CLASS(parent_class)->dispose(object);
}
@@ -305,6 +328,8 @@ libbalsa_mailbox_dispose(GObject * 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;
@@ -313,8 +338,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;
@@ -408,12 +433,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;
@@ -428,12 +455,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);
@@ -449,22 +477,21 @@ libbalsa_mailbox_index_set_flags(LibBalsaMailbox *mailbox,
static void
libbalsa_mailbox_finalize(GObject * object)
{
- LibBalsaMailbox *mailbox;
+ LibBalsaMailbox *mailbox = (LibBalsaMailbox *) object;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
- g_return_if_fail(object != NULL);
-
- mailbox = LIBBALSA_MAILBOX(object);
+ g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
- g_free(mailbox->config_prefix);
- g_free(mailbox->name);
- g_free(mailbox->url);
+ g_free(priv->config_prefix);
+ g_free(priv->name);
+ g_free(priv->url);
- libbalsa_condition_unref(mailbox->view_filter);
- libbalsa_condition_unref(mailbox->persistent_view_filter);
+ libbalsa_condition_unref(priv->view_filter);
+ libbalsa_condition_unref(priv->persistent_view_filter);
- g_slist_free_full(mailbox->filters, g_free);
+ g_slist_free_full(priv->filters, g_free);
- libbalsa_mailbox_view_free(mailbox->view);
+ libbalsa_mailbox_view_free(priv->view);
G_OBJECT_CLASS(parent_class)->finalize(object);
}
@@ -528,13 +555,15 @@ libbalsa_mailbox_new_from_config(const gchar * group)
static void
libbalsa_mailbox_free_mindex(LibBalsaMailbox *mailbox)
{
- if(mailbox->mindex) {
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ if(priv->mindex) {
unsigned i;
/* we could have used g_ptr_array_foreach but it is >=2.4.0 */
- for(i=0; i<mailbox->mindex->len; i++)
- lbm_index_entry_free(g_ptr_array_index(mailbox->mindex, i));
- g_ptr_array_free(mailbox->mindex, TRUE);
- mailbox->mindex = NULL;
+ for(i=0; i<priv->mindex->len; i++)
+ lbm_index_entry_free(g_ptr_array_index(priv->mindex, i));
+ g_ptr_array_free(priv->mindex, TRUE);
+ priv->mindex = NULL;
}
}
@@ -544,6 +573,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);
@@ -552,26 +582,26 @@ 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 = g_ptr_array_new();
+ priv->stamp++;
+ if(priv->mindex) g_warning("mindex set - I leak memory");
+ priv->mindex = g_ptr_array_new();
- 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);
}
}
@@ -588,7 +618,9 @@ libbalsa_mailbox_open(LibBalsaMailbox * mailbox, GError **err)
gboolean
libbalsa_mailbox_is_valid(LibBalsaMailbox * mailbox)
{
- if(mailbox->open_ref == 0) return TRUE;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ if(priv->open_ref == 0) return TRUE;
if(MAILBOX_CLOSED(mailbox)) return FALSE;
return TRUE;
}
@@ -596,16 +628,20 @@ libbalsa_mailbox_is_valid(LibBalsaMailbox * mailbox)
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));
@@ -614,18 +650,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);
@@ -636,10 +672,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);
}
@@ -674,6 +712,8 @@ 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));
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
@@ -681,7 +721,7 @@ libbalsa_mailbox_check(LibBalsaMailbox * mailbox)
libbalsa_lock_mailbox(mailbox);
/* Remove any scheduled idle callback. */
- libbalsa_clear_source_id(&mailbox->queue_check_idle_id);
+ libbalsa_clear_source_id(&priv->queue_check_idle_id);
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->check(mailbox);
@@ -691,9 +731,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 FALSE;
}
@@ -701,9 +743,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);
}
@@ -711,11 +755,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;
}
@@ -725,11 +771,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);
}
@@ -790,6 +836,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;
@@ -805,12 +852,12 @@ lbm_run_filters_on_reception_idle_cb(LibBalsaMailbox * mailbox)
return FALSE;
g_object_remove_weak_pointer(G_OBJECT(mailbox), (gpointer) &mailbox);
- 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)
@@ -841,7 +888,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);
@@ -905,6 +952,8 @@ 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));
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
@@ -912,8 +961,8 @@ libbalsa_mailbox_save_config(LibBalsaMailbox * 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);
@@ -995,6 +1044,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;
@@ -1004,8 +1055,8 @@ libbalsa_mailbox_real_messages_copy(LibBalsaMailbox * mailbox,
g_assert(LIBBALSA_MAILBOX_GET_CLASS(dest) != NULL);
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);
@@ -1047,25 +1098,29 @@ static void
libbalsa_mailbox_real_save_config(LibBalsaMailbox * mailbox,
const gchar * group)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
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)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
g_return_if_fail(LIBBALSA_IS_MAILBOX(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
@@ -1161,7 +1216,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;
@@ -1169,7 +1224,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. */
@@ -1181,8 +1236,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);
}
@@ -1191,15 +1248,17 @@ 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,
path, iter);
@@ -1211,27 +1270,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;
@@ -1240,10 +1300,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);
@@ -1255,27 +1315,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;
}
@@ -1286,9 +1348,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;
}
@@ -1308,11 +1371,13 @@ 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->view->threading_type);
+ lbm_set_threading(mailbox, priv->view->threading_type);
- mailbox->need_threading_idle_id = 0;
+ priv->need_threading_idle_id = 0;
libbalsa_unlock_mailbox(mailbox);
@@ -1323,21 +1388,22 @@ 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,
@@ -1350,36 +1416,37 @@ libbalsa_mailbox_msgno_inserted(LibBalsaMailbox *mailbox, guint seqno,
}
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,
path, &iter);
gtk_tree_path_free(path);
- mailbox->msg_tree_changed = TRUE;
+ priv->msg_tree_changed = TRUE;
lbm_changed_schedule_idle(mailbox);
}
@@ -1406,6 +1473,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;
@@ -1415,7 +1483,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;
}
@@ -1423,16 +1491,16 @@ 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) {
- lbm_index_entry_free(g_ptr_array_index(mailbox->mindex,
+ if (seqno <= priv->mindex->len) {
+ lbm_index_entry_free(g_ptr_array_index(priv->mindex,
seqno - 1));
- g_ptr_array_remove_index(mailbox->mindex, seqno - 1);
+ 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 */
@@ -1440,7 +1508,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
@@ -1466,8 +1534,8 @@ libbalsa_mailbox_msgno_removed(LibBalsaMailbox * mailbox, guint seqno)
}
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);
@@ -1485,22 +1553,23 @@ libbalsa_mailbox_msgno_removed(LibBalsaMailbox * mailbox, guint seqno)
}
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
@@ -1538,9 +1607,9 @@ libbalsa_mailbox_msgno_filt_out(LibBalsaMailbox * mailbox, GNode * node)
}
gtk_tree_path_free(path);
- mailbox->stamp++;
+ priv->stamp++;
- mailbox->msg_tree_changed = TRUE;
+ priv->msg_tree_changed = TRUE;
lbm_changed_schedule_idle(mailbox);
}
@@ -1557,12 +1626,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) {
@@ -1615,9 +1685,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;
}
@@ -1658,9 +1730,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
@@ -1748,17 +1822,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 =
@@ -1876,11 +1951,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);
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
libbalsa_lock_mailbox(mailbox);
@@ -1902,15 +1978,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)
@@ -1920,6 +1997,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);
@@ -1930,7 +2008,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;
}
@@ -1943,7 +2021,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);
@@ -2044,6 +2122,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;
@@ -2052,7 +2131,7 @@ libbalsa_mailbox_messages_change_flags(LibBalsaMailbox * mailbox,
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
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;
@@ -2063,7 +2142,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++) {
@@ -2162,23 +2241,24 @@ libbalsa_mailbox_set_view_filter(LibBalsaMailbox *mailbox,
LibBalsaCondition *cond,
gboolean update_immediately)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
gboolean retval = FALSE;
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
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->threading_type);
- mailbox->view_filter_pending = FALSE;
+ retval = lbm_set_threading(mailbox, priv->view->threading_type);
+ priv->view_filter_pending = FALSE;
}
libbalsa_unlock_mailbox(mailbox);
@@ -2189,9 +2269,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. */
@@ -2235,8 +2317,10 @@ static void lbm_sort(LibBalsaMailbox * mbox, 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);
}
@@ -2331,13 +2415,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. */
@@ -2473,11 +2559,12 @@ 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(mailbox != NULL && 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;
@@ -2542,8 +2629,10 @@ libbalsa_mailbox_set_mtime(LibBalsaMailbox * mailbox, time_t mtime)
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);
+
+ return (mailbox && priv->view) ?
+ priv->view->identity_name :
libbalsa_mailbox_view_default.identity_name;
}
@@ -2551,67 +2640,85 @@ 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);
+
+ return (mailbox && priv->view) ?
+ priv->view->threading_type :
libbalsa_mailbox_view_default.threading_type;
}
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);
+
+ return (mailbox && priv->view) ?
+ 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);
+
+ return (mailbox && priv->view) ?
+ 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);
+
+ return (mailbox && priv->view) ?
+ 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);
+
+ return (mailbox && priv->view) ?
+ 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);
+
+ return (mailbox && priv->view) ?
+ 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);
+
+ return (mailbox && priv->view) ?
+ 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);
+
+ return (mailbox && priv->view) ?
+ priv->view->filter : libbalsa_mailbox_view_default.filter;
}
#ifdef HAVE_GPGME
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);
+
+ return (mailbox && priv->view) ?
+ priv->view->gpg_chk_mode :
libbalsa_mailbox_view_default.gpg_chk_mode;
}
#endif
@@ -2619,9 +2726,11 @@ libbalsa_mailbox_get_crypto_mode(LibBalsaMailbox * mailbox)
gint
libbalsa_mailbox_get_unread(LibBalsaMailbox * mailbox)
{
- if (mailbox && mailbox->view) {
- mailbox->view->used = 1;
- return mailbox->view->unread;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ if (mailbox && priv->view) {
+ priv->view->used = 1;
+ return priv->view->unread;
} else
return libbalsa_mailbox_view_default.unread;
}
@@ -2629,15 +2738,19 @@ libbalsa_mailbox_get_unread(LibBalsaMailbox * mailbox)
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);
+
+ return (mailbox && priv->view) ?
+ 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);
+
+ return (mailbox && priv->view) ?
+ priv->view->mtime : libbalsa_mailbox_view_default.mtime;
}
/* End of get methods. */
@@ -2654,9 +2767,9 @@ libbalsa_mailbox_get_mtime(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);
@@ -2808,6 +2921,8 @@ mbox_model_get_path_helper(GNode * node, GNode * msg_tree)
static GtkTreePath *
mbox_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;
@@ -2824,9 +2939,7 @@ 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 mbox_model_get_path_helper(node, priv->msg_tree);
}
/* mbox_model_get_value:
@@ -2838,36 +2951,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)))
@@ -2878,10 +2994,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);
@@ -2891,26 +3007,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);
@@ -2921,10 +3038,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);
@@ -3046,14 +3163,15 @@ mbox_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;
@@ -3081,12 +3199,13 @@ static gint
mbox_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;
}
@@ -3097,19 +3216,20 @@ mbox_model_iter_nth_child(GtkTreeModel * tree_model,
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.
@@ -3130,6 +3250,8 @@ mbox_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);
@@ -3138,7 +3260,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;
@@ -3314,25 +3436,26 @@ mbox_compare_func(const SortTuple * a,
const SortTuple * b,
LibBalsaMailbox * mbox)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mbox);
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);
break;
@@ -3352,7 +3475,7 @@ 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);
break;
@@ -3372,7 +3495,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;
}
@@ -3388,12 +3511,13 @@ 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);
}
@@ -3401,11 +3525,12 @@ lbm_has_valid_index_entry(LibBalsaMailbox * mailbox, guint msgno)
static void
lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mbox);
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);
#else
@@ -3466,7 +3591,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;
@@ -3490,7 +3615,7 @@ lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
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)
: gtk_tree_path_new();
@@ -3514,11 +3639,12 @@ mbox_get_sort_column_id(GtkTreeSortable * sortable,
GtkSortType * order)
{
LibBalsaMailbox *mbox = (LibBalsaMailbox *) sortable;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mbox);
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;
@@ -3539,7 +3665,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);
@@ -3553,13 +3679,14 @@ mbox_set_sort_column_id(GtkTreeSortable * sortable,
GtkSortType order)
{
LibBalsaMailbox *mbox = (LibBalsaMailbox *) sortable;
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mbox);
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:
@@ -3605,7 +3732,7 @@ mbox_set_sort_column_id(GtkTreeSortable * sortable,
return;
}
libbalsa_lock_mailbox(mbox);
- lbm_sort(mbox, mbox->msg_tree);
+ lbm_sort(mbox, priv->msg_tree);
libbalsa_unlock_mailbox(mbox);
libbalsa_mailbox_changed(mbox);
@@ -3640,6 +3767,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;
@@ -3650,13 +3778,13 @@ 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 = mbox_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);
if (!current_parent->children) {
@@ -3676,9 +3804,9 @@ libbalsa_mailbox_unlink_and_prepend(LibBalsaMailbox * mailbox,
}
g_node_prepend(parent, node);
- path = mbox_model_get_path_helper(parent, mailbox->msg_tree);
+ path = mbox_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;
@@ -3697,7 +3825,7 @@ libbalsa_mailbox_unlink_and_prepend(LibBalsaMailbox * mailbox,
0, path, &iter);
gtk_tree_path_free(path);
- mailbox->msg_tree_changed = TRUE;
+ priv->msg_tree_changed = TRUE;
}
}
@@ -3787,6 +3915,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;
@@ -3798,13 +3927,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,
@@ -3816,19 +3945,20 @@ 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,
@@ -3846,17 +3976,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 *
@@ -3905,6 +4037,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;
@@ -3914,7 +4047,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);
@@ -4054,9 +4187,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);
@@ -4110,8 +4244,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;
}
@@ -4119,8 +4254,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;
}
@@ -4129,13 +4265,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;
@@ -4163,6 +4300,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,
@@ -4170,7 +4308,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;
@@ -4179,9 +4317,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);
}
@@ -4202,13 +4342,14 @@ 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;
node = iter->user_data;
if (!node)
- node = mailbox->msg_tree;
+ node = priv->msg_tree;
total = libbalsa_mailbox_total_messages(mailbox);
for (;;) {
@@ -4252,6 +4393,7 @@ gint
libbalsa_mailbox_move_duplicates(LibBalsaMailbox * mailbox,
LibBalsaMailbox * dest, GError ** err)
{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GArray *msgnos = NULL;
gint retval;
@@ -4261,7 +4403,7 @@ libbalsa_mailbox_move_duplicates(LibBalsaMailbox * 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,
@@ -4310,8 +4452,10 @@ 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));
@@ -4323,18 +4467,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) {
@@ -4371,3 +4516,273 @@ void libbalsa_mailbox_test_can_reach(LibBalsaMailbox * 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);
+
+ return priv->filters;
+}
+
+const gchar *
+libbalsa_mailbox_get_name(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ return priv->name;
+}
+
+const gchar *
+libbalsa_mailbox_get_url(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ return priv->url;
+}
+
+glong
+libbalsa_mailbox_get_unread_messages(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ return priv->unread_messages;
+}
+
+guint
+libbalsa_mailbox_get_first_unread(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ return priv->first_unread;
+}
+
+LibBalsaCondition *
+libbalsa_mailbox_get_view_filter(LibBalsaMailbox * mailbox,
+ gboolean persistent)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ 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);
+
+ return priv->msg_tree;
+}
+
+gboolean
+libbalsa_mailbox_get_msg_tree_changed(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ return priv->msg_tree_changed;
+}
+
+LibBalsaMailboxState
+libbalsa_mailbox_get_state(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ return priv->state;
+}
+
+LibBalsaMailboxIndexEntry *
+libbalsa_mailbox_get_index_entry(LibBalsaMailbox * mailbox, guint msgno)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ return (LibBalsaMailboxIndexEntry *) g_ptr_array_index(priv->mindex, msgno - 1);
+}
+
+LibBalsaMailboxView *
+libbalsa_mailbox_get_view(LibBalsaMailbox * mailbox)
+{
+ return lbm_get_view(mailbox);
+}
+
+gint
+libbalsa_mailbox_get_stamp(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ return priv->stamp;
+}
+
+guint
+libbalsa_mailbox_get_open_ref(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ return priv->open_ref;
+}
+
+gboolean
+libbalsa_mailbox_get_readonly(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ return priv->readonly;
+}
+
+const gchar *
+libbalsa_mailbox_get_config_prefix(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ return priv->config_prefix;
+}
+
+gboolean
+libbalsa_mailbox_get_has_unread_messages(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ return priv->has_unread_messages;
+}
+
+/*
+ * Setters
+ */
+
+void
+libbalsa_mailbox_clear_unread_messages(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ priv->unread_messages = 0;
+}
+
+void
+libbalsa_mailbox_set_filters(LibBalsaMailbox * mailbox, GSList * filters)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ libbalsa_clear_slist(&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_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);
+
+ priv->first_unread = first;
+}
+
+void
+libbalsa_mailbox_set_msg_tree_changed(LibBalsaMailbox * mailbox, gboolean changed)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(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);
+
+ priv->is_directory = is_directory;
+}
+
+void
+libbalsa_mailbox_set_readonly(LibBalsaMailbox * mailbox, gboolean readonly)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ priv->readonly = readonly;
+}
+
+void
+libbalsa_mailbox_set_no_reassemble(LibBalsaMailbox * mailbox, gboolean no_reassemble)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(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_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);
+
+ 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);
+
+ 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_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);
+
+ priv->unread_messages += count;
+}
+
+/*
+ * Locking
+ */
+
+void
+libbalsa_lock_mailbox(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_rec_mutex_lock(&priv->rec_mutex);
+}
+
+void
+libbalsa_unlock_mailbox(LibBalsaMailbox * mailbox)
+{
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+
+ g_rec_mutex_unlock(&priv->rec_mutex);
+}
diff --git a/libbalsa/mailbox.h b/libbalsa/mailbox.h
index 834c41a..62d9753 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 {\
@@ -145,7 +140,6 @@ enum LibBalsaMailboxCapability {
/*
* structures
*/
-typedef struct _LibBalsaMailboxClass LibBalsaMailboxClass;
typedef struct _LibBalsaMailboxView LibBalsaMailboxView;
struct _LibBalsaMailboxView {
@@ -184,69 +178,6 @@ struct _LibBalsaMailboxView {
time_t mtime; /* Mailbox mtime when counts were cached. */
};
-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;
-};
-
/* Search iter */
struct _LibBalsaMailboxSearchIter {
gint ref_count;
@@ -330,8 +261,6 @@ struct _LibBalsaMailboxClass {
gpointer cb_data);
};
-GType libbalsa_mailbox_get_type(void);
-
LibBalsaMailbox *libbalsa_mailbox_new_from_config(const gchar * prefix);
/*
@@ -672,4 +601,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 6a25505..d76946c 100644
--- a/libbalsa/mailbox_imap.c
+++ b/libbalsa/mailbox_imap.c
@@ -79,6 +79,8 @@ struct _LibBalsaMailboxImap {
ImapAclType rights; /* RFC 4314 'myrights' */
GList *acls; /* RFC 4314 acl's */
+
+ gboolean disconnected;
};
struct _LibBalsaMailboxImapClass {
@@ -191,7 +193,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
@@ -301,6 +303,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;
}
static void
@@ -338,7 +341,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);
g_free(mailbox->path);
g_array_free(mailbox->sort_ranks, TRUE);
@@ -364,9 +367,11 @@ void
libbalsa_mailbox_imap_update_url(LibBalsaMailboxImap* mailbox)
{
LibBalsaServer *s = LIBBALSA_MAILBOX_REMOTE_GET_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
@@ -718,6 +723,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
@@ -728,8 +734,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;
@@ -774,12 +782,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;
@@ -827,6 +835,7 @@ imap_exists_idle(gpointer data)
LibBalsaMailboxImap *mimap = (LibBalsaMailboxImap*)data;
LibBalsaMailbox *mailbox = LIBBALSA_MAILBOX(mimap);
unsigned cnt;
+ GNode *msg_tree;
libbalsa_lock_mailbox(mailbox);
@@ -868,12 +877,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;
@@ -976,6 +986,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);
@@ -991,8 +1002,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,
@@ -1007,7 +1018,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);
}
@@ -1037,26 +1048,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);
}
@@ -1078,13 +1092,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),
@@ -1110,17 +1124,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;
}
@@ -1608,7 +1624,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)));
};
res = cbdata->res;
g_free(cbdata);
@@ -1670,7 +1686,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);
@@ -1735,11 +1751,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));
}
}
@@ -1752,12 +1767,13 @@ libbalsa_mailbox_imap_reconnect(LibBalsaMailboxImap* mimap)
imap_mbox_is_disconnected (mimap->handle)) {
const gchar *host =
libbalsa_server_get_host(LIBBALSA_MAILBOX_REMOTE_GET_SERVER(mimap));
+ gboolean readonly;
printf("Reconnecting %s (%u)\n", host, (unsigned)time(NULL));
- if (imap_mbox_handle_reconnect
- (mimap->handle, &(LIBBALSA_MAILBOX(mimap)->readonly))
+ if (imap_mbox_handle_reconnect(mimap->handle, &readonly)
== IMAP_SUCCESS)
printf("Reconnected %s (%u)\n", host, (unsigned)time(NULL));
+ libbalsa_mailbox_set_readonly(LIBBALSA_MAILBOX(mimap), readonly);
}
}
@@ -3153,11 +3169,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;
@@ -3174,10 +3190,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:
@@ -3196,7 +3213,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)
@@ -3251,7 +3268,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;
}
@@ -3261,7 +3278,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;
@@ -3270,7 +3287,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,
@@ -3283,7 +3300,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 ce6c61f..194e59a 100644
--- a/libbalsa/mailbox_local.c
+++ b/libbalsa/mailbox_local.c
@@ -227,6 +227,21 @@ libbalsa_mailbox_local_new(const gchar * path, gboolean create)
}
}
+/*
+ * libbalsa_mailbox_local_get_path
+ */
+const gchar *
+libbalsa_mailbox_local_get_path(LibBalsaMailboxLocal * local)
+{
+ static const gchar prefix[] = "file://";
+ const gchar *url;
+
+ url = libbalsa_mailbox_get_url(LIBBALSA_MAILBOX(local));
+ g_assert(g_str_has_prefix(url, prefix));
+
+ return url + sizeof prefix - 1;
+}
+
/* libbalsa_mailbox_local_set_path:
returrns errno on error, 0 on success
FIXME: proper suport for maildir and mh
@@ -244,7 +259,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(LIBBALSA_MAILBOX(mailbox)) != NULL) {
const gchar *cur_path = libbalsa_mailbox_local_get_path(mailbox);
if (strcmp(path, cur_path) == 0)
return 0;
@@ -257,11 +272,14 @@ libbalsa_mailbox_local_set_path(LibBalsaMailboxLocal * mailbox,
/* update mailbox data */
if (i == 0) {
+ gchar *url;
+
if (klass->set_path)
klass->set_path(mailbox, path);
- g_free(LIBBALSA_MAILBOX(mailbox)->url);
- LIBBALSA_MAILBOX(mailbox)->url =
- g_strconcat("file://", path, NULL);
+ url = g_strconcat("file://", path, NULL);
+ libbalsa_mailbox_set_url(LIBBALSA_MAILBOX(mailbox), url);
+ g_free(url);
+
return 0;
} else
return errno ? errno : -1;
@@ -330,15 +348,16 @@ libbalsa_mailbox_local_load_message(LibBalsaMailboxLocal * local,
msg_info)
{
LibBalsaMailbox *mbx = 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(mbx, 1);
+ if (libbalsa_mailbox_get_first_unread(mbx) == 0)
+ libbalsa_mailbox_set_first_unread(mbx, msgno);
}
if (msg_info->flags & LIBBALSA_MESSAGE_FLAG_RECENT) {
@@ -353,14 +372,15 @@ libbalsa_mailbox_local_load_message(LibBalsaMailboxLocal * local,
}
}
- if (!mbx->view_filter)
+ view_filter = libbalsa_mailbox_get_view_filter(mbx, FALSE);
+ if (view_filter == NULL)
match = TRUE;
- else if (!libbalsa_condition_is_flag_only(mbx->view_filter,
+ else if (!libbalsa_condition_is_flag_only(view_filter,
mbx, msgno, &match))
- match = message_match_real(mbx, msgno, mbx->view_filter);
+ match = message_match_real(mbx, msgno, view_filter);
if (match)
- libbalsa_mailbox_msgno_inserted(mbx, msgno, mbx->msg_tree,
+ libbalsa_mailbox_msgno_inserted(mbx, msgno, libbalsa_mailbox_get_msg_tree(mbx),
sibling);
}
@@ -447,12 +467,15 @@ libbalsa_mailbox_local_load_config(LibBalsaMailbox * mailbox,
const gchar * prefix)
{
gchar* path;
+ gchar *url;
+
g_return_if_fail(LIBBALSA_IS_MAILBOX_LOCAL(mailbox));
- g_free(mailbox->url);
path = libbalsa_conf_get_string("Path");
- mailbox->url = g_strconcat("file://", path, NULL);
+ url = g_strconcat("file://", path, NULL);
+ libbalsa_mailbox_set_url(mailbox, url);
+ g_free(url);
g_free(path);
if (LIBBALSA_MAILBOX_CLASS(parent_class)->load_config)
@@ -535,13 +558,14 @@ lbm_local_save_tree(LibBalsaMailboxLocal * local)
g_assert(LIBBALSA_MAILBOX_LOCAL_GET_CLASS(local) != NULL);
- if (!mailbox->msg_tree || !mailbox->msg_tree_changed)
+ if (!libbalsa_mailbox_get_msg_tree(mailbox) ||
+ !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 (!libbalsa_mailbox_get_msg_tree(mailbox)->children
|| (libbalsa_mailbox_get_threading_type(mailbox) ==
LB_MAILBOX_THREADING_FLAT
&& libbalsa_mailbox_get_sort_field(mailbox) ==
@@ -559,7 +583,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(libbalsa_mailbox_get_msg_tree(mailbox), G_PRE_ORDER, G_TRAVERSE_ALL, -1,
(GNodeTraverseFunc) lbm_local_save_tree_func,
&save_info);
@@ -580,6 +604,7 @@ lbm_local_restore_tree(LibBalsaMailboxLocal * local, guint * total)
{
LibBalsaMailbox *mailbox = LIBBALSA_MAILBOX(local);
gchar *filename;
+ const gchar *mailbox_name;
gchar *name;
struct stat st;
gchar *contents;
@@ -594,7 +619,8 @@ lbm_local_restore_tree(LibBalsaMailboxLocal * local, guint * total)
g_assert(LIBBALSA_MAILBOX_LOCAL_GET_CLASS(local) != NULL);
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
@@ -639,7 +665,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)) {
@@ -689,10 +715,13 @@ lbm_local_restore_tree(LibBalsaMailboxLocal * local, guint * total)
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;
+ guint first_unread;
+
+ libbalsa_mailbox_add_to_unread_messages(mailbox, 1);
+
+ first_unread = libbalsa_mailbox_get_first_unread(mailbox);
+ if (first_unread == 0 || first_unread > info->msgno)
+ libbalsa_mailbox_set_first_unread(mailbox, info->msgno);
}
}
@@ -710,7 +739,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;
@@ -751,7 +780,8 @@ 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) {
/* Rethread immediately. */
@@ -824,7 +854,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;
@@ -837,7 +867,7 @@ message_match_real(LibBalsaMailbox *mailbox, guint msgno,
if (!message)
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);
}
@@ -1043,7 +1073,7 @@ lbml_load_messages_idle_cb(LibBalsaMailbox * mailbox)
libbalsa_lock_mailbox(mailbox);
local->load_messages_id = 0;
- if (!mailbox->msg_tree) {
+ if (!libbalsa_mailbox_get_msg_tree(mailbox)) {
/* Mailbox is closed, or no view has been created. */
libbalsa_unlock_mailbox(mailbox);
return FALSE;
@@ -1052,7 +1082,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(libbalsa_mailbox_get_msg_tree(mailbox));
get_info = LIBBALSA_MAILBOX_LOCAL_GET_CLASS(local)->get_info;
while (++msgno <= lastno){
LibBalsaMailboxLocalMessageInfo *msg_info = get_info(local, msgno);
@@ -1067,8 +1097,8 @@ lbml_load_messages_idle_cb(LibBalsaMailbox * mailbox)
if (new_messages) {
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);
@@ -1148,7 +1178,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)) { /* first reference */
guint total = 0;
gboolean natural = (thread_type == LB_MAILBOX_THREADING_FLAT
&& libbalsa_mailbox_get_sort_field(mailbox) ==
@@ -1160,7 +1190,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)
@@ -1228,7 +1258,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;
@@ -1317,7 +1347,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);
@@ -1455,7 +1485,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;
}
@@ -1484,7 +1514,7 @@ lbml_threading_jwz(LibBalsaMailbox * mailbox)
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,
@@ -1995,7 +2025,7 @@ static void
lbml_threading_simple(LibBalsaMailbox * mailbox,
LibBalsaMailboxThreadingType type)
{
- GNode *msg_tree = mailbox->msg_tree;
+ GNode *msg_tree = libbalsa_mailbox_get_msg_tree(mailbox);
ThreadingInfo ti;
lbml_info_setup(mailbox, &ti);
@@ -2040,9 +2070,10 @@ lbml_thread_message(GNode * node, ThreadingInfo * ti)
return FALSE;
if (ti->type == LB_MAILBOX_THREADING_FLAT) {
- if (node->parent != ti->mailbox->msg_tree)
+ if (node->parent != libbalsa_mailbox_get_msg_tree(ti->mailbox))
libbalsa_mailbox_unlink_and_prepend(ti->mailbox, node,
- ti->mailbox->msg_tree);
+ libbalsa_mailbox_get_msg_tree
+ (ti->mailbox));
} else {
LibBalsaMailboxLocalInfo *info;
GList *refs;
@@ -2058,7 +2089,7 @@ lbml_thread_message(GNode * node, ThreadingInfo * ti)
g_list_last(refs)->data);
if (!parent)
- parent = ti->mailbox->msg_tree;
+ parent = libbalsa_mailbox_get_msg_tree(ti->mailbox);
if (parent != node->parent && parent != node
&& !g_node_is_ancestor(node, parent))
libbalsa_mailbox_unlink_and_prepend(ti->mailbox, node, parent);
@@ -2105,7 +2136,7 @@ libbalsa_mailbox_local_get_message_stream(LibBalsaMailbox * mailbox,
int fd;
GMimeStream *stream = NULL;
- path = libbalsa_mailbox_local_get_path(mailbox);
+ path = libbalsa_mailbox_local_get_path(LIBBALSA_MAILBOX_LOCAL(mailbox));
filename = g_build_filename(path, name1, name2, NULL);
fd = open(filename, O_RDONLY);
@@ -2136,7 +2167,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_id = 0;
local->sync_time += time(NULL)-tstart;
local->sync_cnt++;
@@ -2271,16 +2302,16 @@ 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
- > 0);
+ libbalsa_mailbox_set_unread_messages_flag(mailbox,
+ 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 89d9988..2caad75 100644
--- a/libbalsa/mailbox_local.h
+++ b/libbalsa/mailbox_local.h
@@ -101,8 +101,7 @@ 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)
+const gchar *libbalsa_mailbox_local_get_path(LibBalsaMailboxLocal * local);
void libbalsa_mailbox_local_load_messages(LibBalsaMailbox * mailbox,
guint last_msgno);
diff --git a/libbalsa/mailbox_maildir.c b/libbalsa/mailbox_maildir.c
index 78e7f43..97f7524 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 315a085..f81e26c 100644
--- a/libbalsa/mailbox_mbox.c
+++ b/libbalsa/mailbox_mbox.c
@@ -225,7 +225,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) {
@@ -321,14 +321,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);
}
@@ -692,11 +694,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,
@@ -704,8 +707,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."));
@@ -742,7 +746,7 @@ libbalsa_mailbox_mbox_open(LibBalsaMailbox * mailbox, GError **err)
mbox->msgno_2_msg_info = g_ptr_array_new();
- mailbox->unread_messages = 0;
+ libbalsa_mailbox_clear_unread_messages(mailbox);
time(&t0);
if (st.st_size > 0) {
@@ -991,7 +995,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)) {
@@ -1088,7 +1092,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
@@ -1445,7 +1449,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)
@@ -1470,7 +1474,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;
@@ -1656,7 +1660,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 4ed62f1..f6a50ca 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 a8a7eab..d5230ab 100644
--- a/libbalsa/mailbox_pop3.c
+++ b/libbalsa/mailbox_pop3.c
@@ -45,13 +45,13 @@ static LibBalsaMailboxClass *parent_class = NULL;
struct _LibBalsaMailboxPop3Class {
LibBalsaMailboxRemoteClass klass;
- void (*config_changed) (LibBalsaMailboxPop3* mailbox);
+ void (*config_changed) (LibBalsaMailboxPop3* mailbox_pop3);
};
static void libbalsa_mailbox_pop3_dispose(GObject * object);
static void libbalsa_mailbox_pop3_class_init(LibBalsaMailboxPop3Class *
klass);
-static void libbalsa_mailbox_pop3_init(LibBalsaMailboxPop3 * mailbox);
+static void libbalsa_mailbox_pop3_init(LibBalsaMailboxPop3 * mailbox_pop3);
static gboolean libbalsa_mailbox_pop3_open(LibBalsaMailbox * mailbox,
GError **err);
@@ -117,17 +117,17 @@ libbalsa_mailbox_pop3_class_init(LibBalsaMailboxPop3Class * klass)
}
static void
-libbalsa_mailbox_pop3_init(LibBalsaMailboxPop3 * mailbox)
+libbalsa_mailbox_pop3_init(LibBalsaMailboxPop3 * mailbox_pop3)
{
LibBalsaMailboxRemote *remote;
- mailbox->check = FALSE;
- mailbox->delete_from_server = FALSE;
- mailbox->inbox = NULL;
- mailbox->msg_size_limit = -1;
-
- mailbox->filter = FALSE;
- mailbox->filter_cmd = NULL;
- remote = LIBBALSA_MAILBOX_REMOTE(mailbox);
+ mailbox_pop3->check = FALSE;
+ mailbox_pop3->delete_from_server = FALSE;
+ mailbox_pop3->inbox = NULL;
+ mailbox_pop3->msg_size_limit = -1;
+
+ mailbox_pop3->filter = FALSE;
+ mailbox_pop3->filter_cmd = NULL;
+ remote = LIBBALSA_MAILBOX_REMOTE(mailbox_pop3);
remote->server = libbalsa_server_new();
}
@@ -144,11 +144,11 @@ libbalsa_mailbox_pop3_dispose(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;
}
@@ -427,16 +427,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);
}
}
@@ -458,20 +468,21 @@ 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;
NetClientPop *pop;
GError *error = NULL;
guint allow_auth;
/* create the mailbox connection */
if (libbalsa_server_get_security(server) == NET_CLIENT_CRYPT_ENCRYPTED) {
- pop = net_client_pop_new(libbalsa_server_get_host(server), 995U,
libbalsa_server_get_security(server), mbox->enable_pipe);
+ pop = net_client_pop_new(libbalsa_server_get_host(server), 995U,
libbalsa_server_get_security(server), mailbox_pop3->enable_pipe);
} else {
- pop = net_client_pop_new(libbalsa_server_get_host(server), 110U,
libbalsa_server_get_security(server), mbox->enable_pipe);
+ pop = net_client_pop_new(libbalsa_server_get_host(server), 110U,
libbalsa_server_get_security(server), mailbox_pop3->enable_pipe);
}
if (pop == NULL) {
return NULL;
@@ -480,7 +491,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);
@@ -504,7 +515,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…"), libbalsa_server_get_host(server));
+ libbalsa_mailbox_progress_notify(mailbox, LIBBALSA_NTFY_INIT, INFINITY, _("Connecting %s…"),
libbalsa_server_get_host(server));
if (!net_client_pop_connect(pop, NULL, &error)) {
libbalsa_information(LIBBALSA_INFORMATION_ERROR, _("POP3 mailbox %s: cannot connect %s: %s"),
name, libbalsa_server_get_host(server),
error->message);
@@ -515,8 +526,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));
@@ -530,10 +541,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;
@@ -541,7 +552,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_username(server), "@",
libbalsa_server_get_host(server), NULL);
prefix_len = strlen(uid_prefix);
uids = mp_load_uids(uid_prefix);
@@ -558,7 +569,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);
@@ -569,7 +581,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));
@@ -590,7 +602,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;
@@ -614,19 +626,21 @@ 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_GET_SERVER(mbox);
+ server = LIBBALSA_MAILBOX_REMOTE_GET_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) {
@@ -642,7 +656,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 */
@@ -654,13 +669,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);
@@ -673,7 +688,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_username(server), "@",
libbalsa_server_get_host(server), NULL);
mp_save_uids(current_uids, uid_prefix, &err);
@@ -703,21 +718,21 @@ static void
libbalsa_mailbox_pop3_save_config(LibBalsaMailbox * mailbox,
const gchar * prefix)
{
- 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);
libbalsa_server_save_config(LIBBALSA_MAILBOX_REMOTE_GET_SERVER(mailbox));
- libbalsa_conf_set_bool("Check", pop->check);
- libbalsa_conf_set_bool("Delete", pop->delete_from_server);
- libbalsa_conf_set_bool("DisableApop", pop->disable_apop);
- libbalsa_conf_set_bool("EnablePipe", pop->enable_pipe);
- libbalsa_conf_set_bool("Filter", pop->filter);
- if(pop->filter_cmd)
- libbalsa_conf_set_string("FilterCmd", pop->filter_cmd);
+ libbalsa_conf_set_bool("Check", mailbox_pop3->check);
+ libbalsa_conf_set_bool("Delete", mailbox_pop3->delete_from_server);
+ libbalsa_conf_set_bool("DisableApop", mailbox_pop3->disable_apop);
+ libbalsa_conf_set_bool("EnablePipe", mailbox_pop3->enable_pipe);
+ libbalsa_conf_set_bool("Filter", mailbox_pop3->filter);
+ if(mailbox_pop3->filter_cmd)
+ libbalsa_conf_set_string("FilterCmd", mailbox_pop3->filter_cmd);
if (LIBBALSA_MAILBOX_CLASS(parent_class)->save_config)
LIBBALSA_MAILBOX_CLASS(parent_class)->save_config(mailbox, prefix);
@@ -728,22 +743,22 @@ static void
libbalsa_mailbox_pop3_load_config(LibBalsaMailbox * mailbox,
const gchar * prefix)
{
- 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);
libbalsa_server_load_config(LIBBALSA_MAILBOX_REMOTE_GET_SERVER(mailbox));
- pop->check = libbalsa_conf_get_bool("Check=false");
- pop->delete_from_server = libbalsa_conf_get_bool("Delete=false");
- pop->disable_apop = libbalsa_conf_get_bool("DisableApop=false");
- pop->enable_pipe = libbalsa_conf_get_bool("EnablePipe=false");
- pop->filter = libbalsa_conf_get_bool("Filter=false");
- pop->filter_cmd = libbalsa_conf_get_string("FilterCmd");
- if(pop->filter_cmd && *pop->filter_cmd == '\0') {
- g_free(pop->filter_cmd); pop->filter_cmd = NULL;
+ mailbox_pop3->check = libbalsa_conf_get_bool("Check=false");
+ mailbox_pop3->delete_from_server = libbalsa_conf_get_bool("Delete=false");
+ mailbox_pop3->disable_apop = libbalsa_conf_get_bool("DisableApop=false");
+ mailbox_pop3->enable_pipe = libbalsa_conf_get_bool("EnablePipe=false");
+ mailbox_pop3->filter = libbalsa_conf_get_bool("Filter=false");
+ mailbox_pop3->filter_cmd = libbalsa_conf_get_string("FilterCmd");
+ if (mailbox_pop3->filter_cmd != NULL && mailbox_pop3->filter_cmd[0] == '\0') {
+ g_free(mailbox_pop3->filter_cmd); mailbox_pop3->filter_cmd = NULL;
}
if (LIBBALSA_MAILBOX_CLASS(parent_class)->load_config)
@@ -754,18 +769,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 949eaf6..9eec27e 100644
--- a/libbalsa/message.c
+++ b/libbalsa/message.c
@@ -566,11 +566,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 e23703c..2850ab9 100644
--- a/libbalsa/send.c
+++ b/libbalsa/send.c
@@ -447,7 +447,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");
@@ -645,9 +645,9 @@ lbs_check_reachable_cb(GObject *object,
} else {
libbalsa_information(LIBBALSA_INFORMATION_WARNING,
_("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_smtp_server_get_name(smtp_server),
+ libbalsa_server_get_host(LIBBALSA_SERVER(smtp_server)),
+ libbalsa_mailbox_get_name(send_info->outbox));
}
if (!thread_started) {
@@ -938,20 +938,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 405c07f..4c4f2f6 100644
--- a/libinit_balsa/assistant_page_directory.c
+++ b/libinit_balsa/assistant_page_directory.c
@@ -139,14 +139,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 *url;
+
+ url = g_strdup_printf("file://%s", path);
+ libbalsa_mailbox_set_url(*box, url);
+ g_free(url);
+ }
+ unlink(tmp);
}
}
if ( *box == NULL) {
@@ -157,11 +161,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 1c10402..f34af91 100644
--- a/libinit_balsa/assistant_page_user.c
+++ b/libinit_balsa/assistant_page_user.c
@@ -207,7 +207,7 @@ create_pop3_mbx(const gchar *name, const gchar* host, gint security,
libbalsa_server_set_host(server, host, FALSE);
libbalsa_server_set_security(server, security);
libbalsa_server_set_remember_passwd(server, remember);
- mbx->name = g_strdup(name && *name ? name : host);
+ libbalsa_mailbox_set_name(mbx, name != NULL && name[0] != '\0' ? name : host);
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 3fd52b7..3d31060 100644
--- a/src/balsa-app.c
+++ b/src/balsa-app.c
@@ -72,7 +72,7 @@ ask_password_real(LibBalsaServer * server, LibBalsaMailbox * mbox)
prompt =
g_strdup_printf(_("Opening remote mailbox %s.\n"
"The _password for %s@%s:"),
- mbox->name, libbalsa_server_get_username(server),
libbalsa_server_get_host(server));
+ libbalsa_mailbox_get_name(mbox), libbalsa_server_get_username(server),
libbalsa_server_get_host(server));
else
prompt =
g_strdup_printf(_("_Password for %s@%s (%s):"), libbalsa_server_get_username(server),
@@ -627,7 +627,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;
}
@@ -697,9 +698,9 @@ balsa_get_short_mailbox_name(const gchar *url)
if ((mbnode = balsa_find_url(url)) && mbnode->mailbox) {
if (mbnode->server) {
return g_strconcat(libbalsa_server_get_host(mbnode->server), ":",
- mbnode->mailbox->name, NULL);
+ libbalsa_mailbox_get_name(mbnode->mailbox), NULL);
} else {
- return g_strdup(mbnode->mailbox->name);
+ return g_strdup(libbalsa_mailbox_get_name(mbnode->mailbox));
}
}
return g_strdup(url);
@@ -785,7 +786,7 @@ 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);
diff --git a/src/balsa-index.c b/src/balsa-index.c
index 5c1516c..51c1b9e 100644
--- a/src/balsa-index.c
+++ b/src/balsa-index.c
@@ -823,6 +823,7 @@ static gboolean
bndx_scroll_on_open_idle(BalsaIndex *index)
{
LibBalsaMailbox *mailbox;
+ guint msgno;
GtkTreeView *tree_view = GTK_TREE_VIEW(index);
GtkTreePath *path;
gpointer view_on_open;
@@ -832,9 +833,8 @@ 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 ((msgno = libbalsa_mailbox_get_first_unread(mailbox))) {
+ libbalsa_mailbox_set_first_unread(mailbox, 0);
if(!libbalsa_mailbox_msgno_find(mailbox, msgno, &path, NULL))
return FALSE; /* Oops! */
} else {
@@ -916,7 +916,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,
@@ -1375,6 +1375,7 @@ static gboolean
bndx_mailbox_changed_idle(BalsaIndex * bindex)
{
LibBalsaMailbox *mailbox;
+ guint msgno;
GtkTreePath *path;
if (bndx_clear_if_last_ref(&bindex))
@@ -1383,12 +1384,11 @@ 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,
- &path, NULL)) {
+ if ((msgno = libbalsa_mailbox_get_first_unread(mailbox)) > 0
+ && libbalsa_mailbox_msgno_find(mailbox, msgno, &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)) {
@@ -1905,6 +1905,7 @@ bndx_do_popup(BalsaIndex * index, const GdkEvent * event)
GtkWidget *submenu;
LibBalsaMailbox* mailbox;
gboolean any;
+ gboolean readonly;
gboolean any_deleted = FALSE;
gboolean any_not_deleted = FALSE;
GArray *selected = balsa_index_selected_msgnos_new(index);
@@ -1929,17 +1930,18 @@ bndx_do_popup(BalsaIndex * index, const GdkEvent * event)
GINT_TO_POINTER(any));
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
@@ -2068,6 +2070,7 @@ balsa_index_transfer(BalsaIndex *index, GArray * msgnos,
gboolean success;
LibBalsaMailbox *from_mailbox;
GError *e = NULL;
+ const gchar *to_mailbox_name;
if (msgnos->len == 0)
return;
@@ -2077,13 +2080,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_mailbox_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_mailbox_name, e ? e->message : "?");
return;
}
@@ -2093,7 +2097,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_mailbox_name);
if (!copy)
/* Note when message was flagged as deleted, for use in
* auto-expunge. */
@@ -2189,14 +2193,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 d3a4f12..db71f19 100644
--- a/src/balsa-mblist.c
+++ b/src/balsa-mblist.c
@@ -958,8 +958,8 @@ 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);
+ umd->notify = (libbalsa_mailbox_get_state(mailbox) == LB_MAILBOX_STATE_OPEN
+ || libbalsa_mailbox_get_state(mailbox) == LB_MAILBOX_STATE_CLOSED);
G_UNLOCK(mblist_update);
}
@@ -1254,7 +1254,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. */
@@ -1403,6 +1403,7 @@ bmbl_node_style(GtkTreeModel * model, GtkTreeIter * iter)
/* 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. */
+ name = libbalsa_mailbox_get_name(mailbox);
if (unread_messages > 0) {
gboolean display_info;
@@ -1411,17 +1412,14 @@ bmbl_node_style(GtkTreeModel * model, GtkTreeIter * iter)
display_info = GPOINTER_TO_INT(g_object_get_data
(G_OBJECT(model),
BALSA_MBLIST_DISPLAY_INFO));
- name = (!display_info && total_messages >= 0) ?
- (tmp = g_strdup_printf("%s (%d)", mailbox->name,
- unread_messages))
- : mailbox->name;
+ if (!display_info && total_messages >= 0)
+ name = tmp = g_strdup_printf("%s (%d)", name, unread_messages);
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;
weight = PANGO_WEIGHT_NORMAL;
mbnode->style &= ~MBNODE_STYLE_NEW_MAIL;
}
@@ -1666,7 +1664,8 @@ 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 != NULL ?
+ 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,
@@ -1835,7 +1834,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 94a2d9a..7a163d1 100644
--- a/src/balsa-message.c
+++ b/src/balsa-message.c
@@ -1094,7 +1094,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;
}
@@ -1106,7 +1106,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;
}
@@ -1160,7 +1160,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);
@@ -1571,7 +1571,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/balsa-mime-widget-text.c b/src/balsa-mime-widget-text.c
index 2acf011..d3eaf00 100644
--- a/src/balsa-mime-widget-text.c
+++ b/src/balsa-mime-widget-text.c
@@ -782,9 +782,8 @@ check_call_url(GtkGestureMultiPress *multi_press,
gesture = GTK_GESTURE(multi_press);
event = gtk_gesture_get_last_event(gesture, gtk_gesture_get_last_updated_sequence(gesture));
- g_return_if_fail(event != NULL);
- if (!gdk_event_get_state(event, &state)) {
+ if (event == NULL || !gdk_event_get_state(event, &state)) {
return;
}
diff --git a/src/filter-edit-callbacks.c b/src/filter-edit-callbacks.c
index 6d63d85..ddc4a93 100644
--- a/src/filter-edit-callbacks.c
+++ b/src/filter-edit-callbacks.c
@@ -1327,6 +1327,7 @@ update_filters_mailbox(GtkTreeModel * model, GtkTreePath * path,
BalsaMailboxNode *mbnode;
LibBalsaMailbox *mailbox;
gchar *tmp;
+ const gchar *url;
gtk_tree_model_get(model, iter, 0, &mbnode, -1);
mailbox = mbnode->mailbox;
@@ -1335,13 +1336,14 @@ update_filters_mailbox(GtkTreeModel * model, GtkTreePath * path,
return FALSE;
/* First we free the filters list (which is now obsolete) */
- libbalsa_clear_slist(&mailbox->filters, g_free);
+ 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);
+ url = libbalsa_mailbox_get_url(mailbox);
+ tmp = mailbox_filters_section_lookup(url != NULL ? url :
+ libbalsa_mailbox_get_name(mailbox));
if (tmp) {
gchar **filters_names = NULL;
gboolean def;
diff --git a/src/filter-run-callbacks.c b/src/filter-run-callbacks.c
index 8b355f0..cf510fb 100644
--- a/src/filter-run-callbacks.c
+++ b/src/filter-run-callbacks.c
@@ -146,8 +146,9 @@ 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;
}
@@ -209,7 +210,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);
}
@@ -233,7 +234,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);
}
@@ -255,7 +256,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
@@ -269,7 +270,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 =
@@ -297,7 +298,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,
@@ -307,7 +308,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 eafda90..83ba204 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);
@@ -194,18 +195,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);
}
@@ -495,7 +497,8 @@ filters_run_dialog(LibBalsaMailbox * mbox,
/* We look for an existing dialog box for this mailbox */
for (lst = fr_dialogs_opened; lst != NULL; lst = lst->next) {
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 ff11dd9..43daaaf 100644
--- a/src/folder-conf.c
+++ b/src/folder-conf.c
@@ -69,7 +69,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 */
};
@@ -774,7 +774,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);
} else {
/* create */
sdd->old_folder = NULL;
@@ -871,20 +871,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 faef9e5..eeae7a1 100644
--- a/src/mailbox-conf.c
+++ b/src/mailbox-conf.c
@@ -436,7 +436,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;
}
@@ -454,13 +454,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,
@@ -476,7 +477,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,
@@ -492,7 +493,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,
@@ -512,7 +513,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);
@@ -522,7 +523,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),
@@ -737,11 +739,11 @@ mailbox_conf_set_values(MailboxConfWindow *mcw)
g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
- if (mcw->mailbox_name && mailbox->name)
- gtk_entry_set_text(GTK_ENTRY(mcw->mailbox_name), mailbox->name);
+ if (mcw->mailbox_name && libbalsa_mailbox_get_name(mailbox))
+ gtk_entry_set_text(GTK_ENTRY(mcw->mailbox_name), libbalsa_mailbox_get_name(mailbox));
if (LIBBALSA_IS_MAILBOX_LOCAL(mailbox)) {
- if (mailbox->url) {
+ if (libbalsa_mailbox_get_url(mailbox)) {
GtkFileChooser *chooser = GTK_FILE_CHOOSER(mcw->window);
LibBalsaMailboxLocal *local = LIBBALSA_MAILBOX_LOCAL(mailbox);
const gchar *path = libbalsa_mailbox_local_get_path(local);
@@ -897,10 +899,8 @@ update_pop_mailbox(MailboxConfWindow *mcw)
bsc = &mcw->mb_data.pop3.bsc;
/* basic data */
- g_free(LIBBALSA_MAILBOX(mailbox)->name);
- LIBBALSA_MAILBOX(mailbox)->name =
- gtk_editable_get_chars(GTK_EDITABLE(mcw->mailbox_name), 0, -1);
-
+ libbalsa_mailbox_set_name((LibBalsaMailbox *) mailbox,
+ gtk_entry_get_text(GTK_ENTRY(mcw->mailbox_name)));
libbalsa_server_set_host(server, gtk_entry_get_text(GTK_ENTRY(mcw->mb_data.pop3.bsc.server)), FALSE);
libbalsa_server_set_security(server,
gtk_combo_box_get_active(GTK_COMBO_BOX(mcw->mb_data.pop3.security)) + 1);
@@ -935,6 +935,7 @@ static void
update_imap_mailbox(MailboxConfWindow *mcw)
{
gchar *path;
+ gchar *name = NULL;
LibBalsaMailboxImap *mailbox;
LibBalsaServer* server;
@@ -948,8 +949,9 @@ update_imap_mailbox(MailboxConfWindow *mcw)
G_CALLBACK(config_mailbox_update),
mailbox);
}
- g_free(LIBBALSA_MAILBOX(mailbox)->name);
- fill_in_imap_data(mcw, &LIBBALSA_MAILBOX(mailbox)->name, &path);
+ fill_in_imap_data(mcw, &name, &path);
+ libbalsa_mailbox_set_name((LibBalsaMailbox *) mailbox, name);
+ g_free(name);
libbalsa_server_set_username(server,
gtk_entry_get_text(GTK_ENTRY
(mcw->mb_data.imap.username)));
@@ -1008,8 +1010,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;
@@ -1046,13 +1049,12 @@ mailbox_conf_update(MailboxConfWindow *mcw)
name = mcw->mailbox_name ?
gtk_editable_get_chars(GTK_EDITABLE(mcw->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);
@@ -1065,7 +1067,7 @@ mailbox_conf_update(MailboxConfWindow *mcw)
return;
}
- if (mailbox->config_prefix)
+ if (libbalsa_mailbox_get_config_prefix(mailbox) != NULL)
config_mailbox_update(mailbox);
if (LIBBALSA_IS_MAILBOX_POP3(mcw->mailbox))
@@ -1088,9 +1090,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);
@@ -1102,7 +1104,9 @@ mailbox_conf_add(MailboxConfWindow * mcw)
!libbalsa_path_is_below_dir(path,
balsa_app.local_mail_directory);
printf("Save to config: %d\n", save_to_config);
- mcw->mailbox->name = g_path_get_basename(path);
+ basename = g_path_get_basename(path);
+ libbalsa_mailbox_set_name(mcw->mailbox, basename);
+ g_free(basename);
g_free(path);
balsa_mailbox_local_append(mcw->mailbox);
@@ -1201,7 +1205,8 @@ create_local_mailbox_dialog(MailboxConfWindow *mcw)
grid = libbalsa_create_grid();
/* mailbox name */
- if(mcw->mailbox && mcw->mailbox->config_prefix) {
+ if (mcw->mailbox != NULL &&
+ libbalsa_mailbox_get_config_prefix(mcw->mailbox) != NULL) {
label = libbalsa_create_grid_label(_("_Mailbox Name:"), grid, ++row);
mcw->mailbox_name =
libbalsa_create_grid_entry(grid,
@@ -1627,6 +1632,7 @@ mailbox_conf_view_check(BalsaMailboxConfView * view_info,
LibBalsaMailbox * mailbox)
{
gboolean changed;
+ LibBalsaMailboxView *view;
GtkComboBox *combo_box;
GtkTreeIter iter;
gint active;
@@ -1637,12 +1643,13 @@ mailbox_conf_view_check(BalsaMailboxConfView * view_info,
changed = FALSE;
- libbalsa_mailbox_view_free(mailbox->view);
- g_print("%s set view on %s\n", __func__, mailbox->name);
- mailbox->view = config_load_mailbox_view(mailbox->url);
- if (!mailbox->view) {
+ g_print("%s set view on %s\n", __func__, libbalsa_mailbox_get_name(mailbox));
+ view = config_load_mailbox_view(libbalsa_mailbox_get_url(mailbox));
+ if (view != NULL) {
+ libbalsa_mailbox_set_view(mailbox, view);
+ } else {
/* The mailbox may not have its URL yet */
- mailbox->view = libbalsa_mailbox_view_new();
+ libbalsa_mailbox_set_view(mailbox, libbalsa_mailbox_view_new());
}
combo_box = GTK_COMBO_BOX(view_info->identity_combo_box);
diff --git a/src/mailbox-node.c b/src/mailbox-node.c
index fcaf96e..f1bbe64 100644
--- a/src/mailbox-node.c
+++ b/src/mailbox-node.c
@@ -195,7 +195,7 @@ balsa_mailbox_node_dispose(GObject * object)
if (mailbox != NULL) {
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 +402,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
@@ -430,10 +432,10 @@ imap_scan_attach_mailbox(BalsaMailboxNode * mbnode, imap_scan_item * isi)
libbalsa_mailbox_imap_set_path(m, isi->fn);
if(balsa_app.debug)
printf("imap_scan_attach_mailbox: add mbox of name %s "
- "(full path %s)\n", isi->fn, mailbox->url);
+ "(full path %s)\n", isi->fn, libbalsa_mailbox_get_url(mailbox));
/* avoid allocating the name again: */
- mailbox->name = mbnode->name;
- mbnode->name = NULL;
+ libbalsa_mailbox_set_name(mailbox, mbnode->name);
+ g_clear_pointer(&mbnode->name, g_free);
mbnode->mailbox = mailbox;
load_mailbox_view(mbnode);
if (isi->special) {
@@ -443,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;
@@ -562,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);
@@ -735,7 +738,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);
@@ -882,17 +885,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);
@@ -1175,15 +1180,25 @@ remove_special_mailbox_by_url(const gchar* url, LibBalsaMailbox *** special)
{
LibBalsaMailbox **mailbox;
- if (balsa_app.trash && strcmp(url, balsa_app.trash->url) == 0)
+ if (balsa_app.trash && strcmp(url,
+ libbalsa_mailbox_get_url(balsa_app.trash))
+ == 0)
mailbox = &balsa_app.trash;
- else if (balsa_app.inbox && strcmp(url, balsa_app.inbox->url) == 0)
+ else if (balsa_app.inbox && strcmp(url,
+ libbalsa_mailbox_get_url(balsa_app.inbox))
+ == 0)
mailbox = &balsa_app.inbox;
- else if (balsa_app.outbox && strcmp(url, balsa_app.outbox->url) == 0)
+ else if (balsa_app.outbox && strcmp(url,
+ libbalsa_mailbox_get_url(balsa_app.outbox))
+ == 0)
mailbox = &balsa_app.outbox;
- else if (balsa_app.sentbox && strcmp(url, balsa_app.sentbox->url) == 0)
+ else if (balsa_app.sentbox && strcmp(url,
+ libbalsa_mailbox_get_url(balsa_app.sentbox))
+ == 0)
mailbox = &balsa_app.sentbox;
- else if (balsa_app.draftbox && strcmp(url, balsa_app.draftbox->url) == 0)
+ else if (balsa_app.draftbox && strcmp(url,
+ libbalsa_mailbox_get_url(balsa_app.draftbox))
+ == 0)
mailbox = &balsa_app.draftbox;
else
mailbox = NULL;
@@ -1232,13 +1247,13 @@ add_local_mailbox(BalsaMailboxNode *root, const gchar * name,
printf("Not accessible mailbox %s\n", 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 c872a8c..13b9c92 100644
--- a/src/main-window.c
+++ b/src/main-window.c
@@ -2453,7 +2453,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);
@@ -2509,7 +2509,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);
@@ -2761,7 +2762,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: */
@@ -2792,7 +2793,7 @@ bw_notebook_label_new(BalsaMailboxNode * mbnode)
G_CALLBACK(bw_mailbox_tab_close_cb), mbnode);
gtk_box_pack_start(GTK_BOX(box), but);
- gtk_widget_set_tooltip_text(box, mbnode->mailbox->url);
+ gtk_widget_set_tooltip_text(box, libbalsa_mailbox_get_url(mbnode->mailbox));
return box;
}
@@ -2948,7 +2949,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);
@@ -3178,7 +3179,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);
}
@@ -3235,7 +3236,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);
}
@@ -3373,10 +3374,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;
@@ -3384,8 +3385,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 */
@@ -3395,7 +3396,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;
@@ -3403,12 +3404,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();
@@ -4192,12 +4193,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);
@@ -4223,7 +4224,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
@@ -4677,19 +4678,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". */
@@ -4754,13 +4755,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 77746dd..8c202f1 100644
--- a/src/main.c
+++ b/src/main.c
@@ -173,7 +173,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);
@@ -188,7 +188,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;
@@ -200,9 +200,12 @@ balsa_get_stats(long *unread, long *unsent)
if(balsa_app.inbox && libbalsa_mailbox_open(balsa_app.inbox, NULL) ) {
/* set threading type to load messages */
+ LibBalsaMailboxView *view;
+
+ view = libbalsa_mailbox_get_view(balsa_app.inbox);
libbalsa_mailbox_set_threading(balsa_app.inbox,
- balsa_app.inbox->view->threading_type);
- *unread = balsa_app.inbox->unread_messages;
+ view->threading_type);
+ *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)){
@@ -265,7 +268,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);
}
@@ -295,7 +298,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) {
@@ -348,7 +351,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 fa55c31..4fcc744 100644
--- a/src/message-window.c
+++ b/src/message-window.c
@@ -319,7 +319,8 @@ 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 != NULL &&
+ libbalsa_mailbox_get_unread_messages(index->mailbox_node->mailbox) > 0;
mw_set_enabled(mw, "next-unread", enable);
enable = index
@@ -885,7 +886,7 @@ 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);
}
diff --git a/src/pref-manager.c b/src/pref-manager.c
index 294a92d..d71c964 100644
--- a/src/pref-manager.c
+++ b/src/pref-manager.c
@@ -332,7 +332,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;
@@ -961,7 +964,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) {
@@ -969,7 +972,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
@@ -3557,7 +3560,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 5bc287f..b01e085 100644
--- a/src/save-restore.c
+++ b/src/save-restore.c
@@ -70,12 +70,19 @@ static void config_filters_load(void);
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;
+
+ config_prefix = libbalsa_mailbox_get_config_prefix(LIBBALSA_MAILBOX(mailbox));
+
+ return config_prefix != NULL ? g_strdup(config_prefix) :
+ config_get_unused_group(MAILBOX_SECTION_PREFIX);
+}
-gint config_load(void)
+gint
+config_load(void)
{
return config_global_load();
}
@@ -187,17 +194,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);
@@ -209,8 +218,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;
@@ -223,7 +231,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;
@@ -309,7 +318,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;
@@ -406,7 +416,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)
@@ -1922,11 +1932,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);
@@ -1938,7 +1952,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 adc2c92..26419eb 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 fa3b982..60b8282 100644
--- a/src/sendmsg-window.c
+++ b/src/sendmsg-window.c
@@ -480,8 +480,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);
}
@@ -2582,8 +2585,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 */
@@ -5236,7 +5240,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]
