#include "modest-platform.h"
#include "modest-debug.h"
#include <tny-mime-part.h>
+#include <tny-error.h>
#include <tny-camel-folder.h>
#include <tny-camel-imap-folder.h>
#include <tny-camel-pop-folder.h>
guint reply_forward_type;
ReplyForwardAction action;
gchar *account_name;
+ gchar *mailbox;
GtkWidget *parent_window;
TnyHeader *header;
} ReplyForwardHelper;
window_list = modest_window_mgr_get_window_list (mgr);
if (window_list == NULL) {
- ModestWindow *old_win;
win = MODEST_WINDOW (modest_accounts_window_new ());
if (modest_window_mgr_register_window (mgr, win, NULL)) {
gtk_widget_show_all (GTK_WIDGET (win));
win = NULL;
}
- old_win = win;
- win = MODEST_WINDOW (modest_folder_window_new (NULL));
- if (modest_window_mgr_register_window (mgr, win, NULL)) {
- gtk_widget_show_all (GTK_WIDGET (win));
- } else {
- gtk_widget_destroy (GTK_WIDGET (win));
- win = old_win;
- }
} else {
g_list_free (window_list);
}
modest_ui_actions_on_new_account (GtkAction *action,
ModestWindow *window)
{
- modest_ui_actions_run_account_setup_wizard (window);
+ if (!modest_ui_actions_run_account_setup_wizard (window)) {
+ g_debug ("%s: wizard was already running", __FUNCTION__);
+ }
}
void
#endif /* !MODEST_TOOLKIT_GTK */
}
+static guint64
+count_part_size (const gchar *part)
+{
+ GnomeVFSURI *vfs_uri;
+ gchar *escaped_filename;
+ gchar *filename;
+ GnomeVFSFileInfo *info;
+ guint64 result;
+
+ /* Estimation of attachment size if we cannot get it from file info */
+ result = 32768;
+
+ vfs_uri = gnome_vfs_uri_new (part);
+
+ escaped_filename = g_path_get_basename (gnome_vfs_uri_get_path (vfs_uri));
+ filename = gnome_vfs_unescape_string_for_display (escaped_filename);
+ g_free (escaped_filename);
+ gnome_vfs_uri_unref (vfs_uri);
+
+ info = gnome_vfs_file_info_new ();
+
+ if (gnome_vfs_get_file_info (part,
+ info,
+ GNOME_VFS_FILE_INFO_GET_MIME_TYPE)
+ == GNOME_VFS_OK) {
+ if (info->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_SIZE) {
+ result = info->size;
+ }
+ }
+ g_free (filename);
+ gnome_vfs_file_info_unref (info);
+
+ return result;
+}
+
+static guint64
+count_parts_size (GSList *parts)
+{
+ GSList *node;
+ guint64 result = 0;
+
+ for (node = parts; node != NULL; node = g_slist_next (node)) {
+ result += count_part_size ((const gchar *) node->data);
+ }
+
+ return result;
+}
+
void
modest_ui_actions_compose_msg(ModestWindow *win,
const gchar *to_str,
gboolean set_as_modified)
{
gchar *account_name = NULL;
+ const gchar *mailbox;
TnyMsg *msg = NULL;
TnyAccount *account = NULL;
TnyFolder *folder = NULL;
gchar *from_str = NULL, *signature = NULL, *body = NULL;
+ gchar *recipient = NULL;
gboolean use_signature = FALSE;
ModestWindow *msg_win = NULL;
ModestAccountMgr *mgr = modest_runtime_get_account_mgr();
ModestTnyAccountStore *store = modest_runtime_get_account_store();
GnomeVFSFileSize total_size, allowed_size;
+ guint64 available_disk, expected_size, parts_size;
+ guint parts_count;
/* we check for low-mem */
if (modest_platform_check_memory_low (win, TRUE))
goto cleanup;
+ available_disk = modest_utils_get_available_space (NULL);
+ parts_count = g_slist_length (attachments);
+ parts_size = count_parts_size (attachments);
+ expected_size = modest_tny_msg_estimate_size (body, NULL, parts_count, parts_size);
+
+ /* Double check: memory full condition or message too big */
+ if (available_disk < MIN_FREE_SPACE ||
+ expected_size > available_disk) {
+ gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
+ modest_platform_system_banner (NULL, NULL, msg);
+ g_free (msg);
+
+ return;
+ }
+
+ if (expected_size > MODEST_MAX_ATTACHMENT_SIZE) {
+ modest_platform_run_information_dialog (
+ GTK_WINDOW(win),
+ _FM("sfil_ib_opening_not_allowed"),
+ TRUE);
+ return;
+ }
+
+
#ifdef MODEST_TOOLKIT_HILDON2
- account_name = g_strdup (modest_window_get_active_account(win));
+ if (win)
+ account_name = g_strdup (modest_window_get_active_account(win));
#endif
if (!account_name) {
account_name = modest_account_mgr_get_default_account(mgr);
g_printerr ("modest: no account found\n");
goto cleanup;
}
+
+ if (win)
+ mailbox = modest_window_get_active_mailbox (win);
+ else
+ mailbox = NULL;
account = modest_tny_account_store_get_server_account (store, account_name, TNY_ACCOUNT_TYPE_STORE);
if (!account) {
g_printerr ("modest: failed to get tnyaccount for '%s'\n", account_name);
g_printerr ("modest: failed to find Drafts folder\n");
goto cleanup;
}
- from_str = modest_account_mgr_get_from_string (mgr, account_name);
+ from_str = modest_account_mgr_get_from_string (mgr, account_name, mailbox);
if (!from_str) {
g_printerr ("modest: failed get from string for '%s'\n", account_name);
goto cleanup;
}
- signature = modest_account_mgr_get_signature (mgr, account_name, &use_signature);
+ recipient = modest_text_utils_get_email_address (from_str);
+ signature = modest_account_mgr_get_signature_from_recipient (mgr, recipient, &use_signature);
+ g_free (recipient);
if (body_str != NULL) {
body = use_signature ? g_strconcat(body_str, "\n--\n", signature, NULL) : g_strdup(body_str);
} else {
body = use_signature ? g_strconcat("\n--\n", signature, NULL) : g_strdup("");
}
- msg = modest_tny_msg_new (to_str, from_str, cc_str, bcc_str, subject_str, body, NULL, NULL, NULL);
+ msg = modest_tny_msg_new (to_str, from_str, cc_str, bcc_str, subject_str, NULL, NULL, body, NULL, NULL, NULL);
if (!msg) {
g_printerr ("modest: failed to create new msg\n");
goto cleanup;
/* This is destroyed by TODO. */
total_size = 0;
allowed_size = MODEST_MAX_ATTACHMENT_SIZE;
- msg_win = modest_msg_edit_window_new (msg, account_name, FALSE);
+ msg_win = modest_msg_edit_window_new (msg, account_name, mailbox, FALSE);
if (!modest_window_mgr_register_window (modest_runtime_get_window_mgr(), msg_win, win)) {
gtk_widget_destroy (GTK_WIDGET (msg_win));
gtk_widget_show_all (GTK_WIDGET (msg_win));
while (attachments) {
- total_size +=
+ GnomeVFSFileSize att_size;
+ att_size =
modest_msg_edit_window_attach_file_one((ModestMsgEditWindow *)msg_win,
attachments->data, allowed_size);
+ total_size += att_size;
- if (total_size > allowed_size) {
- g_warning ("%s: total size: %u",
- __FUNCTION__, (unsigned int)total_size);
+ if (att_size > allowed_size) {
+ g_debug ("%s: total size: %u",
+ __FUNCTION__, (unsigned int)total_size);
break;
}
- allowed_size -= total_size;
+ allowed_size -= att_size;
attachments = g_slist_next(attachments);
}
if (open_in_editor) {
ModestAccountMgr *mgr = modest_runtime_get_account_mgr ();
gchar *from_header = NULL, *acc_name;
+ gchar *mailbox = NULL;
from_header = tny_header_dup_from (header);
}
}
- acc_name = modest_utils_get_account_name_from_recipient (from_header);
+ acc_name = modest_utils_get_account_name_from_recipient (from_header, &mailbox);
g_free (from_header);
if (acc_name) {
g_free (account);
account = acc_name;
}
- win = modest_msg_edit_window_new (msg, account, TRUE);
+ win = modest_msg_edit_window_new (msg, account, mailbox, TRUE);
+ if (mailbox)
+ g_free (mailbox);
} else {
gchar *uid = modest_tny_folder_get_header_unique_id (header);
+ const gchar *mailbox = NULL;
+
+ if (parent_win && MODEST_IS_WINDOW (parent_win))
+ mailbox = modest_window_get_active_mailbox (MODEST_WINDOW (parent_win));
if (helper->rowref && helper->model) {
- win = modest_msg_view_window_new_with_header_model (msg, account, (const gchar*) uid,
+ win = modest_msg_view_window_new_with_header_model (msg, account, mailbox, (const gchar*) uid,
helper->model, helper->rowref);
} else {
- win = modest_msg_view_window_new_for_attachment (msg, account, (const gchar*) uid);
+ win = modest_msg_view_window_new_for_attachment (msg, account, mailbox, (const gchar*) uid);
}
g_free (uid);
}
}
static gboolean
-is_memory_full_error (GError *error, ModestMailOperation *mail_op)
+is_memory_full_error (GError *error, ModestMailOperation *mail_op, gboolean *is_mmc)
{
gboolean enough_free_space = TRUE;
GnomeVFSURI *cache_dir_uri;
acc_store = TNY_ACCOUNT_STORE (modest_runtime_get_account_store ());
+ if (is_mmc)
+ *is_mmc = FALSE;
+
/* Cache dir is different in case we're using an external storage (like MMC account) */
if (mail_op) {
TnyAccount *account = modest_mail_operation_get_account (mail_op);
if (account) {
if (modest_tny_account_is_memory_card_account (account)) {
+ if (is_mmc)
+ *is_mmc = TRUE;
cache_dir = g_getenv (MODEST_MMC1_VOLUMEPATH_ENV);
}
g_object_unref (account);
}
}
+/* Shows an error if we're in memory full conditions. The #alternate
+ parametter contains the error that will be shown if the memory full
+ conditions happen in the mmc external storage */
static gboolean
-check_memory_full_error (GtkWidget *parent_window, GError *err)
+check_memory_full_error (GtkWidget *parent_window, GError *err, const gchar *alternate)
{
+ gboolean is_mcc;
+
if (err == NULL)
return FALSE;
- if (is_memory_full_error (err, NULL))
- modest_platform_information_banner (parent_window,
- NULL, _KR("cerm_device_memory_full"));
- else if (err->code == TNY_SYSTEM_ERROR_MEMORY)
+ if (is_memory_full_error (err, NULL, &is_mcc)) {
+ if (is_mcc && alternate) {
+ modest_platform_information_banner (parent_window, NULL, alternate);
+ } else {
+ gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
+ modest_platform_information_banner (parent_window, NULL, msg);
+ g_free (msg);
+ }
+ } else if (err->code == TNY_SYSTEM_ERROR_MEMORY)
/* If the account was created in memory full
conditions then tinymail won't be able to
connect so it'll return this error code */
/* If the mail op has been cancelled then it's not an error:
don't show any message */
if (status != MODEST_MAIL_OPERATION_STATUS_CANCELED) {
- if (is_memory_full_error ((GError *) error, mail_op)) {
- modest_platform_information_banner ((GtkWidget *) win,
- NULL, _KR("cerm_device_memory_full"));
+ if (is_memory_full_error ((GError *) error, mail_op, NULL)) {
+ gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
+ modest_platform_information_banner ((GtkWidget *) win, NULL, msg);
+ g_free (msg);
} else if (error->code == TNY_SYSTEM_ERROR_MEMORY) {
modest_platform_information_banner ((GtkWidget *) win,
NULL, _("emev_ui_imap_inbox_select_error"));
open_msg_helper_destroyer (helper);
/* In memory full conditions we could get this error here */
- check_memory_full_error ((GtkWidget *) parent_window, err);
+ check_memory_full_error ((GtkWidget *) parent_window, err, NULL);
goto clean;
}
header_view = get_header_view_from_window (MODEST_WINDOW (parent_window));
uid = modest_tny_folder_get_header_unique_id (helper->header);
if (header_view) {
- window = modest_msg_view_window_new_from_header_view
- (MODEST_HEADER_VIEW (header_view), account_name, uid, helper->rowref);
+ const gchar *mailbox = NULL;
+ mailbox = modest_window_get_active_mailbox (MODEST_WINDOW (parent_window));
+ window = modest_msg_view_window_new_from_header_view
+ (MODEST_HEADER_VIEW (header_view), account_name, mailbox, uid, helper->rowref);
if (window != NULL) {
if (!modest_window_mgr_register_window (modest_runtime_get_window_mgr (),
window, NULL)) {
{
ReplyForwardHelper *rf_helper = NULL;
const gchar *active_acc = modest_window_get_active_account (win);
+ const gchar *active_mailbox = modest_window_get_active_mailbox (win);
rf_helper = g_slice_new0 (ReplyForwardHelper);
rf_helper->reply_forward_type = reply_forward_type;
rf_helper->account_name = (active_acc) ?
g_strdup (active_acc) :
modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
+ rf_helper->mailbox = g_strdup (active_mailbox);
/* Note that window could be destroyed just AFTER calling
register_window so we must ensure that this pointer does
helper = (ReplyForwardHelper *) data;
g_free (helper->account_name);
+ g_free (helper->mailbox);
if (helper->header)
g_object_unref (helper->header);
if (helper->parent_window)
ModestWindowMgr *mgr = NULL;
gchar *signature = NULL;
gboolean use_signature;
+ gchar *recipient;
/* If there was any error. The mail operation could be NULL,
this means that we already have the message downloaded and
goto cleanup;
from = modest_account_mgr_get_from_string (modest_runtime_get_account_mgr(),
- rf_helper->account_name);
- signature = modest_account_mgr_get_signature (modest_runtime_get_account_mgr(),
- rf_helper->account_name,
- &use_signature);
+ rf_helper->account_name, rf_helper->mailbox);
+ recipient = modest_text_utils_get_email_address (from);
+ signature = modest_account_mgr_get_signature_from_recipient (modest_runtime_get_account_mgr(),
+ recipient,
+ &use_signature);
+ g_free (recipient);
/* Create reply mail */
switch (rf_helper->action) {
}
/* Create and register the windows */
- msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name, FALSE);
+ msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name, rf_helper->mailbox, FALSE);
mgr = modest_runtime_get_window_mgr ();
modest_window_mgr_register_window (mgr, msg_win, (ModestWindow *) rf_helper->parent_window);
send&receive was invoked by the user then do not show any
visual notification, only play a sound and activate the LED
(for the Maemo version) */
- if (TNY_IS_LIST(new_headers) && (tny_list_get_length (new_headers)) > 0)
- modest_platform_on_new_headers_received (new_headers,
- show_visual_notifications);
+ if (TNY_IS_LIST(new_headers) && (tny_list_get_length (new_headers)) > 0) {
+
+ /* We only notify about really new messages (not seen) we get */
+ TnyList *actually_new_list;
+ TnyIterator *iterator;
+ actually_new_list = TNY_LIST (tny_simple_list_new ());
+ for (iterator = tny_list_create_iterator (new_headers);
+ !tny_iterator_is_done (iterator);
+ tny_iterator_next (iterator)) {
+ TnyHeader *header;
+ TnyHeaderFlags flags;
+ header = TNY_HEADER (tny_iterator_get_current (iterator));
+ flags = tny_header_get_flags (header);
+
+ if (!(flags & TNY_HEADER_FLAG_SEEN)) {
+ tny_list_append (actually_new_list, G_OBJECT (header));
+ }
+ g_object_unref (header);
+ }
+ g_object_unref (iterator);
+
+ if (tny_list_get_length (actually_new_list) > 0) {
+ GList *new_headers_list = NULL;
+
+ new_headers_list = modest_utils_create_notification_list_from_header_list (actually_new_list);
+
+ /* Send notifications */
+ if (new_headers_list) {
+ modest_platform_on_new_headers_received (new_headers_list,
+ show_visual_notifications);
+ /* Free the list */
+ modest_utils_free_notification_list (new_headers_list);
+ }
+ }
+ g_object_unref (actually_new_list);
+ }
}
if (err || canceled) {
/* In memory full conditions we could get this error here */
- check_memory_full_error ((GtkWidget *) parent_window, err);
+ check_memory_full_error ((GtkWidget *) parent_window, err, NULL);
if (info->mail_op) {
modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (),
gchar *acc_name = NULL;
SendReceiveInfo *info;
ModestTnyAccountStore *acc_store;
+ TnyAccount *account;
/* If no account name was provided then get the current account, and if
there is no current account then pick the default one: */
}
acc_store = modest_runtime_get_account_store ();
+ account = modest_tny_account_store_get_server_account (acc_store, acc_name, TNY_ACCOUNT_TYPE_STORE);
+
+ /* Do not automatically refresh accounts that are flagged as
+ NO_AUTO_UPDATE. This could be useful for accounts that
+ handle their own update times */
+ if (!interactive) {
+ ModestProtocolType proto = modest_tny_account_get_protocol_type (account);
+ if (proto != MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
+ const gchar *tag = MODEST_PROTOCOL_REGISTRY_NO_AUTO_UPDATE_PROTOCOLS;
+ ModestProtocolRegistry *registry = modest_runtime_get_protocol_registry ();
+
+ if (modest_protocol_registry_protocol_type_has_tag (registry, proto, tag)) {
+ g_debug ("%s no auto update allowed for account %s", __FUNCTION__, account_name);
+ g_object_unref (account);
+ g_free (acc_name);
+ return;
+ }
+ }
+ }
/* Create the info for the connect and perform */
info = g_slice_new (SendReceiveInfo);
info->win = (win) ? g_object_ref (win) : NULL;
info->poke_status = poke_status;
info->interactive = interactive;
- info->account = modest_tny_account_store_get_server_account (acc_store, acc_name,
- TNY_ACCOUNT_TYPE_STORE);
+ info->account = account;
/* We need to create the operation here, because otherwise it
could happen that the queue emits the queue-empty signal
while we're trying to connect the account */
/* We need the TnyAccount provided by the
account store because that is the one that
knows the name of the Modest account */
- TnyAccount *modest_server_account = modest_server_account =
+ TnyAccount *modest_server_account =
modest_tny_account_store_get_tny_account_by (modest_runtime_get_account_store (),
MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
server_acc_name);
gpointer user_data)
{
ModestMainWindow *win = NULL;
- GtkWidget *folder_view;
+ GtkWidget *folder_view, *header_view;
const GError *error;
g_return_if_fail (TNY_IS_FOLDER (folder));
folder_view =
modest_main_window_get_child_widget(win, MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
+ header_view =
+ modest_main_window_get_child_widget(win, MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
if (folder_view) {
TnyFolderStore *current_folder;
}
/* Check if folder is empty and set headers view contents style */
- if (tny_folder_get_all_count (folder) == 0)
+ if ((tny_folder_get_all_count (folder) == 0) ||
+ modest_header_view_is_empty (MODEST_HEADER_VIEW (header_view)))
modest_main_window_set_contents_style (win,
MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
-
}
void
gboolean selected,
ModestMainWindow *main_window)
{
- ModestConf *conf;
GtkWidget *header_view;
g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
if (!header_view)
return;
- conf = modest_runtime_get_conf ();
if (TNY_IS_ACCOUNT (folder_store)) {
if (selected) {
} else {
if (TNY_IS_FOLDER (folder_store) && selected) {
TnyAccount *account;
- const gchar *account_name = NULL;
/* Update the active account */
account = modest_tny_folder_get_account (TNY_FOLDER (folder_store));
if (account) {
set_active_account_from_tny_account (account, MODEST_WINDOW (main_window));
- account_name =
- modest_tny_account_get_parent_modest_account_name_for_server_account (account);
g_object_unref (account);
account = NULL;
}
#ifdef MODEST_TOOLKIT_GTK
if (modest_main_window_get_contents_style (main_window) ==
MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
- modest_widget_memory_save (conf, G_OBJECT (header_view),
+ modest_widget_memory_save (modest_runtime_get_conf (),
+ G_OBJECT (header_view),
MODEST_CONF_HEADER_VIEW_KEY);
#endif
modest_header_view_clear (MODEST_HEADER_VIEW(header_view));
modest_ui_actions_on_msg_link_hover (ModestMsgView *msgview, const gchar* link,
ModestWindow *win)
{
- /* g_message ("%s %s", __FUNCTION__, link); */
+ /* g_debug ("%s %s", __FUNCTION__, link); */
}
const gchar *address,
ModestWindow *win)
{
- /* g_message ("%s %s", __FUNCTION__, address); */
+ /* g_debug ("%s %s", __FUNCTION__, address); */
}
static void
enough_space_for_message (ModestMsgEditWindow *edit_window,
MsgData *data)
{
- TnyAccountStore *acc_store;
guint64 available_disk, expected_size;
gint parts_count;
guint64 parts_size;
/* Check size */
- acc_store = TNY_ACCOUNT_STORE (modest_runtime_get_account_store());
available_disk = modest_utils_get_available_space (NULL);
modest_msg_edit_window_get_parts_size (edit_window, &parts_count, &parts_size);
expected_size = modest_tny_msg_estimate_size (data->plain_body,
/* Double check: memory full condition or message too big */
if (available_disk < MIN_FREE_SPACE ||
expected_size > available_disk) {
+ gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
+ modest_platform_information_banner (NULL, NULL, msg);
+ g_free (msg);
- modest_platform_information_banner (NULL, NULL,
- _KR("cerm_device_memory_full"));
return FALSE;
}
if (expected_size > MODEST_MAX_ATTACHMENT_SIZE) {
modest_platform_run_information_dialog (
GTK_WINDOW(edit_window),
- _KR("memr_ib_operation_disabled"),
+ _FM("sfil_ib_opening_not_allowed"),
TRUE);
return FALSE;
}
TnyTransportAccount *transport_account;
ModestMailOperation *mail_operation;
MsgData *data;
- gchar *account_name, *from;
+ gchar *account_name;
ModestAccountMgr *account_mgr;
gboolean had_error = FALSE;
ModestMainWindow *win = NULL;
modest_msg_edit_window_free_msg_data (edit_window, data);
return FALSE;
}
- from = modest_account_mgr_get_from_string (account_mgr, account_name);
/* Create the mail operation */
mail_operation = modest_mail_operation_new_with_error_handling (NULL, modest_ui_actions_disk_operations_error_handler,
modest_mail_operation_save_to_drafts (mail_operation,
transport_account,
data->draft_msg,
- from,
- data->to,
- data->cc,
+ data->from,
+ data->to,
+ data->cc,
data->bcc,
data->subject,
data->plain_body,
data->attachments,
data->images,
data->priority_flags,
+ data->references,
+ data->in_reply_to,
on_save_to_drafts_cb,
g_object_ref(edit_window));
modest_msg_edit_window_set_modified (edit_window, FALSE);
/* Frees */
- g_free (from);
g_free (account_name);
g_object_unref (G_OBJECT (transport_account));
g_object_unref (G_OBJECT (mail_operation));
MsgData *data;
ModestAccountMgr *account_mgr;
gchar *account_name;
- gchar *from;
ModestMailOperation *mail_operation;
+ gchar *recipients;
g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window), TRUE);
data = modest_msg_edit_window_get_msg_data (edit_window);
+ if (data->subject == NULL || data->subject[0] == '\0') {
+ /* Empty subject -> no send */
+ modest_msg_edit_window_free_msg_data (edit_window, data);
+ return FALSE;
+ }
+
+ recipients = g_strconcat (data->to?data->to:"",
+ data->cc?data->cc:"",
+ data->bcc?data->bcc:"",
+ NULL);
+ if (recipients == NULL || recipients[0] == '\0') {
+ /* Empty subject -> no send */
+ g_free (recipients);
+ modest_msg_edit_window_free_msg_data (edit_window, data);
+ return FALSE;
+ }
+ g_free (recipients);
+
/* Check size */
if (!enough_space_for_message (edit_window, data)) {
modest_msg_edit_window_free_msg_data (edit_window, data);
/* Create the mail operation */
- from = modest_account_mgr_get_from_string (account_mgr, account_name);
mail_operation = modest_mail_operation_new_with_error_handling (NULL, modest_ui_actions_disk_operations_error_handler, NULL, NULL);
modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
modest_mail_operation_send_new_mail (mail_operation,
transport_account,
data->draft_msg,
- from,
+ data->from,
data->to,
data->cc,
data->bcc,
data->html_body,
data->attachments,
data->images,
+ data->references,
+ data->in_reply_to,
data->priority_flags);
if (modest_mail_operation_get_status (mail_operation) == MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS)
}
/* Free data: */
- g_free (from);
g_free (account_name);
g_object_unref (G_OBJECT (transport_account));
g_object_unref (G_OBJECT (mail_operation));
stop the main loop in a gtk_dialog_run and then,
the message won't be shown until that dialog is
closed */
- modest_ui_actions_disk_operations_error_handler (mail_op,
- _("mail_in_ui_folder_create_error"));
-
- if (!is_memory_full_error ((GError *) error, mail_op)) {
- /* Try again if there is no full memory condition */
+ if (!check_memory_full_error ((GtkWidget *) source_win, (GError *) error,
+ _("mail_in_ui_folder_create_error_memory"))) {
+ /* Show an error and try again if there is no
+ full memory condition */
+ modest_platform_information_banner ((GtkWidget *) source_win, NULL,
+ _("mail_in_ui_folder_create_error"));
do_create_folder (source_win, parent_folder, (const gchar *) suggested_name);
}
} else {
if (canceled || err) {
/* In memory full conditions we could get this error here */
- check_memory_full_error ((GtkWidget *) parent_window, err);
+ check_memory_full_error ((GtkWidget *) parent_window, err,
+ _("mail_in_ui_folder_create_error_memory"));
+
+ /* This happens if we have selected the outbox folder
+ as the parent */
+ if (err->code == TNY_SERVICE_ERROR_UNKNOWN &&
+ TNY_IS_MERGE_FOLDER (helper->parent)) {
+ /* Show an error and retry */
+ modest_platform_information_banner ((GtkWidget *) parent_window,
+ NULL,
+ _("mail_in_ui_folder_create_error"));
+
+ do_create_folder (parent_window, helper->parent, helper->folder_name);
+ }
+
goto frees;
}
static void
modest_ui_actions_create_folder(GtkWidget *parent_window,
- GtkWidget *folder_view)
+ GtkWidget *folder_view,
+ TnyFolderStore *parent_folder)
{
- TnyFolderStore *parent_folder;
-
+ if (!parent_folder) {
#ifdef MODEST_TOOLKIT_HILDON2
- ModestTnyAccountStore *acc_store;
+ ModestTnyAccountStore *acc_store;
- acc_store = modest_runtime_get_account_store ();
+ acc_store = modest_runtime_get_account_store ();
- parent_folder = (TnyFolderStore *)
- modest_tny_account_store_get_local_folders_account (acc_store);
+ parent_folder = (TnyFolderStore *)
+ modest_tny_account_store_get_local_folders_account (acc_store);
#else
- parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
+ parent_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW(folder_view));
#endif
+ }
if (parent_folder) {
do_create_folder (GTK_WINDOW (parent_window), parent_folder, NULL);
if (!folder_view)
return;
- modest_ui_actions_create_folder (GTK_WIDGET (window), folder_view);
+ modest_ui_actions_create_folder (GTK_WIDGET (window), folder_view, NULL);
#ifdef MODEST_TOOLKIT_HILDON2
} else if (MODEST_IS_FOLDER_WINDOW (window)) {
GtkWidget *folder_view;
folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (MODEST_FOLDER_WINDOW (window)));
- modest_ui_actions_create_folder (GTK_WIDGET (window), folder_view);
+ modest_ui_actions_create_folder (GTK_WIDGET (window), folder_view, NULL);
#endif
} else {
g_assert_not_reached ();
gpointer user_data)
{
const GError *error = NULL;
- const gchar *message = NULL;
+ gchar *message = NULL;
+ gboolean mem_full;
/* Get error message */
error = modest_mail_operation_get_error (mail_op);
if (!error)
g_return_if_reached ();
- if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
- error->code == MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS) {
+ mem_full = is_memory_full_error ((GError *) error, mail_op, NULL);
+ if (mem_full) {
+ message = g_strdup_printf (_KR("cerm_device_memory_full"), "");
+ } else if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
+ error->code == MODEST_MAIL_OPERATION_ERROR_FOLDER_EXISTS) {
message = _CS("ckdg_ib_folder_already_exists");
} else if (error->domain == TNY_ERROR_DOMAIN &&
error->code == TNY_SERVICE_ERROR_STATE) {
/* We don't set a parent for the dialog because the dialog
will be destroyed so the banner won't appear */
modest_platform_information_banner (NULL, NULL, message);
+
+ if (mem_full)
+ g_free (message);
}
typedef struct {
if (canceled || err) {
/* In memory full conditions we could get this error here */
- check_memory_full_error ((GtkWidget *) parent_window, err);
+ check_memory_full_error ((GtkWidget *) parent_window, err, NULL);
} else {
mail_op =
GtkTreeSelection *sel;
if (!MODEST_IS_WINDOW(parent_window) || canceled || (err!=NULL)) {
+ /* Note that the connection process can fail due to
+ memory low conditions as it can not successfully
+ store the summary */
+ if (!check_memory_full_error ((GtkWidget*) parent_window, err, NULL))
+ g_debug ("Error connecting when trying to delete a folder");
g_object_unref (G_OBJECT (info->folder));
g_free (info);
return;
gpointer user_data)
{
- modest_platform_run_header_details_dialog (GTK_WINDOW (window), header);
+ gboolean async_retrieval;
+ TnyMsg *msg = NULL;
+
+ if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
+ async_retrieval = TRUE;
+ msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (window));
+ } else {
+ async_retrieval = FALSE;
+ }
+ modest_platform_run_header_details_dialog (GTK_WINDOW (window), header, async_retrieval, msg);
+ if (msg)
+ g_object_unref (msg);
}
/*
GtkWidget *parent_win;
MoveToInfo *helper = NULL;
ModestFolderView *folder_view;
+ gboolean unset_edit_mode = FALSE;
helper = (MoveToInfo *) user_data;
switch (response) {
TnyFolderStore *dst_folder;
+ TnyFolderStore *selected;
case MODEST_GTK_RESPONSE_NEW_FOLDER:
- modest_ui_actions_create_folder (GTK_WIDGET (dialog), GTK_WIDGET (folder_view));
+ selected = modest_folder_view_get_selected (folder_view);
+ modest_ui_actions_create_folder (GTK_WIDGET (dialog), GTK_WIDGET (folder_view), selected);
+ g_object_unref (selected);
return;
case GTK_RESPONSE_NONE:
case GTK_RESPONSE_CANCEL:
if (dst_folder)
g_object_unref (dst_folder);
+ unset_edit_mode = TRUE;
break;
default:
g_warning ("%s unexpected response id %d", __FUNCTION__, response);
/* Free the helper and exit */
if (helper->list)
g_object_unref (helper->list);
+ if (unset_edit_mode) {
+#ifdef MODEST_TOOLKIT_HILDON2
+ modest_hildon2_window_unset_edit_mode (MODEST_HILDON2_WINDOW (helper->win));
+#endif
+ }
g_slice_free (MoveToInfo, helper);
gtk_widget_destroy (GTK_WIDGET (dialog));
}
g_object_set_data (G_OBJECT(dialog), MODEST_MOVE_TO_DIALOG_FOLDER_VIEW, tree_view);
/* Hide special folders */
+#ifndef MODEST_TOOLKIT_HILDON2
modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (tree_view), FALSE);
+#endif
if (list_to_move)
modest_folder_view_set_list_to_move (MODEST_FOLDER_VIEW (tree_view), list_to_move);
#ifndef MODEST_TOOLKIT_HILDON2
modest_msg_view_window_remove_attachments (MODEST_MSG_VIEW_WINDOW (msg_view_window), TRUE);
else {
/* do nothing; uid was registered before, so window is probably on it's way */
- g_warning ("debug: header %p has already been registered", header);
+ g_debug ("header %p has already been registered", header);
}
} else {
ModestMailOperation *mail_op = NULL;
win = modest_mail_operation_get_source (mail_op);
error = modest_mail_operation_get_error (mail_op);
- if (error && is_memory_full_error ((GError *) error, mail_op))
- modest_platform_information_banner ((GtkWidget *) win,
- NULL, _KR("cerm_device_memory_full"));
- else
+ if (error && is_memory_full_error ((GError *) error, mail_op, NULL)) {
+ gchar *msg = g_strdup_printf (_KR("cerm_device_memory_full"), "");
+ modest_platform_information_banner ((GtkWidget *) win, NULL, msg);
+ g_free (msg);
+ } else {
modest_platform_run_information_dialog ((GtkWindow *) win,
_("mail_in_ui_folder_move_target_error"),
FALSE);
+ }
if (win)
g_object_unref (win);
}
helper = (XferMsgsHelper *) user_data;
if (canceled || err) {
- if (!check_memory_full_error ((GtkWidget *) parent_window, err)) {
+ if (!check_memory_full_error ((GtkWidget *) parent_window, err, NULL)) {
/* Show the proper error message */
modest_ui_actions_on_account_connection_error (parent_window, account);
}
/* Show the dialog */
gtk_widget_show (dialog);
- return TRUE;
+ return FALSE;
}
/*
{
/* We only need this callback to show an error in case of
memory low condition */
- modest_ui_actions_msg_retrieval_check (mail_op, header, msg);
+ if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) {
+ g_debug ("%s: message failed to retrieve. Memory low?", __FUNCTION__);
+ }
}
static void
TnyList *headers = TNY_LIST (user_data);
if (err || canceled) {
- check_memory_full_error ((GtkWidget *) parent_window, err);
+ check_memory_full_error ((GtkWidget *) parent_window, err, NULL);
goto out;
}
}
iter = tny_list_create_iterator (headers);
header = TNY_HEADER (tny_iterator_get_current (iter));
- folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
+ if (header) {
+ folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
+ } else {
+ g_warning ("List should contain headers");
+ }
g_object_unref (iter);
g_object_unref (headers);
#endif
} else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
- folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
+ if (header)
+ folder = TNY_FOLDER_STORE (tny_header_get_folder (header));
}
if (!header || !folder)
}
return removed;
}
+
+static void
+on_fetch_images_performer (gboolean canceled,
+ GError *err,
+ GtkWindow *parent_window,
+ TnyAccount *account,
+ gpointer user_data)
+{
+ if (err || canceled) {
+ /* Show an unable to retrieve images ??? */
+ return;
+ }
+
+ /* Note that the user could have closed the window while connecting */
+ if (GTK_WIDGET_VISIBLE (parent_window))
+ modest_msg_view_window_fetch_images ((ModestMsgViewWindow *) parent_window);
+ g_object_unref ((GObject *) user_data);
+}
+
+void
+modest_ui_actions_on_fetch_images (GtkAction *action,
+ ModestWindow *window)
+{
+ g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
+
+ modest_platform_connect_and_perform ((GtkWindow *) window, TRUE,
+ NULL,
+ on_fetch_images_performer,
+ g_object_ref (window));
+}
+
+void
+modest_ui_actions_on_reload_message (const gchar *msg_id)
+{
+ ModestWindow *window = NULL;
+
+ g_return_if_fail (msg_id && msg_id[0] != '\0');
+ if (!modest_window_mgr_find_registered_message_uid (modest_runtime_get_window_mgr (),
+ msg_id,
+ &window))
+ return;
+
+
+ if (window == NULL || !MODEST_IS_MSG_VIEW_WINDOW (window))
+ return;
+
+ modest_msg_view_window_reload (MODEST_MSG_VIEW_WINDOW (window));
+}