#include <modest-address-book.h>
#include "modest-error.h"
#include "modest-ui-actions.h"
-#include "modest-protocol-info.h"
#include "modest-tny-platform-factory.h"
#include "modest-platform.h"
#include "modest-debug.h"
#include <tny-camel-folder.h>
#include <tny-camel-imap-folder.h>
#include <tny-camel-pop-folder.h>
+#ifdef MODEST_TOOLKIT_HILDON2
+#include <hildon/hildon-pannable-area.h>
+#include <modest-header-window.h>
+#endif
#ifdef MODEST_PLATFORM_MAEMO
#include "maemo/modest-osso-state-saving.h"
+#endif /* MODEST_PLATFORM_MAEMO */
+#ifndef MODEST_TOOLKIT_GTK
#include "maemo/modest-hildon-includes.h"
#include "maemo/modest-connection-specific-smtp-window.h"
-#endif /* MODEST_PLATFORM_MAEMO */
+#endif /* !MODEST_TOOLKIT_GTK */
#include <modest-utils.h>
#include "widgets/modest-ui-constants.h"
#include "modest-text-utils.h"
#ifdef MODEST_HAVE_EASYSETUP
+#ifdef MODEST_TOOLKIT_HILDON2
+#include "modest-easysetup-wizard-dialog.h"
+#else
#include "easysetup/modest-easysetup-wizard-dialog.h"
+#endif
#endif /* MODEST_HAVE_EASYSETUP */
#include <modest-widget-memory.h>
#include <gtkhtml/gtkhtml.h>
#define MIN_FREE_SPACE 5 * 1024 * 1024
+#define MOVE_FOLDER_OK_BUTTON "ok-button"
+#define MOVE_FOLDER_NEW_BUTTON "new-button"
typedef struct _GetMsgAsyncHelper {
ModestWindow *window;
gint num_of_uncached_msgs,
TnyAccount *account);
-static gboolean remote_folder_is_pop (TnyFolderStore *folder);
+static gboolean remote_folder_has_leave_on_server (TnyFolderStore *folder);
static void do_create_folder (GtkWindow *window,
TnyFolderStore *parent_folder,
* This function checks whether a TnyFolderStore is a pop account
*/
static gboolean
-remote_folder_is_pop (TnyFolderStore *folder)
+remote_folder_has_leave_on_server (TnyFolderStore *folder)
{
- const gchar *proto = NULL;
- TnyAccount *account = NULL;
+ TnyAccount *account;
+ gboolean result;
g_return_val_if_fail (TNY_IS_FOLDER_STORE (folder), FALSE);
account = get_account_from_folder_store (folder);
- proto = tny_account_get_proto (account);
+ result = (modest_protocol_registry_protocol_type_has_leave_on_server (modest_runtime_get_protocol_registry (),
+ modest_tny_account_get_protocol_type (account)));
g_object_unref (account);
- return (modest_protocol_info_get_transport_store_protocol (proto) == MODEST_PROTOCOL_STORE_POP);
+ return result;
}
/* FIXME: this should be merged with the similar code in modest-account-view-window */
gboolean
modest_ui_actions_run_account_setup_wizard (ModestWindow *win)
{
- gboolean result = FALSE;
- GtkWindow *dialog, *wizard;
+ gboolean result = FALSE;
+ GtkWindow *wizard;
gint dialog_response;
- /* Show the easy-setup wizard: */
- dialog = modest_window_mgr_get_modal (modest_runtime_get_window_mgr());
- if (dialog) {
- /* old wizard is active already;
- */
- gtk_window_present (GTK_WINDOW(dialog));
- return FALSE;
- }
-
-
- /* there is no such wizard yet */
+ /* there is no such wizard yet */
wizard = GTK_WINDOW (modest_platform_get_account_settings_wizard ());
- modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), wizard);
+ modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), GTK_WINDOW (wizard), (GtkWindow *) win);
/* always present a main window in the background
* we do it here, so we cannot end up with two wizards (as this
if (!win)
win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(),
TRUE); /* create if not existent */
-
+
gtk_window_set_transient_for (GTK_WINDOW (wizard), GTK_WINDOW (win));
/* make sure the mainwindow is visible. We need to present the
in order to get the widgets properly drawn (MainWindow main
paned won't be in its right position and the dialog will be
missplaced */
+#ifndef MODEST_TOOLKIT_HILDON2
gtk_widget_show_all (GTK_WIDGET (win));
gtk_widget_show_all (GTK_WIDGET (wizard));
gtk_window_present (GTK_WINDOW (win));
gtk_window_present (GTK_WINDOW (wizard));
-
+#endif
+
dialog_response = gtk_dialog_run (GTK_DIALOG (wizard));
gtk_widget_destroy (GTK_WIDGET (wizard));
if (gtk_events_pending ())
if (header) {
gchar *subject;
subject = tny_header_dup_subject (header);
+ if (!subject)
+ subject = g_strdup (_("mail_va_no_subject"));
desc = g_strdup_printf ("%s", subject);
g_free (subject);
g_object_unref (header);
}
/* Free */
- if (next_row_reference != NULL)
+ 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 (prev_row_reference != NULL)
+ if (gtk_tree_row_reference_valid (prev_row_reference))
gtk_tree_row_reference_free (prev_row_reference);
if (prev_path != NULL)
gtk_tree_path_free (prev_path);
}
void
+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));
+}
+
+void
modest_ui_actions_on_add_to_contacts (GtkAction *action, ModestWindow *win)
{
GtkClipboard *clipboard = NULL;
GtkWindow *account_win = GTK_WINDOW (modest_account_view_window_new ());
/* The accounts dialog must be modal */
- modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), account_win);
+ 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));
}
}
* because it requires an API (libconic) to detect different connection
* possiblities.
*/
-#ifdef MODEST_PLATFORM_MAEMO /* Defined in config.h */
+#ifndef MODEST_TOOLKIT_GTK /* Defined in config.h */
/* Create the window if necessary: */
GtkWidget *specific_window = GTK_WIDGET (modest_connection_specific_smtp_window_new ());
/* Show the window: */
modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
- GTK_WINDOW (specific_window));
+ GTK_WINDOW (specific_window), (GtkWindow *) win);
gtk_widget_show (specific_window);
-#endif /* MODEST_PLATFORM_MAEMO */
+#endif /* !MODEST_TOOLKIT_GTK */
}
void
ModestTnyAccountStore *store = modest_runtime_get_account_store();
GnomeVFSFileSize total_size, allowed_size;
- /* we check for low-mem; in that case, show a warning, and don't allow
- * composing a message with attachments
- */
- if (attachments && modest_platform_check_memory_low (win, TRUE))
+ /* we check for low-mem */
+ if (modest_platform_check_memory_low (win, TRUE))
goto cleanup;
- account_name = modest_account_mgr_get_default_account(mgr);
+#ifdef MODEST_TOOLKIT_HILDON2
+ account_name = g_strdup (modest_window_get_active_account(win));
+#endif
+ if (!account_name) {
+ account_name = modest_account_mgr_get_default_account(mgr);
+ }
if (!account_name) {
g_printerr ("modest: no account found\n");
goto cleanup;
allowed_size = MODEST_MAX_ATTACHMENT_SIZE;
msg_win = modest_msg_edit_window_new (msg, account_name, FALSE);
- modest_window_mgr_register_window (modest_runtime_get_window_mgr(), msg_win);
+ if (!modest_window_mgr_register_window (modest_runtime_get_window_mgr(), msg_win, NULL)) {
+ gtk_widget_destroy (GTK_WIDGET (msg_win));
+ goto cleanup;
+ }
modest_msg_edit_window_set_modified (MODEST_MSG_EDIT_WINDOW (msg_win), set_as_modified);
gtk_widget_show_all (GTK_WIDGET (msg_win));
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;
+ 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);
+ modest_platform_run_information_dialog (NULL, msg, FALSE);
+ g_free (msg);
+ g_free (subject);
+ }
+
/* Remove the header from the preregistered uids */
modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
header);
typedef struct {
GtkTreeModel *model;
- TnyList *headers;
+ TnyHeader *header;
OpenMsgBannerInfo *banner_info;
- GHashTable *row_refs_per_header;
+ GtkTreeRowReference *rowref;
} OpenMsgHelper;
gboolean
}
-static void
-open_msg_cb (ModestMailOperation *mail_op,
- TnyHeader *header,
- gboolean canceled,
- TnyMsg *msg,
- GError *err,
- gpointer user_data)
+static GtkWidget *
+get_header_view_from_window (ModestWindow *window)
{
- ModestWindowMgr *mgr = NULL;
- ModestWindow *parent_win = NULL;
- ModestWindow *win = NULL;
- TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
- gchar *account = NULL;
- TnyFolder *folder;
- gboolean open_in_editor = FALSE;
- 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 */
- if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
- return;
+ GtkWidget *header_view;
- parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
- folder = tny_header_get_folder (header);
+ if (MODEST_IS_MAIN_WINDOW (window)) {
+ header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (window),
+ MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
+#ifdef MODEST_TOOLKIT_HILDON2
+ } else if (MODEST_IS_HEADER_WINDOW (window)){
+ header_view = GTK_WIDGET (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (window)));
+#endif
+ } else {
+ header_view = NULL;
+ }
- /* Mark header as read */
- headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
+ return header_view;
+}
+static gchar *
+get_info_from_header (TnyHeader *header, gboolean *is_draft)
+{
+ TnyFolder *folder;
+ gchar *account = NULL;
+ TnyFolderType folder_type = TNY_FOLDER_TYPE_UNKNOWN;
+
+ *is_draft = FALSE;
+
+ folder = tny_header_get_folder (header);
/* Gets folder type (OUTBOX headers will be opened in edit window */
if (modest_tny_folder_is_local_folder (folder)) {
folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
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;
if (traccount) {
ModestTnySendQueue *send_queue = NULL;
ModestTnySendQueueStatus status;
- char *msg_id;
+ gchar *msg_id;
account = g_strdup(modest_tny_account_get_parent_modest_account_name_for_server_account(
TNY_ACCOUNT(traccount)));
send_queue = modest_runtime_get_send_queue(traccount, TRUE);
if (TNY_IS_SEND_QUEUE (send_queue)) {
msg_id = modest_tny_send_queue_get_msg_id (header);
status = modest_tny_send_queue_get_msg_status(send_queue, msg_id);
+ g_free(msg_id);
+
/* Only open messages in outbox with the editor if they are in Failed state */
if (status == MODEST_TNY_SEND_QUEUE_FAILED) {
- open_in_editor = TRUE;
+ *is_draft = TRUE;
}
- g_free(msg_id);
+#endif
}
g_object_unref(traccount);
} else {
g_warning("Cannot get transport account for message in outbox!!");
}
} else if (folder_type == TNY_FOLDER_TYPE_DRAFTS) {
- open_in_editor = TRUE; /* Open in editor if the message is in the Drafts folder */
+ *is_draft = TRUE; /* Open in editor if the message is in the Drafts folder */
}
+ g_object_unref (folder);
+
+ return account;
+}
+
+static void
+open_msg_cb (ModestMailOperation *mail_op,
+ TnyHeader *header,
+ gboolean canceled,
+ TnyMsg *msg,
+ GError *err,
+ gpointer user_data)
+{
+ ModestWindowMgr *mgr = NULL;
+ ModestWindow *parent_win = NULL;
+ ModestWindow *win = NULL;
+ gchar *account = NULL;
+ gboolean open_in_editor = FALSE;
+ 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 */
+ if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg))
+ return;
+
+ parent_win = (ModestWindow *) modest_mail_operation_get_source (mail_op);
+
+ /* Mark header as read */
+ headers_action_mark_as_read (header, MODEST_WINDOW(parent_win), NULL);
+
+ account = get_info_from_header (header, &open_in_editor);
+
/* 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;
win = modest_msg_edit_window_new (msg, account, TRUE);
} else {
gchar *uid = modest_tny_folder_get_header_unique_id (header);
-
- if (MODEST_IS_MAIN_WINDOW (parent_win)) {
- GtkTreeRowReference *row_reference;
- row_reference = (GtkTreeRowReference *) g_hash_table_lookup (helper->row_refs_per_header, header);
-
+ if (helper->rowref && helper->model) {
win = modest_msg_view_window_new_with_header_model (msg, account, (const gchar*) uid,
- helper->model, row_reference);
+ helper->model, helper->rowref);
} else {
win = modest_msg_view_window_new_for_attachment (msg, account, (const gchar*) uid);
}
g_free (uid);
}
-
+
/* Register and show new window */
if (win != NULL) {
mgr = modest_runtime_get_window_mgr ();
- modest_window_mgr_register_window (mgr, win);
+ if (!modest_window_mgr_register_window (mgr, win, NULL)) {
+ gtk_widget_destroy (GTK_WIDGET (win));
+ goto cleanup;
+ }
gtk_widget_show_all (GTK_WIDGET(win));
}
/* Free */
g_free(account);
g_object_unref (parent_win);
- g_object_unref (folder);
}
static gboolean
return account;
}
-static void
-foreach_unregister_headers (gpointer data,
- gpointer user_data)
+static TnyAccount*
+get_account_from_header (TnyHeader *header)
{
- ModestWindowMgr *mgr = (ModestWindowMgr *) user_data;
- TnyHeader *header = TNY_HEADER (data);
+ TnyAccount *account = NULL;
+ TnyFolder *folder;
- modest_window_mgr_unregister_header (mgr, header);
+ folder = tny_header_get_folder (header);
+
+ if (folder) {
+ account = tny_folder_get_account (folder);
+ g_object_unref (folder);
+ }
+
+ return account;
}
static void
-open_msgs_helper_destroyer (gpointer user_data)
+open_msg_helper_destroyer (gpointer user_data)
{
OpenMsgHelper *helper = (OpenMsgHelper *) user_data;
helper->banner_info = NULL;
}
g_object_unref (helper->model);
- g_object_unref (helper->headers);
- g_hash_table_destroy (helper->row_refs_per_header);
+ g_object_unref (helper->header);
+ gtk_tree_row_reference_free (helper->rowref);
g_slice_free (OpenMsgHelper, helper);
}
static void
-open_msgs_performer(gboolean canceled,
+open_msg_performer(gboolean canceled,
GError *err,
GtkWindow *parent_window,
TnyAccount *account,
gpointer user_data)
{
ModestMailOperation *mail_op = NULL;
- const gchar *proto_name;
gchar *error_msg;
- ModestTransportStoreProtocol proto;
- TnyList *not_opened_headers;
+ ModestProtocolType proto;
TnyConnectionStatus status;
gboolean show_open_draft = FALSE;
OpenMsgHelper *helper = NULL;
helper = (OpenMsgHelper *) user_data;
- not_opened_headers = helper->headers;
status = tny_account_get_connection_status (account);
if (err || canceled) {
- /* Unregister the already registered headers */
- tny_list_foreach (not_opened_headers, foreach_unregister_headers,
- modest_runtime_get_window_mgr ());
+ modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (), helper->header);
/* Free the helper */
- open_msgs_helper_destroyer (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;
}
/* Get the error message depending on the protocol */
- proto_name = tny_account_get_proto (account);
- if (proto_name != NULL) {
- proto = modest_protocol_info_get_transport_store_protocol (proto_name);
- } else {
- proto = MODEST_PROTOCOL_STORE_MAILDIR;
+ proto = modest_tny_account_get_protocol_type (account);
+ if (proto == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
+ proto = MODEST_PROTOCOLS_STORE_MAILDIR;
}
- /* Create the error messages */
- if (tny_list_get_length (not_opened_headers) == 1) {
- if (proto == MODEST_PROTOCOL_STORE_POP) {
- error_msg = g_strdup (_("emev_ni_ui_pop3_msg_recv_error"));
- } else if (proto == MODEST_PROTOCOL_STORE_IMAP) {
- TnyIterator *iter = tny_list_create_iterator (not_opened_headers);
- TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
- gchar *subject = tny_header_dup_subject (header);
- error_msg = g_strdup_printf (_("emev_ni_ui_imap_message_not_available_in_server"),
- subject);
- g_free (subject);
- g_object_unref (header);
- g_object_unref (iter);
- } else {
- TnyHeader *header;
- TnyFolder *folder;
- TnyIterator *iter;
- TnyFolderType folder_type;
+ ModestProtocol *protocol;
+ ModestProtocolRegistry *protocol_registry;
+ gchar *subject;
+
+ protocol_registry = modest_runtime_get_protocol_registry ();
+ subject = tny_header_dup_subject (helper->header);
- iter = tny_list_create_iterator (not_opened_headers);
- header = TNY_HEADER (tny_iterator_get_current (iter));
- folder = tny_header_get_folder (header);
- folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
- show_open_draft = (folder_type == TNY_FOLDER_TYPE_DRAFTS);
- g_object_unref (folder);
- g_object_unref (header);
- g_object_unref (iter);
- error_msg = g_strdup (_("mail_ni_ui_folder_get_msg_folder_error"));
- }
- } else {
+ protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, proto);
+ 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"));
}
+ if (modest_protocol_registry_protocol_type_has_tag (protocol_registry,
+ proto,
+ MODEST_PROTOCOL_REGISTRY_LOCAL_STORE_PROTOCOLS)) {
+ TnyFolder *folder;
+ TnyFolderType folder_type;
+
+ folder = tny_header_get_folder (helper->header);
+ folder_type = modest_tny_folder_get_local_or_mmc_folder_type (folder);
+ show_open_draft = (folder_type == TNY_FOLDER_TYPE_DRAFTS);
+ g_object_unref (folder);
+ }
+
+#ifdef MODEST_TOOLKIT_HILDON2
+ gboolean is_draft;
+ gchar *account_name = get_info_from_header (helper->header, &is_draft);
+
+ if (!is_draft) {
+ ModestWindow *window;
+ GtkWidget *header_view;
+ gchar *uid;
+
+ header_view = get_header_view_from_window (MODEST_WINDOW (parent_window));
+ uid = modest_tny_folder_get_header_unique_id (helper->header);
+ if (header_view) {
+ window = modest_msg_view_window_new_from_header_view
+ (MODEST_HEADER_VIEW (header_view), account_name, uid, helper->rowref);
+ if (window != NULL) {
+ if (!modest_window_mgr_register_window (modest_runtime_get_window_mgr (),
+ window, NULL)) {
+ gtk_widget_destroy (GTK_WIDGET (window));
+ } else {
+ gtk_widget_show_all (GTK_WIDGET(window));
+ }
+ }
+ }
+ g_free (account_name);
+ g_free (uid);
+ open_msg_helper_destroyer (helper);
+ goto clean;
+ }
+ g_free (account_name);
+#endif
/* Create the mail operation */
mail_op =
modest_mail_operation_new_with_error_handling ((GObject *) parent_window,
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);
}
+ TnyList *headers;
+ headers = TNY_LIST (tny_simple_list_new ());
+ tny_list_prepend (headers, G_OBJECT (helper->header));
modest_mail_operation_get_msgs_full (mail_op,
- not_opened_headers,
+ headers,
open_msg_cb,
helper,
- open_msgs_helper_destroyer);
+ open_msg_helper_destroyer);
+ g_object_unref (headers);
/* Frees */
clean:
* same when trying to open messages.
*/
static void
-open_msgs_from_headers (TnyList *headers, ModestWindow *win)
+open_msg_from_header (TnyHeader *header, GtkTreeRowReference *rowref, ModestWindow *win)
{
ModestWindowMgr *mgr = NULL;
- TnyIterator *iter = NULL, *iter_not_opened = NULL;
- TnyList *not_opened_headers = NULL;
- TnyHeaderFlags flags = 0;
TnyAccount *account;
- gint uncached_msgs = 0;
- GtkWidget *header_view;
- GtkTreeModel *model;
- GHashTable *refs_for_headers;
+ gboolean cached = FALSE;
+ gboolean found;
+ GtkWidget *header_view = NULL;
OpenMsgHelper *helper;
- GtkTreeSelection *sel;
- GList *sel_list = NULL, *sel_list_iter = NULL;
+ ModestWindow *window;
- g_return_if_fail (headers != NULL);
-
- /* Check that only one message is selected for opening */
- if (tny_list_get_length (headers) != 1) {
- modest_platform_information_banner ((win) ? GTK_WIDGET (win) : NULL,
- NULL, _("mcen_ib_select_one_message"));
- return;
- }
+ g_return_if_fail (header != NULL && rowref != NULL);
mgr = modest_runtime_get_window_mgr ();
- iter = tny_list_create_iterator (headers);
- /* Get the account */
- account = get_account_from_header_list (headers);
+ /* get model */
+ header_view = get_header_view_from_window (MODEST_WINDOW (win));
+ if (header_view == NULL)
+ return;
+ /* Get the account */
+ account = get_account_from_header (header);
if (!account)
return;
- /* Get the selections, we need to get the references to the
- rows here because the treeview/model could dissapear (the
- user might want to select another folder)*/
- header_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
- MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW);
- sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (header_view));
- model = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
- sel_list = gtk_tree_selection_get_selected_rows (sel, &model);
- refs_for_headers = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL,
- (GDestroyNotify) gtk_tree_row_reference_free);
-
- /* Look if we already have a message view for each header. If
- true, then remove the header from the list of headers to
- open */
- sel_list_iter = sel_list;
- not_opened_headers = tny_simple_list_new ();
- while (!tny_iterator_is_done (iter) && sel_list_iter) {
-
- ModestWindow *window = NULL;
- TnyHeader *header = NULL;
- gboolean found = FALSE;
-
- header = TNY_HEADER (tny_iterator_get_current (iter));
- if (header)
- flags = tny_header_get_flags (header);
-
- window = NULL;
- found = modest_window_mgr_find_registered_header (mgr, header, &window);
+ 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) {
- if (window) {
- gtk_window_present (GTK_WINDOW (window));
- } else {
- /* the header has been registered already, we don't do
- * anything but wait for the window to come up*/
- g_debug ("header %p already registered, waiting for window", header);
- }
+ /* Do not open again the message and present the
+ window to the user */
+ if (found) {
+ if (window) {
+#ifndef MODEST_TOOLKIT_HILDON2
+ gtk_window_present (GTK_WINDOW (window));
+#endif
} else {
- GtkTreeRowReference *row_reference;
-
- tny_list_append (not_opened_headers, G_OBJECT (header));
- /* Create a new row reference and add it to the hash table */
- row_reference = gtk_tree_row_reference_new (model, (GtkTreePath *) sel_list_iter->data);
- g_hash_table_insert (refs_for_headers, header, row_reference);
+ /* the header has been registered already, we don't do
+ * anything but wait for the window to come up*/
+ g_debug ("header %p already registered, waiting for window", header);
}
-
- if (header)
- g_object_unref (header);
-
- /* Go to next */
- tny_iterator_next (iter);
- sel_list_iter = g_list_next (sel_list_iter);
+ goto cleanup;
}
- g_object_unref (iter);
- iter = NULL;
- g_list_foreach (sel_list, (GFunc) gtk_tree_path_free, NULL);
- g_list_free (sel_list);
/* Open each message */
- if (tny_list_get_length (not_opened_headers) == 0) {
- g_hash_table_destroy (refs_for_headers);
- goto cleanup;
- }
-
- /* If some messages would have to be downloaded, ask the user to
- * make a connection. It's generally easier to do this here (in the mainloop)
- * than later in a thread:
- */
- if (tny_list_get_length (not_opened_headers) > 0) {
- uncached_msgs = header_list_count_uncached_msgs (not_opened_headers);
-
- if (uncached_msgs > 0) {
- /* Allways download if we are online. */
- if (!tny_device_is_online (modest_runtime_get_device ())) {
- gint response;
-
- /* If ask for user permission to download the messages */
- response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
- ngettext("mcen_nc_get_msg",
- "mcen_nc_get_msgs",
- uncached_msgs));
-
- /* End if the user does not want to continue */
- if (response == GTK_RESPONSE_CANCEL) {
- g_hash_table_destroy (refs_for_headers);
- goto cleanup;
- }
+ cached = tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED;
+ if (!cached) {
+ /* Allways download if we are online. */
+ if (!tny_device_is_online (modest_runtime_get_device ())) {
+ gint response;
+
+ /* If ask for user permission to download the messages */
+ response = modest_platform_run_confirmation_dialog (GTK_WINDOW (win),
+ _("mcen_nc_get_msg"));
+
+ /* End if the user does not want to continue */
+ if (response == GTK_RESPONSE_CANCEL) {
+ goto cleanup;
}
}
}
- /* Register the headers before actually creating the windows: */
- iter_not_opened = tny_list_create_iterator (not_opened_headers);
- while (!tny_iterator_is_done (iter_not_opened)) {
- TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter_not_opened));
- if (header) {
- modest_window_mgr_register_header (mgr, header, NULL);
- g_object_unref (header);
- }
- tny_iterator_next (iter_not_opened);
- }
- g_object_unref (iter_not_opened);
- iter_not_opened = NULL;
+ /* We register the window for opening */
+ modest_window_mgr_register_header (mgr, header, NULL);
/* Create the helper. We need to get a reference to the model
here because it could change while the message is readed
(the user could switch between folders) */
helper = g_slice_new (OpenMsgHelper);
- helper->model = g_object_ref (model);
- helper->headers = g_object_ref (not_opened_headers);
- helper->row_refs_per_header = refs_for_headers;
+ helper->model = g_object_ref (gtk_tree_view_get_model (GTK_TREE_VIEW (header_view)));
+ helper->header = g_object_ref (header);
+ helper->rowref = gtk_tree_row_reference_copy (rowref);
helper->banner_info = NULL;
/* Connect to the account and perform */
- if (uncached_msgs > 0) {
+ if (!cached) {
modest_platform_connect_and_perform ((GtkWindow *) win, TRUE, g_object_ref (account),
- open_msgs_performer, helper);
+ open_msg_performer, helper);
} else {
/* Call directly the performer, do not need to connect */
- open_msgs_performer (FALSE, NULL, (GtkWindow *) win,
- g_object_ref (account), helper);
+ open_msg_performer (FALSE, NULL, (GtkWindow *) win,
+ g_object_ref (account), helper);
}
cleanup:
/* Clean */
if (account)
g_object_unref (account);
- if (not_opened_headers)
- g_object_unref (not_opened_headers);
}
void
modest_ui_actions_on_open (GtkAction *action, ModestWindow *win)
{
TnyList *headers;
+ TnyHeader *header;
+ gint headers_count;
+ TnyIterator *iter;
/* we check for low-mem; in that case, show a warning, and don't allow
* opening
if (!headers)
return;
+ headers_count = tny_list_get_length (headers);
+ if (headers_count != 1) {
+ if (headers_count > 1) {
+ /* Don't allow activation if there are more than one message selected */
+ modest_platform_information_banner (NULL, NULL, _("mcen_ib_select_one_message"));
+ }
+
+ g_object_unref (headers);
+ return;
+ }
+
+ iter = tny_list_create_iterator (headers);
+ header = TNY_HEADER (tny_iterator_get_current (iter));
+ g_object_unref (iter);
+
/* Open them */
- open_msgs_from_headers (headers, win);
+ if (header) {
+ open_msg_from_header (header, NULL, win);
+ g_object_unref (header);
+ }
g_object_unref(headers);
}
edit_type = MODEST_EDIT_TYPE_FORWARD;
break;
default:
+ modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
+ header);
g_return_if_reached ();
return;
}
/* Create and register the windows */
msg_win = modest_msg_edit_window_new (new_msg, rf_helper->account_name, FALSE);
mgr = modest_runtime_get_window_mgr ();
- modest_window_mgr_register_window (mgr, msg_win);
+ modest_window_mgr_register_window (mgr, msg_win, (ModestWindow *) rf_helper->parent_window);
if (rf_helper->parent_window != NULL) {
gdouble parent_zoom;
gtk_widget_show_all (GTK_WIDGET (msg_win));
cleanup:
+ /* We always unregister the header because the message is
+ forwarded or replied so the original one is no longer
+ opened */
+ modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (),
+ header);
if (new_msg)
g_object_unref (G_OBJECT (new_msg));
if (account)
}
/* Retrieve the message */
+ modest_window_mgr_register_header (modest_runtime_get_window_mgr (), rf_helper->header, NULL);
mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT (parent_window),
modest_ui_actions_disk_operations_error_handler,
NULL, NULL);
void
modest_ui_actions_on_header_activated (ModestHeaderView *header_view,
TnyHeader *header,
- ModestMainWindow *main_window)
+ GtkTreePath *path,
+ ModestWindow *window)
{
- TnyList *headers;
GtkWidget *open_widget;
+ GtkTreeRowReference *rowref;
- g_return_if_fail (MODEST_IS_MAIN_WINDOW(main_window));
-
- if (!header)
- return;
+ g_return_if_fail (MODEST_IS_WINDOW(window));
+ g_return_if_fail (MODEST_IS_HEADER_VIEW (header_view));
+ g_return_if_fail (TNY_IS_HEADER (header));
if (modest_header_view_count_selected_headers (header_view) > 1) {
+ /* Don't allow activation if there are more than one message selected */
modest_platform_information_banner (NULL, NULL, _("mcen_ib_select_one_message"));
return;
}
/* we check for low-mem; in that case, show a warning, and don't allow
* activating headers
*/
- if (modest_platform_check_memory_low (MODEST_WINDOW(main_window), TRUE))
- return;
-
- modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (main_window));
- open_widget = modest_window_get_action_widget (MODEST_WINDOW (main_window), "/MenuBar/EmailMenu/EmailOpenMenu");
- if (!GTK_WIDGET_IS_SENSITIVE (open_widget))
+ if (modest_platform_check_memory_low (MODEST_WINDOW(window), TRUE))
return;
- headers = modest_header_view_get_selected_headers (header_view);
-
- open_msgs_from_headers (headers, MODEST_WINDOW (main_window));
+ if (MODEST_IS_MAIN_WINDOW (window)) {
+ modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (window));
+ open_widget = modest_window_get_action_widget (MODEST_WINDOW (window), "/MenuBar/EmailMenu/EmailOpenMenu");
+ if (!GTK_WIDGET_IS_SENSITIVE (open_widget))
+ return;
+ }
- g_object_unref (headers);
+ rowref = gtk_tree_row_reference_new (gtk_tree_view_get_model (GTK_TREE_VIEW (header_view)), path);
+ open_msg_from_header (header, rowref, MODEST_WINDOW (window));
+ gtk_tree_row_reference_free (rowref);
}
static void
already being done by the sort
dialog. Remove it when the GNOME version
has the same behaviour */
-#ifdef MODEST_PLATFORM_GNOME
+#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),
gchar *account_name, *from;
ModestAccountMgr *account_mgr;
gboolean had_error = FALSE;
- ModestMainWindow *win;
+ ModestMainWindow *win = NULL;
g_return_val_if_fail (MODEST_IS_MSG_EDIT_WINDOW(edit_window), FALSE);
on_save_to_drafts_cb,
g_object_ref(edit_window));
+#ifdef MODEST_TOOLKIT_HILDON2
+ /* In hildon2 we always show the information banner on saving to drafts.
+ * It will be a system information banner in this case.
+ */
+ gchar *text = g_strdup_printf (_("mail_va_saved_to_drafts"), _("mcen_me_folder_drafts"));
+ modest_platform_information_banner (NULL, NULL, text);
+ g_free (text);
+#else
/* Use the main window as the parent of the banner, if the
main window does not exist it won't be shown, if the parent
window exists then it's properly shown. We don't use the
modest_platform_information_banner (GTK_WIDGET (win), NULL, text);
g_free (text);
}
+#endif
modest_msg_edit_window_set_modified (edit_window, FALSE);
/* Frees */
}
-#ifdef MODEST_PLATFORM_MAEMO
+#ifndef MODEST_TOOLKIT_GTK
typedef struct {
guint handler;
gchar *name;
/* Try again. Do *NOT* show any error because the mail
operations system will do it for us because we
created the mail_op with new_with_error_handler */
-#ifdef MODEST_PLATFORM_MAEMO
+#ifndef MODEST_TOOLKIT_GTK
CreateFolderHelper *helper;
helper = g_slice_new0 (CreateFolderHelper);
helper->name = g_strdup (suggested_name);
return;
if (TNY_IS_FOLDER (folder)) {
- gchar *folder_name;
+ gchar *folder_name = NULL;
gint response;
const gchar *current_name;
TnyFolderStore *parent;
}
void
-modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
+modest_ui_actions_on_password_requested (TnyAccountStore *account_store,
const gchar* server_account_name,
gchar **username,
- gchar **password,
- gboolean *cancel,
+ gchar **password,
+ gboolean *cancel,
gboolean *remember,
ModestMainWindow *main_window)
{
g_return_if_fail(server_account_name);
gboolean completed = FALSE;
PasswordDialogFields *fields = NULL;
-
+
/* Initalize output parameters: */
if (cancel)
*cancel = FALSE;
-
+
if (remember)
*remember = TRUE;
-
-#ifdef MODEST_PLATFORM_MAEMO
+
+#ifndef MODEST_TOOLKIT_GTK
/* Maemo uses a different (awkward) button order,
* It should probably just use gtk_alternative_dialog_button_order ().
*/
- GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
- NULL,
- GTK_DIALOG_MODAL,
- _("mcen_bd_dialog_ok"),
- GTK_RESPONSE_ACCEPT,
- _("mcen_bd_dialog_cancel"),
- GTK_RESPONSE_REJECT,
- NULL);
+#ifdef MODEST_TOOLKIT_HILDON2
+ GtkWidget *dialog =
+ gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
+ NULL,
+ GTK_DIALOG_MODAL,
+ _HL("wdgt_bd_done"),
+ GTK_RESPONSE_ACCEPT,
+ NULL);
#else
- GtkWidget *dialog = gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
- NULL,
- GTK_DIALOG_MODAL,
- GTK_STOCK_CANCEL,
- GTK_RESPONSE_REJECT,
- GTK_STOCK_OK,
- GTK_RESPONSE_ACCEPT,
- NULL);
-#endif /* MODEST_PLATFORM_MAEMO */
+ GtkWidget *dialog =
+ gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
+ NULL,
+ GTK_DIALOG_MODAL,
+ _("mcen_bd_dialog_ok"),
+ GTK_RESPONSE_ACCEPT,
+ _("mcen_bd_dialog_cancel"),
+ GTK_RESPONSE_REJECT,
+ NULL);
+#endif /* MODEST_TOOLKIT_HILDON2 */
+#else
+ GtkWidget *dialog =
+ gtk_dialog_new_with_buttons (_("mail_ti_password_protected"),
+ NULL,
+ GTK_DIALOG_MODAL,
+ GTK_STOCK_CANCEL,
+ GTK_RESPONSE_REJECT,
+ GTK_STOCK_OK,
+ GTK_RESPONSE_ACCEPT,
+ NULL);
+#endif /* MODEST_TOOLKIT_GTK */
+
+ modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), GTK_WINDOW (dialog), NULL);
- modest_window_mgr_set_modal (modest_runtime_get_window_mgr(), GTK_WINDOW (dialog));
-
gchar *server_name = modest_account_mgr_get_server_account_hostname (
modest_runtime_get_account_mgr(), server_account_name);
if (!server_name) {/* This happened once, though I don't know why. murrayc. */
g_warning("%s: Could not get server name for server account '%s'", __FUNCTION__, server_account_name);
if (cancel)
*cancel = TRUE;
+ gtk_widget_destroy (dialog);
return;
}
-
- /* This causes a warning because the logical ID has no %s in it,
- * though the translation does, but there is not much we can do about that: */
+
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);
/* username: */
gchar *initial_username = modest_account_mgr_get_server_account_username (
modest_runtime_get_account_mgr(), server_account_name);
-
+
GtkWidget *entry_username = gtk_entry_new ();
if (initial_username)
gtk_entry_set_text (GTK_ENTRY (entry_username), initial_username);
*/
gtk_widget_set_sensitive (entry_username, FALSE);
-#ifdef MODEST_PLATFORM_MAEMO
+#ifndef MODEST_TOOLKIT_GTK
/* Auto-capitalization is the default, so let's turn it off: */
hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_username), HILDON_GTK_INPUT_MODE_FULL);
-
+
/* Create a size group to be used by all captions.
* Note that HildonCaption does not create a default size group if we do not specify one.
* 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,
_("mail_fi_username"), entry_username, NULL, HILDON_CAPTION_MANDATORY);
gtk_widget_show (entry_username);
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), caption,
FALSE, FALSE, MODEST_MARGIN_HALF);
gtk_widget_show (caption);
-#else
+#else
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_username,
TRUE, FALSE, 0);
-#endif /* MODEST_PLATFORM_MAEMO */
-
+#endif /* !MODEST_TOOLKIT_GTK */
+
/* password: */
GtkWidget *entry_password = gtk_entry_new ();
gtk_entry_set_visibility (GTK_ENTRY(entry_password), FALSE);
/* gtk_entry_set_invisible_char (GTK_ENTRY(entry_password), "*"); */
-
-#ifdef MODEST_PLATFORM_MAEMO
+
+#ifndef MODEST_TOOLKIT_GTK
/* Auto-capitalization is the default, so let's turn it off: */
- hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
+ hildon_gtk_entry_set_input_mode (GTK_ENTRY (entry_password),
HILDON_GTK_INPUT_MODE_FULL | HILDON_GTK_INPUT_MODE_INVISIBLE);
-
- caption = hildon_caption_new (sizegroup,
+
+ caption = hildon_caption_new (sizegroup,
_("mail_fi_password"), entry_password, NULL, HILDON_CAPTION_MANDATORY);
gtk_widget_show (entry_password);
- 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);
g_object_unref (sizegroup);
-#else
+#else
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), entry_password,
TRUE, FALSE, 0);
-#endif /* MODEST_PLATFORM_MAEMO */
+#endif /* !MODEST_TOOLKIT_GTK */
if (initial_username != NULL)
gtk_widget_grab_focus (GTK_WIDGET (entry_password));
-
+
/* This is not in the Maemo UI spec:
remember_pass_check = gtk_check_button_new_with_label (_("Remember password"));
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), remember_pass_check,
gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
while (!completed) {
-
+
if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
if (username) {
*username = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_username)));
-
+
/* 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,
*username);
completed = TRUE;
-
+
const gboolean username_was_changed =
(strcmp (*username, initial_username) != 0);
if (username_was_changed) {
"username in the get_password() callback.\n", __FUNCTION__);
}
} else {
+ g_free (*username);
+ *username = NULL;
/* Show error */
modest_platform_information_banner (GTK_WIDGET (dialog), NULL,
_("mcen_ib_username_pw_incorrect"));
completed = FALSE;
}
}
-
+
if (password) {
*password = g_strdup (gtk_entry_get_text (GTK_ENTRY(entry_password)));
-
+
/* We do not save the password in the configuration,
* because this function is only called for passwords that should
* not be remembered:
modest_runtime_get_account_mgr(), server_account_name,
*password);
*/
- }
+ }
if (cancel)
- *cancel = FALSE;
+ *cancel = FALSE;
} else {
+#ifndef MODEST_TOOLKIT_HILDON2
/* Set parent to NULL or the banner will disappear with its parent dialog */
modest_platform_information_banner(NULL, NULL, _("mail_ib_login_cancelled"));
+#endif
completed = TRUE;
if (username)
- *username = NULL;
+ *username = NULL;
if (password)
- *password = NULL;
+ *password = NULL;
if (cancel)
*cancel = TRUE;
}
*remember = FALSE;
*/
+ g_free (initial_username);
gtk_widget_destroy (dialog);
g_slice_free (PasswordDialogFields, fields);
gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
} else if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
ModestMailOperation *mail_op;
- TnyFolder *src_folder;
- TnyList *data;
+ TnyFolder *src_folder = NULL;
+ TnyList *data = NULL;
gboolean delete;
PasteAsAttachmentHelper *helper = g_new0 (PasteAsAttachmentHelper, 1);
helper->window = MODEST_MSG_EDIT_WINDOW (window);
helper,
paste_as_attachment_free);
}
+ /* Free */
+ if (data)
+ g_object_unref (data);
+ if (src_folder)
+ g_object_unref (src_folder);
+
}
} else if (MODEST_IS_FOLDER_VIEW (focused_widget)) {
ModestEmailClipboard *clipboard = NULL;
if (active != fullscreen) {
modest_window_mgr_set_fullscreen_mode (mgr, active);
+#ifndef MODEST_TOOLKIT_HILDON2
gtk_window_present (GTK_WINDOW (window));
+#endif
}
}
fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
modest_window_mgr_set_fullscreen_mode (mgr, !fullscreen);
+#ifndef MODEST_TOOLKIT_HILDON2
gtk_window_present (GTK_WINDOW (window));
+#endif
}
/*
gpointer user_data)
{
- GtkWidget *dialog;
-
- /* Create dialog */
- dialog = modest_details_dialog_new_with_header (GTK_WINDOW (window), header);
-
- /* Run dialog */
- modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (dialog));
- gtk_widget_show_all (dialog);
-
- g_signal_connect_swapped (dialog, "response",
- G_CALLBACK (gtk_widget_destroy),
- dialog);
-}
-
-/*
- * Show the folder details in a ModestDetailsDialog widget
- */
-static void
-show_folder_details (TnyFolder *folder,
- GtkWindow *window)
-{
- GtkWidget *dialog;
-
- /* Create dialog */
- dialog = modest_details_dialog_new_with_folder (window, folder);
-
- /* Run dialog */
- gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
- gtk_widget_show_all (dialog);
- gtk_dialog_run (GTK_DIALOG (dialog));
-
- gtk_widget_destroy (dialog);
+ modest_platform_run_header_details_dialog (GTK_WINDOW (window), header);
}
/*
/* This function should not be called for account items,
* because we dim the menu item for them. */
if (TNY_IS_FOLDER (folder_store)) {
- show_folder_details (TNY_FOLDER (folder_store), GTK_WINDOW (win));
+ modest_platform_run_folder_details_dialog (GTK_WINDOW (win),
+ TNY_FOLDER (folder_store));
}
g_object_unref (folder_store);
/* Show details of each header */
do_headers_action (win, headers_action_show_details, header_view);
}
+#ifdef MODEST_TOOLKIT_HILDON2
+ } else if (MODEST_IS_HEADER_WINDOW (win)) {
+ TnyFolder *folder;
+ GtkWidget *header_view;
+
+ 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),
+ folder);
+ g_object_unref (folder);
+ }
+#endif
}
}
active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (toggle));
- /* Check if we want to toggle the toolbar vuew in fullscreen
+ /* Check if we want to toggle the toolbar view in fullscreen
or normal mode */
if (!strcmp (gtk_action_get_name (GTK_ACTION (toggle)),
"ViewShowToolbarFullScreen")) {
{
GtkWidget *dialog = NULL;
GtkWidget *ok_button = NULL, *new_button = NULL;
- GList *children = NULL;
gboolean ok_sensitive = TRUE, new_sensitive = TRUE;
gboolean moving_folder = FALSE;
gboolean is_local_account = TRUE;
if (!dialog)
return;
- children = gtk_container_get_children (GTK_CONTAINER (GTK_DIALOG (dialog)->action_area));
-#ifdef MODEST_PLATFORM_MAEMO
- ok_button = GTK_WIDGET (children->next->next->data);
- new_button = GTK_WIDGET (children->next->data);
-#else
- ok_button = GTK_WIDGET (children->data);
- new_button = GTK_WIDGET (children->next->next->data);
-#endif
- g_list_free (children);
+ ok_button = g_object_get_data (G_OBJECT (dialog), MOVE_FOLDER_OK_BUTTON);
+ new_button = g_object_get_data (G_OBJECT (dialog), MOVE_FOLDER_NEW_BUTTON);
/* check if folder_store is an remote account */
if (TNY_IS_ACCOUNT (folder_store)) {
if ((gpointer) local_account != (gpointer) folder_store &&
(gpointer) mmc_account != (gpointer) folder_store) {
- const char *proto_name = tny_account_get_proto (TNY_ACCOUNT (folder_store));
- ModestTransportStoreProtocol proto = MODEST_PROTOCOL_STORE_MAILDIR;
- if (proto_name != NULL) {
- proto = modest_protocol_info_get_transport_store_protocol (proto_name);
+ ModestProtocolType proto;
+ proto = modest_tny_account_get_protocol_type (TNY_ACCOUNT (folder_store));
+ if (proto == MODEST_PROTOCOL_REGISTRY_TYPE_INVALID) {
+ proto = MODEST_PROTOCOLS_STORE_MAILDIR;
}
is_local_account = FALSE;
/* New button should be dimmed on remote
POP account root */
- new_sensitive = (proto != MODEST_PROTOCOL_STORE_POP);
+ new_sensitive = (modest_protocol_registry_protocol_type_has_tag (modest_runtime_get_protocol_registry (),
+ proto,
+ MODEST_PROTOCOL_REGISTRY_STORE_HAS_FOLDERS));
}
g_object_unref (local_account);
- g_object_unref (mmc_account);
+
+ /* It could not exist */
+ if (mmc_account)
+ g_object_unref (mmc_account);
}
/* Check the target folder rules */
GtkWidget *folder_view,
GtkWidget **tree_view)
{
- GtkWidget *dialog, *scroll;
- GtkWidget *new_button;
+ GtkWidget *dialog;
+#ifdef MODEST_TOOLKIT_HILDON2
+ GtkWidget *pannable;
+#else
+ GtkWidget *scroll;
+#endif
+ GtkWidget *new_button, *ok_button;
dialog = gtk_dialog_new_with_buttons (_("mcen_ti_moveto_folders_title"),
GTK_WINDOW (win),
GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
NULL);
-#ifdef MODEST_PLATFORM_MAEMO
- gtk_dialog_add_button (GTK_DIALOG (dialog), _("mcen_bd_dialog_ok"), GTK_RESPONSE_ACCEPT);
+#ifndef MODEST_TOOLKIT_GTK
+ ok_button = gtk_dialog_add_button (GTK_DIALOG (dialog), _("mcen_bd_dialog_ok"), GTK_RESPONSE_ACCEPT);
/* We do this manually so GTK+ does not associate a response ID for
* the button. */
new_button = gtk_button_new_from_stock (_("mcen_bd_new"));
gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog)->action_area), new_button, FALSE, FALSE, 0);
+ gtk_widget_show (new_button);
+#ifndef MODEST_TOOLKIT_HILDON2
gtk_dialog_add_button (GTK_DIALOG (dialog), _("mcen_bd_dialog_cancel"), GTK_RESPONSE_REJECT);
+#endif
#else
/* We do this manually so GTK+ does not associate a response ID for
* the button. */
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), new_button, FALSE, FALSE, 0);
gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (GTK_DIALOG (dialog)->action_area), new_button, TRUE);
gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT);
- gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT);
+ ok_button = gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 12);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 24);
#endif
+ g_object_set_data (G_OBJECT (dialog), MOVE_FOLDER_OK_BUTTON, ok_button);
+ g_object_set_data (G_OBJECT (dialog), MOVE_FOLDER_NEW_BUTTON, new_button);
/* Create scrolled window */
+#ifdef MODEST_TOOLKIT_HILDON2
+ pannable = hildon_pannable_area_new ();
+#else
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
+#endif
-#ifndef MODEST_PLATFORM_MAEMO
+#ifdef MODEST_TOOLKIT_GTK
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN);
#endif
/* Hide special folders */
modest_folder_view_show_non_move_folders (MODEST_FOLDER_VIEW (*tree_view), FALSE);
+#ifdef MODEST_TOOLKIT_HILDON2
+ gtk_container_add (GTK_CONTAINER (pannable), *tree_view);
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
+ pannable, TRUE, TRUE, 0);
+#else
gtk_container_add (GTK_CONTAINER (scroll), *tree_view);
-
/* Add scroll to dialog */
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
scroll, TRUE, TRUE, 0);
+#endif
+
gtk_widget_show_all (GTK_WIDGET(GTK_DIALOG(dialog)->vbox));
-#ifdef MODEST_PLATFORM_MAEMO
+#ifndef MODEST_TOOLKIT_GTK
gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 300);
#else
gtk_window_set_default_size (GTK_WINDOW (dialog), 600, 400);
gtk_widget_destroy (GTK_WIDGET (helper->banner));
g_object_unref (helper->banner);
}
- if (helper->reference != NULL)
+ if (gtk_tree_row_reference_valid (helper->reference)) {
gtk_tree_row_reference_free (helper->reference);
+ helper->reference = NULL;
+ }
g_free (helper);
}
/* 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) && helper->reference != NULL) {
+ } else if (MODEST_IS_MAIN_WINDOW (object) &&
+ gtk_tree_row_reference_valid (helper->reference)) {
GtkWidget *header_view;
GtkTreePath *path;
GtkTreeSelection *sel;
if (response == GTK_RESPONSE_OK) {
GtkWidget *info;
info =
- modest_platform_animation_banner (GTK_WIDGET (win), NULL, _("mcen_ib_removing_attachment"));
+ modest_platform_animation_banner (GTK_WIDGET (win), NULL, _("mcen_me_inbox_remove_attachments"));
iter = tny_list_create_iterator (parts);
while (!tny_iterator_is_done (iter)) {
TnyMimePart *part;
/* The transfer is possible and the user wants to */
*do_xfer = TRUE;
- if (remote_folder_is_pop (src_folder) && delete_originals) {
+ if (remote_folder_has_leave_on_server (src_folder) && delete_originals) {
const gchar *account_name;
gboolean leave_on_server;
{
ModestWindow *win = MODEST_WINDOW (parent_window);
TnyAccount *dst_account = NULL;
- const gchar *proto_str = NULL;
- gboolean dst_is_pop = FALSE;
+ gboolean dst_forbids_message_add = FALSE;
XferMsgsHelper *helper;
MoveToHelper *movehelper;
ModestMailOperation *mail_op;
}
dst_account = tny_folder_get_account (TNY_FOLDER (helper->dst_folder));
- proto_str = tny_account_get_proto (dst_account);
/* tinymail will return NULL for local folders it seems */
- dst_is_pop = proto_str &&
- (modest_protocol_info_get_transport_store_protocol (proto_str) ==
- MODEST_PROTOCOL_STORE_POP);
-
+ dst_forbids_message_add = modest_protocol_registry_protocol_type_has_tag (modest_runtime_get_protocol_registry (),
+ modest_tny_account_get_protocol_type (dst_account),
+ MODEST_PROTOCOL_REGISTRY_STORE_FORBID_MESSAGE_ADD);
g_object_unref (dst_account);
- if (dst_is_pop) {
+ if (dst_forbids_message_add) {
modest_platform_information_banner (GTK_WIDGET (win),
NULL,
ngettext("mail_in_ui_folder_move_target_error",
/* Create and run the dialog */
dialog = create_move_to_dialog (GTK_WINDOW (win), folder_view, &tree_view);
modest_folder_view_select_first_inbox_or_local (MODEST_FOLDER_VIEW (tree_view));
- modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (dialog));
+ modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (dialog), (GtkWindow *) win);
result = gtk_dialog_run (GTK_DIALOG(dialog));
g_object_ref (tree_view);
gtk_widget_destroy (dialog);
modest_ui_actions_on_help (GtkAction *action,
GtkWindow *win)
{
+ /* Help app is not available at all in fremantle */
+#ifndef MODEST_TOOLKIT_HILDON2
const gchar *help_id;
g_return_if_fail (win && GTK_IS_WINDOW(win));
if (help_id)
modest_platform_show_help (GTK_WINDOW (win), help_id);
+#endif
}
void
modest_ui_actions_on_csm_help (GtkAction *action,
GtkWindow *win)
{
+ /* Help app is not available at all in fremantle */
+#ifndef MODEST_TOOLKIT_HILDON2
+
const gchar* help_id = NULL;
GtkWidget *folder_view;
TnyFolderStore *folder_store;
modest_platform_show_help (GTK_WINDOW (win), help_id);
else
modest_ui_actions_on_help (action, win);
+#endif
}
static void
tree_column = gtk_tree_view_get_column (GTK_TREE_VIEW (header_view),
TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN);
- gtk_tree_view_column_queue_resize (tree_column);
+ if (tree_column)
+ gtk_tree_view_column_queue_resize (tree_column);
}
#else
gtk_widget_queue_draw (header_view);
modest_ui_actions_on_account_connection_error (GtkWindow *parent_window,
TnyAccount *account)
{
- ModestTransportStoreProtocol proto;
- const gchar *proto_name;
+ ModestProtocolType protocol_type;
+ ModestProtocol *protocol;
gchar *error_note = NULL;
- proto_name = tny_account_get_proto (account);
- proto = modest_protocol_info_get_transport_store_protocol (proto_name);
-
- switch (proto) {
- case MODEST_PROTOCOL_STORE_POP:
- error_note = g_strdup_printf (_("emev_ni_ui_pop3_msg_connect_error"),
- tny_account_get_hostname (account));
- break;
- case MODEST_PROTOCOL_STORE_IMAP:
- error_note = g_strdup_printf (_("emev_ni_ui_imap_connect_server_error"),
- tny_account_get_hostname (account));
- break;
- case MODEST_PROTOCOL_STORE_MAILDIR:
- case MODEST_PROTOCOL_STORE_MBOX:
- error_note = g_strdup (_("emev_nc_mailbox_notavailable"));
- break;
- default:
- g_warning ("%s: This should not be reached", __FUNCTION__);
- }
+ protocol_type = modest_tny_account_get_protocol_type (account);
+ protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
+ protocol_type);
- if (error_note) {
+ error_note = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_ACCOUNT_CONNECTION_ERROR, tny_account_get_hostname (account));
+ if (error_note == NULL) {
+ g_warning ("%s: This should not be reached", __FUNCTION__);
+ } else {
modest_platform_run_information_dialog (parent_window, error_note, FALSE);
g_free (error_note);
}
modest_ui_actions_get_msg_already_deleted_error_msg (ModestWindow *win)
{
gchar *msg = NULL;
+ gchar *subject;
TnyFolderStore *folder = NULL;
TnyAccount *account = NULL;
- ModestTransportStoreProtocol proto;
+ ModestProtocolType proto;
+ ModestProtocol *protocol;
TnyHeader *header = NULL;
if (MODEST_IS_MAIN_WINDOW (win)) {
/* Get the account type */
account = tny_folder_get_account (TNY_FOLDER (folder));
- proto = modest_protocol_info_get_transport_store_protocol (tny_account_get_proto (account));
- if (proto == MODEST_PROTOCOL_STORE_POP) {
- msg = g_strdup (_("emev_ni_ui_pop3_msg_recv_error"));
- } else if (proto == MODEST_PROTOCOL_STORE_IMAP) {
- gchar *subject;
- subject = tny_header_dup_subject (header);
- msg = g_strdup_printf (_("emev_ni_ui_imap_message_not_available_in_server"),
- subject);
+ proto = modest_tny_account_get_protocol_type (account);
+ protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
+ proto);
+
+ subject = tny_header_dup_subject (header);
+ msg = modest_protocol_get_translation (protocol, MODEST_PROTOCOL_TRANSLATION_MSG_NOT_AVAILABLE, subject);
+ if (subject)
g_free (subject);
- } else {
+ if (msg == NULL) {
msg = g_strdup_printf (_("mail_ni_ui_folder_get_msg_folder_error"));
}
return msg;
}
+
+gboolean
+modest_ui_actions_on_delete_account (GtkWindow *parent_window,
+ const gchar *account_name,
+ const gchar *account_title)
+{
+ ModestAccountMgr *account_mgr;
+ gchar *txt = NULL;
+ gint response;
+ ModestProtocol *protocol;
+ gboolean removed = FALSE;
+
+ g_return_val_if_fail (account_name, FALSE);
+ g_return_val_if_fail (account_title, FALSE);
+
+ account_mgr = modest_runtime_get_account_mgr();
+
+ /* The warning text depends on the account type: */
+ protocol = modest_protocol_registry_get_protocol_by_type (modest_runtime_get_protocol_registry (),
+ modest_account_mgr_get_store_protocol (account_mgr,
+ account_name));
+ txt = modest_protocol_get_translation (protocol,
+ MODEST_PROTOCOL_TRANSLATION_DELETE_MAILBOX,
+ account_title);
+ if (txt == NULL)
+ txt = g_strdup_printf (_("emev_nc_delete_mailbox"), account_title);
+
+ response = modest_platform_run_confirmation_dialog (parent_window, txt);
+ g_free (txt);
+ txt = NULL;
+
+ if (response == GTK_RESPONSE_OK) {
+ /* Remove account. If it succeeds then it also removes
+ the account from the ModestAccountView: */
+ gboolean is_default = FALSE;
+ gchar *default_account_name = modest_account_mgr_get_default_account (account_mgr);
+ if (default_account_name && (strcmp (default_account_name, account_name) == 0))
+ is_default = TRUE;
+ g_free (default_account_name);
+
+ removed = modest_account_mgr_remove_account (account_mgr, account_name);
+ if (!removed)
+ g_warning ("%s: modest_account_mgr_remove_account() failed.\n", __FUNCTION__);
+ }
+ return removed;
+}
projects / modest / blobdiff