* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#include "modest-mail-operation.h"
-/* include other impl specific header files */
#include <string.h>
#include <stdarg.h>
#include <tny-mime-part.h>
#include <tny-folder-store.h>
#include <tny-folder-store-query.h>
#include <tny-camel-stream.h>
+#include <tny-camel-pop-store-account.h>
#include <tny-simple-list.h>
#include <tny-send-queue.h>
#include <tny-status.h>
#include "modest-tny-platform-factory.h"
#include "modest-marshal.h"
#include "modest-error.h"
+#include "modest-mail-operation.h"
#define KB 1024
static void modest_mail_operation_notify_end (ModestMailOperation *self);
+static gboolean did_a_cancel = FALSE;
+
enum _ModestMailOperationSignals
{
PROGRESS_CHANGED_SIGNAL,
typedef struct _ModestMailOperationPrivate ModestMailOperationPrivate;
struct _ModestMailOperationPrivate {
TnyAccount *account;
+ gchar *account_name;
guint done;
guint total;
GObject *source;
typedef struct _GetMsgAsyncHelper {
ModestMailOperation *mail_op;
GetMsgAsyncUserCallback user_callback;
- guint pending_ops;
gpointer user_data;
} GetMsgAsyncHelper;
+typedef struct _RefreshAsyncHelper {
+ ModestMailOperation *mail_op;
+ RefreshAsyncUserCallback user_callback;
+ gpointer user_data;
+} RefreshAsyncHelper;
+
typedef struct _XFerMsgAsyncHelper
{
ModestMailOperation *mail_op;
NULL, NULL,
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1, G_TYPE_POINTER);
+
}
static void
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(obj);
- priv->account = NULL;
+ priv->account = NULL;
priv->status = MODEST_MAIL_OPERATION_STATUS_INVALID;
priv->op_type = MODEST_MAIL_OPERATION_TYPE_UNKNOWN;
priv->error = NULL;
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(obj);
+
+
if (priv->error) {
g_error_free (priv->error);
priv->error = NULL;
{
ModestMailOperationPrivate *priv;
+ g_return_val_if_fail (self, NULL);
+
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
-
+ if (!priv) {
+ g_warning ("BUG: %s: priv == NULL", __FUNCTION__);
+ return NULL;
+ }
+
return g_object_ref (priv->source);
}
MODEST_MAIL_OPERATION_STATUS_INVALID);
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
+ if (!priv) {
+ g_warning ("BUG: %s: priv == NULL", __FUNCTION__);
+ return MODEST_MAIL_OPERATION_STATUS_INVALID;
+ }
+
return priv->status;
}
g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self), NULL);
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
+
+ if (!priv) {
+ g_warning ("BUG: %s: priv == NULL", __FUNCTION__);
+ return NULL;
+ }
+
return priv->error;
}
}
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
+ if (!priv) {
+ g_warning ("BUG: %s: priv == NULL", __FUNCTION__);
+ return FALSE;
+ }
- /* TODO: Tinymail does not support cancel operation */
-/* tny_account_cancel (); */
+ /* Notify about operation end */
+ modest_mail_operation_notify_end (self);
+
+ did_a_cancel = TRUE;
/* Set new status */
priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
+
+ modest_mail_operation_queue_cancel_all (modest_runtime_get_mail_operation_queue());
- /* Notify about operation end */
- modest_mail_operation_notify_end (self);
-
+
return TRUE;
}
ModestMailOperationState *state;
ModestMailOperationPrivate *priv;
+ /* FIXME: this should be fixed properly
+ *
+ * in some cases, priv was NULL, so checking here to
+ * make sure.
+ */
+ g_return_val_if_fail (self, NULL);
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
+ g_return_val_if_fail (priv, NULL);
+
+ if (!priv)
+ return NULL;
state = g_slice_new (ModestMailOperationState);
void
modest_mail_operation_send_new_mail (ModestMailOperation *self,
TnyTransportAccount *transport_account,
+ TnyMsg *draft_msg,
const gchar *from, const gchar *to,
const gchar *cc, const gchar *bcc,
const gchar *subject, const gchar *plain_body,
TnyHeaderFlags priority_flags)
{
TnyMsg *new_msg = NULL;
+ TnyFolder *folder = NULL;
+ TnyHeader *header = NULL;
ModestMailOperationPrivate *priv = NULL;
g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
return;
}
- /* TODO: add priority handling. It's received in the priority_flags operator, and
- it should have effect in the sending operation */
+ /* Set priority flags in message */
+ header = tny_msg_get_header (new_msg);
+ if (priority_flags != 0)
+ tny_header_set_flags (header, priority_flags);
/* Call mail operation */
modest_mail_operation_send_mail (self, transport_account, new_msg);
+ folder = modest_tny_account_get_special_folder (TNY_ACCOUNT (transport_account), TNY_FOLDER_TYPE_DRAFTS);
+ if (folder) {
+ if (draft_msg != NULL) {
+ header = tny_msg_get_header (draft_msg);
+ /* Note: This can fail (with a warning) if the message is not really already in a folder,
+ * because this function requires it to have a UID. */
+ tny_folder_remove_msg (folder, header, NULL);
+ g_object_unref (header);
+ }
+ }
+
/* Free */
g_object_unref (G_OBJECT (new_msg));
}
void
modest_mail_operation_save_to_drafts (ModestMailOperation *self,
TnyTransportAccount *transport_account,
+ TnyMsg *draft_msg,
const gchar *from, const gchar *to,
const gchar *cc, const gchar *bcc,
const gchar *subject, const gchar *plain_body,
{
TnyMsg *msg = NULL;
TnyFolder *folder = NULL;
+ TnyHeader *header = NULL;
ModestMailOperationPrivate *priv = NULL;
g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
goto end;
}
+ /* add priority flags */
+ header = tny_msg_get_header (msg);
+ tny_header_set_flags (header, priority_flags);
+
folder = modest_tny_account_get_special_folder (TNY_ACCOUNT (transport_account), TNY_FOLDER_TYPE_DRAFTS);
if (!folder) {
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
"modest: failed to create a new msg\n");
goto end;
}
+
+ if (draft_msg != NULL) {
+ header = tny_msg_get_header (draft_msg);
+ /* Remove the old draft expunging it */
+ tny_folder_remove_msg (folder, header, NULL);
+ tny_folder_sync (folder, TRUE, NULL);
+ g_object_unref (header);
+ }
tny_folder_add_msg (folder, msg, &(priv->error));
if (priv->error)
gint max_size;
gint retrieve_limit;
gchar *retrieve_type;
+ gchar *account_name;
} UpdateAccountInfo;
/***** I N T E R N A L F O L D E R O B S E R V E R *****/
static void
foreach_add_item (gpointer header, gpointer user_data)
{
+ /* printf("DEBUG: %s: header subject=%s\n",
+ * __FUNCTION__, tny_header_get_subject(TNY_HEADER(header)));
+ */
tny_list_prepend (TNY_LIST (user_data),
g_object_ref (G_OBJECT (header)));
}
static void
internal_folder_observer_update (TnyFolderObserver *self, TnyFolderChange *change)
{
+ InternalFolderObserver *derived = (InternalFolderObserver *)self;
+
TnyFolderChangeChanged changed;
changed = tny_folder_change_get_changed (change);
list = tny_simple_list_new ();
tny_folder_change_get_added_headers (change, list);
+ /* printf ("DEBUG: %s: Calling foreach with a list of size=%d\n",
+ * __FUNCTION__, tny_list_get_length(list));
+ */
+
/* Add them to the folder observer */
tny_list_foreach (list, foreach_add_item,
- ((InternalFolderObserver *)self)->new_headers);
+ derived->new_headers);
g_object_unref (G_OBJECT (list));
}
state = modest_mail_operation_clone_state (mail_op);
g_signal_emit (G_OBJECT (mail_op), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
g_slice_free (ModestMailOperationState, state);
-
+
return TRUE;
}
notify_update_account_queue (gpointer data)
{
ModestMailOperation *mail_op = MODEST_MAIL_OPERATION (data);
+ ModestMailOperationPrivate *priv = NULL;
+ priv = MODEST_MAIL_OPERATION_GET_PRIVATE(mail_op);
+
modest_mail_operation_notify_end (mail_op);
g_object_unref (mail_op);
return -1;
}
+static gboolean
+set_last_updated_idle (gpointer data)
+{
+ /* It does not matter if the time is not exactly the same than
+ the time when this idle was called, it's just an
+ approximation and it won't be very different */
+ modest_account_mgr_set_int (modest_runtime_get_account_mgr (),
+ (gchar *) data,
+ MODEST_ACCOUNT_LAST_UPDATED,
+ time(NULL),
+ TRUE);
+
+ return FALSE;
+}
+
static gpointer
update_account_thread (gpointer thr_user_data)
{
TnyIterator *iter = NULL;
TnyFolderStoreQuery *query = NULL;
ModestMailOperationPrivate *priv;
+ ModestTnySendQueue *send_queue;
info = (UpdateAccountInfo *) thr_user_data;
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(info->mail_op);
/* Get account and set it into mail_operation */
priv->account = g_object_ref (info->account);
- /* Get all the folders We can do it synchronously because
+ /*
+ * for POP3, we do a logout-login upon send/receive -- many POP-servers (like Gmail) do not
+ * show any updates unless we do that
+ */
+ if (TNY_IS_CAMEL_POP_STORE_ACCOUNT(priv->account))
+ tny_camel_pop_store_account_reconnect (TNY_CAMEL_POP_STORE_ACCOUNT(priv->account));
+
+ /* Get all the folders. We can do it synchronously because
we're already running in a different thread than the UI */
all_folders = tny_simple_list_new ();
query = tny_folder_store_query_new ();
g_object_unref (G_OBJECT (iter));
/* Update status and notify. We need to call the notification
- with a source functopm in order to call it from the main
+ with a source function in order to call it from the main
loop. We need that in order not to get into trouble with
Gtk+. We use a timeout in order to provide more status
information, because the sync tinymail call does not
/* Refresh folders */
new_headers = g_ptr_array_new ();
iter = tny_list_create_iterator (all_folders);
- while (!tny_iterator_is_done (iter) && !priv->error) {
+
+ while (!tny_iterator_is_done (iter) && !priv->error && !did_a_cancel) {
InternalFolderObserver *observer;
TnyFolderStore *folder = TNY_FOLDER_STORE (tny_iterator_get_current (iter));
/* Refresh the folder */
+ /* Our observer receives notification of new emails during folder refreshes,
+ * so we can use observer->new_headers.
+ * TODO: This does not seem to be providing accurate numbers.
+ * Possibly the observer is notified asynchronously.
+ */
observer = g_object_new (internal_folder_observer_get_type (), NULL);
tny_folder_add_observer (TNY_FOLDER (folder), TNY_FOLDER_OBSERVER (observer));
- tny_folder_refresh (TNY_FOLDER (folder), &(priv->error));
+
+ /* This gets the status information (headers) from the server.
+ * We use the blocking version, because we are already in a separate
+ * thread.
+ */
- /* If the retrieve type is headers only do nothing more */
if (!g_ascii_strcasecmp (info->retrieve_type, MODEST_ACCOUNT_RETRIEVE_VALUE_MESSAGES) ||
!g_ascii_strcasecmp (info->retrieve_type, MODEST_ACCOUNT_RETRIEVE_VALUE_MESSAGES_AND_ATTACHMENTS)) {
TnyIterator *iter;
+ /* If the retrieve type is full messages, refresh and get the messages */
+ tny_folder_refresh (TNY_FOLDER (folder), &(priv->error));
+
iter = tny_list_create_iterator (observer->new_headers);
while (!tny_iterator_is_done (iter)) {
TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
+ /* printf (" DEBUG1.2 %s: checking size: account=%s, subject=%s\n",
+ * __FUNCTION__, tny_account_get_id (priv->account),
+ * tny_header_get_subject (header));
+ */
+
/* Apply per-message size limits */
if (tny_header_get_message_size (header) < info->max_size)
g_ptr_array_add (new_headers, g_object_ref (header));
}
g_object_unref (iter);
}
+
tny_folder_remove_observer (TNY_FOLDER (folder), TNY_FOLDER_OBSERVER (observer));
g_object_unref (observer);
+ observer = NULL;
if (priv->error)
priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
g_object_unref (G_OBJECT (folder));
tny_iterator_next (iter);
}
+
+ did_a_cancel = FALSE;
+
g_object_unref (G_OBJECT (iter));
g_source_remove (timeout);
g_ptr_array_sort (new_headers, (GCompareFunc) compare_headers_by_date);
/* Apply message count limit */
- /* TODO if the number of messages exceeds the maximum, ask the
- user to download them all */
+ /* If the number of messages exceeds the maximum, ask the
+ * user to download them all,
+ * as per the UI spec "Retrieval Limits" section in 4.4:
+ */
+ printf ("DEBUG: %s: account=%s, len=%d, retrieve_limit = %d\n", __FUNCTION__,
+ tny_account_get_id (priv->account), new_headers->len, info->retrieve_limit);
+ if (new_headers->len > info->retrieve_limit) {
+ /* TODO: Ask the user, instead of just failing, showing mail_nc_msg_count_limit_exceeded,
+ * with 'Get all' and 'Newest only' buttons. */
+ g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
+ MODEST_MAIL_OPERATION_ERROR_RETRIEVAL_NUMBER_LIMIT,
+ "The number of messages to retrieve exceeds the chosen limit for account %s\n",
+ tny_account_get_name (TNY_ACCOUNT (info->transport_account)));
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+ goto out;
+ }
+
priv->done = 0;
priv->total = MIN (new_headers->len, info->retrieve_limit);
- while ((msg_num < priv->total)) {
+ while (msg_num < priv->total) {
TnyHeader *header = TNY_HEADER (g_ptr_array_index (new_headers, msg_num));
TnyFolder *folder = tny_header_get_folder (header);
g_object_unref (priv->account);
priv->account = g_object_ref (info->transport_account);
- ModestTnySendQueue *send_queue = modest_runtime_get_send_queue
- (info->transport_account);
-
- timeout = g_timeout_add (250, idle_notify_progress, info->mail_op);
- modest_tny_send_queue_try_to_send (send_queue);
- g_source_remove (timeout);
-
- g_object_unref (G_OBJECT(send_queue));
+ send_queue = modest_runtime_get_send_queue (info->transport_account);
+ if (send_queue) {
+ timeout = g_timeout_add (250, idle_notify_progress, info->mail_op);
+ modest_tny_send_queue_try_to_send (send_queue);
+ g_source_remove (timeout);
+ } else {
+ g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
+ MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED,
+ "cannot create a send queue for %s\n",
+ tny_account_get_name (TNY_ACCOUNT (info->transport_account)));
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+ }
/* Check if the operation was a success */
if (!priv->error) {
priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
/* Update the last updated key */
- modest_account_mgr_set_int (modest_runtime_get_account_mgr (),
- tny_account_get_id (TNY_ACCOUNT (info->account)),
- MODEST_ACCOUNT_LAST_UPDATED,
- time(NULL),
- TRUE);
+ g_idle_add_full (G_PRIORITY_HIGH_IDLE,
+ set_last_updated_idle,
+ g_strdup (tny_account_get_id (TNY_ACCOUNT (info->account))),
+ (GDestroyNotify) g_free);
}
out:
/* Notify about operation end. Note that the info could be
freed before this idle happens, but the mail operation will
be still alive */
- g_idle_add (notify_update_account_queue, info->mail_op);
-
+ g_idle_add (notify_update_account_queue, g_object_ref (info->mail_op));
+
/* Frees */
g_object_unref (query);
g_object_unref (all_folders);
g_return_val_if_fail (MODEST_IS_MAIL_OPERATION (self), FALSE);
g_return_val_if_fail (account_name, FALSE);
+ /* Make sure that we have a connection, and request one
+ * if necessary:
+ * TODO: Is there some way to trigger this for every attempt to
+ * use the network? */
+ if (!modest_platform_connect_and_wait(NULL))
+ return FALSE;
+
/* Init mail operation. Set total and done to 0, and do not
update them, this way the progress objects will know that
we have no clue about the number of the objects */
/* Get the Modest account */
modest_account = (TnyStoreAccount *)
- modest_tny_account_store_get_tny_account_by_account (modest_runtime_get_account_store (),
+ modest_tny_account_store_get_server_account (modest_runtime_get_account_store (),
account_name,
TNY_ACCOUNT_TYPE_STORE);
MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
"cannot get tny store account for %s\n", account_name);
modest_mail_operation_notify_end (self);
+
return FALSE;
}
+
/* Get the transport account, we can not do it in the thread
due to some problems with dbus */
transport_account = (TnyTransportAccount *)
MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
"cannot get tny transport account for %s\n", account_name);
modest_mail_operation_notify_end (self);
+
return FALSE;
}
MODEST_ACCOUNT_LIMIT_RETRIEVE, FALSE);
if (info->retrieve_limit == 0)
info->retrieve_limit = G_MAXINT;
+
+ /* printf ("DEBUG: %s: info->retrieve_limit = %d\n", __FUNCTION__, info->retrieve_limit); */
+ /* Set account busy */
+ modest_account_mgr_set_account_busy(mgr, account_name, TRUE);
+ priv->account_name = g_strdup(account_name);
+
thread = g_thread_create (update_account_thread, info, FALSE, NULL);
return TRUE;
TnyFolderStore *parent,
const gchar *name)
{
- ModestTnyFolderRules rules;
ModestMailOperationPrivate *priv;
TnyFolder *new_folder = NULL;
- gboolean can_create = FALSE;
g_return_val_if_fail (TNY_IS_FOLDER_STORE (parent), NULL);
g_return_val_if_fail (name, NULL);
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
- /* Get account and set it into mail_operation */
- priv->account = tny_folder_get_account (TNY_FOLDER(parent));
-
/* Check parent */
- if (!TNY_IS_FOLDER (parent)) {
- /* Set status failed and set an error */
- priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
- g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
- MODEST_MAIL_OPERATION_ERROR_BAD_PARAMETER,
- _("mail_in_ui_folder_create_error"));
- } else {
+ if (TNY_IS_FOLDER (parent)) {
/* Check folder rules */
- rules = modest_tny_folder_get_rules (TNY_FOLDER (parent));
+ ModestTnyFolderRules rules = modest_tny_folder_get_rules (TNY_FOLDER (parent));
if (rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
/* Set status failed and set an error */
priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
_("mail_in_ui_folder_create_error"));
- }
- else
- can_create = TRUE;
+ }
}
- if (can_create) {
+ if (!priv->error) {
/* Create the folder */
new_folder = tny_folder_store_create_folder (parent, name, &(priv->error));
CHECK_EXCEPTION (priv, MODEST_MAIL_OPERATION_STATUS_FAILED);
+ if (!priv->error)
+ priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
}
/* Notify about operation end */
}
/* Get the account */
- account = tny_folder_get_account (folder);
+ account = modest_tny_folder_get_account (folder);
priv->account = g_object_ref(account);
/* Delete folder or move to trash */
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
/* Get account and set it into mail_operation */
- priv->account = tny_folder_get_account (TNY_FOLDER(folder));
+ priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
/* Get folder rules */
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
/* Get account and set it into mail_operation */
- priv->account = tny_folder_get_account (TNY_FOLDER(folder));
+ priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
/* Check folder rules */
rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
/* Get message from folder */
if (folder) {
/* Get account and set it into mail_operation */
- priv->account = tny_folder_get_account (TNY_FOLDER(folder));
+ priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
helper = g_slice_new0 (GetMsgAsyncHelper);
helper->mail_op = self;
helper->user_callback = user_callback;
- helper->pending_ops = 1;
helper->user_data = user_data;
tny_folder_get_msg_async (folder, header, get_msg_cb, get_msg_status_cb, helper);
self = helper->mail_op;
g_return_if_fail (MODEST_IS_MAIL_OPERATION(self));
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
-
- helper->pending_ops--;
/* Check errors and cancel */
if (*error) {
helper->user_callback (self, NULL, msg, helper->user_data);
}
- /* Free */
out:
- if (helper->pending_ops == 0) {
- g_slice_free (GetMsgAsyncHelper, helper);
+ /* Free */
+ g_slice_free (GetMsgAsyncHelper, helper);
- /* Notify about operation end */
- modest_mail_operation_notify_end (self);
- }
+ /* Notify about operation end */
+ modest_mail_operation_notify_end (self);
}
static void
priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
/* Notify about operation end */
- g_idle_add (notify_update_account_queue, info->mail_op);
+ g_idle_add (notify_update_account_queue, g_object_ref (info->mail_op));
/* Free thread resources. Will be called after all previous idles */
g_idle_add_full (G_PRIORITY_DEFAULT_IDLE + 1, get_msgs_full_destroyer, info, NULL);
priv->total = tny_list_get_length(header_list);
/* Get account and set it into mail_operation */
- if (tny_list_get_length (header_list) > 1) {
- iter = tny_list_create_iterator (header_list);
+ if (tny_list_get_length (header_list) >= 1) {
+ iter = tny_list_create_iterator (header_list);
header = TNY_HEADER (tny_iterator_get_current (iter));
folder = tny_header_get_folder (header);
- priv->account = tny_folder_get_account (TNY_FOLDER(folder));
+ priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
g_object_unref (header);
g_object_unref (folder);
+
+ if (tny_list_get_length (header_list) == 1) {
+ g_object_unref (iter);
+ iter = NULL;
+ }
}
/* Get msg size limit */
priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
/* FIXME: the error msg is different for pop */
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
- MODEST_MAIL_OPERATION_ERROR_SIZE_LIMIT,
+ MODEST_MAIL_OPERATION_ERROR_MESSAGE_SIZE_LIMIT,
_("emev_ni_ui_imap_msg_size_exceed_error"));
/* Remove from queue and free resources */
modest_mail_operation_notify_end (self);
folder = tny_header_get_folder (header);
/* Get account and set it into mail_operation */
- priv->account = tny_folder_get_account (TNY_FOLDER(folder));
+ priv->account = modest_tny_folder_get_account (TNY_FOLDER(folder));
priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
TnyFolder *trash_folder;
TnyStoreAccount *store_account;
- store_account = TNY_STORE_ACCOUNT (tny_folder_get_account (folder));
+ store_account = TNY_STORE_ACCOUNT (modest_tny_folder_get_account (folder));
trash_folder = modest_tny_account_get_special_folder (TNY_ACCOUNT(store_account),
TNY_FOLDER_TYPE_TRASH);
if (trash_folder) {
g_object_unref (iter);
/* Get account and set it into mail_operation */
- priv->account = tny_folder_get_account (src_folder);
+ priv->account = modest_tny_folder_get_account (src_folder);
/* Transfer messages */
tny_folder_transfer_msgs_async (src_folder,
GError **error,
gpointer user_data)
{
- ModestMailOperation *self;
- ModestMailOperationPrivate *priv;
+ RefreshAsyncHelper *helper = NULL;
+ ModestMailOperation *self = NULL;
+ ModestMailOperationPrivate *priv = NULL;
- self = MODEST_MAIL_OPERATION (user_data);
+ helper = (RefreshAsyncHelper *) user_data;
+ self = helper->mail_op;
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
if (*error) {
priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
out:
+ /* Call user defined callback, if it exists */
+ if (helper->user_callback)
+ helper->user_callback (priv->source, folder, helper->user_data);
+
/* Free */
+ g_object_unref (helper->mail_op);
+ g_slice_free (RefreshAsyncHelper, helper);
g_object_unref (folder);
/* Notify about operation end */
TnyStatus *status,
gpointer user_data)
{
- ModestMailOperation *self;
- ModestMailOperationPrivate *priv;
+ RefreshAsyncHelper *helper = NULL;
+ ModestMailOperation *self = NULL;
+ ModestMailOperationPrivate *priv = NULL;
ModestMailOperationState *state;
+ g_return_if_fail (user_data != NULL);
g_return_if_fail (status != NULL);
g_return_if_fail (status->code == TNY_FOLDER_STATUS_CODE_REFRESH);
- self = MODEST_MAIL_OPERATION (user_data);
+ helper = (RefreshAsyncHelper *) user_data;
+ self = helper->mail_op;
+ g_return_if_fail (MODEST_IS_MAIL_OPERATION(self));
+
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
priv->done = status->position;
void
modest_mail_operation_refresh_folder (ModestMailOperation *self,
- TnyFolder *folder)
+ TnyFolder *folder,
+ RefreshAsyncUserCallback user_callback,
+ gpointer user_data)
{
- ModestMailOperationPrivate *priv;
+ ModestMailOperationPrivate *priv = NULL;
+ RefreshAsyncHelper *helper = NULL;
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
/* Get account and set it into mail_operation */
- priv->account = tny_folder_get_account (folder);
+ priv->account = modest_tny_folder_get_account (folder);
+
+ /* Create the helper */
+ helper = g_slice_new0 (RefreshAsyncHelper);
+ helper->mail_op = g_object_ref(self);
+ helper->user_callback = user_callback;
+ helper->user_data = user_data;
/* Refresh the folder. TODO: tinymail could issue a status
updates before the callback call then this could happen. We
tny_folder_refresh_async (folder,
on_refresh_folder,
on_refresh_folder_status_update,
- self);
+ helper);
}
/**
modest_mail_operation_notify_end (ModestMailOperation *self)
{
ModestMailOperationState *state;
+ ModestMailOperationPrivate *priv = NULL;
+
+ g_return_if_fail (self);
+ priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
+
+ if (!priv) {
+ g_warning ("BUG: %s: priv == NULL", __FUNCTION__);
+ return;
+ }
+
+ /* Set the account back to not busy */
+ if (priv->account_name) {
+ modest_account_mgr_set_account_busy(modest_runtime_get_account_mgr(), priv->account_name,
+ FALSE);
+ g_free(priv->account_name);
+ priv->account_name = NULL;
+ }
+
/* Notify the observers about the mail opertation end */
state = modest_mail_operation_clone_state (self);
g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
g_slice_free (ModestMailOperationState, state);
-
- /* Notify the queue */
- modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (), self);
}