/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) version 3.
*
* 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 GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with the program; if not, see <http://www.gnu.org/licenses/>
*
*
* Authors:
* Miguel de Icaza (miguel@ximian.com)
* Bertrand Guiheneuf (bg@aful.org)
* And just about everyone else in evolution ...
*
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "message-list.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <glib/gi18n.h>
#include <glib/gstdio.h>
#include "libemail-engine/e-mail-utils.h"
#include "libemail-engine/mail-config.h"
#include "libemail-engine/mail-mt.h"
#include "libemail-engine/mail-ops.h"
#include "libemail-engine/mail-tools.h"
#include "e-mail-label-list-store.h"
#include "e-mail-ui-session.h"
#include "em-utils.h"
/*#define TIMEIT */
#ifdef TIMEIT
#include <sys/time.h>
#include <unistd.h>
#endif
#ifdef G_OS_WIN32
#ifdef gmtime_r
#undef gmtime_r
#endif
#ifdef localtime_r
#undef localtime_r
#endif
/* The gmtime() and localtime() in Microsoft's C library are MT-safe */
#define gmtime_r(tp,tmp) (gmtime(tp)?(*(tmp)=*gmtime(tp),(tmp)):0)
#define localtime_r(tp,tmp) (localtime(tp)?(*(tmp)=*localtime(tp),(tmp)):0)
#endif
#define d(x)
#define t(x)
#define MESSAGE_LIST_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE \
((obj), MESSAGE_LIST_TYPE, MessageListPrivate))
/* Common search expression segments. */
#define EXCLUDE_DELETED_MESSAGES_EXPR "(not (system-flag \"deleted\"))"
#define EXCLUDE_JUNK_MESSAGES_EXPR "(not (system-flag \"junk\"))"
typedef struct _ExtendedGNode ExtendedGNode;
typedef struct _RegenData RegenData;
struct _MLSelection {
GPtrArray *uids;
CamelFolder *folder;
};
struct _MessageListPrivate {
GtkWidget *invisible; /* 4 selection */
EMailSession *session;
CamelFolder *folder;
gulong folder_changed_handler_id;
/* For message list regeneration. */
GMutex regen_lock;
RegenData *regen_data;
guint regen_idle_id;
GMutex thread_tree_lock;
CamelFolderThread *thread_tree;
struct _MLSelection clipboard;
gboolean destroyed;
gboolean expanded_default;
gboolean group_by_threads;
gboolean show_deleted;
gboolean thread_latest;
gboolean thread_subject;
gboolean any_row_changed; /* save state before regen list when this is set to true */
GtkTargetList *copy_target_list;
GtkTargetList *paste_target_list;
/* XXX Not sure if we really need a separate frozen counter
* for the tree model but the old ETreeMemory class had
* its own frozen counter so we preserve it here. */
GNode *tree_model_root;
gint tree_model_frozen;
/* This aids in automatic message selection. */
time_t newest_read_date;
const gchar *newest_read_uid;
time_t oldest_unread_date;
const gchar *oldest_unread_uid;
};
/* XXX Plain GNode suffers from O(N) tail insertions, and that won't
* do for large mail folders. This structure extends GNode with
* a pointer to its last child, so we get O(1) tail insertions. */
struct _ExtendedGNode {
GNode gnode;
GNode *last_child;
};
struct _RegenData {
volatile gint ref_count;
EActivity *activity;
MessageList *message_list;
gchar *search;
gboolean group_by_threads;
gboolean thread_subject;
CamelFolderThread *thread_tree;
/* This indicates we're regenerating the message list because
* we received a "folder-changed" signal from our CamelFolder. */
gboolean folder_changed;
CamelFolder *folder;
GPtrArray *summary;
gint last_row; /* last selected (cursor) row */
xmlDoc *expand_state; /* expanded state to be restored */
/* These may be set during a regen operation. Use the
* select_lock to ensure consistency and thread-safety.
* These are applied after the operation is finished. */
GMutex select_lock;
gchar *select_uid;
gboolean select_all;
gboolean select_use_fallback;
};
enum {
PROP_0,
PROP_COPY_TARGET_LIST,
PROP_FOLDER,
PROP_GROUP_BY_THREADS,
PROP_PASTE_TARGET_LIST,
PROP_SESSION,
PROP_SHOW_DELETED,
PROP_THREAD_LATEST,
PROP_THREAD_SUBJECT
};
/* Forward Declarations */
static void message_list_selectable_init
(ESelectableInterface *interface);
static void message_list_tree_model_init
(ETreeModelInterface *interface);
static gboolean message_list_get_hide_deleted
(MessageList *message_list,
CamelFolder *folder);
G_DEFINE_TYPE_WITH_CODE (
MessageList,
message_list,
E_TYPE_TREE,
G_IMPLEMENT_INTERFACE (
E_TYPE_EXTENSIBLE, NULL)
G_IMPLEMENT_INTERFACE (
E_TYPE_SELECTABLE,
message_list_selectable_init)
G_IMPLEMENT_INTERFACE (
E_TYPE_TREE_MODEL,
message_list_tree_model_init))
static struct {
const gchar *target;
GdkAtom atom;
guint32 actions;
} ml_drag_info[] = {
{ "x-uid-list", NULL, GDK_ACTION_MOVE | GDK_ACTION_COPY },
{ "message/rfc822", NULL, GDK_ACTION_COPY },
{ "text/uri-list", NULL, GDK_ACTION_COPY },
};
enum {
DND_X_UID_LIST, /* x-uid-list */
DND_MESSAGE_RFC822, /* message/rfc822 */
DND_TEXT_URI_LIST /* text/uri-list */
};
/* What we send */
static GtkTargetEntry ml_drag_types[] = {
{ (gchar *) "x-uid-list", 0, DND_X_UID_LIST },
{ (gchar *) "text/uri-list", 0, DND_TEXT_URI_LIST },
};
/* What we accept */
static GtkTargetEntry ml_drop_types[] = {
{ (gchar *) "x-uid-list", 0, DND_X_UID_LIST },
{ (gchar *) "message/rfc822", 0, DND_MESSAGE_RFC822 },
{ (gchar *) "text/uri-list", 0, DND_TEXT_URI_LIST },
};
/*
* Default sizes for the ETable display
*
*/
#define N_CHARS(x) (CHAR_WIDTH * (x))
#define COL_ICON_WIDTH (16)
#define COL_ATTACH_WIDTH (16)
#define COL_CHECK_BOX_WIDTH (16)
#define COL_FROM_EXPANSION (24.0)
#define COL_FROM_WIDTH_MIN (32)
#define COL_SUBJECT_EXPANSION (30.0)
#define COL_SUBJECT_WIDTH_MIN (32)
#define COL_SENT_EXPANSION (24.0)
#define COL_SENT_WIDTH_MIN (32)
#define COL_RECEIVED_EXPANSION (20.0)
#define COL_RECEIVED_WIDTH_MIN (32)
#define COL_TO_EXPANSION (24.0)
#define COL_TO_WIDTH_MIN (32)
#define COL_SIZE_EXPANSION (6.0)
#define COL_SIZE_WIDTH_MIN (32)
#define COL_SENDER_EXPANSION (24.0)
#define COL_SENDER_WIDTH_MIN (32)
enum {
NORMALISED_SUBJECT,
NORMALISED_FROM,
NORMALISED_TO,
NORMALISED_LAST
};
static void on_cursor_activated_cmd (ETree *tree,
gint row,
GNode *node,
gpointer user_data);
static void on_selection_changed_cmd (ETree *tree,
MessageList *message_list);
static gint on_click (ETree *tree,
gint row,
GNode *node,
gint col,
GdkEvent *event,
MessageList *message_list);
static void mail_regen_list (MessageList *message_list,
const gchar *search,
gboolean folder_changed);
static void mail_regen_cancel (MessageList *message_list);
static void clear_info (gchar *key,
GNode *node,
MessageList *message_list);
enum {
MESSAGE_SELECTED,
MESSAGE_LIST_BUILT,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = {0, };
static const gchar *status_map[] = {
N_("Unseen"),
N_("Seen"),
N_("Answered"),
N_("Forwarded"),
N_("Multiple Unseen Messages"),
N_("Multiple Messages"),
};
static const gchar *status_icons[] = {
"mail-unread",
"mail-read",
"mail-replied",
"mail-forward",
"stock_mail-unread-multiple",
"stock_mail-open-multiple"
};
static const gchar *score_map[] = {
N_("Lowest"),
N_("Lower"),
N_("Low"),
N_("Normal"),
N_("High"),
N_("Higher"),
N_("Highest"),
};
static const gchar *score_icons[] = {
"stock_score-lowest",
"stock_score-lower",
"stock_score-low",
"stock_score-normal",
"stock_score-high",
"stock_score-higher",
"stock_score-highest"
};
static const gchar *attachment_icons[] = {
NULL, /* empty icon */
"mail-attachment",
"stock_new-meeting"
};
static const gchar *flagged_icons[] = {
NULL, /* empty icon */
"emblem-important"
};
static const gchar *followup_icons[] = {
NULL, /* empty icon */
"stock_mail-flag-for-followup",
"stock_mail-flag-for-followup-done"
};
static GNode *
extended_g_node_new (gpointer data)
{
GNode *node;
node = (GNode *) g_slice_new0 (ExtendedGNode);
node->data = data;
return node;
}
static void
extended_g_node_unlink (GNode *node)
{
g_return_if_fail (node != NULL);
/* Update the last_child pointer before we unlink. */
if (node->parent != NULL) {
ExtendedGNode *ext_parent;
ext_parent = (ExtendedGNode *) node->parent;
if (ext_parent->last_child == node) {
g_warn_if_fail (node->next == NULL);
ext_parent->last_child = node->prev;
}
}
g_node_unlink (node);
}
static void
extended_g_nodes_free (GNode *node)
{
while (node != NULL) {
GNode *next = node->next;
if (node->children != NULL)
extended_g_nodes_free (node->children);
g_slice_free (ExtendedGNode, (ExtendedGNode *) node);
node = next;
}
}
static void
extended_g_node_destroy (GNode *root)
{
g_return_if_fail (root != NULL);
if (!G_NODE_IS_ROOT (root))
extended_g_node_unlink (root);
extended_g_nodes_free (root);
}
static GNode *
extended_g_node_insert_before (GNode *parent,
GNode *sibling,
GNode *node)
{
ExtendedGNode *ext_parent;
g_return_val_if_fail (parent != NULL, node);
g_return_val_if_fail (node != NULL, node);
g_return_val_if_fail (G_NODE_IS_ROOT (node), node);
if (sibling != NULL)
g_return_val_if_fail (sibling->parent == parent, node);
ext_parent = (ExtendedGNode *) parent;
/* This is where tracking the last child pays off. */
if (sibling == NULL && ext_parent->last_child != NULL) {
node->parent = parent;
node->prev = ext_parent->last_child;
ext_parent->last_child->next = node;
} else {
g_node_insert_before (parent, sibling, node);
}
if (sibling == NULL)
ext_parent->last_child = node;
return node;
}
static GNode *
extended_g_node_insert (GNode *parent,
gint position,
GNode *node)
{
GNode *sibling;
g_return_val_if_fail (parent != NULL, node);
g_return_val_if_fail (node != NULL, node);
g_return_val_if_fail (G_NODE_IS_ROOT (node), node);
if (position > 0)
sibling = g_node_nth_child (parent, position);
else if (position == 0)
sibling = parent->children;
else /* if (position < 0) */
sibling = NULL;
return extended_g_node_insert_before (parent, sibling, node);
}
static RegenData *
regen_data_new (MessageList *message_list,
GCancellable *cancellable)
{
RegenData *regen_data;
EActivity *activity;
EMailSession *session;
activity = e_activity_new ();
e_activity_set_cancellable (activity, cancellable);
e_activity_set_text (activity, _("Generating message list"));
regen_data = g_slice_new0 (RegenData);
regen_data->ref_count = 1;
regen_data->activity = g_object_ref (activity);
regen_data->message_list = g_object_ref (message_list);
regen_data->last_row = -1;
g_mutex_init (®en_data->select_lock);
session = message_list_get_session (message_list);
e_mail_ui_session_add_activity (E_MAIL_UI_SESSION (session), activity);
g_object_unref (activity);
return regen_data;
}
static RegenData *
regen_data_ref (RegenData *regen_data)
{
g_return_val_if_fail (regen_data != NULL, NULL);
g_return_val_if_fail (regen_data->ref_count > 0, NULL);
g_atomic_int_inc (®en_data->ref_count);
return regen_data;
}
static void
regen_data_unref (RegenData *regen_data)
{
g_return_if_fail (regen_data != NULL);
g_return_if_fail (regen_data->ref_count > 0);
if (g_atomic_int_dec_and_test (®en_data->ref_count)) {
g_clear_object (®en_data->activity);
g_clear_object (®en_data->message_list);
g_free (regen_data->search);
if (regen_data->thread_tree != NULL)
camel_folder_thread_messages_unref (
regen_data->thread_tree);
if (regen_data->summary != NULL) {
guint ii, length;
length = regen_data->summary->len;
for (ii = 0; ii < length; ii++)
camel_folder_free_message_info (
regen_data->folder,
regen_data->summary->pdata[ii]);
g_ptr_array_free (regen_data->summary, TRUE);
}
g_clear_object (®en_data->folder);
if (regen_data->expand_state != NULL)
xmlFreeDoc (regen_data->expand_state);
g_mutex_clear (®en_data->select_lock);
g_free (regen_data->select_uid);
g_slice_free (RegenData, regen_data);
}
}
static CamelFolderThread *
message_list_ref_thread_tree (MessageList *message_list)
{
CamelFolderThread *thread_tree = NULL;
g_return_val_if_fail (IS_MESSAGE_LIST (message_list), NULL);
g_mutex_lock (&message_list->priv->thread_tree_lock);
if (message_list->priv->thread_tree != NULL) {
thread_tree = message_list->priv->thread_tree;
camel_folder_thread_messages_ref (thread_tree);
}
g_mutex_unlock (&message_list->priv->thread_tree_lock);
return thread_tree;
}
static void
message_list_set_thread_tree (MessageList *message_list,
CamelFolderThread *thread_tree)
{
g_return_if_fail (IS_MESSAGE_LIST (message_list));
g_mutex_lock (&message_list->priv->thread_tree_lock);
if (thread_tree != NULL)
camel_folder_thread_messages_ref (thread_tree);
if (message_list->priv->thread_tree != NULL)
camel_folder_thread_messages_unref (
message_list->priv->thread_tree);
message_list->priv->thread_tree = thread_tree;
g_mutex_unlock (&message_list->priv->thread_tree_lock);
}
static RegenData *
message_list_ref_regen_data (MessageList *message_list)
{
RegenData *regen_data = NULL;
g_mutex_lock (&message_list->priv->regen_lock);
if (message_list->priv->regen_data != NULL)
regen_data = regen_data_ref (message_list->priv->regen_data);
g_mutex_unlock (&message_list->priv->regen_lock);
return regen_data;
}
static void
message_list_tree_model_freeze (MessageList *message_list)
{
if (message_list->priv->tree_model_frozen == 0)
e_tree_model_pre_change (E_TREE_MODEL (message_list));
message_list->priv->tree_model_frozen++;
}
static void
message_list_tree_model_thaw (MessageList *message_list)
{
if (message_list->priv->tree_model_frozen > 0)
message_list->priv->tree_model_frozen--;
if (message_list->priv->tree_model_frozen == 0)
e_tree_model_node_changed (
E_TREE_MODEL (message_list),
message_list->priv->tree_model_root);
}
static GNode *
message_list_tree_model_insert (MessageList *message_list,
GNode *parent,
gint position,
gpointer data)
{
ETreeModel *tree_model;
GNode *node;
gboolean tree_model_frozen;
if (parent == NULL)
g_return_val_if_fail (
message_list->priv->tree_model_root == NULL, NULL);
tree_model = E_TREE_MODEL (message_list);
tree_model_frozen = (message_list->priv->tree_model_frozen > 0);
if (!tree_model_frozen)
e_tree_model_pre_change (tree_model);
node = extended_g_node_new (data);
if (parent != NULL) {
extended_g_node_insert (parent, position, node);
if (!tree_model_frozen)
e_tree_model_node_inserted (tree_model, parent, node);
} else {
message_list->priv->tree_model_root = node;
if (!tree_model_frozen)
e_tree_model_node_changed (tree_model, node);
}
return node;
}
static void
message_list_tree_model_remove (MessageList *message_list,
GNode *node)
{
ETreeModel *tree_model;
GNode *parent = node->parent;
gboolean tree_model_frozen;
gint old_position = 0;
g_return_if_fail (node != NULL);
tree_model = E_TREE_MODEL (message_list);
tree_model_frozen = (message_list->priv->tree_model_frozen > 0);
if (!tree_model_frozen) {
e_tree_model_pre_change (tree_model);
old_position = g_node_child_position (parent, node);
}
extended_g_node_unlink (node);
if (!tree_model_frozen)
e_tree_model_node_removed (
tree_model, parent, node, old_position);
extended_g_node_destroy (node);
if (node == message_list->priv->tree_model_root)
message_list->priv->tree_model_root = NULL;
if (!tree_model_frozen)
e_tree_model_node_deleted (tree_model, node);
}
static gint
address_compare (gconstpointer address1,
gconstpointer address2,
gpointer cmp_cache)
{
gint retval;
g_return_val_if_fail (address1 != NULL, 1);
g_return_val_if_fail (address2 != NULL, -1);
retval = g_ascii_strcasecmp ((gchar *) address1, (gchar *) address2);
return retval;
}
static gchar *
filter_size (gint size)
{
gfloat fsize;
if (size < 1024) {
return g_strdup_printf ("%d", size);
} else {
fsize = ((gfloat) size) / 1024.0;
if (fsize < 1024.0) {
return g_strdup_printf ("%.2f K", fsize);
} else {
fsize /= 1024.0;
return g_strdup_printf ("%.2f M", fsize);
}
}
}
/* Gets the uid of the message displayed at a given view row */
static const gchar *
get_message_uid (MessageList *message_list,
GNode *node)
{
g_return_val_if_fail (node != NULL, NULL);
g_return_val_if_fail (node->data != NULL, NULL);
return camel_message_info_uid (node->data);
}
/* Gets the CamelMessageInfo for the message displayed at the given
* view row.
*/
static CamelMessageInfo *
get_message_info (MessageList *message_list,
GNode *node)
{
g_return_val_if_fail (node != NULL, NULL);
g_return_val_if_fail (node->data != NULL, NULL);
return node->data;
}
static const gchar *
get_normalised_string (MessageList *message_list,
CamelMessageInfo *info,
gint col)
{
const gchar *string, *str;
gchar *normalised;
EPoolv *poolv;
gint index;
switch (col) {
case COL_SUBJECT_NORM:
string = camel_message_info_subject (info);
index = NORMALISED_SUBJECT;
break;
case COL_FROM_NORM:
string = camel_message_info_from (info);
index = NORMALISED_FROM;
break;
case COL_TO_NORM:
string = camel_message_info_to (info);
index = NORMALISED_TO;
break;
default:
string = NULL;
index = NORMALISED_LAST;
g_warning ("Should not be reached\n");
}
/* slight optimisation */
if (string == NULL || string[0] == '\0')
return "";
poolv = g_hash_table_lookup (message_list->normalised_hash, camel_message_info_uid (info));
if (poolv == NULL) {
poolv = e_poolv_new (NORMALISED_LAST);
g_hash_table_insert (message_list->normalised_hash, (gchar *) camel_message_info_uid (info), poolv);
} else {
str = e_poolv_get (poolv, index);
if (*str)
return str;
}
if (col == COL_SUBJECT_NORM) {
gint skip_len;
const gchar *subject;
gboolean found_re = TRUE;
subject = string;
while (found_re) {
found_re = em_utils_is_re_in_subject (
subject, &skip_len) && skip_len > 0;
if (found_re)
subject += skip_len;
/* jump over any spaces */
while (*subject && isspace ((gint) *subject))
subject++;
}
/* jump over any spaces */
while (*subject && isspace ((gint) *subject))
subject++;
string = subject;
normalised = g_utf8_collate_key (string, -1);
} else {
/* because addresses require strings, not collate keys */
normalised = g_strdup (string);
}
e_poolv_set (poolv, index, normalised, TRUE);
return e_poolv_get (poolv, index);
}
static void
clear_selection (MessageList *message_list,
struct _MLSelection *selection)
{
if (selection->uids != NULL) {
g_ptr_array_unref (selection->uids);
selection->uids = NULL;
}
g_clear_object (&selection->folder);
}
static GNode *
ml_search_forward (MessageList *message_list,
gint start,
gint end,
guint32 flags,
guint32 mask)
{
GNode *node;
gint row;
CamelMessageInfo *info;
ETreeTableAdapter *etta;
etta = e_tree_get_table_adapter (E_TREE (message_list));
for (row = start; row <= end; row++) {
node = e_tree_table_adapter_node_at_row (etta, row);
if (node != NULL
&& (info = get_message_info (message_list, node))
&& (camel_message_info_flags (info) & mask) == flags)
return node;
}
return NULL;
}
static GNode *
ml_search_backward (MessageList *message_list,
gint start,
gint end,
guint32 flags,
guint32 mask)
{
GNode *node;
gint row;
CamelMessageInfo *info;
ETreeTableAdapter *etta;
etta = e_tree_get_table_adapter (E_TREE (message_list));
for (row = start; row >= end; row--) {
node = e_tree_table_adapter_node_at_row (etta, row);
if (node != NULL
&& (info = get_message_info (message_list, node))
&& (camel_message_info_flags (info) & mask) == flags)
return node;
}
return NULL;
}
static GNode *
ml_search_path (MessageList *message_list,
MessageListSelectDirection direction,
guint32 flags,
guint32 mask)
{
ETreeTableAdapter *adapter;
GNode *node;
gint row_count;
gint row;
if (message_list->cursor_uid == NULL)
return NULL;
node = g_hash_table_lookup (
message_list->uid_nodemap,
message_list->cursor_uid);
if (node == NULL)
return NULL;
adapter = e_tree_get_table_adapter (E_TREE (message_list));
row_count = e_table_model_row_count (E_TABLE_MODEL (adapter));
row = e_tree_table_adapter_row_of_node (adapter, node);
if (row == -1)
return NULL;
if ((direction & MESSAGE_LIST_SELECT_DIRECTION) == MESSAGE_LIST_SELECT_NEXT)
node = ml_search_forward (
message_list, row + 1, row_count - 1, flags, mask);
else
node = ml_search_backward (
message_list, row - 1, 0, flags, mask);
if (node == NULL && (direction & MESSAGE_LIST_SELECT_WRAP)) {
if ((direction & MESSAGE_LIST_SELECT_DIRECTION) == MESSAGE_LIST_SELECT_NEXT)
node = ml_search_forward (
message_list, 0, row, flags, mask);
else
node = ml_search_backward (
message_list, row_count - 1, row, flags, mask);
}
return node;
}
static void
select_node (MessageList *message_list,
GNode *node)
{
ETree *tree;
ETreeTableAdapter *etta;
ETreeSelectionModel *etsm;
tree = E_TREE (message_list);
etta = e_tree_get_table_adapter (tree);
etsm = (ETreeSelectionModel *) e_tree_get_selection_model (tree);
g_free (message_list->cursor_uid);
message_list->cursor_uid = NULL;
e_tree_table_adapter_show_node (etta, node);
e_tree_set_cursor (tree, node);
e_tree_selection_model_select_single_path (etsm, node);
}
/**
* message_list_select:
* @message_list: a MessageList
* @direction: the direction to search in
* @flags: a set of flag values
* @mask: a mask for comparing against @flags
*
* This moves the message list selection to a suitable row. @flags and
* @mask combine to specify what constitutes a suitable row. @direction is
* %MESSAGE_LIST_SELECT_NEXT if it should find the next matching
* message, or %MESSAGE_LIST_SELECT_PREVIOUS if it should find the
* previous. %MESSAGE_LIST_SELECT_WRAP is an option bit which specifies the
* search should wrap.
*
* If no suitable row is found, the selection will be
* unchanged.
*
* Returns %TRUE if a new message has been selected or %FALSE otherwise.
**/
gboolean
message_list_select (MessageList *message_list,
MessageListSelectDirection direction,
guint32 flags,
guint32 mask)
{
GNode *node;
node = ml_search_path (message_list, direction, flags, mask);
if (node != NULL) {
select_node (message_list, node);
/* This function is usually called in response to a key
* press, so grab focus if the message list is visible. */
if (gtk_widget_get_visible (GTK_WIDGET (message_list)))
gtk_widget_grab_focus (GTK_WIDGET (message_list));
return TRUE;
} else
return FALSE;
}
/**
* message_list_can_select:
* @message_list:
* @direction:
* @flags:
* @mask:
*
* Returns true if the selection specified is possible with the current view.
*
* Return value:
**/
gboolean
message_list_can_select (MessageList *message_list,
MessageListSelectDirection direction,
guint32 flags,
guint32 mask)
{
return ml_search_path (message_list, direction, flags, mask) != NULL;
}
/**
* message_list_select_uid:
* @message_list:
* @uid:
*
* Selects the message with the given UID.
**/
void
message_list_select_uid (MessageList *message_list,
const gchar *uid,
gboolean with_fallback)
{
MessageListPrivate *priv;
GHashTable *uid_nodemap;
GNode *node = NULL;
RegenData *regen_data = NULL;
g_return_if_fail (IS_MESSAGE_LIST (message_list));
priv = message_list->priv;
uid_nodemap = message_list->uid_nodemap;
if (message_list->priv->folder == NULL)
return;
/* Try to find the requested message UID. */
if (uid != NULL)
node = g_hash_table_lookup (uid_nodemap, uid);
regen_data = message_list_ref_regen_data (message_list);
/* If we're busy or waiting to regenerate the message list, cache
* the UID so we can try again when we're done. Otherwise if the
* requested message UID was not found and 'with_fallback' is set,
* try a couple fallbacks:
*
* 1) Oldest unread message in the list, by date received.
* 2) Newest read message in the list, by date received.
*/
if (regen_data != NULL) {
g_mutex_lock (®en_data->select_lock);
g_free (regen_data->select_uid);
regen_data->select_uid = g_strdup (uid);
regen_data->select_use_fallback = with_fallback;
g_mutex_unlock (®en_data->select_lock);
regen_data_unref (regen_data);
} else if (with_fallback) {
if (node == NULL && priv->oldest_unread_uid != NULL)
node = g_hash_table_lookup (
uid_nodemap, priv->oldest_unread_uid);
if (node == NULL && priv->newest_read_uid != NULL)
node = g_hash_table_lookup (
uid_nodemap, priv->newest_read_uid);
}
if (node) {
ETree *tree;
GNode *old_cur;
tree = E_TREE (message_list);
old_cur = e_tree_get_cursor (tree);
/* This will emit a changed signal that we'll pick up */
e_tree_set_cursor (tree, node);
if (old_cur == node)
g_signal_emit (
message_list,
signals[MESSAGE_SELECTED],
0, message_list->cursor_uid);
} else {
g_free (message_list->cursor_uid);
message_list->cursor_uid = NULL;
g_signal_emit (
message_list,
signals[MESSAGE_SELECTED],
0, NULL);
}
}
void
message_list_select_next_thread (MessageList *message_list)
{
ETreeTableAdapter *adapter;
GNode *node;
gint row_count;
gint row;
gint ii;
g_return_if_fail (IS_MESSAGE_LIST (message_list));
if (message_list->cursor_uid == NULL)
return;
node = g_hash_table_lookup (
message_list->uid_nodemap,
message_list->cursor_uid);
if (node == NULL)
return;
adapter = e_tree_get_table_adapter (E_TREE (message_list));
row_count = e_table_model_row_count ((ETableModel *) adapter);
row = e_tree_table_adapter_row_of_node (adapter, node);
if (row == -1)
return;
/* find the next node which has a root parent (i.e. toplevel node) */
for (ii = row + 1; ii < row_count - 1; ii++) {
node = e_tree_table_adapter_node_at_row (adapter, ii);
if (node != NULL && G_NODE_IS_ROOT (node->parent)) {
select_node (message_list, node);
return;
}
}
}
void
message_list_select_prev_thread (MessageList *message_list)
{
ETreeTableAdapter *adapter;
GNode *node;
gboolean skip_first;
gint row;
gint ii;
g_return_if_fail (IS_MESSAGE_LIST (message_list));
if (message_list->cursor_uid == NULL)
return;
node = g_hash_table_lookup (
message_list->uid_nodemap,
message_list->cursor_uid);
if (node == NULL)
return;
adapter = e_tree_get_table_adapter (E_TREE (message_list));
row = e_tree_table_adapter_row_of_node (adapter, node);
if (row == -1)
return;
/* skip first found if in the middle of the thread */
skip_first = !G_NODE_IS_ROOT (node->parent);
/* find the previous node which has a root parent (i.e. toplevel node) */
for (ii = row - 1; ii >= 0; ii--) {
node = e_tree_table_adapter_node_at_row (adapter, ii);
if (node != NULL && G_NODE_IS_ROOT (node->parent)) {
if (skip_first) {
skip_first = FALSE;
continue;
}
select_node (message_list, node);
return;
}
}
}
/**
* message_list_select_all:
* @message_list: Message List widget
*
* Selects all messages in the message list.
**/
void
message_list_select_all (MessageList *message_list)
{
RegenData *regen_data = NULL;
g_return_if_fail (IS_MESSAGE_LIST (message_list));
regen_data = message_list_ref_regen_data (message_list);
if (regen_data != NULL && regen_data->group_by_threads) {
regen_data->select_all = TRUE;
} else {
ETree *tree;
ESelectionModel *selection_model;
tree = E_TREE (message_list);
selection_model = e_tree_get_selection_model (tree);
e_selection_model_select_all (selection_model);
}
if (regen_data != NULL)
regen_data_unref (regen_data);
}
typedef struct thread_select_info {
MessageList *message_list;
GPtrArray *paths;
} thread_select_info_t;
static gboolean
select_thread_node (ETreeModel *model,
GNode *node,
gpointer user_data)
{
thread_select_info_t *tsi = (thread_select_info_t *) user_data;
g_ptr_array_add (tsi->paths, node);
return FALSE; /*not done yet */
}
static void
select_thread (MessageList *message_list,
ETreeForeachFunc selector)
{
ETree *tree;
ETreeSelectionModel *etsm;
thread_select_info_t tsi;
tsi.message_list = message_list;
tsi.paths = g_ptr_array_new ();
tree = E_TREE (message_list);
etsm = (ETreeSelectionModel *) e_tree_get_selection_model (tree);
e_tree_selection_model_foreach (etsm, selector, &tsi);
e_tree_selection_model_select_paths (etsm, tsi.paths);
g_ptr_array_free (tsi.paths, TRUE);
}
static void
thread_select_foreach (ETreePath path,
gpointer user_data)
{
thread_select_info_t *tsi = (thread_select_info_t *) user_data;
ETreeModel *tree_model;
GNode *last, *node = path;
tree_model = E_TREE_MODEL (tsi->message_list);
do {
last = node;
node = node->parent;
} while (!G_NODE_IS_ROOT (node));
g_ptr_array_add (tsi->paths, last);
e_tree_model_node_traverse (
tree_model, last,
(ETreePathFunc) select_thread_node, tsi);
}
/**
* message_list_select_thread:
* @message_list: Message List widget
*
* Selects all messages in the current thread (based on cursor).
**/
void
message_list_select_thread (MessageList *message_list)
{
select_thread (message_list, thread_select_foreach);
}
static void
subthread_select_foreach (ETreePath path,
gpointer user_data)
{
thread_select_info_t *tsi = (thread_select_info_t *) user_data;
ETreeModel *tree_model;
tree_model = E_TREE_MODEL (tsi->message_list);
e_tree_model_node_traverse (
tree_model, path,
(ETreePathFunc) select_thread_node, tsi);
}
/**
* message_list_select_subthread:
* @message_list: Message List widget
*
* Selects all messages in the current subthread (based on cursor).
**/
void
message_list_select_subthread (MessageList *message_list)
{
select_thread (message_list, subthread_select_foreach);
}
void
message_list_copy (MessageList *message_list,
gboolean cut)
{
MessageListPrivate *p = message_list->priv;
GPtrArray *uids;
clear_selection (message_list, &p->clipboard);
uids = message_list_get_selected (message_list);
if (uids->len > 0) {
if (cut) {
CamelFolder *folder;
gint i;
folder = message_list_ref_folder (message_list);
camel_folder_freeze (folder);
for (i = 0; i < uids->len; i++)
camel_folder_set_message_flags (
folder, uids->pdata[i],
CAMEL_MESSAGE_SEEN |
CAMEL_MESSAGE_DELETED,
CAMEL_MESSAGE_SEEN |
CAMEL_MESSAGE_DELETED);
camel_folder_thaw (folder);
g_object_unref (folder);
}
p->clipboard.uids = g_ptr_array_ref (uids);
p->clipboard.folder = message_list_ref_folder (message_list);
gtk_selection_owner_set (
p->invisible,
GDK_SELECTION_CLIPBOARD,
gtk_get_current_event_time ());
} else {
gtk_selection_owner_set (
NULL, GDK_SELECTION_CLIPBOARD,
gtk_get_current_event_time ());
}
g_ptr_array_unref (uids);
}
void
message_list_paste (MessageList *message_list)
{
gtk_selection_convert (
message_list->priv->invisible,
GDK_SELECTION_CLIPBOARD,
gdk_atom_intern ("x-uid-list", FALSE),
GDK_CURRENT_TIME);
}
static void
for_node_and_subtree_if_collapsed (MessageList *message_list,
GNode *node,
CamelMessageInfo *mi,
ETreePathFunc func,
gpointer data)
{
ETreeModel *tree_model;
ETreeTableAdapter *adapter;
GNode *child = NULL;
tree_model = E_TREE_MODEL (message_list);
adapter = e_tree_get_table_adapter (E_TREE (message_list));
func (NULL, (ETreePath) mi, data);
if (node != NULL)
child = g_node_first_child (node);
if (child && !e_tree_table_adapter_node_is_expanded (adapter, node))
e_tree_model_node_traverse (tree_model, node, func, data);
}
static gboolean
unread_foreach (ETreeModel *etm,
ETreePath path,
gpointer data)
{
gboolean *saw_unread = data;
CamelMessageInfo *info;
if (!etm)
info = (CamelMessageInfo *) path;
else
info = ((GNode *) path)->data;
g_return_val_if_fail (info != NULL, FALSE);
if (!(camel_message_info_flags (info) & CAMEL_MESSAGE_SEEN))
*saw_unread = TRUE;
return FALSE;
}
struct LatestData {
gboolean sent;
time_t latest;
};
static gboolean
latest_foreach (ETreeModel *etm,
ETreePath path,
gpointer data)
{
struct LatestData *ld = data;
CamelMessageInfo *info;
time_t date;
if (!etm)
info = (CamelMessageInfo *) path;
else
info = ((GNode *) path)->data;
g_return_val_if_fail (info != NULL, FALSE);
date = ld->sent ? camel_message_info_date_sent (info)
: camel_message_info_date_received (info);
if (ld->latest == 0 || date > ld->latest)
ld->latest = date;
return FALSE;
}
static gchar *
sanitize_recipients (const gchar *string)
{
GString *gstring;
gboolean quoted = FALSE;
const gchar *p;
GString *recipients = g_string_new ("");
gchar *single_add;
gchar **name;
if (!string || !*string)
return (gchar *) "";
gstring = g_string_new ("");
for (p = string; *p; p = g_utf8_next_char (p)) {
gunichar c = g_utf8_get_char (p);
if (c == '"')
quoted = ~quoted;
else if (c == ',' && !quoted) {
single_add = g_string_free (gstring, FALSE);
name = g_strsplit (single_add,"<",2);
g_string_append (recipients, *name);
g_string_append (recipients, ",");
g_free (single_add);
g_strfreev (name);
gstring = g_string_new ("");
continue;
}
g_string_append_unichar (gstring, c);
}
single_add = g_string_free (gstring, FALSE);
name = g_strsplit (single_add,"<",2);
g_string_append (recipients, *name);
g_free (single_add);
g_strfreev (name);
return g_string_free (recipients, FALSE);
}
struct LabelsData {
EMailLabelListStore *store;
GHashTable *labels_tag2iter;
};
static void
add_label_if_known (struct LabelsData *ld,
const gchar *tag)
{
GtkTreeIter label_defn;
if (e_mail_label_list_store_lookup (ld->store, tag, &label_defn)) {
g_hash_table_insert (
ld->labels_tag2iter,
/* Should be the same as the "tag" arg */
e_mail_label_list_store_get_tag (ld->store, &label_defn),
gtk_tree_iter_copy (&label_defn));
}
}
static gboolean
add_all_labels_foreach (ETreeModel *etm,
ETreePath path,
gpointer data)
{
struct LabelsData *ld = data;
CamelMessageInfo *msg_info;
const gchar *old_label;
gchar *new_label;
const CamelFlag *flag;
if (!etm)
msg_info = (CamelMessageInfo *) path;
else
msg_info = ((GNode *) path)->data;
g_return_val_if_fail (msg_info != NULL, FALSE);
for (flag = camel_message_info_user_flags (msg_info); flag; flag = flag->next)
add_label_if_known (ld, flag->name);
old_label = camel_message_info_user_tag (msg_info, "label");
if (old_label != NULL) {
/* Convert old-style labels ("<name>") to "$Label<name>". */
new_label = g_alloca (strlen (old_label) + 10);
g_stpcpy (g_stpcpy (new_label, "$Label"), old_label);
add_label_if_known (ld, new_label);
}
return FALSE;
}
static const gchar *
get_trimmed_subject (CamelMessageInfo *info)
{
const gchar *subject;
const gchar *mlist;
gint mlist_len = 0;
gboolean found_mlist;
subject = camel_message_info_subject (info);
if (!subject || !*subject)
return subject;
mlist = camel_message_info_mlist (info);
if (mlist && *mlist) {
const gchar *mlist_end;
mlist_end = strchr (mlist, '@');
if (mlist_end)
mlist_len = mlist_end - mlist;
else
mlist_len = strlen (mlist);
}
do {
gint skip_len;
gboolean found_re = TRUE;
found_mlist = FALSE;
while (found_re) {
found_re = FALSE;
found_re = em_utils_is_re_in_subject (
subject, &skip_len) && skip_len > 0;
if (found_re)
subject += skip_len;
/* jump over any spaces */
while (*subject && isspace ((gint) *subject))
subject++;
}
if (mlist_len &&
*subject == '[' &&
!g_ascii_strncasecmp ((gchar *) subject + 1, mlist, mlist_len) &&
subject[1 + mlist_len] == ']') {
subject += 1 + mlist_len + 1; /* jump over "[mailing-list]" */
found_mlist = TRUE;
/* jump over any spaces */
while (*subject && isspace ((gint) *subject))
subject++;
}
} while (found_mlist);
/* jump over any spaces */
while (*subject && isspace ((gint) *subject))
subject++;
return subject;
}
static gpointer
ml_tree_value_at_ex (ETreeModel *etm,
GNode *node,
gint col,
CamelMessageInfo *msg_info,
MessageList *message_list)
{
EMailSession *session;
const gchar *str;
guint32 flags;
session = message_list_get_session (message_list);
g_return_val_if_fail (msg_info != NULL, NULL);
switch (col) {
case COL_MESSAGE_STATUS:
flags = camel_message_info_flags (msg_info);
if (flags & CAMEL_MESSAGE_ANSWERED)
return GINT_TO_POINTER (2);
else if (flags & CAMEL_MESSAGE_FORWARDED)
return GINT_TO_POINTER (3);
else if (flags & CAMEL_MESSAGE_SEEN)
return GINT_TO_POINTER (1);
else
return GINT_TO_POINTER (0);
case COL_FLAGGED:
return GINT_TO_POINTER ((camel_message_info_flags (msg_info) & CAMEL_MESSAGE_FLAGGED) != 0);
case COL_SCORE: {
const gchar *tag;
gint score = 0;
tag = camel_message_info_user_tag (msg_info, "score");
if (tag)
score = atoi (tag);
return GINT_TO_POINTER (score);
}
case COL_FOLLOWUP_FLAG_STATUS: {
const gchar *tag, *cmp;
/* FIXME: this all should be methods off of message-tag-followup class,
* FIXME: the tag names should be namespaced :( */
tag = camel_message_info_user_tag (msg_info, "follow-up");
cmp = camel_message_info_user_tag (msg_info, "completed-on");
if (tag && tag[0]) {
if (cmp && cmp[0])
return GINT_TO_POINTER (2);
else
return GINT_TO_POINTER (1);
} else
return GINT_TO_POINTER (0);
}
case COL_FOLLOWUP_DUE_BY: {
const gchar *tag;
time_t due_by;
tag = camel_message_info_user_tag (msg_info, "due-by");
if (tag && *tag) {
due_by = camel_header_decode_date (tag, NULL);
return GINT_TO_POINTER (due_by);
} else {
return GINT_TO_POINTER (0);
}
}
case COL_FOLLOWUP_FLAG:
str = camel_message_info_user_tag (msg_info, "follow-up");
return (gpointer)(str ? str : "");
case COL_ATTACHMENT:
if (camel_message_info_user_flag (msg_info, "$has_cal"))
return GINT_TO_POINTER (2);
return GINT_TO_POINTER ((camel_message_info_flags (msg_info) & CAMEL_MESSAGE_ATTACHMENTS) != 0);
case COL_FROM:
str = camel_message_info_from (msg_info);
return (gpointer)(str ? str : "");
case COL_FROM_NORM:
return (gpointer) get_normalised_string (message_list, msg_info, col);
case COL_SUBJECT:
str = camel_message_info_subject (msg_info);
return (gpointer)(str ? str : "");
case COL_SUBJECT_TRIMMED:
str = get_trimmed_subject (msg_info);
return (gpointer)(str ? str : "");
case COL_SUBJECT_NORM:
return (gpointer) get_normalised_string (message_list, msg_info, col);
case COL_SENT: {
struct LatestData ld;
ld.sent = TRUE;
ld.latest = 0;
for_node_and_subtree_if_collapsed (message_list, node, msg_info, latest_foreach, &ld);
return GINT_TO_POINTER (ld.latest);
}
case COL_RECEIVED: {
struct LatestData ld;
ld.sent = FALSE;
ld.latest = 0;
for_node_and_subtree_if_collapsed (message_list, node, msg_info, latest_foreach, &ld);
return GINT_TO_POINTER (ld.latest);
}
case COL_TO:
str = camel_message_info_to (msg_info);
return (gpointer)(str ? str : "");
case COL_TO_NORM:
return (gpointer) get_normalised_string (message_list, msg_info, col);
case COL_SIZE:
return GINT_TO_POINTER (camel_message_info_size (msg_info));
case COL_DELETED:
return GINT_TO_POINTER ((camel_message_info_flags (msg_info) & CAMEL_MESSAGE_DELETED) != 0);
case COL_UNREAD: {
gboolean saw_unread = FALSE;
for_node_and_subtree_if_collapsed (message_list, node, msg_info, unread_foreach, &saw_unread);
return GINT_TO_POINTER (saw_unread);
}
case COL_COLOUR: {
const gchar *colour, *due_by, *completed, *followup;
/* Priority: colour tag; label tag; important flag; due-by tag */
/* This is astonisngly poorly written code */
/* To add to the woes, what color to show when the user choose multiple labels ?
Don't say that I need to have the new labels[with subject] column visible always */
colour = NULL;
due_by = camel_message_info_user_tag (msg_info, "due-by");
completed = camel_message_info_user_tag (msg_info, "completed-on");
followup = camel_message_info_user_tag (msg_info, "follow-up");
if (colour == NULL) {
/* Get all applicable labels. */
struct LabelsData ld;
ld.store = e_mail_ui_session_get_label_store (
E_MAIL_UI_SESSION (session));
ld.labels_tag2iter = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) gtk_tree_iter_free);
for_node_and_subtree_if_collapsed (message_list, node, msg_info, add_all_labels_foreach, &ld);
if (g_hash_table_size (ld.labels_tag2iter) == 1) {
GHashTableIter iter;
GtkTreeIter *label_defn;
GdkColor colour_val;
gchar *colour_alloced;
/* Extract the single label from the hashtable. */
g_hash_table_iter_init (&iter, ld.labels_tag2iter);
g_hash_table_iter_next (&iter, NULL, (gpointer *) &label_defn);
e_mail_label_list_store_get_color (ld.store, label_defn, &colour_val);
/* XXX Hack to avoid returning an allocated string. */
colour_alloced = gdk_color_to_string (&colour_val);
colour = g_intern_string (colour_alloced);
g_free (colour_alloced);
} else if (camel_message_info_flags (msg_info) & CAMEL_MESSAGE_FLAGGED) {
/* FIXME: extract from the important.xpm somehow. */
colour = "#A7453E";
} else if (((followup && *followup) || (due_by && *due_by)) && !(completed && *completed)) {
time_t now = time (NULL);
if ((followup && *followup) || now >= camel_header_decode_date (due_by, NULL))
colour = "#A7453E";
}
g_hash_table_destroy (ld.labels_tag2iter);
}
if (!colour)
colour = camel_message_info_user_tag (msg_info, "color");
return (gpointer) colour;
}
case COL_LOCATION: {
/* Fixme : freeing memory stuff (mem leaks) */
CamelStore *store;
CamelFolder *folder;
CamelService *service;
const gchar *store_name;
const gchar *folder_name;
folder = message_list->priv->folder;
if (CAMEL_IS_VEE_FOLDER (folder))
folder = camel_vee_folder_get_location (
CAMEL_VEE_FOLDER (folder),
(CamelVeeMessageInfo *) msg_info, NULL);
store = camel_folder_get_parent_store (folder);
folder_name = camel_folder_get_full_name (folder);
service = CAMEL_SERVICE (store);
store_name = camel_service_get_display_name (service);
return g_strdup_printf ("%s : %s", store_name, folder_name);
}
case COL_MIXED_RECIPIENTS:
case COL_RECIPIENTS:{
str = camel_message_info_to (msg_info);
return sanitize_recipients (str);
}
case COL_MIXED_SENDER:
case COL_SENDER:{
gchar **sender_name = NULL;
str = camel_message_info_from (msg_info);
if (str && str[0] != '\0') {
gchar *res;
sender_name = g_strsplit (str,"<",2);
res = g_strdup (*sender_name);
g_strfreev (sender_name);
return (gpointer)(res);
}
else
return (gpointer)("");
}
case COL_LABELS:{
struct LabelsData ld;
GString *result = g_string_new ("");
ld.store = e_mail_ui_session_get_label_store (
E_MAIL_UI_SESSION (session));
ld.labels_tag2iter = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) gtk_tree_iter_free);
for_node_and_subtree_if_collapsed (message_list, node, msg_info, add_all_labels_foreach, &ld);
if (g_hash_table_size (ld.labels_tag2iter) > 0) {
GHashTableIter iter;
GtkTreeIter *label_defn;
g_hash_table_iter_init (&iter, ld.labels_tag2iter);
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &label_defn)) {
gchar *label_name, *label_name_clean;
if (result->len > 0)
g_string_append (result, ", ");
label_name = e_mail_label_list_store_get_name (ld.store, label_defn);
label_name_clean = e_str_without_underscores (label_name);
g_string_append (result, label_name_clean);
g_free (label_name_clean);
g_free (label_name);
}
}
g_hash_table_destroy (ld.labels_tag2iter);
return (gpointer) g_string_free (result, FALSE);
}
default:
g_warning ("%s: This shouldn't be reached (col:%d)", G_STRFUNC, col);
return NULL;
}
}
static gchar *
filter_date (time_t date)
{
time_t nowdate = time (NULL);
time_t yesdate;
struct tm then, now, yesterday;
gchar buf[26];
gboolean done = FALSE;
if (date == 0)
return g_strdup (_("?"));
localtime_r (&date, &then);
localtime_r (&nowdate, &now);
if (then.tm_mday == now.tm_mday &&
then.tm_mon == now.tm_mon &&
then.tm_year == now.tm_year) {
e_utf8_strftime_fix_am_pm (buf, 26, _("Today %l:%M %p"), &then);
done = TRUE;
}
if (!done) {
yesdate = nowdate - 60 * 60 * 24;
localtime_r (&yesdate, &yesterday);
if (then.tm_mday == yesterday.tm_mday &&
then.tm_mon == yesterday.tm_mon &&
then.tm_year == yesterday.tm_year) {
e_utf8_strftime_fix_am_pm (buf, 26, _("Yesterday %l:%M %p"), &then);
done = TRUE;
}
}
if (!done) {
gint i;
for (i = 2; i < 7; i++) {
yesdate = nowdate - 60 * 60 * 24 * i;
localtime_r (&yesdate, &yesterday);
if (then.tm_mday == yesterday.tm_mday &&
then.tm_mon == yesterday.tm_mon &&
then.tm_year == yesterday.tm_year) {
e_utf8_strftime_fix_am_pm (buf, 26, _("%a %l:%M %p"), &then);
done = TRUE;
break;
}
}
}
if (!done) {
if (then.tm_year == now.tm_year) {
e_utf8_strftime_fix_am_pm (buf, 26, _("%b %d %l:%M %p"), &then);
} else {
e_utf8_strftime_fix_am_pm (buf, 26, _("%b %d %Y"), &then);
}
}
return g_strdup (buf);
}
static ECell * create_composite_cell (gint col)
{
ECell *cell_vbox, *cell_hbox, *cell_sub, *cell_date, *cell_from, *cell_tree, *cell_attach;
GSettings *settings;
gchar *fixed_name = NULL;
gboolean show_email;
gint alt_col = (col == COL_FROM) ? COL_SENDER : COL_RECIPIENTS;
gboolean same_font = FALSE;
settings = g_settings_new ("org.gnome.evolution.mail");
show_email = g_settings_get_boolean (settings, "show-email");
same_font = g_settings_get_boolean (settings, "vertical-view-fonts");
g_object_unref (settings);
if (!same_font) {
settings = g_settings_new ("org.gnome.desktop.interface");
fixed_name = g_settings_get_string (settings, "monospace-font-name");
g_object_unref (settings);
}
cell_vbox = e_cell_vbox_new ();
cell_hbox = e_cell_hbox_new ();
/* Exclude the meeting icon. */
cell_attach = e_cell_toggle_new (attachment_icons, G_N_ELEMENTS (attachment_icons));
cell_date = e_cell_date_new (NULL, GTK_JUSTIFY_RIGHT);
e_cell_date_set_format_component (E_CELL_DATE (cell_date), "mail");
g_object_set (
cell_date,
"bold_column", COL_UNREAD,
"color_column", COL_COLOUR,
NULL);
cell_from = e_cell_text_new (NULL, GTK_JUSTIFY_LEFT);
g_object_set (
cell_from,
"bold_column", COL_UNREAD,
"color_column", COL_COLOUR,
NULL);
e_cell_hbox_append (E_CELL_HBOX (cell_hbox), cell_from, show_email ? col : alt_col, 68);
e_cell_hbox_append (E_CELL_HBOX (cell_hbox), cell_attach, COL_ATTACHMENT, 5);
e_cell_hbox_append (E_CELL_HBOX (cell_hbox), cell_date, COL_SENT, 27);
g_object_unref (cell_from);
g_object_unref (cell_attach);
g_object_unref (cell_date);
cell_sub = e_cell_text_new (fixed_name? fixed_name : NULL, GTK_JUSTIFY_LEFT);
g_object_set (
cell_sub,
"color_column", COL_COLOUR,
NULL);
cell_tree = e_cell_tree_new (TRUE, cell_sub);
e_cell_vbox_append (E_CELL_VBOX (cell_vbox), cell_hbox, COL_FROM);
e_cell_vbox_append (E_CELL_VBOX (cell_vbox), cell_tree, COL_SUBJECT);
g_object_unref (cell_sub);
g_object_unref (cell_hbox);
g_object_unref (cell_tree);
g_object_set_data (G_OBJECT (cell_vbox), "cell_date", cell_date);
g_object_set_data (G_OBJECT (cell_vbox), "cell_sub", cell_sub);
g_object_set_data (G_OBJECT (cell_vbox), "cell_from", cell_from);
g_free (fixed_name);
return cell_vbox;
}
static void
composite_cell_set_strike_col (ECell *cell,
gint col)
{
g_object_set (g_object_get_data (G_OBJECT (cell), "cell_date"), "strikeout_column", col, NULL);
g_object_set (g_object_get_data (G_OBJECT (cell), "cell_from"), "strikeout_column", col, NULL);
}
static ETableExtras *
message_list_create_extras (void)
{
ETableExtras *extras;
ECell *cell;
extras = e_table_extras_new ();
e_table_extras_add_icon_name (extras, "status", "mail-unread");
e_table_extras_add_icon_name (extras, "score", "stock_score-higher");
e_table_extras_add_icon_name (extras, "attachment", "mail-attachment");
e_table_extras_add_icon_name (extras, "flagged", "emblem-important");
e_table_extras_add_icon_name (extras, "followup", "stock_mail-flag-for-followup");
e_table_extras_add_compare (extras, "address_compare", address_compare);
cell = e_cell_toggle_new (
status_icons, G_N_ELEMENTS (status_icons));
e_table_extras_add_cell (extras, "render_message_status", cell);
g_object_unref (cell);
cell = e_cell_toggle_new (
attachment_icons, G_N_ELEMENTS (attachment_icons));
e_table_extras_add_cell (extras, "render_attachment", cell);
g_object_unref (cell);
cell = e_cell_toggle_new (
flagged_icons, G_N_ELEMENTS (flagged_icons));
e_table_extras_add_cell (extras, "render_flagged", cell);
g_object_unref (cell);
cell = e_cell_toggle_new (
followup_icons, G_N_ELEMENTS (followup_icons));
e_table_extras_add_cell (extras, "render_flag_status", cell);
g_object_unref (cell);
cell = e_cell_toggle_new (
score_icons, G_N_ELEMENTS (score_icons));
e_table_extras_add_cell (extras, "render_score", cell);
g_object_unref (cell);
/* date cell */
cell = e_cell_date_new (NULL, GTK_JUSTIFY_LEFT);
e_cell_date_set_format_component (E_CELL_DATE (cell), "mail");
g_object_set (
cell,
"bold_column", COL_UNREAD,
"color_column", COL_COLOUR,
NULL);
e_table_extras_add_cell (extras, "render_date", cell);
g_object_unref (cell);
/* text cell */
cell = e_cell_text_new (NULL, GTK_JUSTIFY_LEFT);
g_object_set (
cell,
"bold_column", COL_UNREAD,
"color_column", COL_COLOUR,
NULL);
e_table_extras_add_cell (extras, "render_text", cell);
g_object_unref (cell);
cell = e_cell_tree_new (TRUE, cell);
e_table_extras_add_cell (extras, "render_tree", cell);
g_object_unref (cell);
/* size cell */
cell = e_cell_size_new (NULL, GTK_JUSTIFY_RIGHT);
g_object_set (
cell,
"bold_column", COL_UNREAD,
"color_column", COL_COLOUR,
NULL);
e_table_extras_add_cell (extras, "render_size", cell);
g_object_unref (cell);
/* Composite cell for wide view */
cell = create_composite_cell (COL_FROM);
e_table_extras_add_cell (extras, "render_composite_from", cell);
g_object_unref (cell);
cell = create_composite_cell (COL_TO);
e_table_extras_add_cell (extras, "render_composite_to", cell);
g_object_unref (cell);
/* set proper format component for a default 'date' cell renderer */
cell = e_table_extras_get_cell (extras, "date");
e_cell_date_set_format_component (E_CELL_DATE (cell), "mail");
return extras;
}
static void
save_tree_state (MessageList *message_list,
CamelFolder *folder)
{
ETreeTableAdapter *adapter;
gchar *filename;
if (folder == NULL)
return;
if (message_list->search != NULL && *message_list->search != '\0')
return;
adapter = e_tree_get_table_adapter (E_TREE (message_list));
filename = mail_config_folder_to_cachename (folder, "et-expanded-");
e_tree_table_adapter_save_expanded_state (adapter, filename);
g_free (filename);
message_list->priv->any_row_changed = FALSE;
}
static void
load_tree_state (MessageList *message_list,
CamelFolder *folder,
xmlDoc *expand_state)
{
ETreeTableAdapter *adapter;
if (folder == NULL)
return;
adapter = e_tree_get_table_adapter (E_TREE (message_list));
if (expand_state != NULL) {
e_tree_table_adapter_load_expanded_state_xml (
adapter, expand_state);
} else if (!message_list->search || !*message_list->search) {
/* only when not searching */
gchar *filename;
filename = mail_config_folder_to_cachename (
folder, "et-expanded-");
e_tree_table_adapter_load_expanded_state (adapter, filename);
g_free (filename);
}
message_list->priv->any_row_changed = FALSE;
}
void
message_list_save_state (MessageList *message_list)
{
CamelFolder *folder;
folder = message_list_ref_folder (message_list);
if (folder != NULL) {
save_tree_state (message_list, folder);
g_object_unref (folder);
}
}
static void
message_list_setup_etree (MessageList *message_list)
{
CamelFolder *folder;
/* Build the spec based on the folder, and possibly
* from a saved file. Otherwise, leave default. */
folder = message_list_ref_folder (message_list);
if (folder != NULL) {
gint data = 1;
ETableItem *item;
item = e_tree_get_item (E_TREE (message_list));
g_object_set (message_list, "uniform_row_height", TRUE, NULL);
g_object_set_data (
G_OBJECT (((GnomeCanvasItem *) item)->canvas),
"freeze-cursor", &data);
/* build based on saved file */
load_tree_state (message_list, folder, NULL);
g_object_unref (folder);
}
}
static void
ml_selection_get (GtkWidget *widget,
GtkSelectionData *data,
guint info,
guint time_stamp,
MessageList *message_list)
{
struct _MLSelection *selection;
selection = &message_list->priv->clipboard;
if (selection->uids == NULL)
return;
if (info & 2) {
/* text/plain */
d (printf ("setting text/plain selection for uids\n"));
em_utils_selection_set_mailbox (data, selection->folder, selection->uids);
} else {
/* x-uid-list */
d (printf ("setting x-uid-list selection for uids\n"));
em_utils_selection_set_uidlist (data, selection->folder, selection->uids);
}
}
static gboolean
ml_selection_clear_event (GtkWidget *widget,
GdkEventSelection *event,
MessageList *message_list)
{
MessageListPrivate *p = message_list->priv;
clear_selection (message_list, &p->clipboard);
return TRUE;
}
static void
ml_selection_received (GtkWidget *widget,
GtkSelectionData *selection_data,
guint time,
MessageList *message_list)
{
EMailSession *session;
CamelFolder *folder;
GdkAtom target;
target = gtk_selection_data_get_target (selection_data);
if (target != gdk_atom_intern ("x-uid-list", FALSE)) {
d (printf ("Unknown selection received by message-list\n"));
return;
}
folder = message_list_ref_folder (message_list);
session = message_list_get_session (message_list);
/* FIXME Not passing a GCancellable or GError here. */
em_utils_selection_get_uidlist (
selection_data, session, folder, FALSE, NULL, NULL);
g_clear_object (&folder);
}
static void
ml_tree_drag_data_get (ETree *tree,
gint row,
GNode *node,
gint col,
GdkDragContext *context,
GtkSelectionData *data,
guint info,
guint time,
MessageList *message_list)
{
CamelFolder *folder;
GPtrArray *uids;
folder = message_list_ref_folder (message_list);
uids = message_list_get_selected (message_list);
if (uids->len > 0) {
switch (info) {
case DND_X_UID_LIST:
em_utils_selection_set_uidlist (data, folder, uids);
break;
case DND_TEXT_URI_LIST:
em_utils_selection_set_urilist (data, folder, uids);
break;
}
}
g_clear_object (&folder);
g_ptr_array_unref (uids);
}
/* TODO: merge this with the folder tree stuff via empopup targets */
/* Drop handling */
struct _drop_msg {
MailMsg base;
GdkDragContext *context;
/* Only selection->data and selection->length are valid */
GtkSelectionData *selection;
CamelFolder *folder;
MessageList *message_list;
guint32 action;
guint info;
guint move : 1;
guint moved : 1;
guint aborted : 1;
};
static gchar *
ml_drop_async_desc (struct _drop_msg *m)
{
const gchar *full_name;
full_name = camel_folder_get_full_name (m->folder);
if (m->move)
return g_strdup_printf (_("Moving messages into folder %s"), full_name);
else
return g_strdup_printf (_("Copying messages into folder %s"), full_name);
}
static void
ml_drop_async_exec (struct _drop_msg *m,
GCancellable *cancellable,
GError **error)
{
EMailSession *session;
session = message_list_get_session (m->message_list);
switch (m->info) {
case DND_X_UID_LIST:
em_utils_selection_get_uidlist (
m->selection, session, m->folder,
m->action == GDK_ACTION_MOVE,
cancellable, error);
break;
case DND_MESSAGE_RFC822:
em_utils_selection_get_message (m->selection, m->folder);
break;
case DND_TEXT_URI_LIST:
em_utils_selection_get_urilist (m->selection, m->folder);
break;
}
}
static void
ml_drop_async_done (struct _drop_msg *m)
{
gboolean success, delete;
/* ?? */
if (m->aborted) {
success = FALSE;
delete = FALSE;
} else {
success = (m->base.error == NULL);
delete = success && m->move && !m->moved;
}
gtk_drag_finish (m->context, success, delete, GDK_CURRENT_TIME);
}
static void
ml_drop_async_free (struct _drop_msg *m)
{
g_object_unref (m->context);
g_object_unref (m->folder);
g_object_unref (m->message_list);
gtk_selection_data_free (m->selection);
}
static MailMsgInfo ml_drop_async_info = {
sizeof (struct _drop_msg),
(MailMsgDescFunc) ml_drop_async_desc,
(MailMsgExecFunc) ml_drop_async_exec,
(MailMsgDoneFunc) ml_drop_async_done,
(MailMsgFreeFunc) ml_drop_async_free
};
static void
ml_drop_action (struct _drop_msg *m)
{
m->move = m->action == GDK_ACTION_MOVE;
mail_msg_unordered_push (m);
}
static void
ml_tree_drag_data_received (ETree *tree,
gint row,
GNode *node,
gint col,
GdkDragContext *context,
gint x,
gint y,
GtkSelectionData *selection_data,
guint info,
guint time,
MessageList *message_list)
{
CamelFolder *folder;
struct _drop_msg *m;
if (gtk_selection_data_get_data (selection_data) == NULL)
return;
if (gtk_selection_data_get_length (selection_data) == -1)
return;
folder = message_list_ref_folder (message_list);
if (folder == NULL)
return;
m = mail_msg_new (&ml_drop_async_info);
m->context = g_object_ref (context);
m->folder = g_object_ref (folder);
m->message_list = g_object_ref (message_list);
m->action = gdk_drag_context_get_selected_action (context);
m->info = info;
/* need to copy, goes away once we exit */
m->selection = gtk_selection_data_copy (selection_data);
ml_drop_action (m);
g_object_unref (folder);
}
struct search_child_struct {
gboolean found;
gconstpointer looking_for;
};
static void
search_child_cb (GtkWidget *widget,
gpointer data)
{
struct search_child_struct *search = (struct search_child_struct *) data;
search->found = search->found || g_direct_equal (widget, search->looking_for);
}
static gboolean
is_tree_widget_children (ETree *tree,
gconstpointer widget)
{
struct search_child_struct search;
search.found = FALSE;
search.looking_for = widget;
gtk_container_foreach (GTK_CONTAINER (tree), search_child_cb, &search);
return search.found;
}
static gboolean
ml_tree_drag_motion (ETree *tree,
GdkDragContext *context,
gint x,
gint y,
guint time,
MessageList *message_list)
{
GList *targets;
GdkDragAction action, actions = 0;
GtkWidget *source_widget;
/* If drop target is name of the account/store
* and not actual folder, don't allow any action. */
if (message_list->priv->folder == NULL) {
gdk_drag_status (context, 0, time);
return TRUE;
}
source_widget = gtk_drag_get_source_widget (context);
/* If source widget is packed under 'tree', don't allow any action */
if (is_tree_widget_children (tree, source_widget)) {
gdk_drag_status (context, 0, time);
return TRUE;
}
if (EM_IS_FOLDER_TREE (source_widget)) {
EMFolderTree *folder_tree;
CamelFolder *selected_folder = NULL;
CamelStore *selected_store;
gchar *selected_folder_name;
gboolean has_selection;
folder_tree = EM_FOLDER_TREE (source_widget);
has_selection = em_folder_tree_get_selected (
folder_tree, &selected_store, &selected_folder_name);
/* Sanity checks */
g_warn_if_fail (
(has_selection && selected_store != NULL) ||
(!has_selection && selected_store == NULL));
g_warn_if_fail (
(has_selection && selected_folder_name != NULL) ||
(!has_selection && selected_folder_name == NULL));
if (has_selection) {
selected_folder = camel_store_get_folder_sync (
selected_store, selected_folder_name,
CAMEL_STORE_FOLDER_INFO_FAST, NULL, NULL);
g_object_unref (selected_store);
g_free (selected_folder_name);
}
if (selected_folder == message_list->priv->folder) {
gdk_drag_status (context, 0, time);
return TRUE;
}
}
targets = gdk_drag_context_list_targets (context);
while (targets != NULL) {
gint i;
d (printf ("atom drop '%s'\n", gdk_atom_name (targets->data)));
for (i = 0; i < G_N_ELEMENTS (ml_drag_info); i++)
if (targets->data == (gpointer) ml_drag_info[i].atom)
actions |= ml_drag_info[i].actions;
targets = g_list_next (targets);
}
d (printf ("\n"));
actions &= gdk_drag_context_get_actions (context);
action = gdk_drag_context_get_suggested_action (context);
if (action == GDK_ACTION_COPY && (actions & GDK_ACTION_MOVE))
action = GDK_ACTION_MOVE;
gdk_drag_status (context, action, time);
return action != 0;
}
static void
on_model_row_changed (ETableModel *model,
gint row,
MessageList *message_list)
{
message_list->priv->any_row_changed = TRUE;
}
static gboolean
ml_tree_sorting_changed (ETreeTableAdapter *adapter,
MessageList *message_list)
{
gboolean group_by_threads;
g_return_val_if_fail (message_list != NULL, FALSE);
group_by_threads = message_list_get_group_by_threads (message_list);
if (group_by_threads && message_list->frozen == 0) {
/* Invalidate the thread tree. */
message_list_set_thread_tree (message_list, NULL);
mail_regen_list (message_list, message_list->search, FALSE);
return TRUE;
}
return FALSE;
}
static void
message_list_set_session (MessageList *message_list,
EMailSession *session)
{
g_return_if_fail (E_IS_MAIL_SESSION (session));
g_return_if_fail (message_list->priv->session == NULL);
message_list->priv->session = g_object_ref (session);
}
static void
message_list_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
switch (property_id) {
case PROP_FOLDER:
message_list_set_folder (
MESSAGE_LIST (object),
g_value_get_object (value));
return;
case PROP_GROUP_BY_THREADS:
message_list_set_group_by_threads (
MESSAGE_LIST (object),
g_value_get_boolean (value));
return;
case PROP_SESSION:
message_list_set_session (
MESSAGE_LIST (object),
g_value_get_object (value));
return;
case PROP_SHOW_DELETED:
message_list_set_show_deleted (
MESSAGE_LIST (object),
g_value_get_boolean (value));
return;
case PROP_THREAD_LATEST:
message_list_set_thread_latest (
MESSAGE_LIST (object),
g_value_get_boolean (value));
return;
case PROP_THREAD_SUBJECT:
message_list_set_thread_subject (
MESSAGE_LIST (object),
g_value_get_boolean (value));
return;
}
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
static void
message_list_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
switch (property_id) {
case PROP_COPY_TARGET_LIST:
g_value_set_boxed (
value,
message_list_get_copy_target_list (
MESSAGE_LIST (object)));
return;
case PROP_FOLDER:
g_value_take_object (
value,
message_list_ref_folder (
MESSAGE_LIST (object)));
return;
case PROP_GROUP_BY_THREADS:
g_value_set_boolean (
value,
message_list_get_group_by_threads (
MESSAGE_LIST (object)));
return;
case PROP_PASTE_TARGET_LIST:
g_value_set_boxed (
value,
message_list_get_paste_target_list (
MESSAGE_LIST (object)));
return;
case PROP_SESSION:
g_value_set_object (
value,
message_list_get_session (
MESSAGE_LIST (object)));
return;
case PROP_SHOW_DELETED:
g_value_set_boolean (
value,
message_list_get_show_deleted (
MESSAGE_LIST (object)));
return;
case PROP_THREAD_LATEST:
g_value_set_boolean (
value,
message_list_get_thread_latest (
MESSAGE_LIST (object)));
return;
case PROP_THREAD_SUBJECT:
g_value_set_boolean (
value,
message_list_get_thread_subject (
MESSAGE_LIST (object)));
return;
}
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
static void
message_list_dispose (GObject *object)
{
MessageList *message_list = MESSAGE_LIST (object);
MessageListPrivate *priv;
priv = message_list->priv;
if (priv->folder_changed_handler_id > 0) {
g_signal_handler_disconnect (
priv->folder,
priv->folder_changed_handler_id);
priv->folder_changed_handler_id = 0;
}
if (priv->copy_target_list != NULL) {
gtk_target_list_unref (priv->copy_target_list);
priv->copy_target_list = NULL;
}
if (priv->paste_target_list != NULL) {
gtk_target_list_unref (priv->paste_target_list);
priv->paste_target_list = NULL;
}
priv->destroyed = TRUE;
if (message_list->priv->folder != NULL)
mail_regen_cancel (message_list);
if (message_list->uid_nodemap) {
g_hash_table_foreach (
message_list->uid_nodemap,
(GHFunc) clear_info, message_list);
g_hash_table_destroy (message_list->uid_nodemap);
message_list->uid_nodemap = NULL;
}
g_clear_object (&priv->session);
g_clear_object (&priv->folder);
g_clear_object (&priv->invisible);
g_clear_object (&message_list->extras);
if (message_list->idle_id > 0) {
g_source_remove (message_list->idle_id);
message_list->idle_id = 0;
}
if (message_list->seen_id > 0) {
g_source_remove (message_list->seen_id);
message_list->seen_id = 0;
}
/* Chain up to parent's dispose() method. */
G_OBJECT_CLASS (message_list_parent_class)->dispose (object);
}
static void
message_list_finalize (GObject *object)
{
MessageList *message_list = MESSAGE_LIST (object);
g_hash_table_destroy (message_list->normalised_hash);
if (message_list->priv->thread_tree != NULL)
camel_folder_thread_messages_unref (
message_list->priv->thread_tree);
g_free (message_list->search);
g_free (message_list->frozen_search);
g_free (message_list->cursor_uid);
g_mutex_clear (&message_list->priv->regen_lock);
g_mutex_clear (&message_list->priv->thread_tree_lock);
clear_selection (message_list, &message_list->priv->clipboard);
if (message_list->priv->tree_model_root != NULL)
extended_g_node_destroy (message_list->priv->tree_model_root);
/* Chain up to parent's finalize() method. */
G_OBJECT_CLASS (message_list_parent_class)->finalize (object);
}
static void
message_list_constructed (GObject *object)
{
/* Chain up to parent's constructed() method. */
G_OBJECT_CLASS (message_list_parent_class)->constructed (object);
e_extensible_load_extensions (E_EXTENSIBLE (object));
}
static void
message_list_selectable_update_actions (ESelectable *selectable,
EFocusTracker *focus_tracker,
GdkAtom *clipboard_targets,
gint n_clipboard_targets)
{
ETreeTableAdapter *adapter;
GtkAction *action;
gint row_count;
adapter = e_tree_get_table_adapter (E_TREE (selectable));
row_count = e_table_model_row_count (E_TABLE_MODEL (adapter));
action = e_focus_tracker_get_select_all_action (focus_tracker);
gtk_action_set_tooltip (action, _("Select all visible messages"));
gtk_action_set_sensitive (action, row_count > 0);
}
static void
message_list_selectable_select_all (ESelectable *selectable)
{
message_list_select_all (MESSAGE_LIST (selectable));
}
static ETreePath
message_list_get_root (ETreeModel *tree_model)
{
MessageList *message_list = MESSAGE_LIST (tree_model);
return message_list->priv->tree_model_root;
}
static ETreePath
message_list_get_parent (ETreeModel *tree_model,
ETreePath path)
{
return ((GNode *) path)->parent;
}
static ETreePath
message_list_get_first_child (ETreeModel *tree_model,
ETreePath path)
{
return g_node_first_child ((GNode *) path);
}
static ETreePath
message_list_get_next (ETreeModel *tree_model,
ETreePath path)
{
return g_node_next_sibling ((GNode *) path);
}
static gboolean
message_list_is_root (ETreeModel *tree_model,
ETreePath path)
{
return G_NODE_IS_ROOT ((GNode *) path);
}
static gboolean
message_list_is_expandable (ETreeModel *tree_model,
ETreePath path)
{
return (g_node_first_child ((GNode *) path) != NULL);
}
static guint
message_list_get_n_nodes (ETreeModel *tree_model)
{
ETreePath root;
root = e_tree_model_get_root (tree_model);
if (root == NULL)
return 0;
/* The root node is an empty placeholder, so
* subtract one from the count to exclude it. */
return g_node_n_nodes ((GNode *) root, G_TRAVERSE_ALL) - 1;
}
static guint
message_list_get_n_children (ETreeModel *tree_model,
ETreePath path)
{
return g_node_n_children ((GNode *) path);
}
static guint
message_list_depth (ETreeModel *tree_model,
ETreePath path)
{
return g_node_depth ((GNode *) path);
}
static gboolean
message_list_get_expanded_default (ETreeModel *tree_model)
{
MessageList *message_list = MESSAGE_LIST (tree_model);
return message_list->priv->expanded_default;
}
static gint
message_list_column_count (ETreeModel *tree_model)
{
return COL_LAST;
}
static gchar *
message_list_get_save_id (ETreeModel *tree_model,
ETreePath path)
{
CamelMessageInfo *info;
if (G_NODE_IS_ROOT ((GNode *) path))
return g_strdup ("root");
/* Note: ETable can ask for the save_id while we're clearing
* it, which is the only time info should be NULL. */
info = ((GNode *) path)->data;
if (info == NULL)
return NULL;
return g_strdup (camel_message_info_uid (info));
}
static ETreePath
message_list_get_node_by_id (ETreeModel *tree_model,
const gchar *save_id)
{
MessageList *message_list;
message_list = MESSAGE_LIST (tree_model);
if (!strcmp (save_id, "root"))
return e_tree_model_get_root (tree_model);
return g_hash_table_lookup (message_list->uid_nodemap, save_id);
}
static gpointer
message_list_sort_value_at (ETreeModel *tree_model,
ETreePath path,
gint col)
{
MessageList *message_list;
struct LatestData ld;
message_list = MESSAGE_LIST (tree_model);
if (!(col == COL_SENT || col == COL_RECEIVED))
return e_tree_model_value_at (tree_model, path, col);
if (G_NODE_IS_ROOT ((GNode *) path))
return NULL;
ld.sent = (col == COL_SENT);
ld.latest = 0;
latest_foreach (tree_model, path, &ld);
if (message_list->priv->thread_latest)
e_tree_model_node_traverse (
tree_model, path, latest_foreach, &ld);
return GINT_TO_POINTER (ld.latest);
}
static gpointer
message_list_value_at (ETreeModel *tree_model,
ETreePath path,
gint col)
{
MessageList *message_list;
CamelMessageInfo *msg_info;
message_list = MESSAGE_LIST (tree_model);
if (G_NODE_IS_ROOT ((GNode *) path))
return NULL;
/* retrieve the message information array */
msg_info = ((GNode *) path)->data;
g_return_val_if_fail (msg_info != NULL, NULL);
return ml_tree_value_at_ex (tree_model, path, col, msg_info, message_list);
}
static gpointer
message_list_duplicate_value (ETreeModel *tree_model,
gint col,
gconstpointer value)
{
switch (col) {
case COL_MESSAGE_STATUS:
case COL_FLAGGED:
case COL_SCORE:
case COL_ATTACHMENT:
case COL_DELETED:
case COL_UNREAD:
case COL_SENT:
case COL_RECEIVED:
case COL_SIZE:
case COL_FOLLOWUP_FLAG_STATUS:
case COL_FOLLOWUP_DUE_BY:
return (gpointer) value;
case COL_FROM:
case COL_SUBJECT:
case COL_TO:
case COL_SENDER:
case COL_RECIPIENTS:
case COL_MIXED_SENDER:
case COL_MIXED_RECIPIENTS:
case COL_FOLLOWUP_FLAG:
case COL_LOCATION:
case COL_LABELS:
return g_strdup (value);
default:
g_return_val_if_reached (NULL);
}
}
static void
message_list_free_value (ETreeModel *tree_model,
gint col,
gpointer value)
{
switch (col) {
case COL_MESSAGE_STATUS:
case COL_FLAGGED:
case COL_SCORE:
case COL_ATTACHMENT:
case COL_DELETED:
case COL_UNREAD:
case COL_SENT:
case COL_RECEIVED:
case COL_SIZE:
case COL_FOLLOWUP_FLAG_STATUS:
case COL_FOLLOWUP_DUE_BY:
case COL_FROM_NORM:
case COL_SUBJECT_NORM:
case COL_TO_NORM:
case COL_SUBJECT_TRIMMED:
case COL_COLOUR:
break;
case COL_FROM:
case COL_SUBJECT:
case COL_TO:
case COL_FOLLOWUP_FLAG:
case COL_LOCATION:
case COL_SENDER:
case COL_RECIPIENTS:
case COL_MIXED_SENDER:
case COL_MIXED_RECIPIENTS:
case COL_LABELS:
g_free (value);
break;
default:
g_warn_if_reached ();
}
}
static gpointer
message_list_initialize_value (ETreeModel *tree_model,
gint col)
{
switch (col) {
case COL_MESSAGE_STATUS:
case COL_FLAGGED:
case COL_SCORE:
case COL_ATTACHMENT:
case COL_DELETED:
case COL_UNREAD:
case COL_SENT:
case COL_RECEIVED:
case COL_SIZE:
case COL_FOLLOWUP_FLAG_STATUS:
case COL_FOLLOWUP_DUE_BY:
return NULL;
case COL_FROM:
case COL_SUBJECT:
case COL_TO:
case COL_FOLLOWUP_FLAG:
case COL_LOCATION:
case COL_SENDER:
case COL_RECIPIENTS:
case COL_MIXED_SENDER:
case COL_MIXED_RECIPIENTS:
case COL_LABELS:
return g_strdup ("");
default:
g_return_val_if_reached (NULL);
}
}
static gboolean
message_list_value_is_empty (ETreeModel *tree_model,
gint col,
gconstpointer value)
{
switch (col) {
case COL_MESSAGE_STATUS:
case COL_FLAGGED:
case COL_SCORE:
case COL_ATTACHMENT:
case COL_DELETED:
case COL_UNREAD:
case COL_SENT:
case COL_RECEIVED:
case COL_SIZE:
case COL_FOLLOWUP_FLAG_STATUS:
case COL_FOLLOWUP_DUE_BY:
return value == NULL;
case COL_FROM:
case COL_SUBJECT:
case COL_TO:
case COL_FOLLOWUP_FLAG:
case COL_LOCATION:
case COL_SENDER:
case COL_RECIPIENTS:
case COL_MIXED_SENDER:
case COL_MIXED_RECIPIENTS:
case COL_LABELS:
return !(value && *(gchar *) value);
default:
g_return_val_if_reached (FALSE);
}
}
static gchar *
message_list_value_to_string (ETreeModel *tree_model,
gint col,
gconstpointer value)
{
guint ii;
switch (col) {
case COL_MESSAGE_STATUS:
ii = GPOINTER_TO_UINT (value);
if (ii > 5)
return g_strdup ("");
return g_strdup (_(status_map[ii]));
case COL_SCORE:
ii = GPOINTER_TO_UINT (value) + 3;
if (ii > 6)
ii = 3;
return g_strdup (_(score_map[ii]));
case COL_ATTACHMENT:
case COL_FLAGGED:
case COL_DELETED:
case COL_UNREAD:
case COL_FOLLOWUP_FLAG_STATUS:
ii = GPOINTER_TO_UINT (value);
return g_strdup_printf ("%u", ii);
case COL_SENT:
case COL_RECEIVED:
case COL_FOLLOWUP_DUE_BY:
return filter_date (GPOINTER_TO_INT (value));
case COL_SIZE:
return filter_size (GPOINTER_TO_INT (value));
case COL_FROM:
case COL_SUBJECT:
case COL_TO:
case COL_FOLLOWUP_FLAG:
case COL_LOCATION:
case COL_SENDER:
case COL_RECIPIENTS:
case COL_MIXED_SENDER:
case COL_MIXED_RECIPIENTS:
case COL_LABELS:
return g_strdup (value);
default:
g_return_val_if_reached (NULL);
}
}
static void
message_list_class_init (MessageListClass *class)
{
GObjectClass *object_class;
gint i;
for (i = 0; i < G_N_ELEMENTS (ml_drag_info); i++)
ml_drag_info[i].atom = gdk_atom_intern (ml_drag_info[i].target, FALSE);
g_type_class_add_private (class, sizeof (MessageListPrivate));
object_class = G_OBJECT_CLASS (class);
object_class->set_property = message_list_set_property;
object_class->get_property = message_list_get_property;
object_class->dispose = message_list_dispose;
object_class->finalize = message_list_finalize;
object_class->constructed = message_list_constructed;
class->message_list_built = NULL;
/* Inherited from ESelectableInterface */
g_object_class_override_property (
object_class,
PROP_COPY_TARGET_LIST,
"copy-target-list");
g_object_class_install_property (
object_class,
PROP_FOLDER,
g_param_spec_object (
"folder",
"Folder",
"The source folder",
CAMEL_TYPE_FOLDER,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (
object_class,
PROP_GROUP_BY_THREADS,
g_param_spec_boolean (
"group-by-threads",
"Group By Threads",
"Group messages into conversation threads",
FALSE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
/* Inherited from ESelectableInterface */
g_object_class_override_property (
object_class,
PROP_PASTE_TARGET_LIST,
"paste-target-list");
g_object_class_install_property (
object_class,
PROP_SESSION,
g_param_spec_object (
"session",
"Mail Session",
"The mail session",
E_TYPE_MAIL_SESSION,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (
object_class,
PROP_SHOW_DELETED,
g_param_spec_boolean (
"show-deleted",
"Show Deleted",
"Show messages marked for deletion",
FALSE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (
object_class,
PROP_THREAD_LATEST,
g_param_spec_boolean (
"thread-latest",
"Thread Latest",
"Sort threads by latest message",
TRUE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (
object_class,
PROP_THREAD_SUBJECT,
g_param_spec_boolean (
"thread-subject",
"Thread Subject",
"Thread messages by Subject headers",
FALSE,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
signals[MESSAGE_SELECTED] = g_signal_new (
"message_selected",
MESSAGE_LIST_TYPE,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (MessageListClass, message_selected),
NULL,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1,
G_TYPE_STRING);
signals[MESSAGE_LIST_BUILT] = g_signal_new (
"message_list_built",
MESSAGE_LIST_TYPE,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (MessageListClass, message_list_built),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
static void
message_list_selectable_init (ESelectableInterface *interface)
{
interface->update_actions = message_list_selectable_update_actions;
interface->select_all = message_list_selectable_select_all;
}
static void
message_list_tree_model_init (ETreeModelInterface *interface)
{
interface->get_root = message_list_get_root;
interface->get_parent = message_list_get_parent;
interface->get_first_child = message_list_get_first_child;
interface->get_next = message_list_get_next;
interface->is_root = message_list_is_root;
interface->is_expandable = message_list_is_expandable;
interface->get_n_nodes = message_list_get_n_nodes;
interface->get_n_children = message_list_get_n_children;
interface->depth = message_list_depth;
interface->get_expanded_default = message_list_get_expanded_default;
interface->column_count = message_list_column_count;
interface->get_save_id = message_list_get_save_id;
interface->get_node_by_id = message_list_get_node_by_id;
interface->sort_value_at = message_list_sort_value_at;
interface->value_at = message_list_value_at;
interface->duplicate_value = message_list_duplicate_value;
interface->free_value = message_list_free_value;
interface->initialize_value = message_list_initialize_value;
interface->value_is_empty = message_list_value_is_empty;
interface->value_to_string = message_list_value_to_string;
}
static void
message_list_init (MessageList *message_list)
{
MessageListPrivate *p;
GtkTargetList *target_list;
GdkAtom matom;
message_list->priv = MESSAGE_LIST_GET_PRIVATE (message_list);
message_list->normalised_hash = g_hash_table_new_full (
g_str_hash, g_str_equal,
(GDestroyNotify) NULL,
(GDestroyNotify) e_poolv_destroy);
message_list->uid_nodemap = g_hash_table_new (g_str_hash, g_str_equal);
message_list->cursor_uid = NULL;
message_list->last_sel_single = FALSE;
g_mutex_init (&message_list->priv->regen_lock);
g_mutex_init (&message_list->priv->thread_tree_lock);
/* TODO: Should this only get the selection if we're realised? */
p = message_list->priv;
p->invisible = gtk_invisible_new ();
p->destroyed = FALSE;
g_object_ref_sink (p->invisible);
p->any_row_changed = FALSE;
matom = gdk_atom_intern ("x-uid-list", FALSE);
gtk_selection_add_target (p->invisible, GDK_SELECTION_CLIPBOARD, matom, 0);
gtk_selection_add_target (p->invisible, GDK_SELECTION_CLIPBOARD, GDK_SELECTION_TYPE_STRING, 2);
g_signal_connect (
p->invisible, "selection_get",
G_CALLBACK (ml_selection_get), message_list);
g_signal_connect (
p->invisible, "selection_clear_event",
G_CALLBACK (ml_selection_clear_event), message_list);
g_signal_connect (
p->invisible, "selection_received",
G_CALLBACK (ml_selection_received), message_list);
/* FIXME This is currently unused. */
target_list = gtk_target_list_new (NULL, 0);
message_list->priv->copy_target_list = target_list;
/* FIXME This is currently unused. */
target_list = gtk_target_list_new (NULL, 0);
message_list->priv->paste_target_list = target_list;
}
static void
message_list_construct (MessageList *message_list)
{
ETreeTableAdapter *adapter;
ETableSpecification *specification;
AtkObject *a11y;
gboolean constructed;
gchar *etspecfile;
GError *local_error = NULL;
/*
* The etree
*/
message_list->extras = message_list_create_extras ();
etspecfile = g_build_filename (
EVOLUTION_ETSPECDIR, "message-list.etspec", NULL);
specification = e_table_specification_new (etspecfile, &local_error);
/* Failure here is fatal. */
if (local_error != NULL) {
g_error ("%s: %s", etspecfile, local_error->message);
g_assert_not_reached ();
}
constructed = e_tree_construct (
E_TREE (message_list),
E_TREE_MODEL (message_list),
message_list->extras, specification);
g_object_unref (specification);
g_free (etspecfile);
adapter = e_tree_get_table_adapter (E_TREE (message_list));
if (constructed)
e_tree_table_adapter_root_node_set_visible (adapter, FALSE);
if (atk_get_root () != NULL) {
a11y = gtk_widget_get_accessible (GTK_WIDGET (message_list));
atk_object_set_name (a11y, _("Messages"));
}
g_signal_connect (
adapter, "model_row_changed",
G_CALLBACK (on_model_row_changed), message_list);
g_signal_connect (
message_list, "cursor_activated",
G_CALLBACK (on_cursor_activated_cmd), message_list);
g_signal_connect (
message_list, "click",
G_CALLBACK (on_click), message_list);
g_signal_connect (
message_list, "selection_change",
G_CALLBACK (on_selection_changed_cmd), message_list);
e_tree_drag_source_set (
E_TREE (message_list), GDK_BUTTON1_MASK,
ml_drag_types, G_N_ELEMENTS (ml_drag_types),
GDK_ACTION_MOVE | GDK_ACTION_COPY);
g_signal_connect (
message_list, "tree_drag_data_get",
G_CALLBACK (ml_tree_drag_data_get), message_list);
gtk_drag_dest_set (
GTK_WIDGET (message_list),
GTK_DEST_DEFAULT_ALL,
ml_drop_types,
G_N_ELEMENTS (ml_drop_types),
GDK_ACTION_MOVE |
GDK_ACTION_COPY);
g_signal_connect (
message_list, "tree_drag_data_received",
G_CALLBACK (ml_tree_drag_data_received), message_list);
g_signal_connect (
message_list, "drag-motion",
G_CALLBACK (ml_tree_drag_motion), message_list);
g_signal_connect (
adapter, "sorting_changed",
G_CALLBACK (ml_tree_sorting_changed), message_list);
}
/**
* message_list_new:
*
* Creates a new message-list widget.
*
* Returns a new message-list widget.
**/
GtkWidget *
message_list_new (EMailSession *session)
{
GtkWidget *message_list;
g_return_val_if_fail (E_IS_MAIL_SESSION (session), NULL);
message_list = g_object_new (
message_list_get_type (),
"session", session, NULL);
message_list_construct (MESSAGE_LIST (message_list));
return message_list;
}
EMailSession *
message_list_get_session (MessageList *message_list)
{
g_return_val_if_fail (IS_MESSAGE_LIST (message_list), NULL);
return message_list->priv->session;
}
static void
clear_info (gchar *key,
GNode *node,
MessageList *message_list)
{
CamelMessageInfo *info;
info = node->data;
camel_folder_free_message_info (message_list->priv->folder, info);
node->data = NULL;
}
static void
clear_tree (MessageList *message_list,
gboolean tfree)
{
ETreeModel *tree_model;
CamelFolder *folder;
#ifdef TIMEIT
struct timeval start, end;
gulong diff;
printf ("Clearing tree\n");
gettimeofday (&start, NULL);
#endif
tree_model = E_TREE_MODEL (message_list);
/* we also reset the uid_rowmap since it is no longer useful/valid anyway */
folder = message_list_ref_folder (message_list);
if (folder != NULL)
g_hash_table_foreach (
message_list->uid_nodemap,
(GHFunc) clear_info, message_list);
g_hash_table_destroy (message_list->uid_nodemap);
message_list->uid_nodemap = g_hash_table_new (g_str_hash, g_str_equal);
g_clear_object (&folder);
message_list->priv->newest_read_date = 0;
message_list->priv->newest_read_uid = NULL;
message_list->priv->oldest_unread_date = 0;
message_list->priv->oldest_unread_uid = NULL;
if (message_list->priv->tree_model_root != NULL) {
/* we should be frozen already */
message_list_tree_model_remove (
message_list, message_list->priv->tree_model_root);
}
/* Create a new placeholder root node. */
message_list_tree_model_insert (message_list, NULL, 0, NULL);
g_warn_if_fail (message_list->priv->tree_model_root != NULL);
if (tfree)
e_tree_model_rebuilt (tree_model);
#ifdef TIMEIT
gettimeofday (&end, NULL);
diff = end.tv_sec * 1000 + end.tv_usec / 1000;
diff -= start.tv_sec * 1000 + start.tv_usec / 1000;
printf ("Clearing tree took %ld.%03ld seconds\n", diff / 1000, diff % 1000);
#endif
}
static gboolean
folder_store_supports_vjunk_folder (CamelFolder *folder)
{
CamelStore *store;
g_return_val_if_fail (folder != NULL, FALSE);
store = camel_folder_get_parent_store (folder);
if (store == NULL)
return FALSE;
if (CAMEL_IS_VEE_FOLDER (folder))
return TRUE;
if (store->flags & CAMEL_STORE_VJUNK)
return TRUE;
if (store->flags & CAMEL_STORE_REAL_JUNK_FOLDER)
return TRUE;
return FALSE;
}
static gboolean
message_list_get_hide_junk (MessageList *message_list,
CamelFolder *folder)
{
if (folder == NULL)
return FALSE;
if (!folder_store_supports_vjunk_folder (folder))
return FALSE;
if (folder->folder_flags & CAMEL_FOLDER_IS_JUNK)
return FALSE;
if (folder->folder_flags & CAMEL_FOLDER_IS_TRASH)
return FALSE;
return TRUE;
}
static gboolean
message_list_get_hide_deleted (MessageList *message_list,
CamelFolder *folder)
{
CamelStore *store;
gboolean non_trash_folder;
if (folder == NULL)
return FALSE;
if (message_list_get_show_deleted (message_list))
return FALSE;
store = camel_folder_get_parent_store (folder);
g_return_val_if_fail (store != NULL, FALSE);
non_trash_folder =
((store->flags & CAMEL_STORE_VTRASH) == 0) ||
((folder->folder_flags & CAMEL_FOLDER_IS_TRASH) == 0);
return non_trash_folder;
}
/* Check if the given node is selectable in the current message list,
* which depends on the type of the folder (normal, junk, trash). */
static gboolean
is_node_selectable (MessageList *message_list,
CamelMessageInfo *info)
{
CamelFolder *folder;
gboolean is_junk_folder;
gboolean is_trash_folder;
guint32 flags;
gboolean flag_junk;
gboolean flag_deleted;
gboolean hide_junk;
gboolean hide_deleted;
gboolean store_has_vjunk;
gboolean selectable = FALSE;
g_return_val_if_fail (info != NULL, FALSE);
folder = message_list_ref_folder (message_list);
g_return_val_if_fail (folder != NULL, FALSE);
store_has_vjunk = folder_store_supports_vjunk_folder (folder);
/* check folder type */
is_junk_folder =
store_has_vjunk &&
(folder->folder_flags & CAMEL_FOLDER_IS_JUNK) != 0;
is_trash_folder = folder->folder_flags & CAMEL_FOLDER_IS_TRASH;
hide_junk = message_list_get_hide_junk (message_list, folder);
hide_deleted = message_list_get_hide_deleted (message_list, folder);
g_object_unref (folder);
/* check flags set on current message */
flags = camel_message_info_flags (info);
flag_junk = store_has_vjunk && (flags & CAMEL_MESSAGE_JUNK) != 0;
flag_deleted = flags & CAMEL_MESSAGE_DELETED;
/* perform actions depending on folder type */
if (is_junk_folder) {
/* messages in a junk folder are selectable only if
* the message is marked as junk and if not deleted
* when hide_deleted is set */
if (flag_junk && !(flag_deleted && hide_deleted))
selectable = TRUE;
} else if (is_trash_folder) {
/* messages in a trash folder are selectable unless
* not deleted any more */
if (flag_deleted)
selectable = TRUE;
} else {
/* in normal folders it depends on hide_deleted,
* hide_junk and the message flags */
if (!(flag_junk && hide_junk)
&& !(flag_deleted && hide_deleted))
selectable = TRUE;
}
return selectable;
}
/* We try and find something that is selectable in our tree. There is
* actually no assurance that we'll find something that will still be
* there next time, but its probably going to work most of the time. */
static gchar *
find_next_selectable (MessageList *message_list)
{
ETreeTableAdapter *adapter;
GNode *node;
gint vrow_orig;
gint vrow;
gint row_count;
CamelMessageInfo *info;
node = g_hash_table_lookup (
message_list->uid_nodemap,
message_list->cursor_uid);
if (node == NULL)
return NULL;
info = get_message_info (message_list, node);
if (info && is_node_selectable (message_list, info))
return NULL;
adapter = e_tree_get_table_adapter (E_TREE (message_list));
row_count = e_table_model_row_count (E_TABLE_MODEL (adapter));
/* model_to_view_row etc simply dont work for sorted views. Sigh. */
vrow_orig = e_tree_table_adapter_row_of_node (adapter, node);
/* We already checked this node. */
vrow = vrow_orig + 1;
while (vrow < row_count) {
node = e_tree_table_adapter_node_at_row (adapter, vrow);
info = get_message_info (message_list, node);
if (info && is_node_selectable (message_list, info))
return g_strdup (camel_message_info_uid (info));
vrow++;
}
/* We didn't find any undeleted entries _below_ the currently selected one
* * so let's try to find one _above_ */
vrow = vrow_orig - 1;
while (vrow >= 0) {
node = e_tree_table_adapter_node_at_row (adapter, vrow);
info = get_message_info (message_list, node);
if (info && is_node_selectable (message_list, info))
return g_strdup (camel_message_info_uid (info));
vrow--;
}
return NULL;
}
static GNode *
ml_uid_nodemap_insert (MessageList *message_list,
CamelMessageInfo *info,
GNode *parent,
gint row)
{
CamelFolder *folder;
GNode *node;
const gchar *uid;
time_t date;
guint flags;
folder = message_list_ref_folder (message_list);
g_return_val_if_fail (folder != NULL, NULL);
if (parent == NULL)
parent = message_list->priv->tree_model_root;
node = message_list_tree_model_insert (
message_list, parent, row, info);
uid = camel_message_info_uid (info);
flags = camel_message_info_flags (info);
date = camel_message_info_date_received (info);
camel_folder_ref_message_info (folder, info);
g_hash_table_insert (message_list->uid_nodemap, (gpointer) uid, node);
/* Track the latest seen and unseen messages shown, used in
* fallback heuristics for automatic message selection. */
if (flags & CAMEL_MESSAGE_SEEN) {
if (date > message_list->priv->newest_read_date) {
message_list->priv->newest_read_date = date;
message_list->priv->newest_read_uid = uid;
}
} else {
if (message_list->priv->oldest_unread_date == 0) {
message_list->priv->oldest_unread_date = date;
message_list->priv->oldest_unread_uid = uid;
} else if (date < message_list->priv->oldest_unread_date) {
message_list->priv->oldest_unread_date = date;
message_list->priv->oldest_unread_uid = uid;
}
}
g_object_unref (folder);
return node;
}
static void
ml_uid_nodemap_remove (MessageList *message_list,
CamelMessageInfo *info)
{
CamelFolder *folder;
const gchar *uid;
folder = message_list_ref_folder (message_list);
g_return_if_fail (folder != NULL);
uid = camel_message_info_uid (info);
if (uid == message_list->priv->newest_read_uid) {
message_list->priv->newest_read_date = 0;
message_list->priv->newest_read_uid = NULL;
}
if (uid == message_list->priv->oldest_unread_uid) {
message_list->priv->oldest_unread_date = 0;
message_list->priv->oldest_unread_uid = NULL;
}
g_hash_table_remove (message_list->uid_nodemap, uid);
camel_folder_free_message_info (folder, info);
g_object_unref (folder);
}
/* only call if we have a tree model */
/* builds the tree structure */
static void build_subtree (MessageList *message_list,
GNode *parent,
CamelFolderThreadNode *c,
gint *row);
static void build_subtree_diff (MessageList *message_list,
GNode *parent,
GNode *node,
CamelFolderThreadNode *c,
gint *row);
static void
build_tree (MessageList *message_list,
CamelFolderThread *thread,
gboolean folder_changed)
{
gint row = 0;
ETableItem *table_item = e_tree_get_item (E_TREE (message_list));
ETreeTableAdapter *adapter;
gchar *saveuid = NULL;
GPtrArray *selected;
#ifdef TIMEIT
struct timeval start, end;
gulong diff;
printf ("Building tree\n");
gettimeofday (&start, NULL);
#endif
#ifdef TIMEIT
gettimeofday (&end, NULL);
diff = end.tv_sec * 1000 + end.tv_usec / 1000;
diff -= start.tv_sec * 1000 + start.tv_usec / 1000;
printf ("Loading tree state took %ld.%03ld seconds\n", diff / 1000, diff % 1000);
#endif
adapter = e_tree_get_table_adapter (E_TREE (message_list));
if (message_list->priv->tree_model_root == NULL) {
message_list_tree_model_insert (message_list, NULL, 0, NULL);
g_warn_if_fail (message_list->priv->tree_model_root != NULL);
}
if (message_list->cursor_uid != NULL)
saveuid = find_next_selectable (message_list);
selected = message_list_get_selected (message_list);
message_list_tree_model_freeze (message_list);
clear_tree (message_list, FALSE);
build_subtree (
message_list,
message_list->priv->tree_model_root,
thread->tree, &row);
/* Show the cursor unless we're responding to a
* "folder-changed" signal from our CamelFolder. */
if (folder_changed && table_item != NULL)
table_item->queue_show_cursor = FALSE;
message_list_tree_model_thaw (message_list);
/* it's required to thaw & freeze, to propagate changes */
message_list_tree_model_freeze (message_list);
message_list_set_selected (message_list, selected);
g_ptr_array_unref (selected);
/* Show the cursor unless we're responding to a
* "folder-changed" signal from our CamelFolder. */
if (folder_changed && table_item != NULL)
table_item->queue_show_cursor = FALSE;
message_list_tree_model_thaw (message_list);
if (!saveuid && message_list->cursor_uid && g_hash_table_lookup (message_list->uid_nodemap, message_list->cursor_uid)) {
/* this makes sure a visible node is selected, like when
* collapsing all nodes and a children had been selected
*/
saveuid = g_strdup (message_list->cursor_uid);
}
if (saveuid) {
GNode *node;
node = g_hash_table_lookup (
message_list->uid_nodemap, saveuid);
if (node == NULL) {
g_free (message_list->cursor_uid);
message_list->cursor_uid = NULL;
g_signal_emit (
message_list,
signals[MESSAGE_SELECTED], 0, NULL);
} else {
GNode *parent = node;
while ((parent = parent->parent) != NULL) {
if (!e_tree_table_adapter_node_is_expanded (adapter, parent))
node = parent;
}
message_list_tree_model_freeze (message_list);
e_tree_set_cursor (E_TREE (message_list), node);
/* Show the cursor unless we're responding to a
* "folder-changed" signal from our CamelFolder. */
if (folder_changed && table_item != NULL)
table_item->queue_show_cursor = FALSE;
message_list_tree_model_thaw (message_list);
}
g_free (saveuid);
} else if (message_list->cursor_uid && !g_hash_table_lookup (message_list->uid_nodemap, message_list->cursor_uid)) {
g_free (message_list->cursor_uid);
message_list->cursor_uid = NULL;
g_signal_emit (
message_list,
signals[MESSAGE_SELECTED], 0, NULL);
}
#ifdef TIMEIT
gettimeofday (&end, NULL);
diff = end.tv_sec * 1000 + end.tv_usec / 1000;
diff -= start.tv_sec * 1000 + start.tv_usec / 1000;
printf ("Building tree took %ld.%03ld seconds\n", diff / 1000, diff % 1000);
#endif
}
/* this is about 20% faster than build_subtree_diff,
* entirely because e_tree_model_node_insert (xx, -1 xx)
* is faster than inserting to the right row :( */
/* Otherwise, this code would probably go as it does the same thing essentially */
static void
build_subtree (MessageList *message_list,
GNode *parent,
CamelFolderThreadNode *c,
gint *row)
{
GNode *node;
while (c) {
/* phantom nodes no longer allowed */
if (!c->message) {
g_warning ("c->message shouldn't be NULL\n");
c = c->next;
continue;
}
node = ml_uid_nodemap_insert (
message_list,
(CamelMessageInfo *) c->message, parent, -1);
if (c->child) {
build_subtree (message_list, node, c->child, row);
}
c = c->next;
}
}
/* compares a thread tree node with the etable tree node to see if they point to
* the same object */
static gint
node_equal (ETreeModel *etm,
GNode *ap,
CamelFolderThreadNode *bp)
{
if (bp->message && strcmp (camel_message_info_uid (ap->data), camel_message_info_uid (bp->message)) == 0)
return 1;
return 0;
}
/* adds a single node, retains save state, and handles adding children if required */
static void
add_node_diff (MessageList *message_list,
GNode *parent,
GNode *node,
CamelFolderThreadNode *c,
gint *row,
gint myrow)
{
CamelMessageInfo *info;
GNode *new_node;
g_return_if_fail (c->message != NULL);
/* XXX Casting away constness. */
info = (CamelMessageInfo *) c->message;
/* we just update the hashtable key */
ml_uid_nodemap_remove (message_list, info);
new_node = ml_uid_nodemap_insert (message_list, info, parent, myrow);
(*row)++;
if (c->child) {
build_subtree_diff (
message_list, new_node, NULL, c->child, row);
}
}
/* removes node, children recursively and all associated data */
static void
remove_node_diff (MessageList *message_list,
GNode *node,
gint depth)
{
ETreePath cp, cn;
CamelMessageInfo *info;
t (printf ("Removing node: %s\n", (gchar *) node->data));
/* we depth-first remove all node data's ... */
cp = g_node_first_child (node);
while (cp) {
cn = g_node_next_sibling (cp);
remove_node_diff (message_list, cp, depth + 1);
cp = cn;
}
/* and the rowid entry - if and only if it is referencing this node */
info = node->data;
/* and only at the toplevel, remove the node (etree should optimise this remove somewhat) */
if (depth == 0)
message_list_tree_model_remove (message_list, node);
g_return_if_fail (info);
ml_uid_nodemap_remove (message_list, info);
}
/* applies a new tree structure to an existing tree, but only by changing things
* that have changed */
static void
build_subtree_diff (MessageList *message_list,
GNode *parent,
GNode *node,
CamelFolderThreadNode *c,
gint *row)
{
ETreeModel *tree_model;
GNode *ap, *ai, *at, *tmp;
CamelFolderThreadNode *bp, *bi, *bt;
gint i, j, myrow = 0;
tree_model = E_TREE_MODEL (message_list);
ap = node;
bp = c;
while (ap || bp) {
t (printf ("Processing row: %d (subtree row %d)\n", *row, myrow));
if (ap == NULL) {
t (printf ("out of old nodes\n"));
/* ran out of old nodes - remaining nodes are added */
add_node_diff (
message_list, parent, ap, bp, row, myrow);
myrow++;
bp = bp->next;
} else if (bp == NULL) {
t (printf ("out of new nodes\n"));
/* ran out of new nodes - remaining nodes are removed */
tmp = g_node_next_sibling (ap);
remove_node_diff (message_list, ap, 0);
ap = tmp;
} else if (node_equal (tree_model, ap, bp)) {
*row = (*row)+1;
myrow++;
tmp = g_node_first_child (ap);
/* make child lists match (if either has one) */
if (bp->child || tmp) {
build_subtree_diff (
message_list, ap, tmp, bp->child, row);
}
ap = g_node_next_sibling (ap);
bp = bp->next;
} else {
t (printf ("searching for matches\n"));
/* we have to scan each side for a match */
bi = bp->next;
ai = g_node_next_sibling (ap);
for (i = 1; bi != NULL; i++,bi = bi->next) {
if (node_equal (tree_model, ap, bi))
break;
}
for (j = 1; ai != NULL; j++,ai = g_node_next_sibling (ai)) {
if (node_equal (tree_model, ai, bp))
break;
}
if (i < j) {
/* smaller run of new nodes - must be nodes to add */
if (bi) {
bt = bp;
while (bt != bi) {
t (printf ("adding new node 0\n"));
add_node_diff (
message_list, parent, NULL, bt, row, myrow);
myrow++;
bt = bt->next;
}
bp = bi;
} else {
t (printf ("adding new node 1\n"));
/* no match in new nodes, add one, try next */
add_node_diff (
message_list, parent, NULL, bp, row, myrow);
myrow++;
bp = bp->next;
}
} else {
/* bigger run of old nodes - must be nodes to remove */
if (ai) {
at = ap;
while (at != NULL && at != ai) {
t (printf ("removing old node 0\n"));
tmp = g_node_next_sibling (at);
remove_node_diff (message_list, at, 0);
at = tmp;
}
ap = ai;
} else {
t (printf ("adding new node 2\n"));
/* didn't find match in old nodes, must be new node? */
add_node_diff (
message_list, parent, NULL, bp, row, myrow);
myrow++;
bp = bp->next;
}
}
}
}
}
static void
build_flat (MessageList *message_list,
GPtrArray *summary)
{
gchar *saveuid = NULL;
gint i;
GPtrArray *selected;
#ifdef TIMEIT
struct timeval start, end;
gulong diff;
printf ("Building flat\n");
gettimeofday (&start, NULL);
#endif
if (message_list->cursor_uid != NULL)
saveuid = find_next_selectable (message_list);
selected = message_list_get_selected (message_list);
message_list_tree_model_freeze (message_list);
clear_tree (message_list, FALSE);
for (i = 0; i < summary->len; i++) {
CamelMessageInfo *info = summary->pdata[i];
ml_uid_nodemap_insert (message_list, info, NULL, -1);
}
message_list_tree_model_thaw (message_list);
message_list_set_selected (message_list, selected);
g_ptr_array_unref (selected);
if (saveuid) {
GNode *node;
node = g_hash_table_lookup (
message_list->uid_nodemap, saveuid);
if (node == NULL) {
g_free (message_list->cursor_uid);
message_list->cursor_uid = NULL;
g_signal_emit (
message_list,
signals[MESSAGE_SELECTED], 0, NULL);
} else {
e_tree_set_cursor (E_TREE (message_list), node);
}
g_free (saveuid);
}
#ifdef TIMEIT
gettimeofday (&end, NULL);
diff = end.tv_sec * 1000 + end.tv_usec / 1000;
diff -= start.tv_sec * 1000 + start.tv_usec / 1000;
printf ("Building flat took %ld.%03ld seconds\n", diff / 1000, diff % 1000);
#endif
}
static void
message_list_change_first_visible_parent (MessageList *message_list,
GNode *node)
{
ETreeModel *tree_model;
ETreeTableAdapter *adapter;
GNode *first_visible = NULL;
tree_model = E_TREE_MODEL (message_list);
adapter = e_tree_get_table_adapter (E_TREE (message_list));
while (node != NULL && (node = node->parent) != NULL) {
if (!e_tree_table_adapter_node_is_expanded (adapter, node))
first_visible = node;
}
if (first_visible != NULL) {
e_tree_model_pre_change (tree_model);
e_tree_model_node_data_changed (tree_model, first_visible);
}
}
static CamelFolderChangeInfo *
mail_folder_hide_by_flag (CamelFolder *folder,
MessageList *message_list,
CamelFolderChangeInfo *changes,
gint flag)
{
CamelFolderChangeInfo *newchanges;
CamelMessageInfo *info;
gint i;
newchanges = camel_folder_change_info_new ();
for (i = 0; i < changes->uid_changed->len; i++) {
GNode *node;
guint32 flags;
node = g_hash_table_lookup (
message_list->uid_nodemap,
changes->uid_changed->pdata[i]);
info = camel_folder_get_message_info (
folder, changes->uid_changed->pdata[i]);
if (info)
flags = camel_message_info_flags (info);
if (node != NULL && info != NULL && (flags & flag) != 0)
camel_folder_change_info_remove_uid (
newchanges, changes->uid_changed->pdata[i]);
else if (node == NULL && info != NULL && (flags & flag) == 0)
camel_folder_change_info_add_uid (
newchanges, changes->uid_changed->pdata[i]);
else
camel_folder_change_info_change_uid (
newchanges, changes->uid_changed->pdata[i]);
if (info)
camel_folder_free_message_info (folder, info);
}
if (newchanges->uid_added->len > 0 || newchanges->uid_removed->len > 0) {
for (i = 0; i < changes->uid_added->len; i++)
camel_folder_change_info_add_uid (
newchanges, changes->uid_added->pdata[i]);
for (i = 0; i < changes->uid_removed->len; i++)
camel_folder_change_info_remove_uid (
newchanges, changes->uid_removed->pdata[i]);
} else {
camel_folder_change_info_clear (newchanges);
camel_folder_change_info_cat (newchanges, changes);
}
return newchanges;
}
static void
message_list_folder_changed (CamelFolder *folder,
CamelFolderChangeInfo *changes,
MessageList *message_list)
{
CamelFolderChangeInfo *altered_changes = NULL;
ETreeModel *tree_model;
gboolean need_list_regen = TRUE;
gboolean hide_junk;
gboolean hide_deleted;
gint i;
if (message_list->priv->destroyed)
return;
tree_model = E_TREE_MODEL (message_list);
hide_junk = message_list_get_hide_junk (message_list, folder);
hide_deleted = message_list_get_hide_deleted (message_list, folder);
d (printf ("folder changed event, changes = %p\n", changes));
if (changes != NULL) {
for (i = 0; i < changes->uid_removed->len; i++)
g_hash_table_remove (
message_list->normalised_hash,
changes->uid_removed->pdata[i]);
/* Check if the hidden state has changed.
* If so, modify accordingly and regenerate. */
if (hide_junk || hide_deleted)
altered_changes = mail_folder_hide_by_flag (
folder, message_list, changes,
(hide_junk ? CAMEL_MESSAGE_JUNK : 0) |
(hide_deleted ? CAMEL_MESSAGE_DELETED : 0));
else {
altered_changes = camel_folder_change_info_new ();
camel_folder_change_info_cat (altered_changes, changes);
}
if (altered_changes->uid_added->len == 0 && altered_changes->uid_removed->len == 0 && altered_changes->uid_changed->len < 100) {
for (i = 0; i < altered_changes->uid_changed->len; i++) {
GNode *node;
node = g_hash_table_lookup (
message_list->uid_nodemap,
altered_changes->uid_changed->pdata[i]);
if (node) {
e_tree_model_pre_change (tree_model);
e_tree_model_node_data_changed (tree_model, node);
message_list_change_first_visible_parent (message_list, node);
}
}
g_signal_emit (
message_list,
signals[MESSAGE_LIST_BUILT], 0);
need_list_regen = FALSE;
}
}
if (need_list_regen)
mail_regen_list (message_list, message_list->search, TRUE);
if (altered_changes != NULL)
camel_folder_change_info_free (altered_changes);
}
CamelFolder *
message_list_ref_folder (MessageList *message_list)
{
CamelFolder *folder = NULL;
/* XXX Do we need a property lock to guard this? */
g_return_val_if_fail (IS_MESSAGE_LIST (message_list), NULL);
if (message_list->priv->folder != NULL)
folder = g_object_ref (message_list->priv->folder);
return folder;
}
/**
* message_list_set_folder:
* @message_list: Message List widget
* @folder: folder backend to be set
*
* Sets @folder to be the backend folder for @message_list.
**/
void
message_list_set_folder (MessageList *message_list,
CamelFolder *folder)
{
/* XXX Do we need a property lock to guard this? */
g_return_if_fail (IS_MESSAGE_LIST (message_list));
if (folder == message_list->priv->folder)
return;
if (folder != NULL) {
g_return_if_fail (CAMEL_IS_FOLDER (folder));
g_object_ref (folder);
}
g_free (message_list->search);
message_list->search = NULL;
g_free (message_list->frozen_search);
message_list->frozen_search = NULL;
if (message_list->seen_id) {
g_source_remove (message_list->seen_id);
message_list->seen_id = 0;
}
/* reset the normalised sort performance hack */
g_hash_table_remove_all (message_list->normalised_hash);
mail_regen_cancel (message_list);
if (message_list->priv->folder != NULL)
save_tree_state (message_list, message_list->priv->folder);
message_list_tree_model_freeze (message_list);
clear_tree (message_list, TRUE);
message_list_tree_model_thaw (message_list);
/* remove the cursor activate idle handler */
if (message_list->idle_id != 0) {
g_source_remove (message_list->idle_id);
message_list->idle_id = 0;
}
if (message_list->priv->folder != NULL) {
g_signal_handler_disconnect (
message_list->priv->folder,
message_list->priv->folder_changed_handler_id);
message_list->priv->folder_changed_handler_id = 0;
if (message_list->uid_nodemap != NULL)
g_hash_table_foreach (
message_list->uid_nodemap,
(GHFunc) clear_info, message_list);
g_clear_object (&message_list->priv->folder);
}
/* Invalidate the thread tree. */
message_list_set_thread_tree (message_list, NULL);
g_free (message_list->cursor_uid);
message_list->cursor_uid = NULL;
/* Always emit message-selected, event when an account node
* (folder == NULL) is selected, so that views know what happened and
* can stop all running operations etc. */
g_signal_emit (message_list, signals[MESSAGE_SELECTED], 0, NULL);
if (folder != NULL) {
CamelStore *store;
gboolean non_trash_folder;
gint strikeout_col;
ECell *cell;
gulong handler_id;
message_list->priv->folder = folder;
message_list->just_set_folder = TRUE;
store = camel_folder_get_parent_store (folder);
non_trash_folder =
((store->flags & CAMEL_STORE_VTRASH) == 0) ||
((folder->folder_flags & CAMEL_FOLDER_IS_TRASH) == 0);
/* Setup the strikeout effect for non-trash folders */
strikeout_col = non_trash_folder ? COL_DELETED : -1;
cell = e_table_extras_get_cell (message_list->extras, "render_date");
g_object_set (cell, "strikeout_column", strikeout_col, NULL);
cell = e_table_extras_get_cell (message_list->extras, "render_text");
g_object_set (cell, "strikeout_column", strikeout_col, NULL);
cell = e_table_extras_get_cell (message_list->extras, "render_size");
g_object_set (cell, "strikeout_column", strikeout_col, NULL);
cell = e_table_extras_get_cell (message_list->extras, "render_composite_from");
composite_cell_set_strike_col (cell, strikeout_col);
cell = e_table_extras_get_cell (message_list->extras, "render_composite_to");
composite_cell_set_strike_col (cell, strikeout_col);
/* Build the etree suitable for this folder */
message_list_setup_etree (message_list);
handler_id = g_signal_connect (
folder, "changed",
G_CALLBACK (message_list_folder_changed),
message_list);
message_list->priv->folder_changed_handler_id = handler_id;
if (message_list->frozen == 0)
mail_regen_list (message_list, message_list->search, FALSE);
}
}
GtkTargetList *
message_list_get_copy_target_list (MessageList *message_list)
{
g_return_val_if_fail (IS_MESSAGE_LIST (message_list), NULL);
return message_list->priv->copy_target_list;
}
GtkTargetList *
message_list_get_paste_target_list (MessageList *message_list)
{
g_return_val_if_fail (IS_MESSAGE_LIST (message_list), NULL);
return message_list->priv->paste_target_list;
}
void
message_list_set_expanded_default (MessageList *message_list,
gboolean expanded_default)
{
g_return_if_fail (IS_MESSAGE_LIST (message_list));
message_list->priv->expanded_default = expanded_default;
}
gboolean
message_list_get_group_by_threads (MessageList *message_list)
{
g_return_val_if_fail (IS_MESSAGE_LIST (message_list), FALSE);
return message_list->priv->group_by_threads;
}
void
message_list_set_group_by_threads (MessageList *message_list,
gboolean group_by_threads)
{
g_return_if_fail (IS_MESSAGE_LIST (message_list));
if (group_by_threads == message_list->priv->group_by_threads)
return;
message_list->priv->group_by_threads = group_by_threads;
g_object_notify (G_OBJECT (message_list), "group-by-threads");
/* Changing this property triggers a message list regen. */
if (message_list->frozen == 0)
mail_regen_list (message_list, message_list->search, FALSE);
}
gboolean
message_list_get_show_deleted (MessageList *message_list)
{
g_return_val_if_fail (IS_MESSAGE_LIST (message_list), FALSE);
return message_list->priv->show_deleted;
}
void
message_list_set_show_deleted (MessageList *message_list,
gboolean show_deleted)
{
g_return_if_fail (IS_MESSAGE_LIST (message_list));
if (show_deleted == message_list->priv->show_deleted)
return;
message_list->priv->show_deleted = show_deleted;
g_object_notify (G_OBJECT (message_list), "show-deleted");
/* Invalidate the thread tree. */
message_list_set_thread_tree (message_list, NULL);
/* Changing this property triggers a message list regen. */
if (message_list->frozen == 0)
mail_regen_list (message_list, message_list->search, FALSE);
}
gboolean
message_list_get_thread_latest (MessageList *message_list)
{
g_return_val_if_fail (IS_MESSAGE_LIST (message_list), FALSE);
return message_list->priv->thread_latest;
}
void
message_list_set_thread_latest (MessageList *message_list,
gboolean thread_latest)
{
g_return_if_fail (IS_MESSAGE_LIST (message_list));
if (thread_latest == message_list->priv->thread_latest)
return;
message_list->priv->thread_latest = thread_latest;
g_object_notify (G_OBJECT (message_list), "thread-latest");
}
gboolean
message_list_get_thread_subject (MessageList *message_list)
{
g_return_val_if_fail (IS_MESSAGE_LIST (message_list), FALSE);
return message_list->priv->thread_subject;
}
void
message_list_set_thread_subject (MessageList *message_list,
gboolean thread_subject)
{
g_return_if_fail (IS_MESSAGE_LIST (message_list));
if (thread_subject == message_list->priv->thread_subject)
return;
message_list->priv->thread_subject = thread_subject;
g_object_notify (G_OBJECT (message_list), "thread-subject");
}
static gboolean
on_cursor_activated_idle (gpointer data)
{
MessageList *message_list = data;
ESelectionModel *esm;
gint selected;
esm = e_tree_get_selection_model (E_TREE (message_list));
selected = e_selection_model_selected_count (esm);
if (selected == 1 && message_list->cursor_uid) {
d (printf ("emitting cursor changed signal, for uid %s\n", message_list->cursor_uid));
g_signal_emit (
message_list,
signals[MESSAGE_SELECTED], 0,
message_list->cursor_uid);
} else {
g_signal_emit (
message_list,
signals[MESSAGE_SELECTED], 0,
NULL);
}
message_list->idle_id = 0;
return FALSE;
}
static void
on_cursor_activated_cmd (ETree *tree,
gint row,
GNode *node,
gpointer user_data)
{
MessageList *message_list = MESSAGE_LIST (user_data);
const gchar *new_uid;
if (node == NULL)
new_uid = NULL;
else
new_uid = get_message_uid (message_list, node);
/* Do not check the cursor_uid and the new_uid values, because the
* selected item (set in on_selection_changed_cmd) can be different
* from the one with a cursor (when selecting with Ctrl, for example).
* This has a little side-effect, when keeping list it that state,
* then changing folders forth and back will select and move cursor
* to that selected item. Does anybody consider it as a bug? */
if ((message_list->cursor_uid == NULL && new_uid == NULL)
|| (message_list->last_sel_single && message_list->cursor_uid != NULL && new_uid != NULL))
return;
g_free (message_list->cursor_uid);
message_list->cursor_uid = g_strdup (new_uid);
if (!message_list->idle_id) {
message_list->idle_id =
g_idle_add_full (
G_PRIORITY_LOW, on_cursor_activated_idle,
message_list, NULL);
}
}
static void
on_selection_changed_cmd (ETree *tree,
MessageList *message_list)
{
GPtrArray *uids;
const gchar *newuid;
GNode *cursor;
/* not sure if we could just ignore this for the cursor, i think sometimes you
* only get a selection changed when you should also get a cursor activated? */
uids = message_list_get_selected (message_list);
if (uids->len == 1)
newuid = g_ptr_array_index (uids, 0);
else if ((cursor = e_tree_get_cursor (tree)))
newuid = (gchar *) camel_message_info_uid (cursor->data);
else
newuid = NULL;
/* If the selection isn't empty, then we ignore the no-uid check, since this event
* is also used for other updating. If it is empty, it might just be a setup event
* from etree which we do need to ignore */
if ((newuid == NULL && message_list->cursor_uid == NULL && uids->len == 0) ||
(message_list->last_sel_single && uids->len == 1 && newuid != NULL && message_list->cursor_uid != NULL && !strcmp (message_list->cursor_uid, newuid))) {
/* noop */
} else {
g_free (message_list->cursor_uid);
message_list->cursor_uid = g_strdup (newuid);
if (message_list->idle_id == 0)
message_list->idle_id = g_idle_add_full (
G_PRIORITY_LOW,
on_cursor_activated_idle,
message_list, NULL);
}
message_list->last_sel_single = uids->len == 1;
g_ptr_array_unref (uids);
}
static gint
on_click (ETree *tree,
gint row,
GNode *node,
gint col,
GdkEvent *event,
MessageList *list)
{
CamelFolder *folder;
CamelMessageInfo *info;
gboolean folder_is_trash;
const gchar *uid;
gint flag = 0;
guint32 flags;
if (col == COL_MESSAGE_STATUS)
flag = CAMEL_MESSAGE_SEEN;
else if (col == COL_FLAGGED)
flag = CAMEL_MESSAGE_FLAGGED;
else if (col != COL_FOLLOWUP_FLAG_STATUS)
return FALSE;
if (!(info = get_message_info (list, node)))
return FALSE;
folder = message_list_ref_folder (list);
g_return_val_if_fail (folder != NULL, FALSE);
if (col == COL_FOLLOWUP_FLAG_STATUS) {
const gchar *tag, *cmp;
tag = camel_message_info_user_tag (info, "follow-up");
cmp = camel_message_info_user_tag (info, "completed-on");
if (tag && tag[0]) {
if (cmp && cmp[0]) {
camel_message_info_set_user_tag (info, "follow-up", NULL);
camel_message_info_set_user_tag (info, "due-by", NULL);
camel_message_info_set_user_tag (info, "completed-on", NULL);
} else {
gchar *text;
text = camel_header_format_date (time (NULL), 0);
camel_message_info_set_user_tag (info, "completed-on", text);
g_free (text);
}
} else {
/* default follow-up flag name to use when clicked in the message list column */
camel_message_info_set_user_tag (info, "follow-up", _("Follow-up"));
camel_message_info_set_user_tag (info, "completed-on", NULL);
}
return TRUE;
}
flags = camel_message_info_flags (info);
folder_is_trash =
((folder->folder_flags & CAMEL_FOLDER_IS_TRASH) != 0);
/* If a message was marked as deleted and the user flags it as
* important or unread in a non-Trash folder, then undelete the
* message. We avoid automatically undeleting messages while
* viewing a Trash folder because it would cause the message to
* suddenly disappear from the message list, which is confusing
* and alarming to the user. */
if (!folder_is_trash && flags & CAMEL_MESSAGE_DELETED) {
if (col == COL_FLAGGED && !(flags & CAMEL_MESSAGE_FLAGGED))
flag |= CAMEL_MESSAGE_DELETED;
if (col == COL_MESSAGE_STATUS && (flags & CAMEL_MESSAGE_SEEN))
flag |= CAMEL_MESSAGE_DELETED;
}
uid = camel_message_info_uid (info);
camel_folder_set_message_flags (folder, uid, flag, ~flags);
/* Notify the folder tree model that the user has marked a message
* as unread so it doesn't mistake the event as new mail arriving. */
if (col == COL_MESSAGE_STATUS && (flags & CAMEL_MESSAGE_SEEN)) {
EMFolderTreeModel *model;
model = em_folder_tree_model_get_default ();
em_folder_tree_model_user_marked_unread (model, folder, 1);
}
if (flag == CAMEL_MESSAGE_SEEN && list->seen_id) {
g_source_remove (list->seen_id);
list->seen_id = 0;
}
g_object_unref (folder);
return TRUE;
}
struct _ml_selected_data {
MessageList *message_list;
GPtrArray *uids;
};
static void
ml_getselected_cb (GNode *node,
gpointer user_data)
{
struct _ml_selected_data *data = user_data;
const gchar *uid;
if (G_NODE_IS_ROOT (node))
return;
uid = get_message_uid (data->message_list, node);
g_return_if_fail (uid != NULL);
g_ptr_array_add (data->uids, g_strdup (uid));
}
GPtrArray *
message_list_get_selected (MessageList *message_list)
{
CamelFolder *folder;
ESelectionModel *selection;
struct _ml_selected_data data = {
message_list,
g_ptr_array_new ()
};
g_ptr_array_set_free_func (data.uids, (GDestroyNotify) g_free);
selection = e_tree_get_selection_model (E_TREE (message_list));
e_tree_selection_model_foreach (
E_TREE_SELECTION_MODEL (selection),
(ETreeForeachFunc) ml_getselected_cb, &data);
folder = message_list_ref_folder (message_list);
if (folder != NULL && data.uids->len > 0)
camel_folder_sort_uids (folder, data.uids);
g_clear_object (&folder);
return data.uids;
}
void
message_list_set_selected (MessageList *message_list,
GPtrArray *uids)
{
gint i;
ETreeSelectionModel *etsm;
GNode *node;
GPtrArray *paths = g_ptr_array_new ();
etsm = (ETreeSelectionModel *)
e_tree_get_selection_model (E_TREE (message_list));
for (i = 0; i < uids->len; i++) {
node = g_hash_table_lookup (
message_list->uid_nodemap, uids->pdata[i]);
if (node != NULL)
g_ptr_array_add (paths, node);
}
e_tree_selection_model_select_paths (etsm, paths);
g_ptr_array_free (paths, TRUE);
}
struct ml_sort_uids_data {
gchar *uid;
gint row;
};
static gint
ml_sort_uids_cb (gconstpointer a,
gconstpointer b)
{
struct ml_sort_uids_data * const *pdataA = a;
struct ml_sort_uids_data * const *pdataB = b;
return (* pdataA)->row - (* pdataB)->row;
}
void
message_list_sort_uids (MessageList *message_list,
GPtrArray *uids)
{
struct ml_sort_uids_data *data;
GPtrArray *array;
GNode *node;
ETreeTableAdapter *adapter;
gint ii;
g_return_if_fail (message_list != NULL);
g_return_if_fail (IS_MESSAGE_LIST (message_list));
g_return_if_fail (uids != NULL);
if (uids->len <= 1)
return;
adapter = e_tree_get_table_adapter (E_TREE (message_list));
array = g_ptr_array_new_full (uids->len, g_free);
for (ii = 0; ii < uids->len; ii++) {
data = g_new0 (struct ml_sort_uids_data, 1);
data->uid = g_ptr_array_index (uids, ii);
node = g_hash_table_lookup (message_list->uid_nodemap, data->uid);
if (node != NULL)
data->row = e_tree_table_adapter_row_of_node (adapter, node);
else
data->row = ii;
g_ptr_array_add (array, data);
}
g_ptr_array_sort (array, ml_sort_uids_cb);
for (ii = 0; ii < uids->len; ii++) {
data = g_ptr_array_index (array, ii);
uids->pdata[ii] = data->uid;
}
g_ptr_array_free (array, TRUE);
}
struct ml_count_data {
MessageList *message_list;
guint count;
};
static void
ml_getcount_cb (GNode *node,
gpointer user_data)
{
struct ml_count_data *data = user_data;
if (!G_NODE_IS_ROOT (node))
data->count++;
}
guint
message_list_count (MessageList *message_list)
{
struct ml_count_data data = { message_list, 0 };
g_return_val_if_fail (IS_MESSAGE_LIST (message_list), 0);
e_tree_path_foreach (
E_TREE (message_list),
(ETreeForeachFunc) ml_getcount_cb, &data);
return data.count;
}
static void
ml_getselcount_cb (gint model_row,
gpointer user_data)
{
struct ml_count_data *data = user_data;
data->count++;
}
guint
message_list_selected_count (MessageList *message_list)
{
ESelectionModel *selection;
struct ml_count_data data = { message_list, 0 };
g_return_val_if_fail (IS_MESSAGE_LIST (message_list), 0);
selection = e_tree_get_selection_model (E_TREE (message_list));
e_selection_model_foreach (selection, ml_getselcount_cb, &data);
return data.count;
}
void
message_list_freeze (MessageList *message_list)
{
message_list->frozen++;
}
void
message_list_thaw (MessageList *message_list)
{
g_return_if_fail (message_list->frozen != 0);
message_list->frozen--;
if (message_list->frozen == 0) {
const gchar *search;
if (message_list->frozen_search != NULL)
search = message_list->frozen_search;
else
search = message_list->search;
mail_regen_list (message_list, search, FALSE);
g_free (message_list->frozen_search);
message_list->frozen_search = NULL;
}
}
/* set whether we are in threaded view or flat view */
void
message_list_set_threaded_expand_all (MessageList *message_list)
{
g_return_if_fail (IS_MESSAGE_LIST (message_list));
if (message_list_get_group_by_threads (message_list)) {
message_list->expand_all = 1;
if (message_list->frozen == 0)
mail_regen_list (
message_list, message_list->search, FALSE);
}
}
void
message_list_set_threaded_collapse_all (MessageList *message_list)
{
g_return_if_fail (IS_MESSAGE_LIST (message_list));
if (message_list_get_group_by_threads (message_list)) {
message_list->collapse_all = 1;
if (message_list->frozen == 0)
mail_regen_list (
message_list, message_list->search, FALSE);
}
}
void
message_list_set_search (MessageList *message_list,
const gchar *search)
{
if (search == NULL || search[0] == '\0')
if (message_list->search == NULL || message_list->search[0] == '\0')
return;
if (search != NULL && message_list->search != NULL && strcmp (search, message_list->search) == 0)
return;
/* Invalidate the thread tree. */
message_list_set_thread_tree (message_list, NULL);
if (message_list->frozen == 0)
mail_regen_list (message_list, search, FALSE);
else {
g_free (message_list->frozen_search);
message_list->frozen_search = g_strdup (search);
}
}
struct sort_column_data {
ETableCol *col;
GtkSortType sort_type;
};
struct sort_message_info_data {
CamelMessageInfo *mi;
GPtrArray *values; /* read values so far, in order of sort_array_data::sort_columns */
};
struct sort_array_data {
MessageList *message_list;
CamelFolder *folder;
GPtrArray *sort_columns; /* struct sort_column_data in order of sorting */
GHashTable *message_infos; /* uid -> struct sort_message_info_data */
gpointer cmp_cache;
GCancellable *cancellable;
};
static gint
cmp_array_uids (gconstpointer a,
gconstpointer b,
gpointer user_data)
{
const gchar *uid1 = *(const gchar **) a;
const gchar *uid2 = *(const gchar **) b;
struct sort_array_data *sort_data = user_data;
gint i, res = 0;
struct sort_message_info_data *md1, *md2;
g_return_val_if_fail (sort_data != NULL, 0);
md1 = g_hash_table_lookup (sort_data->message_infos, uid1);
md2 = g_hash_table_lookup (sort_data->message_infos, uid2);
g_return_val_if_fail (md1 != NULL, 0);
g_return_val_if_fail (md1->mi != NULL, 0);
g_return_val_if_fail (md2 != NULL, 0);
g_return_val_if_fail (md2->mi != NULL, 0);
if (g_cancellable_is_cancelled (sort_data->cancellable))
return 0;
for (i = 0;
res == 0
&& i < sort_data->sort_columns->len
&& !g_cancellable_is_cancelled (sort_data->cancellable);
i++) {
gpointer v1, v2;
struct sort_column_data *scol = g_ptr_array_index (sort_data->sort_columns, i);
if (md1->values->len <= i) {
v1 = ml_tree_value_at_ex (
NULL, NULL,
scol->col->spec->compare_col,
md1->mi, sort_data->message_list);
g_ptr_array_add (md1->values, v1);
} else {
v1 = g_ptr_array_index (md1->values, i);
}
if (md2->values->len <= i) {
v2 = ml_tree_value_at_ex (
NULL, NULL,
scol->col->spec->compare_col,
md2->mi, sort_data->message_list);
g_ptr_array_add (md2->values, v2);
} else {
v2 = g_ptr_array_index (md2->values, i);
}
if (v1 != NULL && v2 != NULL) {
res = (*scol->col->compare) (v1, v2, sort_data->cmp_cache);
} else if (v1 != NULL || v2 != NULL) {
res = v1 == NULL ? -1 : 1;
}
if (scol->sort_type == GTK_SORT_DESCENDING)
res = res * (-1);
}
if (res == 0)
res = camel_folder_cmp_uids (sort_data->folder, uid1, uid2);
return res;
}
static void
free_message_info_data (gpointer uid,
struct sort_message_info_data *data,
struct sort_array_data *sort_data)
{
if (data->values) {
/* values in this array are not newly allocated, even ml_tree_value_at_ex
* returns gpointer, not a gconstpointer */
g_ptr_array_free (data->values, TRUE);
}
camel_folder_free_message_info (sort_data->folder, data->mi);
g_free (data);
}
static void
ml_sort_uids_by_tree (MessageList *message_list,
GPtrArray *uids,
GCancellable *cancellable)
{
ETreeTableAdapter *adapter;
ETableSortInfo *sort_info;
ETableHeader *full_header;
CamelFolder *folder;
struct sort_array_data sort_data;
guint i, len;
if (g_cancellable_is_cancelled (cancellable))
return;
g_return_if_fail (uids != NULL);
folder = message_list_ref_folder (message_list);
g_return_if_fail (folder != NULL);
adapter = e_tree_get_table_adapter (E_TREE (message_list));
g_return_if_fail (adapter != NULL);
sort_info = e_tree_table_adapter_get_sort_info (adapter);
full_header = e_tree_table_adapter_get_header (adapter);
if (!sort_info || uids->len == 0 || !full_header || e_table_sort_info_sorting_get_count (sort_info) == 0) {
camel_folder_sort_uids (folder, uids);
g_object_unref (folder);
return;
}
len = e_table_sort_info_sorting_get_count (sort_info);
sort_data.message_list = message_list;
sort_data.folder = folder;
sort_data.sort_columns = g_ptr_array_sized_new (len);
sort_data.message_infos = g_hash_table_new (g_str_hash, g_str_equal);
sort_data.cmp_cache = e_table_sorting_utils_create_cmp_cache ();
sort_data.cancellable = cancellable;
for (i = 0;
i < len
&& !g_cancellable_is_cancelled (cancellable);
i++) {
ETableColumnSpecification *spec;
struct sort_column_data *data;
data = g_new0 (struct sort_column_data, 1);
spec = e_table_sort_info_sorting_get_nth (
sort_info, i, &data->sort_type);
data->col = e_table_header_get_column_by_spec (full_header, spec);
if (data->col == NULL) {
gint last = e_table_header_count (full_header) - 1;
data->col = e_table_header_get_column (full_header, last);
}
g_ptr_array_add (sort_data.sort_columns, data);
}
camel_folder_summary_prepare_fetch_all (folder->summary, NULL);
for (i = 0;
i < uids->len
&& !g_cancellable_is_cancelled (cancellable);
i++) {
gchar *uid;
CamelMessageInfo *mi;
struct sort_message_info_data *md;
uid = g_ptr_array_index (uids, i);
mi = camel_folder_get_message_info (folder, uid);
if (mi == NULL) {
g_warning (
"%s: Cannot find uid '%s' in folder '%s'",
G_STRFUNC, uid,
camel_folder_get_full_name (folder));
continue;
}
md = g_new0 (struct sort_message_info_data, 1);
md->mi = mi;
md->values = g_ptr_array_sized_new (len);
g_hash_table_insert (sort_data.message_infos, uid, md);
}
if (!g_cancellable_is_cancelled (cancellable))
g_qsort_with_data (
uids->pdata,
uids->len,
sizeof (gpointer),
cmp_array_uids,
&sort_data);
camel_folder_summary_unlock (folder->summary, CAMEL_FOLDER_SUMMARY_SUMMARY_LOCK);
/* FIXME Teach the hash table to destroy its own data. */
g_hash_table_foreach (
sort_data.message_infos,
(GHFunc) free_message_info_data,
&sort_data);
g_hash_table_destroy (sort_data.message_infos);
g_ptr_array_foreach (sort_data.sort_columns, (GFunc) g_free, NULL);
g_ptr_array_free (sort_data.sort_columns, TRUE);
e_table_sorting_utils_free_cmp_cache (sort_data.cmp_cache);
g_object_unref (folder);
}
static void
message_list_regen_tweak_search_results (MessageList *message_list,
GPtrArray *search_results,
CamelFolder *folder,
gboolean folder_changed,
gboolean show_deleted,
gboolean show_junk)
{
CamelMessageInfo *info;
CamelMessageFlags flags;
const gchar *uid;
gboolean needs_tweaking;
gboolean uid_is_deleted;
gboolean uid_is_junk;
gboolean add_uid;
guint ii;
/* If we're responding to a "folder-changed" signal, then the
* displayed message may not be included in the search results.
* Include the displayed message anyway so it doesn't suddenly
* disappear while the user is reading it. */
needs_tweaking =
(folder_changed && message_list->cursor_uid != NULL);
if (!needs_tweaking)
return;
uid = message_list->cursor_uid;
/* Scan the search results for a particular UID.
* If found then the results don't need tweaked. */
for (ii = 0; ii < search_results->len; ii++) {
if (g_str_equal (uid, search_results->pdata[ii]))
return;
}
info = camel_folder_get_message_info (folder, uid);
/* XXX Should we emit a runtime warning here? */
if (info == NULL)
return;
flags = camel_message_info_flags (info);
uid_is_deleted = ((flags & CAMEL_MESSAGE_DELETED) != 0);
uid_is_junk = ((flags & CAMEL_MESSAGE_JUNK) != 0);
if (!folder_store_supports_vjunk_folder (folder))
uid_is_junk = FALSE;
add_uid =
(!uid_is_junk || show_junk) &&
(!uid_is_deleted || show_deleted);
if (add_uid)
g_ptr_array_add (
search_results,
(gpointer) camel_pstring_strdup (uid));
camel_folder_free_message_info (folder, info);
}
static void
message_list_regen_thread (GSimpleAsyncResult *simple,
GObject *source_object,
GCancellable *cancellable)
{
MessageList *message_list;
RegenData *regen_data;
GPtrArray *uids, *searchuids = NULL;
CamelMessageInfo *info;
CamelFolder *folder;
GNode *cursor;
ETree *tree;
GString *expr;
gboolean hide_deleted;
gboolean hide_junk;
GError *local_error = NULL;
message_list = MESSAGE_LIST (source_object);
regen_data = g_simple_async_result_get_op_res_gpointer (simple);
if (g_cancellable_is_cancelled (cancellable))
return;
/* Just for convenience. */
folder = g_object_ref (regen_data->folder);
hide_junk = message_list_get_hide_junk (message_list, folder);
hide_deleted = message_list_get_hide_deleted (message_list, folder);
tree = E_TREE (message_list);
cursor = e_tree_get_cursor (tree);
if (cursor != NULL)
regen_data->last_row =
e_tree_table_adapter_row_of_node (
e_tree_get_table_adapter (tree), cursor);
/* Construct the search expression. */
expr = g_string_new ("");
if (hide_deleted && hide_junk) {
g_string_append_printf (
expr, "(match-all (and %s %s))",
EXCLUDE_DELETED_MESSAGES_EXPR,
EXCLUDE_JUNK_MESSAGES_EXPR);
} else if (hide_deleted) {
g_string_append_printf (
expr, "(match-all %s)",
EXCLUDE_DELETED_MESSAGES_EXPR);
} else if (hide_junk) {
g_string_append_printf (
expr, "(match-all %s)",
EXCLUDE_JUNK_MESSAGES_EXPR);
}
if (regen_data->search != NULL) {
if (expr->len == 0) {
g_string_assign (expr, regen_data->search);
} else {
g_string_prepend (expr, "(and ");
g_string_append_c (expr, ' ');
g_string_append (expr, regen_data->search);
g_string_append_c (expr, ')');
}
}
/* Execute the search. */
if (expr->len == 0) {
uids = camel_folder_get_uids (folder);
} else {
uids = camel_folder_search_by_expression (
folder, expr->str, cancellable, &local_error);
/* XXX This indicates we need to use a different
* "free UID" function for some dumb reason. */
searchuids = uids;
if (uids != NULL)
message_list_regen_tweak_search_results (
message_list,
uids, folder,
regen_data->folder_changed,
!hide_deleted,
!hide_junk);
}
g_string_free (expr, TRUE);
/* Handle search error or cancellation. */
if (local_error == NULL)
g_cancellable_set_error_if_cancelled (
cancellable, &local_error);
if (local_error != NULL) {
g_simple_async_result_take_error (simple, local_error);
goto exit;
}
/* XXX This check might not be necessary. A successfully completed
* search with no results should return an empty UID array, but
* still need to verify that. */
if (uids == NULL)
goto exit;
/* update/build a new tree */
if (regen_data->group_by_threads) {
CamelFolderThread *thread_tree;
ml_sort_uids_by_tree (message_list, uids, cancellable);
thread_tree = message_list_ref_thread_tree (message_list);
if (thread_tree != NULL)
camel_folder_thread_messages_apply (thread_tree, uids);
else
thread_tree = camel_folder_thread_messages_new (
folder, uids, regen_data->thread_subject);
/* We will build the ETreeModel content from this
* CamelFolderThread during regen post-processing.
*
* We're committed at this point so keep our own
* reference in case the MessageList's reference
* gets invalidated before regen post-processing. */
regen_data->thread_tree = thread_tree;
} else {
guint ii;
camel_folder_sort_uids (folder, uids);
regen_data->summary = g_ptr_array_new ();
camel_folder_summary_prepare_fetch_all (folder->summary, NULL);
for (ii = 0; ii < uids->len; ii++) {
const gchar *uid;
uid = g_ptr_array_index (uids, ii);
info = camel_folder_get_message_info (folder, uid);
if (info != NULL)
g_ptr_array_add (regen_data->summary, info);
}
}
exit:
if (searchuids != NULL)
camel_folder_search_free (folder, searchuids);
else if (uids != NULL)
camel_folder_free_uids (folder, uids);
g_object_unref (folder);
}
static void
message_list_regen_done_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
MessageList *message_list;
GSimpleAsyncResult *simple;
RegenData *regen_data;
EActivity *activity;
ETree *tree;
ETreeTableAdapter *adapter;
gboolean searching;
gint row_count;
GError *local_error = NULL;
message_list = MESSAGE_LIST (source_object);
simple = G_SIMPLE_ASYNC_RESULT (result);
regen_data = g_simple_async_result_get_op_res_gpointer (simple);
/* Withdraw our RegenData from the private struct, if it hasn't
* already been replaced. We have exclusive access to it now. */
g_mutex_lock (&message_list->priv->regen_lock);
if (message_list->priv->regen_data == regen_data) {
regen_data_unref (message_list->priv->regen_data);
message_list->priv->regen_data = NULL;
}
g_mutex_unlock (&message_list->priv->regen_lock);
activity = regen_data->activity;
g_simple_async_result_propagate_error (simple, &local_error);
if (e_activity_handle_cancellation (activity, local_error)) {
g_error_free (local_error);
return;
/* FIXME This should be handed off to an EAlertSink. */
} else if (local_error != NULL) {
g_warning ("%s: %s", G_STRFUNC, local_error->message);
g_error_free (local_error);
return;
}
e_activity_set_state (activity, E_ACTIVITY_COMPLETED);
tree = E_TREE (message_list);
adapter = e_tree_get_table_adapter (tree);
/* Show the cursor unless we're responding to a
* "folder-changed" signal from our CamelFolder. */
if (!regen_data->folder_changed)
e_tree_show_cursor_after_reflow (tree);
g_signal_handlers_block_by_func (
adapter, ml_tree_sorting_changed, message_list);
g_free (message_list->search);
message_list->search = g_strdup (regen_data->search);
searching =
(message_list->search != NULL) &&
(*message_list->search != '\0');
if (regen_data->group_by_threads) {
gboolean forcing_expand_state;
forcing_expand_state =
message_list->expand_all ||
message_list->collapse_all;
if (message_list->just_set_folder) {
message_list->just_set_folder = FALSE;
if (regen_data->expand_state != NULL) {
/* Load state from disk rather than use
* the memory data when changing folders. */
xmlFreeDoc (regen_data->expand_state);
regen_data->expand_state = NULL;
}
}
if (forcing_expand_state || searching) {
gint state;
if (message_list->expand_all || searching)
state = 1; /* force expand */
else
state = -1; /* force collapse */
e_tree_table_adapter_force_expanded_state (
adapter, state);
}
/* Show the cursor unless we're responding to a
* "folder-changed" signal from our CamelFolder. */
build_tree (
message_list,
regen_data->thread_tree,
regen_data->folder_changed);
message_list_set_thread_tree (
message_list, regen_data->thread_tree);
if (forcing_expand_state || searching) {
if (message_list->priv->folder != NULL &&
tree != NULL && !searching)
save_tree_state (
message_list,
regen_data->folder);
/* Disable forced expand/collapse state. */
e_tree_table_adapter_force_expanded_state (adapter, 0);
} else {
load_tree_state (
message_list,
regen_data->folder,
regen_data->expand_state);
}
message_list->expand_all = 0;
message_list->collapse_all = 0;
} else {
build_flat (
message_list,
regen_data->summary);
}
row_count = e_table_model_row_count (E_TABLE_MODEL (adapter));
if (regen_data->select_all) {
message_list_select_all (message_list);
} else if (regen_data->select_uid != NULL) {
message_list_select_uid (
message_list,
regen_data->select_uid,
regen_data->select_use_fallback);
} else if (message_list->cursor_uid == NULL && regen_data->last_row != -1) {
if (regen_data->last_row >= row_count)
regen_data->last_row = row_count;
if (regen_data->last_row >= 0) {
GNode *node;
node = e_tree_table_adapter_node_at_row (
adapter, regen_data->last_row);
if (node != NULL)
select_node (message_list, node);
}
}
if (gtk_widget_get_visible (GTK_WIDGET (message_list))) {
const gchar *info_message;
gboolean have_search_expr;
/* space is used to indicate no search too */
have_search_expr =
(message_list->search != NULL) &&
(*message_list->search != '\0') &&
(strcmp (message_list->search, " ") != 0);
if (row_count > 0) {
info_message = NULL;
} else if (have_search_expr) {
info_message =
_("No message satisfies your search criteria. "
"Change search criteria by selecting a new "
"Show message filter from the drop down list "
"above or by running a new search either by "
"clearing it with Search->Clear menu item or "
"by changing the query above.");
} else {
info_message =
_("There are no messages in this folder.");
}
e_tree_set_info_message (tree, info_message);
}
g_signal_handlers_unblock_by_func (
adapter, ml_tree_sorting_changed, message_list);
g_signal_emit (
message_list,
signals[MESSAGE_LIST_BUILT], 0);
message_list->priv->any_row_changed = FALSE;
}
static gboolean
message_list_regen_idle_cb (gpointer user_data)
{
GSimpleAsyncResult *simple;
RegenData *regen_data;
GCancellable *cancellable;
MessageList *message_list;
ETreeTableAdapter *adapter;
gboolean searching;
gint row_count;
simple = G_SIMPLE_ASYNC_RESULT (user_data);
regen_data = g_simple_async_result_get_op_res_gpointer (simple);
cancellable = e_activity_get_cancellable (regen_data->activity);
message_list = regen_data->message_list;
g_mutex_lock (&message_list->priv->regen_lock);
/* Capture MessageList state to use for this regen. */
regen_data->folder =
message_list_ref_folder (message_list);
regen_data->group_by_threads =
message_list_get_group_by_threads (message_list);
regen_data->thread_subject =
message_list_get_thread_subject (message_list);
searching = (g_strcmp0 (message_list->search, " ") != 0);
adapter = e_tree_get_table_adapter (E_TREE (message_list));
row_count = e_table_model_row_count (E_TABLE_MODEL (adapter));
if (row_count <= 0) {
if (gtk_widget_get_visible (GTK_WIDGET (message_list))) {
gchar *txt;
txt = g_strdup_printf (
"%s...", _("Generating message list"));
e_tree_set_info_message (E_TREE (message_list), txt);
g_free (txt);
}
} else if (regen_data->group_by_threads &&
!message_list->just_set_folder &&
!searching) {
if (message_list->priv->any_row_changed) {
/* Something changed. If it was an expand
* state change, then save the expand state. */
message_list_save_state (message_list);
} else {
/* Remember the expand state and restore it
* after regen. */
regen_data->expand_state =
e_tree_table_adapter_save_expanded_state_xml (
adapter);
}
}
message_list->priv->regen_idle_id = 0;
g_mutex_unlock (&message_list->priv->regen_lock);
if (g_cancellable_is_cancelled (cancellable)) {
g_simple_async_result_complete (simple);
} else {
g_simple_async_result_run_in_thread (
simple,
message_list_regen_thread,
G_PRIORITY_DEFAULT,
cancellable);
}
return FALSE;
}
static void
mail_regen_cancel (MessageList *message_list)
{
RegenData *regen_data = NULL;
g_mutex_lock (&message_list->priv->regen_lock);
if (message_list->priv->regen_data != NULL)
regen_data = regen_data_ref (message_list->priv->regen_data);
if (message_list->priv->regen_idle_id > 0) {
g_source_remove (message_list->priv->regen_idle_id);
message_list->priv->regen_idle_id = 0;
}
g_mutex_unlock (&message_list->priv->regen_lock);
/* Cancel outside the lock, since this will emit a signal. */
if (regen_data != NULL) {
e_activity_cancel (regen_data->activity);
regen_data_unref (regen_data);
}
}
static void
mail_regen_list (MessageList *message_list,
const gchar *search,
gboolean folder_changed)
{
GSimpleAsyncResult *simple;
GCancellable *cancellable;
RegenData *new_regen_data;
RegenData *old_regen_data;
/* Report empty search as NULL, not as one/two-space string. */
if (search && (strcmp (search, " ") == 0 || strcmp (search, " ") == 0))
search = NULL;
/* Can't list messages in a folder until we have a folder. */
if (message_list->priv->folder == NULL) {
g_free (message_list->search);
message_list->search = g_strdup (search);
return;
}
g_mutex_lock (&message_list->priv->regen_lock);
old_regen_data = message_list->priv->regen_data;
/* If a regen is scheduled but not yet started, just
* apply the argument values without cancelling it. */
if (message_list->priv->regen_idle_id > 0) {
g_return_if_fail (old_regen_data != NULL);
if (g_strcmp0 (search, old_regen_data->search) != 0) {
g_free (old_regen_data->search);
old_regen_data->search = g_strdup (search);
}
old_regen_data->folder_changed = folder_changed;
/* Avoid cancelling on the way out. */
old_regen_data = NULL;
goto exit;
}
cancellable = g_cancellable_new ();
new_regen_data = regen_data_new (message_list, cancellable);
new_regen_data->search = g_strdup (search);
new_regen_data->folder_changed = folder_changed;
/* We generate the message list content in a worker thread, and
* then supply our own GAsyncReadyCallback to redraw the widget. */
simple = g_simple_async_result_new (
G_OBJECT (message_list),
message_list_regen_done_cb,
NULL, mail_regen_list);
g_simple_async_result_set_check_cancellable (simple, cancellable);
g_simple_async_result_set_op_res_gpointer (
simple,
regen_data_ref (new_regen_data),
(GDestroyNotify) regen_data_unref);
/* Set the RegenData immediately, but start the actual regen
* operation from an idle callback. That way the caller has
* the remainder of this main loop iteration to make further
* MessageList changes without triggering additional regens. */
message_list->priv->regen_data = regen_data_ref (new_regen_data);
message_list->priv->regen_idle_id =
g_idle_add_full (
G_PRIORITY_DEFAULT_IDLE,
message_list_regen_idle_cb,
g_object_ref (simple),
(GDestroyNotify) g_object_unref);
g_object_unref (simple);
regen_data_unref (new_regen_data);
g_object_unref (cancellable);
exit:
g_mutex_unlock (&message_list->priv->regen_lock);
/* Cancel outside the lock, since this will emit a signal. */
if (old_regen_data != NULL) {
e_activity_cancel (old_regen_data->activity);
regen_data_unref (old_regen_data);
}
}