[balsa/wip/gtk4: 256/351] Uncrustify mailbox.[ch]
- From: Peter Bloomfield <peterb src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [balsa/wip/gtk4: 256/351] Uncrustify mailbox.[ch]
- Date: Wed, 23 May 2018 21:38:29 +0000 (UTC)
commit 37fe2a6741486d592967aae1b01ee23b5c0cd37b
Author: Peter Bloomfield <PeterBloomfield bellsouth net>
Date: Mon Mar 26 13:47:10 2018 -0400
Uncrustify mailbox.[ch]
libbalsa/mailbox.c | 2504 +++++++++++++++++++++++++++++++---------------------
libbalsa/mailbox.h | 701 ++++++++-------
2 files changed, 1883 insertions(+), 1322 deletions(-)
---
diff --git a/libbalsa/mailbox.c b/libbalsa/mailbox.c
index a4209f4..8c7228d 100644
--- a/libbalsa/mailbox.c
+++ b/libbalsa/mailbox.c
@@ -5,20 +5,20 @@
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
+ * the Free Software Foundation; either version 2, or (at your option)
* any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#if defined(HAVE_CONFIG_H) && HAVE_CONFIG_H
-# include "config.h"
+# include "config.h"
#endif /* HAVE_CONFIG_H */
#include <ctype.h>
@@ -39,31 +39,31 @@
#include <glib/gi18n.h>
/* Class functions */
-static void libbalsa_mailbox_class_init(LibBalsaMailboxClass * klass);
-static void libbalsa_mailbox_init(LibBalsaMailbox * mailbox);
-static void libbalsa_mailbox_dispose(GObject * object);
-static void libbalsa_mailbox_finalize(GObject * object);
-
-static void libbalsa_mailbox_real_release_message (LibBalsaMailbox * mailbox,
- LibBalsaMessage * message);
-static gboolean
-libbalsa_mailbox_real_messages_copy(LibBalsaMailbox * mailbox,
- GArray * msgnos,
- LibBalsaMailbox * dest, GError **err);
-static gboolean libbalsa_mailbox_real_can_do(LibBalsaMailbox* mbox,
+static void libbalsa_mailbox_class_init(LibBalsaMailboxClass *klass);
+static void libbalsa_mailbox_init(LibBalsaMailbox *mailbox);
+static void libbalsa_mailbox_dispose(GObject *object);
+static void libbalsa_mailbox_finalize(GObject *object);
+
+static void libbalsa_mailbox_real_release_message(LibBalsaMailbox *mailbox,
+ LibBalsaMessage *message);
+static gboolean libbalsa_mailbox_real_messages_copy(LibBalsaMailbox *mailbox,
+ GArray *msgnos,
+ LibBalsaMailbox *dest,
+ GError **err);
+static gboolean libbalsa_mailbox_real_can_do(LibBalsaMailbox *mbox,
enum LibBalsaMailboxCapability c);
-static void libbalsa_mailbox_real_sort(LibBalsaMailbox* mbox,
- GArray *sort_array);
-static gboolean libbalsa_mailbox_real_can_match(LibBalsaMailbox *mailbox,
+static void libbalsa_mailbox_real_sort(LibBalsaMailbox *mbox,
+ GArray *sort_array);
+static gboolean libbalsa_mailbox_real_can_match(LibBalsaMailbox *mailbox,
LibBalsaCondition *condition);
-static void libbalsa_mailbox_real_save_config(LibBalsaMailbox * mailbox,
- const gchar * group);
-static void libbalsa_mailbox_real_load_config(LibBalsaMailbox * mailbox,
- const gchar * group);
-static gboolean libbalsa_mailbox_real_close_backend (LibBalsaMailbox *
- mailbox);
-static void libbalsa_mailbox_real_lock_store(LibBalsaMailbox * mailbox,
- gboolean lock);
+static void libbalsa_mailbox_real_save_config(LibBalsaMailbox *mailbox,
+ const gchar *group);
+static void libbalsa_mailbox_real_load_config(LibBalsaMailbox *mailbox,
+ const gchar *group);
+static gboolean libbalsa_mailbox_real_close_backend(LibBalsaMailbox *
+ mailbox);
+static void libbalsa_mailbox_real_lock_store(LibBalsaMailbox *mailbox,
+ gboolean lock);
/* SIGNALS MEANINGS :
- CHANGED: notification signal sent by the mailbox to allow the
@@ -73,7 +73,7 @@ static void libbalsa_mailbox_real_lock_store(LibBalsaMailbox * mailbox,
Also when the unread message count might have changed.
- MESSAGE_EXPUNGED: sent when a message is expunged. This signal is
used to update lists of msgnos when messages are renumbered.
-*/
+ */
enum {
CHANGED,
@@ -96,26 +96,26 @@ static guint libbalsa_mailbox_signals[LAST_SIGNAL];
static guint libbalsa_mbox_model_signals[LAST_MODEL_SIGNAL];
/* GtkTreeModel function prototypes */
-static void mbox_model_init(GtkTreeModelIface *iface);
+static void mbox_model_init(GtkTreeModelIface *iface);
/* GtkTreeDragSource function prototypes */
-static void mbox_drag_source_init(GtkTreeDragSourceIface *iface);
+static void mbox_drag_source_init(GtkTreeDragSourceIface *iface);
/* GtkTreeSortable function prototypes */
-static void mbox_sortable_init(GtkTreeSortableIface *iface);
+static void mbox_sortable_init(GtkTreeSortableIface *iface);
typedef struct _LibBalsaMailboxPrivate LibBalsaMailboxPrivate;
struct _LibBalsaMailboxPrivate {
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;
-
+
GRecMutex rec_mutex;
gboolean is_directory;
@@ -128,8 +128,8 @@ struct _LibBalsaMailboxPrivate {
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
+ 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
@@ -142,7 +142,7 @@ struct _LibBalsaMailboxPrivate {
* used for automatical scrolling down on opening.
*/
/* Associated filters (struct mailbox_filter) */
- GSList * filters;
+ GSList *filters;
gboolean filters_loaded;
LibBalsaMailboxView *view;
@@ -174,10 +174,10 @@ G_DEFINE_TYPE_WITH_CODE(LibBalsaMailbox,
G_IMPLEMENT_INTERFACE(GTK_TYPE_TREE_SORTABLE,
mbox_sortable_init)
G_ADD_PRIVATE(LibBalsaMailbox)
- )
+ )
static void
-libbalsa_mailbox_class_init(LibBalsaMailboxClass * klass)
+libbalsa_mailbox_class_init(LibBalsaMailboxClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
@@ -186,7 +186,7 @@ libbalsa_mailbox_class_init(LibBalsaMailboxClass * klass)
/* This signal is emitted by the mailbox when new messages are
retrieved (check mail or opening of the mailbox). This is used
by GUI to sync on the mailbox content (see BalsaIndex)
- */
+ */
libbalsa_mailbox_signals[CHANGED] =
g_signal_new("changed",
G_TYPE_FROM_CLASS(object_class),
@@ -216,44 +216,45 @@ libbalsa_mailbox_class_init(LibBalsaMailboxClass * klass)
libbalsa_VOID__INT_DOUBLE_STRING, G_TYPE_NONE,
3U, G_TYPE_INT, G_TYPE_DOUBLE, G_TYPE_STRING);
- object_class->dispose = libbalsa_mailbox_dispose;
+ object_class->dispose = libbalsa_mailbox_dispose;
object_class->finalize = libbalsa_mailbox_finalize;
/* Signals */
- klass->progress_notify = NULL;
- klass->changed = NULL;
+ klass->progress_notify = NULL;
+ klass->changed = NULL;
klass->message_expunged = NULL;
/* Virtual functions */
- klass->open_mailbox = NULL;
- klass->close_mailbox = NULL;
- klass->get_message = NULL;
- klass->prepare_threading = NULL;
+ klass->open_mailbox = NULL;
+ klass->close_mailbox = NULL;
+ klass->get_message = NULL;
+ klass->prepare_threading = NULL;
klass->fetch_message_structure = NULL;
klass->fetch_headers = NULL;
- klass->release_message = libbalsa_mailbox_real_release_message;
- klass->get_message_part = NULL;
- klass->get_message_stream = NULL;
- klass->messages_change_flags = NULL;
- klass->messages_copy = libbalsa_mailbox_real_messages_copy;
- klass->can_do = libbalsa_mailbox_real_can_do;
- klass->set_threading = NULL;
- klass->update_view_filter = NULL;
- klass->sort = libbalsa_mailbox_real_sort;
- klass->check = NULL;
- klass->message_match = NULL;
- klass->can_match = libbalsa_mailbox_real_can_match;
- klass->save_config = libbalsa_mailbox_real_save_config;
- klass->load_config = libbalsa_mailbox_real_load_config;
- klass->close_backend = libbalsa_mailbox_real_close_backend;
- klass->total_messages = NULL;
- klass->duplicate_msgnos = NULL;
- klass->lock_store = libbalsa_mailbox_real_lock_store;
- klass->test_can_reach = NULL;
+ klass->release_message = libbalsa_mailbox_real_release_message;
+ klass->get_message_part = NULL;
+ klass->get_message_stream = NULL;
+ klass->messages_change_flags = NULL;
+ klass->messages_copy = libbalsa_mailbox_real_messages_copy;
+ klass->can_do = libbalsa_mailbox_real_can_do;
+ klass->set_threading = NULL;
+ klass->update_view_filter = NULL;
+ klass->sort = libbalsa_mailbox_real_sort;
+ klass->check = NULL;
+ klass->message_match = NULL;
+ klass->can_match = libbalsa_mailbox_real_can_match;
+ klass->save_config = libbalsa_mailbox_real_save_config;
+ klass->load_config = libbalsa_mailbox_real_load_config;
+ klass->close_backend = libbalsa_mailbox_real_close_backend;
+ klass->total_messages = NULL;
+ klass->duplicate_msgnos = NULL;
+ klass->lock_store = libbalsa_mailbox_real_lock_store;
+ klass->test_can_reach = NULL;
}
+
static void
-libbalsa_mailbox_init(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_init(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -261,18 +262,18 @@ libbalsa_mailbox_init(LibBalsaMailbox * mailbox)
priv->is_directory = FALSE;
priv->config_prefix = NULL;
- priv->name = NULL;
- priv->url = NULL;
+ priv->name = NULL;
+ priv->url = NULL;
- priv->open_ref = 0;
+ priv->open_ref = 0;
priv->has_unread_messages = FALSE;
- priv->unread_messages = 0;
+ priv->unread_messages = 0;
priv->readonly = FALSE;
- priv->filters=NULL;
+ priv->filters = NULL;
priv->filters_loaded = FALSE;
- priv->view=NULL;
+ priv->view = NULL;
/* priv->stamp is incremented before we use it, so it won't be
* zero for a long, long time... */
priv->stamp = g_random_int() / 2;
@@ -280,6 +281,7 @@ libbalsa_mailbox_init(LibBalsaMailbox * mailbox)
priv->no_reassemble = FALSE;
}
+
/*
* libbalsa_mailbox_dispose:
*
@@ -287,19 +289,22 @@ libbalsa_mailbox_init(LibBalsaMailbox * mailbox)
* decremented to 0
*/
-static void lbm_get_index_entry_expunged_cb(LibBalsaMailbox * mailbox, guint seqno);
-static void lbm_msgno_changed_expunged_cb(LibBalsaMailbox * mailbox, guint seqno);
+static void lbm_get_index_entry_expunged_cb(LibBalsaMailbox *mailbox,
+ guint seqno);
+static void lbm_msgno_changed_expunged_cb(LibBalsaMailbox *mailbox,
+ guint seqno);
static void
-libbalsa_mailbox_dispose(GObject * object)
+libbalsa_mailbox_dispose(GObject *object)
{
- LibBalsaMailbox *mailbox = LIBBALSA_MAILBOX(object);
+ LibBalsaMailbox *mailbox = LIBBALSA_MAILBOX(object);
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
g_rec_mutex_clear(&priv->rec_mutex);
- while (priv->open_ref > 0)
+ while (priv->open_ref > 0) {
libbalsa_mailbox_close(mailbox, FALSE);
+ }
if (priv->msgnos_pending != NULL) {
g_signal_handlers_disconnect_by_func(mailbox,
@@ -325,24 +330,25 @@ libbalsa_mailbox_dispose(GObject * object)
}
-static gchar*
+static gchar *
get_from_field(LibBalsaMessage *message)
{
- LibBalsaMailbox *mailbox = message->mailbox;
- LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+ 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;
+ const gchar *name_str = NULL;
+ gboolean append_dots = FALSE;
gchar *from;
g_return_val_if_fail(message->mailbox, NULL);
if (message->headers) {
if (priv->view &&
- priv->view->show == LB_MAILBOX_SHOW_TO)
+ (priv->view->show == LB_MAILBOX_SHOW_TO)) {
address_list = message->headers->to_list;
- else
+ } else {
address_list = message->headers->from;
+ }
}
if (address_list) {
@@ -353,12 +359,14 @@ get_from_field(LibBalsaMessage *message)
internet_address_list_get_address(address_list, i);
if (ia->name && *ia->name) {
name_str = ia->name;
- if (i < len - 1)
+ if (i < len - 1) {
append_dots = TRUE;
+ }
} else if (INTERNET_ADDRESS_IS_MAILBOX(ia)) {
name_str = ((InternetAddressMailbox *) ia)->addr;
- if (i < len - 1)
+ if (i < len - 1) {
append_dots = TRUE;
+ }
} else {
InternetAddressGroup *g = (InternetAddressGroup *) ia;
gint gi, glen =
@@ -368,61 +376,65 @@ get_from_field(LibBalsaMessage *message)
internet_address_list_get_address(g->members, gi);
if (ia2->name && *ia2->name) {
name_str = ia2->name;
- if (gi < glen - 1)
+ if (gi < glen - 1) {
append_dots = TRUE;
+ }
} else if (INTERNET_ADDRESS_IS_MAILBOX(ia2)) {
name_str = ((InternetAddressMailbox *) ia2)->addr;
- if (gi < glen - 1)
+ if (gi < glen - 1) {
append_dots = TRUE;
+ }
}
}
}
}
}
- if (name_str == NULL)
+ if (name_str == NULL) {
name_str = "";
- from = append_dots ? g_strconcat(name_str, ",…", NULL)
- : g_strdup(name_str);
+ }
+ from = append_dots ? g_strconcat(name_str, ",…", NULL) : g_strdup(name_str);
libbalsa_utf8_sanitize(&from, TRUE, NULL);
return from;
}
+
static void
-lbm_index_entry_populate_from_msg(LibBalsaMailboxIndexEntry * entry,
- LibBalsaMessage * msg)
-{
- entry->from = get_from_field(msg);
- entry->subject = g_strdup(LIBBALSA_MESSAGE_GET_SUBJECT(msg));
- entry->msg_date = msg->headers->date;
- entry->internal_date = 0; /* FIXME */
- entry->status_icon = libbalsa_get_icon_from_flags(msg->flags);
- entry->attach_icon = libbalsa_message_get_attach_icon(msg);
- entry->size = msg->length;
+lbm_index_entry_populate_from_msg(LibBalsaMailboxIndexEntry *entry,
+ LibBalsaMessage *msg)
+{
+ entry->from = get_from_field(msg);
+ entry->subject = g_strdup(LIBBALSA_MESSAGE_GET_SUBJECT(msg));
+ entry->msg_date = msg->headers->date;
+ entry->internal_date = 0; /* FIXME */
+ entry->status_icon = libbalsa_get_icon_from_flags(msg->flags);
+ entry->attach_icon = libbalsa_message_get_attach_icon(msg);
+ entry->size = msg->length;
entry->foreground = NULL;
entry->background = NULL;
entry->foreground_set = 0;
entry->background_set = 0;
- entry->unseen = LIBBALSA_MESSAGE_IS_UNREAD(msg);
- entry->idle_pending = 0;
+ entry->unseen = LIBBALSA_MESSAGE_IS_UNREAD(msg);
+ entry->idle_pending = 0;
libbalsa_mailbox_msgno_changed(msg->mailbox, msg->msgno);
}
-static LibBalsaMailboxIndexEntry*
+
+static LibBalsaMailboxIndexEntry *
lbm_index_entry_new_pending(void)
{
- LibBalsaMailboxIndexEntry *entry = g_new(LibBalsaMailboxIndexEntry,1);
+ LibBalsaMailboxIndexEntry *entry = g_new(LibBalsaMailboxIndexEntry, 1);
entry->idle_pending = 1;
return entry;
}
+
static void
lbm_index_entry_free(LibBalsaMailboxIndexEntry *entry)
{
- if(entry) {
- if (!entry->idle_pending)
- {
+ if (entry != NULL) {
+ if (!entry->idle_pending) {
g_free(entry->from);
g_free(entry->subject);
}
@@ -430,8 +442,10 @@ lbm_index_entry_free(LibBalsaMailboxIndexEntry *entry)
}
}
+
void
-libbalsa_mailbox_index_entry_clear(LibBalsaMailbox * mailbox, guint msgno)
+libbalsa_mailbox_index_entry_clear(LibBalsaMailbox *mailbox,
+ guint msgno)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -440,7 +454,7 @@ libbalsa_mailbox_index_entry_clear(LibBalsaMailbox * mailbox, guint msgno)
if (msgno <= priv->mindex->len) {
LibBalsaMailboxIndexEntry **entry = (LibBalsaMailboxIndexEntry **)
- & g_ptr_array_index(priv->mindex, msgno - 1);
+ &g_ptr_array_index(priv->mindex, msgno - 1);
lbm_index_entry_free(*entry);
*entry = NULL;
@@ -448,36 +462,40 @@ libbalsa_mailbox_index_entry_clear(LibBalsaMailbox * mailbox, guint msgno)
}
}
+
#define VALID_ENTRY(entry) \
((entry) && !((LibBalsaMailboxIndexEntry *) (entry))->idle_pending)
void
-libbalsa_mailbox_index_set_flags(LibBalsaMailbox *mailbox,
- unsigned msgno, LibBalsaMessageFlag f)
+libbalsa_mailbox_index_set_flags(LibBalsaMailbox *mailbox,
+ unsigned msgno,
+ LibBalsaMessageFlag f)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
LibBalsaMailboxIndexEntry *entry;
- if (msgno > priv->mindex->len)
+ if (msgno > priv->mindex->len) {
return;
+ }
- entry = g_ptr_array_index(priv->mindex, msgno-1);
+ entry = g_ptr_array_index(priv->mindex, msgno - 1);
if (VALID_ENTRY(entry)) {
- entry->status_icon =
+ entry->status_icon =
libbalsa_get_icon_from_flags(f);
entry->unseen = f & LIBBALSA_MESSAGE_FLAG_NEW;
libbalsa_mailbox_msgno_changed(mailbox, msgno);
}
}
+
/* libbalsa_mailbox_finalize:
destroys mailbox.
-*/
+ */
static void
-libbalsa_mailbox_finalize(GObject * object)
+libbalsa_mailbox_finalize(GObject *object)
{
- LibBalsaMailbox *mailbox = (LibBalsaMailbox *) object;
+ LibBalsaMailbox *mailbox = (LibBalsaMailbox *) object;
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
@@ -496,9 +514,10 @@ libbalsa_mailbox_finalize(GObject * object)
G_OBJECT_CLASS(parent_class)->finalize(object);
}
+
/* Create a new mailbox by loading it from a config entry... */
LibBalsaMailbox *
-libbalsa_mailbox_new_from_config(const gchar * group)
+libbalsa_mailbox_new_from_config(const gchar *group)
{
gchar *type_str;
GType type;
@@ -523,18 +542,19 @@ libbalsa_mailbox_new_from_config(const gchar * group)
return NULL;
}
- /* Handle Local mailboxes.
- * They are now separate classes for each type
+ /* Handle Local mailboxes.
+ * They are now separate classes for each type
* FIXME: This should be removed in som efuture release.
*/
if ( type == LIBBALSA_TYPE_MAILBOX_LOCAL ) {
gchar *path = libbalsa_conf_get_string("Path");
type = libbalsa_mailbox_type_from_path(path);
- if (type != G_TYPE_OBJECT)
+ if (type != G_TYPE_OBJECT) {
libbalsa_conf_set_string("Type", g_type_name(type));
- else
+ } else {
libbalsa_information(LIBBALSA_INFORMATION_WARNING,
_("Bad local mailbox path “%s”"), path);
+ }
}
mailbox = (type != G_TYPE_OBJECT ? g_object_new(type, NULL) : NULL);
if (mailbox == NULL) {
@@ -543,7 +563,7 @@ libbalsa_mailbox_new_from_config(const gchar * group)
type_str);
} else {
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
- LIBBALSA_MAILBOX_GET_CLASS(mailbox)->load_config(mailbox, group);
+ LIBBALSA_MAILBOX_GET_CLASS(mailbox)->load_config(mailbox, group);
}
libbalsa_conf_pop_group();
@@ -552,26 +572,26 @@ libbalsa_mailbox_new_from_config(const gchar * group)
return mailbox;
}
+
static void
libbalsa_mailbox_free_mindex(LibBalsaMailbox *mailbox)
{
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<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;
+ if (priv->mindex != NULL) {
+ g_ptr_array_foreach(priv->mindex, (GFunc) lbm_index_entry_free, NULL);
+ g_clear_pointer(&priv->mindex, (GDestroyNotify) g_ptr_array_free);
}
}
-static gboolean lbm_set_threading(LibBalsaMailbox * mailbox,
+
+static gboolean lbm_set_threading(LibBalsaMailbox *mailbox,
LibBalsaMailboxThreadingType
thread_type);
+
gboolean
-libbalsa_mailbox_open(LibBalsaMailbox * mailbox, GError **err)
+libbalsa_mailbox_open(LibBalsaMailbox *mailbox,
+ GError **err)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
gboolean retval;
@@ -584,26 +604,28 @@ libbalsa_mailbox_open(LibBalsaMailbox * mailbox, GError **err)
if (priv->open_ref > 0) {
priv->open_ref++;
- libbalsa_mailbox_check(mailbox);
+ libbalsa_mailbox_check(mailbox);
retval = TRUE;
} else {
- LibBalsaMailboxState saved_state;
+ LibBalsaMailboxState saved_state;
priv->stamp++;
- if(priv->mindex) g_warning("mindex set - I leak memory");
+ if (priv->mindex) {
+ g_warning("mindex set - I leak memory");
+ }
priv->mindex = g_ptr_array_new();
- saved_state = priv->state;
- priv->state = LB_MAILBOX_STATE_OPENING;
- retval =
+ saved_state = priv->state;
+ priv->state = LB_MAILBOX_STATE_OPENING;
+ retval =
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->open_mailbox(mailbox, err);
- if(retval) {
+ if (retval) {
priv->open_ref++;
- priv->state = LB_MAILBOX_STATE_OPEN;
- } else {
- priv->state = saved_state;
+ priv->state = LB_MAILBOX_STATE_OPEN;
+ } else {
+ priv->state = saved_state;
libbalsa_mailbox_free_mindex(mailbox);
- }
+ }
}
libbalsa_unlock_mailbox(mailbox);
@@ -611,20 +633,26 @@ libbalsa_mailbox_open(LibBalsaMailbox * mailbox, GError **err)
return retval;
}
+
/* libbalsa_mailbox_is_valid:
mailbox is valid when:
a). it is closed, b). it is open and has proper client context.
-*/
+ */
gboolean
-libbalsa_mailbox_is_valid(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_is_valid(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
- if(priv->open_ref == 0) return TRUE;
- if(MAILBOX_CLOSED(mailbox)) return FALSE;
+ if (priv->open_ref == 0) {
+ return TRUE;
+ }
+ if (MAILBOX_CLOSED(mailbox)) {
+ return FALSE;
+ }
return TRUE;
}
+
gboolean
libbalsa_mailbox_is_open(LibBalsaMailbox *mailbox)
{
@@ -632,13 +660,15 @@ libbalsa_mailbox_is_open(LibBalsaMailbox *mailbox)
g_return_val_if_fail(mailbox != NULL, FALSE);
g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), FALSE);
-
- return priv->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)
+libbalsa_mailbox_close(LibBalsaMailbox *mailbox,
+ gboolean expunge)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -651,26 +681,27 @@ libbalsa_mailbox_close(LibBalsaMailbox * mailbox, gboolean expunge)
libbalsa_lock_mailbox(mailbox);
if (--priv->open_ref == 0) {
- priv->state = LB_MAILBOX_STATE_CLOSING;
+ priv->state = LB_MAILBOX_STATE_CLOSING;
/* do not try expunging read-only mailboxes, it's a waste of time */
expunge = expunge && !priv->readonly;
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->close_mailbox(mailbox, expunge);
- if(priv->msg_tree) {
+ if (priv->msg_tree) {
g_node_destroy(priv->msg_tree);
priv->msg_tree = NULL;
}
libbalsa_mailbox_free_mindex(mailbox);
priv->stamp++;
- priv->state = LB_MAILBOX_STATE_CLOSED;
+ priv->state = LB_MAILBOX_STATE_CLOSED;
}
libbalsa_unlock_mailbox(mailbox);
g_object_unref(mailbox);
}
+
void
-libbalsa_mailbox_set_unread_messages_flag(LibBalsaMailbox * mailbox,
- gboolean has_unread)
+libbalsa_mailbox_set_unread_messages_flag(LibBalsaMailbox *mailbox,
+ gboolean has_unread)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -681,36 +712,43 @@ libbalsa_mailbox_set_unread_messages_flag(LibBalsaMailbox * mailbox,
libbalsa_mailbox_changed(mailbox);
}
+
/* libbalsa_mailbox_progress_notify:
there has been a progress in current operation.
-*/
+ */
void
-libbalsa_mailbox_progress_notify(LibBalsaMailbox *mailbox,
- LibBalsaMailboxNotify action,
- gdouble fraction,
- const gchar *message,
- ...)
+libbalsa_mailbox_progress_notify(LibBalsaMailbox *mailbox,
+ LibBalsaMailboxNotify action,
+ gdouble fraction,
+ const gchar *message,
+ ...)
{
- gchar *full_msg;
+ gchar *full_msg;
g_return_if_fail(mailbox != NULL);
g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
if (message != NULL) {
- va_list args;
+ va_list args;
- va_start(args, message);
- full_msg = g_strdup_vprintf(message, args);
- va_end(args);
+ va_start(args, message);
+ full_msg = g_strdup_vprintf(message, args);
+ va_end(args);
} else {
- full_msg = NULL;
+ full_msg = NULL;
}
- g_signal_emit(G_OBJECT(mailbox), libbalsa_mailbox_signals[PROGRESS_NOTIFY], 0, (gint) action, fraction,
full_msg);
- g_free(full_msg);
+ g_signal_emit(G_OBJECT(mailbox),
+ libbalsa_mailbox_signals[PROGRESS_NOTIFY],
+ 0,
+ (gint) action,
+ fraction,
+ full_msg);
+ g_free(full_msg);
}
+
void
-libbalsa_mailbox_check(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_check(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -728,8 +766,9 @@ libbalsa_mailbox_check(LibBalsaMailbox * mailbox)
libbalsa_unlock_mailbox(mailbox);
}
+
static gboolean
-lbm_changed_idle_cb(LibBalsaMailbox * mailbox)
+lbm_changed_idle_cb(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -740,26 +779,29 @@ lbm_changed_idle_cb(LibBalsaMailbox * mailbox)
return FALSE;
}
+
static void
-lbm_changed_schedule_idle(LibBalsaMailbox * mailbox)
+lbm_changed_schedule_idle(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
libbalsa_lock_mailbox(mailbox);
- if (!priv->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);
}
+
void
-libbalsa_mailbox_changed(LibBalsaMailbox * mailbox)
+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)) {
+ (mailbox, libbalsa_mailbox_signals[CHANGED], 0, TRUE)) {
/* No one cares, so don't set any message counts--that might
* cause priv->view to be created. */
libbalsa_unlock_mailbox(mailbox);
@@ -770,10 +812,10 @@ libbalsa_mailbox_changed(LibBalsaMailbox * mailbox)
/* Both counts are valid. */
libbalsa_mailbox_set_total(mailbox,
libbalsa_mailbox_total_messages
- (mailbox));
+ (mailbox));
libbalsa_mailbox_set_unread(mailbox, priv->unread_messages);
} else if (priv->has_unread_messages
- && libbalsa_mailbox_get_unread(mailbox) <= 0) {
+ && (libbalsa_mailbox_get_unread(mailbox) <= 0)) {
/* Mail has arrived in a closed mailbox since our last check;
* total is unknown, but priv->has_unread_messages is valid. */
libbalsa_mailbox_set_total(mailbox, -1);
@@ -784,6 +826,7 @@ libbalsa_mailbox_changed(LibBalsaMailbox * mailbox)
libbalsa_unlock_mailbox(mailbox);
}
+
/* libbalsa_mailbox_message_match:
* Tests if message with msgno matches the conditions cached in the
* search_iter: this is used
@@ -791,9 +834,9 @@ libbalsa_mailbox_changed(LibBalsaMailbox * mailbox)
special way to implement it for speed/bandwidth reasons
*/
gboolean
-libbalsa_mailbox_message_match(LibBalsaMailbox * mailbox,
- guint msgno,
- LibBalsaMailboxSearchIter * search_iter)
+libbalsa_mailbox_message_match(LibBalsaMailbox *mailbox,
+ guint msgno,
+ LibBalsaMailboxSearchIter *search_iter)
{
gboolean match;
@@ -804,23 +847,27 @@ libbalsa_mailbox_message_match(LibBalsaMailbox * mailbox,
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
if (libbalsa_condition_is_flag_only(search_iter->condition,
- mailbox, msgno, &match))
+ mailbox, msgno, &match)) {
return match;
+ }
return LIBBALSA_MAILBOX_GET_CLASS(mailbox)->message_match(mailbox,
msgno,
search_iter);
}
-gboolean libbalsa_mailbox_real_can_match(LibBalsaMailbox *mailbox,
- LibBalsaCondition *condition)
+
+gboolean
+libbalsa_mailbox_real_can_match(LibBalsaMailbox *mailbox,
+ LibBalsaCondition *condition)
{
/* By default : all filters is OK */
return TRUE;
}
+
gboolean
-libbalsa_mailbox_can_match(LibBalsaMailbox * mailbox,
+libbalsa_mailbox_can_match(LibBalsaMailbox *mailbox,
LibBalsaCondition *condition)
{
g_return_val_if_fail(mailbox != NULL, FALSE);
@@ -831,10 +878,11 @@ libbalsa_mailbox_can_match(LibBalsaMailbox * mailbox,
condition);
}
+
/* Helper function to run the "on reception" filters on a mailbox */
static gboolean
-lbm_run_filters_on_reception_idle_cb(LibBalsaMailbox * mailbox)
+lbm_run_filters_on_reception_idle_cb(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GSList *filters;
@@ -846,11 +894,12 @@ lbm_run_filters_on_reception_idle_cb(LibBalsaMailbox * mailbox)
guint progress_total;
LibBalsaProgress progress;
- g_object_add_weak_pointer(G_OBJECT(mailbox), (gpointer) &mailbox);
+ g_object_add_weak_pointer(G_OBJECT(mailbox), (gpointer) & mailbox);
g_object_unref(mailbox);
- if (!mailbox)
+ if (!mailbox) {
return FALSE;
- g_object_remove_weak_pointer(G_OBJECT(mailbox), (gpointer) &mailbox);
+ }
+ g_object_remove_weak_pointer(G_OBJECT(mailbox), (gpointer) & mailbox);
if (!priv->filters_loaded) {
config_mailbox_filters_load(mailbox);
@@ -860,8 +909,9 @@ lbm_run_filters_on_reception_idle_cb(LibBalsaMailbox * mailbox)
filters = libbalsa_mailbox_filters_when(priv->filters,
FILTER_WHEN_INCOMING);
- if (!filters)
+ if (!filters) {
return FALSE;
+ }
if (!filters_prepare_to_run(filters)) {
g_slist_free(filters);
return FALSE;
@@ -873,23 +923,25 @@ lbm_run_filters_on_reception_idle_cb(LibBalsaMailbox * mailbox)
if (filter->condition
&& !libbalsa_condition_is_flag_only(filter->condition, NULL, 0,
- NULL))
+ NULL)) {
++progress_count;
+ }
}
libbalsa_lock_mailbox(mailbox);
- if (!recent_undeleted)
+ if (!recent_undeleted) {
recent_undeleted =
libbalsa_condition_new_bool_ptr(FALSE, CONDITION_AND,
libbalsa_condition_new_flag_enum
- (FALSE,
- LIBBALSA_MESSAGE_FLAG_RECENT),
+ (FALSE,
+ LIBBALSA_MESSAGE_FLAG_RECENT),
libbalsa_condition_new_flag_enum
- (TRUE,
- LIBBALSA_MESSAGE_FLAG_DELETED));
+ (TRUE,
+ LIBBALSA_MESSAGE_FLAG_DELETED));
+ }
- text = g_strdup_printf(_("Applying filter rules to %s"), priv->name);
- total = libbalsa_mailbox_total_messages(mailbox);
+ 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);
g_free(text);
@@ -903,8 +955,9 @@ lbm_run_filters_on_reception_idle_cb(LibBalsaMailbox * mailbox)
guint msgno;
GArray *msgnos;
- if (!filter->condition)
+ if (!filter->condition) {
continue;
+ }
use_progress = !libbalsa_condition_is_flag_only(filter->condition,
NULL, 0, NULL);
@@ -917,13 +970,15 @@ lbm_run_filters_on_reception_idle_cb(LibBalsaMailbox * mailbox)
msgnos = g_array_new(FALSE, FALSE, sizeof(guint));
for (msgno = 1; msgno <= total; msgno++) {
- if (libbalsa_mailbox_message_match(mailbox, msgno, search_iter))
+ if (libbalsa_mailbox_message_match(mailbox, msgno, search_iter)) {
g_array_append_val(msgnos, msgno);
- if (use_progress)
+ }
+ if (use_progress) {
libbalsa_progress_set_fraction(&progress,
- ((gdouble) ++progress_count)
+ ((gdouble)++ progress_count)
/
((gdouble) progress_total));
+ }
}
libbalsa_mailbox_search_iter_unref(search_iter);
@@ -939,8 +994,9 @@ lbm_run_filters_on_reception_idle_cb(LibBalsaMailbox * mailbox)
return FALSE;
}
+
void
-libbalsa_mailbox_run_filters_on_reception(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_run_filters_on_reception(LibBalsaMailbox *mailbox)
{
g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
@@ -948,9 +1004,10 @@ libbalsa_mailbox_run_filters_on_reception(LibBalsaMailbox * mailbox)
g_object_ref(mailbox));
}
+
void
-libbalsa_mailbox_save_config(LibBalsaMailbox * mailbox,
- const gchar * group)
+libbalsa_mailbox_save_config(LibBalsaMailbox *mailbox,
+ const gchar *group)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -971,13 +1028,15 @@ libbalsa_mailbox_save_config(LibBalsaMailbox * mailbox,
libbalsa_conf_pop_group();
}
+
static void
-libbalsa_mailbox_real_release_message(LibBalsaMailbox * mailbox,
- LibBalsaMessage * message)
+libbalsa_mailbox_real_release_message(LibBalsaMailbox *mailbox,
+ LibBalsaMessage *message)
{
g_clear_object(&message->mime_msg);
}
+
struct MsgCopyData {
LibBalsaMailbox *src_mailbox;
GArray *msgnos;
@@ -988,63 +1047,75 @@ struct MsgCopyData {
};
static gboolean
-copy_iterator(LibBalsaMessageFlag *flags, GMimeStream **stream, void * arg)
+copy_iterator(LibBalsaMessageFlag *flags,
+ GMimeStream **stream,
+ void *arg)
{
- struct MsgCopyData *mcd = (struct MsgCopyData*)arg;
+ struct MsgCopyData *mcd = (struct MsgCopyData *)arg;
guint msgno;
- gboolean (*msgno_has_flags)(LibBalsaMailbox *, guint,
- LibBalsaMessageFlag, LibBalsaMessageFlag);
+ gboolean (*msgno_has_flags)(LibBalsaMailbox *,
+ guint,
+ LibBalsaMessageFlag,
+ LibBalsaMessageFlag);
LibBalsaMailbox *mailbox = mcd->src_mailbox;
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
- if(mcd->current_idx >= mcd->msgnos->len)
- return FALSE; /* no more messages */
+ if (mcd->current_idx >= mcd->msgnos->len) {
+ return FALSE; /* no more messages */
+ }
g_clear_object(&mcd->stream);
msgno_has_flags = LIBBALSA_MAILBOX_GET_CLASS(mailbox)->msgno_has_flags;
- msgno = g_array_index(mcd->msgnos, guint, mcd->current_idx);
+ msgno = g_array_index(mcd->msgnos, guint, mcd->current_idx);
- libbalsa_progress_set_fraction(&mcd->progress,
- ((gdouble) (mcd->current_idx + 1)) /
- ((gdouble) mcd->msgnos->len));
+ libbalsa_progress_set_fraction(&mcd->progress,
+ ((gdouble) (mcd->current_idx + 1)) /
+ ((gdouble) mcd->msgnos->len));
mcd->current_idx++;
-
+
*flags = 0;
/* Copy flags. */
- if (msgno_has_flags(mailbox, msgno, LIBBALSA_MESSAGE_FLAG_NEW, 0))
- *flags |= LIBBALSA_MESSAGE_FLAG_NEW;
+ if (msgno_has_flags(mailbox, msgno, LIBBALSA_MESSAGE_FLAG_NEW, 0)) {
+ *flags |= LIBBALSA_MESSAGE_FLAG_NEW;
+ }
if (msgno_has_flags
- (mailbox, msgno, LIBBALSA_MESSAGE_FLAG_REPLIED, 0))
- *flags |= LIBBALSA_MESSAGE_FLAG_REPLIED;
+ (mailbox, msgno, LIBBALSA_MESSAGE_FLAG_REPLIED, 0)) {
+ *flags |= LIBBALSA_MESSAGE_FLAG_REPLIED;
+ }
if (msgno_has_flags
- (mailbox, msgno, LIBBALSA_MESSAGE_FLAG_FLAGGED, 0))
- *flags |= LIBBALSA_MESSAGE_FLAG_FLAGGED;
+ (mailbox, msgno, LIBBALSA_MESSAGE_FLAG_FLAGGED, 0)) {
+ *flags |= LIBBALSA_MESSAGE_FLAG_FLAGGED;
+ }
if (msgno_has_flags
- (mailbox, msgno, LIBBALSA_MESSAGE_FLAG_DELETED, 0))
- *flags |= LIBBALSA_MESSAGE_FLAG_DELETED;
+ (mailbox, msgno, LIBBALSA_MESSAGE_FLAG_DELETED, 0)) {
+ *flags |= LIBBALSA_MESSAGE_FLAG_DELETED;
+ }
/* Copy stream */
*stream = libbalsa_mailbox_get_message_stream(mailbox, msgno, TRUE);
- if(!*stream) {
- printf("Connection broken for message %u\n",
- (unsigned)msgno);
- return FALSE;
+ if (!*stream) {
+ printf("Connection broken for message %u\n",
+ (unsigned)msgno);
+ return FALSE;
}
return TRUE;
}
+
/* Default method; imap backend replaces with its own method, optimized
* for server-side copy, but falls back to this one if it's not a
* server-side copy. */
-static void lbm_queue_check(LibBalsaMailbox * mailbox);
+static void lbm_queue_check(LibBalsaMailbox *mailbox);
+
static gboolean
-libbalsa_mailbox_real_messages_copy(LibBalsaMailbox * mailbox,
- GArray * msgnos,
- LibBalsaMailbox * dest, GError ** err)
+libbalsa_mailbox_real_messages_copy(LibBalsaMailbox *mailbox,
+ GArray *msgnos,
+ LibBalsaMailbox *dest,
+ GError **err)
{
- LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
LibBalsaMailboxPrivate *dest_priv = libbalsa_mailbox_get_instance_private(dest);
gchar *text;
guint successfully_copied;
@@ -1061,42 +1132,46 @@ libbalsa_mailbox_real_messages_copy(LibBalsaMailbox * mailbox,
libbalsa_progress_set_text(&mcd.progress, text, msgnos->len);
g_free(text);
- mcd.src_mailbox = mailbox;
- mcd.msgnos = msgnos;
- mcd.stream = NULL;
- mcd.current_idx = 0;
- mcd.copied_cnt = 0;
+ mcd.src_mailbox = mailbox;
+ mcd.msgnos = msgnos;
+ mcd.stream = NULL;
+ mcd.current_idx = 0;
+ mcd.copied_cnt = 0;
successfully_copied =
- LIBBALSA_MAILBOX_GET_CLASS(dest)->add_messages(dest,
- copy_iterator,
- &mcd,
- err);
+ LIBBALSA_MAILBOX_GET_CLASS(dest)->add_messages(dest,
+ copy_iterator,
+ &mcd,
+ err);
g_clear_object(&mcd.stream);
libbalsa_progress_set_text(&mcd.progress, NULL, 0);
- if (successfully_copied)
+ if (successfully_copied) {
/* Some messages copied. */
lbm_queue_check(dest);
+ }
return successfully_copied == msgnos->len;
}
-static gint mbox_compare_func(const SortTuple * a,
- const SortTuple * b,
- LibBalsaMailbox * mbox);
+
+static gint mbox_compare_func(const SortTuple *a,
+ const SortTuple *b,
+ LibBalsaMailbox *mbox);
static void
-libbalsa_mailbox_real_sort(LibBalsaMailbox* mbox, GArray *sort_array)
+libbalsa_mailbox_real_sort(LibBalsaMailbox *mbox,
+ GArray *sort_array)
{
/* Sort the array */
g_array_sort_with_data(sort_array,
(GCompareDataFunc) mbox_compare_func, mbox);
}
+
static void
-libbalsa_mailbox_real_save_config(LibBalsaMailbox * mailbox,
- const gchar * group)
+libbalsa_mailbox_real_save_config(LibBalsaMailbox *mailbox,
+ const gchar *group)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -1108,9 +1183,10 @@ libbalsa_mailbox_real_save_config(LibBalsaMailbox * mailbox,
libbalsa_conf_set_string("Name", priv->name);
}
+
static void
-libbalsa_mailbox_real_load_config(LibBalsaMailbox * mailbox,
- const gchar * group)
+libbalsa_mailbox_real_load_config(LibBalsaMailbox *mailbox,
+ const gchar *group)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -1123,20 +1199,24 @@ libbalsa_mailbox_real_load_config(LibBalsaMailbox * mailbox,
priv->name = libbalsa_conf_get_string("Name=Mailbox");
}
+
static gboolean
-libbalsa_mailbox_real_close_backend(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_real_close_backend(LibBalsaMailbox *mailbox)
{
return TRUE; /* Default is noop. */
}
+
static void
-libbalsa_mailbox_real_lock_store(LibBalsaMailbox * mailbox, gboolean lock)
+libbalsa_mailbox_real_lock_store(LibBalsaMailbox *mailbox,
+ gboolean lock)
{
/* Default is noop. */
}
+
GType
-libbalsa_mailbox_type_from_path(const gchar * path)
+libbalsa_mailbox_type_from_path(const gchar *path)
/* libbalsa_get_mailbox_storage_type:
returns one of LIBBALSA_TYPE_MAILBOX_IMAP,
LIBBALSA_TYPE_MAILBOX_MAILDIR, LIBBALSA_TYPE_MAILBOX_MH,
@@ -1145,45 +1225,53 @@ libbalsa_mailbox_type_from_path(const gchar * path)
{
struct stat st;
- if(strncmp(path, "imap://", 7) == 0)
+ if (strncmp(path, "imap://", 7) == 0) {
return LIBBALSA_TYPE_MAILBOX_IMAP;
+ }
- if (stat (path, &st) == -1)
+ if (stat (path, &st) == -1) {
return G_TYPE_OBJECT;
-
+ }
+
if (S_ISDIR (st.st_mode)) {
char tmp[_POSIX_PATH_MAX];
/* check for maildir-style mailbox */
snprintf (tmp, sizeof (tmp), "%s/cur", path);
- if (stat (tmp, &st) == 0 && S_ISDIR (st.st_mode))
+ if ((stat (tmp, &st) == 0) && S_ISDIR (st.st_mode)) {
return LIBBALSA_TYPE_MAILBOX_MAILDIR;
-
+ }
+
/* check for mh-style mailbox */
snprintf (tmp, sizeof (tmp), "%s/.mh_sequences", path);
- if (access (tmp, F_OK) == 0)
+ if (access (tmp, F_OK) == 0) {
return LIBBALSA_TYPE_MAILBOX_MH;
+ }
snprintf (tmp, sizeof (tmp), "%s/.xmhcache", path);
- if (access (tmp, F_OK) == 0)
+ if (access (tmp, F_OK) == 0) {
return LIBBALSA_TYPE_MAILBOX_MH;
-
+ }
+
snprintf (tmp, sizeof (tmp), "%s/.mew_cache", path);
- if (access (tmp, F_OK) == 0)
+ if (access (tmp, F_OK) == 0) {
return LIBBALSA_TYPE_MAILBOX_MH;
+ }
snprintf (tmp, sizeof (tmp), "%s/.mew-cache", path);
- if (access (tmp, F_OK) == 0)
+ if (access (tmp, F_OK) == 0) {
return LIBBALSA_TYPE_MAILBOX_MH;
+ }
- /*
+ /*
* ok, this isn't an mh folder, but mh mode can be used to read
- * Usenet news from the spool. ;-)
+ * Usenet news from the spool. ;-)
*/
snprintf (tmp, sizeof (tmp), "%s/.overview", path);
- if (access (tmp, F_OK) == 0)
+ if (access (tmp, F_OK) == 0) {
return LIBBALSA_TYPE_MAILBOX_MH;
+ }
} else {
/* Minimal check for an mbox */
@@ -1193,10 +1281,11 @@ libbalsa_mailbox_type_from_path(const gchar * path)
gchar buf[5];
guint len = read(fd, buf, sizeof buf);
close(fd);
- if (len == 0
- || (len == sizeof buf
- && strncmp(buf, "From ", sizeof buf) == 0))
+ if ((len == 0)
+ || ((len == sizeof buf)
+ && (strncmp(buf, "From ", sizeof buf) == 0))) {
return LIBBALSA_TYPE_MAILBOX_MBOX;
+ }
}
}
@@ -1204,37 +1293,45 @@ libbalsa_mailbox_type_from_path(const gchar * path)
return G_TYPE_OBJECT;
}
+
/* Each of the next three methods emits a signal that will be caught by
* a GtkTreeView, so the emission must be made holding the gdk lock.
*/
static LibBalsaMailboxIndexEntry *lbm_get_index_entry(LibBalsaMailbox *
- lmm, guint msgno);
+ lmm,
+ guint msgno);
+
/* Does the node (non-NULL) have unseen children? */
static gboolean
-lbm_node_has_unseen_child(LibBalsaMailbox * lmm, GNode * node)
+lbm_node_has_unseen_child(LibBalsaMailbox *lmm,
+ GNode *node)
{
for (node = node->children; node; node = node->next) {
- LibBalsaMailboxIndexEntry *entry =
- /* 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;
+ LibBalsaMailboxIndexEntry *entry =
+ /* 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;
+ }
}
return FALSE;
}
+
/* 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. */
static GMutex msgnos_changed_lock;
-static void lbm_update_msgnos(LibBalsaMailbox * mailbox, guint seqno,
- GArray * msgnos);
+static void lbm_update_msgnos(LibBalsaMailbox *mailbox,
+ guint seqno,
+ GArray *msgnos);
static void
-lbm_msgno_changed_expunged_cb(LibBalsaMailbox * mailbox, guint seqno)
+lbm_msgno_changed_expunged_cb(LibBalsaMailbox *mailbox,
+ guint seqno)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -1245,21 +1342,23 @@ lbm_msgno_changed_expunged_cb(LibBalsaMailbox * mailbox, guint seqno)
static void
-lbm_msgno_row_changed(LibBalsaMailbox * mailbox, guint msgno,
- GtkTreeIter * iter)
+lbm_msgno_row_changed(LibBalsaMailbox *mailbox,
+ guint msgno,
+ GtkTreeIter *iter)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
- if (!iter->user_data)
+ if (!iter->user_data) {
iter->user_data =
g_node_find(priv->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL,
GUINT_TO_POINTER(msgno));
+ }
if (iter->user_data) {
GtkTreePath *path;
iter->stamp = priv->stamp;
- path = gtk_tree_model_get_path(GTK_TREE_MODEL(mailbox), iter);
+ path = gtk_tree_model_get_path(GTK_TREE_MODEL(mailbox), iter);
g_signal_emit(mailbox, libbalsa_mbox_model_signals[ROW_CHANGED], 0,
path, iter);
gtk_tree_path_free(path);
@@ -1268,13 +1367,14 @@ lbm_msgno_row_changed(LibBalsaMailbox * mailbox, guint msgno,
static gboolean
-lbm_msgnos_changed_idle_cb(LibBalsaMailbox * mailbox)
+lbm_msgnos_changed_idle_cb(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
guint i;
- if (!priv->msgnos_changed)
+ if (!priv->msgnos_changed) {
return FALSE;
+ }
#define DEBUG FALSE
#if DEBUG
@@ -1287,8 +1387,9 @@ lbm_msgnos_changed_idle_cb(LibBalsaMailbox * mailbox)
guint msgno = g_array_index(priv->msgnos_changed, guint, i);
GtkTreeIter iter;
- if (!MAILBOX_OPEN(mailbox))
+ if (!MAILBOX_OPEN(mailbox)) {
break;
+ }
#if DEBUG
g_print("%s %s msgno %d\n", __func__, priv->name, msgno);
@@ -1312,8 +1413,9 @@ lbm_msgnos_changed_idle_cb(LibBalsaMailbox * mailbox)
static void
-lbm_msgno_changed(LibBalsaMailbox * mailbox, guint seqno,
- GtkTreeIter * iter)
+lbm_msgno_changed(LibBalsaMailbox *mailbox,
+ guint seqno,
+ GtkTreeIter *iter)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -1326,27 +1428,31 @@ lbm_msgno_changed(LibBalsaMailbox * mailbox, guint seqno,
G_CALLBACK(lbm_msgno_changed_expunged_cb),
NULL);
}
- if (priv->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(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)
+ if (!iter->user_data) {
iter->user_data =
g_node_find(priv->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL,
GUINT_TO_POINTER(seqno));
+ }
return;
}
lbm_msgno_row_changed(mailbox, seqno, iter);
}
+
void
-libbalsa_mailbox_msgno_changed(LibBalsaMailbox * mailbox, guint seqno)
+libbalsa_mailbox_msgno_changed(LibBalsaMailbox *mailbox,
+ guint seqno)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GtkTreeIter iter;
@@ -1363,11 +1469,13 @@ libbalsa_mailbox_msgno_changed(LibBalsaMailbox * mailbox, guint seqno)
GNode *parent = ((GNode *) iter.user_data)->parent;
iter.user_data = parent;
- if (parent && (seqno = GPOINTER_TO_UINT(parent->data)) > 0)
+ if (parent && ((seqno = GPOINTER_TO_UINT(parent->data)) > 0)) {
lbm_msgno_changed(mailbox, seqno, &iter);
+ }
}
}
+
static gboolean
lbm_need_threading_idle_cb(LibBalsaMailbox *mailbox)
{
@@ -1384,16 +1492,20 @@ lbm_need_threading_idle_cb(LibBalsaMailbox *mailbox)
return FALSE;
}
+
void
-libbalsa_mailbox_msgno_inserted(LibBalsaMailbox *mailbox, guint seqno,
- GNode * parent, GNode ** sibling)
+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 (!priv->msg_tree)
+ if (!priv->msg_tree) {
return;
+ }
#undef SANITY_CHECK
#ifdef SANITY_CHECK
g_return_if_fail(!g_node_find(priv->msg_tree,
@@ -1403,8 +1515,8 @@ libbalsa_mailbox_msgno_inserted(LibBalsaMailbox *mailbox, guint seqno,
/* Insert node into the message tree before getting path. */
iter.user_data = g_node_new(GUINT_TO_POINTER(seqno));
- iter.stamp = priv->stamp;
- *sibling = g_node_insert_after(parent, *sibling, iter.user_data);
+ iter.stamp = priv->stamp;
+ *sibling = g_node_insert_after(parent, *sibling, iter.user_data);
if (g_signal_has_handler_pending(mailbox,
libbalsa_mbox_model_signals
@@ -1425,8 +1537,10 @@ libbalsa_mailbox_msgno_inserted(LibBalsaMailbox *mailbox, guint seqno,
priv->msg_tree_changed = TRUE;
}
+
static void
-libbalsa_mailbox_msgno_filt_in(LibBalsaMailbox *mailbox, guint seqno)
+libbalsa_mailbox_msgno_filt_in(LibBalsaMailbox *mailbox,
+ guint seqno)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GtkTreeIter iter;
@@ -1438,7 +1552,7 @@ libbalsa_mailbox_msgno_filt_in(LibBalsaMailbox *mailbox, guint seqno)
/* Insert node into the message tree before getting path. */
iter.user_data = g_node_new(GUINT_TO_POINTER(seqno));
- iter.stamp = priv->stamp;
+ iter.stamp = priv->stamp;
g_node_prepend(priv->msg_tree, iter.user_data);
path = gtk_tree_model_get_path(GTK_TREE_MODEL(mailbox), &iter);
@@ -1450,28 +1564,36 @@ libbalsa_mailbox_msgno_filt_in(LibBalsaMailbox *mailbox, guint seqno)
lbm_changed_schedule_idle(mailbox);
}
+
/*
* libbalsa_mailbox_msgno_removed and helpers
*/
-struct remove_data {LibBalsaMailbox *mailbox; unsigned seqno; GNode *node; };
+struct remove_data {
+ LibBalsaMailbox *mailbox;
+ unsigned seqno;
+ GNode *node;
+};
static gboolean
-decrease_post(GNode *node, gpointer data)
+decrease_post(GNode *node,
+ gpointer data)
{
- struct remove_data *dt = (struct remove_data*)data;
- unsigned seqno = GPOINTER_TO_UINT(node->data);
- if(seqno == dt->seqno)
+ struct remove_data *dt = (struct remove_data *)data;
+ unsigned seqno = GPOINTER_TO_UINT(node->data);
+ if (seqno == dt->seqno) {
dt->node = node;
- else if(seqno>dt->seqno) {
- GtkTreeIter iter;
- node->data = GUINT_TO_POINTER(seqno-1);
+ } else if (seqno > dt->seqno) {
+ GtkTreeIter iter;
+ node->data = GUINT_TO_POINTER(seqno - 1);
iter.user_data = node;
lbm_msgno_changed(dt->mailbox, seqno, &iter);
}
return FALSE;
}
+
void
-libbalsa_mailbox_msgno_removed(LibBalsaMailbox * mailbox, guint seqno)
+libbalsa_mailbox_msgno_removed(LibBalsaMailbox *mailbox,
+ guint seqno)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GtkTreeIter iter;
@@ -1488,8 +1610,8 @@ libbalsa_mailbox_msgno_removed(LibBalsaMailbox * mailbox, guint seqno)
}
dt.mailbox = mailbox;
- dt.seqno = seqno;
- dt.node = NULL;
+ dt.seqno = seqno;
+ dt.node = NULL;
g_node_traverse(priv->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
decrease_post, &dt);
@@ -1508,8 +1630,8 @@ libbalsa_mailbox_msgno_removed(LibBalsaMailbox * mailbox, guint seqno)
}
iter.user_data = dt.node;
- iter.stamp = priv->stamp;
- path = gtk_tree_model_get_path(GTK_TREE_MODEL(mailbox), &iter);
+ 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
* them all before the current node, to keep the path calculation
@@ -1526,10 +1648,11 @@ libbalsa_mailbox_msgno_removed(LibBalsaMailbox * mailbox, guint seqno)
iter.user_data = child;
g_signal_emit(mailbox, libbalsa_mbox_model_signals[ROW_INSERTED], 0,
path, &iter);
- if (child->children)
+ if (child->children) {
g_signal_emit(mailbox,
libbalsa_mbox_model_signals[ROW_HAS_CHILD_TOGGLED],
0, path, &iter);
+ }
gtk_tree_path_next(path);
}
@@ -1551,13 +1674,15 @@ libbalsa_mailbox_msgno_removed(LibBalsaMailbox * mailbox, guint seqno)
libbalsa_mbox_model_signals[ROW_HAS_CHILD_TOGGLED], 0,
path, &iter);
}
-
+
gtk_tree_path_free(path);
priv->stamp++;
}
+
static void
-libbalsa_mailbox_msgno_filt_out(LibBalsaMailbox * mailbox, GNode * node)
+libbalsa_mailbox_msgno_filt_out(LibBalsaMailbox *mailbox,
+ GNode *node)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GtkTreeIter iter;
@@ -1569,8 +1694,8 @@ libbalsa_mailbox_msgno_filt_out(LibBalsaMailbox * mailbox, GNode * node)
}
iter.user_data = node;
- iter.stamp = priv->stamp;
- path = gtk_tree_model_get_path(GTK_TREE_MODEL(mailbox), &iter);
+ 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
* them all before the current node, to keep the path calculation
@@ -1587,10 +1712,11 @@ libbalsa_mailbox_msgno_filt_out(LibBalsaMailbox * mailbox, GNode * node)
iter.user_data = child;
g_signal_emit(mailbox, libbalsa_mbox_model_signals[ROW_INSERTED], 0,
path, &iter);
- if (child->children)
+ if (child->children) {
g_signal_emit(mailbox,
libbalsa_mbox_model_signals[ROW_HAS_CHILD_TOGGLED],
0, path, &iter);
+ }
gtk_tree_path_next(path);
}
@@ -1605,7 +1731,7 @@ libbalsa_mailbox_msgno_filt_out(LibBalsaMailbox * mailbox, GNode * node)
libbalsa_mbox_model_signals[ROW_HAS_CHILD_TOGGLED], 0,
path, &iter);
}
-
+
gtk_tree_path_free(path);
priv->stamp++;
@@ -1613,6 +1739,7 @@ libbalsa_mailbox_msgno_filt_out(LibBalsaMailbox * mailbox, GNode * node)
lbm_changed_schedule_idle(mailbox);
}
+
/*
* Check whether to filter the message in or out of the view:
* - if it's in the view and doesn't match the condition, filter it out,
@@ -1622,9 +1749,10 @@ libbalsa_mailbox_msgno_filt_out(LibBalsaMailbox * mailbox, GNode * node)
*/
static void
-lbm_msgno_filt_check(LibBalsaMailbox * mailbox, guint seqno,
- LibBalsaMailboxSearchIter * search_iter,
- gboolean hold_selected)
+lbm_msgno_filt_check(LibBalsaMailbox *mailbox,
+ guint seqno,
+ LibBalsaMailboxSearchIter *search_iter,
+ gboolean hold_selected)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
gboolean match;
@@ -1641,37 +1769,42 @@ lbm_msgno_filt_check(LibBalsaMailbox * mailbox, guint seqno,
LIBBALSA_MESSAGE_FLAG_SELECTED)
: TRUE;
#if 1
- /* a hack. The whole filtering idea is bit silly since we
- keep checking flags (or maybe more!) on all messages so
- that the time spent on changing the selection grows
- linearly with the mailbox size! */
- if (LIBBALSA_IS_MAILBOX_IMAP(mailbox) &&
- !libbalsa_mailbox_imap_is_connected
- (LIBBALSA_MAILBOX_IMAP(mailbox)))
- filt_out = FALSE;
+ /* a hack. The whole filtering idea is bit silly since we
+ keep checking flags (or maybe more!) on all messages so
+ that the time spent on changing the selection grows
+ linearly with the mailbox size! */
+ if (LIBBALSA_IS_MAILBOX_IMAP(mailbox) &&
+ !libbalsa_mailbox_imap_is_connected
+ (LIBBALSA_MAILBOX_IMAP(mailbox))) {
+ filt_out = FALSE;
+ }
#endif
- if (filt_out)
+ if (filt_out) {
libbalsa_mailbox_msgno_filt_out(mailbox, node);
+ }
}
} else {
- if (match)
+ if (match) {
libbalsa_mailbox_msgno_filt_in(mailbox, seqno);
+ }
}
}
+
typedef struct {
- LibBalsaMailbox *mailbox;
- guint seqno;
+ LibBalsaMailbox *mailbox;
+ guint seqno;
LibBalsaMailboxSearchIter *search_iter;
- gboolean hold_selected;
+ gboolean hold_selected;
} LibBalsaMailboxMsgnoFiltCheckInfo;
static gboolean
-lbm_msgno_filt_check_idle_cb(LibBalsaMailboxMsgnoFiltCheckInfo * info)
+lbm_msgno_filt_check_idle_cb(LibBalsaMailboxMsgnoFiltCheckInfo *info)
{
- if (MAILBOX_OPEN(info->mailbox))
+ if (MAILBOX_OPEN(info->mailbox)) {
lbm_msgno_filt_check(info->mailbox, info->seqno, info->search_iter,
info->hold_selected);
+ }
g_object_unref(info->mailbox);
libbalsa_mailbox_search_iter_unref(info->search_iter);
@@ -1680,10 +1813,12 @@ lbm_msgno_filt_check_idle_cb(LibBalsaMailboxMsgnoFiltCheckInfo * info)
return FALSE;
}
+
void
-libbalsa_mailbox_msgno_filt_check(LibBalsaMailbox * mailbox, guint seqno,
- LibBalsaMailboxSearchIter * search_iter,
- gboolean hold_selected)
+libbalsa_mailbox_msgno_filt_check(LibBalsaMailbox *mailbox,
+ guint seqno,
+ LibBalsaMailboxSearchIter *search_iter,
+ gboolean hold_selected)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -1698,27 +1833,29 @@ libbalsa_mailbox_msgno_filt_check(LibBalsaMailbox * mailbox, guint seqno,
} else {
LibBalsaMailboxMsgnoFiltCheckInfo *info;
- info = g_new(LibBalsaMailboxMsgnoFiltCheckInfo, 1);
- info->mailbox = g_object_ref(mailbox);
- info->seqno = seqno;
- info->search_iter = libbalsa_mailbox_search_iter_ref(search_iter);
+ info = g_new(LibBalsaMailboxMsgnoFiltCheckInfo, 1);
+ info->mailbox = g_object_ref(mailbox);
+ info->seqno = seqno;
+ info->search_iter = libbalsa_mailbox_search_iter_ref(search_iter);
info->hold_selected = hold_selected;
g_idle_add((GSourceFunc) lbm_msgno_filt_check_idle_cb, info);
}
}
+
/* Search iters */
LibBalsaMailboxSearchIter *
-libbalsa_mailbox_search_iter_new(LibBalsaCondition * condition)
+libbalsa_mailbox_search_iter_new(LibBalsaCondition *condition)
{
LibBalsaMailboxSearchIter *iter;
- if (!condition)
+ if (!condition) {
return NULL;
+ }
- iter = g_slice_new(LibBalsaMailboxSearchIter);
- iter->mailbox = NULL;
- iter->stamp = 0;
+ iter = g_slice_new(LibBalsaMailboxSearchIter);
+ iter->mailbox = NULL;
+ iter->stamp = 0;
iter->condition = libbalsa_condition_ref(condition);
iter->user_data = NULL;
iter->ref_count = 1;
@@ -1726,9 +1863,10 @@ libbalsa_mailbox_search_iter_new(LibBalsaCondition * condition)
return iter;
}
+
/* Create a LibBalsaMailboxSearchIter for a mailbox's view_filter. */
LibBalsaMailboxSearchIter *
-libbalsa_mailbox_search_iter_view(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_search_iter_view(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -1737,50 +1875,58 @@ libbalsa_mailbox_search_iter_view(LibBalsaMailbox * mailbox)
return libbalsa_mailbox_search_iter_new(priv->view_filter);
}
+
/* Increment reference count of a LibBalsaMailboxSearchIter, if it is
* valid */
LibBalsaMailboxSearchIter *
-libbalsa_mailbox_search_iter_ref(LibBalsaMailboxSearchIter * search_iter)
+libbalsa_mailbox_search_iter_ref(LibBalsaMailboxSearchIter *search_iter)
{
- if (search_iter)
+ if (search_iter) {
++search_iter->ref_count;
+ }
return search_iter;
}
+
/* Decrement reference count of a LibBalsaMailboxSearchIter, if it is
* non-NULL and valid, and free it if it goes to zero */
void
-libbalsa_mailbox_search_iter_unref(LibBalsaMailboxSearchIter * search_iter)
+libbalsa_mailbox_search_iter_unref(LibBalsaMailboxSearchIter *search_iter)
{
LibBalsaMailbox *mailbox;
- if (!search_iter || --search_iter->ref_count > 0)
+ if (!search_iter || (--search_iter->ref_count > 0)) {
return;
+ }
mailbox = search_iter->mailbox;
- if (mailbox && LIBBALSA_MAILBOX_GET_CLASS(mailbox)->search_iter_free)
+ if (mailbox && LIBBALSA_MAILBOX_GET_CLASS(mailbox)->search_iter_free) {
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->search_iter_free(search_iter);
+ }
libbalsa_condition_unref(search_iter->condition);
g_slice_free(LibBalsaMailboxSearchIter, search_iter);
}
+
/* GNode iterators; they return the root node when they run out of nodes,
* and find the appropriate starting node when called with the root. */
static GNode *
-lbm_next(GNode * node)
+lbm_next(GNode *node)
{
/* next is: our first child, if we have one;
* else our sibling, if we have one;
* else the sibling of our first ancestor who has
* one. */
- if (node->children)
+ if (node->children) {
return node->children;
+ }
do {
- if (node->next)
+ if (node->next) {
return node->next;
+ }
node = node->parent;
g_assert(node != NULL);
} while (!G_NODE_IS_ROOT(node));
@@ -1788,39 +1934,47 @@ lbm_next(GNode * node)
return node;
}
+
static GNode *
-lbm_last_descendant(GNode * node)
+lbm_last_descendant(GNode *node)
{
if (node->children) {
GNode *tmp;
node = node->children;
- while ((tmp = node->next) || (tmp = node->children))
+ while ((tmp = node->next) || (tmp = node->children)) {
node = tmp;
+ }
}
return node;
}
+
static GNode *
-lbm_prev(GNode * node)
+lbm_prev(GNode *node)
{
- if (G_NODE_IS_ROOT(node))
+ if (G_NODE_IS_ROOT(node)) {
return lbm_last_descendant(node);
+ }
/* previous is: if we have a sibling,
* if it has children, its last descendant;
* else the sibling;
* else our parent. */
- if (node->prev)
+ if (node->prev) {
return lbm_last_descendant(node->prev);
+ }
return node->parent;
}
+
/* Find a message in the tree-model, by its message number. */
gboolean
-libbalsa_mailbox_msgno_find(LibBalsaMailbox * mailbox, guint seqno,
- GtkTreePath ** path, GtkTreeIter * iter)
+libbalsa_mailbox_msgno_find(LibBalsaMailbox *mailbox,
+ guint seqno,
+ GtkTreePath **path,
+ GtkTreeIter *iter)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GtkTreeIter tmp_iter;
@@ -1829,21 +1983,25 @@ libbalsa_mailbox_msgno_find(LibBalsaMailbox * mailbox, guint seqno,
g_return_val_if_fail(seqno > 0, FALSE);
if (!priv->msg_tree || !(tmp_iter.user_data =
- g_node_find(priv->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL,
- GINT_TO_POINTER(seqno))))
+ g_node_find(priv->msg_tree, G_PRE_ORDER, G_TRAVERSE_ALL,
+ GINT_TO_POINTER(seqno)))) {
return FALSE;
+ }
tmp_iter.stamp = priv->stamp;
- if (path)
+ if (path) {
*path =
gtk_tree_model_get_path(GTK_TREE_MODEL(mailbox), &tmp_iter);
- if (iter)
+ }
+ if (iter) {
*iter = tmp_iter;
+ }
return TRUE;
}
+
struct AddMessageData {
GMimeStream *stream;
LibBalsaMessageFlag flags;
@@ -1851,22 +2009,27 @@ struct AddMessageData {
};
static gboolean
-msg_iterator(LibBalsaMessageFlag *flg, GMimeStream **stream, void *arg)
+msg_iterator(LibBalsaMessageFlag *flg,
+ GMimeStream **stream,
+ void *arg)
{
- struct AddMessageData * amd = (struct AddMessageData*)arg;
- if (amd->processed)
+ struct AddMessageData *amd = (struct AddMessageData *)arg;
+ if (amd->processed) {
return FALSE;
+ }
amd->processed = TRUE;
- *flg = amd->flags;
- /* Make sure ::add_messages does not destroy the stream. */
+ *flg = amd->flags;
+ /* Make sure ::add_messages does not destroy the stream. */
*stream = g_object_ref(amd->stream);
return TRUE;
}
+
gboolean
-libbalsa_mailbox_add_message(LibBalsaMailbox * mailbox,
- GMimeStream * stream,
- LibBalsaMessageFlag flags, GError ** err)
+libbalsa_mailbox_add_message(LibBalsaMailbox *mailbox,
+ GMimeStream *stream,
+ LibBalsaMessageFlag flags,
+ GError **err)
{
guint retval;
struct AddMessageData amd;
@@ -1875,17 +2038,18 @@ libbalsa_mailbox_add_message(LibBalsaMailbox * mailbox,
libbalsa_lock_mailbox(mailbox);
- amd.stream = stream;
- amd.flags = flags;
+ amd.stream = stream;
+ amd.flags = flags;
amd.processed = FALSE;
- retval =
- LIBBALSA_MAILBOX_GET_CLASS(mailbox)->add_messages(mailbox,
- msg_iterator, &amd,
- err);
+ retval =
+ LIBBALSA_MAILBOX_GET_CLASS(mailbox)->add_messages(mailbox,
+ msg_iterator, &amd,
+ err);
if (retval) {
if (!(flags & LIBBALSA_MESSAGE_FLAG_DELETED)
- && (flags & LIBBALSA_MESSAGE_FLAG_NEW))
+ && (flags & LIBBALSA_MESSAGE_FLAG_NEW)) {
libbalsa_mailbox_set_unread_messages_flag(mailbox, TRUE);
+ }
lbm_queue_check(mailbox);
}
@@ -1894,11 +2058,12 @@ libbalsa_mailbox_add_message(LibBalsaMailbox * mailbox,
return retval;
}
+
guint
-libbalsa_mailbox_add_messages(LibBalsaMailbox * mailbox,
- LibBalsaAddMessageIterator iterator,
- void *arg,
- GError ** err)
+libbalsa_mailbox_add_messages(LibBalsaMailbox *mailbox,
+ LibBalsaAddMessageIterator iterator,
+ void *arg,
+ GError **err)
{
guint retval;
@@ -1908,17 +2073,18 @@ libbalsa_mailbox_add_messages(LibBalsaMailbox * mailbox,
libbalsa_lock_mailbox(mailbox);
retval =
- LIBBALSA_MAILBOX_GET_CLASS(mailbox)->add_messages(mailbox,
- iterator, arg,
- err);
+ LIBBALSA_MAILBOX_GET_CLASS(mailbox)->add_messages(mailbox,
+ iterator, arg,
+ err);
if (retval) {
#ifdef FIXED
- /* this is something that should be returned/taken care of by
- add_messages? */
+ /* this is something that should be returned/taken care of by
+ add_messages? */
if (!(flags & LIBBALSA_MESSAGE_FLAG_DELETED)
- && (flags & LIBBALSA_MESSAGE_FLAG_NEW))
+ && (flags & LIBBALSA_MESSAGE_FLAG_NEW)) {
libbalsa_mailbox_set_unread_messages_flag(mailbox, TRUE);
+ }
#endif
lbm_queue_check(mailbox);
}
@@ -1928,8 +2094,9 @@ libbalsa_mailbox_add_messages(LibBalsaMailbox * mailbox,
return retval;
}
+
gboolean
-libbalsa_mailbox_close_backend(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_close_backend(LibBalsaMailbox *mailbox)
{
g_return_val_if_fail(mailbox != NULL, FALSE);
g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), FALSE);
@@ -1938,8 +2105,9 @@ libbalsa_mailbox_close_backend(LibBalsaMailbox * mailbox)
return LIBBALSA_MAILBOX_GET_CLASS(mailbox)->close_backend(mailbox);
}
+
guint
-libbalsa_mailbox_total_messages(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_total_messages(LibBalsaMailbox *mailbox)
{
g_return_val_if_fail(mailbox != NULL, 0);
g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), 0);
@@ -1948,11 +2116,13 @@ libbalsa_mailbox_total_messages(LibBalsaMailbox * mailbox)
return LIBBALSA_MAILBOX_GET_CLASS(mailbox)->total_messages(mailbox);
}
+
gboolean
-libbalsa_mailbox_sync_storage(LibBalsaMailbox * mailbox, gboolean expunge)
+libbalsa_mailbox_sync_storage(LibBalsaMailbox *mailbox,
+ gboolean expunge)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
- gboolean retval = TRUE;
+ gboolean retval = TRUE;
g_return_val_if_fail(mailbox != NULL, FALSE);
g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), FALSE);
@@ -1974,28 +2144,34 @@ libbalsa_mailbox_sync_storage(LibBalsaMailbox * mailbox, gboolean expunge)
return retval;
}
+
static void
-lbm_cache_message(LibBalsaMailbox * mailbox, guint msgno,
- LibBalsaMessage * message)
+lbm_cache_message(LibBalsaMailbox *mailbox,
+ guint msgno,
+ LibBalsaMessage *message)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
LibBalsaMailboxIndexEntry *entry;
- if (priv->mindex->len < msgno)
+ if (priv->mindex->len < msgno) {
g_ptr_array_set_size(priv->mindex, msgno);
+ }
entry = g_ptr_array_index(priv->mindex, msgno - 1);
if (!entry) {
g_ptr_array_index(priv->mindex, msgno - 1) =
- entry = g_new(LibBalsaMailboxIndexEntry, 1);
+ entry = g_new(LibBalsaMailboxIndexEntry, 1);
lbm_index_entry_populate_from_msg(entry, message);
- } else if (entry->idle_pending)
+ } else if (entry->idle_pending) {
lbm_index_entry_populate_from_msg(entry, message);
+ }
}
+
LibBalsaMessage *
-libbalsa_mailbox_get_message(LibBalsaMailbox * mailbox, guint msgno)
+libbalsa_mailbox_get_message(LibBalsaMailbox *mailbox,
+ guint msgno)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
LibBalsaMessage *message;
@@ -2013,25 +2189,28 @@ libbalsa_mailbox_get_message(LibBalsaMailbox * mailbox, guint msgno)
return NULL;
}
- if( !(msgno > 0 && msgno <= libbalsa_mailbox_total_messages(mailbox)) ) {
- libbalsa_unlock_mailbox(mailbox);
- g_warning("get_message: msgno %d out of range", msgno);
- return NULL;
+ if ( !((msgno > 0) && (msgno <= libbalsa_mailbox_total_messages(mailbox)))) {
+ libbalsa_unlock_mailbox(mailbox);
+ g_warning("get_message: msgno %d out of range", msgno);
+ return NULL;
}
message = LIBBALSA_MAILBOX_GET_CLASS(mailbox)->get_message(mailbox,
msgno);
- if (message && priv->mindex)
+ if (message && priv->mindex) {
/* Cache the message info, if we do not already have it. */
lbm_cache_message(mailbox, msgno, message);
+ }
libbalsa_unlock_mailbox(mailbox);
return message;
}
+
gboolean
-libbalsa_mailbox_prepare_threading(LibBalsaMailbox * mailbox, guint start)
+libbalsa_mailbox_prepare_threading(LibBalsaMailbox *mailbox,
+ guint start)
{
g_return_val_if_fail(mailbox != NULL, FALSE);
g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), FALSE);
@@ -2041,9 +2220,10 @@ libbalsa_mailbox_prepare_threading(LibBalsaMailbox * mailbox, guint start)
start);
}
+
gboolean
-libbalsa_mailbox_fetch_message_structure(LibBalsaMailbox *mailbox,
- LibBalsaMessage *message,
+libbalsa_mailbox_fetch_message_structure(LibBalsaMailbox *mailbox,
+ LibBalsaMessage *message,
LibBalsaFetchFlag flags)
{
g_return_val_if_fail(mailbox != NULL, FALSE);
@@ -2052,12 +2232,13 @@ libbalsa_mailbox_fetch_message_structure(LibBalsaMailbox *mailbox,
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
return LIBBALSA_MAILBOX_GET_CLASS(mailbox)
- ->fetch_message_structure(mailbox, message, flags);
+ ->fetch_message_structure(mailbox, message, flags);
}
+
void
-libbalsa_mailbox_release_message(LibBalsaMailbox * mailbox,
- LibBalsaMessage * message)
+libbalsa_mailbox_release_message(LibBalsaMailbox *mailbox,
+ LibBalsaMessage *message)
{
g_return_if_fail(mailbox != NULL);
g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
@@ -2069,6 +2250,7 @@ libbalsa_mailbox_release_message(LibBalsaMailbox * mailbox,
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->release_message(mailbox, message);
}
+
void
libbalsa_mailbox_set_msg_headers(LibBalsaMailbox *mailbox,
LibBalsaMessage *message)
@@ -2078,16 +2260,17 @@ libbalsa_mailbox_set_msg_headers(LibBalsaMailbox *mailbox,
g_return_if_fail(message != NULL);
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
- if(!message->has_all_headers) {
+ if (!message->has_all_headers) {
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->fetch_headers(mailbox, message);
message->has_all_headers = 1;
}
}
+
gboolean
-libbalsa_mailbox_get_message_part(LibBalsaMessage *message,
+libbalsa_mailbox_get_message_part(LibBalsaMessage *message,
LibBalsaMessageBody *part,
- GError **err)
+ GError **err)
{
g_return_val_if_fail(message != NULL, FALSE);
g_return_val_if_fail(message->mailbox != NULL, FALSE);
@@ -2096,12 +2279,14 @@ libbalsa_mailbox_get_message_part(LibBalsaMessage *message,
g_return_val_if_fail(part != NULL, FALSE);
return LIBBALSA_MAILBOX_GET_CLASS(message->mailbox)
- ->get_message_part(message, part, err);
+ ->get_message_part(message, part, err);
}
+
GMimeStream *
-libbalsa_mailbox_get_message_stream(LibBalsaMailbox * mailbox, guint msgno,
- gboolean peek)
+libbalsa_mailbox_get_message_stream(LibBalsaMailbox *mailbox,
+ guint msgno,
+ gboolean peek)
{
g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), NULL);
g_return_val_if_fail(msgno <= libbalsa_mailbox_total_messages(mailbox),
@@ -2110,15 +2295,16 @@ libbalsa_mailbox_get_message_stream(LibBalsaMailbox * mailbox, guint msgno,
return LIBBALSA_MAILBOX_GET_CLASS(mailbox)->get_message_stream(mailbox,
msgno,
- peek);
+ peek);
}
+
/* libbalsa_mailbox_change_msgs_flags() changes stored message flags
and is to be used only internally by libbalsa.
-*/
+ */
gboolean
-libbalsa_mailbox_messages_change_flags(LibBalsaMailbox * mailbox,
- GArray * msgnos,
+libbalsa_mailbox_messages_change_flags(LibBalsaMailbox *mailbox,
+ GArray *msgnos,
LibBalsaMessageFlag set,
LibBalsaMessageFlag clear)
{
@@ -2133,14 +2319,16 @@ libbalsa_mailbox_messages_change_flags(LibBalsaMailbox * mailbox,
real_flag = (set | clear) & LIBBALSA_MESSAGE_FLAGS_REAL;
g_return_val_if_fail(!priv->readonly || !real_flag, FALSE);
- if (msgnos->len == 0)
- return TRUE;
+ if (msgnos->len == 0) {
+ return TRUE;
+ }
- if (real_flag)
- libbalsa_lock_mailbox(mailbox);
+ if (real_flag) {
+ libbalsa_lock_mailbox(mailbox);
+ }
retval = LIBBALSA_MAILBOX_GET_CLASS(mailbox)->
- messages_change_flags(mailbox, msgnos, set, clear);
+ messages_change_flags(mailbox, msgnos, set, clear);
if (retval && priv->mindex && priv->view_filter) {
LibBalsaMailboxSearchIter *iter_view =
@@ -2153,18 +2341,21 @@ libbalsa_mailbox_messages_change_flags(LibBalsaMailbox * mailbox,
libbalsa_mailbox_search_iter_unref(iter_view);
}
- if (real_flag)
- libbalsa_unlock_mailbox(mailbox);
+ if (real_flag) {
+ libbalsa_unlock_mailbox(mailbox);
+ }
- if ((set & LIBBALSA_MESSAGE_FLAG_DELETED) && retval)
+ if ((set & LIBBALSA_MESSAGE_FLAG_DELETED) && retval) {
libbalsa_mailbox_changed(mailbox);
+ }
return retval;
}
+
gboolean
-libbalsa_mailbox_msgno_change_flags(LibBalsaMailbox * mailbox,
- guint msgno,
+libbalsa_mailbox_msgno_change_flags(LibBalsaMailbox *mailbox,
+ guint msgno,
LibBalsaMessageFlag set,
LibBalsaMessageFlag clear)
{
@@ -2182,10 +2373,13 @@ libbalsa_mailbox_msgno_change_flags(LibBalsaMailbox * mailbox,
return retval;
}
+
/* Copy messages with msgnos in the list from mailbox to dest. */
gboolean
-libbalsa_mailbox_messages_copy(LibBalsaMailbox * mailbox, GArray * msgnos,
- LibBalsaMailbox * dest, GError **err)
+libbalsa_mailbox_messages_copy(LibBalsaMailbox *mailbox,
+ GArray *msgnos,
+ LibBalsaMailbox *dest,
+ GError **err)
{
gboolean retval;
@@ -2200,11 +2394,13 @@ libbalsa_mailbox_messages_copy(LibBalsaMailbox * mailbox, GArray * msgnos,
return retval;
}
+
/* Move messages with msgnos in the list from mailbox to dest. */
gboolean
-libbalsa_mailbox_messages_move(LibBalsaMailbox * mailbox,
- GArray * msgnos,
- LibBalsaMailbox * dest, GError **err)
+libbalsa_mailbox_messages_move(LibBalsaMailbox *mailbox,
+ GArray *msgnos,
+ LibBalsaMailbox *dest,
+ GError **err)
{
gboolean retval;
@@ -2214,19 +2410,22 @@ libbalsa_mailbox_messages_move(LibBalsaMailbox * mailbox,
libbalsa_lock_mailbox(mailbox);
if (libbalsa_mailbox_messages_copy(mailbox, msgnos, dest, err)) {
retval = libbalsa_mailbox_messages_change_flags
- (mailbox, msgnos, LIBBALSA_MESSAGE_FLAG_DELETED,
- (LibBalsaMessageFlag) 0);
- if(!retval)
- g_set_error(err,LIBBALSA_MAILBOX_ERROR,
+ (mailbox, msgnos, LIBBALSA_MESSAGE_FLAG_DELETED,
+ (LibBalsaMessageFlag) 0);
+ if (!retval) {
+ g_set_error(err, LIBBALSA_MAILBOX_ERROR,
LIBBALSA_MAILBOX_COPY_ERROR,
- _("Removing messages from source mailbox failed"));
- } else
+ _("Removing messages from source mailbox failed"));
+ }
+ } else {
retval = FALSE;
+ }
libbalsa_unlock_mailbox(mailbox);
return retval;
}
+
/*
* Mailbox views.
*
@@ -2237,19 +2436,20 @@ libbalsa_mailbox_messages_move(LibBalsaMailbox * mailbox,
* Returns TRUE if the message tree was updated.
*/
gboolean
-libbalsa_mailbox_set_view_filter(LibBalsaMailbox *mailbox,
+libbalsa_mailbox_set_view_filter(LibBalsaMailbox *mailbox,
LibBalsaCondition *cond,
- gboolean update_immediately)
+ gboolean update_immediately)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
- gboolean retval = FALSE;
+ gboolean retval = FALSE;
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
libbalsa_lock_mailbox(mailbox);
- if (!libbalsa_condition_compare(priv->view_filter, cond))
+ if (!libbalsa_condition_compare(priv->view_filter, cond)) {
priv->view_filter_pending = TRUE;
+ }
libbalsa_condition_unref(priv->view_filter);
priv->view_filter = libbalsa_condition_ref(cond);
@@ -2257,7 +2457,7 @@ libbalsa_mailbox_set_view_filter(LibBalsaMailbox *mailbox,
if (update_immediately && priv->view_filter_pending) {
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->update_view_filter(mailbox,
cond);
- retval = lbm_set_threading(mailbox, priv->view->threading_type);
+ retval = lbm_set_threading(mailbox, priv->view->threading_type);
priv->view_filter_pending = FALSE;
}
@@ -2266,8 +2466,9 @@ libbalsa_mailbox_set_view_filter(LibBalsaMailbox *mailbox,
return retval;
}
+
void
-libbalsa_mailbox_make_view_filter_persistent(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_make_view_filter_persistent(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -2276,9 +2477,11 @@ libbalsa_mailbox_make_view_filter_persistent(LibBalsaMailbox * mailbox)
libbalsa_condition_ref(priv->view_filter);
}
+
/* Test message flags. */
gboolean
-libbalsa_mailbox_msgno_has_flags(LibBalsaMailbox * mailbox, guint msgno,
+libbalsa_mailbox_msgno_has_flags(LibBalsaMailbox *mailbox,
+ guint msgno,
LibBalsaMessageFlag set,
LibBalsaMessageFlag unset)
{
@@ -2291,19 +2494,21 @@ libbalsa_mailbox_msgno_has_flags(LibBalsaMailbox * mailbox, guint msgno,
unset);
}
+
/* Inquire method: check whether mailbox driver can perform operation
in question. In principle, all operations should be supported but
some of them may be expensive under certain circumstances and are
best avoided. */
static gboolean
-libbalsa_mailbox_real_can_do(LibBalsaMailbox* mbox,
+libbalsa_mailbox_real_can_do(LibBalsaMailbox *mbox,
enum LibBalsaMailboxCapability cap)
{
return TRUE;
}
+
gboolean
-libbalsa_mailbox_can_do(LibBalsaMailbox *mailbox,
+libbalsa_mailbox_can_do(LibBalsaMailbox *mailbox,
enum LibBalsaMailboxCapability cap)
{
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
@@ -2312,35 +2517,40 @@ libbalsa_mailbox_can_do(LibBalsaMailbox *mailbox,
}
-static void lbm_sort(LibBalsaMailbox * mbox, GNode * parent);
+static void lbm_sort(LibBalsaMailbox *mbox,
+ GNode *parent);
static void
-lbm_check_and_sort(LibBalsaMailbox * mailbox)
+lbm_check_and_sort(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
- if (priv->msg_tree)
+ if (priv->msg_tree) {
lbm_sort(mailbox, priv->msg_tree);
+ }
libbalsa_mailbox_changed(mailbox);
}
+
static gboolean
-lbm_set_threading_idle_cb(LibBalsaMailbox * mailbox)
+lbm_set_threading_idle_cb(LibBalsaMailbox *mailbox)
{
lbm_check_and_sort(mailbox);
g_object_unref(mailbox);
return FALSE;
}
+
static gboolean
-lbm_set_threading(LibBalsaMailbox * mailbox,
+lbm_set_threading(LibBalsaMailbox *mailbox,
LibBalsaMailboxThreadingType thread_type)
{
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
- if (!MAILBOX_OPEN(mailbox))
+ if (!MAILBOX_OPEN(mailbox)) {
return FALSE;
+ }
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->set_threading(mailbox,
thread_type);
@@ -2353,8 +2563,9 @@ lbm_set_threading(LibBalsaMailbox * mailbox,
return TRUE;
}
+
void
-libbalsa_mailbox_set_threading(LibBalsaMailbox *mailbox,
+libbalsa_mailbox_set_threading(LibBalsaMailbox *mailbox,
LibBalsaMailboxThreadingType thread_type)
{
g_return_if_fail(mailbox != NULL);
@@ -2365,23 +2576,24 @@ libbalsa_mailbox_set_threading(LibBalsaMailbox *mailbox,
libbalsa_unlock_mailbox(mailbox);
}
+
/* =================================================================== *
- * Mailbox view methods *
- * =================================================================== */
+* Mailbox view methods *
+* =================================================================== */
static LibBalsaMailboxView libbalsa_mailbox_view_default = {
- NULL, /* identity_name */
- LB_MAILBOX_THREADING_FLAT, /* threading_type */
- 0, /* filter */
- LB_MAILBOX_SORT_TYPE_ASC, /* sort_type */
+ NULL, /* identity_name */
+ LB_MAILBOX_THREADING_FLAT, /* threading_type */
+ 0, /* filter */
+ LB_MAILBOX_SORT_TYPE_ASC, /* sort_type */
LB_MAILBOX_SORT_NO, /* sort_field */
LB_MAILBOX_SORT_NO, /* sort_field_prev */
- LB_MAILBOX_SHOW_UNSET, /* show */
- LB_MAILBOX_SUBSCRIBE_UNSET, /* subscribe */
- 0, /* exposed */
- 0, /* open */
- 1, /* in_sync */
- 0, /* used */
+ LB_MAILBOX_SHOW_UNSET, /* show */
+ LB_MAILBOX_SUBSCRIBE_UNSET, /* subscribe */
+ 0, /* exposed */
+ 0, /* open */
+ 1, /* in_sync */
+ 0, /* used */
#ifdef HAVE_GPGME
LB_MAILBOX_CHK_CRYPT_MAYBE, /* gpg_chk_mode */
#endif
@@ -2395,169 +2607,200 @@ libbalsa_mailbox_view_new(void)
{
LibBalsaMailboxView *view;
- view = g_new(LibBalsaMailboxView, 1);
+ view = g_new(LibBalsaMailboxView, 1);
*view = libbalsa_mailbox_view_default;
return view;
}
+
void
-libbalsa_mailbox_view_free(LibBalsaMailboxView * view)
+libbalsa_mailbox_view_free(LibBalsaMailboxView *view)
{
- if (!view)
+ if (!view) {
return;
+ }
g_free(view->identity_name);
g_free(view);
}
+
/* helper */
static LibBalsaMailboxView *
-lbm_get_view(LibBalsaMailbox * mailbox)
+lbm_get_view(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
- if (!mailbox)
- return &libbalsa_mailbox_view_default;
+ if (!mailbox) {
+ return &libbalsa_mailbox_view_default;
+ }
- if (!priv->view)
+ if (!priv->view) {
priv->view = libbalsa_mailbox_view_new();
+ }
return priv->view;
}
+
/* Set methods; NULL mailbox is valid, and changes the default value. */
gboolean
-libbalsa_mailbox_set_identity_name(LibBalsaMailbox * mailbox,
- const gchar * identity_name)
+libbalsa_mailbox_set_identity_name(LibBalsaMailbox *mailbox,
+ const gchar *identity_name)
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
if (g_strcmp0(view->identity_name, identity_name) != 0) {
- g_free(view->identity_name);
- view->identity_name = g_strdup(identity_name);
- if (mailbox)
- view->in_sync = 0;
- return TRUE;
- } else
- return FALSE;
+ g_free(view->identity_name);
+ view->identity_name = g_strdup(identity_name);
+ if (mailbox) {
+ view->in_sync = 0;
+ }
+ return TRUE;
+ } else {
+ return FALSE;
+ }
}
+
void
-libbalsa_mailbox_set_threading_type(LibBalsaMailbox * mailbox,
- LibBalsaMailboxThreadingType
- threading_type)
+libbalsa_mailbox_set_threading_type(LibBalsaMailbox *mailbox,
+ LibBalsaMailboxThreadingType
+ threading_type)
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
if (view->threading_type != threading_type) {
- view->threading_type = threading_type;
- if (mailbox)
- view->in_sync = 0;
+ view->threading_type = threading_type;
+ if (mailbox) {
+ view->in_sync = 0;
+ }
}
}
+
void
-libbalsa_mailbox_set_sort_type(LibBalsaMailbox * mailbox,
- LibBalsaMailboxSortType sort_type)
+libbalsa_mailbox_set_sort_type(LibBalsaMailbox *mailbox,
+ LibBalsaMailboxSortType sort_type)
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
if (view->sort_type != sort_type) {
- view->sort_type = sort_type;
- if (mailbox)
- view->in_sync = 0;
+ view->sort_type = sort_type;
+ if (mailbox) {
+ view->in_sync = 0;
+ }
}
}
+
void
-libbalsa_mailbox_set_sort_field(LibBalsaMailbox * mailbox,
- LibBalsaMailboxSortFields sort_field)
+libbalsa_mailbox_set_sort_field(LibBalsaMailbox *mailbox,
+ LibBalsaMailboxSortFields sort_field)
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
if (view->sort_field != sort_field) {
- view->sort_field_prev = view->sort_field;
- view->sort_field = sort_field;
- if (mailbox)
- view->in_sync = 0;
+ view->sort_field_prev = view->sort_field;
+ view->sort_field = sort_field;
+ if (mailbox) {
+ view->in_sync = 0;
+ }
}
}
+
gboolean
-libbalsa_mailbox_set_show(LibBalsaMailbox * mailbox, LibBalsaMailboxShow show)
+libbalsa_mailbox_set_show(LibBalsaMailbox *mailbox,
+ LibBalsaMailboxShow show)
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
if (view->show != show) {
- /* Don't set not in sync if we're just replacing UNSET with the
- * default. */
- if (mailbox && view->show != LB_MAILBOX_SHOW_UNSET)
- view->in_sync = 0;
- view->show = show;
- return TRUE;
- } else
- return FALSE;
+ /* Don't set not in sync if we're just replacing UNSET with the
+ * default. */
+ if (mailbox && (view->show != LB_MAILBOX_SHOW_UNSET)) {
+ view->in_sync = 0;
+ }
+ view->show = show;
+ return TRUE;
+ } else {
+ return FALSE;
+ }
}
+
gboolean
-libbalsa_mailbox_set_subscribe(LibBalsaMailbox * mailbox,
+libbalsa_mailbox_set_subscribe(LibBalsaMailbox *mailbox,
LibBalsaMailboxSubscribe subscribe)
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
if (view->subscribe != subscribe) {
- /* Don't set not in sync if we're just replacing UNSET with the
- * default. */
- if (mailbox && view->subscribe != LB_MAILBOX_SUBSCRIBE_UNSET)
- view->in_sync = 0;
- view->subscribe = subscribe;
- return TRUE;
- } else
- return FALSE;
+ /* Don't set not in sync if we're just replacing UNSET with the
+ * default. */
+ if (mailbox && (view->subscribe != LB_MAILBOX_SUBSCRIBE_UNSET)) {
+ view->in_sync = 0;
+ }
+ view->subscribe = subscribe;
+ return TRUE;
+ } else {
+ return FALSE;
+ }
}
+
void
-libbalsa_mailbox_set_exposed(LibBalsaMailbox * mailbox, gboolean exposed)
+libbalsa_mailbox_set_exposed(LibBalsaMailbox *mailbox,
+ gboolean exposed)
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
if (view->exposed != exposed) {
- view->exposed = exposed ? 1 : 0;
- if (mailbox)
- view->in_sync = 0;
+ view->exposed = exposed ? 1 : 0;
+ if (mailbox) {
+ view->in_sync = 0;
+ }
}
}
+
void
-libbalsa_mailbox_set_open(LibBalsaMailbox * mailbox, gboolean open)
+libbalsa_mailbox_set_open(LibBalsaMailbox *mailbox,
+ gboolean open)
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
if (view->open != open) {
- view->open = open ? 1 : 0;
- if (mailbox)
- view->in_sync = 0;
+ view->open = open ? 1 : 0;
+ if (mailbox) {
+ view->in_sync = 0;
+ }
}
}
+
void
-libbalsa_mailbox_set_filter(LibBalsaMailbox * mailbox, gint filter)
+libbalsa_mailbox_set_filter(LibBalsaMailbox *mailbox,
+ gint filter)
{
LibBalsaMailboxView *view = lbm_get_view(mailbox);
if (view->filter != filter) {
- view->filter = filter;
- if (mailbox)
- view->in_sync = 0;
+ view->filter = filter;
+ if (mailbox) {
+ view->in_sync = 0;
+ }
}
}
+
#ifdef HAVE_GPGME
-gboolean
-libbalsa_mailbox_set_crypto_mode(LibBalsaMailbox * mailbox,
- LibBalsaChkCryptoMode gpg_chk_mode)
+gboolean
+libbalsa_mailbox_set_crypto_mode(LibBalsaMailbox *mailbox,
+ LibBalsaChkCryptoMode gpg_chk_mode)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
LibBalsaMailboxView *view;
@@ -2566,32 +2809,38 @@ libbalsa_mailbox_set_crypto_mode(LibBalsaMailbox * mailbox,
view = priv->view;
if (view->gpg_chk_mode != gpg_chk_mode) {
- view->gpg_chk_mode = gpg_chk_mode;
- return TRUE;
- } else
- return FALSE;
+ view->gpg_chk_mode = gpg_chk_mode;
+ return TRUE;
+ } else {
+ return FALSE;
+ }
}
+
+
#endif
void
-libbalsa_mailbox_set_unread(LibBalsaMailbox * mailbox, gint unread)
+libbalsa_mailbox_set_unread(LibBalsaMailbox *mailbox,
+ gint unread)
{
LibBalsaMailboxView *view;
/* Changing the default is not allowed. */
g_return_if_fail(mailbox != NULL);
- view = lbm_get_view(mailbox);
+ view = lbm_get_view(mailbox);
view->used = 1;
if (view->unread != unread) {
- view->unread = unread;
+ view->unread = unread;
view->in_sync = 0;
}
}
+
void
-libbalsa_mailbox_set_total(LibBalsaMailbox * mailbox, gint total)
+libbalsa_mailbox_set_total(LibBalsaMailbox *mailbox,
+ gint total)
{
LibBalsaMailboxView *view;
@@ -2601,13 +2850,15 @@ libbalsa_mailbox_set_total(LibBalsaMailbox * mailbox, gint total)
view = lbm_get_view(mailbox);
if (view->total != total) {
- view->total = total;
+ view->total = total;
view->in_sync = 0;
}
}
+
void
-libbalsa_mailbox_set_mtime(LibBalsaMailbox * mailbox, time_t mtime)
+libbalsa_mailbox_set_mtime(LibBalsaMailbox *mailbox,
+ time_t mtime)
{
LibBalsaMailboxView *view;
@@ -2617,190 +2868,209 @@ libbalsa_mailbox_set_mtime(LibBalsaMailbox * mailbox, time_t mtime)
view = lbm_get_view(mailbox);
if (view->mtime != mtime) {
- view->mtime = mtime;
+ view->mtime = mtime;
view->in_sync = 0;
}
}
+
/* End of set methods. */
/* Get methods; NULL mailbox is valid, and returns the default value. */
const gchar *
-libbalsa_mailbox_get_identity_name(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_get_identity_name(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
return (mailbox && priv->view) ?
- priv->view->identity_name :
- libbalsa_mailbox_view_default.identity_name;
+ priv->view->identity_name :
+ libbalsa_mailbox_view_default.identity_name;
}
LibBalsaMailboxThreadingType
-libbalsa_mailbox_get_threading_type(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_get_threading_type(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
return (mailbox && priv->view) ?
- priv->view->threading_type :
- libbalsa_mailbox_view_default.threading_type;
+ priv->view->threading_type :
+ libbalsa_mailbox_view_default.threading_type;
}
+
LibBalsaMailboxSortType
-libbalsa_mailbox_get_sort_type(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_get_sort_type(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
return (mailbox && priv->view) ?
- priv->view->sort_type : libbalsa_mailbox_view_default.sort_type;
+ priv->view->sort_type : libbalsa_mailbox_view_default.sort_type;
}
+
LibBalsaMailboxSortFields
-libbalsa_mailbox_get_sort_field(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_get_sort_field(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
return (mailbox && priv->view) ?
- priv->view->sort_field :
- libbalsa_mailbox_view_default.sort_field;
+ priv->view->sort_field :
+ libbalsa_mailbox_view_default.sort_field;
}
+
LibBalsaMailboxShow
-libbalsa_mailbox_get_show(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_get_show(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
return (mailbox && priv->view) ?
- priv->view->show : libbalsa_mailbox_view_default.show;
+ priv->view->show : libbalsa_mailbox_view_default.show;
}
+
LibBalsaMailboxSubscribe
-libbalsa_mailbox_get_subscribe(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_get_subscribe(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
return (mailbox && priv->view) ?
- priv->view->subscribe : libbalsa_mailbox_view_default.subscribe;
+ priv->view->subscribe : libbalsa_mailbox_view_default.subscribe;
}
+
gboolean
-libbalsa_mailbox_get_exposed(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_get_exposed(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
return (mailbox && priv->view) ?
- priv->view->exposed : libbalsa_mailbox_view_default.exposed;
+ priv->view->exposed : libbalsa_mailbox_view_default.exposed;
}
+
gboolean
-libbalsa_mailbox_get_open(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_get_open(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
return (mailbox && priv->view) ?
- priv->view->open : libbalsa_mailbox_view_default.open;
+ priv->view->open : libbalsa_mailbox_view_default.open;
}
+
gint
-libbalsa_mailbox_get_filter(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_get_filter(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
return (mailbox && priv->view) ?
- priv->view->filter : libbalsa_mailbox_view_default.filter;
+ priv->view->filter : libbalsa_mailbox_view_default.filter;
}
+
#ifdef HAVE_GPGME
LibBalsaChkCryptoMode
-libbalsa_mailbox_get_crypto_mode(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_get_crypto_mode(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
return (mailbox && priv->view) ?
- priv->view->gpg_chk_mode :
- libbalsa_mailbox_view_default.gpg_chk_mode;
+ priv->view->gpg_chk_mode :
+ libbalsa_mailbox_view_default.gpg_chk_mode;
}
+
+
#endif
gint
-libbalsa_mailbox_get_unread(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_get_unread(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
if (mailbox && priv->view) {
priv->view->used = 1;
- return priv->view->unread;
- } else
+ return priv->view->unread;
+ } else {
return libbalsa_mailbox_view_default.unread;
+ }
}
+
gint
-libbalsa_mailbox_get_total(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_get_total(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
return (mailbox && priv->view) ?
- priv->view->total : libbalsa_mailbox_view_default.total;
+ priv->view->total : libbalsa_mailbox_view_default.total;
}
+
time_t
-libbalsa_mailbox_get_mtime(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_get_mtime(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
return (mailbox && priv->view) ?
- priv->view->mtime : libbalsa_mailbox_view_default.mtime;
+ priv->view->mtime : libbalsa_mailbox_view_default.mtime;
}
+
/* End of get methods. */
/* =================================================================== *
- * GtkTreeModel implementation functions. *
- * Important:
- * do not forget to modify LibBalsaMailbox::stamp on each modification
- * of the message list.
- * =================================================================== */
+* GtkTreeModel implementation functions. *
+* Important:
+* do not forget to modify LibBalsaMailbox::stamp on each modification
+* of the message list.
+* =================================================================== */
/* Iterator invalidation macros. */
#define VALID_ITER(iter, tree_model) \
- ((iter)!= NULL && \
+ ((iter) != NULL && \
(iter)->user_data != NULL && \
LIBBALSA_IS_MAILBOX(tree_model) && \
- ((LibBalsaMailboxPrivate *) libbalsa_mailbox_get_instance_private(((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 = ((LibBalsaMailboxPrivate *) libbalsa_mailbox_get_instance_private((LibBalsaMailbox *)
tree_model))->stamp)
+ ((iter)->stamp = \
+ ((LibBalsaMailboxPrivate *) libbalsa_mailbox_get_instance_private((LibBalsaMailbox *) \
+ tree_model))->stamp)
#define INVALIDATE_ITER(iter) ((iter)->stamp = 0)
-static GtkTreeModelFlags mbox_model_get_flags (GtkTreeModel *tree_model);
-static gint mbox_model_get_n_columns (GtkTreeModel *tree_model);
-static GType mbox_model_get_column_type (GtkTreeModel *tree_model,
- gint index);
-static gboolean mbox_model_get_iter (GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- GtkTreePath *path);
-static GtkTreePath *mbox_model_get_path (GtkTreeModel *tree_model,
- GtkTreeIter *iter);
-static void mbox_model_get_value (GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- gint column,
- GValue *value);
-static gboolean mbox_model_iter_next (GtkTreeModel *tree_model,
- GtkTreeIter *iter);
-static gboolean mbox_model_iter_children (GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- GtkTreeIter *parent);
-static gboolean mbox_model_iter_has_child (GtkTreeModel *tree_model,
- GtkTreeIter *iter);
-static gint mbox_model_iter_n_children (GtkTreeModel *tree_model,
- GtkTreeIter *iter);
-static gboolean mbox_model_iter_nth_child (GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- GtkTreeIter *parent,
- gint n);
-static gboolean mbox_model_iter_parent (GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- GtkTreeIter *child);
+static GtkTreeModelFlags mbox_model_get_flags(GtkTreeModel *tree_model);
+static gint mbox_model_get_n_columns(GtkTreeModel *tree_model);
+static GType mbox_model_get_column_type(GtkTreeModel *tree_model,
+ gint index);
+static gboolean mbox_model_get_iter(GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreePath *path);
+static GtkTreePath *mbox_model_get_path(GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+static void mbox_model_get_value(GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ gint column,
+ GValue *value);
+static gboolean mbox_model_iter_next(GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+static gboolean mbox_model_iter_children(GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent);
+static gboolean mbox_model_iter_has_child(GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+static gint mbox_model_iter_n_children(GtkTreeModel *tree_model,
+ GtkTreeIter *iter);
+static gboolean mbox_model_iter_nth_child(GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent,
+ gint n);
+static gboolean mbox_model_iter_parent(GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *child);
static GType mbox_model_col_type[LB_MBOX_N_COLS];
@@ -2821,15 +3091,15 @@ mbox_model_init(GtkTreeModelIface *iface)
iface->iter_nth_child = mbox_model_iter_nth_child;
iface->iter_parent = mbox_model_iter_parent;
- mbox_model_col_type[LB_MBOX_MSGNO_COL] = G_TYPE_UINT;
- mbox_model_col_type[LB_MBOX_MARKED_COL] = GDK_TYPE_PIXBUF;
- mbox_model_col_type[LB_MBOX_ATTACH_COL] = GDK_TYPE_PIXBUF;
- mbox_model_col_type[LB_MBOX_FROM_COL] = G_TYPE_STRING;
- mbox_model_col_type[LB_MBOX_SUBJECT_COL] = G_TYPE_STRING;
- mbox_model_col_type[LB_MBOX_DATE_COL] = G_TYPE_STRING;
- mbox_model_col_type[LB_MBOX_SIZE_COL] = G_TYPE_STRING;
- mbox_model_col_type[LB_MBOX_WEIGHT_COL] = G_TYPE_UINT;
- mbox_model_col_type[LB_MBOX_STYLE_COL] = G_TYPE_UINT;
+ mbox_model_col_type[LB_MBOX_MSGNO_COL] = G_TYPE_UINT;
+ mbox_model_col_type[LB_MBOX_MARKED_COL] = GDK_TYPE_PIXBUF;
+ mbox_model_col_type[LB_MBOX_ATTACH_COL] = GDK_TYPE_PIXBUF;
+ mbox_model_col_type[LB_MBOX_FROM_COL] = G_TYPE_STRING;
+ mbox_model_col_type[LB_MBOX_SUBJECT_COL] = G_TYPE_STRING;
+ mbox_model_col_type[LB_MBOX_DATE_COL] = G_TYPE_STRING;
+ mbox_model_col_type[LB_MBOX_SIZE_COL] = G_TYPE_STRING;
+ mbox_model_col_type[LB_MBOX_WEIGHT_COL] = G_TYPE_UINT;
+ mbox_model_col_type[LB_MBOX_STYLE_COL] = G_TYPE_UINT;
mbox_model_col_type[LB_MBOX_FOREGROUND_COL] = G_TYPE_STRING;
mbox_model_col_type[LB_MBOX_FOREGROUND_SET_COL] = G_TYPE_UINT;
mbox_model_col_type[LB_MBOX_BACKGROUND_COL] = G_TYPE_STRING;
@@ -2837,36 +3107,41 @@ mbox_model_init(GtkTreeModelIface *iface)
libbalsa_mbox_model_signals[ROW_CHANGED] =
- g_signal_lookup("row-changed", GTK_TYPE_TREE_MODEL);
+ g_signal_lookup("row-changed", GTK_TYPE_TREE_MODEL);
libbalsa_mbox_model_signals[ROW_DELETED] =
- g_signal_lookup("row-deleted", GTK_TYPE_TREE_MODEL);
+ g_signal_lookup("row-deleted", GTK_TYPE_TREE_MODEL);
libbalsa_mbox_model_signals[ROW_HAS_CHILD_TOGGLED] =
g_signal_lookup("row-has-child-toggled", GTK_TYPE_TREE_MODEL);
libbalsa_mbox_model_signals[ROW_INSERTED] =
- g_signal_lookup("row-inserted", GTK_TYPE_TREE_MODEL);
+ g_signal_lookup("row-inserted", GTK_TYPE_TREE_MODEL);
libbalsa_mbox_model_signals[ROWS_REORDERED] =
- g_signal_lookup("rows-reordered", GTK_TYPE_TREE_MODEL);
+ g_signal_lookup("rows-reordered", GTK_TYPE_TREE_MODEL);
}
+
static GtkTreeModelFlags
mbox_model_get_flags(GtkTreeModel *tree_model)
{
return 0;
}
+
static gint
mbox_model_get_n_columns(GtkTreeModel *tree_model)
{
return LB_MBOX_N_COLS;
}
+
static GType
-mbox_model_get_column_type(GtkTreeModel *tree_model, gint index)
+mbox_model_get_column_type(GtkTreeModel *tree_model,
+ gint index)
{
- g_return_val_if_fail(index>=0 && index <LB_MBOX_N_COLS, G_TYPE_BOOLEAN);
+ g_return_val_if_fail(index >= 0 && index < LB_MBOX_N_COLS, G_TYPE_BOOLEAN);
return mbox_model_col_type[index];
}
+
static gboolean
mbox_model_get_iter(GtkTreeModel *tree_model,
GtkTreeIter *iter,
@@ -2880,48 +3155,55 @@ mbox_model_get_iter(GtkTreeModel *tree_model,
g_return_val_if_fail(LIBBALSA_IS_MAILBOX(tree_model), FALSE);
indices = gtk_tree_path_get_indices(path);
- depth = gtk_tree_path_get_depth(path);
+ depth = gtk_tree_path_get_depth(path);
g_return_val_if_fail(depth > 0, FALSE);
- if (!mbox_model_iter_nth_child(tree_model, iter, NULL, indices[0]))
+ if (!mbox_model_iter_nth_child(tree_model, iter, NULL, indices[0])) {
return FALSE;
+ }
for (i = 1; i < depth; i++) {
parent = *iter;
if (!mbox_model_iter_nth_child(tree_model, iter, &parent,
- indices[i]))
+ indices[i])) {
return FALSE;
+ }
}
return TRUE;
}
+
static GtkTreePath *
-mbox_model_get_path_helper(GNode * node, GNode * msg_tree)
+mbox_model_get_path_helper(GNode *node,
+ GNode *msg_tree)
{
GtkTreePath *path = gtk_tree_path_new();
while (node->parent) {
- gint i = g_node_child_position(node->parent, node);
- if (i < 0) {
- gtk_tree_path_free(path);
- return NULL;
- }
- gtk_tree_path_prepend_index(path, i);
- node = node->parent;
+ gint i = g_node_child_position(node->parent, node);
+ if (i < 0) {
+ gtk_tree_path_free(path);
+ return NULL;
+ }
+ gtk_tree_path_prepend_index(path, i);
+ node = node->parent;
}
- if (node == msg_tree)
- return path;
+ if (node == msg_tree) {
+ return path;
+ }
gtk_tree_path_free(path);
return NULL;
}
+
static GtkTreePath *
-mbox_model_get_path(GtkTreeModel * tree_model, GtkTreeIter * iter)
+mbox_model_get_path(GtkTreeModel *tree_model,
+ GtkTreeIter *iter)
{
- LibBalsaMailbox *mailbox = (LibBalsaMailbox *) tree_model;
+ LibBalsaMailbox *mailbox = (LibBalsaMailbox *) tree_model;
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GNode *node;
#ifdef SANITY_CHECK
@@ -2933,8 +3215,9 @@ mbox_model_get_path(GtkTreeModel * tree_model, GtkTreeIter * iter)
node = iter->user_data;
#ifdef SANITY_CHECK
for (parent_node = node->parent; parent_node;
- parent_node = parent_node->parent)
+ parent_node = parent_node->parent) {
g_return_val_if_fail(parent_node != node, NULL);
+ }
#endif
g_return_val_if_fail(node->parent != NULL, NULL);
@@ -2942,10 +3225,11 @@ mbox_model_get_path(GtkTreeModel * tree_model, GtkTreeIter * iter)
return mbox_model_get_path_helper(node, priv->msg_tree);
}
-/* mbox_model_get_value:
- FIXME: still includes some debugging code in case fetching the
- message failed.
-*/
+
+/* mbox_model_get_value:
+ FIXME: still includes some debugging code in case fetching the
+ message failed.
+ */
static GdkPixbuf *status_icons[LIBBALSA_MESSAGE_STATUS_ICONS_NUM];
static GdkPixbuf *attach_icons[LIBBALSA_MESSAGE_ATTACH_ICONS_NUM];
@@ -2955,7 +3239,8 @@ static GdkPixbuf *attach_icons[LIBBALSA_MESSAGE_ATTACH_ICONS_NUM];
static GMutex get_index_entry_lock;
static void
-lbm_get_index_entry_expunged_cb(LibBalsaMailbox * mailbox, guint seqno)
+lbm_get_index_entry_expunged_cb(LibBalsaMailbox *mailbox,
+ guint seqno)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -2964,8 +3249,9 @@ lbm_get_index_entry_expunged_cb(LibBalsaMailbox * mailbox, guint seqno)
g_mutex_unlock(&get_index_entry_lock);
}
+
static void
-lbm_get_index_entry_real(LibBalsaMailbox * mailbox)
+lbm_get_index_entry_real(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
guint i;
@@ -2979,17 +3265,19 @@ lbm_get_index_entry_real(LibBalsaMailbox * mailbox)
guint msgno = g_array_index(priv->msgnos_pending, guint, i);
LibBalsaMessage *message;
- if (!MAILBOX_OPEN(mailbox))
+ if (!MAILBOX_OPEN(mailbox)) {
break;
+ }
#if DEBUG
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)))
+ if ((message = libbalsa_mailbox_get_message(mailbox, msgno))) {
/* get-message has cached the message info, so we just unref
* message. */
g_object_unref(message);
+ }
g_mutex_lock(&get_index_entry_lock);
}
@@ -3005,20 +3293,24 @@ lbm_get_index_entry_real(LibBalsaMailbox * mailbox)
static LibBalsaMailboxIndexEntry *
-lbm_get_index_entry(LibBalsaMailbox * lmm, guint msgno)
+lbm_get_index_entry(LibBalsaMailbox *lmm,
+ guint msgno)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(lmm);
LibBalsaMailboxIndexEntry *entry;
- if (!priv->mindex)
+ if (!priv->mindex) {
return NULL;
+ }
- if (priv->mindex->len < msgno )
+ if (priv->mindex->len < msgno ) {
g_ptr_array_set_size(priv->mindex, msgno);
+ }
entry = g_ptr_array_index(priv->mindex, msgno - 1);
- if (entry)
+ if (entry) {
return entry->idle_pending ? NULL : entry;
+ }
g_mutex_lock(&get_index_entry_lock);
if (!priv->msgnos_pending) {
@@ -3032,9 +3324,9 @@ lbm_get_index_entry(LibBalsaMailbox * lmm, guint msgno)
g_object_ref(lmm);
get_index_entry_thread =
- g_thread_new("lbm_get_index_entry_real",
- (GThreadFunc) lbm_get_index_entry_real,
- lmm);
+ g_thread_new("lbm_get_index_entry_real",
+ (GThreadFunc) lbm_get_index_entry_real,
+ lmm);
g_thread_unref(get_index_entry_thread);
}
@@ -3048,107 +3340,127 @@ lbm_get_index_entry(LibBalsaMailbox * lmm, guint msgno)
return entry;
}
+
gchar **libbalsa_mailbox_date_format;
static void
mbox_model_get_value(GtkTreeModel *tree_model,
GtkTreeIter *iter,
- gint column,
- GValue *value)
+ gint column,
+ GValue *value)
{
- LibBalsaMailbox* lmm = LIBBALSA_MAILBOX(tree_model);
- LibBalsaMailboxIndexEntry* msg = NULL;
+ LibBalsaMailbox *lmm = LIBBALSA_MAILBOX(tree_model);
+ LibBalsaMailboxIndexEntry *msg = NULL;
guint msgno;
gchar *tmp;
-
+
g_return_if_fail(VALID_ITER(iter, tree_model));
g_return_if_fail(column >= 0 &&
column < (gint) G_N_ELEMENTS(mbox_model_col_type));
-
+
g_value_init (value, mbox_model_col_type[column]);
- msgno = GPOINTER_TO_UINT( ((GNode*)iter->user_data)->data );
+ msgno = GPOINTER_TO_UINT(((GNode *)iter->user_data)->data );
- if(column == LB_MBOX_MSGNO_COL) {
+ if (column == LB_MBOX_MSGNO_COL) {
g_value_set_uint(value, msgno);
return;
}
- g_return_if_fail(msgno<=libbalsa_mailbox_total_messages(lmm));
+ g_return_if_fail(msgno <= libbalsa_mailbox_total_messages(lmm));
msg = lbm_get_index_entry(lmm, msgno);
- switch(column) {
- /* case LB_MBOX_MSGNO_COL: handled above */
+ switch (column) {
+ /* case LB_MBOX_MSGNO_COL: handled above */
case LB_MBOX_MARKED_COL:
- if (msg && msg->status_icon < LIBBALSA_MESSAGE_STATUS_ICONS_NUM)
+ if (msg && (msg->status_icon < LIBBALSA_MESSAGE_STATUS_ICONS_NUM)) {
g_value_set_object(value, status_icons[msg->status_icon]);
+ }
break;
+
case LB_MBOX_ATTACH_COL:
- if (msg && msg->attach_icon < LIBBALSA_MESSAGE_ATTACH_ICONS_NUM)
+ if (msg && (msg->attach_icon < LIBBALSA_MESSAGE_ATTACH_ICONS_NUM)) {
g_value_set_object(value, attach_icons[msg->attach_icon]);
+ }
break;
+
case LB_MBOX_FROM_COL:
- if(msg) {
- if (msg->from)
+ if (msg) {
+ if (msg->from) {
g_value_set_string(value, msg->from);
- else
+ } else {
g_value_set_static_string(value, _("from unknown"));
- } else
+ }
+ } else {
g_value_set_static_string(value, _("Loading…"));
+ }
break;
+
case LB_MBOX_SUBJECT_COL:
- if(msg) g_value_set_string(value, msg->subject);
+ if (msg) {
+ g_value_set_string(value, msg->subject);
+ }
break;
+
case LB_MBOX_DATE_COL:
- if(msg) {
+ if (msg) {
tmp = libbalsa_date_to_utf8(msg->msg_date,
- *libbalsa_mailbox_date_format);
+ *libbalsa_mailbox_date_format);
g_value_take_string(value, tmp);
}
break;
+
case LB_MBOX_SIZE_COL:
- if(msg) {
+ if (msg) {
tmp = libbalsa_size_to_gchar(msg->size);
g_value_take_string(value, tmp);
+ } else {
+ g_value_set_static_string(value, " ");
}
- else g_value_set_static_string(value, " ");
break;
+
case LB_MBOX_WEIGHT_COL:
g_value_set_uint(value, msg && msg->unseen
? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL);
break;
+
case LB_MBOX_STYLE_COL:
g_value_set_uint(value, msg &&
- lbm_node_has_unseen_child(lmm,
- (GNode *) iter->user_data)
+ lbm_node_has_unseen_child(lmm,
+ (GNode *) iter->user_data)
? PANGO_STYLE_OBLIQUE : PANGO_STYLE_NORMAL);
break;
+
case LB_MBOX_FOREGROUND_COL:
- if(msg) {
+ if (msg) {
tmp = g_strdup(msg->foreground);
g_value_take_string(value, tmp);
}
break;
+
case LB_MBOX_FOREGROUND_SET_COL:
g_value_set_uint(value, msg && msg->foreground_set);
break;
+
case LB_MBOX_BACKGROUND_COL:
- if(msg) {
+ if (msg) {
tmp = g_strdup(msg->background);
g_value_take_string(value, tmp);
}
break;
+
case LB_MBOX_BACKGROUND_SET_COL:
g_value_set_uint(value, msg && msg->background_set);
break;
}
}
+
static gboolean
-mbox_model_iter_next(GtkTreeModel *tree_model,
- GtkTreeIter *iter)
+mbox_model_iter_next(GtkTreeModel *tree_model,
+ GtkTreeIter *iter)
{
GNode *node;
g_return_val_if_fail(VALID_ITER(iter, tree_model), FALSE);
node = iter->user_data;
- if(node && (node = node->next)) {
+ if (node && (node = node->next)) {
iter->user_data = node;
VALIDATE_ITER(iter, tree_model);
return TRUE;
@@ -3158,10 +3470,11 @@ mbox_model_iter_next(GtkTreeModel *tree_model,
}
}
+
static gboolean
-mbox_model_iter_children(GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- GtkTreeIter *parent)
+mbox_model_iter_children(GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent)
{
LibBalsaMailboxPrivate *priv =
libbalsa_mailbox_get_instance_private(((LibBalsaMailbox *) tree_model));
@@ -3177,13 +3490,15 @@ mbox_model_iter_children(GtkTreeModel *tree_model,
iter->user_data = node;
VALIDATE_ITER(iter, tree_model);
return TRUE;
- } else
+ } else {
return FALSE;
+ }
}
+
static gboolean
-mbox_model_iter_has_child(GtkTreeModel * tree_model,
- GtkTreeIter * iter)
+mbox_model_iter_has_child(GtkTreeModel *tree_model,
+ GtkTreeIter *iter)
{
GNode *node;
@@ -3195,9 +3510,10 @@ mbox_model_iter_has_child(GtkTreeModel * tree_model,
return (node->children != NULL);
}
+
static gint
-mbox_model_iter_n_children(GtkTreeModel *tree_model,
- GtkTreeIter *iter)
+mbox_model_iter_n_children(GtkTreeModel *tree_model,
+ GtkTreeIter *iter)
{
LibBalsaMailboxPrivate *priv =
libbalsa_mailbox_get_instance_private(((LibBalsaMailbox *) tree_model));
@@ -3210,45 +3526,51 @@ mbox_model_iter_n_children(GtkTreeModel *tree_model,
return node ? g_node_n_children(node) : 0;
}
+
static gboolean
-mbox_model_iter_nth_child(GtkTreeModel * tree_model,
- GtkTreeIter * iter,
- GtkTreeIter * parent,
- gint n)
+mbox_model_iter_nth_child(GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent,
+ gint n)
{
LibBalsaMailboxPrivate *priv =
libbalsa_mailbox_get_instance_private(((LibBalsaMailbox *) tree_model));
GNode *node;
INVALIDATE_ITER(iter);
- if(!priv->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);
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.
- */
+ 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.
+ */
return FALSE;
+ }
node = g_node_nth_child(node, n);
if (node) {
iter->user_data = node;
VALIDATE_ITER(iter, tree_model);
return TRUE;
- } else
+ } else {
return FALSE;
+ }
}
+
static gboolean
-mbox_model_iter_parent(GtkTreeModel * tree_model,
- GtkTreeIter * iter,
- GtkTreeIter * child)
+mbox_model_iter_parent(GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *child)
{
LibBalsaMailboxPrivate *priv =
libbalsa_mailbox_get_instance_private(((LibBalsaMailbox *) tree_model));
@@ -3260,141 +3582,171 @@ mbox_model_iter_parent(GtkTreeModel * tree_model,
node = child->user_data;
node = node->parent;
- if (node && node != priv->msg_tree) {
+ if (node && (node != priv->msg_tree)) {
iter->user_data = node;
VALIDATE_ITER(iter, tree_model);
return TRUE;
- } else
+ } else {
return FALSE;
+ }
}
+
/* Set icons used in tree view. */
/* Icons for status column. */
void
-libbalsa_mailbox_set_unread_icon(GdkPixbuf * pixbuf)
+libbalsa_mailbox_set_unread_icon(GdkPixbuf *pixbuf)
{
g_set_object(&status_icons[LIBBALSA_MESSAGE_STATUS_UNREAD], pixbuf);
}
-void libbalsa_mailbox_set_trash_icon(GdkPixbuf * pixbuf)
+
+void
+libbalsa_mailbox_set_trash_icon(GdkPixbuf *pixbuf)
{
g_set_object(&status_icons[LIBBALSA_MESSAGE_STATUS_DELETED], pixbuf);
}
-void libbalsa_mailbox_set_flagged_icon(GdkPixbuf * pixbuf)
+
+void
+libbalsa_mailbox_set_flagged_icon(GdkPixbuf *pixbuf)
{
g_set_object(&status_icons[LIBBALSA_MESSAGE_STATUS_FLAGGED], pixbuf);
}
-void libbalsa_mailbox_set_replied_icon(GdkPixbuf * pixbuf)
+
+void
+libbalsa_mailbox_set_replied_icon(GdkPixbuf *pixbuf)
{
g_set_object(&status_icons[LIBBALSA_MESSAGE_STATUS_REPLIED], pixbuf);
}
+
/* Icons for attachment column. */
-void libbalsa_mailbox_set_attach_icon(GdkPixbuf * pixbuf)
+void
+libbalsa_mailbox_set_attach_icon(GdkPixbuf *pixbuf)
{
g_set_object(&attach_icons[LIBBALSA_MESSAGE_ATTACH_ATTACH], pixbuf);
}
+
#ifdef HAVE_GPGME
-void libbalsa_mailbox_set_good_icon(GdkPixbuf * pixbuf)
+void
+libbalsa_mailbox_set_good_icon(GdkPixbuf *pixbuf)
{
g_set_object(&attach_icons[LIBBALSA_MESSAGE_ATTACH_GOOD], pixbuf);
}
-void libbalsa_mailbox_set_notrust_icon(GdkPixbuf * pixbuf)
+
+void
+libbalsa_mailbox_set_notrust_icon(GdkPixbuf *pixbuf)
{
g_set_object(&attach_icons[LIBBALSA_MESSAGE_ATTACH_NOTRUST], pixbuf);
}
-void libbalsa_mailbox_set_bad_icon(GdkPixbuf * pixbuf)
+
+void
+libbalsa_mailbox_set_bad_icon(GdkPixbuf *pixbuf)
{
g_set_object(&attach_icons[LIBBALSA_MESSAGE_ATTACH_BAD], pixbuf);
}
-void libbalsa_mailbox_set_sign_icon(GdkPixbuf * pixbuf)
+
+void
+libbalsa_mailbox_set_sign_icon(GdkPixbuf *pixbuf)
{
g_set_object(&attach_icons[LIBBALSA_MESSAGE_ATTACH_SIGN], pixbuf);
}
-void libbalsa_mailbox_set_encr_icon(GdkPixbuf * pixbuf)
+
+void
+libbalsa_mailbox_set_encr_icon(GdkPixbuf *pixbuf)
{
g_set_object(&attach_icons[LIBBALSA_MESSAGE_ATTACH_ENCR], pixbuf);
}
+
+
#endif /* HAVE_GPGME */
/* =================================================================== *
- * GtkTreeDragSource implementation functions. *
- * =================================================================== */
+* GtkTreeDragSource implementation functions. *
+* =================================================================== */
-static gboolean mbox_row_draggable(GtkTreeDragSource * drag_source,
- GtkTreePath * path);
-static gboolean mbox_drag_data_delete(GtkTreeDragSource * drag_source,
- GtkTreePath * path);
-static gboolean mbox_drag_data_get(GtkTreeDragSource * drag_source,
- GtkTreePath * path,
- GtkSelectionData * selection_data);
+static gboolean mbox_row_draggable(GtkTreeDragSource *drag_source,
+ GtkTreePath *path);
+static gboolean mbox_drag_data_delete(GtkTreeDragSource *drag_source,
+ GtkTreePath *path);
+static gboolean mbox_drag_data_get(GtkTreeDragSource *drag_source,
+ GtkTreePath *path,
+ GtkSelectionData *selection_data);
static void
-mbox_drag_source_init(GtkTreeDragSourceIface * iface)
+mbox_drag_source_init(GtkTreeDragSourceIface *iface)
{
iface->row_draggable = mbox_row_draggable;
iface->drag_data_delete = mbox_drag_data_delete;
iface->drag_data_get = mbox_drag_data_get;
}
+
/* These three methods are apparently never called, so what they return
* is irrelevant. The code reflects guesses about what they should
* return if they were ever called.
*/
static gboolean
-mbox_row_draggable(GtkTreeDragSource * drag_source, GtkTreePath * path)
+mbox_row_draggable(GtkTreeDragSource *drag_source,
+ GtkTreePath *path)
{
/* All rows are valid sources. */
return TRUE;
}
+
static gboolean
-mbox_drag_data_delete(GtkTreeDragSource * drag_source, GtkTreePath * path)
+mbox_drag_data_delete(GtkTreeDragSource *drag_source,
+ GtkTreePath *path)
{
/* The "drag-data-received" callback handles deleting messages that
* are dragged out of the mailbox, so we don't. */
return FALSE;
}
+
static gboolean
-mbox_drag_data_get(GtkTreeDragSource * drag_source, GtkTreePath * path,
- GtkSelectionData * selection_data)
+mbox_drag_data_get(GtkTreeDragSource *drag_source,
+ GtkTreePath *path,
+ GtkSelectionData *selection_data)
{
/* The "drag-data-get" callback passes the list of selected messages
* to the GtkSelectionData, so we don't. */
return FALSE;
}
+
/* =================================================================== *
- * GtkTreeSortable implementation functions. *
- * =================================================================== */
-
-static gboolean mbox_get_sort_column_id(GtkTreeSortable * sortable,
- gint * sort_column_id,
- GtkSortType * order);
-static void mbox_set_sort_column_id(GtkTreeSortable * sortable,
- gint sort_column_id,
- GtkSortType order);
-static void mbox_set_sort_func(GtkTreeSortable * sortable,
- gint sort_column_id,
- GtkTreeIterCompareFunc func, gpointer data,
- GDestroyNotify destroy);
-static void mbox_set_default_sort_func(GtkTreeSortable * sortable,
+* GtkTreeSortable implementation functions. *
+* =================================================================== */
+
+static gboolean mbox_get_sort_column_id(GtkTreeSortable *sortable,
+ gint *sort_column_id,
+ GtkSortType *order);
+static void mbox_set_sort_column_id(GtkTreeSortable *sortable,
+ gint sort_column_id,
+ GtkSortType order);
+static void mbox_set_sort_func(GtkTreeSortable *sortable,
+ gint sort_column_id,
+ GtkTreeIterCompareFunc func,
+ gpointer data,
+ GDestroyNotify destroy);
+static void mbox_set_default_sort_func(GtkTreeSortable *sortable,
GtkTreeIterCompareFunc func,
- gpointer data,
- GDestroyNotify destroy);
-static gboolean mbox_has_default_sort_func(GtkTreeSortable * sortable);
+ gpointer data,
+ GDestroyNotify destroy);
+static gboolean mbox_has_default_sort_func(GtkTreeSortable *sortable);
static void
-mbox_sortable_init(GtkTreeSortableIface * iface)
+mbox_sortable_init(GtkTreeSortableIface *iface)
{
iface->get_sort_column_id = mbox_get_sort_column_id;
iface->set_sort_column_id = mbox_set_sort_column_id;
@@ -3403,38 +3755,43 @@ mbox_sortable_init(GtkTreeSortableIface * iface)
iface->has_default_sort_func = mbox_has_default_sort_func;
}
+
static gint
-mbox_compare_from(LibBalsaMailboxIndexEntry * message_a,
- LibBalsaMailboxIndexEntry * message_b)
+mbox_compare_from(LibBalsaMailboxIndexEntry *message_a,
+ LibBalsaMailboxIndexEntry *message_b)
{
return g_ascii_strcasecmp(message_a->from, message_b->from);
}
+
static gint
-mbox_compare_subject(LibBalsaMailboxIndexEntry * message_a,
- LibBalsaMailboxIndexEntry * message_b)
+mbox_compare_subject(LibBalsaMailboxIndexEntry *message_a,
+ LibBalsaMailboxIndexEntry *message_b)
{
return g_ascii_strcasecmp(message_a->subject, message_b->subject);
}
+
static gint
-mbox_compare_date(LibBalsaMailboxIndexEntry * message_a,
- LibBalsaMailboxIndexEntry * message_b)
+mbox_compare_date(LibBalsaMailboxIndexEntry *message_a,
+ LibBalsaMailboxIndexEntry *message_b)
{
return message_a->msg_date - message_b->msg_date;
}
+
static gint
-mbox_compare_size(LibBalsaMailboxIndexEntry * message_a,
- LibBalsaMailboxIndexEntry * message_b)
+mbox_compare_size(LibBalsaMailboxIndexEntry *message_a,
+ LibBalsaMailboxIndexEntry *message_b)
{
return message_a->size - message_b->size;
}
+
static gint
-mbox_compare_func(const SortTuple * a,
- const SortTuple * b,
- LibBalsaMailbox * mbox)
+mbox_compare_func(const SortTuple *a,
+ const SortTuple *b,
+ LibBalsaMailbox *mbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mbox);
guint msgno_a;
@@ -3443,35 +3800,40 @@ mbox_compare_func(const SortTuple * a,
msgno_a = GPOINTER_TO_UINT(a->node->data);
msgno_b = GPOINTER_TO_UINT(b->node->data);
- 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(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 (priv->view->sort_field) {
- case LB_MAILBOX_SORT_SENDER:
- retval = mbox_compare_from(message_a, message_b);
- break;
- case LB_MAILBOX_SORT_SUBJECT:
- retval = mbox_compare_subject(message_a, message_b);
- break;
- case LB_MAILBOX_SORT_DATE:
- retval = mbox_compare_date(message_a, message_b);
- break;
- case LB_MAILBOX_SORT_SIZE:
- retval = mbox_compare_size(message_a, message_b);
- break;
- default:
- retval = 0;
- break;
- }
+ 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(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 (priv->view->sort_field) {
+ case LB_MAILBOX_SORT_SENDER:
+ retval = mbox_compare_from(message_a, message_b);
+ break;
+
+ case LB_MAILBOX_SORT_SUBJECT:
+ retval = mbox_compare_subject(message_a, message_b);
+ break;
+
+ case LB_MAILBOX_SORT_DATE:
+ retval = mbox_compare_date(message_a, message_b);
+ break;
+
+ case LB_MAILBOX_SORT_SIZE:
+ retval = mbox_compare_size(message_a, message_b);
+ break;
+
+ default:
+ retval = 0;
+ break;
+ }
if (retval == 0) {
/* resolve ties using previous sort column */
@@ -3479,15 +3841,19 @@ mbox_compare_func(const SortTuple * a,
case LB_MAILBOX_SORT_SENDER:
retval = mbox_compare_from(message_a, message_b);
break;
+
case LB_MAILBOX_SORT_SUBJECT:
retval = mbox_compare_subject(message_a, message_b);
break;
+
case LB_MAILBOX_SORT_DATE:
retval = mbox_compare_date(message_a, message_b);
break;
+
case LB_MAILBOX_SORT_SIZE:
retval = mbox_compare_size(message_a, message_b);
break;
+
default:
retval = 0;
break;
@@ -3502,6 +3868,7 @@ mbox_compare_func(const SortTuple * a,
return retval;
}
+
/*
* Sort part of the mailbox tree.
*
@@ -3509,21 +3876,25 @@ mbox_compare_func(const SortTuple * a,
* for only the nodes where we do have them.
*/
static gboolean
-lbm_has_valid_index_entry(LibBalsaMailbox * mailbox, guint msgno)
+lbm_has_valid_index_entry(LibBalsaMailbox *mailbox,
+ guint msgno)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
LibBalsaMailboxIndexEntry *entry;
- if (msgno > priv->mindex->len)
+ if (msgno > priv->mindex->len) {
return FALSE;
+ }
entry = g_ptr_array_index(priv->mindex, msgno - 1);
return VALID_ENTRY(entry);
}
+
static void
-lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
+lbm_sort(LibBalsaMailbox *mbox,
+ GNode *parent)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mbox);
GArray *sort_array;
@@ -3540,8 +3911,9 @@ lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mbox) != NULL);
node = parent->children;
- if (!node)
+ if (!node) {
return;
+ }
if (node->next == NULL) {
lbm_sort(mbox, node);
@@ -3554,10 +3926,10 @@ lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
SortTuple sort_tuple;
guint msgno = GPOINTER_TO_UINT(tmp_node->data);
- if (can_sort_all || lbm_has_valid_index_entry(mbox, msgno)) {
+ if (can_sort_all || lbm_has_valid_index_entry(mbox, msgno)) {
/* We have the sort fields. */
sort_tuple.offset = node_array->len;
- sort_tuple.node = tmp_node;
+ sort_tuple.node = tmp_node;
g_array_append_val(sort_array, sort_tuple);
}
g_ptr_array_add(node_array, tmp_node);
@@ -3577,8 +3949,8 @@ lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
guint msgno;
tmp_node = g_ptr_array_index(node_array, i);
- msgno = GPOINTER_TO_UINT(tmp_node->data);
- if (can_sort_all || lbm_has_valid_index_entry(mbox, msgno)) {
+ msgno = GPOINTER_TO_UINT(tmp_node->data);
+ if (can_sort_all || lbm_has_valid_index_entry(mbox, msgno)) {
/* This is one of the nodes we sorted: find out which one
* goes here. */
g_assert(j < sort_array->len);
@@ -3586,18 +3958,21 @@ lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
}
if (tmp_node->prev != prev) {
/* Change the links. */
- if (prev)
+ if (prev) {
prev->next = tmp_node;
- else
+ } else {
node = parent->children = tmp_node;
- tmp_node->prev = prev;
+ }
+ tmp_node->prev = prev;
priv->msg_tree_changed = TRUE;
- } else
+ } else {
g_assert(prev == NULL || prev->next == tmp_node);
+ }
prev = tmp_node;
}
- if (prev != NULL)
+ if (prev != NULL) {
prev->next = NULL;
+ }
/* Let the world know about our new order */
if (node_array->len > 0) {
@@ -3606,7 +3981,7 @@ lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
GtkTreePath *path;
new_order = g_new(gint, node_array->len);
- i = j = 0;
+ i = j = 0;
for (tmp_node = node; tmp_node; tmp_node = tmp_node->next) {
guint msgno = GPOINTER_TO_UINT(tmp_node->data);
new_order[j] = can_sort_all || lbm_has_valid_index_entry(mbox, msgno)
@@ -3615,10 +3990,10 @@ lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
j++;
}
- iter.stamp = priv->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();
+ path = parent->parent ? mbox_model_get_path(GTK_TREE_MODEL(mbox), &iter)
+ : gtk_tree_path_new();
gtk_tree_model_rows_reordered(GTK_TREE_MODEL(mbox),
path, &iter, new_order);
gtk_tree_path_free(path);
@@ -3628,17 +4003,19 @@ lbm_sort(LibBalsaMailbox * mbox, GNode * parent)
g_array_free(sort_array, TRUE);
g_ptr_array_free(node_array, TRUE);
- for (tmp_node = node; tmp_node; tmp_node = tmp_node->next)
+ for (tmp_node = node; tmp_node; tmp_node = tmp_node->next) {
lbm_sort(mbox, tmp_node);
+ }
}
+
/* called from gtk-tree-view-column */
static gboolean
-mbox_get_sort_column_id(GtkTreeSortable * sortable,
- gint * sort_column_id,
- GtkSortType * order)
+mbox_get_sort_column_id(GtkTreeSortable *sortable,
+ gint *sort_column_id,
+ GtkSortType *order)
{
- LibBalsaMailbox *mbox = (LibBalsaMailbox *) sortable;
+ LibBalsaMailbox *mbox = (LibBalsaMailbox *) sortable;
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mbox);
g_return_val_if_fail(LIBBALSA_IS_MAILBOX(sortable), FALSE);
@@ -3649,36 +4026,42 @@ mbox_get_sort_column_id(GtkTreeSortable * sortable,
case LB_MAILBOX_SORT_NO:
*sort_column_id = LB_MBOX_MSGNO_COL;
break;
+
case LB_MAILBOX_SORT_SENDER:
*sort_column_id = LB_MBOX_FROM_COL;
break;
+
case LB_MAILBOX_SORT_SUBJECT:
*sort_column_id = LB_MBOX_SUBJECT_COL;
break;
+
case LB_MAILBOX_SORT_DATE:
*sort_column_id = LB_MBOX_DATE_COL;
break;
+
case LB_MAILBOX_SORT_SIZE:
*sort_column_id = LB_MBOX_SIZE_COL;
break;
}
}
- if (order)
+ if (order) {
*order = (priv->view->sort_type ==
LB_MAILBOX_SORT_TYPE_DESC ? GTK_SORT_DESCENDING :
GTK_SORT_ASCENDING);
+ }
return TRUE;
}
+
/* called from gtk-tree-view-column */
static void
-mbox_set_sort_column_id(GtkTreeSortable * sortable,
- gint sort_column_id,
- GtkSortType order)
+mbox_set_sort_column_id(GtkTreeSortable *sortable,
+ gint sort_column_id,
+ GtkSortType order)
{
- LibBalsaMailbox *mbox = (LibBalsaMailbox *) sortable;
+ LibBalsaMailbox *mbox = (LibBalsaMailbox *) sortable;
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mbox);
LibBalsaMailboxView *view;
LibBalsaMailboxSortFields new_field;
@@ -3693,15 +4076,19 @@ mbox_set_sort_column_id(GtkTreeSortable * sortable,
case LB_MBOX_MSGNO_COL:
new_field = LB_MAILBOX_SORT_NO;
break;
+
case LB_MBOX_FROM_COL:
new_field = LB_MAILBOX_SORT_SENDER;
break;
+
case LB_MBOX_SUBJECT_COL:
new_field = LB_MAILBOX_SORT_SUBJECT;
break;
+
case LB_MBOX_DATE_COL:
new_field = LB_MAILBOX_SORT_DATE;
break;
+
case LB_MBOX_SIZE_COL:
new_field = LB_MAILBOX_SORT_SIZE;
break;
@@ -3710,15 +4097,16 @@ mbox_set_sort_column_id(GtkTreeSortable * sortable,
new_type = (order == GTK_SORT_DESCENDING ? LB_MAILBOX_SORT_TYPE_DESC :
LB_MAILBOX_SORT_TYPE_ASC);
- if (view->sort_field == new_field && view->sort_type == new_type)
+ if ((view->sort_field == new_field) && (view->sort_type == new_type)) {
return;
+ }
if (view->sort_field != new_field) {
view->sort_field_prev = view->sort_field;
- view->sort_field = new_field;
+ view->sort_field = new_field;
}
view->sort_type = new_type;
- view->in_sync = 0;
+ view->in_sync = 0;
gtk_tree_sortable_sort_column_changed(sortable);
@@ -3727,9 +4115,10 @@ mbox_set_sort_column_id(GtkTreeSortable * sortable,
rc = libbalsa_mailbox_prepare_threading(mbox, 0);
- if (!rc)
+ if (!rc) {
/* Prepare-threading failed--perhaps mailbox was closed. */
return;
+ }
}
libbalsa_lock_mailbox(mbox);
lbm_sort(mbox, priv->msg_tree);
@@ -3738,34 +4127,41 @@ mbox_set_sort_column_id(GtkTreeSortable * sortable,
libbalsa_mailbox_changed(mbox);
}
+
static void
-mbox_set_sort_func(GtkTreeSortable * sortable,
- gint sort_column_id,
+mbox_set_sort_func(GtkTreeSortable *sortable,
+ gint sort_column_id,
GtkTreeIterCompareFunc func,
- gpointer data, GDestroyNotify destroy)
+ gpointer data,
+ GDestroyNotify destroy)
{
g_warning("%s called but not implemented.\n", __func__);
}
+
static void
-mbox_set_default_sort_func(GtkTreeSortable * sortable,
+mbox_set_default_sort_func(GtkTreeSortable *sortable,
GtkTreeIterCompareFunc func,
- gpointer data, GDestroyNotify destroy)
+ gpointer data,
+ GDestroyNotify destroy)
{
g_warning("%s called but not implemented.\n", __func__);
}
+
/* called from gtk-tree-view-column */
static gboolean
-mbox_has_default_sort_func(GtkTreeSortable * sortable)
+mbox_has_default_sort_func(GtkTreeSortable *sortable)
{
return FALSE;
}
+
/* Helpers for set-threading-type. */
void
-libbalsa_mailbox_unlink_and_prepend(LibBalsaMailbox * mailbox,
- GNode * node, GNode * parent)
+libbalsa_mailbox_unlink_and_prepend(LibBalsaMailbox *mailbox,
+ GNode *node,
+ GNode *parent)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GtkTreeIter iter;
@@ -3780,7 +4176,7 @@ libbalsa_mailbox_unlink_and_prepend(LibBalsaMailbox * mailbox,
iter.stamp = priv->stamp;
- path = mbox_model_get_path_helper(node, priv->msg_tree);
+ path = mbox_model_get_path_helper(node, priv->msg_tree);
current_parent = node->parent;
g_node_unlink(node);
if (path) {
@@ -3819,16 +4215,18 @@ libbalsa_mailbox_unlink_and_prepend(LibBalsaMailbox * mailbox,
g_signal_emit(mailbox,
libbalsa_mbox_model_signals[ROW_INSERTED], 0,
path, &iter);
- if (node->children)
+ if (node->children) {
g_signal_emit(mailbox,
libbalsa_mbox_model_signals[ROW_HAS_CHILD_TOGGLED],
0, path, &iter);
+ }
gtk_tree_path_free(path);
priv->msg_tree_changed = TRUE;
}
}
+
struct lbm_update_msg_tree_info {
LibBalsaMailbox *mailbox;
GNode *new_tree;
@@ -3838,37 +4236,40 @@ struct lbm_update_msg_tree_info {
/* GNodeTraverseFunc for making a reverse lookup array into a tree. */
static gboolean
-lbm_update_msg_tree_populate(GNode * node,
+lbm_update_msg_tree_populate(GNode *node,
struct lbm_update_msg_tree_info *mti)
{
guint msgno;
msgno = GPOINTER_TO_UINT(node->data);
- if (msgno < mti->total)
+ if (msgno < mti->total) {
mti->nodes[msgno] = node;
+ }
return FALSE;
}
+
/* GNodeTraverseFunc for pruning the current tree; mti->nodes is a
* reverse lookup array into the new tree, so a NULL value is a node
* that doesn't appear in the new tree. */
static gboolean
-lbm_update_msg_tree_prune(GNode * node,
+lbm_update_msg_tree_prune(GNode *node,
struct lbm_update_msg_tree_info *mti)
{
guint msgno;
msgno = GPOINTER_TO_UINT(node->data);
- if (msgno >= mti->total || !mti->nodes[msgno]) {
+ if ((msgno >= mti->total) || !mti->nodes[msgno]) {
/* It's a bottom-up traverse, so the node's remaining children
* are all in the new tree; we'll promote them to be children of
* the node's parent, which might even be where they finish up. */
- while (node->children)
+ while (node->children) {
libbalsa_mailbox_unlink_and_prepend(mti->mailbox,
node->children,
node->parent);
+ }
/* Now we can destroy the node. */
libbalsa_mailbox_unlink_and_prepend(mti->mailbox, node, NULL);
}
@@ -3876,52 +4277,60 @@ lbm_update_msg_tree_prune(GNode * node,
return FALSE;
}
+
/* GNodeTraverseFunc for checking parent-child relationships; mti->nodes
* is a reverse lookup array into the old tree, so a NULL value means a
* node that isn't in the current tree, and we insert one; because the
* traverse is top-down, a missing parent will have been inserted before
* we get to the child. */
static gboolean
-lbm_update_msg_tree_move(GNode * new_node,
+lbm_update_msg_tree_move(GNode *new_node,
struct lbm_update_msg_tree_info *mti)
{
guint msgno;
GNode *node;
GNode *parent;
- if (!new_node->parent)
+ if (!new_node->parent) {
return FALSE;
+ }
msgno = GPOINTER_TO_UINT(new_node->data);
- if (msgno >= mti->total)
+ if (msgno >= mti->total) {
return FALSE;
+ }
node = mti->nodes[msgno];
- if (!node)
+ if (!node) {
mti->nodes[msgno] = node = g_node_new(new_node->data);
+ }
msgno = GPOINTER_TO_UINT(new_node->parent->data);
- if (msgno >= mti->total)
+ if (msgno >= mti->total) {
return FALSE;
+ }
parent = mti->nodes[msgno];
- if (parent && parent != node->parent)
+ if (parent && (parent != node->parent)) {
libbalsa_mailbox_unlink_and_prepend(mti->mailbox, node, parent);
+ }
return FALSE;
}
+
static void
-lbm_update_msg_tree(LibBalsaMailbox * mailbox, GNode * new_tree)
+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;
+ mti.mailbox = mailbox;
mti.new_tree = new_tree;
- mti.total = 1 + libbalsa_mailbox_total_messages(mailbox);
- mti.nodes = g_new0(GNode *, mti.total);
+ mti.total = 1 + libbalsa_mailbox_total_messages(mailbox);
+ mti.nodes = g_new0(GNode *, mti.total);
/* Populate the nodes array with nodes in the new tree. */
g_node_traverse(new_tree, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
@@ -3942,8 +4351,9 @@ lbm_update_msg_tree(LibBalsaMailbox * mailbox, GNode * new_tree)
g_free(mti.nodes);
}
+
static void
-lbm_set_msg_tree(LibBalsaMailbox * mailbox)
+lbm_set_msg_tree(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GtkTreeIter iter;
@@ -3952,8 +4362,9 @@ lbm_set_msg_tree(LibBalsaMailbox * mailbox)
iter.stamp = ++priv->stamp;
- if (!priv->msg_tree)
+ if (!priv->msg_tree) {
return;
+ }
path = gtk_tree_path_new();
gtk_tree_path_down(path);
@@ -3963,18 +4374,21 @@ lbm_set_msg_tree(LibBalsaMailbox * mailbox)
g_signal_emit(mailbox,
libbalsa_mbox_model_signals[ROW_INSERTED], 0, path,
&iter);
- if (node->children)
+ if (node->children) {
g_signal_emit(mailbox,
libbalsa_mbox_model_signals
[ROW_HAS_CHILD_TOGGLED], 0, path, &iter);
+ }
gtk_tree_path_next(path);
}
gtk_tree_path_free(path);
}
+
void
-libbalsa_mailbox_set_msg_tree(LibBalsaMailbox * mailbox, GNode * new_tree)
+libbalsa_mailbox_set_msg_tree(LibBalsaMailbox *mailbox,
+ GNode *new_tree)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -3982,8 +4396,9 @@ libbalsa_mailbox_set_msg_tree(LibBalsaMailbox * mailbox, GNode * new_tree)
lbm_update_msg_tree(mailbox, new_tree);
g_node_destroy(new_tree);
} else {
- if (priv->msg_tree)
+ if (priv->msg_tree) {
g_node_destroy(priv->msg_tree);
+ }
priv->msg_tree = new_tree;
lbm_set_msg_tree(mailbox);
}
@@ -3991,23 +4406,26 @@ libbalsa_mailbox_set_msg_tree(LibBalsaMailbox * mailbox, GNode * new_tree)
priv->msg_tree_changed = TRUE;
}
+
static GMimeMessage *
-lbm_get_mime_msg(LibBalsaMailbox * mailbox, LibBalsaMessage * msg)
+lbm_get_mime_msg(LibBalsaMailbox *mailbox,
+ LibBalsaMessage *msg)
{
GMimeMessage *mime_msg;
- if (!msg->mime_msg)
+ if (!msg->mime_msg) {
libbalsa_mailbox_fetch_message_structure(mailbox, msg,
LB_FETCH_RFC822_HEADERS);
+ }
mime_msg = msg->mime_msg;
- if (mime_msg)
+ if (mime_msg) {
g_object_ref(mime_msg);
- else {
+ } else {
GMimeStream *stream;
GMimeParser *parser;
stream = libbalsa_mailbox_get_message_stream(mailbox, msg->msgno,
- TRUE);
+ TRUE);
parser = g_mime_parser_new_with_stream(stream);
g_object_unref(stream);
mime_msg = g_mime_parser_construct_message(parser);
@@ -4018,24 +4436,29 @@ lbm_get_mime_msg(LibBalsaMailbox * mailbox, LibBalsaMessage * msg)
return mime_msg;
}
+
/* Try to reassemble messages of type message/partial with the given id;
* if successful, delete the parts, so we don't keep creating the whole
* message. */
static void
-lbm_try_reassemble_func(GMimeObject * parent, GMimeObject * mime_part,
- gpointer data)
+lbm_try_reassemble_func(GMimeObject *parent,
+ GMimeObject *mime_part,
+ gpointer data)
{
- if (GMIME_IS_MESSAGE_PART(mime_part))
+ if (GMIME_IS_MESSAGE_PART(mime_part)) {
mime_part = ((GMimeMessagePart *) mime_part)->message->mime_part;
+ }
if (GMIME_IS_MESSAGE_PARTIAL(mime_part)) {
const GMimeMessagePartial **partial = data;
*partial = (GMimeMessagePartial *) mime_part;
}
}
+
static void
-lbm_try_reassemble(LibBalsaMailbox * mailbox, const gchar * id)
+lbm_try_reassemble(LibBalsaMailbox *mailbox,
+ const gchar *id)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
gchar *text;
@@ -4043,8 +4466,8 @@ lbm_try_reassemble(LibBalsaMailbox * mailbox, const gchar * id)
LibBalsaProgress progress;
guint msgno;
GPtrArray *partials = g_ptr_array_new();
- guint total = G_MAXUINT;
- GArray *messages = g_array_new(FALSE, FALSE, sizeof(guint));
+ guint total = G_MAXUINT;
+ GArray *messages = g_array_new(FALSE, FALSE, sizeof(guint));
text = g_strdup_printf(_("Searching %s for partial messages"),
priv->name);
@@ -4060,8 +4483,9 @@ lbm_try_reassemble(LibBalsaMailbox * mailbox, const gchar * id)
if (libbalsa_mailbox_msgno_has_flags(mailbox, msgno,
LIBBALSA_MESSAGE_FLAG_DELETED,
0)
- || !(message = libbalsa_mailbox_get_message(mailbox, msgno)))
+ || !(message = libbalsa_mailbox_get_message(mailbox, msgno))) {
continue;
+ }
if (!libbalsa_message_is_partial(message, &tmp_id)) {
g_object_unref(message);
@@ -4069,13 +4493,14 @@ lbm_try_reassemble(LibBalsaMailbox * mailbox, const gchar * id)
}
if (strcmp(tmp_id, id) == 0) {
- GMimeMessage *mime_message = lbm_get_mime_msg(mailbox, message);
+ GMimeMessage *mime_message = lbm_get_mime_msg(mailbox, message);
GMimeMessagePartial *partial =
(GMimeMessagePartial *) mime_message->mime_part;
g_ptr_array_add(partials, partial);
- if (g_mime_message_partial_get_total(partial) > 0)
+ if (g_mime_message_partial_get_total(partial) > 0) {
total = g_mime_message_partial_get_total(partial);
+ }
g_object_ref(partial);
g_object_unref(mime_message);
@@ -4101,8 +4526,9 @@ lbm_try_reassemble(LibBalsaMailbox * mailbox, const gchar * id)
if (libbalsa_mailbox_msgno_has_flags(mailbox, msgno,
LIBBALSA_MESSAGE_FLAG_DELETED,
0)
- || !(message = libbalsa_mailbox_get_message(mailbox, msgno)))
+ || !(message = libbalsa_mailbox_get_message(mailbox, msgno))) {
continue;
+ }
if (!libbalsa_message_is_multipart(message)) {
g_object_unref(message);
@@ -4110,15 +4536,16 @@ lbm_try_reassemble(LibBalsaMailbox * mailbox, const gchar * id)
}
mime_message = lbm_get_mime_msg(mailbox, message);
- partial = NULL;
+ partial = NULL;
g_mime_multipart_foreach((GMimeMultipart *)
mime_message->mime_part,
lbm_try_reassemble_func, &partial);
if (partial
- && strcmp(g_mime_message_partial_get_id(partial), id) == 0) {
+ && (strcmp(g_mime_message_partial_get_id(partial), id) == 0)) {
g_ptr_array_add(partials, partial);
- if (g_mime_message_partial_get_total(partial) > 0)
+ if (g_mime_message_partial_get_total(partial) > 0) {
total = g_mime_message_partial_get_total(partial);
+ }
g_object_ref(partial);
/* We will leave this message undeleted, as it may have
* some warning content.
@@ -4158,10 +4585,11 @@ lbm_try_reassemble(LibBalsaMailbox * mailbox, const gchar * id)
libbalsa_progress_set_text(&progress, NULL, 0);
}
+
#define LBM_TRY_REASSEMBLE_IDS "libbalsa-mailbox-try-reassemble-ids"
static gboolean
-lbm_try_reassemble_idle(LibBalsaMailbox * mailbox)
+lbm_try_reassemble_idle(LibBalsaMailbox *mailbox)
{
GSList *id, *ids;
@@ -4170,8 +4598,9 @@ lbm_try_reassemble_idle(LibBalsaMailbox * mailbox)
libbalsa_lock_mailbox(mailbox);
ids = g_object_get_data(G_OBJECT(mailbox), LBM_TRY_REASSEMBLE_IDS);
- for (id = ids; id; id = id->next)
+ for (id = ids; id; id = id->next) {
lbm_try_reassemble(mailbox, id->data);
+ }
g_slist_free_full(ids, g_free);
g_object_set_data(G_OBJECT(mailbox), LBM_TRY_REASSEMBLE_IDS, NULL);
@@ -4183,15 +4612,17 @@ lbm_try_reassemble_idle(LibBalsaMailbox * mailbox)
return FALSE;
}
+
void
-libbalsa_mailbox_try_reassemble(LibBalsaMailbox * mailbox,
- const gchar * id)
+libbalsa_mailbox_try_reassemble(LibBalsaMailbox *mailbox,
+ const gchar *id)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GSList *ids;
- if (priv->no_reassemble)
+ if (priv->no_reassemble) {
return;
+ }
ids = g_object_get_data(G_OBJECT(mailbox), LBM_TRY_REASSEMBLE_IDS);
if (!ids) {
@@ -4205,91 +4636,108 @@ libbalsa_mailbox_try_reassemble(LibBalsaMailbox * mailbox,
}
}
+
/* Use "message-expunged" signal to update an array of msgnos. */
static void
-lbm_update_msgnos(LibBalsaMailbox * mailbox, guint seqno, GArray * msgnos)
+lbm_update_msgnos(LibBalsaMailbox *mailbox,
+ guint seqno,
+ GArray *msgnos)
{
guint i, j;
for (i = j = 0; i < msgnos->len; i++) {
guint msgno = g_array_index(msgnos, guint, i);
- if (msgno == seqno)
+ if (msgno == seqno) {
continue;
- if (msgno > seqno)
+ }
+ if (msgno > seqno) {
--msgno;
+ }
g_array_index(msgnos, guint, j) = msgno;
++j;
}
msgnos->len = j;
}
+
void
-libbalsa_mailbox_register_msgnos(LibBalsaMailbox * mailbox,
- GArray * msgnos)
+libbalsa_mailbox_register_msgnos(LibBalsaMailbox *mailbox,
+ GArray *msgnos)
{
g_signal_connect(mailbox, "message-expunged",
G_CALLBACK(lbm_update_msgnos), msgnos);
}
+
void
-libbalsa_mailbox_unregister_msgnos(LibBalsaMailbox * mailbox,
- GArray * msgnos)
+libbalsa_mailbox_unregister_msgnos(LibBalsaMailbox *mailbox,
+ GArray *msgnos)
{
- if (mailbox && msgnos)
- g_signal_handlers_disconnect_by_func(mailbox, lbm_update_msgnos,
+ if (mailbox && msgnos) {
+ g_signal_handlers_disconnect_by_func(mailbox, lbm_update_msgnos,
msgnos);
+ }
}
+
/* Accessors for LibBalsaMailboxIndexEntry */
LibBalsaMessageStatus
-libbalsa_mailbox_msgno_get_status(LibBalsaMailbox * mailbox, guint msgno)
+libbalsa_mailbox_msgno_get_status(LibBalsaMailbox *mailbox,
+ guint msgno)
{
- LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
LibBalsaMailboxIndexEntry *entry =
g_ptr_array_index(priv->mindex, msgno - 1);
return VALID_ENTRY(entry) ?
- entry->status_icon : LIBBALSA_MESSAGE_STATUS_ICONS_NUM;
+ entry->status_icon : LIBBALSA_MESSAGE_STATUS_ICONS_NUM;
}
+
const gchar *
-libbalsa_mailbox_msgno_get_subject(LibBalsaMailbox * mailbox, guint msgno)
+libbalsa_mailbox_msgno_get_subject(LibBalsaMailbox *mailbox,
+ guint msgno)
{
- LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+ LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
LibBalsaMailboxIndexEntry *entry =
g_ptr_array_index(priv->mindex, msgno - 1);
return VALID_ENTRY(entry) ? entry->subject : NULL;
}
+
/* Update icons, but only if entry has been allocated. */
void
-libbalsa_mailbox_msgno_update_attach(LibBalsaMailbox * mailbox,
- guint msgno, LibBalsaMessage * message)
+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 || !priv->mindex || priv->mindex->len < msgno)
- return;
+ if (!mailbox || !priv->mindex || (priv->mindex->len < msgno)) {
+ return;
+ }
entry = g_ptr_array_index(priv->mindex, msgno - 1);
- if (!VALID_ENTRY(entry))
- return;
+ if (!VALID_ENTRY(entry)) {
+ return;
+ }
attach_icon = libbalsa_message_get_attach_icon(message);
if (entry->attach_icon != attach_icon) {
GtkTreeIter iter;
- entry->attach_icon = attach_icon;
- iter.user_data = NULL;
- lbm_msgno_changed(mailbox, msgno, &iter);
+ entry->attach_icon = attach_icon;
+ iter.user_data = NULL;
+ lbm_msgno_changed(mailbox, msgno, &iter);
}
}
+
/* Queued check. */
static void
-lbm_check_real(LibBalsaMailbox * mailbox)
+lbm_check_real(LibBalsaMailbox *mailbox)
{
libbalsa_lock_mailbox(mailbox);
libbalsa_mailbox_check(mailbox);
@@ -4297,8 +4745,9 @@ lbm_check_real(LibBalsaMailbox * mailbox)
g_object_unref(mailbox);
}
+
static gboolean
-lbm_check_idle(LibBalsaMailbox * mailbox)
+lbm_check_idle(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GThread *check_thread;
@@ -4314,18 +4763,21 @@ lbm_check_idle(LibBalsaMailbox * mailbox)
return FALSE;
}
+
static void
-lbm_queue_check(LibBalsaMailbox * mailbox)
+lbm_queue_check(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
libbalsa_lock_mailbox(mailbox);
- if (!priv->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);
}
+
/* Search mailbox for a message matching the condition in search_iter,
* starting at iter, either forward or backward, and abandoning the
* search if message stop_msgno is reached; return value indicates
@@ -4336,11 +4788,11 @@ lbm_queue_check(LibBalsaMailbox * mailbox)
* if return value is FALSE, iter is invalid.
*/
gboolean
-libbalsa_mailbox_search_iter_step(LibBalsaMailbox * mailbox,
- LibBalsaMailboxSearchIter * search_iter,
- GtkTreeIter * iter,
- gboolean forward,
- guint stop_msgno)
+libbalsa_mailbox_search_iter_step(LibBalsaMailbox *mailbox,
+ LibBalsaMailboxSearchIter *search_iter,
+ GtkTreeIter *iter,
+ gboolean forward,
+ guint stop_msgno)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
GNode *node;
@@ -4348,60 +4800,66 @@ libbalsa_mailbox_search_iter_step(LibBalsaMailbox * mailbox,
gint total;
node = iter->user_data;
- if (!node)
+ if (!node) {
node = priv->msg_tree;
+ }
total = libbalsa_mailbox_total_messages(mailbox);
for (;;) {
guint msgno;
- node = forward ? lbm_next(node) : lbm_prev(node);
+ node = forward ? lbm_next(node) : lbm_prev(node);
msgno = GPOINTER_TO_UINT(node->data);
- if (msgno == stop_msgno
- || --total < 0 /* Runaway? */ ) {
+ if ((msgno == stop_msgno)
+ || (--total < 0) /* Runaway? */ ) {
retval = FALSE;
break;
}
- if (msgno > 0
+ if ((msgno > 0)
&& libbalsa_mailbox_message_match(mailbox, msgno,
search_iter)) {
iter->user_data = node;
- retval = TRUE;
+ retval = TRUE;
break;
}
}
- if (retval)
+ if (retval) {
VALIDATE_ITER(iter, mailbox);
- else
- INVALIDATE_ITER(iter);
+ } else {
+ INVALIDATE_ITER(iter);
+ }
return retval;
}
+
/* Remove duplicates */
gboolean
-libbalsa_mailbox_can_move_duplicates(LibBalsaMailbox * mailbox)
+libbalsa_mailbox_can_move_duplicates(LibBalsaMailbox *mailbox)
{
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
return LIBBALSA_MAILBOX_GET_CLASS(mailbox)->duplicate_msgnos != NULL;
}
+
gint
-libbalsa_mailbox_move_duplicates(LibBalsaMailbox * mailbox,
- LibBalsaMailbox * dest, GError ** err)
+libbalsa_mailbox_move_duplicates(LibBalsaMailbox *mailbox,
+ LibBalsaMailbox *dest,
+ GError **err)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
- GArray *msgnos = NULL;
+ GArray *msgnos = NULL;
gint retval;
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
- if (libbalsa_mailbox_can_move_duplicates(mailbox))
+ if (libbalsa_mailbox_can_move_duplicates(mailbox)) {
msgnos =
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->duplicate_msgnos(mailbox);
+ }
if (priv->state == LB_MAILBOX_STATE_CLOSED) {
/* duplicate msgnos was interrupted */
@@ -4411,25 +4869,28 @@ libbalsa_mailbox_move_duplicates(LibBalsaMailbox * mailbox,
return 0;
}
- if (!msgnos)
+ if (!msgnos) {
return 0;
+ }
if (msgnos->len > 0) {
- if (dest && mailbox != dest)
+ if (dest && (mailbox != dest)) {
libbalsa_mailbox_messages_move(mailbox, msgnos, dest, err);
- else
+ } else {
libbalsa_mailbox_messages_change_flags(mailbox, msgnos,
LIBBALSA_MESSAGE_FLAG_DELETED,
0);
+ }
}
retval = msgnos->len;
g_array_free(msgnos, TRUE);
return retval;
}
+
/* Lock and unlock the mail store. NULL mailbox is not an error. */
-void
-libbalsa_mailbox_lock_store(LibBalsaMailbox * mailbox)
+void
+libbalsa_mailbox_lock_store(LibBalsaMailbox *mailbox)
{
if (mailbox != NULL) {
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
@@ -4438,8 +4899,9 @@ libbalsa_mailbox_lock_store(LibBalsaMailbox * mailbox)
}
}
-void
-libbalsa_mailbox_unlock_store(LibBalsaMailbox * mailbox)
+
+void
+libbalsa_mailbox_unlock_store(LibBalsaMailbox *mailbox)
{
if (mailbox != NULL) {
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
@@ -4448,24 +4910,30 @@ libbalsa_mailbox_unlock_store(LibBalsaMailbox * mailbox)
}
}
+
void
-libbalsa_mailbox_cache_message(LibBalsaMailbox * mailbox, guint msgno,
- LibBalsaMessage * message)
+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 (!priv->mindex)
+ if (!priv->mindex) {
return;
+ }
g_return_if_fail(msgno > 0);
g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
lbm_cache_message(mailbox, msgno, message);
}
+
static void
-lbm_set_color(LibBalsaMailbox * mailbox, GArray * msgnos,
- const gchar * color, gboolean foreground)
+lbm_set_color(LibBalsaMailbox *mailbox,
+ GArray *msgnos,
+ const gchar *color,
+ gboolean foreground)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
guint i;
@@ -4474,194 +4942,222 @@ lbm_set_color(LibBalsaMailbox * mailbox, GArray * msgnos,
guint msgno = g_array_index(msgnos, guint, i);
LibBalsaMailboxIndexEntry *entry;
- if (msgno > priv->mindex->len)
+ if (msgno > priv->mindex->len) {
return;
+ }
entry = g_ptr_array_index(priv->mindex, msgno - 1);
- if (!entry)
+ if (!entry) {
entry = g_ptr_array_index(priv->mindex, msgno - 1) =
- g_new0(LibBalsaMailboxIndexEntry, 1);
+ g_new0(LibBalsaMailboxIndexEntry, 1);
+ }
if (foreground) {
g_free(entry->foreground);
- entry->foreground = g_strdup(color);
+ entry->foreground = g_strdup(color);
entry->foreground_set = TRUE;
} else {
g_free(entry->background);
- entry->background = g_strdup(color);
+ entry->background = g_strdup(color);
entry->background_set = TRUE;
}
}
}
+
void
-libbalsa_mailbox_set_foreground(LibBalsaMailbox * mailbox, GArray * msgnos,
- const gchar * color)
+libbalsa_mailbox_set_foreground(LibBalsaMailbox *mailbox,
+ GArray *msgnos,
+ const gchar *color)
{
lbm_set_color(mailbox, msgnos, color, TRUE);
}
+
void
-libbalsa_mailbox_set_background(LibBalsaMailbox * mailbox, GArray * msgnos,
- const gchar * color)
+libbalsa_mailbox_set_background(LibBalsaMailbox *mailbox,
+ GArray *msgnos,
+ const gchar *color)
{
lbm_set_color(mailbox, msgnos, color, FALSE);
}
-void libbalsa_mailbox_test_can_reach(LibBalsaMailbox * mailbox,
- LibBalsaCanReachCallback * cb,
- gpointer cb_data)
+
+void
+libbalsa_mailbox_test_can_reach(LibBalsaMailbox *mailbox,
+ LibBalsaCanReachCallback *cb,
+ gpointer cb_data)
{
g_assert(LIBBALSA_MAILBOX_GET_CLASS(mailbox) != NULL);
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->test_can_reach(mailbox, cb, cb_data);
}
+
/*
* Getters
*/
GSList *
-libbalsa_mailbox_get_filters(LibBalsaMailbox * mailbox)
+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)
+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)
+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)
+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)
+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)
+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)
+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)
+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)
+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)
+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)
+libbalsa_mailbox_get_view(LibBalsaMailbox *mailbox)
{
return lbm_get_view(mailbox);
}
+
gint
-libbalsa_mailbox_get_stamp(LibBalsaMailbox * mailbox)
+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)
+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)
+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)
+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)
+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)
+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)
+libbalsa_mailbox_set_filters(LibBalsaMailbox *mailbox,
+ GSList *filters)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -4669,8 +5165,10 @@ libbalsa_mailbox_set_filters(LibBalsaMailbox * mailbox, GSList * filters)
priv->filters = filters;
}
+
void
-libbalsa_mailbox_set_url(LibBalsaMailbox * mailbox, const gchar * url)
+libbalsa_mailbox_set_url(LibBalsaMailbox *mailbox,
+ const gchar *url)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -4678,48 +5176,60 @@ libbalsa_mailbox_set_url(LibBalsaMailbox * mailbox, const gchar * url)
priv->url = g_strdup(url);
}
+
void
-libbalsa_mailbox_set_first_unread(LibBalsaMailbox * mailbox, guint first)
+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)
+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)
+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)
+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)
+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)
+libbalsa_mailbox_set_name(LibBalsaMailbox *mailbox,
+ const gchar *name)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -4727,8 +5237,10 @@ libbalsa_mailbox_set_name(LibBalsaMailbox * mailbox, const gchar * name)
priv->name = g_strdup(name);
}
+
void
-libbalsa_mailbox_set_view(LibBalsaMailbox * mailbox, LibBalsaMailboxView * view)
+libbalsa_mailbox_set_view(LibBalsaMailbox *mailbox,
+ LibBalsaMailboxView *view)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -4736,18 +5248,20 @@ libbalsa_mailbox_set_view(LibBalsaMailbox * mailbox, LibBalsaMailboxView * view)
priv->view = view;
}
+
void
-libbalsa_mailbox_set_has_unread_messages(LibBalsaMailbox * mailbox,
- gboolean has_unread_messages)
+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)
+libbalsa_mailbox_set_config_prefix(LibBalsaMailbox *mailbox,
+ const gchar *config_prefix)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
@@ -4755,32 +5269,36 @@ libbalsa_mailbox_set_config_prefix(LibBalsaMailbox * mailbox,
priv->config_prefix = g_strdup(config_prefix);
}
+
/*
* Incrementers
*/
void
-libbalsa_mailbox_add_to_unread_messages(LibBalsaMailbox * mailbox, glong count)
+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)
+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)
+libbalsa_unlock_mailbox(LibBalsaMailbox *mailbox)
{
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
diff --git a/libbalsa/mailbox.h b/libbalsa/mailbox.h
index 62d9753..a354266 100644
--- a/libbalsa/mailbox.h
+++ b/libbalsa/mailbox.h
@@ -6,14 +6,14 @@
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
+ * the Free Software Foundation; either version 2, or (at your option)
* any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
@@ -22,7 +22,7 @@
#define __LIBBALSA_MAILBOX_H__
#ifndef BALSA_VERSION
-# error "Include config.h before this file."
+# error "Include config.h before this file."
#endif
#include <gdk/gdk.h>
@@ -37,29 +37,29 @@ G_DECLARE_DERIVABLE_TYPE(LibBalsaMailbox,
GObject)
#define MAILBOX_OPEN(mailbox) \
- (libbalsa_mailbox_get_state(mailbox) != LB_MAILBOX_STATE_CLOSED)
+ (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 {\
- if (MAILBOX_CLOSED (mailbox))\
- {\
- g_print (_("*** ERROR: Mailbox Stream Closed: %s ***\n"), __PRETTY_FUNCTION__);\
- libbalsa_unlock_mailbox (mailbox);\
- return;\
- }\
-} while (0)
-#define RETURN_VAL_IF_CONTEXT_CLOSED(mailbox, val)\
-do {\
- if (MAILBOX_CLOSED (mailbox))\
- {\
- g_print (_("*** ERROR: Mailbox Stream Closed: %s ***\n"), __PRETTY_FUNCTION__);\
- libbalsa_unlock_mailbox (mailbox);\
- return (val);\
- }\
-} while (0)
+ (libbalsa_mailbox_get_state(mailbox) == LB_MAILBOX_STATE_CLOSED)
+
+#define RETURN_IF_MAILBOX_CLOSED(mailbox) \
+ do { \
+ if (MAILBOX_CLOSED (mailbox)) \
+ { \
+ g_print (_("*** ERROR: Mailbox Stream Closed: %s ***\n"), __PRETTY_FUNCTION__); \
+ libbalsa_unlock_mailbox (mailbox); \
+ return; \
+ } \
+ } while (0)
+#define RETURN_VAL_IF_CONTEXT_CLOSED(mailbox, val) \
+ do { \
+ if (MAILBOX_CLOSED (mailbox)) \
+ { \
+ g_print (_("*** ERROR: Mailbox Stream Closed: %s ***\n"), __PRETTY_FUNCTION__); \
+ libbalsa_unlock_mailbox (mailbox); \
+ return (val); \
+ } \
+ } while (0)
typedef enum {
@@ -85,9 +85,9 @@ typedef enum {
} LibBalsaMailboxSortType;
typedef enum {
- LIBBALSA_NTFY_INIT,
- LIBBALSA_NTFY_UPDATE,
- LIBBALSA_NTFY_FINISHED
+ LIBBALSA_NTFY_INIT,
+ LIBBALSA_NTFY_UPDATE,
+ LIBBALSA_NTFY_FINISHED
} LibBalsaMailboxNotify;
@@ -113,8 +113,8 @@ typedef enum {
} LibBalsaMailboxSubscribe;
typedef enum {
- LB_FETCH_RFC822_HEADERS = 1<<0, /* prepare all rfc822 headers */
- LB_FETCH_STRUCTURE = 1<<1 /* prepare message structure */
+ LB_FETCH_RFC822_HEADERS = 1 << 0, /* prepare all rfc822 headers */
+ LB_FETCH_STRUCTURE = 1 << 1 /* prepare message structure */
} LibBalsaFetchFlag;
typedef enum {
@@ -151,16 +151,16 @@ struct _LibBalsaMailboxView {
* LibBalsaCondition to a GUI configuration is not always
* possible. Therefore, we provide this variable for GUI's
* convinence. */
- int filter;
- LibBalsaMailboxSortType sort_type;
- LibBalsaMailboxSortFields sort_field;
- LibBalsaMailboxSortFields sort_field_prev;
- LibBalsaMailboxShow show;
- LibBalsaMailboxSubscribe subscribe;
+ int filter;
+ LibBalsaMailboxSortType sort_type;
+ LibBalsaMailboxSortFields sort_field;
+ LibBalsaMailboxSortFields sort_field_prev;
+ LibBalsaMailboxShow show;
+ LibBalsaMailboxSubscribe subscribe;
gboolean exposed;
gboolean open;
- gboolean in_sync; /* view is in sync with config */
- gboolean used; /* keep track of usage */
+ gboolean in_sync; /* view is in sync with config */
+ gboolean used; /* keep track of usage */
#ifdef HAVE_GPGME
LibBalsaChkCryptoMode gpg_chk_mode;
@@ -184,104 +184,124 @@ struct _LibBalsaMailboxSearchIter {
gint stamp;
LibBalsaMailbox *mailbox;
LibBalsaCondition *condition;
- gpointer user_data; /* private backend info */
+ gpointer user_data; /* private backend info */
};
/** Iterates over a list of messages, returning each time it is called
flags and the stream to a message. It is the responsibility of the
called to un-ref the stream after use. */
typedef gboolean (*LibBalsaAddMessageIterator)(LibBalsaMessageFlag *,
- GMimeStream **stream,
- void *);
+ GMimeStream **stream,
+ void *);
struct _LibBalsaMailboxClass {
GObjectClass parent_class;
/* Signals */
- void (*changed) (LibBalsaMailbox * mailbox);
- void (*message_expunged) (LibBalsaMailbox * mailbox, guint seqno);
- void (*progress_notify) (LibBalsaMailbox * mailbox, gint action, gdouble fraction, gchar *message);
+ void (*changed) (LibBalsaMailbox *mailbox);
+ void (*message_expunged) (LibBalsaMailbox *mailbox,
+ guint seqno);
+ void (*progress_notify) (LibBalsaMailbox *mailbox,
+ gint action,
+ gdouble fraction,
+ gchar *message);
/* Virtual Functions */
- gboolean (*open_mailbox) (LibBalsaMailbox * mailbox, GError **err);
- void (*close_mailbox) (LibBalsaMailbox * mailbox, gboolean expunge);
- LibBalsaMessage *(*get_message) (LibBalsaMailbox * mailbox, guint msgno);
- gboolean (*prepare_threading)(LibBalsaMailbox *mailbox, guint start);
- gboolean (*fetch_message_structure)(LibBalsaMailbox *mailbox,
- LibBalsaMessage * message,
+ gboolean (*open_mailbox) (LibBalsaMailbox *mailbox,
+ GError **err);
+ void (*close_mailbox) (LibBalsaMailbox *mailbox,
+ gboolean expunge);
+ LibBalsaMessage *(*get_message) (LibBalsaMailbox *mailbox,
+ guint msgno);
+ gboolean (*prepare_threading)(LibBalsaMailbox *mailbox,
+ guint start);
+ gboolean (*fetch_message_structure)(LibBalsaMailbox *mailbox,
+ LibBalsaMessage *message,
LibBalsaFetchFlag flags);
void (*fetch_headers)(LibBalsaMailbox *mailbox,
- LibBalsaMessage * message);
- void (*release_message) (LibBalsaMailbox * mailbox,
- LibBalsaMessage * message);
- gboolean (*get_message_part) (LibBalsaMessage *message,
- LibBalsaMessageBody *part,
- GError **err);
- GMimeStream *(*get_message_stream) (LibBalsaMailbox * mailbox,
- guint msgno, gboolean peek);
-
- void (*check) (LibBalsaMailbox * mailbox);
-
- void (*search_iter_free) (LibBalsaMailboxSearchIter * iter);
- gboolean (*message_match) (LibBalsaMailbox * mailbox,
- guint msgno,
- LibBalsaMailboxSearchIter *search_iter);
- gboolean (*can_match) (LibBalsaMailbox * mailbox,
- LibBalsaCondition *condition);
- void (*save_config) (LibBalsaMailbox * mailbox, const gchar * prefix);
- void (*load_config) (LibBalsaMailbox * mailbox, const gchar * prefix);
- gboolean (*sync) (LibBalsaMailbox * mailbox, gboolean expunge);
- guint (*add_messages) (LibBalsaMailbox * mailbox,
- LibBalsaAddMessageIterator msg_iterator,
- void *iter_arg, GError ** err);
- gboolean (*messages_change_flags) (LibBalsaMailbox * mailbox,
- GArray *msgnos,
- LibBalsaMessageFlag set,
- LibBalsaMessageFlag clear);
- gboolean (*messages_copy) (LibBalsaMailbox * mailbox, GArray *msgnos,
- LibBalsaMailbox * dest, GError **err);
+ LibBalsaMessage *message);
+ void (*release_message) (LibBalsaMailbox *mailbox,
+ LibBalsaMessage *message);
+ gboolean (*get_message_part) (LibBalsaMessage *message,
+ LibBalsaMessageBody *part,
+ GError **err);
+ GMimeStream *(*get_message_stream) (LibBalsaMailbox *mailbox,
+ guint msgno,
+ gboolean peek);
+
+ void (*check) (LibBalsaMailbox *mailbox);
+
+ void (*search_iter_free) (LibBalsaMailboxSearchIter *iter);
+ gboolean (*message_match) (LibBalsaMailbox *mailbox,
+ guint msgno,
+ LibBalsaMailboxSearchIter *search_iter);
+ gboolean (*can_match) (LibBalsaMailbox *mailbox,
+ LibBalsaCondition *condition);
+ void (*save_config) (LibBalsaMailbox *mailbox,
+ const gchar *prefix);
+ void (*load_config) (LibBalsaMailbox *mailbox,
+ const gchar *prefix);
+ gboolean (*sync) (LibBalsaMailbox *mailbox,
+ gboolean expunge);
+ guint (*add_messages) (LibBalsaMailbox *mailbox,
+ LibBalsaAddMessageIterator msg_iterator,
+ void *iter_arg,
+ GError **err);
+ gboolean (*messages_change_flags) (LibBalsaMailbox *mailbox,
+ GArray *msgnos,
+ LibBalsaMessageFlag set,
+ LibBalsaMessageFlag clear);
+ gboolean (*messages_copy) (LibBalsaMailbox *mailbox,
+ GArray *msgnos,
+ LibBalsaMailbox *dest,
+ GError **err);
/* Test message flags */
- gboolean(*msgno_has_flags) (LibBalsaMailbox * mailbox, guint msgno,
- LibBalsaMessageFlag set,
- LibBalsaMessageFlag unset);
+ gboolean (*msgno_has_flags) (LibBalsaMailbox *mailbox,
+ guint msgno,
+ LibBalsaMessageFlag set,
+ LibBalsaMessageFlag unset);
- gboolean (*can_do) (LibBalsaMailbox *mailbox,
+ gboolean (*can_do) (LibBalsaMailbox *mailbox,
enum LibBalsaMailboxCapability cap);
- void (*set_threading) (LibBalsaMailbox * mailbox,
- LibBalsaMailboxThreadingType thread_type);
- void (*update_view_filter) (LibBalsaMailbox * mailbox,
+ void (*set_threading) (LibBalsaMailbox *mailbox,
+ LibBalsaMailboxThreadingType thread_type);
+ void (*update_view_filter) (LibBalsaMailbox *mailbox,
LibBalsaCondition *view_filter);
- void (*sort) (LibBalsaMailbox * mailbox, GArray *sort_array);
- gboolean (*close_backend)(LibBalsaMailbox * mailbox);
- guint (*total_messages)(LibBalsaMailbox * mailbox);
- GArray *(*duplicate_msgnos) (LibBalsaMailbox * mailbox);
- void (*lock_store) (LibBalsaMailbox * mailbox, gboolean lock);
- void (*test_can_reach) (LibBalsaMailbox * mailbox,
- LibBalsaCanReachCallback * cb,
- gpointer cb_data);
+ void (*sort) (LibBalsaMailbox *mailbox,
+ GArray *sort_array);
+ gboolean (*close_backend)(LibBalsaMailbox *mailbox);
+ guint (*total_messages)(LibBalsaMailbox *mailbox);
+ GArray *(*duplicate_msgnos) (LibBalsaMailbox *mailbox);
+ void (*lock_store) (LibBalsaMailbox *mailbox,
+ gboolean lock);
+ void (*test_can_reach) (LibBalsaMailbox *mailbox,
+ LibBalsaCanReachCallback *cb,
+ gpointer cb_data);
};
-LibBalsaMailbox *libbalsa_mailbox_new_from_config(const gchar * prefix);
+LibBalsaMailbox *libbalsa_mailbox_new_from_config(const gchar *prefix);
-/*
- * open and close a mailbox
+/*
+ * open and close a mailbox
*/
/* XXX these need to return a value if they failed */
-gboolean libbalsa_mailbox_open(LibBalsaMailbox * mailbox, GError **err);
-gboolean libbalsa_mailbox_is_valid(LibBalsaMailbox * mailbox);
+gboolean libbalsa_mailbox_open(LibBalsaMailbox *mailbox,
+ GError **err);
+gboolean libbalsa_mailbox_is_valid(LibBalsaMailbox *mailbox);
gboolean libbalsa_mailbox_is_open(LibBalsaMailbox *mailbox);
-void libbalsa_mailbox_close(LibBalsaMailbox * mailbox, gboolean expunge);
-
-void libbalsa_mailbox_check(LibBalsaMailbox * mailbox);
-void libbalsa_mailbox_changed(LibBalsaMailbox * mailbox);
-void libbalsa_mailbox_set_unread_messages_flag(LibBalsaMailbox * mailbox,
- gboolean has_unread);
-void libbalsa_mailbox_progress_notify(LibBalsaMailbox *mailbox,
- LibBalsaMailboxNotify action,
- gdouble
fraction,
- const gchar *message,
- ...)
- G_GNUC_PRINTF(4, 5);
+void libbalsa_mailbox_close(LibBalsaMailbox *mailbox,
+ gboolean expunge);
+
+void libbalsa_mailbox_check(LibBalsaMailbox *mailbox);
+void libbalsa_mailbox_changed(LibBalsaMailbox *mailbox);
+void libbalsa_mailbox_set_unread_messages_flag(LibBalsaMailbox *mailbox,
+ gboolean has_unread);
+void libbalsa_mailbox_progress_notify(LibBalsaMailbox *mailbox,
+ LibBalsaMailboxNotify action,
+ gdouble fraction,
+ const gchar *message,
+ ...)
+G_GNUC_PRINTF(4, 5);
/** Message access functions.
*/
@@ -292,51 +312,50 @@ void libbalsa_mailbox_progress_notify(LibBalsaMailbox *mailbox,
produce message index unless more information was requested to be
prefetched.
*/
-LibBalsaMessage *libbalsa_mailbox_get_message(LibBalsaMailbox * mailbox,
- guint msgno);
+LibBalsaMessage *libbalsa_mailbox_get_message(LibBalsaMailbox *mailbox,
+ guint msgno);
/** libbalsa_mailbox_prepare_threading() requests prefetching of information
needed for client-side message threading.
msgnos are related to currently set view.
Returns TRUE if successful; FALSE may mean that the mailbox was
closed during the operation.
-*/
-gboolean libbalsa_mailbox_prepare_threading(LibBalsaMailbox * mailbox,
- guint start);
+ */
+gboolean libbalsa_mailbox_prepare_threading(LibBalsaMailbox *mailbox,
+ guint start);
/** libbalsa_mailbox_fetch_message_structure() fetches detailed
message structure for given message. It can also fetch all RFC822
headers of the message.
-*/
-gboolean libbalsa_mailbox_fetch_message_structure(LibBalsaMailbox *
- mailbox,
- LibBalsaMessage *
- message,
+ */
+gboolean libbalsa_mailbox_fetch_message_structure(LibBalsaMailbox *mailbox,
+ LibBalsaMessage *message,
LibBalsaFetchFlag flags);
/** libbalsa_mailbox_release_message() is called when the message
content and structure are no longer needed. It's passed to the
maildir and mh backends to unref the mime_message, but is a noop
for other backends.
-*/
-void libbalsa_mailbox_release_message(LibBalsaMailbox * mailbox,
- LibBalsaMessage * message);
+ */
+void libbalsa_mailbox_release_message(LibBalsaMailbox *mailbox,
+ LibBalsaMessage *message);
-void libbalsa_mailbox_set_msg_headers(LibBalsaMailbox * mailbox,
- LibBalsaMessage * message);
+void libbalsa_mailbox_set_msg_headers(LibBalsaMailbox *mailbox,
+ LibBalsaMessage *message);
/** libbalsa_mailbox_get_message_part() ensures that a selected, single
part of the message is loaded.
-*/
-gboolean libbalsa_mailbox_get_message_part(LibBalsaMessage *message,
- LibBalsaMessageBody *part,
- GError **err);
+ */
+gboolean libbalsa_mailbox_get_message_part(LibBalsaMessage *message,
+ LibBalsaMessageBody *part,
+ GError **err);
/** libbalsa_mailbox_get_message_stream() returns a message stream associated
with full RFC822 text of the message.
-*/
-GMimeStream *libbalsa_mailbox_get_message_stream(LibBalsaMailbox * mailbox,
- guint msgno, gboolean peek);
+ */
+GMimeStream *libbalsa_mailbox_get_message_stream(LibBalsaMailbox *mailbox,
+ guint msgno,
+ gboolean peek);
/** libbalsa_mailbox_sync_storage() asks the mailbox to synchronise
@@ -344,98 +363,98 @@ GMimeStream *libbalsa_mailbox_get_message_stream(LibBalsaMailbox * mailbox,
update storage immediately and for them this operation may be
no-op. When expunge is set, driver is supposed to clean up the mailbox,
including physical removal of old deleted messages.
-*/
+ */
-gboolean libbalsa_mailbox_sync_storage(LibBalsaMailbox * mailbox,
- gboolean expunge);
+gboolean libbalsa_mailbox_sync_storage(LibBalsaMailbox *mailbox,
+ gboolean expunge);
/* This function returns TRUE if the mailbox can be matched
against the given filters (eg : IMAP mailbox can't
use the SEARCH IMAP command for regex match, so the
match is done via default filtering funcs->can be slow)
*/
-gboolean libbalsa_mailbox_can_match(LibBalsaMailbox *mailbox,
- LibBalsaCondition *condition);
-gboolean libbalsa_mailbox_message_match(LibBalsaMailbox *mailbox,
- guint msgno,
- LibBalsaMailboxSearchIter *search_iter);
+gboolean libbalsa_mailbox_can_match(LibBalsaMailbox *mailbox,
+ LibBalsaCondition *condition);
+gboolean libbalsa_mailbox_message_match(LibBalsaMailbox *mailbox,
+ guint msgno,
+ LibBalsaMailboxSearchIter *search_iter);
/* Search iter */
LibBalsaMailboxSearchIter
- *libbalsa_mailbox_search_iter_new(LibBalsaCondition * condition);
+ *libbalsa_mailbox_search_iter_new(LibBalsaCondition *condition);
LibBalsaMailboxSearchIter
- *libbalsa_mailbox_search_iter_view(LibBalsaMailbox * mailbox);
+ *libbalsa_mailbox_search_iter_view(LibBalsaMailbox *mailbox);
LibBalsaMailboxSearchIter
- *libbalsa_mailbox_search_iter_ref(LibBalsaMailboxSearchIter * iter);
-void libbalsa_mailbox_search_iter_unref(LibBalsaMailboxSearchIter * iter);
-gboolean libbalsa_mailbox_search_iter_step(LibBalsaMailbox * mailbox,
- LibBalsaMailboxSearchIter
- * search_iter,
- GtkTreeIter * iter,
- gboolean forward,
- guint stop_msgno);
+ *libbalsa_mailbox_search_iter_ref(LibBalsaMailboxSearchIter *iter);
+void libbalsa_mailbox_search_iter_unref(LibBalsaMailboxSearchIter *iter);
+gboolean libbalsa_mailbox_search_iter_step(LibBalsaMailbox *mailbox,
+ LibBalsaMailboxSearchIter *search_iter,
+ GtkTreeIter *iter,
+ gboolean forward,
+ guint stop_msgno);
/* Default filtering function (on reception)
It is ONLY FOR INTERNAL USE
-*/
-void libbalsa_mailbox_run_filters_on_reception(LibBalsaMailbox * mailbox);
+ */
+void libbalsa_mailbox_run_filters_on_reception(LibBalsaMailbox *mailbox);
-void libbalsa_mailbox_save_config(LibBalsaMailbox * mailbox,
- const gchar * prefix);
+void libbalsa_mailbox_save_config(LibBalsaMailbox *mailbox,
+ const gchar *prefix);
-gboolean libbalsa_mailbox_add_message(LibBalsaMailbox * mailbox,
- GMimeStream * stream,
+gboolean libbalsa_mailbox_add_message(LibBalsaMailbox *mailbox,
+ GMimeStream *stream,
LibBalsaMessageFlag flags,
- GError ** err);
+ GError **err);
-guint libbalsa_mailbox_add_messages(LibBalsaMailbox * mailbox,
- LibBalsaAddMessageIterator msg_iterator,
- void *arg,
- GError ** err);
+guint libbalsa_mailbox_add_messages(LibBalsaMailbox *mailbox,
+ LibBalsaAddMessageIterator msg_iterator,
+ void *arg,
+ GError **err);
-gboolean libbalsa_mailbox_close_backend(LibBalsaMailbox * mailbox);
+gboolean libbalsa_mailbox_close_backend(LibBalsaMailbox *mailbox);
/* Message number-list methods */
-gboolean libbalsa_mailbox_messages_change_flags(LibBalsaMailbox * mailbox,
- GArray * msgnos,
- LibBalsaMessageFlag set,
- LibBalsaMessageFlag clear);
-gboolean libbalsa_mailbox_messages_copy(LibBalsaMailbox * mailbox,
- GArray * msgnos,
- LibBalsaMailbox * dest, GError **err);
-gboolean libbalsa_mailbox_messages_move(LibBalsaMailbox * mailbox,
- GArray * msgnos,
- LibBalsaMailbox * dest, GError **err);
+gboolean libbalsa_mailbox_messages_change_flags(LibBalsaMailbox *mailbox,
+ GArray *msgnos,
+ LibBalsaMessageFlag set,
+ LibBalsaMessageFlag clear);
+gboolean libbalsa_mailbox_messages_copy(LibBalsaMailbox *mailbox,
+ GArray *msgnos,
+ LibBalsaMailbox *dest,
+ GError **err);
+gboolean libbalsa_mailbox_messages_move(LibBalsaMailbox *mailbox,
+ GArray *msgnos,
+ LibBalsaMailbox *dest,
+ GError **err);
/*
* misc mailbox releated functions
*/
-GType libbalsa_mailbox_type_from_path(const gchar * filename);
+GType libbalsa_mailbox_type_from_path(const gchar *filename);
-guint libbalsa_mailbox_total_messages(LibBalsaMailbox * mailbox);
-gboolean libbalsa_mailbox_can_move_duplicates(LibBalsaMailbox * mailbox);
-gint libbalsa_mailbox_move_duplicates(LibBalsaMailbox * mailbox,
- LibBalsaMailbox * dest,
- GError ** err);
+guint libbalsa_mailbox_total_messages(LibBalsaMailbox *mailbox);
+gboolean libbalsa_mailbox_can_move_duplicates(LibBalsaMailbox *mailbox);
+gint libbalsa_mailbox_move_duplicates(LibBalsaMailbox *mailbox,
+ LibBalsaMailbox *dest,
+ GError **err);
/*
* Mailbox views-related functions.
*/
typedef struct LibBalsaMailboxIndexEntry_ LibBalsaMailboxIndexEntry;
void libbalsa_mailbox_index_entry_set_no(LibBalsaMailboxIndexEntry *entry,
- unsigned no);
-void libbalsa_mailbox_index_entry_clear(LibBalsaMailbox * mailbox,
- guint msgno);
-void libbalsa_mailbox_index_set_flags(LibBalsaMailbox *mailbox,
- unsigned msgno, LibBalsaMessageFlag f);
-gboolean libbalsa_mailbox_set_view_filter(LibBalsaMailbox * mailbox,
- LibBalsaCondition *
- filter_condition,
- gboolean update_immediately);
-void libbalsa_mailbox_make_view_filter_persistent(LibBalsaMailbox *
- mailbox);
-
-gboolean libbalsa_mailbox_can_do(LibBalsaMailbox *mailbox,
+ unsigned no);
+void libbalsa_mailbox_index_entry_clear(LibBalsaMailbox *mailbox,
+ guint msgno);
+void libbalsa_mailbox_index_set_flags(LibBalsaMailbox *mailbox,
+ unsigned msgno,
+ LibBalsaMessageFlag f);
+gboolean libbalsa_mailbox_set_view_filter(LibBalsaMailbox *mailbox,
+ LibBalsaCondition *filter_condition,
+ gboolean update_immediately);
+void libbalsa_mailbox_make_view_filter_persistent(LibBalsaMailbox *mailbox);
+
+gboolean libbalsa_mailbox_can_do(LibBalsaMailbox *mailbox,
enum LibBalsaMailboxCapability cap);
/** libbalsa_mailbox_set_threading() uses backend-optimized threading mode
@@ -444,142 +463,157 @@ gboolean libbalsa_mailbox_can_do(LibBalsaMailbox *mailbox,
libbalsa_mailbox_set_threading() is the public method;
libbalsa_mailbox_set_msg_tree and libbalsa_mailbox_unlink_and_prepend
are helpers for the subclass methods.
-*/
-void libbalsa_mailbox_set_threading(LibBalsaMailbox *mailbox,
- LibBalsaMailboxThreadingType thread_type);
-void libbalsa_mailbox_set_msg_tree(LibBalsaMailbox * mailbox,
- GNode * msg_tree);
-void libbalsa_mailbox_unlink_and_prepend(LibBalsaMailbox * mailbox,
- GNode * node, GNode * parent);
+ */
+void libbalsa_mailbox_set_threading(LibBalsaMailbox *mailbox,
+ LibBalsaMailboxThreadingType thread_type);
+void libbalsa_mailbox_set_msg_tree(LibBalsaMailbox *mailbox,
+ GNode *msg_tree);
+void libbalsa_mailbox_unlink_and_prepend(LibBalsaMailbox *mailbox,
+ GNode *node,
+ GNode *parent);
/* Mailbox views. */
LibBalsaMailboxView *libbalsa_mailbox_view_new(void);
-void libbalsa_mailbox_view_free(LibBalsaMailboxView * view);
-gboolean libbalsa_mailbox_set_identity_name(LibBalsaMailbox * mailbox,
- const gchar * identity_name);
-void libbalsa_mailbox_set_threading_type(LibBalsaMailbox * mailbox,
- LibBalsaMailboxThreadingType
- threading_type);
-void libbalsa_mailbox_set_sort_type(LibBalsaMailbox * mailbox,
- LibBalsaMailboxSortType sort_type);
-void libbalsa_mailbox_set_sort_field(LibBalsaMailbox * mailbox,
- LibBalsaMailboxSortFields sort_field);
-gboolean libbalsa_mailbox_set_show(LibBalsaMailbox * mailbox,
- LibBalsaMailboxShow show);
-gboolean libbalsa_mailbox_set_subscribe(LibBalsaMailbox * mailbox,
+void libbalsa_mailbox_view_free(LibBalsaMailboxView *view);
+gboolean libbalsa_mailbox_set_identity_name(LibBalsaMailbox *mailbox,
+ const gchar *identity_name);
+void libbalsa_mailbox_set_threading_type(LibBalsaMailbox *mailbox,
+ LibBalsaMailboxThreadingType
+ threading_type);
+void libbalsa_mailbox_set_sort_type(LibBalsaMailbox *mailbox,
+ LibBalsaMailboxSortType sort_type);
+void libbalsa_mailbox_set_sort_field(LibBalsaMailbox *mailbox,
+ LibBalsaMailboxSortFields sort_field);
+gboolean libbalsa_mailbox_set_show(LibBalsaMailbox *mailbox,
+ LibBalsaMailboxShow show);
+gboolean libbalsa_mailbox_set_subscribe(LibBalsaMailbox *mailbox,
LibBalsaMailboxSubscribe
subscribe);
-void libbalsa_mailbox_set_exposed(LibBalsaMailbox * mailbox,
- gboolean exposed);
-void libbalsa_mailbox_set_open(LibBalsaMailbox * mailbox, gboolean open);
-void libbalsa_mailbox_set_filter(LibBalsaMailbox * mailbox, gint filter);
+void libbalsa_mailbox_set_exposed(LibBalsaMailbox *mailbox,
+ gboolean exposed);
+void libbalsa_mailbox_set_open(LibBalsaMailbox *mailbox,
+ gboolean open);
+void libbalsa_mailbox_set_filter(LibBalsaMailbox *mailbox,
+ gint filter);
+
#ifdef HAVE_GPGME
-gboolean libbalsa_mailbox_set_crypto_mode(LibBalsaMailbox * mailbox,
- LibBalsaChkCryptoMode gpg_chk_mode);
+gboolean libbalsa_mailbox_set_crypto_mode(LibBalsaMailbox *mailbox,
+ LibBalsaChkCryptoMode gpg_chk_mode);
+
#endif
-void libbalsa_mailbox_set_unread(LibBalsaMailbox * mailbox, gint unread);
-void libbalsa_mailbox_set_total (LibBalsaMailbox * mailbox, gint total);
-void libbalsa_mailbox_set_mtime (LibBalsaMailbox * mailbox, time_t mtime);
-
-const gchar *libbalsa_mailbox_get_identity_name(LibBalsaMailbox * mailbox);
-LibBalsaMailboxThreadingType
-libbalsa_mailbox_get_threading_type(LibBalsaMailbox * mailbox);
-LibBalsaMailboxSortType libbalsa_mailbox_get_sort_type(LibBalsaMailbox *
- mailbox);
-LibBalsaMailboxSortFields libbalsa_mailbox_get_sort_field(LibBalsaMailbox *
- mailbox);
-LibBalsaMailboxShow libbalsa_mailbox_get_show(LibBalsaMailbox * mailbox);
-LibBalsaMailboxSubscribe libbalsa_mailbox_get_subscribe(LibBalsaMailbox *
- mailbox);
-gboolean libbalsa_mailbox_get_exposed(LibBalsaMailbox * mailbox);
-gboolean libbalsa_mailbox_get_open(LibBalsaMailbox * mailbox);
-gint libbalsa_mailbox_get_filter(LibBalsaMailbox * mailbox);
+void libbalsa_mailbox_set_unread(LibBalsaMailbox *mailbox,
+ gint unread);
+void libbalsa_mailbox_set_total(LibBalsaMailbox *mailbox,
+ gint total);
+void libbalsa_mailbox_set_mtime(LibBalsaMailbox *mailbox,
+ time_t mtime);
+
+const gchar *libbalsa_mailbox_get_identity_name(LibBalsaMailbox *mailbox);
+LibBalsaMailboxThreadingType libbalsa_mailbox_get_threading_type(LibBalsaMailbox *mailbox);
+LibBalsaMailboxSortType libbalsa_mailbox_get_sort_type(LibBalsaMailbox *mailbox);
+LibBalsaMailboxSortFields libbalsa_mailbox_get_sort_field(LibBalsaMailbox *mailbox);
+LibBalsaMailboxShow libbalsa_mailbox_get_show(LibBalsaMailbox *mailbox);
+LibBalsaMailboxSubscribe libbalsa_mailbox_get_subscribe(LibBalsaMailbox *mailbox);
+gboolean libbalsa_mailbox_get_exposed(LibBalsaMailbox *mailbox);
+gboolean libbalsa_mailbox_get_open(LibBalsaMailbox *mailbox);
+gint libbalsa_mailbox_get_filter(LibBalsaMailbox *mailbox);
+
#ifdef HAVE_GPGME
-LibBalsaChkCryptoMode libbalsa_mailbox_get_crypto_mode(LibBalsaMailbox * mailbox);
+LibBalsaChkCryptoMode libbalsa_mailbox_get_crypto_mode(LibBalsaMailbox *mailbox);
+
#endif
-gint libbalsa_mailbox_get_unread(LibBalsaMailbox * mailbox);
-gint libbalsa_mailbox_get_total (LibBalsaMailbox * mailbox);
-time_t libbalsa_mailbox_get_mtime(LibBalsaMailbox * mailbox);
+gint libbalsa_mailbox_get_unread(LibBalsaMailbox *mailbox);
+gint libbalsa_mailbox_get_total(LibBalsaMailbox *mailbox);
+time_t libbalsa_mailbox_get_mtime(LibBalsaMailbox *mailbox);
/** force update of given msgno */
-void libbalsa_mailbox_msgno_changed(LibBalsaMailbox *mailbox, guint seqno);
-void libbalsa_mailbox_msgno_inserted(LibBalsaMailbox * mailbox,
- guint seqno, GNode * parent,
- GNode ** sibling);
-void libbalsa_mailbox_msgno_removed(LibBalsaMailbox *mailbox, guint seqno);
-void libbalsa_mailbox_msgno_filt_check(LibBalsaMailbox * mailbox,
- guint seqno,
- LibBalsaMailboxSearchIter
- * search_iter,
- gboolean hold_selected);
+void libbalsa_mailbox_msgno_changed(LibBalsaMailbox *mailbox,
+ guint seqno);
+void libbalsa_mailbox_msgno_inserted(LibBalsaMailbox *mailbox,
+ guint seqno,
+ GNode *parent,
+ GNode **sibling);
+void libbalsa_mailbox_msgno_removed(LibBalsaMailbox *mailbox,
+ guint seqno);
+void libbalsa_mailbox_msgno_filt_check(LibBalsaMailbox *mailbox,
+ guint seqno,
+ LibBalsaMailboxSearchIter
+ *search_iter,
+ gboolean hold_selected);
/* Search */
-gboolean libbalsa_mailbox_msgno_find(LibBalsaMailbox * mailbox,
- guint seqno,
- GtkTreePath ** path,
- GtkTreeIter * iter);
+gboolean libbalsa_mailbox_msgno_find(LibBalsaMailbox *mailbox,
+ guint seqno,
+ GtkTreePath **path,
+ GtkTreeIter *iter);
+
/* Manage message flags */
-gboolean libbalsa_mailbox_msgno_change_flags(LibBalsaMailbox * mailbox,
- guint msgno,
+gboolean libbalsa_mailbox_msgno_change_flags(LibBalsaMailbox *mailbox,
+ guint msgno,
LibBalsaMessageFlag set,
LibBalsaMessageFlag clear);
+
/* Test message flags */
-gboolean libbalsa_mailbox_msgno_has_flags(LibBalsaMailbox * mailbox,
- guint seqno,
+gboolean libbalsa_mailbox_msgno_has_flags(LibBalsaMailbox *mailbox,
+ guint seqno,
LibBalsaMessageFlag set,
LibBalsaMessageFlag unset);
/* set icons */
-void libbalsa_mailbox_set_unread_icon(GdkPixbuf * pixbuf);
-void libbalsa_mailbox_set_trash_icon(GdkPixbuf * pixbuf);
-void libbalsa_mailbox_set_flagged_icon(GdkPixbuf * pixbuf);
-void libbalsa_mailbox_set_replied_icon(GdkPixbuf * pixbuf);
-void libbalsa_mailbox_set_attach_icon(GdkPixbuf * pixbuf);
+void libbalsa_mailbox_set_unread_icon(GdkPixbuf *pixbuf);
+void libbalsa_mailbox_set_trash_icon(GdkPixbuf *pixbuf);
+void libbalsa_mailbox_set_flagged_icon(GdkPixbuf *pixbuf);
+void libbalsa_mailbox_set_replied_icon(GdkPixbuf *pixbuf);
+void libbalsa_mailbox_set_attach_icon(GdkPixbuf *pixbuf);
+
#ifdef HAVE_GPGME
-void libbalsa_mailbox_set_good_icon(GdkPixbuf * pixbuf);
-void libbalsa_mailbox_set_notrust_icon(GdkPixbuf * pixbuf);
-void libbalsa_mailbox_set_bad_icon(GdkPixbuf * pixbuf);
-void libbalsa_mailbox_set_sign_icon(GdkPixbuf * pixbuf);
-void libbalsa_mailbox_set_encr_icon(GdkPixbuf * pixbuf);
+void libbalsa_mailbox_set_good_icon(GdkPixbuf *pixbuf);
+void libbalsa_mailbox_set_notrust_icon(GdkPixbuf *pixbuf);
+void libbalsa_mailbox_set_bad_icon(GdkPixbuf *pixbuf);
+void libbalsa_mailbox_set_sign_icon(GdkPixbuf *pixbuf);
+void libbalsa_mailbox_set_encr_icon(GdkPixbuf *pixbuf);
+
#endif /* HAVE_GPGME */
/* Partial messages */
-void libbalsa_mailbox_try_reassemble(LibBalsaMailbox * mailbox,
- const gchar * id);
+void libbalsa_mailbox_try_reassemble(LibBalsaMailbox *mailbox,
+ const gchar *id);
/* Message numbers and arrays */
-void libbalsa_mailbox_register_msgnos(LibBalsaMailbox * mailbox,
- GArray * msgnos);
-void libbalsa_mailbox_unregister_msgnos(LibBalsaMailbox * mailbox,
- GArray * msgnos);
+void libbalsa_mailbox_register_msgnos(LibBalsaMailbox *mailbox,
+ GArray *msgnos);
+void libbalsa_mailbox_unregister_msgnos(LibBalsaMailbox *mailbox,
+ GArray *msgnos);
/* Accessors for LibBalsaMailboxIndexEntry */
-LibBalsaMessageStatus libbalsa_mailbox_msgno_get_status(LibBalsaMailbox *
- mailbox,
- guint msgno);
-const gchar *libbalsa_mailbox_msgno_get_subject(LibBalsaMailbox * mailbox,
- guint msgno);
-void libbalsa_mailbox_msgno_update_attach(LibBalsaMailbox * mailbox,
- guint msgno,
- LibBalsaMessage * message);
-void libbalsa_mailbox_cache_message(LibBalsaMailbox * mailbox, guint msgno,
- LibBalsaMessage * message);
+LibBalsaMessageStatus libbalsa_mailbox_msgno_get_status(LibBalsaMailbox *mailbox,
+ guint msgno);
+const gchar *libbalsa_mailbox_msgno_get_subject(LibBalsaMailbox *mailbox,
+ guint msgno);
+void libbalsa_mailbox_msgno_update_attach(LibBalsaMailbox *mailbox,
+ guint msgno,
+ LibBalsaMessage *message);
+void libbalsa_mailbox_cache_message(LibBalsaMailbox *mailbox,
+ guint msgno,
+ LibBalsaMessage *message);
/* Set the foreground and background colors of an array of messages */
-void libbalsa_mailbox_set_foreground(LibBalsaMailbox * mailbox,
- GArray * msgnos, const gchar * color);
-void libbalsa_mailbox_set_background(LibBalsaMailbox * mailbox,
- GArray * msgnos, const gchar * color);
+void libbalsa_mailbox_set_foreground(LibBalsaMailbox *mailbox,
+ GArray *msgnos,
+ const gchar *color);
+void libbalsa_mailbox_set_background(LibBalsaMailbox *mailbox,
+ GArray *msgnos,
+ const gchar *color);
/* Lock and unlock the mail store--currently, a no-op except for mbox.
*/
-void libbalsa_mailbox_lock_store (LibBalsaMailbox * mailbox);
-void libbalsa_mailbox_unlock_store(LibBalsaMailbox * mailbox);
+void libbalsa_mailbox_lock_store(LibBalsaMailbox *mailbox);
+void libbalsa_mailbox_unlock_store(LibBalsaMailbox *mailbox);
/* Check whether a mailbox can be reached */
-void libbalsa_mailbox_test_can_reach(LibBalsaMailbox * mailbox,
- LibBalsaCanReachCallback * cb,
- gpointer cb_data);
+void libbalsa_mailbox_test_can_reach(LibBalsaMailbox *mailbox,
+ LibBalsaCanReachCallback *cb,
+ gpointer cb_data);
/* columns ids */
typedef enum {
@@ -604,47 +638,56 @@ 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);
+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);
+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);
+void libbalsa_mailbox_add_to_unread_messages(LibBalsaMailbox *mailbox,
+ glong count);
-#endif /* __LIBBALSA_MAILBOX_H__ */
+#endif /* __LIBBALSA_MAILBOX_H__ */
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
