/* 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 <hildon/hildon-gtk.h>
#include <modest-header-window.h>
#include <modest-folder-window.h>
+#include <modest-maemo-utils.h>
#endif
#ifdef MODEST_PLATFORM_MAEMO
#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;
*/
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)));
wizard = GTK_WINDOW (modest_platform_get_account_settings_wizard ());
modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), GTK_WINDOW (wizard), (GtkWindow *) win);
- /* always present a main window in the background
+#ifndef MODEST_TOOLKIT_HILDON2
+ /* 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)
+ if (!win)
win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(),
TRUE); /* create if not existent */
+#else
+ if (!win) {
+ GList *window_list;
+ ModestWindowMgr *mgr;
+
+ mgr = modest_runtime_get_window_mgr ();
+
+ 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));
+ } else {
+ gtk_widget_destroy (GTK_WIDGET (win));
+ win = NULL;
+ }
- gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
+ 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);
+ }
+ }
+#endif
+
+ if (win)
+ gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
/* make sure the mainwindow is visible. We need to present the
wizard again to give it the focus back. show_all are needed
}
-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) {
+
+ if (response == GTK_RESPONSE_OK) {
ModestWindow *main_window = NULL;
ModestWindowMgr *mgr = NULL;
GtkTreeModel *model = 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));
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));
-
+
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;
+ 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_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)
/* 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 */
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 == MODEST_MAIL_OPERATION_ERROR_LOW_MEMORY) {
GObject *source = modest_mail_operation_get_source (mail_op);
modest_platform_run_information_dialog (GTK_IS_WINDOW (source) ? GTK_WINDOW (source) : NULL,
- dgettext("ke-recv","memr_ib_operation_disabled"),
+ _KR("memr_ib_operation_disabled"),
TRUE);
g_object_unref (source);
}
if (error && ((error->code == TNY_SERVICE_ERROR_NO_SUCH_MESSAGE) ||
error->code == TNY_SERVICE_ERROR_MESSAGE_NOT_AVAILABLE)) {
- gchar *subject, *msg;
+ gchar *subject, *msg, *format = NULL;
+ TnyAccount *account;
subject = tny_header_dup_subject (header);
if (!subject)
- subject = g_strdup (_("mail_va_no_subject"));;
- msg = g_strdup_printf (_("emev_ni_ui_imap_message_not_available_in_server"),
- subject);
+ subject = g_strdup (_("mail_va_no_subject"));
+
+ account = modest_mail_operation_get_account (mail_op);
+ if (account) {
+ ModestProtocol *protocol;
+ ModestProtocolType proto;
+ proto = modest_tny_account_get_protocol_type (account);
+ protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (), proto);
+ if (protocol)
+ format = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, subject);
+ g_object_unref (account);
+ }
+
+ if (!format)
+ format = g_strdup (_("emev_ni_ui_imap_message_not_available_in_server"));
+
+ msg = g_strdup_printf (format, subject);
modest_platform_run_information_dialog (NULL, msg, FALSE);
g_free (msg);
+ g_free (format);
g_free (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;
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 gchar *
-get_info_from_header (TnyHeader *header, gboolean *is_draft)
+get_info_from_header (TnyHeader *header, gboolean *is_draft, gboolean *can_open)
{
TnyFolder *folder;
gchar *account = NULL;
TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
*is_draft = FALSE;
+ *can_open = TRUE;
folder = tny_header_get_folder (header);
/* Gets folder type (OUTBOX headers will be opened in edit window */
if (folder_type == TNY_FOLDER_TYPE_INVALID)
g_warning ("%s: BUG: TNY_FOLDER_TYPE_INVALID", __FUNCTION__);
}
-
+
if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
TnyTransportAccount *traccount = NULL;
ModestTnyAccountStore *accstore = modest_runtime_get_account_store();
open any message from
outbox which is not in
failed state */
- g_object_unref(traccount);
+ *can_open = FALSE;
}
#endif
}
*is_draft = TRUE; /* Open in editor if the message is in the Drafts folder */
}
+ if (!account) {
+ TnyAccount *acc = tny_folder_get_account (folder);
+ if (acc) {
+ account =
+ g_strdup (modest_tny_account_get_parent_modest_account_name_for_server_account (acc));
+ g_object_unref (acc);
+ }
+ }
+
g_object_unref (folder);
return account;
}
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)
{
ModestWindow *win = NULL;
gchar *account = NULL;
gboolean open_in_editor = FALSE;
+ gboolean can_open;
OpenMsgHelper *helper = (OpenMsgHelper *) user_data;
-
+
/* Do nothing if there was any problem with the mail
operation. The error will be shown by the error_handler of
the mail operation */
/* Mark header as read */
headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
- account = get_info_from_header (header, &open_in_editor);
+ account = get_info_from_header (header, &open_in_editor, &can_open);
/* Get account */
if (!account)
account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (parent_win)));
if (!account)
account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr());
-
+
if (open_in_editor) {
ModestAccountMgr *mgr = modest_runtime_get_account_mgr ();
gchar *from_header = NULL, *acc_name;
} else {
gchar *uid = modest_tny_folder_get_header_unique_id (header);
- if (helper->rowref && helper->model) {
+ if (helper->rowref && helper->model) {
win = modest_msg_view_window_new_with_header_model (msg, account, (const gchar*) uid,
helper->model, helper->rowref);
} else {
}
g_free (uid);
}
-
+
/* Register and show new window */
if (win != NULL) {
mgr = modest_runtime_get_window_mgr ();
}
static gboolean
-is_memory_full_error (GError *error)
+is_memory_full_error (GError *error, ModestMailOperation *mail_op)
{
gboolean enough_free_space = TRUE;
GnomeVFSURI *cache_dir_uri;
- const gchar *cache_dir;
+ const gchar *cache_dir = NULL;
GnomeVFSFileSize free_space;
+ TnyAccountStore *acc_store;
+
+ acc_store = TNY_ACCOUNT_STORE (modest_runtime_get_account_store ());
+
+ /* Cache dir is different in case we're using an external storage (like MMC account) */
+ if (mail_op) {
+ TnyAccount *account = modest_mail_operation_get_account (mail_op);
+ if (account) {
+ if (modest_tny_account_is_memory_card_account (account)) {
+ cache_dir = g_getenv (MODEST_MMC1_VOLUMEPATH_ENV);
+ }
+ g_object_unref (account);
+ }
+ }
+
+ /* Get the default local cache dir */
+ if (!cache_dir)
+ cache_dir = tny_account_store_get_cache_dir (acc_store);
- 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;
+ if (cache_dir_uri) {
+ 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);
}
- 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
/* When the folder summary could not be read or
written */
error->code == TNY_IO_ERROR_WRITE ||
- error->code == TNY_IO_ERROR_READ) &&
+ error->code == TNY_IO_ERROR_READ) &&
!enough_free_space) {
return TRUE;
} else {
if (err == NULL)
return FALSE;
- if (is_memory_full_error (err))
+ if (is_memory_full_error (err, NULL))
modest_platform_information_banner (parent_window,
- NULL, dgettext("ke-recv",
- "cerm_device_memory_full"));
+ 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 */
+ connect so it'll return this error code */
modest_platform_information_banner (parent_window,
NULL, _("emev_ui_imap_inbox_select_error"));
else
/* 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)) {
+ if (is_memory_full_error ((GError *) error, mail_op)) {
modest_platform_information_banner ((GtkWidget *) win,
- NULL, dgettext("ke-recv",
- "cerm_device_memory_full"));
+ NULL, _KR("cerm_device_memory_full"));
} else if (error->code == TNY_SYSTEM_ERROR_MEMORY) {
modest_platform_information_banner ((GtkWidget *) win,
NULL, _("emev_ui_imap_inbox_select_error"));
} else if (error->domain == MODEST_MAIL_OPERATION_ERROR &&
error->code == MODEST_MAIL_OPERATION_ERROR_FILE_IO) {
modest_platform_information_banner ((GtkWidget *) win,
- NULL, dgettext ("hildon-common-strings", "sfil_ni_unable_to_open_file_not_found"));
+ 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);
}
}
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);
}
-
return account;
}
}
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;
- gboolean show_open_draft = FALSE;
OpenMsgHelper *helper = NULL;
+ ModestProtocol *protocol;
+ ModestProtocolRegistry *protocol_registry;
+ gchar *subject;
helper = (OpenMsgHelper *) user_data;
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);
-
+
goto clean;
}
if (proto == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
proto = MODEST_PROTOCOLS_STORE_MAILDIR;
}
-
- ModestProtocol *protocol;
- ModestProtocolRegistry *protocol_registry;
- gchar *subject;
-
+
protocol_registry = modest_runtime_get_protocol_registry ();
subject = tny_header_dup_subject (helper->header);
error_msg = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, subject);
if (subject)
g_free (subject);
-
+
if (error_msg == NULL) {
error_msg = g_strdup (_("mail_ni_ui_folder_get_msg_folder_error"));
}
+#ifndef MODEST_TOOLKIT_HILDON2
+ 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;
show_open_draft = (folder_type == TNY_FOLDER_TYPE_DRAFTS);
g_object_unref (folder);
}
+#endif
#ifdef MODEST_TOOLKIT_HILDON2
gboolean is_draft;
- gchar *account_name = get_info_from_header (helper->header, &is_draft);
+ gboolean can_open;
+ gchar *account_name = get_info_from_header (helper->header, &is_draft, &can_open);
+
+ if (!can_open) {
+ modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (), helper->header);
+ g_free (account_name);
+ open_msg_helper_destroyer (helper);
+ goto clean;
+ }
if (!is_draft) {
ModestWindow *window;
header_view = get_header_view_from_window (MODEST_WINDOW (parent_window));
uid = modest_tny_folder_get_header_unique_id (helper->header);
if (header_view) {
- window = modest_msg_view_window_new_from_header_view
+ window = modest_msg_view_window_new_from_header_view
(MODEST_HEADER_VIEW (header_view), account_name, uid, helper->rowref);
if (window != NULL) {
if (!modest_window_mgr_register_window (modest_runtime_get_window_mgr (),
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);
+
+#ifndef MODEST_TOOLKIT_HILDON2
if (show_open_draft) {
helper->banner_info = g_slice_new (OpenMsgBannerInfo);
-#ifdef MODEST_TOOLKIT_HILDON2
- helper->banner_info->message = g_strdup (_("mail_me_opening"));
-#else
helper->banner_info->message = g_strdup (_("mail_ib_opening_draft_message"));
-#endif
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
+
TnyList *headers;
headers = TNY_LIST (tny_simple_list_new ());
/* Frees */
clean:
+ if (error_msg)
+ g_free (error_msg);
if (mail_op)
g_object_unref (mail_op);
g_object_unref (account);
GtkWidget *header_view = NULL;
OpenMsgHelper *helper;
ModestWindow *window;
-
+
g_return_if_fail (header != NULL && rowref != NULL);
mgr = modest_runtime_get_window_mgr ();
window = NULL;
found = modest_window_mgr_find_registered_header (mgr, header, &window);
-
+
/* Do not open again the message and present the
window to the user */
if (found) {
/* 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)
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());
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;
g_free (helper->account_name);
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,
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,
+ signature = modest_account_mgr_get_signature (modest_runtime_get_account_mgr(),
+ rf_helper->account_name,
&use_signature);
/* Create reply mail */
switch (rf_helper->action) {
case ACTION_REPLY:
- new_msg =
- modest_tny_msg_create_reply_msg (msg, header, from,
+ new_msg =
+ modest_tny_msg_create_reply_msg (msg, header, from,
(use_signature) ? signature : NULL,
rf_helper->reply_forward_type,
MODEST_TNY_MSG_REPLY_MODE_SENDER);
break;
case ACTION_REPLY_TO_ALL:
- new_msg =
- modest_tny_msg_create_reply_msg (msg, header, from,
- (use_signature) ? signature : NULL,
+ new_msg =
+ modest_tny_msg_create_reply_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;
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;
}
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)
{
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,
+ modest_platform_on_new_headers_received (new_headers,
show_visual_notifications);
}
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;
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,
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_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;
/* 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),
- dgettext("ke-recv","memr_ib_operation_disabled"),
+ _KR("memr_ib_operation_disabled"),
TRUE);
return;
}
- folder_view =
+ folder_view =
modest_main_window_get_child_widget(win, MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
if (folder_view) {
}
-void
+void
modest_ui_actions_on_folder_selection_changed (ModestFolderView *folder_view,
- TnyFolderStore *folder_store,
+ TnyFolderStore *folder_store,
gboolean selected,
ModestMainWindow *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);
}
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 =
+ 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 (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);
ModestWindow *win)
{
/* g_message ("%s %s", __FUNCTION__, link); */
-}
+}
void
}
static void
-on_save_to_drafts_cb (ModestMailOperation *mail_op,
+on_save_to_drafts_cb (ModestMailOperation *mail_op,
TnyMsg *saved_draft,
gpointer user_data)
{
parts_size);
/* Double check: memory full condition or message too big */
- if (available_disk < MIN_FREE_SPACE ||
+ if (available_disk < MIN_FREE_SPACE ||
expected_size > available_disk) {
- modest_platform_information_banner (NULL, NULL,
- dgettext("ke-recv",
- "cerm_device_memory_full"));
+ 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),
- dgettext("ke-recv","memr_ib_operation_disabled"),
+ _KR("memr_ib_operation_disabled"),
TRUE);
return 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");
}
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);
transport_account,
data->draft_msg,
from,
- data->to,
- data->cc,
+ data->to,
+ data->cc,
data->bcc,
- data->subject,
- data->plain_body,
+ data->subject,
+ data->plain_body,
data->html_body,
data->attachments,
data->images,
if (!modest_msg_edit_window_check_names (edit_window, TRUE))
return TRUE;
-
+
data = modest_msg_edit_window_get_msg_data (edit_window);
/* Check size */
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);
data->draft_msg,
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,
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);
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
-modest_ui_actions_on_insert_image (GtkAction *action,
+void
+modest_ui_actions_on_insert_image (GObject *object,
ModestMsgEditWindow *window)
{
g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
- g_return_if_fail (GTK_IS_ACTION (action));
if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
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) {
/* Show an error. If there was some problem writing to
disk, show it, otherwise show the generic folder
modest_ui_actions_disk_operations_error_handler (mail_op,
_("mail_in_ui_folder_create_error"));
- /* 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
+ if (!is_memory_full_error ((GError *) error, mail_op)) {
+ /* Try again if there is no full memory condition */
+ do_create_folder (source_win, parent_folder, (const gchar *) suggested_name);
+ }
} 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
g_object_unref (source_win);
}
+typedef struct {
+ gchar *folder_name;
+ TnyFolderStore *parent;
+} CreateFolderConnect;
+
+static void
+do_create_folder_performer (gboolean canceled,
+ GError *err,
+ 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);
+ goto frees;
+ }
+
+ mail_op = modest_mail_operation_new ((GObject *) parent_window);
+ modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
+ mail_op);
+ modest_mail_operation_create_folder (mail_op,
+ helper->parent,
+ (const gchar *) helper->folder_name,
+ do_create_folder_cb,
+ g_strdup (helper->folder_name));
+ g_object_unref (mail_op);
+
+ frees:
+ if (helper->parent)
+ g_object_unref (helper->parent);
+ if (helper->folder_name)
+ g_free (helper->folder_name);
+ g_slice_free (CreateFolderConnect, helper);
+}
+
+
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) {
- ModestMailOperation *mail_op;
+ CreateFolderConnect *helper = (CreateFolderConnect *) g_slice_new0 (CreateFolderConnect);
+ helper->folder_name = g_strdup (folder_name);
+ helper->parent = g_object_ref (parent_folder);
- mail_op = modest_mail_operation_new ((GObject *) parent_window);
- modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
- mail_op);
- modest_mail_operation_create_folder (mail_op,
- parent_folder,
- (const gchar *) folder_name,
- do_create_folder_cb,
- folder_name);
- g_object_unref (mail_op);
+ modest_platform_connect_if_remote_and_perform (GTK_WINDOW (parent_window),
+ TRUE,
+ parent_folder,
+ do_create_folder_performer,
+ helper);
}
+ if (folder_name)
+ g_free (folder_name);
if (parent_folder)
g_object_unref (parent_folder);
}
static void
-create_folder_performer (gboolean canceled,
- GError *err,
- GtkWindow *parent_window,
- TnyAccount *account,
- gpointer user_data)
-{
- TnyFolderStore *parent_folder = TNY_FOLDER_STORE (user_data);
-
- if (canceled || err) {
- /* In memory full conditions we could get this error here */
- check_memory_full_error ((GtkWidget *) parent_window, err);
- goto frees;
- }
-
- /* Run the new folder dialog */
- do_create_folder (GTK_WINDOW (parent_window), parent_folder, NULL);
-
- frees:
- g_object_unref (parent_folder);
-}
-
-static void
modest_ui_actions_create_folder(GtkWidget *parent_window,
GtkWidget *folder_view)
{
TnyFolderStore *parent_folder;
#ifdef MODEST_TOOLKIT_HILDON2
- const gchar *active_account;
- TnyAccount *account;
ModestTnyAccountStore *acc_store;
- /* In hildon 2.2 we use the current account as default parent */
acc_store = modest_runtime_get_account_store ();
- active_account = modest_window_get_active_account (MODEST_WINDOW (parent_window));
- if (active_account) {
- account = modest_tny_account_store_get_server_account (acc_store,
- active_account,
- TNY_ACCOUNT_TYPE_STORE);
- parent_folder = TNY_FOLDER_STORE (account);
- } else {
- 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));
#endif
if (parent_folder) {
- /* The parent folder will be freed in the callback */
- modest_platform_connect_if_remote_and_perform (GTK_WINDOW (parent_window),
- TRUE,
- parent_folder,
- create_folder_performer,
- parent_folder);
+ do_create_folder (GTK_WINDOW (parent_window), parent_folder, NULL);
+ g_object_unref (parent_folder);
}
}
{
const GError *error = NULL;
const gchar *message = NULL;
-
+
/* Get error message */
error = modest_mail_operation_get_error (mail_op);
if (!error)
message is opened for example */
message = _("emev_ni_internal_error");
} else {
- message = _("emev_ib_ui_imap_unable_to_rename");
+ message = _CS("ckdg_ib_unable_to_rename");
}
/* We don't set a parent for the dialog because the dialog
} RenameFolderInfo;
static void
-on_rename_folder_cb (ModestMailOperation *mail_op,
+on_rename_folder_cb (ModestMailOperation *mail_op,
TnyFolder *new_folder,
gpointer user_data)
{
} else {
modest_folder_view_select_first_inbox_or_local (folder_view);
}
- gtk_widget_grab_focus (GTK_WIDGET (folder_view));
+ gtk_widget_grab_focus (GTK_WIDGET (folder_view));
}
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;
check_memory_full_error ((GtkWidget *) parent_window, err);
} else {
- mail_op =
+ mail_op =
modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window),
modest_ui_actions_rename_folder_error_handler,
parent_window, NULL);
folder_view = modest_main_window_get_child_widget (
MODEST_MAIN_WINDOW (parent_window),
MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
-
- /* Clear the headers view */
- sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
- gtk_tree_selection_unselect_all (sel);
- } else {
- folder_view = NULL;
}
+#ifdef MODEST_TOOLKIT_HILDON2
+ else if (MODEST_IS_FOLDER_WINDOW (parent_window)) {
+ ModestFolderWindow *folder_window = (ModestFolderWindow *) parent_window;
+ folder_view = GTK_WIDGET (modest_folder_window_get_folder_view (folder_window));
+ }
+#endif
+
+ /* Clear the folders view */
+ sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (folder_view));
+ gtk_tree_selection_unselect_all (sel);
/* Actually rename the folder */
modest_mail_operation_rename_folder (mail_op,
(const gchar *) (data->new_name),
on_rename_folder_cb,
folder_view);
- g_object_unref (data->folder);
g_object_unref (mail_op);
}
+ g_object_unref (data->folder);
g_free (data->new_name);
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)) {
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)) {
folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
+ if (!folder)
+ return FALSE;
+
/* Show an error if it's an account */
if (!TNY_IS_FOLDER (folder)) {
modest_platform_run_information_dialog (GTK_WINDOW (window),
return FALSE;
}
- /* Ask the user */
- message = g_strdup_printf (_("mcen_nc_delete_folder_text"),
+ /* Ask the user */
+ 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,
+headers_action_show_details (TnyHeader *header,
ModestWindow *window,
gpointer user_data)
/*
* Show the header details in a ModestDetailsDialog widget
*/
-void
-modest_ui_actions_on_details (GtkAction *action,
+void
+modest_ui_actions_on_details (GtkAction *action,
ModestWindow *win)
{
- TnyList * headers_list;
- TnyIterator *iter;
- TnyHeader *header;
-
if (MODEST_IS_MSG_VIEW_WINDOW (win)) {
TnyMsg *msg;
+ TnyHeader *header;
msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (win));
if (!msg)
return;
- g_object_unref (msg);
- headers_list = get_selected_headers (win);
- if (!headers_list)
- return;
-
- iter = tny_list_create_iterator (headers_list);
-
- header = TNY_HEADER (tny_iterator_get_current (iter));
+ header = tny_msg_get_header (msg);
if (header) {
headers_action_show_details (header, win, NULL);
g_object_unref (header);
}
-
- g_object_unref (iter);
- g_object_unref (headers_list);
+ g_object_unref (msg);
} else if (MODEST_IS_MAIN_WINDOW (win)) {
GtkWidget *folder_view, *header_view;
= 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;
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;
case MODEST_GTK_RESPONSE_NEW_FOLDER:
- modest_ui_actions_create_folder (GTK_WIDGET (parent_win), folder_view);
+ modest_ui_actions_create_folder (GTK_WIDGET (dialog), GTK_WIDGET (folder_view));
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));
}
}
/* Free the helper and exit */
- g_object_unref (helper->list);
+ if (helper->list)
+ g_object_unref (helper->list);
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 */
/* Hide special folders */
modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (tree_view), FALSE);
+ 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;
+ GObject *object = modest_mail_operation_get_source (mail_op);
/* Note that the operation could have failed, in that case do
nothing */
- if (modest_mail_operation_get_status (mail_op) ==
- MODEST_MAIL_OPERATION_STATUS_SUCCESS) {
+ if (modest_mail_operation_get_status (mail_op) !=
+ MODEST_MAIL_OPERATION_STATUS_SUCCESS)
+ goto frees;
- GObject *object = modest_mail_operation_get_source (mail_op);
- if (MODEST_IS_MSG_VIEW_WINDOW (object)) {
- ModestMsgViewWindow *self = MODEST_MSG_VIEW_WINDOW (object);
+ if (MODEST_IS_MSG_VIEW_WINDOW (object)) {
+ ModestMsgViewWindow *self = MODEST_MSG_VIEW_WINDOW (object);
- if (!modest_msg_view_window_select_next_message (self) &&
- !modest_msg_view_window_select_previous_message (self)) {
- /* 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) &&
- gtk_tree_row_reference_valid (helper->reference)) {
- GtkWidget *header_view;
- GtkTreePath *path;
- GtkTreeSelection *sel;
-
- header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(object),
- MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
- sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
- path = gtk_tree_row_reference_get_path (helper->reference);
- /* We need to unselect the previous one
- because we could be copying instead of
- moving */
- gtk_tree_selection_unselect_all (sel);
- gtk_tree_selection_select_path (sel, path);
- gtk_tree_path_free (path);
+ if (!modest_msg_view_window_select_next_message (self) &&
+ !modest_msg_view_window_select_previous_message (self)) {
+ /* No more messages to view, so close this window */
+ modest_ui_actions_on_close_window (NULL, MODEST_WINDOW(self));
}
- g_object_unref (object);
- }
+ } else if (MODEST_IS_MAIN_WINDOW (object) &&
+ gtk_tree_row_reference_valid (helper->reference)) {
+ GtkWidget *header_view;
+ GtkTreePath *path;
+ GtkTreeSelection *sel;
+
+ header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(object),
+ MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
+ sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
+ path = gtk_tree_row_reference_get_path (helper->reference);
+ /* We need to unselect the previous one
+ because we could be copying instead of
+ moving */
+ gtk_tree_selection_unselect_all (sel);
+ gtk_tree_selection_select_path (sel, path);
+ gtk_tree_path_free (path);
+ }
+ g_object_unref (object);
+
+ frees:
/* Destroy the helper */
move_to_helper_destroyer (helper);
}
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;
+
+#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 */
if (main_window) {
- GObject *win = NULL;
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);
}
-
- /* 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);
- if (win)
- g_object_unref (win);
}
+#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);
+ 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 */
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)
* Checks if we need a connection to do the transfer and if the user
* wants to connect to complete it
*/
-void
+static void
modest_ui_actions_xfer_messages_check (GtkWindow *parent_window,
TnyFolderStore *src_folder,
TnyList *headers,
TnyAccount *src_account;
gint uncached_msgs = 0;
- uncached_msgs = header_list_count_uncached_msgs (headers);
-
/* We don't need any further check if
*
* 1- the source folder is local OR
/* 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
* offline, it'll take place the next time we get a
* connection)
*/
+ uncached_msgs = header_list_count_uncached_msgs (headers);
src_account = get_account_from_folder_store (src_folder);
if (uncached_msgs > 0) {
guint num_headers;
if (remote_folder_has_leave_on_server (src_folder) && delete_originals) {
const gchar *account_name;
gboolean leave_on_server;
-
+
account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (src_account);
leave_on_server = modest_account_mgr_get_leave_on_server (modest_runtime_get_account_mgr (),
account_name);
-
+
if (leave_on_server == TRUE) {
*need_connection = FALSE;
} else {
}
static void
-xfer_messages_error_handler (ModestMailOperation *mail_op,
+xfer_messages_error_handler (ModestMailOperation *mail_op,
gpointer user_data)
{
- ModestWindow *main_window = NULL;
+ GObject *win;
+ const GError *error;
- /* Disable next automatic folder selection */
- main_window = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
- FALSE); /* don't create */
- if (main_window) {
- GObject *win = modest_mail_operation_get_source (mail_op);
- modest_platform_run_information_dialog ((GtkWindow *) win,
- _("mail_in_ui_folder_move_target_error"),
+ win = modest_mail_operation_get_source (mail_op);
+ error = modest_mail_operation_get_error (mail_op);
+
+ if (error && is_memory_full_error ((GError *) error, mail_op))
+ modest_platform_information_banner ((GtkWidget *) win,
+ NULL, _KR("cerm_device_memory_full"));
+ else
+ modest_platform_run_information_dialog ((GtkWindow *) win,
+ _("mail_in_ui_folder_move_target_error"),
FALSE);
- if (win)
- g_object_unref (win);
- }
- move_to_helper_destroyer (user_data);
+ if (win)
+ g_object_unref (win);
}
typedef struct {
* 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);
}
movehelper = g_new0 (MoveToHelper, 1);
+
+#ifndef MODEST_TOOLKIT_HILDON2
movehelper->banner = modest_platform_animation_banner (GTK_WIDGET (win), NULL,
_CS("ckct_nw_pasting"));
if (movehelper->banner != NULL) {
g_object_ref (movehelper->banner);
gtk_widget_show (GTK_WIDGET (movehelper->banner));
}
+#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,
+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)) {
g_object_unref (G_OBJECT (info->src_folder));
g_object_unref (G_OBJECT (info->dst_folder));
g_free (info);
return;
}
-
+
MoveToHelper *helper = g_new0 (MoveToHelper, 1);
+#ifndef MODEST_TOOLKIT_HILDON2
helper->banner = modest_platform_animation_banner (GTK_WIDGET (parent_window), NULL,
_CS("ckct_nw_pasting"));
if (helper->banner != NULL) {
g_object_ref (helper->banner);
gtk_widget_show (GTK_WIDGET(helper->banner));
}
+#endif
/* Clean folder on header view before moving it */
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (info->folder_view));
gtk_tree_selection_unselect_all (sel);
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);
/* Select *after* the changes */
- /* TODO: this function hangs UI after transfer */
+ /* TODO: this function hangs UI after transfer */
/* modest_folder_view_select_folder (MODEST_FOLDER_VIEW(folder_view), */
/* TNY_FOLDER (src_folder), TRUE); */
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;
+ /* Show an error */
+ modest_platform_run_information_dialog (win,
+ _("mail_in_ui_folder_move_target_error"),
+ FALSE);
} else if (!TNY_IS_FOLDER (src_folder)) {
g_warning ("%s: src_folder is not a TnyFolder.\n", __FUNCTION__);
do_xfer = FALSE;
if (do_xfer) {
MoveFolderInfo *info = g_new0 (MoveFolderInfo, 1);
DoubleConnectionInfo *connect_info = g_slice_new (DoubleConnectionInfo);
-
+
info->src_folder = g_object_ref (src_folder);
info->dst_folder = g_object_ref (dst_folder);
info->delete_original = TRUE;
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);
}
+
/* Frees */
g_object_unref (src_folder);
}
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, *folder_view = NULL;
- ModestMainWindow *main_window;
+ GtkWidget *dialog = NULL;
MoveToInfo *helper = NULL;
+ TnyList *list_to_move;
g_return_val_if_fail (MODEST_IS_WINDOW (win), FALSE);
+#ifndef MODEST_TOOLKIT_HILDON2
/* Get the main window if exists */
+ ModestMainWindow *main_window;
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
- /* Get the folder view widget if exists */
- if (main_window)
- folder_view = modest_main_window_get_child_widget (main_window,
- MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
- else
- folder_view = NULL;
+ list_to_move = modest_platform_get_list_to_move (MODEST_WINDOW (win));
+
+ if (!list_to_move)
+ return FALSE;
+
+ if (tny_list_get_length (list_to_move) < 1) {
+ g_object_unref (list_to_move);
+ return FALSE;
+ }
/* Create and run the dialog */
- dialog = create_move_to_dialog (GTK_WINDOW (win), folder_view);
- 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 */
helper = g_slice_new0 (MoveToInfo);
- helper->list = modest_platform_get_list_to_move (MODEST_WINDOW (win));
+ helper->list = list_to_move;
helper->win = win;
/* Listen to response signal */
* 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)
{
/* Trick: do a poke status in order to speed up the signaling
of observers */
- tny_folder_poke_status (folder);
+ if (folder) {
+ tny_folder_poke_status (folder);
+ g_object_unref (folder);
+ }
/* Frees */
- g_object_unref (folder);
g_object_unref (iter);
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,
}
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;
/* 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));
void
-modest_ui_actions_on_toggle_find_in_page (GtkToggleAction *action,
+modest_ui_actions_on_toggle_find_in_page (GtkAction *action,
ModestWindow *window)
{
+ gboolean active;
g_return_if_fail (MODEST_IS_MSG_EDIT_WINDOW (window));
- modest_msg_edit_window_toggle_find_toolbar (MODEST_MSG_EDIT_WINDOW (window), gtk_toggle_action_get_active (action));
+ if (GTK_IS_TOGGLE_ACTION (action))
+ active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+ else
+ active = TRUE;
+
+ 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 (dgettext("hildon-common-strings", "sfil_ib_unable_to_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 (dgettext("hildon-common-strings", "sfil_ib_unable_to_send"));
- break;
+ message = g_strdup (_CS("sfil_ib_unable_to_send"));
+ 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)
{
- ModestMainWindow *main_window = NULL;
+ ModestWindow *top_window = NULL;
ModestWindowMgr *mgr = NULL;
- GtkWidget *folder_view = NULL, *header_view = NULL;
- TnyFolderStore *selected_folder = NULL;
+ GtkWidget *header_view = NULL;
+ TnyFolder *selected_folder = NULL;
TnyFolderType folder_type;
mgr = modest_runtime_get_window_mgr ();
- main_window = MODEST_MAIN_WINDOW (modest_window_mgr_get_main_window (mgr,
- FALSE));/* don't create */
- if (!main_window)
+ top_window = modest_window_mgr_get_current_top (mgr);
+
+ if (!top_window)
return;
- /* Check if selected folder is OUTBOX */
- folder_view = modest_main_window_get_child_widget (main_window,
- MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
- header_view = modest_main_window_get_child_widget (main_window,
- MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
+#ifndef MODEST_TOOLKIT_HILDON2
+ if (MODEST_IS_MAIN_WINDOW (top_window)) {
+ header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (top_window),
+ MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
+ }
+#else
+ if (MODEST_IS_HEADER_WINDOW (top_window)) {
+ header_view = (GtkWidget *)
+ modest_header_window_get_header_view (MODEST_HEADER_WINDOW (top_window));
+ }
+#endif
- selected_folder = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
- if (!TNY_IS_FOLDER (selected_folder))
- goto frees;
+ /* Get selected folder */
+ if (header_view)
+ selected_folder = modest_header_view_get_folder (MODEST_HEADER_VIEW (header_view));
+ if (!selected_folder)
+ return;
/* gtk_tree_view_column_queue_resize is only available in GTK+ 2.8 */
-#if GTK_CHECK_VERSION(2, 8, 0)
- folder_type = modest_tny_folder_guess_folder_type (TNY_FOLDER (selected_folder));
- if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
+#if GTK_CHECK_VERSION(2, 8, 0)
+ folder_type = modest_tny_folder_guess_folder_type (selected_folder);
+ if (folder_type == TNY_FOLDER_TYPE_OUTBOX) {
GtkTreeViewColumn *tree_column;
- tree_column = gtk_tree_view_get_column (GTK_TREE_VIEW (header_view),
+ tree_column = gtk_tree_view_get_column (GTK_TREE_VIEW (header_view),
TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN);
if (tree_column)
gtk_tree_view_column_queue_resize (tree_column);
- }
-#else
+ }
+#else /* #if GTK_CHECK_VERSION(2, 8, 0) */
gtk_widget_queue_draw (header_view);
-#endif
+#endif
+#ifndef MODEST_TOOLKIT_HILDON2
/* Rerun dimming rules, because the message could become deletable for example */
- modest_window_check_dimming_rules_group (MODEST_WINDOW (main_window),
+ modest_window_check_dimming_rules_group (MODEST_WINDOW (top_window),
MODEST_DIMMING_RULES_TOOLBAR);
- modest_window_check_dimming_rules_group (MODEST_WINDOW (main_window),
+ modest_window_check_dimming_rules_group (MODEST_WINDOW (top_window),
MODEST_DIMMING_RULES_MENU);
-
+#endif
+
/* Free */
- frees:
- if (selected_folder != NULL)
- g_object_unref (selected_folder);
+ g_object_unref (selected_folder);
}
-void
+void
modest_ui_actions_on_account_connection_error (GtkWindow *parent_window,
TnyAccount *account)
{
ModestProtocolType protocol_type;
ModestProtocol *protocol;
gchar *error_note = NULL;
-
+
protocol_type = modest_tny_account_get_protocol_type (account);
protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
protocol_type);
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;
}
projects / modest / blobdiff