#include <tny-folder-store-query.h>
#include <tny-camel-stream.h>
#include <tny-camel-pop-store-account.h>
+#include <tny-camel-pop-folder.h>
+#include <tny-camel-imap-folder.h>
#include <tny-simple-list.h>
#include <tny-send-queue.h>
#include <tny-status.h>
TnyStatus *status,
gpointer user_data);
-static void modest_mail_operation_notify_end (ModestMailOperation *self);
+static void modest_mail_operation_notify_end (ModestMailOperation *self,
+ gboolean need_lock);
static gboolean did_a_cancel = FALSE;
typedef struct _GetMsgAsyncHelper {
ModestMailOperation *mail_op;
+ TnyHeader *header;
GetMsgAsyncUserCallback user_callback;
gpointer user_data;
} GetMsgAsyncHelper;
return FALSE;
}
- /* 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());
+ /* This emits progress-changed on which the mail operation queue is
+ * listening, so the mail operation is correctly removed from the
+ * queue without further explicit calls. */
+ modest_mail_operation_notify_end (self, FALSE);
return TRUE;
}
state->done = priv->done;
state->total = priv->total;
state->finished = modest_mail_operation_is_finished (self);
+ state->bytes_done = 0;
+ state->bytes_total = 0;
return state;
}
/* Get account and set it into mail_operation */
priv->account = g_object_ref (transport_account);
+ priv->done = 1;
+ priv->total = 1;
send_queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (transport_account));
if (!TNY_IS_SEND_QUEUE(send_queue)) {
MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
"modest: could not find send queue for account\n");
} else {
+ /* TODO: connect to the msg-sent in order to know when
+ the mail operation is finished */
tny_send_queue_add (send_queue, msg, &(priv->error));
+ /* TODO: we're setting always success, do the check in
+ the handler */
+ priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
}
- /* Notify about operation end */
- modest_mail_operation_notify_end (self);
+ /* TODO: do this in the handler of the "msg-sent"
+ signal.Notify about operation end */
+ modest_mail_operation_notify_end (self, FALSE);
}
void
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
- /* Get account and set it into mail_operation */
- priv->account = g_object_ref (transport_account);
-
/* Check parametters */
if (to == NULL) {
/* Set status failed and set an error */
msg = modest_tny_msg_new_html_plain (to, from, cc, bcc, subject, html_body, plain_body, (GSList *) attachments_list);
}
if (!msg) {
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
MODEST_MAIL_OPERATION_ERROR_INSTANCE_CREATION_FAILED,
"modest: failed to create a new msg\n");
folder = modest_tny_account_get_special_folder (TNY_ACCOUNT (transport_account), TNY_FOLDER_TYPE_DRAFTS);
if (!folder) {
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
"modest: failed to create a new msg\n");
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);
+ tny_folder_sync (folder, FALSE, &(priv->error)); /* FALSE --> don't expunge */
g_object_unref (header);
}
- tny_folder_add_msg (folder, msg, &(priv->error));
- if (priv->error)
- goto end;
+ if (!priv->error)
+ tny_folder_add_msg (folder, msg, &(priv->error));
+
+ if (!priv->error)
+ priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
+ else
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
end:
if (msg)
if (folder)
g_object_unref (G_OBJECT(folder));
- modest_mail_operation_notify_end (self);
+ modest_mail_operation_notify_end (self, FALSE);
}
typedef struct
gint retrieve_limit;
gchar *retrieve_type;
gchar *account_name;
+ UpdateAccountCallback callback;
+ gpointer user_data;
} UpdateAccountInfo;
/***** I N T E R N A L F O L D E R O B S E R V E R *****/
* loop. We call it inside an idle call to achieve that
*/
static gboolean
-notify_update_account_queue (gpointer data)
+idle_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);
+
+ /* Do not need to block, the notify end will do it for us */
+ modest_mail_operation_notify_end (mail_op, TRUE);
g_object_unref (mail_op);
return FALSE;
static gboolean
set_last_updated_idle (gpointer data)
{
+ gdk_threads_enter ();
+
/* 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 */
time(NULL),
TRUE);
+ gdk_threads_leave ();
+
return FALSE;
}
static gboolean first_time = TRUE;
UpdateAccountInfo *info;
TnyList *all_folders = NULL;
- GPtrArray *new_headers;
+ GPtrArray *new_headers = NULL;
TnyIterator *iter = NULL;
TnyFolderStoreQuery *query = NULL;
- ModestMailOperationPrivate *priv;
- ModestTnySendQueue *send_queue;
+ ModestMailOperationPrivate *priv = NULL;
+ ModestTnySendQueue *send_queue = NULL;
info = (UpdateAccountInfo *) thr_user_data;
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(info->mail_op);
Gtk+. We use a timeout in order to provide more status
information, because the sync tinymail call does not
provide it for the moment */
- gint timeout = g_timeout_add (250, idle_notify_progress, info->mail_op);
+ gint timeout = g_timeout_add (100, idle_notify_progress, info->mail_op);
/* Refresh folders */
new_headers = g_ptr_array_new ();
/* 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_remove_observer (TNY_FOLDER (folder), TNY_FOLDER_OBSERVER (observer));
g_object_unref (observer);
- observer = NULL;
+ observer = NULL;
+ g_object_unref (G_OBJECT (folder));
if (priv->error)
+ {
priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
-
- g_object_unref (G_OBJECT (folder));
+ goto out;
+ }
+
tny_iterator_next (iter);
}
* 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. */
+ /* 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",
g_ptr_array_foreach (new_headers, (GFunc) g_object_unref, NULL);
g_ptr_array_free (new_headers, FALSE);
}
-
+
/* Perform send */
priv->op_type = MODEST_MAIL_OPERATION_TYPE_SEND;
priv->done = 0;
/* 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, g_object_ref (info->mail_op));
+ g_idle_add (idle_notify_update_account_queue, g_object_ref (info->mail_op));
+
+ if (info->callback) {
+ /* This thread is not in the main lock */
+ gdk_threads_enter ();
+ info->callback (info->mail_op,
+ (new_headers) ? new_headers->len : 0,
+ info->user_data);
+ gdk_threads_leave ();
+ }
/* Frees */
g_object_unref (query);
gboolean
modest_mail_operation_update_account (ModestMailOperation *self,
- const gchar *account_name)
+ const gchar *account_name,
+ UpdateAccountCallback callback,
+ gpointer user_data)
{
GThread *thread;
UpdateAccountInfo *info;
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 */
priv->total = 0;
priv->done = 0;
priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
-
+
/* Get the Modest account */
modest_account = (TnyStoreAccount *)
modest_tny_account_store_get_server_account (modest_runtime_get_account_store (),
TNY_ACCOUNT_TYPE_STORE);
if (!modest_account) {
- priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
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;
+ goto error;
}
modest_tny_account_store_get_transport_account_for_open_connection (modest_runtime_get_account_store(),
account_name);
if (!transport_account) {
- priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
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;
+ goto error;
}
/* Create the helper object */
info->mail_op = self;
info->account = modest_account;
info->transport_account = transport_account;
+ info->callback = callback;
+ info->user_data = user_data;
/* Get the message size limit */
info->max_size = modest_conf_get_int (modest_runtime_get_conf (),
thread = g_thread_create (update_account_thread, info, FALSE, NULL);
return TRUE;
+
+ error:
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+ if (callback)
+ callback (self, 0, user_data);
+ modest_mail_operation_notify_end (self, FALSE);
+ return FALSE;
}
/* ******************************************************************* */
}
}
+ if (!strcmp (name, " ") || strchr (name, '/')) {
+ 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"));
+ }
+
if (!priv->error) {
/* Create the folder */
new_folder = tny_folder_store_create_folder (parent, name, &(priv->error));
}
/* Notify about operation end */
- modest_mail_operation_notify_end (self);
+ modest_mail_operation_notify_end (self, FALSE);
return new_folder;
}
end:
/* Notify about operation end */
- modest_mail_operation_notify_end (self);
+ modest_mail_operation_notify_end (self, FALSE);
}
static void
transfer_folder_cb (TnyFolder *folder,
TnyFolderStore *into,
gboolean cancelled,
- TnyFolder *new_folder, GError **err,
+ TnyFolder *new_folder,
+ GError **err,
gpointer user_data)
{
ModestMailOperation *self = NULL;
/* Free */
g_object_unref (folder);
g_object_unref (into);
- if (new_folder != NULL)
- g_object_unref (new_folder);
/* Notify about operation end */
- modest_mail_operation_notify_end (self);
+ modest_mail_operation_notify_end (self, TRUE);
}
void
gboolean delete_original)
{
ModestMailOperationPrivate *priv = NULL;
- ModestTnyFolderRules parent_rules, rules;
+ ModestTnyFolderRules parent_rules = 0, rules;
g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
g_return_if_fail (TNY_IS_FOLDER (folder));
- g_return_if_fail (TNY_IS_FOLDER (parent));
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
/* Get folder rules */
rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
- parent_rules = modest_tny_folder_get_rules (TNY_FOLDER (parent));
-
- if (!TNY_IS_FOLDER_STORE (parent)) {
-
- }
+ if (TNY_IS_FOLDER (parent))
+ parent_rules = modest_tny_folder_get_rules (TNY_FOLDER (parent));
/* The moveable restriction is applied also to copy operation */
if ((!TNY_IS_FOLDER_STORE (parent)) || (rules & MODEST_FOLDER_RULES_FOLDER_NON_MOVEABLE)) {
+ printf("DEBUG: %s: Not allowing the move.\n", __FUNCTION__);
/* Set status failed and set an error */
priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
_("mail_in_ui_folder_move_target_error"));
/* Notify the queue */
- modest_mail_operation_notify_end (self);
- } else if (parent_rules & MODEST_FOLDER_RULES_FOLDER_NON_WRITEABLE) {
+ modest_mail_operation_notify_end (self, FALSE);
+ } else if (TNY_IS_FOLDER (parent) &&
+ (parent_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,
_("FIXME: parent folder does not accept new folders"));
/* Notify the queue */
- modest_mail_operation_notify_end (self);
+ modest_mail_operation_notify_end (self, FALSE);
} else {
/* Pick references for async calls */
g_object_ref (folder);
_("FIXME: unable to rename"));
/* Notify about operation end */
- modest_mail_operation_notify_end (self);
+ modest_mail_operation_notify_end (self, FALSE);
+ } else if (!strcmp (name, " ") || strchr (name, '/')) {
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+ g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
+ MODEST_MAIL_OPERATION_ERROR_FOLDER_RULES,
+ _("FIXME: unable to rename"));
+ /* Notify about operation end */
+ modest_mail_operation_notify_end (self, FALSE);
} else {
- /* Rename. Camel handles folder subscription/unsubscription */
TnyFolderStore *into;
+ /* Rename. Camel handles folder subscription/unsubscription */
into = tny_folder_get_folder_store (folder);
tny_folder_copy_async (folder, into, name, TRUE,
transfer_folder_cb,
transfer_folder_status_cb,
self);
if (into)
- g_object_unref (into);
-
+ g_object_unref (into);
}
}
helper->mail_op = self;
helper->user_callback = user_callback;
helper->user_data = user_data;
+ helper->header = g_object_ref (header);
+
+ // The callback's reference so that the mail op is not
+ // finalized until the async operation is completed even if
+ // the user canceled the request meanwhile.
+ g_object_ref (G_OBJECT (helper->mail_op));
tny_folder_get_msg_async (folder, header, get_msg_cb, get_msg_status_cb, helper);
_("Error trying to get a message. No folder found for header"));
/* Notify the queue */
- modest_mail_operation_notify_end (self);
+ modest_mail_operation_notify_end (self, FALSE);
}
}
goto out;
}
- priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
+ /* The mail operation might have been canceled in which case we do not
+ want to notify anyone anymore. */
+ if(priv->status != MODEST_MAIL_OPERATION_STATUS_CANCELED) {
+ priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
- /* If user defined callback function was defined, call it */
- if (helper->user_callback) {
- helper->user_callback (self, NULL, msg, helper->user_data);
+ /* If user defined callback function was defined, call it */
+ if (helper->user_callback) {
+ /* This callback is called into an iddle by tinymail,
+ and idles are not in the main lock */
+ gdk_threads_enter ();
+ helper->user_callback (self, helper->header, msg, helper->user_data);
+ gdk_threads_leave ();
+ }
}
out:
/* Free */
+ g_object_unref (helper->header);
g_slice_free (GetMsgAsyncHelper, helper);
/* Notify about operation end */
- modest_mail_operation_notify_end (self);
+ if(priv->status != MODEST_MAIL_OPERATION_STATUS_CANCELED)
+ modest_mail_operation_notify_end (self, TRUE);
+
+ g_object_unref (G_OBJECT (self));
}
static void
self = helper->mail_op;
priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
+ if(priv->status == MODEST_MAIL_OPERATION_STATUS_CANCELED)
+ return;
+
if ((status->position == 1) && (status->of_total == 100))
return;
priv->total = 1;
state = modest_mail_operation_clone_state (self);
+ state->bytes_done = status->position;
+ state->bytes_total = status->of_total;
g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
g_slice_free (ModestMailOperationState, state);
}
info = (NotifyGetMsgsInfo *) data;
- /* Call the user callback */
+ /* Call the user callback. Idles are not in the main lock, so
+ lock it */
+ gdk_threads_enter ();
info->user_callback (info->mail_op, info->header, info->msg, info->user_data);
+ gdk_threads_leave ();
g_slice_free (NotifyGetMsgsInfo, info);
info = (GetFullMsgsInfo *) data;
- if (info->notify)
+ if (info->notify) {
+ gdk_threads_enter ();
info->notify (info->user_data);
+ gdk_threads_leave ();
+ }
/* free */
g_object_unref (info->headers);
priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
/* Notify about operation end */
- g_idle_add (notify_update_account_queue, g_object_ref (info->mail_op));
+ g_idle_add (idle_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);
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);
+ modest_mail_operation_notify_end (self, FALSE);
if (notify)
notify (user_data);
}
void
-modest_mail_operation_remove_msg (ModestMailOperation *self,
- TnyHeader *header,
- gboolean remove_to_trash)
+modest_mail_operation_remove_msg (ModestMailOperation *self, TnyHeader *header,
+ gboolean remove_to_trash /*ignored*/)
{
TnyFolder *folder;
ModestMailOperationPrivate *priv;
g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
g_return_if_fail (TNY_IS_HEADER (header));
+ if (remove_to_trash)
+ g_warning ("remove to trash is not implemented");
+
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
folder = tny_header_get_folder (header);
priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
- /* Delete or move to trash */
- if (remove_to_trash) {
- TnyFolder *trash_folder;
- TnyStoreAccount *store_account;
-
- 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) {
- TnyList *headers;
- /* Create list */
- headers = tny_simple_list_new ();
- tny_list_append (headers, G_OBJECT (header));
- g_object_unref (header);
-
- /* Move to trash */
- modest_mail_operation_xfer_msgs (self, headers, trash_folder, TRUE, NULL, NULL);
- g_object_unref (headers);
-/* g_object_unref (trash_folder); */
- } else {
- ModestMailOperationPrivate *priv;
-
- /* Set status failed and set an error */
- priv = MODEST_MAIL_OPERATION_GET_PRIVATE(self);
- priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
- g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
- MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
- _("Error trying to delete a message. Trash folder not found"));
- }
-
- g_object_unref (G_OBJECT (store_account));
- } else {
- tny_folder_remove_msg (folder, header, &(priv->error));
- if (!priv->error)
- tny_folder_sync(folder, TRUE, &(priv->error));
+ tny_folder_remove_msg (folder, header, &(priv->error));
+ if (!priv->error) {
+ tny_header_set_flags (header, TNY_HEADER_FLAG_DELETED);
+
+ if (TNY_IS_CAMEL_IMAP_FOLDER (folder))
+ tny_folder_sync(folder, FALSE, &(priv->error)); /* FALSE --> don't expunge */
+ else if (TNY_IS_CAMEL_POP_FOLDER (folder))
+ tny_folder_sync(folder, TRUE, &(priv->error)); /* TRUE --> expunge */
+ else
+ /* lcoal folders */
+ tny_folder_sync(folder, TRUE, &(priv->error)); /* TRUE --> expunge */
}
-
+
+
/* Set status */
if (!priv->error)
priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
g_object_unref (G_OBJECT (folder));
/* Notify about operation end */
- modest_mail_operation_notify_end (self);
+ modest_mail_operation_notify_end (self, FALSE);
}
static void
priv->status = MODEST_MAIL_OPERATION_STATUS_SUCCESS;
}
+ /* Notify about operation end */
+ modest_mail_operation_notify_end (self, TRUE);
+
/* If user defined callback function was defined, call it */
if (helper->user_callback) {
+ gdk_threads_enter ();
helper->user_callback (priv->source, helper->user_data);
+ gdk_threads_leave ();
}
/* Free */
g_slice_free (XFerMsgAsyncHelper, helper);
g_object_unref (folder);
- /* Notify about operation end */
- modest_mail_operation_notify_end (self);
}
void
XFerMsgAsyncHelper *helper;
TnyHeader *header;
ModestTnyFolderRules rules;
+ const gchar *id1 = NULL;
+ const gchar *id2 = NULL;
+ gboolean same_folder = FALSE;
g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
g_return_if_fail (TNY_IS_LIST (headers));
/* Apply folder rules */
rules = modest_tny_folder_get_rules (TNY_FOLDER (folder));
-
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,
- _("FIXME: folder does not accept msgs"));
+ _("ckct_ib_unable_to_paste_here"));
/* Notify the queue */
- modest_mail_operation_notify_end (self);
+ modest_mail_operation_notify_end (self, FALSE);
+ return;
+ }
+
+ /* Get source folder */
+ iter = tny_list_create_iterator (headers);
+ header = TNY_HEADER (tny_iterator_get_current (iter));
+ src_folder = tny_header_get_folder (header);
+ g_object_unref (header);
+ g_object_unref (iter);
+
+ /* Check folder source and destination */
+ id1 = tny_folder_get_id (src_folder);
+ id2 = tny_folder_get_id (TNY_FOLDER(folder));
+ same_folder = !g_ascii_strcasecmp (id1, id2);
+ if (same_folder) {
+ /* 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,
+ _("mcen_ib_unable_to_copy_samefolder"));
+
+ /* Notify the queue */
+ modest_mail_operation_notify_end (self, FALSE);
+
+ /* Free */
+ g_object_unref (src_folder);
return;
}
helper->user_callback = user_callback;
helper->user_data = user_data;
- /* Get source folder */
- iter = tny_list_create_iterator (headers);
- header = TNY_HEADER (tny_iterator_get_current (iter));
- src_folder = tny_header_get_folder (header);
- g_object_unref (header);
- g_object_unref (iter);
-
/* Get account and set it into mail_operation */
priv->account = modest_tny_folder_get_account (src_folder);
out:
/* Call user defined callback, if it exists */
- if (helper->user_callback)
+ if (helper->user_callback) {
+ gdk_threads_enter ();
helper->user_callback (priv->source, folder, helper->user_data);
+ gdk_threads_leave ();
+ }
/* Free */
g_object_unref (helper->mail_op);
g_object_unref (folder);
/* Notify about operation end */
- modest_mail_operation_notify_end (self);
+ modest_mail_operation_notify_end (self, TRUE);
}
static void
* callback).
*/
static void
-modest_mail_operation_notify_end (ModestMailOperation *self)
+modest_mail_operation_notify_end (ModestMailOperation *self,
+ gboolean need_lock)
{
ModestMailOperationState *state;
ModestMailOperationPrivate *priv = NULL;
/* 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);
+ 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);
+ if (need_lock)
+ gdk_threads_enter ();
g_signal_emit (G_OBJECT (self), signals[PROGRESS_CHANGED_SIGNAL], 0, state, NULL);
+ if (need_lock)
+ gdk_threads_leave ();
g_slice_free (ModestMailOperationState, state);
}
projects / modest / blobdiff