#include <clockd/libtime.h>
#endif
#include "modest-account-protocol.h"
+#include <camel/camel-stream-null.h>
+#include <widgets/modest-msg-view-window.h>
#define KB 1024
TnyFolderObserver *inbox_observer;
gboolean interactive;
gboolean msg_readed;
+ gboolean update_folder_counts;
} UpdateAccountInfo;
static void destroy_update_account_info (UpdateAccountInfo *info);
gint last_total_bytes;
gint sum_total_bytes;
gint total_bytes;
+ TnyIterator *get_parts;
+ TnyMsg *msg;
} GetMsgInfo;
typedef struct _RefreshAsyncHelper {
gpointer user_data;
} XFerFolderAsyncHelper;
+typedef struct _SyncFolderHelper {
+ ModestMailOperation *mail_op;
+ SyncFolderCallback user_callback;
+ gpointer user_data;
+} SyncFolderHelper;
+
typedef void (*ModestMailOperationCreateMsgCallback) (ModestMailOperation *mail_op,
TnyMsg *msg,
gpointer userdata);
const GList *images_list,
TnyHeaderFlags priority_flags,
const gchar *references, const gchar *in_reply_to,
+ TnyList *header_pairs,
ModestMailOperationCreateMsgCallback callback,
gpointer userdata);
GList *attachments_list;
GList *images_list;
TnyHeaderFlags priority_flags;
+ TnyList *header_pairs;
ModestMailOperationCreateMsgCallback callback;
gpointer userdata;
} CreateMsgInfo;
info->references, info->in_reply_to,
info->plain_body,
info->attachments_list, &attached,
+ info->header_pairs,
&(priv->error));
} else {
new_msg = modest_tny_msg_new_html_plain (info->to, info->from, info->cc,
info->html_body,
info->plain_body, info->attachments_list,
info->images_list, &attached,
+ info->header_pairs,
&(priv->error));
}
if (new_msg) {
- TnyHeader *header;
+ TnyHeader *header = tny_msg_get_header (new_msg);
/* Set priority flags in message */
- header = tny_msg_get_header (new_msg);
- tny_header_set_flag (header, info->priority_flags);
+ if (info->priority_flags != TNY_HEADER_FLAG_NORMAL_PRIORITY)
+ tny_header_set_flag (header, info->priority_flags);
/* Set attachment flags in message */
if (info->attachments_list != NULL && attached > 0)
g_list_free (info->attachments_list);
g_list_foreach (info->images_list, (GFunc) g_object_unref, NULL);
g_list_free (info->images_list);
+ g_object_unref (info->header_pairs);
if (info->callback) {
CreateMsgIdleInfo *idle_info;
TnyHeaderFlags priority_flags,
const gchar *references,
const gchar *in_reply_to,
+ TnyList *header_pairs,
ModestMailOperationCreateMsgCallback callback,
gpointer userdata)
{
g_list_foreach (info->attachments_list, (GFunc) g_object_ref, NULL);
info->images_list = g_list_copy ((GList *) images_list);
g_list_foreach (info->images_list, (GFunc) g_object_ref, NULL);
- info->priority_flags = priority_flags;
+ info->priority_flags = 0 | priority_flags;
+ info->header_pairs = tny_list_copy (header_pairs);
info->callback = callback;
info->userdata = userdata;
}
void
+modest_mail_operation_send_mail (ModestMailOperation *self,
+ TnyTransportAccount *transport_account,
+ TnyMsg *msg)
+{
+ TnySendQueue *send_queue = NULL;
+ ModestMailOperationPrivate *priv = NULL;
+
+ priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
+
+ if (!msg) {
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+ modest_mail_operation_notify_end (self);
+ return;
+ }
+
+ if (priv->error && priv->error->code != MODEST_MAIL_OPERATION_ERROR_FILE_IO) {
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+ modest_mail_operation_notify_end (self);
+ return;
+ }
+
+ /* Add message to send queue */
+ send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account, TRUE));
+ if (!TNY_IS_SEND_QUEUE(send_queue)) {
+ if (priv->error) {
+ g_error_free (priv->error);
+ priv->error = NULL;
+ }
+ g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
+ MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
+ "modest: could not find send queue for account\n");
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+ modest_mail_operation_notify_end (self);
+ return;
+ } else {
+ SendNewMailHelper *helper = g_slice_new (SendNewMailHelper);
+ helper->mail_op = g_object_ref (self);
+ helper->notify = TRUE;
+
+ /* Add the msg to the queue. The callback will free
+ the helper */
+ modest_tny_send_queue_set_requested_send_receive (MODEST_TNY_SEND_QUEUE (send_queue),
+ FALSE);
+ tny_send_queue_add_async (send_queue, msg, send_mail_on_added_to_outbox,
+ NULL, helper);
+ }
+
+}
+
+void
modest_mail_operation_send_new_mail (ModestMailOperation *self,
TnyTransportAccount *transport_account,
TnyMsg *draft_msg,
const GList *images_list,
const gchar *references,
const gchar *in_reply_to,
- TnyHeaderFlags priority_flags)
+ TnyHeaderFlags priority_flags,
+ TnyList *header_pairs)
{
ModestMailOperationPrivate *priv = NULL;
SendNewMailInfo *info;
modest_mail_operation_create_msg (self, from, to, cc, bcc, subject, plain_body, html_body,
attachments_list, images_list, priority_flags,
references, in_reply_to,
+ header_pairs,
modest_mail_operation_send_new_mail_cb, info);
}
TnyHeaderFlags priority_flags,
const gchar *references,
const gchar *in_reply_to,
+ TnyList *header_pairs,
SaveToDraftstCallback callback,
gpointer user_data)
{
modest_mail_operation_create_msg (self, from, to, cc, bcc, subject, plain_body, html_body,
attachments_list, images_list, priority_flags,
references, in_reply_to,
+ header_pairs,
modest_mail_operation_save_to_drafts_cb, info);
}
TnyTransportAccount *transport_account = NULL;
ModestTnyAccountStore *account_store;
+ if (info->update_folder_counts)
+ return;
+
account_store = modest_runtime_get_account_store ();
/* We don't try to send messages while sending mails is blocked */
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);
ModestMailOperationPrivate *priv;
TnyIterator *new_headers_iter;
GPtrArray *new_headers_array = NULL;
- gint max_size, retrieve_limit, i;
+ gint max_size = G_MAXINT, retrieve_limit, i;
ModestAccountMgr *mgr;
ModestAccountRetrieveType retrieve_type;
TnyList *new_headers = NULL;
goto send_mail;
}
- /* Set the last updated as the current time */
+ if (!info->update_folder_counts) {
+ /* Set the last updated as the current time */
#ifdef MODEST_USE_LIBTIME
- struct tm utc_tm;
- time_get_utc (&utc_tm);
- time_to_store = time_mktime (&utc_tm, "GMT");
+ struct tm utc_tm;
+ time_get_utc (&utc_tm);
+ time_to_store = time_mktime (&utc_tm, "GMT");
#else
- time_to_store = time (NULL);
+ time_to_store = time (NULL);
#endif
- modest_account_mgr_set_last_updated (mgr, tny_account_get_id (priv->account), time_to_store);
+ modest_account_mgr_set_last_updated (mgr, tny_account_get_id (priv->account), time_to_store);
- /* Get the message max size */
- max_size = modest_conf_get_int (modest_runtime_get_conf (),
- MODEST_CONF_MSG_SIZE_LIMIT, NULL);
- if (max_size == 0)
- max_size = G_MAXINT;
- else
- max_size = max_size * KB;
+ /* Get the message max size */
+ max_size = modest_conf_get_int (modest_runtime_get_conf (),
+ MODEST_CONF_MSG_SIZE_LIMIT, NULL);
+ if (max_size == 0)
+ max_size = G_MAXINT;
+ else
+ max_size = max_size * KB;
+ }
/* Create the new headers array. We need it to sort the
new headers by date */
new_headers_array = g_ptr_array_new ();
if (info->inbox_observer) {
new_headers_iter = tny_list_create_iterator (((InternalFolderObserver *) info->inbox_observer)->new_headers);
+ if (!tny_iterator_is_done (new_headers_iter)) {
+ modest_platform_emit_folder_updated_signal (info->account_name, tny_folder_get_id (TNY_FOLDER (inbox)));
+ modest_account_mgr_set_has_new_mails (modest_runtime_get_account_mgr (),
+ info->account_name, TRUE);
+ }
while (!tny_iterator_is_done (new_headers_iter)) {
TnyHeader *header = NULL;
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)) {
folder = TNY_FOLDER (tny_iterator_get_current (iter_all_folders));
- if (tny_folder_get_folder_type (folder) == TNY_FOLDER_TYPE_INBOX) {
+ if (!info->update_folder_counts && tny_folder_get_folder_type (folder) == TNY_FOLDER_TYPE_INBOX) {
/* Get a reference to the INBOX */
inbox = g_object_ref (folder);
} else {
info->mail_op = g_object_ref (self);
info->poke_all = poke_all;
info->interactive = interactive;
+ info->update_folder_counts = FALSE;
info->account_name = g_strdup (account_name);
info->callback = callback;
info->user_data = user_data;
}
+void
+modest_mail_operation_update_folder_counts (ModestMailOperation *self,
+ const gchar *account_name)
+{
+ UpdateAccountInfo *info = NULL;
+ ModestMailOperationPrivate *priv = NULL;
+ ModestTnyAccountStore *account_store = NULL;
+ TnyList *folders;
+ ModestMailOperationState *state;
+
+ /* Init mail operation */
+ priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
+ priv->total = 0;
+ priv->done = 0;
+ priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
+ priv->op_type = MODEST_MAIL_OPERATION_TYPE_UPDATE_FOLDER_COUNTS;
+
+ /* Get the store account */
+ account_store = modest_runtime_get_account_store ();
+ priv->account =
+ modest_tny_account_store_get_server_account (account_store,
+ account_name,
+ TNY_ACCOUNT_TYPE_STORE);
+
+ /* The above function could return NULL */
+ if (!priv->account) {
+ /* Check if the operation was a success */
+ g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
+ MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
+ "no account");
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+
+ /* Notify about operation end */
+ modest_mail_operation_notify_end (self);
+
+ return;
+ }
+
+ /* We have once seen priv->account getting finalized during this code,
+ * therefore adding a reference (bug #82296) */
+
+ g_object_ref (priv->account);
+
+ /* Create the helper object */
+ info = g_slice_new0 (UpdateAccountInfo);
+ info->pending_calls = 1;
+ info->folders = tny_simple_list_new ();
+ info->mail_op = g_object_ref (self);
+ info->poke_all = TRUE;
+ info->interactive = FALSE;
+ info->update_folder_counts = TRUE;
+ info->account_name = g_strdup (account_name);
+ info->callback = NULL;
+ info->user_data = NULL;
+
+ /* Set account busy */
+ modest_account_mgr_set_account_busy (modest_runtime_get_account_mgr (), account_name, TRUE);
+ modest_mail_operation_notify_start (self);
+
+ /* notify about the start of the operation */
+ state = modest_mail_operation_clone_state (self);
+ state->done = 0;
+ state->total = 0;
+
+ /* Start notifying progress */
+ g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
+ g_slice_free (ModestMailOperationState, state);
+
+ /* Get all folders and continue in the callback */
+ folders = tny_simple_list_new ();
+ tny_folder_store_get_folders_async (TNY_FOLDER_STORE (priv->account),
+ folders, NULL, TRUE,
+ recurse_folders_async_cb,
+ NULL, info);
+ g_object_unref (folders);
+
+ g_object_unref (priv->account);
+
+}
+
/*
* Used to notify the queue from the main
* loop. We call it inside an idle call to achieve that
priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS,
- _CS("ckdg_ib_folder_already_exists"));
+ _CS_FOLDER_ALREADY_EXISTS);
}
/* Check parent */
priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS,
- _CS("ckdg_ib_folder_already_exists"));
+ _CS_FOLDER_ALREADY_EXISTS);
return FALSE;
} else
return TRUE;
priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
- error_msg);
+ "%s", error_msg);
/* Call the user callback if exists */
if (user_callback)
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);
+ if (folder == NULL && MODEST_IS_MSG_VIEW_WINDOW (priv->source)) {
+ const gchar *acc_name;
+ acc_name = modest_window_get_active_account (MODEST_WINDOW (priv->source));
+ priv->account = modest_tny_account_store_get_server_account
+ (modest_runtime_get_account_store (),
+ acc_name,
+ TNY_ACCOUNT_TYPE_STORE);
+ folder = modest_tny_folder_store_find_folder_from_uri (TNY_FOLDER_STORE (priv->account),
+ modest_msg_view_window_get_message_uid (MODEST_MSG_VIEW_WINDOW (priv->source)));
+ } else {
+ 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;
}
} else {
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
- err->message);
+ "%s", err->message);
}
} else if (finished && priv->status == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS) {
/* Set the success status before calling the user callback */
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);
GError *err,
gpointer user_data)
{
- gboolean expunge, leave_on_server;
+ gboolean expunge;
const gchar *account_name;
TnyAccount *account;
ModestProtocolType account_proto = MODEST_PROTOCOL_REGISTRY_TYPE_INVALID;
ModestMailOperation *self;
ModestMailOperationPrivate *priv;
ModestProtocolRegistry *protocol_registry;
+ SyncFolderHelper *helper;
self = (ModestMailOperation *) user_data;
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
account = modest_tny_folder_get_account (folder);
account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (account);
- leave_on_server =
- modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
- account_name);
account_proto = modest_tny_account_get_protocol_type (account);
g_object_unref (account);
- if ((modest_protocol_registry_protocol_type_has_leave_on_server (protocol_registry, account_proto) &&
- !leave_on_server) ||
- !modest_tny_folder_is_remote_folder (folder))
+ if (modest_protocol_registry_protocol_type_has_leave_on_server (protocol_registry, account_proto)) {
+ if (modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
+ account_name))
+ expunge = FALSE;
+ else
+ expunge = TRUE;
+ } else {
expunge = TRUE;
- else
- expunge = FALSE;
+ }
+
+ /* Create helper */
+ helper = g_slice_new0 (SyncFolderHelper);
+ helper->mail_op = g_object_ref (self);
+ helper->user_callback = NULL;
+ helper->user_data = NULL;
/* Sync folder */
- tny_folder_sync_async(folder, expunge, sync_folder_finish_callback,
- NULL, self);
+ tny_folder_sync_async(folder, expunge, sync_folder_finish_callback, NULL, helper);
+
+ /* Remove the extra reference */
+ g_object_unref (self);
}
void
if (!remove_headers)
remove_headers = g_object_ref (headers);
+ /* Notify messages are "read" */
+ iter = tny_list_create_iterator (remove_headers);
+ while (!tny_iterator_is_done (iter)) {
+ gchar *msg_uid;
+ TnyHeader *header;
+
+ header = TNY_HEADER (tny_iterator_get_current (iter));
+ msg_uid = modest_tny_folder_get_header_unique_id (header);
+ if (msg_uid) {
+ modest_platform_emit_msg_read_changed_signal (msg_uid, TRUE);
+ g_free (msg_uid);
+ }
+ g_object_unref (header);
+ tny_iterator_next (iter);
+ }
+ g_object_unref (iter);
+
/* remove message from folder */
modest_mail_operation_notify_start (self);
tny_folder_remove_msgs_async (folder, remove_headers, remove_msgs_async_cb,
}
if (finished) {
+ TnyAccount *src_account;
+ TnyAccount *dest_account;
+
+ /* send the notification that the source folder might have changed */
+ src_account = modest_tny_folder_get_account (folder);
+ if (src_account) {
+ const gchar *src_folder_id;
+ const gchar *src_account_name;
+
+ src_folder_id = tny_folder_get_id (folder);
+ src_account_name =
+ modest_tny_account_get_parent_modest_account_name_for_server_account (src_account);
+ modest_platform_emit_folder_updated_signal (src_account_name, src_folder_id);
+ g_object_unref (src_account);
+ }
+ /* send the notification that the destination folder might have changed */
+ dest_account = modest_tny_folder_get_account (helper->dest_folder);
+ if (dest_account) {
+ const gchar *dest_folder_id;
+ const gchar *dest_account_name;
+
+ dest_folder_id = tny_folder_get_id (helper->dest_folder);
+ dest_account_name =
+ modest_tny_account_get_parent_modest_account_name_for_server_account (dest_account);
+ modest_platform_emit_folder_updated_signal (dest_account_name, dest_folder_id);
+ g_object_unref (dest_account);
+ }
+
/* Synchronize the source folder contents. This should
be done by tinymail but the camel_folder_sync it's
actually disabled in transfer_msgs_thread_clean
priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
- _CS("ckct_ib_unable_to_paste_here"));
+ _CS_UNABLE_TO_PASTE_HERE);
/* Notify the queue */
modest_mail_operation_notify_end (self);
return;
}
static void
-sync_folder_finish_callback (TnyFolder *self,
- gboolean cancelled,
- GError *err,
+sync_folder_finish_callback (TnyFolder *self,
+ gboolean cancelled,
+ GError *err,
gpointer user_data)
{
- ModestMailOperation *mail_op;
ModestMailOperationPrivate *priv;
+ SyncFolderHelper *helper;
- mail_op = (ModestMailOperation *) user_data;
- priv = MODEST_MAIL_OPERATION_GET_PRIVATE (mail_op);
+ helper = (SyncFolderHelper *) user_data;
+ priv = MODEST_MAIL_OPERATION_GET_PRIVATE (helper->mail_op);
/* If canceled by the user, ignore the error given by Tinymail */
if (cancelled) {
priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
}
- modest_mail_operation_notify_end (mail_op);
- g_object_unref (mail_op);
+ /* User callback */
+ if (helper->user_callback)
+ helper->user_callback (helper->mail_op, self, helper->user_data);
+
+ modest_mail_operation_notify_end (helper->mail_op);
+
+ /* Frees */
+ g_object_unref (helper->mail_op);
+ g_slice_free (SyncFolderHelper, helper);
}
void
modest_mail_operation_sync_folder (ModestMailOperation *self,
- TnyFolder *folder, gboolean expunge)
+ TnyFolder *folder,
+ gboolean expunge,
+ SyncFolderCallback callback,
+ gpointer user_data)
{
ModestMailOperationPrivate *priv;
+ SyncFolderHelper *helper;
g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
g_return_if_fail (TNY_IS_FOLDER (folder));
priv->account = modest_tny_folder_get_account (folder);
priv->op_type = MODEST_MAIL_OPERATION_TYPE_SYNC_FOLDER;
+ /* Create helper */
+ helper = g_slice_new0 (SyncFolderHelper);
+ helper->mail_op = g_object_ref (self);
+ helper->user_callback = callback;
+ helper->user_data = user_data;
+
modest_mail_operation_notify_start (self);
- g_object_ref (self);
- tny_folder_sync_async (folder, expunge,
- (TnyFolderCallback) sync_folder_finish_callback,
- NULL, self);
+ tny_folder_sync_async (folder, expunge,
+ (TnyFolderCallback) sync_folder_finish_callback,
+ NULL, helper);
}
static void
projects / modest / blobdiff