/* Copyright (c) 2006, Nokia Corporation
- * All rights reserved.
+ * All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-
+
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif /*HAVE_CONFIG_H*/
#include <glib/gprintf.h>
#include <string.h>
#include <modest-runtime.h>
+#include <modest-defs.h>
#include <modest-tny-folder.h>
#include <modest-tny-msg.h>
#include <modest-tny-account.h>
#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>
#include <hildon/hildon-gtk.h>
#include <modest-header-window.h>
#include <modest-folder-window.h>
+#include <modest-maemo-utils.h>
#endif
#ifdef MODEST_PLATFORM_MAEMO
#include <gtkhtml/gtkhtml.h>
-#define MIN_FREE_SPACE 5 * 1024 * 1024
#define MODEST_MOVE_TO_DIALOG_FOLDER_VIEW "move-to-dialog-folder-view"
-typedef struct _GetMsgAsyncHelper {
+typedef struct _GetMsgAsyncHelper {
ModestWindow *window;
ModestMailOperation *mail_op;
TnyIterator *iter;
guint num_ops;
- GFunc func;
+ GFunc func;
gpointer user_data;
} GetMsgAsyncHelper;
guint reply_forward_type;
ReplyForwardAction action;
gchar *account_name;
+ gchar *mailbox;
GtkWidget *parent_window;
TnyHeader *header;
} ReplyForwardHelper;
*/
typedef void (*HeadersFunc) (TnyHeader *header, ModestWindow *win, gpointer user_data);
-static void do_headers_action (ModestWindow *win,
+static void do_headers_action (ModestWindow *win,
HeadersFunc func,
gpointer user_data);
-static void open_msg_cb (ModestMailOperation *mail_op,
- TnyHeader *header,
+static void open_msg_cb (ModestMailOperation *mail_op,
+ TnyHeader *header,
gboolean canceled,
TnyMsg *msg,
GError *err,
gpointer user_data);
-static void reply_forward_cb (ModestMailOperation *mail_op,
- TnyHeader *header,
+static void reply_forward_cb (ModestMailOperation *mail_op,
+ TnyHeader *header,
gboolean canceled,
TnyMsg *msg,
GError *err,
static void reply_forward (ReplyForwardAction action, ModestWindow *win);
-static void folder_refreshed_cb (ModestMailOperation *mail_op,
- TnyFolder *folder,
+static void folder_refreshed_cb (ModestMailOperation *mail_op,
+ TnyFolder *folder,
gpointer user_data);
-static void on_send_receive_finished (ModestMailOperation *mail_op,
+static void on_send_receive_finished (ModestMailOperation *mail_op,
gpointer user_data);
static gint header_list_count_uncached_msgs (TnyList *header_list);
static gboolean remote_folder_has_leave_on_server (TnyFolderStore *folder);
-static void do_create_folder (GtkWindow *window,
- TnyFolderStore *parent_folder,
+static void do_create_folder (GtkWindow *window,
+ TnyFolderStore *parent_folder,
const gchar *suggested_name);
static TnyAccount *get_account_from_folder_store (TnyFolderStore *folder_store);
gboolean result;
g_return_val_if_fail (TNY_IS_FOLDER_STORE (folder), FALSE);
-
+
account = get_account_from_folder_store (folder);
result = (modest_protocol_registry_protocol_type_has_leave_on_server (modest_runtime_get_protocol_registry (),
modest_tny_account_get_protocol_type (account)));
modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), GTK_WINDOW (wizard), (GtkWindow *) win);
#ifndef MODEST_TOOLKIT_HILDON2
- /* always present a main window in the background
+ /* always present a main window in the background
* we do it here, so we cannot end up with two wizards (as this
* function might be called in modest_window_mgr_get_main_window as well */
if (!win)
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);
}
}
-void
+void
modest_ui_actions_on_about (GtkAction *action, ModestWindow *win)
{
GtkWidget *about;
gtk_about_dialog_set_website (GTK_ABOUT_DIALOG(about), "http://modest.garage.maemo.org");
gtk_window_set_transient_for (GTK_WINDOW (about), GTK_WINDOW (win));
gtk_window_set_modal (GTK_WINDOW (about), TRUE);
-
+
gtk_dialog_run (GTK_DIALOG (about));
gtk_widget_destroy(about);
}
get_selected_headers (ModestWindow *win)
{
if (MODEST_IS_MAIN_WINDOW(win)) {
- GtkWidget *header_view;
-
+ GtkWidget *header_view;
+
header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
return modest_header_view_get_selected_headers (MODEST_HEADER_VIEW(header_view));
-
+
} else if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
/* for MsgViewWindows, we simply return a list with one element */
TnyHeader *header;
TnyList *list = NULL;
-
+
header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
if (header != NULL) {
list = tny_simple_list_new ();
}
}
-/** After deleing a message that is currently visible in a window,
+/** After deleing a message that is currently visible in a window,
* show the next message from the list, or close the window if there are no more messages.
**/
-void
+void
modest_ui_actions_refresh_message_window_after_delete (ModestMsgViewWindow* win)
{
/* Close msg view window or select next */
if (!modest_msg_view_window_select_next_message (win) &&
!modest_msg_view_window_select_previous_message (win)) {
gboolean ret_value;
- g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
+ g_signal_emit_by_name (G_OBJECT (win), "delete-event", NULL, &ret_value);
}
}
gboolean retval = TRUE;
g_return_val_if_fail (MODEST_IS_WINDOW(win), FALSE);
-
+
/* Check first if the header view has the focus */
if (MODEST_IS_MAIN_WINDOW (win)) {
- header_view =
+ header_view =
modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
if (!gtk_widget_is_focus (header_view))
return FALSE;
}
-
+
/* Get the headers, either from the header view (if win is the main window),
* or from the message view window: */
header_list = get_selected_headers (win);
if (!header_list) return FALSE;
-
+
/* Check if any of the headers are already opened, or in the process of being opened */
if (MODEST_IS_MAIN_WINDOW (win)) {
gint opened_headers = 0;
if (opened_headers > 0) {
gchar *msg;
- msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"),
+ msg = g_strdup_printf (_("mcen_nc_unable_to_delete_n_messages"),
opened_headers);
modest_platform_run_information_dialog (GTK_WINDOW (win), (const gchar *) msg, FALSE);
-
+
g_free (msg);
g_object_unref (header_list);
return FALSE;
subject = tny_header_dup_subject (header);
if (!subject)
subject = g_strdup (_("mail_va_no_subject"));
- desc = g_strdup_printf ("%s", subject);
+ desc = g_strdup_printf ("%s", subject);
g_free (subject);
g_object_unref (header);
}
g_object_unref (iter);
}
- message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
+ message = g_strdup_printf(ngettext("emev_nc_delete_message", "emev_nc_delete_messages",
tny_list_get_length(header_list)), desc);
/* Confirmation dialog */
response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
message);
-
- if (response == GTK_RESPONSE_OK) {
- ModestWindow *main_window = NULL;
+
+ if (response == GTK_RESPONSE_OK) {
ModestWindowMgr *mgr = NULL;
GtkTreeModel *model = NULL;
GtkTreeSelection *sel = NULL;
GtkTreePath *prev_path = NULL;
ModestMailOperation *mail_op = NULL;
- /* Find last selected row */
+ /* Find last selected row */
if (MODEST_IS_MAIN_WINDOW (win)) {
model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
}
}
}
-
+
/* Disable window dimming management */
- modest_window_disable_dimming (MODEST_WINDOW(win));
+ modest_window_disable_dimming (win);
/* Remove each header. If it's a view window header_view == NULL */
mail_op = modest_mail_operation_new ((GObject *) win);
mail_op);
modest_mail_operation_remove_msgs (mail_op, header_list, FALSE);
g_object_unref (mail_op);
-
+
/* Enable window dimming management */
if (sel != NULL) {
gtk_tree_selection_unselect_all (sel);
}
- modest_window_enable_dimming (MODEST_WINDOW(win));
-
+ modest_window_enable_dimming (win);
+
if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
modest_ui_actions_refresh_message_window_after_delete (MODEST_MSG_VIEW_WINDOW (win));
-
+
/* Get main window */
mgr = modest_runtime_get_window_mgr ();
- main_window = modest_window_mgr_get_main_window (mgr, FALSE); /* don't create */
} else if (MODEST_IS_MAIN_WINDOW (win)) {
- /* Move cursor to next row */
- main_window = win;
-
/* Select next or previous row */
if (gtk_tree_row_reference_valid (next_row_reference)) {
gtk_tree_selection_select_path (sel, next_path);
}
- else if (gtk_tree_row_reference_valid (prev_row_reference)) {
+ else if (gtk_tree_row_reference_valid (prev_row_reference)) {
gtk_tree_selection_select_path (sel, prev_path);
}
/* Free */
- if (gtk_tree_row_reference_valid (next_row_reference))
+ if (gtk_tree_row_reference_valid (next_row_reference))
gtk_tree_row_reference_free (next_row_reference);
- if (next_path != NULL)
- gtk_tree_path_free (next_path);
- if (gtk_tree_row_reference_valid (prev_row_reference))
+ if (next_path != NULL)
+ gtk_tree_path_free (next_path);
+ if (gtk_tree_row_reference_valid (prev_row_reference))
gtk_tree_row_reference_free (prev_row_reference);
- if (prev_path != NULL)
+ if (prev_path != NULL)
gtk_tree_path_free (prev_path);
}
-
+
/* Update toolbar dimming state */
- if (main_window) {
- modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (main_window));
- modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
- }
+ modest_ui_actions_check_menu_dimming_rules (win);
+ modest_ui_actions_check_toolbar_dimming_rules (win);
/* Free */
g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
modest_ui_actions_on_delete_message_or_folder (GtkAction *action, ModestWindow *win)
{
g_return_if_fail (MODEST_IS_WINDOW(win));
-
+
/* Check first if the header view has the focus */
if (MODEST_IS_MAIN_WINDOW (win)) {
GtkWidget *w;
void
modest_ui_actions_on_quit (GtkAction *action, ModestWindow *win)
-{
+{
ModestWindowMgr *mgr = NULL;
-
+
#ifdef MODEST_PLATFORM_MAEMO
modest_osso_save_state();
#endif /* MODEST_PLATFORM_MAEMO */
(modest_runtime_get_mail_operation_queue()));
/* cancel all outstanding operations */
- modest_mail_operation_queue_cancel_all
+ modest_mail_operation_queue_cancel_all
(modest_runtime_get_mail_operation_queue());
-
+
g_debug ("queue has been cleared");
- /* Check if there are opened editing windows */
+ /* Check if there are opened editing windows */
mgr = modest_runtime_get_window_mgr ();
modest_window_mgr_close_all_windows (mgr);
modest_ui_actions_add_to_contacts (GtkAction *action, ModestWindow *win)
{
g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win));
-
+
modest_msg_view_window_add_to_contacts (MODEST_MSG_VIEW_WINDOW (win));
}
clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
selection = gtk_clipboard_wait_for_text (clipboard);
- /* Question: why is the clipboard being used here?
+ /* Question: why is the clipboard being used here?
* It doesn't really make a lot of sense. */
if (selection)
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
/* The accounts dialog must be modal */
modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (account_win), (GtkWindow *) win);
- modest_utils_show_dialog_and_forget (GTK_WINDOW (win), GTK_DIALOG (account_win));
+ modest_utils_show_dialog_and_forget (GTK_WINDOW (win), GTK_DIALOG (account_win));
}
}
modest_ui_actions_on_smtp_servers (GtkAction *action, ModestWindow *win)
{
/* This is currently only implemented for Maemo,
- * because it requires an API (libconic) to detect different connection
+ * because it requires an API (libconic) to detect different connection
* possiblities.
*/
#ifndef MODEST_TOOLKIT_GTK /* Defined in config.h */
/* Create the window if necessary: */
GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
modest_connection_specific_smtp_window_fill_with_connections (
- MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
+ MODEST_CONNECTION_SPECIFIC_SMTP_WINDOW (specific_window),
modest_runtime_get_account_mgr());
/* Show the window: */
- modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
+ modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
GTK_WINDOW (specific_window), (GtkWindow *) win);
gtk_widget_show (specific_window);
#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: disk full condition or message too big */
+ if (available_disk < MODEST_TNY_ACCOUNT_STORE_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),
+ _("mail_ib_error_attachment_size"),
+ 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);
+ body = use_signature ? g_strconcat(body_str, "\n",
+ MODEST_TEXT_UTILS_SIGNATURE_MARKER,
+ "\n", signature, NULL) : g_strdup(body_str);
} else {
- body = use_signature ? g_strconcat("\n--\n", signature, NULL) : g_strdup("");
+ body = use_signature ? g_strconcat("\n", MODEST_TEXT_UTILS_SIGNATURE_MARKER,
+ "\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);
}
g_free (signature);
g_free (body);
g_free (account_name);
- if (account)
+ if (account)
g_object_unref (G_OBJECT(account));
if (folder)
g_object_unref (G_OBJECT(folder));
if (!modest_account_mgr_has_accounts (modest_runtime_get_account_mgr(), TRUE))
if (!modest_ui_actions_run_account_setup_wizard (win))
return;
-
+
modest_ui_actions_compose_msg(win, NULL, NULL, NULL, NULL, NULL, NULL, FALSE);
}
-gboolean
+gboolean
modest_ui_actions_msg_retrieval_check (ModestMailOperation *mail_op,
TnyHeader *header,
TnyMsg *msg)
error->code == TNY_SERVICE_ERROR_MESSAGE_NOT_AVAILABLE)) {
gchar *subject, *msg, *format = NULL;
TnyAccount *account;
- subject = tny_header_dup_subject (header);
+
+ subject = header?tny_header_dup_subject (header):NULL;
if (!subject)
subject = g_strdup (_("mail_va_no_subject"));
}
/* Remove the header from the preregistered uids */
- modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
+ modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
header);
return FALSE;
typedef struct {
GtkTreeModel *model;
TnyHeader *header;
+ ModestWindow *caller_window;
OpenMsgBannerInfo *banner_info;
GtkTreeRowReference *rowref;
} OpenMsgHelper;
gdk_threads_enter ();
banner_info->idle_handler = 0;
banner_info->banner = modest_platform_animation_banner (NULL, NULL, banner_info->message);
- if (banner_info)
+ if (banner_info->banner)
g_object_ref (banner_info->banner);
-
+
gdk_threads_leave ();
return FALSE;
-
}
static GtkWidget *
}
static void
-open_msg_cb (ModestMailOperation *mail_op,
- TnyHeader *header,
+open_msg_cb (ModestMailOperation *mail_op,
+ TnyHeader *header,
gboolean canceled,
- TnyMsg *msg,
+ TnyMsg *msg,
GError *err,
gpointer user_data)
{
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);
}
g_object_unref (parent_win);
}
-static gboolean
-is_memory_full_error (GError *error)
-{
- gboolean enough_free_space = TRUE;
- GnomeVFSURI *cache_dir_uri;
- const gchar *cache_dir;
- GnomeVFSFileSize free_space;
-
- cache_dir = tny_account_store_get_cache_dir (TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
- cache_dir_uri = gnome_vfs_uri_new (cache_dir);
- if (gnome_vfs_get_volume_free_space (cache_dir_uri, &free_space) == GNOME_VFS_OK) {
- if (free_space < MIN_FREE_SPACE)
- enough_free_space = FALSE;
- }
- gnome_vfs_uri_unref (cache_dir_uri);
-
- if ((error->code == TNY_SYSTEM_ERROR_MEMORY ||
- /* When asking for a mail and no space left on device
- tinymail returns this error */
- error->code == TNY_SERVICE_ERROR_MESSAGE_NOT_AVAILABLE ||
- /* When the folder summary could not be read or
- written */
- error->code == TNY_IO_ERROR_WRITE ||
- error->code == TNY_IO_ERROR_READ) &&
- !enough_free_space) {
- return TRUE;
- } else {
- return FALSE;
- }
-}
-
-static gboolean
-check_memory_full_error (GtkWidget *parent_window, GError *err)
-{
- if (err == NULL)
- return FALSE;
-
- if (is_memory_full_error (err))
- modest_platform_information_banner (parent_window,
- NULL, _KR("cerm_device_memory_full"));
- 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 */
- modest_platform_information_banner (parent_window,
- NULL, _("emev_ui_imap_inbox_select_error"));
- else
- return FALSE;
-
- return TRUE;
-}
-
void
modest_ui_actions_disk_operations_error_handler (ModestMailOperation *mail_op,
gpointer user_data)
/* 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)) {
- modest_platform_information_banner ((GtkWidget *) win,
- NULL, _KR("cerm_device_memory_full"));
+ TnyAccount *account = modest_mail_operation_get_account (mail_op);
+ if (modest_tny_account_store_is_disk_full_error (modest_runtime_get_account_store(),
+ (GError *) error, account)) {
+ 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"));
modest_platform_information_banner ((GtkWidget *) win,
NULL, _CS ("sfil_ni_unable_to_open_file_not_found"));
} else if (user_data) {
- modest_platform_information_banner ((GtkWidget *) win,
+ modest_platform_information_banner ((GtkWidget *) win,
NULL, user_data);
}
+ if (account)
+ g_object_unref (account);
}
if (win)
TnyIterator *iter = tny_list_create_iterator (headers);
TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
TnyFolder *folder = tny_header_get_folder (header);
-
+
if (!folder) {
g_object_unref (header);
-
+
while (!tny_iterator_is_done (iter)) {
header = TNY_HEADER (tny_iterator_get_current (iter));
folder = tny_header_get_folder (header);
- if (folder)
+ if (folder)
break;
g_object_unref (header);
header = NULL;
account = tny_folder_get_account (folder);
g_object_unref (folder);
}
-
+
if (header)
g_object_unref (header);
-
+
g_object_unref (iter);
}
return account;
TnyFolder *folder;
folder = tny_header_get_folder (header);
-
+
if (folder) {
account = tny_folder_get_account (folder);
g_object_unref (folder);
}
static void
+caller_win_destroyed (OpenMsgHelper *helper, GObject *object)
+{
+ if (helper->caller_window)
+ helper->caller_window = NULL;
+}
+
+static void
open_msg_helper_destroyer (gpointer user_data)
{
OpenMsgHelper *helper = (OpenMsgHelper *) user_data;
+ if (helper->caller_window) {
+ g_object_weak_unref ((GObject *) helper->caller_window, (GWeakNotify) caller_win_destroyed, helper);
+ helper->caller_window = NULL;
+ }
+
if (helper->banner_info) {
g_free (helper->banner_info->message);
if (helper->banner_info->idle_handler > 0) {
}
static void
-open_msg_performer(gboolean canceled,
+open_msg_performer(gboolean canceled,
GError *err,
GtkWindow *parent_window,
TnyAccount *account,
gpointer user_data)
{
ModestMailOperation *mail_op = NULL;
- gchar *error_msg;
+ gchar *error_msg = NULL;
ModestProtocolType proto;
TnyConnectionStatus status;
OpenMsgHelper *helper = NULL;
helper = (OpenMsgHelper *) user_data;
status = tny_account_get_connection_status (account);
- if (err || canceled) {
+ if (err || canceled || helper->caller_window == NULL) {
modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (), helper->header);
/* Free the helper */
open_msg_helper_destroyer (helper);
- /* In memory full conditions we could get this error here */
- check_memory_full_error ((GtkWidget *) parent_window, err);
+ /* In disk full conditions we could get this error here */
+ modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
+ (GtkWidget *) parent_window, err,
+ account, NULL);
goto clean;
}
gboolean show_open_draft = FALSE;
if (modest_protocol_registry_protocol_type_has_tag (protocol_registry,
proto,
- MODEST_PROTOCOL_REGISTRY_LOCAL_STORE_PROTOCOLS)) {
+ MODEST_PROTOCOL_REGISTRY_LOCAL_STORE_PROTOCOLS)) {
TnyFolder *folder;
TnyFolderType folder_type;
header_view = get_header_view_from_window (MODEST_WINDOW (parent_window));
uid = modest_tny_folder_get_header_unique_id (helper->header);
if (header_view) {
+ 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, uid, helper->rowref);
+ (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)) {
g_free (account_name);
#endif
/* Create the mail operation */
- mail_op =
+ mail_op =
modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
modest_ui_actions_disk_operations_error_handler,
- error_msg, g_free);
+ g_strdup (error_msg), g_free);
modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
mail_op);
helper->banner_info = g_slice_new (OpenMsgBannerInfo);
helper->banner_info->message = g_strdup (_("mail_ib_opening_draft_message"));
helper->banner_info->banner = NULL;
- helper->banner_info->idle_handler = g_timeout_add (500, open_msg_banner_idle,
+ helper->banner_info->idle_handler = g_timeout_add (500, open_msg_banner_idle,
helper->banner_info);
}
#endif
/* Frees */
clean:
+ if (error_msg)
+ g_free (error_msg);
if (mail_op)
g_object_unref (mail_op);
g_object_unref (account);
(the user could switch between folders) */
helper = g_slice_new (OpenMsgHelper);
helper->model = g_object_ref (gtk_tree_view_get_model (GTK_TREE_VIEW (header_view)));
+ helper->caller_window = win;
+ g_object_weak_ref ((GObject *) helper->caller_window, (GWeakNotify) caller_win_destroyed, helper);
helper->header = g_object_ref (header);
helper->rowref = gtk_tree_row_reference_copy (rowref);
helper->banner_info = NULL;
/* Connect to the account and perform */
if (!cached) {
- modest_platform_connect_and_perform ((GtkWindow *) win, TRUE, g_object_ref (account),
+ modest_platform_connect_and_perform ((GtkWindow *) win, TRUE, g_object_ref (account),
open_msg_performer, helper);
} else {
/* Call directly the performer, do not need to connect */
- open_msg_performer (FALSE, NULL, (GtkWindow *) win,
+ open_msg_performer (FALSE, NULL, (GtkWindow *) win,
g_object_ref (account), helper);
}
cleanup:
TnyHeader *header;
gint headers_count;
TnyIterator *iter;
-
+
/* we check for low-mem; in that case, show a warning, and don't allow
* opening
*/
}
static ReplyForwardHelper*
-create_reply_forward_helper (ReplyForwardAction action,
+create_reply_forward_helper (ReplyForwardAction action,
ModestWindow *win,
guint reply_forward_type,
TnyHeader *header)
{
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->action = action;
rf_helper->parent_window = (MODEST_IS_WINDOW (win)) ? GTK_WIDGET (win) : NULL;
rf_helper->header = (header) ? g_object_ref (header) : NULL;
- rf_helper->account_name = (active_acc) ?
+ 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
not hold invalid references */
if (rf_helper->parent_window)
- g_object_weak_ref (G_OBJECT (rf_helper->parent_window),
+ g_object_weak_ref (G_OBJECT (rf_helper->parent_window),
rf_helper_window_closed, rf_helper);
return rf_helper;
helper = (ReplyForwardHelper *) data;
g_free (helper->account_name);
+ g_free (helper->mailbox);
if (helper->header)
g_object_unref (helper->header);
- if (helper->parent_window)
- g_object_weak_unref (G_OBJECT (helper->parent_window),
+ if (helper->parent_window)
+ g_object_weak_unref (G_OBJECT (helper->parent_window),
rf_helper_window_closed, helper);
g_slice_free (ReplyForwardHelper, helper);
}
static void
-reply_forward_cb (ModestMailOperation *mail_op,
- TnyHeader *header,
+reply_forward_cb (ModestMailOperation *mail_op,
+ TnyHeader *header,
gboolean canceled,
TnyMsg *msg,
GError *err,
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) {
+ /* Use the msg_header to ensure that we have all the
+ information. The summary can lack some data */
+ TnyHeader *msg_header;
case ACTION_REPLY:
- new_msg =
- modest_tny_msg_create_reply_msg (msg, header, from,
+ msg_header = tny_msg_get_header (msg);
+ new_msg =
+ modest_tny_msg_create_reply_msg (msg, msg_header, from,
(use_signature) ? signature : NULL,
rf_helper->reply_forward_type,
MODEST_TNY_MSG_REPLY_MODE_SENDER);
+ g_object_unref (msg_header);
break;
case ACTION_REPLY_TO_ALL:
- new_msg =
- modest_tny_msg_create_reply_msg (msg, header, from,
- (use_signature) ? signature : NULL,
+ msg_header = tny_msg_get_header (msg);
+ new_msg =
+ modest_tny_msg_create_reply_msg (msg, msg_header, from,
+ (use_signature) ? signature : NULL,
rf_helper->reply_forward_type,
MODEST_TNY_MSG_REPLY_MODE_ALL);
edit_type = MODEST_EDIT_TYPE_REPLY;
+ g_object_unref (msg_header);
break;
case ACTION_FORWARD:
- new_msg =
- modest_tny_msg_create_forward_msg (msg, from, (use_signature) ? signature : NULL,
+ new_msg =
+ modest_tny_msg_create_forward_msg (msg, from, (use_signature) ? signature : NULL,
rf_helper->reply_forward_type);
edit_type = MODEST_EDIT_TYPE_FORWARD;
break;
}
/* 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);
}
static void
-reply_forward_performer (gboolean canceled,
+reply_forward_performer (gboolean canceled,
GError *err,
- GtkWindow *parent_window,
- TnyAccount *account,
+ GtkWindow *parent_window,
+ TnyAccount *account,
gpointer user_data)
{
ReplyForwardHelper *rf_helper = NULL;
if (download) {
/* Create helper */
- rf_helper = create_reply_forward_helper (action, win,
+ rf_helper = create_reply_forward_helper (action, win,
reply_forward_type, header);
if (uncached_msgs > 0) {
- modest_platform_connect_and_perform (GTK_WINDOW (win),
- TRUE, account,
- reply_forward_performer,
+ modest_platform_connect_and_perform (GTK_WINDOW (win),
+ TRUE, account,
+ reply_forward_performer,
rf_helper);
} else {
- reply_forward_performer (FALSE, NULL, GTK_WINDOW (win),
+ reply_forward_performer (FALSE, NULL, GTK_WINDOW (win),
account, rf_helper);
}
}
reply_forward (ACTION_REPLY_TO_ALL, win);
}
-void
-modest_ui_actions_on_next (GtkAction *action,
+void
+modest_ui_actions_on_next (GtkAction *action,
ModestWindow *window)
{
if (MODEST_IS_MAIN_WINDOW (window)) {
MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
if (!header_view)
return;
-
+
modest_header_view_select_next (
- MODEST_HEADER_VIEW(header_view));
+ MODEST_HEADER_VIEW(header_view));
} else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
modest_msg_view_window_select_next_message (
MODEST_MSG_VIEW_WINDOW (window));
}
}
-void
-modest_ui_actions_on_prev (GtkAction *action,
+void
+modest_ui_actions_on_prev (GtkAction *action,
ModestWindow *window)
{
g_return_if_fail (MODEST_IS_WINDOW(window));
MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
if (!header_view)
return;
-
- modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
+
+ modest_header_view_select_prev (MODEST_HEADER_VIEW(header_view));
} else if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
modest_msg_view_window_select_previous_message (MODEST_MSG_VIEW_WINDOW (window));
} else {
}
}
-void
-modest_ui_actions_on_sort (GtkAction *action,
+void
+modest_ui_actions_on_sort (GtkAction *action,
ModestWindow *window)
{
GtkWidget *header_view = NULL;
if (!header_view) {
modest_platform_information_banner (NULL, NULL, _CS("ckdg_ib_nothing_to_sort"));
-
+
return;
}
/* Show sorting dialog */
- modest_utils_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
+ modest_utils_run_sort_dialog (GTK_WINDOW (window), MODEST_SORT_HEADERS);
}
static void
-new_messages_arrived (ModestMailOperation *self,
+new_messages_arrived (ModestMailOperation *self,
TnyList *new_headers,
gpointer user_data)
{
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);
+ }
}
gint response;
window = GTK_WINDOW (source);
- msg = g_strdup_printf (_("mail_nc_msg_count_limit_exceeded"),
+ msg = g_strdup_printf (_("mail_nc_msg_count_limit_exceeded"),
num_msgs, retrieve_limit);
/* Ask the user if they want to retrieve all the messages */
- response =
+ response =
modest_platform_run_confirmation_dialog_with_buttons (window, msg,
_("mcen_bd_get_all"),
_("mcen_bd_newest_only"));
} SendReceiveInfo;
static void
-do_send_receive_performer (gboolean canceled,
+do_send_receive_performer (gboolean canceled,
GError *err,
- GtkWindow *parent_window,
- TnyAccount *account,
+ GtkWindow *parent_window,
+ TnyAccount *account,
gpointer user_data)
{
SendReceiveInfo *info;
info = (SendReceiveInfo *) user_data;
if (err || canceled) {
- /* In memory full conditions we could get this error here */
- check_memory_full_error ((GtkWidget *) parent_window, err);
+ /* In disk full conditions we could get this error here */
+ modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
+ (GtkWidget *) parent_window, err,
+ account, NULL);
if (info->mail_op) {
modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (),
goto clean;
}
- /* Set send/receive operation in progress */
+ /* Set send/receive operation in progress */
if (info->win && MODEST_IS_MAIN_WINDOW (info->win)) {
modest_main_window_notify_send_receive_initied (MODEST_MAIN_WINDOW (info->win));
}
if (info->win && MODEST_IS_MAIN_WINDOW (info->win))
- g_signal_connect (G_OBJECT (info->mail_op), "operation-finished",
- G_CALLBACK (on_send_receive_finished),
+ g_signal_connect (G_OBJECT (info->mail_op), "operation-finished",
+ G_CALLBACK (on_send_receive_finished),
info->win);
/* Send & receive. */
modest_mail_operation_update_account (info->mail_op, info->account_name, info->poke_status, info->interactive,
- (info->win) ? retrieve_all_messages_cb : NULL,
+ (info->win) ? retrieve_all_messages_cb : NULL,
new_messages_arrived, info->win);
-
+
clean:
/* Frees */
if (info->mail_op)
* be more flexible.
*/
void
-modest_ui_actions_do_send_receive (const gchar *account_name,
+modest_ui_actions_do_send_receive (const gchar *account_name,
gboolean force_connection,
gboolean poke_status,
gboolean interactive,
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: */
if (!acc_name)
acc_name = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
if (!acc_name) {
- g_printerr ("modest: cannot get default account\n");
+ modest_platform_information_banner (NULL, NULL, _("emev_ni_internal_error"));
return;
}
} else {
}
acc_store = modest_runtime_get_account_store ();
+ account = modest_tny_account_store_get_server_account (acc_store, acc_name, TNY_ACCOUNT_TYPE_STORE);
+
+ if (!account) {
+ g_free (acc_name);
+ modest_platform_information_banner (NULL, NULL, _("emev_ni_internal_error"));
+ return;
+ }
+
+ /* 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 */
modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), info->mail_op);
/* Invoke the connect and perform */
- modest_platform_connect_and_perform ((win) ? GTK_WINDOW (win) : NULL,
- force_connection, info->account,
+ modest_platform_connect_and_perform ((win) ? GTK_WINDOW (win) : NULL,
+ force_connection, info->account,
do_send_receive_performer, info);
}
static void
-modest_ui_actions_do_cancel_send (const gchar *account_name,
+modest_ui_actions_do_cancel_send (const gchar *account_name,
ModestWindow *win)
{
TnyTransportAccount *transport_account;
}
frees:
- if (transport_account != NULL)
+ if (transport_account != NULL)
g_object_unref (G_OBJECT (transport_account));
}
static void
-modest_ui_actions_cancel_send_all (ModestWindow *win)
+modest_ui_actions_cancel_send_all (ModestWindow *win)
{
GSList *account_names, *iter;
- account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
+ account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
TRUE);
iter = account_names;
- while (iter) {
+ while (iter) {
modest_ui_actions_do_cancel_send ((const char*) iter->data, win);
iter = g_slist_next (iter);
}
{
/* Check if accounts exist */
- gboolean accounts_exist =
+ gboolean accounts_exist =
modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
-
+
/* If not, allow the user to create an account before trying to send/receive. */
if (!accounts_exist)
modest_ui_actions_on_accounts (NULL, win);
-
- /* Cancel all sending operaitons */
+
+ /* Cancel all sending operaitons */
modest_ui_actions_cancel_send_all (win);
}
* updates
*/
void
-modest_ui_actions_do_send_receive_all (ModestWindow *win,
+modest_ui_actions_do_send_receive_all (ModestWindow *win,
gboolean force_connection,
gboolean poke_status,
gboolean interactive)
{
GSList *account_names, *iter;
- account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
+ account_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(),
TRUE);
iter = account_names;
- while (iter) {
- modest_ui_actions_do_send_receive ((const char*) iter->data,
- force_connection,
+ while (iter) {
+ modest_ui_actions_do_send_receive ((const char*) iter->data,
+ force_connection,
poke_status, interactive, win);
iter = g_slist_next (iter);
}
accounts_exist =
modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
-
+
/* If not, allow the user to create an account before trying to send/receive. */
if (!accounts_exist)
modest_ui_actions_on_accounts (NULL, win);
-
+
/* Refresh the current folder. The if is always TRUE it's just an extra check */
if (MODEST_IS_MAIN_WINDOW (win)) {
GtkWidget *folder_view;
TnyFolderStore *folder_store;
- folder_view =
- modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
+ folder_view =
+ modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
if (!folder_view)
return;
-
+
folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
-
+
if (folder_store)
g_object_unref (folder_store);
/* Refresh the active account. Force the connection if needed
active_account = modest_window_get_active_account (MODEST_WINDOW (win));
modest_ui_actions_do_send_receive (active_account, TRUE, TRUE, TRUE, win);
- }
-
+ }
+
}
{
ModestConf *conf;
GtkWidget *header_view;
-
+
g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
header_view = modest_main_window_get_child_widget (main_window,
return;
conf = modest_runtime_get_conf ();
-
+
/* what is saved/restored is depending on the style; thus; we save with
* old style, then update the style, and restore for this new style
*/
modest_widget_memory_save (conf, G_OBJECT(header_view), MODEST_CONF_HEADER_VIEW_KEY);
-
+
if (modest_header_view_get_style
(MODEST_HEADER_VIEW(header_view)) == MODEST_HEADER_VIEW_STYLE_DETAILS)
modest_header_view_set_style (MODEST_HEADER_VIEW(header_view),
}
-void
-modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
+void
+modest_ui_actions_on_header_selected (ModestHeaderView *header_view,
TnyHeader *header,
ModestMainWindow *main_window)
{
g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
-
+
/* in the case the folder is empty, show the empty folder message and focus
* folder view */
if (!header && gtk_widget_is_focus (GTK_WIDGET (header_view))) {
if (modest_header_view_is_empty (header_view)) {
TnyFolder *folder = modest_header_view_get_folder (header_view);
- GtkWidget *folder_view =
+ GtkWidget *folder_view =
modest_main_window_get_child_widget (main_window,
MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
if (folder != NULL) {
ModestWindow *window)
{
const gchar *server_acc_name = tny_account_get_id (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,
+ MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
server_acc_name);
if (!modest_server_account) {
g_warning ("%s: could not get tny account\n", __FUNCTION__);
/* Update active account, but only if it's not a pseudo-account */
if ((!modest_tny_account_is_virtual_local_folders(modest_server_account)) &&
(!modest_tny_account_is_memory_card_account(modest_server_account))) {
- const gchar *modest_acc_name =
+ const gchar *modest_acc_name =
modest_tny_account_get_parent_modest_account_name_for_server_account (modest_server_account);
if (modest_acc_name)
modest_window_set_active_account (window, modest_acc_name);
}
-
+
g_object_unref (modest_server_account);
}
static void
-folder_refreshed_cb (ModestMailOperation *mail_op,
- TnyFolder *folder,
+folder_refreshed_cb (ModestMailOperation *mail_op,
+ TnyFolder *folder,
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));
/* Check if the operation failed due to memory low conditions */
error = modest_mail_operation_get_error (mail_op);
- if (error && error->domain == MODEST_MAIL_OPERATION_ERROR &&
+ if (error && error->domain == MODEST_MAIL_OPERATION_ERROR &&
error->code == MODEST_MAIL_OPERATION_ERROR_LOW_MEMORY) {
modest_platform_run_information_dialog (GTK_WINDOW (win),
_KR("memr_ib_operation_disabled"),
return;
}
- folder_view =
+ 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
+void
modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
- TnyFolderStore *folder_store,
+ TnyFolderStore *folder_store,
gboolean selected,
ModestMainWindow *main_window)
{
- ModestConf *conf;
GtkWidget *header_view;
g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
if (!header_view)
return;
-
- conf = modest_runtime_get_conf ();
+
if (TNY_IS_ACCOUNT (folder_store)) {
if (selected) {
set_active_account_from_tny_account (TNY_ACCOUNT (folder_store), MODEST_WINDOW (main_window));
-
+
/* Show account details */
modest_main_window_set_contents_style (main_window, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
}
} 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;
}
/* Set the header style by default, it could
be changed later by the refresh callback to
empty */
- modest_main_window_set_contents_style (main_window,
+ modest_main_window_set_contents_style (main_window,
MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
/* Set folder on header view. This function
MODEST_WINDOW (main_window),
folder_refreshed_cb,
main_window);
-
+
/* Restore configuration. We need to do this
*after* the set_folder because the widget
memory asks the header view about its
folder */
- modest_widget_memory_restore (modest_runtime_get_conf (),
+ modest_widget_memory_restore (modest_runtime_get_conf (),
G_OBJECT(header_view),
MODEST_CONF_HEADER_VIEW_KEY);
} else {
#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_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
}
-void
+void
modest_ui_actions_on_item_not_found (ModestHeaderView *header_view,ModestItemType type,
ModestWindow *win)
{
gboolean online;
item = (type == MODEST_ITEM_TYPE_FOLDER) ? "folder" : "message";
-
+
online = tny_device_is_online (modest_runtime_get_device());
if (online) {
NULL);
txt = g_strdup_printf (_("This %s is not available in offline mode.\n"
"Do you want to get online?"), item);
- gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
+ gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox),
gtk_label_new (txt), FALSE, FALSE, 0);
gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
g_free (txt);
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); */
+}
void
const gchar *address,
ModestWindow *win)
{
- /* g_message ("%s %s", __FUNCTION__, address); */
+ /* g_debug ("%s %s", __FUNCTION__, address); */
}
static void
-on_save_to_drafts_cb (ModestMailOperation *mail_op,
+on_save_to_drafts_cb (ModestMailOperation *mail_op,
TnyMsg *saved_draft,
gpointer user_data)
{
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,
parts_count,
parts_size);
- /* Double check: memory full condition or message too big */
- if (available_disk < MIN_FREE_SPACE ||
+ /* Double check: disk full condition or message too big */
+ if (available_disk < MODEST_TNY_ACCOUNT_STORE_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;
}
/*
* djcb: we also make sure that the attachments are smaller than the max size
- * this is for the case where we'd try to forward a message with attachments
+ * this is for the case where we'd try to forward a message with attachments
* bigger than our max allowed size, or sending an message from drafts which
* somehow got past our checks when attaching.
*/
if (expected_size > MODEST_MAX_ATTACHMENT_SIZE) {
modest_platform_run_information_dialog (
GTK_WINDOW(edit_window),
- _KR("memr_ib_operation_disabled"),
+ _("mail_ib_error_attachment_size"),
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;
g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window), FALSE);
-
+
data = modest_msg_edit_window_get_msg_data (edit_window);
/* Check size */
account_mgr = modest_runtime_get_account_mgr();
if (!account_name)
account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
- if (!account_name)
+ if (!account_name)
account_name = modest_account_mgr_get_default_account (account_mgr);
if (!account_name) {
g_printerr ("modest: no account found\n");
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 */
+ /* Create the mail operation */
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_save_to_drafts (mail_operation,
transport_account,
data->draft_msg,
- from,
+ data->from,
data->to,
data->cc,
data->bcc,
- data->subject,
- data->plain_body,
+ data->subject,
+ data->plain_body,
data->html_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);
if (!modest_msg_edit_window_check_names (edit_window, TRUE))
return 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);
if (!account_name)
account_name = g_strdup(modest_window_get_active_account (MODEST_WINDOW(edit_window)));
- if (!account_name)
+ if (!account_name)
account_name = modest_account_mgr_get_default_account (account_mgr);
-
+
if (!account_name) {
modest_msg_edit_window_free_msg_data (edit_window, data);
/* Run account setup wizard */
return TRUE;
}
}
-
+
/* Get the currently-active transport account for this modest account: */
if (strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID) != 0) {
- transport_account =
+ transport_account =
TNY_TRANSPORT_ACCOUNT(modest_tny_account_store_get_server_account
- (modest_runtime_get_account_store (),
+ (modest_runtime_get_account_store (),
account_name, TNY_ACCOUNT_TYPE_TRANSPORT));
}
-
+
if (!transport_account) {
modest_msg_edit_window_free_msg_data (edit_window, data);
/* Run account setup wizard */
if (!modest_ui_actions_run_account_setup_wizard(MODEST_WINDOW(edit_window)))
return TRUE;
}
-
+
/* 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->cc,
data->bcc,
- data->subject,
- data->plain_body,
+ data->subject,
+ data->plain_body,
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)
modest_platform_information_banner (NULL, NULL, _("mcen_ib_outbox_waiting_to_be_sent"));
-
if (modest_mail_operation_get_error (mail_operation) != NULL) {
const GError *error = modest_mail_operation_get_error (mail_operation);
if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
had_error = TRUE;
}
}
-
+
/* Free data: */
- g_free (from);
g_free (account_name);
g_object_unref (G_OBJECT (transport_account));
g_object_unref (G_OBJECT (mail_operation));
return !had_error;
}
-void
+void
modest_ui_actions_on_toggle_bold (GtkToggleAction *action,
ModestMsgEditWindow *window)
{
format_state->bold = gtk_toggle_action_get_active (action);
modest_msg_edit_window_set_format_state (window, format_state);
g_free (format_state);
-
+
}
-void
+void
modest_ui_actions_on_toggle_italics (GtkToggleAction *action,
ModestMsgEditWindow *window)
{
format_state->italics = gtk_toggle_action_get_active (action);
modest_msg_edit_window_set_format_state (window, format_state);
g_free (format_state);
-
+
}
-void
+void
modest_ui_actions_on_toggle_bullets (GtkToggleAction *action,
ModestMsgEditWindow *window)
{
format_state->bullet = gtk_toggle_action_get_active (action);
modest_msg_edit_window_set_format_state (window, format_state);
g_free (format_state);
-
+
}
-void
+void
modest_ui_actions_on_change_justify (GtkRadioAction *action,
GtkRadioAction *selected,
ModestMsgEditWindow *window)
g_free (format_state);
}
-void
+void
modest_ui_actions_on_select_editor_color (GtkAction *action,
ModestMsgEditWindow *window)
{
modest_msg_edit_window_select_color (window);
}
-void
+void
modest_ui_actions_on_select_editor_background_color (GtkAction *action,
ModestMsgEditWindow *window)
{
modest_msg_edit_window_select_background_color (window);
}
-void
+void
modest_ui_actions_on_insert_image (GObject *object,
ModestMsgEditWindow *window)
{
modest_msg_edit_window_insert_image (window);
}
-void
+void
modest_ui_actions_on_attach_file (GtkAction *action,
ModestMsgEditWindow *window)
{
if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
return;
-
+
modest_msg_edit_window_offer_attach_file (window);
}
-void
+void
modest_ui_actions_on_remove_attachments (GtkAction *action,
ModestMsgEditWindow *window)
{
modest_msg_edit_window_remove_attachments (window, NULL);
}
-
-#ifndef MODEST_TOOLKIT_GTK
-typedef struct {
- guint handler;
- gchar *name;
- GtkWindow *win;
- TnyFolderStore *folder;
-} CreateFolderHelper;
-
-static gboolean
-show_create_folder_in_timeout (gpointer data)
-{
- CreateFolderHelper *helper = (CreateFolderHelper *) data;
-
- /* Remove the timeout ASAP, we can not wait until the dialog
- is shown because it could take a lot of time and so the
- timeout could be called twice or more times */
- g_source_remove (helper->handler);
-
- gdk_threads_enter ();
- do_create_folder (helper->win, helper->folder, helper->name);
- gdk_threads_leave ();
-
- g_object_unref (helper->win);
- g_object_unref (helper->folder);
- g_free (helper->name);
- g_slice_free (CreateFolderHelper, helper);
-
- return FALSE;
-}
-#endif
-
static void
do_create_folder_cb (ModestMailOperation *mail_op,
- TnyFolderStore *parent_folder,
+ TnyFolderStore *parent_folder,
TnyFolder *new_folder,
gpointer user_data)
{
gchar *suggested_name = (gchar *) user_data;
GtkWindow *source_win = (GtkWindow *) modest_mail_operation_get_source (mail_op);
+ const GError *error;
- if (modest_mail_operation_get_error (mail_op)) {
-
+ error = modest_mail_operation_get_error (mail_op);
+ if (error) {
+ gboolean disk_full = FALSE;
+ TnyAccount *account;
/* Show an error. If there was some problem writing to
disk, show it, otherwise show the generic folder
create error. We do it here and not in an error
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"));
+ account = modest_mail_operation_get_account (mail_op);
+ if (account) {
+ disk_full =
+ modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
+ (GtkWidget *) source_win,
+ (GError *) error,
+ account,
+ _("mail_in_ui_folder_create_error_memory"));
+ g_object_unref (account);
+ }
+ if (!disk_full) {
+ /* 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);
+ }
- /* Try again. Do *NOT* show any error because the mail
- operations system will do it for us because we
- created the mail_op with new_with_error_handler */
-#ifndef MODEST_TOOLKIT_GTK
- CreateFolderHelper *helper;
- helper = g_slice_new0 (CreateFolderHelper);
- helper->name = g_strdup (suggested_name);
- helper->folder = g_object_ref (parent_folder);
- helper->win = g_object_ref (source_win);
-
- /* Ugly but neccesary stuff. The problem is that the
- dialog when is shown calls a function that destroys
- all the temporary windows, so the banner is
- destroyed */
- helper->handler = g_timeout_add (2000, show_create_folder_in_timeout, helper);
-#else
- do_create_folder (source_win, parent_folder, (const gchar *) suggested_name);
-#endif
} else {
/* the 'source_win' is either the ModestMainWindow, or the 'Move to folder'-dialog
* FIXME: any other? */
GtkWidget *folder_view;
- if (MODEST_IS_MAIN_WINDOW(source_win))
- folder_view =
+ if (MODEST_IS_MAIN_WINDOW(source_win))
+ folder_view =
modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (source_win),
MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
else
} CreateFolderConnect;
static void
-do_create_folder_performer (gboolean canceled,
+do_create_folder_performer (gboolean canceled,
GError *err,
- GtkWindow *parent_window,
- TnyAccount *account,
+ GtkWindow *parent_window,
+ TnyAccount *account,
gpointer user_data)
{
CreateFolderConnect *helper = (CreateFolderConnect *) user_data;
ModestMailOperation *mail_op;
if (canceled || err) {
- /* In memory full conditions we could get this error here */
- check_memory_full_error ((GtkWidget *) parent_window, err);
+ /* In disk full conditions we could get this error here */
+ modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
+ (GtkWidget *) parent_window, err,
+ NULL, _("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;
}
mail_op = modest_mail_operation_new ((GObject *) parent_window);
- modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
+ modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
mail_op);
modest_mail_operation_create_folder (mail_op,
helper->parent,
static void
-do_create_folder (GtkWindow *parent_window,
- TnyFolderStore *suggested_parent,
+do_create_folder (GtkWindow *parent_window,
+ TnyFolderStore *suggested_parent,
const gchar *suggested_name)
{
gint result;
&parent_folder);
if (result == GTK_RESPONSE_ACCEPT && parent_folder) {
- CreateFolderConnect *helper = (CreateFolderConnect *) g_slice_new0 (CreateFolderHelper);
+ CreateFolderConnect *helper = (CreateFolderConnect *) g_slice_new0 (CreateFolderConnect);
helper->folder_name = g_strdup (folder_name);
helper->parent = g_object_ref (parent_folder);
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)
+ if (parent_folder) {
do_create_folder (GTK_WINDOW (parent_window), parent_folder, NULL);
+ g_object_unref (parent_folder);
+ }
}
void
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;
+ TnyAccount *account = modest_mail_operation_get_account (mail_op);
+
/* 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 = modest_tny_account_store_is_disk_full_error (modest_runtime_get_account_store(),
+ (GError *) error, account);
+ 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 (account)
+ g_object_unref (account);
+ if (mem_full)
+ g_free (message);
}
typedef struct {
} RenameFolderInfo;
static void
-on_rename_folder_cb (ModestMailOperation *mail_op,
+on_rename_folder_cb (ModestMailOperation *mail_op,
TnyFolder *new_folder,
gpointer user_data)
{
}
static void
-on_rename_folder_performer (gboolean canceled,
- GError *err,
- GtkWindow *parent_window,
- TnyAccount *account,
+on_rename_folder_performer (gboolean canceled,
+ GError *err,
+ GtkWindow *parent_window,
+ TnyAccount *account,
gpointer user_data)
{
ModestMailOperation *mail_op = NULL;
RenameFolderInfo *data = (RenameFolderInfo*)user_data;
if (canceled || err) {
- /* In memory full conditions we could get this error here */
- check_memory_full_error ((GtkWidget *) parent_window, err);
+ /* In disk full conditions we could get this error here */
+ modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
+ (GtkWidget *) parent_window, err,
+ account, NULL);
} else {
mail_op =
folder_view = modest_main_window_get_child_widget (
MODEST_MAIN_WINDOW (parent_window),
MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
- }
+ }
#ifdef MODEST_TOOLKIT_HILDON2
else if (MODEST_IS_FOLDER_WINDOW (parent_window)) {
ModestFolderWindow *folder_window = (ModestFolderWindow *) parent_window;
g_free (data);
}
-void
+void
modest_ui_actions_on_rename_folder (GtkAction *action,
ModestWindow *window)
{
modest_ui_actions_on_edit_mode_rename_folder (window);
}
-gboolean
+gboolean
modest_ui_actions_on_edit_mode_rename_folder (ModestWindow *window)
{
TnyFolderStore *folder;
current_name = tny_folder_get_name (TNY_FOLDER (folder));
parent = tny_folder_get_folder_store (TNY_FOLDER (folder));
response = modest_platform_run_rename_folder_dialog (GTK_WINDOW (window),
- parent, current_name,
+ parent, current_name,
&folder_name);
g_object_unref (parent);
} DeleteFolderInfo;
static void
-on_delete_folder_cb (gboolean canceled,
+on_delete_folder_cb (gboolean canceled,
GError *err,
- GtkWindow *parent_window,
- TnyAccount *account,
+ GtkWindow *parent_window,
+ TnyAccount *account,
gpointer user_data)
{
DeleteFolderInfo *info = (DeleteFolderInfo*) user_data;
GtkWidget *folder_view;
ModestMailOperation *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 (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
+ (GtkWidget*) parent_window, err,
+ account, NULL))
+ g_debug ("Error connecting when trying to delete a folder");
g_object_unref (G_OBJECT (info->folder));
g_free (info);
return;
}
-
+
if (MODEST_IS_MAIN_WINDOW (parent_window)) {
folder_view = modest_main_window_get_child_widget (
MODEST_MAIN_WINDOW (parent_window),
modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
mail_op);
modest_mail_operation_remove_folder (mail_op, TNY_FOLDER (info->folder), info->move_to_trash);
-
+
modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (folder_view));
g_object_unref (G_OBJECT (mail_op));
GtkWidget *folder_view;
gint response;
gchar *message;
-
+
g_return_val_if_fail (MODEST_IS_WINDOW(window), FALSE);
if (MODEST_IS_MAIN_WINDOW (window)) {
}
/* Ask the user */
- message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
+ message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
tny_folder_get_name (TNY_FOLDER (folder)));
response = modest_platform_run_confirmation_dialog (GTK_WINDOW (window),
(const gchar *) message);
info->move_to_trash = move_to_trash;
g_object_ref (G_OBJECT (info->folder));
TnyAccount *account = tny_folder_get_account (TNY_FOLDER (folder));
- modest_platform_connect_if_remote_and_perform (GTK_WINDOW (window),
+ modest_platform_connect_if_remote_and_perform (GTK_WINDOW (window),
TRUE,
- TNY_FOLDER_STORE (account),
+ TNY_FOLDER_STORE (account),
on_delete_folder_cb, info);
g_object_unref (account);
return TRUE;
modest_ui_actions_on_edit_mode_delete_folder (ModestWindow *window)
{
g_return_val_if_fail (MODEST_IS_WINDOW(window), TRUE);
-
+
return delete_folder (window, FALSE);
}
-void
+void
modest_ui_actions_on_move_folder_to_trash_folder (GtkAction *action, ModestMainWindow *main_window)
{
g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
-
+
delete_folder (MODEST_WINDOW (main_window), TRUE);
}
const gchar *value;
gboolean any_value_empty = FALSE;
+#ifdef MODEST_TOOLKIT_HILDON2
+ value = hildon_entry_get_text (HILDON_ENTRY (fields->username));
+#else
value = gtk_entry_get_text (GTK_ENTRY (fields->username));
+#endif
if ((value == NULL) || value[0] == '\0') {
any_value_empty = TRUE;
}
+#ifdef MODEST_TOOLKIT_HILDON2
+ value = hildon_entry_get_text (HILDON_ENTRY (fields->password));
+#else
value = gtk_entry_get_text (GTK_ENTRY (fields->password));
+#endif
if ((value == NULL) || value[0] == '\0') {
any_value_empty = TRUE;
}
_HL("wdgt_bd_done"),
GTK_RESPONSE_ACCEPT,
NULL);
+ gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox),
+ HILDON_MARGIN_DOUBLE);
#else
GtkWidget *dialog =
gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
NULL);
#endif /* MODEST_TOOLKIT_HILDON2 */
#else
- GtkWidget *dialog =
+ GtkWidget *dialog =
gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
NULL,
GTK_DIALOG_MODAL,
}
gchar *txt = g_strdup_printf (_("mail_ia_password_info"), server_name);
- gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_label_new(txt),
- FALSE, FALSE, 0);
+ GtkWidget *label = gtk_label_new (txt);
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
g_free (txt);
g_free (server_name);
+ gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), label,
+ FALSE, FALSE, 0);
server_name = NULL;
/* username: */
gchar *initial_username = modest_account_mgr_get_server_account_username (
modest_runtime_get_account_mgr(), server_account_name);
+#ifdef MODEST_TOOLKIT_HILDON2
+ GtkWidget *entry_username = hildon_entry_new (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
+ if (initial_username)
+ hildon_entry_set_text (HILDON_ENTRY (entry_username), initial_username);
+#else
GtkWidget *entry_username = gtk_entry_new ();
if (initial_username)
gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
+#endif
/* Dim this if a connection has ever succeeded with this username,
* as per the UI spec: */
/* const gboolean username_known = */
* We use GTK_SIZE_GROUP_HORIZONTAL, so that the widths are the same. */
GtkSizeGroup *sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
- GtkWidget *caption = hildon_caption_new (sizegroup,
+#ifdef MODEST_TOOLKIT_HILDON2
+ GtkWidget *caption = modest_maemo_utils_create_captioned (sizegroup, NULL,
+ _("mail_fi_username"), FALSE,
+ entry_username);
+#else
+ GtkWidget *caption = hildon_caption_new (sizegroup,
_("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
+#endif
gtk_widget_show (entry_username);
- gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
+ gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
FALSE, FALSE, MODEST_MARGIN_HALF);
gtk_widget_show (caption);
#else
#endif /* !MODEST_TOOLKIT_GTK */
/* password: */
+#ifdef MODEST_TOOLKIT_HILDON2
+ GtkWidget *entry_password = hildon_entry_new (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH);
+#else
GtkWidget *entry_password = gtk_entry_new ();
+#endif
gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
/* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
+#ifdef MODEST_TOOLKIT_HILDON2
+ caption = modest_maemo_utils_create_captioned (sizegroup, NULL,
+ _("mail_fi_password"), FALSE,
+ entry_password);
+#else
caption = hildon_caption_new (sizegroup,
_("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
+#endif
gtk_widget_show (entry_password);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
FALSE, FALSE, MODEST_MARGIN_HALF);
if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
if (username) {
+#ifdef MODEST_TOOLKIT_HILDON2
+ *username = g_strdup (hildon_entry_get_text (HILDON_ENTRY(entry_username)));
+#else
*username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
+#endif
/* Note that an empty field becomes the "" string */
if (*username && strlen (*username) > 0) {
- modest_account_mgr_set_server_account_username (modest_runtime_get_account_mgr(),
- server_account_name,
+ modest_account_mgr_set_server_account_username (modest_runtime_get_account_mgr(),
+ server_account_name,
*username);
completed = TRUE;
- const gboolean username_was_changed =
+ const gboolean username_was_changed =
(strcmp (*username, initial_username) != 0);
if (username_was_changed) {
g_warning ("%s: tinymail does not yet support changing the "
g_free (*username);
*username = NULL;
/* Show error */
- modest_platform_information_banner (GTK_WIDGET (dialog), NULL,
+ modest_platform_information_banner (GTK_WIDGET (dialog), NULL,
_("mcen_ib_username_pw_incorrect"));
completed = FALSE;
}
}
if (password) {
+#ifdef MODEST_TOOLKIT_HILDON2
+ *password = g_strdup (hildon_entry_get_text (HILDON_ENTRY(entry_password)));
+#else
*password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
+#endif
- /* We do not save the password in the configuration,
- * because this function is only called for passwords that should
+ /* We do not save the password in the configuration,
+ * because this function is only called for passwords that should
* not be remembered:
modest_server_account_set_password (
- modest_runtime_get_account_mgr(), server_account_name,
+ modest_runtime_get_account_mgr(), server_account_name,
*password);
*/
}
g_free (initial_username);
gtk_widget_destroy (dialog);
g_slice_free (PasswordDialogFields, fields);
-
+
/* printf ("DEBUG: %s: cancel=%d\n", __FUNCTION__, *cancel); */
}
} else if (MODEST_IS_MAIN_WINDOW (window)) {
/* Clear clipboard source */
clipboard = modest_runtime_get_email_clipboard ();
- modest_email_clipboard_clear (clipboard);
+ modest_email_clipboard_clear (clipboard);
}
else {
g_return_if_reached ();
static void
-destroy_information_note (ModestMailOperation *mail_op,
+destroy_information_note (ModestMailOperation *mail_op,
gpointer user_data)
{
/* destroy information note */
}
static void
-destroy_folder_information_note (ModestMailOperation *mail_op,
+destroy_folder_information_note (ModestMailOperation *mail_op,
TnyFolder *new_folder,
gpointer user_data)
{
return;
modest_msg_edit_window_add_part (MODEST_MSG_EDIT_WINDOW (helper->window), TNY_MIME_PART (msg));
-
+
}
void
}
if (data != NULL) {
- modest_mail_operation_get_msgs_full (mail_op,
+ modest_mail_operation_get_msgs_full (mail_op,
data,
(GetMsgAsyncUserCallback) paste_msg_as_attachment_cb,
helper,
paste_as_attachment_free);
}
/* Free */
- if (data)
+ if (data)
g_object_unref (data);
- if (src_folder)
+ if (src_folder)
g_object_unref (src_folder);
}
ModestEmailClipboard *clipboard = NULL;
TnyFolder *src_folder = NULL;
TnyFolderStore *folder_store = NULL;
- TnyList *data = NULL;
+ TnyList *data = NULL;
gboolean delete = FALSE;
-
+
/* Check clipboard source */
clipboard = modest_runtime_get_email_clipboard ();
- if (modest_email_clipboard_cleared (clipboard))
+ if (modest_email_clipboard_cleared (clipboard))
return;
-
+
/* Get elements to paste */
modest_email_clipboard_get_data (clipboard, &src_folder, &data, &delete);
/* Create a new mail operation */
mail_op = modest_mail_operation_new (G_OBJECT(window));
-
+
/* Get destination folder */
folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (focused_widget));
gint response = 0;
/* Ask for user confirmation */
- response =
- modest_ui_actions_msgs_move_to_confirmation (window,
- TNY_FOLDER (folder_store),
+ response =
+ modest_ui_actions_msgs_move_to_confirmation (window,
+ TNY_FOLDER (folder_store),
delete,
data);
-
+
if (response == GTK_RESPONSE_OK) {
/* Launch notification */
- inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
+ inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
_CS("ckct_nw_pasting"));
if (inf_note != NULL) {
gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
}
modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
- modest_mail_operation_xfer_msgs (mail_op,
+ modest_mail_operation_xfer_msgs (mail_op,
data,
TNY_FOLDER (folder_store),
delete,
destroy_information_note,
- inf_note);
+ inf_note);
} else {
g_object_unref (mail_op);
}
-
- } else if (src_folder != NULL) {
+
+ } else if (src_folder != NULL) {
/* Launch notification */
- inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
+ inf_note = modest_platform_animation_banner (GTK_WIDGET (window), NULL,
_CS("ckct_nw_pasting"));
if (inf_note != NULL) {
gtk_window_set_modal (GTK_WINDOW(inf_note), FALSE);
gtk_widget_show (GTK_WIDGET(inf_note));
}
-
+
modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
- modest_mail_operation_xfer_folder (mail_op,
+ modest_mail_operation_xfer_folder (mail_op,
src_folder,
folder_store,
delete,
}
/* Free */
- if (data != NULL)
+ if (data != NULL)
g_object_unref (data);
- if (src_folder != NULL)
+ if (src_folder != NULL)
g_object_unref (src_folder);
- if (folder_store != NULL)
+ if (folder_store != NULL)
g_object_unref (folder_store);
}
}
} else if (MODEST_IS_MAIN_WINDOW (window)) {
GtkWidget *header_view = focused_widget;
GtkTreeSelection *selection = NULL;
-
+
if (!(MODEST_IS_HEADER_VIEW (focused_widget))) {
header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
}
-
+
/* Disable window dimming management */
modest_window_disable_dimming (MODEST_WINDOW(window));
-
+
/* Select all messages */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(header_view));
gtk_tree_selection_select_all (selection);
void
modest_ui_actions_on_mark_as_read (GtkAction *action,
ModestWindow *window)
-{
+{
g_return_if_fail (MODEST_IS_WINDOW(window));
-
+
/* Mark each header as read */
do_headers_action (window, headers_action_mark_as_read, NULL);
}
void
modest_ui_actions_on_mark_as_unread (GtkAction *action,
ModestWindow *window)
-{
+{
g_return_if_fail (MODEST_IS_WINDOW(window));
-
+
/* Mark each header as read */
do_headers_action (window, headers_action_mark_as_unread, NULL);
}
modest_window_zoom_plus (MODEST_WINDOW (window));
}
-void
+void
modest_ui_actions_on_zoom_minus (GtkAction *action,
ModestWindow *window)
{
modest_window_zoom_minus (MODEST_WINDOW (window));
}
-void
+void
modest_ui_actions_on_toggle_fullscreen (GtkToggleAction *toggle,
ModestWindow *window)
{
#endif
}
-/*
- * Used by modest_ui_actions_on_details to call do_headers_action
+/*
+ * Used by modest_ui_actions_on_details to call do_headers_action
*/
static void
headers_action_show_details (TnyHeader *header,
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);
}
/*
= modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
if (!folder_store) {
g_warning ("%s: No item was selected.\n", __FUNCTION__);
- return;
+ return;
}
/* Show only when it's a folder */
- /* This function should not be called for account items,
+ /* This function should not be called for account items,
* because we dim the menu item for them. */
if (TNY_IS_FOLDER (folder_store)) {
- modest_platform_run_folder_details_dialog (GTK_WINDOW (win),
+ modest_platform_run_folder_details_dialog (GTK_WINDOW (win),
TNY_FOLDER (folder_store));
}
header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (win)));
folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
if (folder) {
- modest_platform_run_folder_details_dialog (GTK_WINDOW (win),
+ modest_platform_run_folder_details_dialog (GTK_WINDOW (win),
folder);
g_object_unref (folder);
}
}
}
-void
+void
modest_ui_actions_on_toggle_show_cc (GtkToggleAction *toggle,
ModestMsgEditWindow *window)
{
modest_msg_edit_window_show_cc (window, gtk_toggle_action_get_active (toggle));
}
-void
+void
modest_ui_actions_on_toggle_show_bcc (GtkToggleAction *toggle,
ModestMsgEditWindow *window)
{
}
void
-modest_ui_actions_toggle_folders_view (GtkAction *action,
+modest_ui_actions_toggle_folders_view (GtkAction *action,
ModestMainWindow *main_window)
{
g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
modest_main_window_set_style (main_window, MODEST_MAIN_WINDOW_STYLE_SIMPLE);
}
-void
-modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
+void
+modest_ui_actions_on_toggle_toolbar (GtkToggleAction *toggle,
ModestWindow *window)
{
gboolean active, fullscreen = FALSE;
/* Check if we want to toggle the toolbar view in fullscreen
or normal mode */
- if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
+ if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
"ViewShowToolbarFullScreen")) {
fullscreen = TRUE;
}
modest_window_mgr_show_toolbars (mgr, G_TYPE_FROM_INSTANCE (window), active, fullscreen);
}
-void
+void
modest_ui_actions_msg_edit_on_select_font (GtkAction *action,
ModestMsgEditWindow *window)
{
if (header)
g_object_unref (header);
} else {
- src_folder =
+ src_folder =
TNY_FOLDER (modest_folder_view_get_selected
(MODEST_FOLDER_VIEW (folder_view)));
}
gint response,
gpointer user_data)
{
- GtkWidget *parent_win, *folder_view;
+ GtkWidget *parent_win;
MoveToInfo *helper = NULL;
+ ModestFolderView *folder_view;
+ gboolean unset_edit_mode = FALSE;
helper = (MoveToInfo *) user_data;
parent_win = (GtkWidget *) helper->win;
- folder_view = GTK_WIDGET (g_object_get_data (G_OBJECT (dialog),
- MODEST_MOVE_TO_DIALOG_FOLDER_VIEW));
+ folder_view = MODEST_FOLDER_VIEW (g_object_get_data (G_OBJECT (dialog),
+ MODEST_MOVE_TO_DIALOG_FOLDER_VIEW));
switch (response) {
TnyFolderStore *dst_folder;
+ TnyFolderStore *selected;
case MODEST_GTK_RESPONSE_NEW_FOLDER:
- modest_ui_actions_create_folder (GTK_WIDGET (dialog), 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:
case GTK_RESPONSE_DELETE_EVENT:
break;
case GTK_RESPONSE_OK:
- dst_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
- /* Do window specific stuff */
+ dst_folder = modest_folder_view_get_selected (folder_view);
+
if (MODEST_IS_MAIN_WINDOW (parent_win)) {
+ /* Clean list to move used for filtering */
+ modest_folder_view_set_list_to_move (folder_view, NULL);
+
modest_ui_actions_on_main_window_move_to (NULL,
- folder_view,
+ GTK_WIDGET (folder_view),
dst_folder,
MODEST_MAIN_WINDOW (parent_win));
#ifdef MODEST_TOOLKIT_HILDON2
} else if (MODEST_IS_FOLDER_WINDOW (parent_win)) {
- modest_ui_actions_on_folder_window_move_to (folder_view,
+ /* Clean list to move used for filtering */
+ modest_folder_view_set_list_to_move (folder_view, NULL);
+
+ modest_ui_actions_on_folder_window_move_to (GTK_WIDGET (folder_view),
dst_folder,
helper->list,
GTK_WINDOW (parent_win));
#endif
} else {
+ /* if the user selected a root folder
+ (account) then do not perform any action */
+ if (TNY_IS_ACCOUNT (dst_folder)) {
+ g_signal_stop_emission_by_name (dialog, "response");
+ return;
+ }
+
+ /* Clean list to move used for filtering */
+ modest_folder_view_set_list_to_move (folder_view, NULL);
+
/* Moving from headers window in edit mode */
modest_ui_actions_on_window_move_to (NULL, helper->list,
- dst_folder,
+ dst_folder,
MODEST_WINDOW (parent_win));
}
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));
}
static GtkWidget*
create_move_to_dialog (GtkWindow *win,
- GtkWidget *folder_view)
+ GtkWidget *folder_view,
+ TnyList *list_to_move)
{
GtkWidget *dialog, *tree_view = NULL;
modest_folder_view_set_style (MODEST_FOLDER_VIEW (tree_view),
MODEST_FOLDER_VIEW_STYLE_SHOW_ALL);
- modest_folder_view_copy_model (MODEST_FOLDER_VIEW(folder_view),
+ modest_folder_view_copy_model (MODEST_FOLDER_VIEW(folder_view),
MODEST_FOLDER_VIEW(tree_view));
- visible_id =
+ visible_id =
modest_folder_view_get_account_id_of_visible_server_account (MODEST_FOLDER_VIEW(folder_view));
/* Show the same account than the one that is shown in the main window */
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_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
#endif
g_object_unref (iter);
/* if no src_folder, message may be an attahcment */
- if (src_folder == NULL)
+ if (src_folder == NULL)
return GTK_RESPONSE_CANCEL;
/* If the source is a local or MMC folder */
}
static void
-move_to_cb (ModestMailOperation *mail_op,
+move_to_cb (ModestMailOperation *mail_op,
gpointer user_data)
{
MoveToHelper *helper = (MoveToHelper *) user_data;
/* Note that the operation could have failed, in that case do
nothing */
- if (modest_mail_operation_get_status (mail_op) !=
+ if (modest_mail_operation_get_status (mail_op) !=
MODEST_MAIL_OPERATION_STATUS_SUCCESS)
goto frees;
/* No more messages to view, so close this window */
modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
}
- } else if (MODEST_IS_MAIN_WINDOW (object) &&
+ } else if (MODEST_IS_MAIN_WINDOW (object) &&
gtk_tree_row_reference_valid (helper->reference)) {
GtkWidget *header_view;
GtkTreePath *path;
}
static void
-folder_move_to_cb (ModestMailOperation *mail_op,
+folder_move_to_cb (ModestMailOperation *mail_op,
TnyFolder *new_folder,
gpointer user_data)
{
}
static void
-msgs_move_to_cb (ModestMailOperation *mail_op,
+msgs_move_to_cb (ModestMailOperation *mail_op,
gpointer user_data)
{
move_to_cb (mail_op, user_data);
}
void
-modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
+modest_ui_actions_move_folder_error_handler (ModestMailOperation *mail_op,
gpointer user_data)
{
GObject *win = NULL;
+ const GError *error;
+ TnyAccount *account = NULL;
#ifndef MODEST_TOOLKIT_HILDON2
ModestWindow *main_window = NULL;
/* Disable next automatic folder selection */
main_window = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
FALSE); /* don't create */
+
+ /* Show notification dialog only if the main window exists */
if (main_window) {
GtkWidget *folder_view = NULL;
folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (main_window),
- MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
+ MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
modest_folder_view_disable_next_folder_selection (MODEST_FOLDER_VIEW(folder_view));
if (user_data && TNY_IS_FOLDER (user_data)) {
- modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view),
+ modest_folder_view_select_folder (MODEST_FOLDER_VIEW (folder_view),
TNY_FOLDER (user_data), FALSE);
}
}
#endif
- /* Show notification dialog only if the main window exists */
win = modest_mail_operation_get_source (mail_op);
- modest_platform_run_information_dialog ((GtkWindow *) win,
- _("mail_in_ui_folder_move_target_error"),
- FALSE);
+ error = modest_mail_operation_get_error (mail_op);
+
+ if (TNY_IS_FOLDER (user_data))
+ account = modest_tny_folder_get_account (TNY_FOLDER (user_data));
+ else if (TNY_IS_ACCOUNT (user_data))
+ account = g_object_ref (user_data);
+
+ /* If it's not a disk full error then show a generic error */
+ if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
+ (GtkWidget *) win, (GError *) error,
+ account, NULL))
+ modest_platform_run_information_dialog ((GtkWindow *) win,
+ _("mail_in_ui_folder_move_target_error"),
+ FALSE);
+ if (account)
+ g_object_unref (account);
if (win)
g_object_unref (win);
}
static void
-open_msg_for_purge_cb (ModestMailOperation *mail_op,
- TnyHeader *header,
+open_msg_for_purge_cb (ModestMailOperation *mail_op,
+ TnyHeader *header,
gboolean canceled,
- TnyMsg *msg,
+ TnyMsg *msg,
GError *err,
gpointer user_data)
{
tny_iterator_next (iter);
}
g_object_unref (iter);
-
+
if (pending_purges>0) {
gint response;
iter = tny_list_create_iterator (parts);
while (!tny_iterator_is_done (iter)) {
TnyMimePart *part;
-
+
part = TNY_MIME_PART (tny_iterator_get_current (iter));
if (part && (tny_mime_part_is_attachment (part) || TNY_IS_MSG (part)))
tny_mime_part_set_purged (part);
tny_iterator_next (iter);
}
g_object_unref (iter);
-
+
tny_msg_rewrite_cache (msg);
gtk_widget_destroy (info);
g_warning ("%s: no header selected", __FUNCTION__);
return;
}
-
+
if (tny_list_get_length (header_list) == 1) {
TnyIterator *iter = tny_list_create_iterator (header_list);
header = TNY_HEADER (tny_iterator_get_current (iter));
g_object_unref (iter);
} else
return;
-
+
if (!header || !TNY_IS_HEADER(header)) {
g_warning ("%s: header is not valid", __FUNCTION__);
return;
}
-
+
found = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
header, &msg_view_window);
flags = tny_header_get_flags (header);
if (!(flags & TNY_HEADER_FLAG_CACHED))
return;
if (found) {
- if (msg_view_window != NULL)
+ if (msg_view_window != NULL)
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;
NULL, NULL);
modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
modest_mail_operation_get_msg (mail_op, header, FALSE, open_msg_for_purge_cb, win);
-
+
g_object_unref (mail_op);
}
if (header)
/* We must ask for a connection when
*
- * - the message(s) is not already cached OR
+ * - the message(s) is not already cached OR
* - the message(s) is cached but the leave_on_server setting
* is FALSE (because we need to sync the source folder to
* delete the message from the server (for IMAP we could do it
}
static void
-xfer_messages_error_handler (ModestMailOperation *mail_op,
+xfer_messages_error_handler (ModestMailOperation *mail_op,
gpointer user_data)
{
GObject *win;
const GError *error;
+ TnyAccount *account;
win = modest_mail_operation_get_source (mail_op);
error = modest_mail_operation_get_error (mail_op);
+ account = modest_mail_operation_get_account (mail_op);
- if (error && is_memory_full_error ((GError *) error))
- modest_platform_information_banner ((GtkWidget *) win,
- NULL, _KR("cerm_device_memory_full"));
- else
- modest_platform_run_information_dialog ((GtkWindow *) win,
- _("mail_in_ui_folder_move_target_error"),
+ if (error && modest_tny_account_store_is_disk_full_error (modest_runtime_get_account_store(),
+ (GError *) error, account)) {
+ 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 (account)
+ g_object_unref (account);
if (win)
g_object_unref (win);
}
* and the msg view window when using the "Move to" dialog
*/
static void
-xfer_messages_performer (gboolean canceled,
+xfer_messages_performer (gboolean canceled,
GError *err,
- GtkWindow *parent_window,
- TnyAccount *account,
+ GtkWindow *parent_window,
+ TnyAccount *account,
gpointer user_data)
{
ModestWindow *win = MODEST_WINDOW (parent_window);
helper = (XferMsgsHelper *) user_data;
if (canceled || err) {
- if (!check_memory_full_error ((GtkWidget *) parent_window, err)) {
+ if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
+ (GtkWidget *) parent_window, err,
+ account, NULL)) {
/* Show the proper error message */
modest_ui_actions_on_account_connection_error (parent_window, account);
}
#endif
if (MODEST_IS_MAIN_WINDOW (win)) {
- GtkWidget *header_view =
+ GtkWidget *header_view =
modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(win),
MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
movehelper->reference = get_next_after_selected_headers (MODEST_HEADER_VIEW (header_view));
mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT(win),
xfer_messages_error_handler,
movehelper, NULL);
- modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
+ modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
mail_op);
- modest_mail_operation_xfer_msgs (mail_op,
+ modest_mail_operation_xfer_msgs (mail_op,
helper->headers,
TNY_FOLDER (helper->dst_folder),
TRUE,
} MoveFolderInfo;
static void
-on_move_folder_cb (gboolean canceled, GError *err, GtkWindow *parent_window,
- TnyAccount *account, gpointer user_data)
+on_move_folder_cb (gboolean canceled,
+ GError *err,
+ GtkWindow *parent_window,
+ TnyAccount *account,
+ gpointer user_data)
{
MoveFolderInfo *info = (MoveFolderInfo*)user_data;
GtkTreeSelection *sel;
ModestMailOperation *mail_op = NULL;
if (canceled || err || !MODEST_IS_WINDOW (parent_window)) {
+ /* Note that the connection process can fail due to
+ memory low conditions as it can not successfully
+ store the summary */
+ if (!modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
+ (GtkWidget*) parent_window, err,
+ account, NULL))
+ g_debug ("Error connecting when trying to move a folder");
+
g_object_unref (G_OBJECT (info->src_folder));
g_object_unref (G_OBJECT (info->dst_folder));
g_free (info);
folder *before* issuing the mail operation
so we need the signal handler of selection
changed to happen before the mail
- operation
+ operation
while (gtk_events_pending ())
gtk_main_iteration (); */
mail_op =
modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
- modest_ui_actions_move_folder_error_handler,
- info->src_folder, NULL);
+ modest_ui_actions_move_folder_error_handler,
+ g_object_ref (info->dst_folder), g_object_unref);
modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
- mail_op);
-
- /* Select *after* the changes */
- /* TODO: this function hangs UI after transfer */
- /* modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view), */
- /* TNY_FOLDER (src_folder), TRUE); */
+ mail_op);
if (MODEST_IS_MAIN_WINDOW (parent_window)) {
modest_folder_view_select_folder (MODEST_FOLDER_VIEW(info->folder_view),
modest_mail_operation_xfer_folder (mail_op,
TNY_FOLDER (info->src_folder),
info->dst_folder,
- info->delete_original,
- folder_move_to_cb,
+ info->delete_original,
+ folder_move_to_cb,
helper);
g_object_unref (G_OBJECT (info->src_folder));
/* if (modest_mail_operation_get_status (mail_op) == MODEST_MAIL_OPERATION_STATUS_SUCCESS) { */
/* } */
-
+
/* Unref mail operation */
g_object_unref (G_OBJECT (mail_op));
g_object_unref (G_OBJECT (info->dst_folder));
}
static TnyAccount *
-get_account_from_folder_store (TnyFolderStore *folder_store)
+get_account_from_folder_store (TnyFolderStore *folder_store)
{
if (TNY_IS_ACCOUNT (folder_store))
return g_object_ref (folder_store);
* UI handler for the "Move to" action when invoked from the
* ModestMainWindow
*/
-static void
-modest_ui_actions_on_main_window_move_to (GtkAction *action,
+static void
+modest_ui_actions_on_main_window_move_to (GtkAction *action,
GtkWidget *folder_view,
TnyFolderStore *dst_folder,
ModestMainWindow *win)
gboolean do_xfer = TRUE;
/* Allow only to transfer folders to the local root folder */
- if (TNY_IS_ACCOUNT (dst_folder) &&
+ if (TNY_IS_ACCOUNT (dst_folder) &&
!MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder) &&
!modest_tny_account_is_memory_card_account (TNY_ACCOUNT (dst_folder))) {
do_xfer = FALSE;
connect_info->data = info;
modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
- TNY_FOLDER_STORE (src_folder),
+ TNY_FOLDER_STORE (src_folder),
connect_info);
}
} else if (gtk_widget_is_focus (GTK_WIDGET(header_view))) {
headers = modest_header_view_get_selected_headers(header_view);
/* Transfer the messages */
- modest_ui_actions_transfer_messages_helper (GTK_WINDOW (win), TNY_FOLDER (src_folder),
+ modest_ui_actions_transfer_messages_helper (GTK_WINDOW (win), TNY_FOLDER (src_folder),
headers, TNY_FOLDER (dst_folder));
g_object_unref (headers);
* UI handler for the "Move to" action when invoked from the
* ModestFolderWindow
*/
-static void
+static void
modest_ui_actions_on_folder_window_move_to (GtkWidget *folder_view,
TnyFolderStore *dst_folder,
TnyList *selection,
gboolean do_xfer = TRUE;
/* Allow only to transfer folders to the local root folder */
- if (TNY_IS_ACCOUNT (dst_folder) &&
+ if (TNY_IS_ACCOUNT (dst_folder) &&
!MODEST_IS_TNY_LOCAL_FOLDERS_ACCOUNT (dst_folder) &&
!modest_tny_account_is_memory_card_account (TNY_ACCOUNT (dst_folder))) {
do_xfer = FALSE;
connect_info->data = info;
modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
- TNY_FOLDER_STORE (src_folder),
+ TNY_FOLDER_STORE (src_folder),
connect_info);
}
g_return_if_fail (TNY_IS_FOLDER (src_folder));
g_return_if_fail (TNY_IS_FOLDER (dst_folder));
g_return_if_fail (TNY_IS_LIST (headers));
-
- modest_ui_actions_xfer_messages_check (win, TNY_FOLDER_STORE (src_folder),
+
+ modest_ui_actions_xfer_messages_check (win, TNY_FOLDER_STORE (src_folder),
headers, TNY_FOLDER (dst_folder),
- TRUE, &need_connection,
+ TRUE, &need_connection,
&do_xfer);
/* If we don't want to transfer just return */
connect_info->callback = xfer_messages_performer;
connect_info->dst_account = tny_folder_get_account (TNY_FOLDER (dst_folder));
connect_info->data = helper;
-
+
modest_platform_double_connect_and_perform(GTK_WINDOW (win), TRUE,
- TNY_FOLDER_STORE (src_folder),
+ TNY_FOLDER_STORE (src_folder),
connect_info);
} else {
TnyAccount *src_account = get_account_from_folder_store (TNY_FOLDER_STORE (src_folder));
src_folder = tny_header_get_folder (header);
/* Transfer the messages */
- modest_ui_actions_transfer_messages_helper (GTK_WINDOW (win), src_folder,
+ modest_ui_actions_transfer_messages_helper (GTK_WINDOW (win), src_folder,
headers,
TNY_FOLDER (dst_folder));
}
}
-void
-modest_ui_actions_on_move_to (GtkAction *action,
+void
+modest_ui_actions_on_move_to (GtkAction *action,
ModestWindow *win)
{
modest_ui_actions_on_edit_mode_move_to (win);
}
-gboolean
+gboolean
modest_ui_actions_on_edit_mode_move_to (ModestWindow *win)
{
GtkWidget *dialog = NULL;
if (MODEST_IS_MAIN_WINDOW (win))
main_window = MODEST_MAIN_WINDOW (win);
else
- main_window =
+ main_window =
MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
FALSE)); /* don't create */
#endif
}
/* Create and run the dialog */
- dialog = create_move_to_dialog (GTK_WINDOW (win), NULL);
- modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
- GTK_WINDOW (dialog),
+ dialog = create_move_to_dialog (GTK_WINDOW (win), NULL, list_to_move);
+ modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
+ GTK_WINDOW (dialog),
(GtkWindow *) win);
/* Create helper */
/* Show the dialog */
gtk_widget_show (dialog);
- return TRUE;
+ return FALSE;
}
/*
* window or the message currently being shown in the msg view window
*/
static void
-do_headers_action (ModestWindow *win,
+do_headers_action (ModestWindow *win,
HeadersFunc func,
gpointer user_data)
{
g_object_unref (headers_list);
}
-void
+void
modest_ui_actions_view_attachment (GtkAction *action,
ModestWindow *window)
{
}
}
-void
-modest_ui_actions_on_settings (GtkAction *action,
+void
+modest_ui_actions_on_settings (GtkAction *action,
ModestWindow *win)
{
GtkWidget *dialog;
gtk_widget_destroy (dialog);
}
-void
-modest_ui_actions_on_help (GtkAction *action,
+void
+modest_ui_actions_on_help (GtkAction *action,
GtkWindow *win)
{
/* Help app is not available at all in fremantle */
const gchar *help_id;
g_return_if_fail (win && GTK_IS_WINDOW(win));
-
+
help_id = modest_window_mgr_get_help_id (modest_runtime_get_window_mgr(), win);
if (help_id)
#endif
}
-void
-modest_ui_actions_on_csm_help (GtkAction *action,
+void
+modest_ui_actions_on_csm_help (GtkAction *action,
GtkWindow *win)
{
/* Help app is not available at all in fremantle */
#endif
}
-static void
-retrieve_contents_cb (ModestMailOperation *mail_op,
- TnyHeader *header,
+static void
+retrieve_contents_cb (ModestMailOperation *mail_op,
+ TnyHeader *header,
gboolean canceled,
TnyMsg *msg,
GError *err,
{
/* 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
-retrieve_msg_contents_performer (gboolean canceled,
+retrieve_msg_contents_performer (gboolean canceled,
GError *err,
- GtkWindow *parent_window,
- TnyAccount *account,
+ GtkWindow *parent_window,
+ TnyAccount *account,
gpointer user_data)
{
ModestMailOperation *mail_op;
TnyList *headers = TNY_LIST (user_data);
if (err || canceled) {
- check_memory_full_error ((GtkWidget *) parent_window, err);
+ modest_tny_account_store_check_disk_full_error (modest_runtime_get_account_store(),
+ (GtkWidget *) parent_window, err,
+ account, NULL);
goto out;
}
/* Create mail operation */
mail_op = modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
- modest_ui_actions_disk_operations_error_handler,
+ modest_ui_actions_disk_operations_error_handler,
NULL, NULL);
modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
modest_mail_operation_get_msgs_full (mail_op, headers, retrieve_contents_cb, NULL, NULL);
g_object_unref (account);
}
-void
+void
modest_ui_actions_on_retrieve_msg_contents (GtkAction *action,
ModestWindow *window)
{
/* Connect and perform the message retrieval */
modest_platform_connect_and_perform ((GtkWindow *) window, TRUE,
- g_object_ref (account),
- retrieve_msg_contents_performer,
+ g_object_ref (account),
+ retrieve_msg_contents_performer,
g_object_ref (headers));
/* Frees */
ModestWindow *window)
{
g_return_if_fail (MODEST_IS_WINDOW (window));
-
+
/* Update dimmed */
modest_ui_actions_check_menu_dimming_rules (window);
}
*/
if (modest_platform_check_memory_low (window, TRUE))
return;
-
+
modest_platform_show_search_messages (GTK_WINDOW (window));
}
-void
+void
modest_ui_actions_on_open_addressbook (GtkAction *action, ModestWindow *win)
{
g_return_if_fail (MODEST_IS_WINDOW (win));
else
active = TRUE;
- modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window),
+ modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window),
active);
}
-static void
-on_send_receive_finished (ModestMailOperation *mail_op,
+static void
+on_send_receive_finished (ModestMailOperation *mail_op,
gpointer user_data)
{
GtkWidget *header_view, *folder_view;
TnyFolderStore *folder_store;
ModestMainWindow *main_win = MODEST_MAIN_WINDOW (user_data);
- /* Set send/receive operation finished */
+ /* Set send/receive operation finished */
modest_main_window_notify_send_receive_completed (main_win);
/* Don't refresh the current folder if there were any errors */
if (modest_mail_operation_get_status (mail_op) !=
MODEST_MAIL_OPERATION_STATUS_SUCCESS)
return;
-
+
/* Refresh the current folder if we're viewing a window. We do
this because the user won't be able to see the new mails in
the selected folder after a Send&Receive because it only
performs a poke_status, i.e, only the number of read/unread
messages is updated, but the new headers are not
downloaded */
- folder_view = modest_main_window_get_child_widget (main_win,
+ folder_view = modest_main_window_get_child_widget (main_win,
MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
if (!folder_view)
return;
folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
-
+
/* Do not need to refresh INBOX again because the
update_account does it always automatically */
- if (folder_store && TNY_IS_FOLDER (folder_store) &&
+ if (folder_store && TNY_IS_FOLDER (folder_store) &&
tny_folder_get_folder_type (TNY_FOLDER (folder_store)) != TNY_FOLDER_TYPE_INBOX) {
ModestMailOperation *refresh_op;
header_view = modest_main_window_get_child_widget (main_win,
MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
-
+
/* We do not need to set the contents style
because it hasn't changed. We also do not
need to save the widget status. Just force
folder_refreshed_cb, main_win);
g_object_unref (refresh_op);
}
-
+
if (folder_store)
g_object_unref (folder_store);
}
-void
-modest_ui_actions_on_send_queue_error_happened (TnySendQueue *self,
- TnyHeader *header,
- TnyMsg *msg,
- GError *err,
+void
+modest_ui_actions_on_send_queue_error_happened (TnySendQueue *self,
+ TnyHeader *header,
+ TnyMsg *msg,
+ GError *err,
gpointer user_data)
{
const gchar* server_name = NULL;
- TnyTransportAccount *server_account;
+ TnyTransportAccount *transport;
gchar *message = NULL;
+ ModestProtocol *protocol;
/* Don't show anything if the user cancelled something or the
* send receive request is not interactive. Authentication
return;
- /* Get the server name: */
- server_account =
- TNY_TRANSPORT_ACCOUNT (tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE (self)));
- if (server_account)
- server_name = tny_account_get_hostname (TNY_ACCOUNT (server_account));
- else
- g_return_if_reached ();
+ /* Get the server name. Note that we could be using a
+ connection specific transport account */
+ transport = (TnyTransportAccount *)
+ tny_camel_send_queue_get_transport_account (TNY_CAMEL_SEND_QUEUE (self));
+ if (transport) {
+ ModestTnyAccountStore *acc_store;
+ const gchar *acc_name;
+ TnyTransportAccount *conn_specific;
+
+ acc_store = modest_runtime_get_account_store();
+ acc_name = modest_tny_account_get_parent_modest_account_name_for_server_account (TNY_ACCOUNT (transport));
+ conn_specific = (TnyTransportAccount *)
+ modest_tny_account_store_get_transport_account_for_open_connection (acc_store, acc_name);
+ if (conn_specific) {
+ server_name = tny_account_get_hostname (TNY_ACCOUNT (conn_specific));
+ g_object_unref (conn_specific);
+ } else {
+ server_name = tny_account_get_hostname (TNY_ACCOUNT (transport));
+ }
+ g_object_unref (transport);
+ }
+
+ /* Get protocol */
+ protocol = modest_protocol_registry_get_protocol_by_name (modest_runtime_get_protocol_registry (),
+ MODEST_PROTOCOL_REGISTRY_TRANSPORT_STORE_PROTOCOLS,
+ tny_account_get_proto (TNY_ACCOUNT (transport)));
+ if (!protocol) {
+ g_warning ("%s: Account with no proto", __FUNCTION__);
+ return;
+ }
/* Show the appropriate message text for the GError: */
switch (err->code) {
case TNY_SERVICE_ERROR_CONNECT:
- message = g_strdup_printf (_("emev_ib_ui_smtp_server_invalid"), server_name);
+ message = modest_protocol_get_translation (protocol,
+ MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR,
+ server_name);
break;
case TNY_SERVICE_ERROR_SEND:
message = g_strdup (_CS("sfil_ib_unable_to_send"));
break;
case TNY_SERVICE_ERROR_UNAVAILABLE:
- message = g_strdup_printf (_("emev_ib_ui_smtp_server_invalid"), server_name);
+ message = modest_protocol_get_translation (protocol,
+ MODEST_PROTOCOL_TRANSLATION_CONNECT_ERROR,
+ server_name);
break;
default:
g_warning ("%s: unexpected ERROR %d",
__FUNCTION__, err->code);
message = g_strdup (_CS("sfil_ib_unable_to_send"));
- break;
+ break;
}
modest_platform_run_information_dialog (NULL, message, FALSE);
g_free (message);
- g_object_unref (server_account);
}
void
modest_ui_actions_on_send_queue_status_changed (ModestTnySendQueue *send_queue,
- gchar *msg_id,
+ gchar *msg_id,
guint status,
gpointer user_data)
{
#endif
/* Get selected folder */
- selected_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
+ if (header_view)
+ selected_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
if (!selected_folder)
return;
}
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)
+ goto frees;
+
/* Get the account type */
account = tny_folder_get_account (TNY_FOLDER (folder));
proto = modest_tny_account_get_protocol_type (account);
msg = g_strdup_printf (_("mail_ni_ui_folder_get_msg_folder_error"));
}
+ frees:
/* Frees */
- g_object_unref (account);
- g_object_unref (folder);
- g_object_unref (header);
+ if (account)
+ g_object_unref (account);
+ if (folder)
+ g_object_unref (folder);
+ if (header)
+ g_object_unref (header);
return msg;
}
}
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));
+}
+
+/** Check whether any connections are active, and cancel them if
+ * the user wishes.
+ * Returns TRUE is there was no problem,
+ * or if an operation was cancelled so we can continue.
+ * Returns FALSE if the user chose to cancel his request instead.
+ */
+
+gboolean
+modest_ui_actions_check_for_active_account (ModestWindow *self,
+ const gchar* account_name)
+{
+ ModestTnySendQueue *send_queue;
+ ModestTnyAccountStore *acc_store;
+ ModestMailOperationQueue* queue;
+ TnyConnectionStatus store_conn_status;
+ TnyAccount *store_account = NULL, *transport_account = NULL;
+ gboolean retval = TRUE, sending = FALSE;
+
+ acc_store = modest_runtime_get_account_store ();
+ queue = modest_runtime_get_mail_operation_queue ();
+
+ store_account =
+ modest_tny_account_store_get_server_account (acc_store,
+ account_name,
+ TNY_ACCOUNT_TYPE_STORE);
+
+ /* This could happen if the account was deleted before the
+ call to this function */
+ if (!store_account)
+ return FALSE;
+
+ transport_account =
+ modest_tny_account_store_get_server_account (acc_store,
+ account_name,
+ TNY_ACCOUNT_TYPE_TRANSPORT);
+
+ /* This could happen if the account was deleted before the
+ call to this function */
+ if (!transport_account) {
+ g_object_unref (store_account);
+ return FALSE;
+ }
+
+ /* If the transport account was not used yet, then the send
+ queue could not exist (it's created on demand) */
+ send_queue = modest_runtime_get_send_queue (TNY_TRANSPORT_ACCOUNT (transport_account), FALSE);
+ if (TNY_IS_SEND_QUEUE (send_queue))
+ sending = modest_tny_send_queue_sending_in_progress (send_queue);
+
+ store_conn_status = tny_account_get_connection_status (store_account);
+ if (store_conn_status == TNY_CONNECTION_STATUS_CONNECTED || sending) {
+ gint response;
+
+ response = modest_platform_run_confirmation_dialog (GTK_WINDOW (self),
+ _("emev_nc_disconnect_account"));
+ if (response == GTK_RESPONSE_OK) {
+ retval = TRUE;
+ } else {
+ retval = FALSE;
+ }
+ }
+
+ if (retval) {
+
+ /* FIXME: We should only cancel those of this account */
+ modest_mail_operation_queue_cancel_all (queue);
+
+ /* Also disconnect the account */
+ if ((tny_account_get_connection_status (store_account) != TNY_CONNECTION_STATUS_DISCONNECTED) &&
+ (tny_account_get_connection_status (store_account) != TNY_CONNECTION_STATUS_DISCONNECTED_BROKEN)) {
+ tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (store_account),
+ FALSE, NULL, NULL);
+ }
+ if (sending) {
+ tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (transport_account),
+ FALSE, NULL, NULL);
+ }
+ }
+
+ /* Frees */
+ g_object_unref (store_account);
+ g_object_unref (transport_account);
+
+ return retval;
+}
projects / modest / blobdiff