required) for bodystruct.
#include <clockd/libtime.h>
#endif
#include "modest-account-protocol.h"
+#include <camel/camel-stream-null.h>
#define KB 1024
gint last_total_bytes;
gint sum_total_bytes;
gint total_bytes;
+ TnyIterator *get_parts;
+ TnyMsg *msg;
} GetMsgInfo;
typedef struct _RefreshAsyncHelper {
update_account_notify_user_and_free (info, new_headers);
/* Delete the helper */
+ if (msg_info->msg)
+ g_object_unref (msg_info->msg);
g_object_unref (msg_info->more_msgs);
g_object_unref (msg_info->mail_op);
g_slice_free (GetMsgInfo, msg_info);
msg_info->mail_op = g_object_ref (info->mail_op);
msg_info->total_bytes = compute_message_list_size (new_headers, priv->total);
msg_info->more_msgs = g_object_ref (iter);
+ msg_info->msg = NULL;
msg_info->user_data = info;
while ((msg_num < priv->total ) && !tny_iterator_is_done (iter)) {
helper->sum_total_bytes = 0;
helper->total_bytes = 0;
helper->more_msgs = NULL;
+ helper->get_parts = NULL;
+ helper->msg = NULL;
modest_mail_operation_notify_start (self);
helper->sum_total_bytes = 0;
helper->total_bytes = tny_header_get_message_size (header);
helper->more_msgs = NULL;
+ helper->get_parts = NULL;
+ helper->msg = NULL;
+
+ modest_mail_operation_notify_start (self);
+
+ /* notify about the start of the operation */
+ ModestMailOperationState *state;
+ state = modest_mail_operation_clone_state (self);
+ state->done = 0;
+ state->total = 0;
+ g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL],
+ 0, state, NULL);
+ g_slice_free (ModestMailOperationState, state);
+
+ tny_folder_get_msg_async (folder, header, get_msg_async_cb, get_msg_status_cb, helper);
+
+ g_object_unref (G_OBJECT (folder));
+}
+
+void
+modest_mail_operation_get_msg_and_parts (ModestMailOperation *self,
+ TnyHeader *header,
+ TnyList *parts,
+ gboolean progress_feedback,
+ GetMsgAsyncUserCallback user_callback,
+ gpointer user_data)
+{
+ GetMsgInfo *helper = NULL;
+ TnyFolder *folder;
+ ModestMailOperationPrivate *priv;
+
+ g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
+ g_return_if_fail (TNY_IS_HEADER (header));
+
+ priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
+ priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
+ priv->total = 1;
+ priv->done = 0;
+
+ /* Check memory low */
+ if (_check_memory_low (self)) {
+ if (user_callback)
+ user_callback (self, header, FALSE, NULL, priv->error, user_data);
+ modest_mail_operation_notify_end (self);
+ return;
+ }
+
+ /* Get account and set it into mail_operation */
+ folder = tny_header_get_folder (header);
+ priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
+
+ /* Check for cached messages */
+ if (progress_feedback) {
+ if (tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED)
+ priv->op_type = MODEST_MAIL_OPERATION_TYPE_OPEN;
+ else
+ priv->op_type = MODEST_MAIL_OPERATION_TYPE_RECEIVE;
+ } else {
+ priv->op_type = MODEST_MAIL_OPERATION_TYPE_UNKNOWN;
+ }
+
+ /* Create the helper */
+ helper = g_slice_new0 (GetMsgInfo);
+ helper->header = g_object_ref (header);
+ helper->mail_op = g_object_ref (self);
+ helper->user_callback = user_callback;
+ helper->user_data = user_data;
+ helper->destroy_notify = NULL;
+ helper->last_total_bytes = 0;
+ helper->sum_total_bytes = 0;
+ helper->total_bytes = tny_header_get_message_size (header);
+ helper->more_msgs = NULL;
+ helper->get_parts = tny_list_create_iterator (parts);
+ helper->msg = NULL;
modest_mail_operation_notify_start (self);
}
static void
+get_msg_async_get_part_cb (TnyMimePart *self, gboolean cancelled, TnyStream *stream, GError *err, gpointer user_data)
+{
+ GetMsgInfo *helper;
+ TnyFolder *folder = NULL;
+
+ helper = (GetMsgInfo *) user_data;
+
+ if (helper->header) {
+ folder = tny_header_get_folder (helper->header);
+ }
+
+ get_msg_async_cb (folder, cancelled, helper->msg, err, user_data);
+
+ if (folder) g_object_unref (folder);
+}
+
+static void
get_msg_async_cb (TnyFolder *folder,
gboolean canceled,
TnyMsg *msg,
if (info->more_msgs) {
tny_iterator_next (info->more_msgs);
finished = (tny_iterator_is_done (info->more_msgs));
+ } else if (info->get_parts) {
+ tny_iterator_next (info->get_parts);
+ finished = (tny_iterator_is_done (info->get_parts));
} else {
finished = (priv->done == priv->total) ? TRUE : FALSE;
}
info->header = tny_msg_get_header (msg);
/* Call the user callback */
- if (info->user_callback)
+ if (info->user_callback && (finished || (info->get_parts == NULL)))
info->user_callback (info->mail_op, info->header, canceled,
msg, err, info->user_data);
modest_mail_operation_notify_end (info->mail_op);
/* Clean */
+ if (info->msg)
+ g_object_unref (info->msg);
if (info->more_msgs)
g_object_unref (info->more_msgs);
if (info->header)
g_object_unref (info->header);
g_object_unref (info->mail_op);
g_slice_free (GetMsgInfo, info);
+ } else if (info->get_parts) {
+ CamelStream *null_stream;
+ TnyStream *tny_null_stream;
+ TnyMimePart *part;
+
+ if (info->msg == NULL && msg != NULL)
+ info->msg = g_object_ref (msg);
+
+ null_stream = camel_stream_null_new ();
+ tny_null_stream = tny_camel_stream_new (null_stream);
+
+ part = TNY_MIME_PART (tny_iterator_get_current (info->get_parts));
+ tny_mime_part_decode_to_stream_async (part, tny_null_stream,
+ get_msg_async_get_part_cb,
+ get_msg_status_cb,
+ info);
+ g_object_unref (tny_null_stream);
+ g_object_unref (part);
+
} else if (info->more_msgs) {
TnyHeader *header = TNY_HEADER (tny_iterator_get_current (info->more_msgs));
TnyFolder *folder = tny_header_get_folder (header);
msg_info->last_total_bytes = 0;
msg_info->sum_total_bytes = 0;
msg_info->total_bytes = msg_list_size;
+ msg_info->msg = NULL;
/* The callback will call it per each header */
tny_folder_get_msg_async (folder, header, get_msg_async_cb, get_msg_status_cb, msg_info);
gboolean remove_to_trash);
/**
+ * modest_mail_operation_get_msg_and_parts:
+ * @self: a #ModestMailOperation
+ * @header_list: the #TnyHeader of the message to get
+ * @progress_feedback: a #gboolean. If %TRUE, we'll get progress bar feedback.
+ * @user_callback: a #GetMsgAsyncUserCallback function to call after tinymail callback execution.
+ * @user_data: generic user data which will be passed to @user_callback function.
+ *
+ * Gets a message from header using an user defined @callback function
+ * pased as argument. This operation is asynchronous, so the
+ * #ModestMailOperation should be added to #ModestMailOperationQueue
+ *
+ * This operation also retrieves to cache all parts of the message. This is needed for
+ * forward operation.
+ **/
+void modest_mail_operation_get_msg_and_parts (ModestMailOperation *self,
+ TnyHeader *header,
+ TnyList *parts,
+ gboolean progress_feedback,
+ GetMsgAsyncUserCallback user_callback,
+ gpointer user_data);
+/**
* modest_mail_operation_get_msg:
* @self: a #ModestMailOperation
* @header_list: the #TnyHeader of the message to get
#include <tny-msg-view.h>
#include <tny-device.h>
#include <tny-merge-folder.h>
+#include <tny-camel-bs-msg.h>
+#include <tny-camel-bs-mime-part.h>
#include <gtkhtml/gtkhtml.h>
gchar *mailbox;
GtkWidget *parent_window;
TnyHeader *header;
+ TnyList *parts;
} ReplyForwardHelper;
typedef struct _MoveToHelper {
create_reply_forward_helper (ReplyForwardAction action,
ModestWindow *win,
guint reply_forward_type,
- TnyHeader *header)
+ TnyHeader *header,
+ TnyList *parts)
{
ReplyForwardHelper *rf_helper = NULL;
const gchar *active_acc = modest_window_get_active_account (win);
g_strdup (active_acc) :
modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
rf_helper->mailbox = g_strdup (active_mailbox);
+ if (parts)
+ rf_helper->parts = g_object_ref (parts);
+ else
+ rf_helper->parts = NULL;
/* Note that window could be destroyed just AFTER calling
register_window so we must ensure that this pointer does
g_free (helper->mailbox);
if (helper->header)
g_object_unref (helper->header);
+ if (helper->parts)
+ g_object_unref (helper->parts);
if (helper->parent_window)
g_object_weak_unref (G_OBJECT (helper->parent_window),
rf_helper_window_closed, helper);
modest_ui_actions_disk_operations_error_handler,
NULL, NULL);
modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
- modest_mail_operation_get_msg (mail_op, rf_helper->header, TRUE, reply_forward_cb, rf_helper);
+ modest_mail_operation_get_msg_and_parts (mail_op, rf_helper->header, rf_helper->parts, TRUE, reply_forward_cb, rf_helper);
/* Frees */
g_object_unref(mail_op);
}
+static gboolean
+all_parts_retrieved (TnyMimePart *part)
+{
+ if (!TNY_IS_CAMEL_BS_MIME_PART (part)) {
+ return TRUE;
+ } else {
+ TnyList *pending_parts;
+ TnyIterator *iterator;
+ gboolean all_retrieved = TRUE;
+
+ pending_parts = TNY_LIST (tny_simple_list_new ());
+ tny_mime_part_get_parts (part, pending_parts);
+ iterator = tny_list_create_iterator (pending_parts);
+ while (all_retrieved && !tny_iterator_is_done (iterator)) {
+ TnyMimePart *child;
+
+ child = TNY_MIME_PART (tny_iterator_get_current (iterator));
+
+ if (tny_camel_bs_mime_part_is_fetched (TNY_CAMEL_BS_MIME_PART (child))) {
+ all_retrieved = all_parts_retrieved (TNY_MIME_PART (child));
+ } else {
+ all_retrieved = FALSE;
+ }
+
+ g_object_unref (child);
+ tny_iterator_next (iterator);
+ }
+ g_object_unref (iterator);
+ g_object_unref (pending_parts);
+ return all_retrieved;
+ }
+}
+
+static void
+forward_pending_parts_helper (TnyMimePart *part, TnyList *list)
+{
+ TnyList *parts;
+ TnyIterator *iterator;
+
+ if (!tny_camel_bs_mime_part_is_fetched (TNY_CAMEL_BS_MIME_PART (part))) {
+ tny_list_append (list, G_OBJECT (part));
+ }
+ parts = TNY_LIST (tny_simple_list_new ());
+ tny_mime_part_get_parts (part, parts);
+ for (iterator = tny_list_create_iterator (parts);
+ !tny_iterator_is_done (iterator);
+ tny_iterator_next (iterator)) {
+ TnyMimePart *child;
+
+ child = TNY_MIME_PART (tny_iterator_get_current (iterator));
+ forward_pending_parts_helper (child, list);
+ g_object_unref (child);
+ }
+ g_object_unref (iterator);
+ g_object_unref (parts);
+}
+
+static TnyList *
+forward_pending_parts (TnyMsg *msg)
+{
+ TnyList *result = TNY_LIST (tny_simple_list_new ());
+ if (TNY_IS_CAMEL_BS_MIME_PART (msg)) {
+ forward_pending_parts_helper (TNY_MIME_PART (msg), result);
+ }
+
+ return result;
+}
+
/*
* Common code for the reply and forward actions
*/
msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW(win));
header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
- if (msg && header) {
+ if (msg && header && (action != ACTION_FORWARD || all_parts_retrieved (TNY_MIME_PART (msg)))) {
/* Create helper */
rf_helper = create_reply_forward_helper (action, win,
- reply_forward_type, header);
+ reply_forward_type, header, NULL);
reply_forward_cb (NULL, header, FALSE, msg, NULL, rf_helper);
} else {
- g_warning("%s: no message or header found in viewer\n", __FUNCTION__);
+ gboolean do_download = TRUE;
+
+ if (msg && header && action == ACTION_FORWARD) {
+ /* Not all parts retrieved. Then we have to retrieve them all before
+ * creating the forward message */
+ if (!tny_device_is_online (modest_runtime_get_device ())) {
+ gint response;
+
+ /* If ask for user permission to download the messages */
+ response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
+ ngettext("mcen_nc_get_msg",
+ "mcen_nc_get_msgs",
+ 1));
+
+ /* End if the user does not want to continue */
+ if (response == GTK_RESPONSE_CANCEL)
+ do_download = FALSE;
+ }
+
+ if (do_download) {
+ TnyList *pending_parts;
+ TnyFolder *folder;
+ TnyAccount *account;
+
+ /* Create helper */
+ pending_parts = forward_pending_parts (msg);
+ rf_helper = create_reply_forward_helper (action, win,
+ reply_forward_type, header, pending_parts);
+ g_object_unref (pending_parts);
+
+ folder = tny_header_get_folder (header);
+ account = tny_folder_get_account (folder);
+ modest_platform_connect_and_perform (GTK_WINDOW (win),
+ TRUE, account,
+ reply_forward_performer,
+ rf_helper);
+ g_object_unref (folder);
+ g_object_unref (account);
+ }
+
+ } else {
+ g_warning("%s: no message or header found in viewer\n", __FUNCTION__);
+ }
}
if (msg)
if (download) {
/* Create helper */
rf_helper = create_reply_forward_helper (action, win,
- reply_forward_type, header);
+ reply_forward_type, header, NULL);
if (uncached_msgs > 0) {
modest_platform_connect_and_perform (GTK_WINDOW (win),
TRUE, account,
projects / modest / commitdiff