X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fmaemo%2Fmodest-msg-view-window.c;h=21143341ee205d5795a6a1357aeb24fca8bf76a5;hp=893f2c1ee621448e3a5f9943deda5f10e58531fb;hb=8f4797391e5962158a0a085646f1d24da887ee3d;hpb=90bdb8d47077f8b4a286e6061dd30bcf872ec501 diff --git a/src/maemo/modest-msg-view-window.c b/src/maemo/modest-msg-view-window.c index 893f2c1..2114334 100644 --- a/src/maemo/modest-msg-view-window.c +++ b/src/maemo/modest-msg-view-window.c @@ -39,7 +39,6 @@ #include #include #include -#include #include #include "modest-msg-view-window-ui-dimming.h" #include @@ -48,7 +47,7 @@ #include #include #include -#include "modest-progress-bar-widget.h" +#include "modest-progress-bar.h" #include "modest-defs.h" #include "modest-hildon-includes.h" #include "modest-ui-dimming-manager.h" @@ -56,9 +55,11 @@ #include #include #include +#include #include #include #include +#include #define DEFAULT_FOLDER "MyDocs/.documents" @@ -94,34 +95,30 @@ static void modest_msg_view_window_show_toolbar (ModestWindow *window, static void modest_msg_view_window_clipboard_owner_change (GtkClipboard *clipboard, GdkEvent *event, ModestMsgViewWindow *window); -void modest_msg_view_window_on_row_changed( - GtkTreeModel *header_model, - GtkTreePath *arg1, - GtkTreeIter *arg2, - ModestMsgViewWindow *window); - -void modest_msg_view_window_on_row_deleted( - GtkTreeModel *header_model, - GtkTreePath *arg1, - ModestMsgViewWindow *window); - -void modest_msg_view_window_on_row_inserted( - GtkTreeModel *header_model, - GtkTreePath *tree_path, - GtkTreeIter *tree_iter, - ModestMsgViewWindow *window); - -void modest_msg_view_window_on_row_reordered( - GtkTreeModel *header_model, - GtkTreePath *arg1, - GtkTreeIter *arg2, - gpointer arg3, - ModestMsgViewWindow *window); - -void modest_msg_view_window_update_model_replaced( - ModestHeaderViewObserver *window, - GtkTreeModel *model, - const gchar *tny_folder_id); + +static void modest_msg_view_window_on_row_changed (GtkTreeModel *header_model, + GtkTreePath *arg1, + GtkTreeIter *arg2, + ModestMsgViewWindow *window); + +static void modest_msg_view_window_on_row_deleted (GtkTreeModel *header_model, + GtkTreePath *arg1, + ModestMsgViewWindow *window); + +static void modest_msg_view_window_on_row_inserted (GtkTreeModel *header_model, + GtkTreePath *tree_path, + GtkTreeIter *tree_iter, + ModestMsgViewWindow *window); + +static void modest_msg_view_window_on_row_reordered (GtkTreeModel *header_model, + GtkTreePath *arg1, + GtkTreeIter *arg2, + gpointer arg3, + ModestMsgViewWindow *window); + +static void modest_msg_view_window_update_model_replaced (ModestHeaderViewObserver *window, + GtkTreeModel *model, + const gchar *tny_folder_id); static void cancel_progressbar (GtkToolButton *toolbutton, ModestMsgViewWindow *self); @@ -156,10 +153,22 @@ static void init_window (ModestMsgViewWindow *obj); static gboolean msg_is_visible (TnyHeader *header, gboolean check_outbox); +static void check_dimming_rules_after_change (ModestMsgViewWindow *window); + +static gboolean on_fetch_image (ModestMsgView *msgview, + const gchar *uri, + TnyStream *stream, + ModestMsgViewWindow *window); + +static gboolean modest_msg_view_window_scroll_child (ModestMsgViewWindow *self, + GtkScrollType scroll_type, + gboolean horizontal, + gpointer userdata); /* list my signals */ enum { MSG_CHANGED_SIGNAL, + SCROLL_CHILD_SIGNAL, LAST_SIGNAL }; @@ -228,6 +237,7 @@ struct _ModestMsgViewWindowPrivate { guint progress_bar_timeout; gchar *msg_uid; + TnyMimePart *other_body; GSList *sighandlers; }; @@ -306,11 +316,43 @@ restore_settings (ModestMsgViewWindow *self) MODEST_CONF_MSG_VIEW_WINDOW_KEY); } +static gboolean modest_msg_view_window_scroll_child (ModestMsgViewWindow *self, + GtkScrollType scroll_type, + gboolean horizontal, + gpointer userdata) +{ + ModestMsgViewWindowPrivate *priv; + gboolean return_value; + + priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self); + g_signal_emit_by_name (priv->main_scroll, "scroll-child", scroll_type, horizontal, &return_value); + return return_value; +} + +static void +add_scroll_binding (GtkBindingSet *binding_set, + guint keyval, + GtkScrollType scroll) +{ + guint keypad_keyval = keyval - GDK_Left + GDK_KP_Left; + + gtk_binding_entry_add_signal (binding_set, keyval, 0, + "scroll_child", 2, + GTK_TYPE_SCROLL_TYPE, scroll, + G_TYPE_BOOLEAN, FALSE); + gtk_binding_entry_add_signal (binding_set, keypad_keyval, 0, + "scroll_child", 2, + GTK_TYPE_SCROLL_TYPE, scroll, + G_TYPE_BOOLEAN, FALSE); +} + static void modest_msg_view_window_class_init (ModestMsgViewWindowClass *klass) { GObjectClass *gobject_class; ModestWindowClass *modest_window_class; + GtkBindingSet *binding_set; + gobject_class = (GObjectClass*) klass; modest_window_class = (ModestWindowClass *) klass; @@ -324,10 +366,10 @@ modest_msg_view_window_class_init (ModestMsgViewWindowClass *klass) modest_window_class->show_toolbar_func = modest_msg_view_window_show_toolbar; modest_window_class->disconnect_signals_func = modest_msg_view_window_disconnect_signals; - g_type_class_add_private (gobject_class, sizeof(ModestMsgViewWindowPrivate)); - modest_window_class->save_state_func = save_state; + klass->scroll_child = modest_msg_view_window_scroll_child; + signals[MSG_CHANGED_SIGNAL] = g_signal_new ("msg-changed", G_TYPE_FROM_CLASS (gobject_class), @@ -336,6 +378,26 @@ modest_msg_view_window_class_init (ModestMsgViewWindowClass *klass) NULL, NULL, modest_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_POINTER); + + signals[SCROLL_CHILD_SIGNAL] = + g_signal_new ("scroll-child", + G_TYPE_FROM_CLASS (gobject_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (ModestMsgViewWindowClass, scroll_child), + NULL, NULL, + modest_marshal_BOOLEAN__ENUM_BOOLEAN, + G_TYPE_BOOLEAN, 2, GTK_TYPE_SCROLL_TYPE, G_TYPE_BOOLEAN); + + binding_set = gtk_binding_set_by_class (klass); + add_scroll_binding (binding_set, GDK_Up, GTK_SCROLL_STEP_UP); + add_scroll_binding (binding_set, GDK_Down, GTK_SCROLL_STEP_DOWN); + add_scroll_binding (binding_set, GDK_Page_Up, GTK_SCROLL_PAGE_UP); + add_scroll_binding (binding_set, GDK_Page_Down, GTK_SCROLL_PAGE_DOWN); + add_scroll_binding (binding_set, GDK_Home, GTK_SCROLL_START); + add_scroll_binding (binding_set, GDK_End, GTK_SCROLL_END); + + g_type_class_add_private (gobject_class, sizeof(ModestMsgViewWindowPrivate)); + } static void modest_header_view_observer_init( @@ -417,6 +479,7 @@ modest_msg_view_window_init (ModestMsgViewWindow *obj) priv->purge_timeout = 0; priv->remove_attachment_banner = NULL; priv->msg_uid = NULL; + priv->other_body = NULL; priv->sighandlers = NULL; @@ -534,26 +597,13 @@ set_toolbar_mode (ModestMsgViewWindow *self, } -static GtkWidget * -menubar_to_menu (GtkUIManager *ui_manager) -{ - GtkWidget *main_menu; - - /* Get the menubar from the UI manager */ - main_menu = gtk_ui_manager_get_widget (ui_manager, "/MenuBar"); - - return main_menu; -} - static void init_window (ModestMsgViewWindow *obj) { GtkWidget *main_vbox; ModestMsgViewWindowPrivate *priv; - ModestWindowPrivate *parent_priv; priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(obj); - parent_priv = MODEST_WINDOW_GET_PRIVATE(obj); priv->msg_view = GTK_WIDGET (tny_platform_factory_new_msg_view (modest_tny_platform_factory_get_instance ())); modest_msg_view_set_shadow_type (MODEST_MSG_VIEW (priv->msg_view), GTK_SHADOW_NONE); @@ -657,6 +707,11 @@ modest_msg_view_window_finalize (GObject *obj) call this function before */ modest_msg_view_window_disconnect_signals (MODEST_WINDOW (obj)); + if (priv->other_body != NULL) { + g_object_unref (priv->other_body); + priv->other_body = NULL; + } + if (priv->header_model != NULL) { g_object_unref (priv->header_model); priv->header_model = NULL; @@ -699,11 +754,13 @@ modest_msg_view_window_finalize (GObject *obj) static gboolean select_next_valid_row (GtkTreeModel *model, GtkTreeRowReference **row_reference, - gboolean cycle) + gboolean cycle, + gboolean is_outbox) { GtkTreeIter tmp_iter; - GtkTreePath *path, *next; - gboolean retval = FALSE; + GtkTreePath *path; + GtkTreePath *next = NULL; + gboolean retval = FALSE, finished; g_return_val_if_fail (gtk_tree_row_reference_valid (*row_reference), FALSE); @@ -712,19 +769,57 @@ select_next_valid_row (GtkTreeModel *model, gtk_tree_row_reference_free (*row_reference); *row_reference = NULL; - if (gtk_tree_model_iter_next (model, &tmp_iter)) { - next = gtk_tree_model_get_path (model, &tmp_iter); - *row_reference = gtk_tree_row_reference_new (model, next); - retval = TRUE; - } else if (cycle && gtk_tree_model_get_iter_first (model, &tmp_iter)) { - next = gtk_tree_model_get_path (model, &tmp_iter); - - /* Ensure that we are not selecting the same */ - if (gtk_tree_path_compare (path, next) != 0) { - *row_reference = gtk_tree_row_reference_new (model, next); - retval = TRUE; + finished = FALSE; + do { + TnyHeader *header = NULL; + + if (gtk_tree_model_iter_next (model, &tmp_iter)) { + gtk_tree_model_get (model, &tmp_iter, + TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, + &header, -1); + + if (header) { + if (msg_is_visible (header, is_outbox)) { + next = gtk_tree_model_get_path (model, &tmp_iter); + *row_reference = gtk_tree_row_reference_new (model, next); + gtk_tree_path_free (next); + retval = TRUE; + finished = TRUE; + } + g_object_unref (header); + header = NULL; + } + } else if (cycle && gtk_tree_model_get_iter_first (model, &tmp_iter)) { + next = gtk_tree_model_get_path (model, &tmp_iter); + + /* Ensure that we are not selecting the same */ + if (gtk_tree_path_compare (path, next) != 0) { + gtk_tree_model_get (model, &tmp_iter, + TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, + &header, -1); + if (header) { + if (msg_is_visible (header, is_outbox)) { + *row_reference = gtk_tree_row_reference_new (model, next); + retval = TRUE; + finished = TRUE; + } + g_object_unref (header); + header = NULL; + } + } else { + /* If we ended up in the same message + then there is no valid next + message */ + finished = TRUE; + } + gtk_tree_path_free (next); + } else { + /* If there are no more messages and we don't + want to start again in the first one then + there is no valid next message */ + finished = TRUE; } - } + } while (!finished); /* Free */ gtk_tree_path_free (path); @@ -735,8 +830,8 @@ select_next_valid_row (GtkTreeModel *model, /* TODO: This should be in _init(), with the parameters as properties. */ static void modest_msg_view_window_construct (ModestMsgViewWindow *self, - const gchar *modest_account_name, - const gchar *msg_uid) + const gchar *modest_account_name, + const gchar *msg_uid) { GObject *obj = NULL; ModestMsgViewWindowPrivate *priv = NULL; @@ -752,14 +847,14 @@ modest_msg_view_window_construct (ModestMsgViewWindow *self, priv->msg_uid = g_strdup (msg_uid); /* Menubar */ - parent_priv->menubar = menubar_to_menu (parent_priv->ui_manager); + parent_priv->menubar = modest_maemo_utils_get_manager_menubar_as_menu (parent_priv->ui_manager, "/MenuBar"); hildon_window_set_menu (HILDON_WINDOW(obj), GTK_MENU(parent_priv->menubar)); gtk_widget_show (parent_priv->menubar); parent_priv->ui_dimming_manager = modest_ui_dimming_manager_new(); - menu_rules_group = modest_dimming_rules_group_new ("ModestMenuDimmingRules", FALSE); - toolbar_rules_group = modest_dimming_rules_group_new ("ModestToolbarDimmingRules", TRUE); - clipboard_rules_group = modest_dimming_rules_group_new ("ModestClipboardDimmingRules", FALSE); + menu_rules_group = modest_dimming_rules_group_new (MODEST_DIMMING_RULES_MENU, FALSE); + toolbar_rules_group = modest_dimming_rules_group_new (MODEST_DIMMING_RULES_TOOLBAR, TRUE); + clipboard_rules_group = modest_dimming_rules_group_new (MODEST_DIMMING_RULES_CLIPBOARD, FALSE); /* Add common dimming rules */ modest_dimming_rules_group_add_rules (menu_rules_group, @@ -798,6 +893,8 @@ modest_msg_view_window_construct (ModestMsgViewWindow *self, G_CALLBACK (modest_ui_actions_on_msg_recpt_activated), obj); g_signal_connect (G_OBJECT(priv->msg_view), "link_contextual", G_CALLBACK (modest_ui_actions_on_msg_link_contextual), obj); + g_signal_connect (G_OBJECT (priv->msg_view), "fetch_image", + G_CALLBACK (on_fetch_image), obj); g_signal_connect (G_OBJECT (obj), "key-release-event", G_CALLBACK (modest_msg_view_window_key_event), @@ -837,16 +934,94 @@ modest_msg_view_window_construct (ModestMsgViewWindow *self, update_window_title (MODEST_MSG_VIEW_WINDOW (obj)); - /* Check toolbar dimming rules */ - modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (obj)); - modest_window_check_dimming_rules_group (MODEST_WINDOW (obj), "ModestClipboardDimmingRules"); } +ModestWindow * +modest_msg_view_window_new_from_uid (const gchar *modest_account_name, + const gchar *mailbox, + const gchar *msg_uid) +{ + ModestMsgViewWindow *window = NULL; + ModestMsgViewWindowPrivate *priv = NULL; + TnyFolder *folder = NULL; + ModestWindowMgr *mgr = NULL; + gboolean is_merge; + TnyAccount *account = NULL; + + mgr = modest_runtime_get_window_mgr (); + window = MODEST_MSG_VIEW_WINDOW (modest_window_mgr_get_msg_view_window (mgr)); + g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), NULL); + + modest_msg_view_window_construct (window, modest_account_name, mailbox, msg_uid); + + priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); + + + + is_merge = g_str_has_prefix (msg_uid, "merge:"); + + /* Get the account */ + if (!is_merge) + account = tny_account_store_find_account (TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()), + msg_uid); + + + if (is_merge || account) { + OpenMsgPerformerInfo *info; + TnyFolder *folder = NULL; + + /* Try to get the message, if it's already downloaded + we don't need to connect */ + if (account) { + folder = tny_store_account_find_folder (TNY_STORE_ACCOUNT (account), msg_uid, NULL); + } else { + ModestTnyAccountStore *account_store; + ModestTnyLocalFoldersAccount *local_folders_account; + + account_store = modest_runtime_get_account_store (); + local_folders_account = MODEST_TNY_LOCAL_FOLDERS_ACCOUNT ( + modest_tny_account_store_get_local_folders_account (account_store)); + folder = modest_tny_local_folders_account_get_merged_outbox (local_folders_account); + g_object_unref (local_folders_account); + } + if (folder) { + TnyDevice *device; + gboolean device_online; + + device = modest_runtime_get_device(); + device_online = tny_device_is_online (device); + if (device_online) { + message_reader (window, priv, NULL, msg_uid, folder, NULL); + } else { + TnyMsg *msg = tny_folder_find_msg (folder, uri, NULL); + if (msg) { + tny_msg_view_set_msg (TNY_MSG_VIEW (priv->msg_view), msg); + g_object_unref (msg); + } else { + message_reader (window, priv, NULL, msg_uid, folder, NULL); + } + } + g_object_unref (folder); + } + + } + + /* Check dimming rules */ + modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window)); + modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (window)); + modest_window_check_dimming_rules_group (MODEST_WINDOW (window), MODEST_DIMMING_RULES_CLIPBOARD); + + return MODEST_WINDOW(window); +} + + + /* FIXME: parameter checks */ ModestWindow * modest_msg_view_window_new_with_header_model (TnyMsg *msg, const gchar *modest_account_name, + const gchar *mailbox, /*ignored */ const gchar *msg_uid, GtkTreeModel *model, GtkTreeRowReference *row_reference) @@ -858,6 +1033,10 @@ modest_msg_view_window_new_with_header_model (TnyMsg *msg, ModestWindow *main_window = NULL; ModestWindowMgr *mgr = NULL; + MODEST_DEBUG_BLOCK ( + modest_tny_mime_part_to_string (TNY_MIME_PART (msg), 0); + ); + mgr = modest_runtime_get_window_mgr (); window = MODEST_MSG_VIEW_WINDOW (modest_window_mgr_get_msg_view_window (mgr)); g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), NULL); @@ -878,39 +1057,47 @@ modest_msg_view_window_new_with_header_model (TnyMsg *msg, if (header_view != NULL){ header_folder = modest_header_view_get_folder(header_view); - priv->is_outbox = (modest_tny_folder_guess_folder_type (header_folder) == TNY_FOLDER_TYPE_OUTBOX); - g_assert(header_folder != NULL); - priv->header_folder_id = tny_folder_get_id(header_folder); - g_assert(priv->header_folder_id != NULL); - g_object_unref(header_folder); + /* This could happen if the header folder was + unseleted before opening this msg window (for + example if the user selects an account in the + folder view of the main window */ + if (header_folder) { + priv->is_outbox = (modest_tny_folder_guess_folder_type (header_folder) == TNY_FOLDER_TYPE_OUTBOX); + priv->header_folder_id = tny_folder_get_id(header_folder); + g_assert(priv->header_folder_id != NULL); + g_object_unref(header_folder); + } } - priv->header_model = g_object_ref(model); + /* Setup row references and connect signals */ + priv->header_model = g_object_ref (model); + if (row_reference) { priv->row_reference = gtk_tree_row_reference_copy (row_reference); priv->next_row_reference = gtk_tree_row_reference_copy (row_reference); - select_next_valid_row (model, &(priv->next_row_reference), TRUE); + select_next_valid_row (model, &(priv->next_row_reference), TRUE, priv->is_outbox); } else { priv->row_reference = NULL; priv->next_row_reference = NULL; } - priv->row_changed_handler = g_signal_connect( - GTK_TREE_MODEL(model), "row-changed", - G_CALLBACK(modest_msg_view_window_on_row_changed), - window); - priv->row_deleted_handler = g_signal_connect( - GTK_TREE_MODEL(model), "row-deleted", - G_CALLBACK(modest_msg_view_window_on_row_deleted), - window); - priv->row_inserted_handler = g_signal_connect ( - GTK_TREE_MODEL(model), "row-inserted", - G_CALLBACK(modest_msg_view_window_on_row_inserted), - window); - priv->rows_reordered_handler = g_signal_connect( - GTK_TREE_MODEL(model), "rows-reordered", - G_CALLBACK(modest_msg_view_window_on_row_reordered), - window); + /* Connect signals */ + priv->row_changed_handler = + g_signal_connect (GTK_TREE_MODEL(model), "row-changed", + G_CALLBACK(modest_msg_view_window_on_row_changed), + window); + priv->row_deleted_handler = + g_signal_connect (GTK_TREE_MODEL(model), "row-deleted", + G_CALLBACK(modest_msg_view_window_on_row_deleted), + window); + priv->row_inserted_handler = + g_signal_connect (GTK_TREE_MODEL(model), "row-inserted", + G_CALLBACK(modest_msg_view_window_on_row_inserted), + window); + priv->rows_reordered_handler = + g_signal_connect(GTK_TREE_MODEL(model), "rows-reordered", + G_CALLBACK(modest_msg_view_window_on_row_reordered), + window); if (header_view != NULL){ modest_header_view_add_observer(header_view, @@ -920,11 +1107,12 @@ modest_msg_view_window_new_with_header_model (TnyMsg *msg, tny_msg_view_set_msg (TNY_MSG_VIEW (priv->msg_view), msg); update_window_title (MODEST_MSG_VIEW_WINDOW (window)); gtk_widget_show_all (GTK_WIDGET (window)); - modest_msg_view_window_update_priority (window); - /* Check toolbar dimming rules */ + /* Check dimming rules */ modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window)); + modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (window)); + modest_window_check_dimming_rules_group (MODEST_WINDOW (window), MODEST_DIMMING_RULES_CLIPBOARD); return MODEST_WINDOW(window); } @@ -932,6 +1120,7 @@ modest_msg_view_window_new_with_header_model (TnyMsg *msg, ModestWindow * modest_msg_view_window_new_for_search_result (TnyMsg *msg, const gchar *modest_account_name, + const gchar *mailbox, /*ignored*/ const gchar *msg_uid) { ModestMsgViewWindow *window = NULL; @@ -952,15 +1141,34 @@ modest_msg_view_window_new_for_search_result (TnyMsg *msg, tny_msg_view_set_msg (TNY_MSG_VIEW (priv->msg_view), msg); update_window_title (window); + gtk_widget_show_all (GTK_WIDGET (window)); modest_msg_view_window_update_priority (window); + /* Check dimming rules */ + modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window)); + modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (window)); + modest_window_check_dimming_rules_group (MODEST_WINDOW (window), MODEST_DIMMING_RULES_CLIPBOARD); + return MODEST_WINDOW(window); } +gboolean +modest_msg_view_window_is_other_body (ModestMsgViewWindow *self) +{ + ModestMsgViewWindowPrivate *priv = NULL; + + g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self), FALSE); + priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self); + + return (priv->other_body != NULL); +} + ModestWindow * -modest_msg_view_window_new_for_attachment (TnyMsg *msg, - const gchar *modest_account_name, - const gchar *msg_uid) +modest_msg_view_window_new_with_other_body (TnyMsg *msg, + TnyMimePart *other_body, + const gchar *modest_account_name, + const gchar *mailbox, /* ignored */ + const gchar *msg_uid) { GObject *obj = NULL; ModestMsgViewWindowPrivate *priv; @@ -973,27 +1181,60 @@ modest_msg_view_window_new_for_attachment (TnyMsg *msg, modest_msg_view_window_construct (MODEST_MSG_VIEW_WINDOW (obj), modest_account_name, msg_uid); - tny_msg_view_set_msg (TNY_MSG_VIEW (priv->msg_view), msg); + if (other_body) { + priv->other_body = g_object_ref (other_body); + modest_msg_view_set_msg_with_other_body (MODEST_MSG_VIEW (priv->msg_view), msg, other_body); + } else { + tny_msg_view_set_msg (TNY_MSG_VIEW (priv->msg_view), msg); + } update_window_title (MODEST_MSG_VIEW_WINDOW (obj)); + gtk_widget_show_all (GTK_WIDGET (obj)); + + /* Check dimming rules */ + modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (obj)); + modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (obj)); + modest_window_check_dimming_rules_group (MODEST_WINDOW (obj), MODEST_DIMMING_RULES_CLIPBOARD); + return MODEST_WINDOW(obj); } -void modest_msg_view_window_on_row_changed( - GtkTreeModel *header_model, - GtkTreePath *arg1, - GtkTreeIter *arg2, - ModestMsgViewWindow *window){ - modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window)); +ModestWindow * +modest_msg_view_window_new_for_attachment (TnyMsg *msg, + const gchar *modest_account_name, + const gchar *mailbox, /* ignored */ + const gchar *msg_uid) +{ + return modest_msg_view_window_new_with_other_body (msg, NULL, modest_account_name, mailbox, msg_uid); + +} + +static void +modest_msg_view_window_on_row_changed (GtkTreeModel *header_model, + GtkTreePath *arg1, + GtkTreeIter *arg2, + ModestMsgViewWindow *window) +{ + check_dimming_rules_after_change (window); } -void modest_msg_view_window_on_row_deleted( - GtkTreeModel *header_model, - GtkTreePath *arg1, - ModestMsgViewWindow *window){ +static void +modest_msg_view_window_on_row_deleted(GtkTreeModel *header_model, + GtkTreePath *arg1, + ModestMsgViewWindow *window) +{ + check_dimming_rules_after_change (window); +} + /* The window could have dissapeared */ + +static void +check_dimming_rules_after_change (ModestMsgViewWindow *window) +{ + modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (window)); modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window)); } + /* On insertions we check if the folder still has the message we are * showing or do not. If do not, we do nothing. Which means we are still * not attached to any header folder and thus next/prev buttons are @@ -1005,90 +1246,122 @@ void modest_msg_view_window_on_row_deleted( * inserted into the model again for example if it is removed by the * imap server and the header view is refreshed.) */ -void modest_msg_view_window_on_row_inserted( - GtkTreeModel *new_model, - GtkTreePath *tree_path, - GtkTreeIter *tree_iter, - ModestMsgViewWindow *window){ +static void +modest_msg_view_window_on_row_inserted (GtkTreeModel *model, + GtkTreePath *tree_path, + GtkTreeIter *tree_iter, + ModestMsgViewWindow *window) +{ ModestMsgViewWindowPrivate *priv = NULL; TnyHeader *header = NULL; - gchar *uid = NULL; g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window)); - priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); - - /* If we already has a model attached then the message shown by - * msg-view is in it, and thus we do not need any actions but - * to check the dimming rules.*/ - if(priv->header_model != NULL){ - if (priv->row_reference) { - gtk_tree_row_reference_free(priv->next_row_reference); - priv->next_row_reference = gtk_tree_row_reference_copy( - priv->row_reference); - select_next_valid_row (priv->header_model, - &(priv->next_row_reference), FALSE); - } - modest_ui_actions_check_toolbar_dimming_rules ( - MODEST_WINDOW (window)); - return; - } + g_assert (model == priv->header_model); + /* Check if the newly inserted message is the same we are actually * showing. IF not, we should remain detached from the header model - * and thus prev and next toolbarbuttons should remain dimmed. */ - gtk_tree_model_get (new_model, tree_iter, - TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, &header, -1); - uid = modest_tny_folder_get_header_unique_id(header); - if(!g_str_equal(priv->msg_uid, uid)){ + * and thus prev and next toolbar buttons should remain dimmed. */ + gtk_tree_model_get (model, tree_iter, + TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, + &header, -1); + + if (TNY_IS_HEADER (header)) { + gchar *uid = NULL; + + uid = modest_tny_folder_get_header_unique_id (header); + if (!g_str_equal(priv->msg_uid, uid)) { + check_dimming_rules_after_change (window); + g_free(uid); + g_object_unref (G_OBJECT(header)); + return; + } g_free(uid); g_object_unref(G_OBJECT(header)); - header = NULL; - return; } - if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_SEEN)) - tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN); - g_object_unref(G_OBJECT(header)); - header = NULL; - g_free(uid); + + if (priv->row_reference) { + gtk_tree_row_reference_free (priv->row_reference); + } /* Setup row_reference for the actual msg. */ - priv->row_reference = gtk_tree_row_reference_new( - new_model, tree_path); - if(priv->row_reference == NULL){ + priv->row_reference = gtk_tree_row_reference_new (priv->header_model, tree_path); + if (priv->row_reference == NULL) { g_warning("No reference for msg header item."); return; } - /* Attach new_model and connect some callback to it to become able - * to detect changes in header-view. */ - priv->header_model = g_object_ref(new_model); - g_signal_connect (new_model, "row-changed", - G_CALLBACK (modest_msg_view_window_on_row_changed), - window); - g_signal_connect (new_model, "row-deleted", - G_CALLBACK (modest_msg_view_window_on_row_deleted), - window); - g_signal_connect (new_model, "rows-reordered", - G_CALLBACK (modest_msg_view_window_on_row_reordered), - window); - /* Now set up next_row_reference. */ - priv->next_row_reference = gtk_tree_row_reference_copy( - priv->row_reference); - select_next_valid_row (priv->header_model, - &(priv->next_row_reference), FALSE); + if (priv->next_row_reference) { + gtk_tree_row_reference_free (priv->next_row_reference); + } - modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window)); + priv->next_row_reference = gtk_tree_row_reference_copy (priv->row_reference); + select_next_valid_row (priv->header_model, + &(priv->next_row_reference), FALSE, priv->is_outbox); + + /* Connect the remaining callbacks to become able to detect + * changes in header-view. */ + priv->row_changed_handler = + g_signal_connect (priv->header_model, "row-changed", + G_CALLBACK (modest_msg_view_window_on_row_changed), + window); + priv->row_deleted_handler = + g_signal_connect (priv->header_model, "row-deleted", + G_CALLBACK (modest_msg_view_window_on_row_deleted), + window); + priv->rows_reordered_handler = + g_signal_connect (priv->header_model, "rows-reordered", + G_CALLBACK (modest_msg_view_window_on_row_reordered), + window); + + check_dimming_rules_after_change (window); } -void modest_msg_view_window_on_row_reordered( - GtkTreeModel *header_model, - GtkTreePath *arg1, - GtkTreeIter *arg2, - gpointer arg3, - ModestMsgViewWindow *window){ - modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window)); +static void +modest_msg_view_window_on_row_reordered (GtkTreeModel *header_model, + GtkTreePath *arg1, + GtkTreeIter *arg2, + gpointer arg3, + ModestMsgViewWindow *window) +{ + ModestMsgViewWindowPrivate *priv = NULL; + gboolean already_changed = FALSE; + + priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(window); + + /* If the current row was reordered select the proper next + valid row. The same if the next row reference changes */ + if (priv->row_reference && + gtk_tree_row_reference_valid (priv->row_reference)) { + GtkTreePath *path; + path = gtk_tree_row_reference_get_path (priv->row_reference); + if (gtk_tree_path_compare (path, arg1) == 0) { + if (priv->next_row_reference) { + gtk_tree_row_reference_free (priv->next_row_reference); + } + priv->next_row_reference = gtk_tree_row_reference_copy (priv->row_reference); + select_next_valid_row (header_model, &(priv->next_row_reference), FALSE, priv->is_outbox); + already_changed = TRUE; + } + gtk_tree_path_free (path); + } + if (!already_changed && + priv->next_row_reference && + gtk_tree_row_reference_valid (priv->next_row_reference)) { + GtkTreePath *path; + path = gtk_tree_row_reference_get_path (priv->next_row_reference); + if (gtk_tree_path_compare (path, arg1) == 0) { + if (priv->next_row_reference) { + gtk_tree_row_reference_free (priv->next_row_reference); + } + priv->next_row_reference = gtk_tree_row_reference_copy (priv->row_reference); + select_next_valid_row (header_model, &(priv->next_row_reference), FALSE, priv->is_outbox); + } + gtk_tree_path_free (path); + } + check_dimming_rules_after_change (window); } /* The modest_msg_view_window_update_model_replaced implements update @@ -1100,10 +1373,11 @@ void modest_msg_view_window_on_row_reordered( * the new model. In this case the view will be detached from it's * header folder. From this point the next/prev buttons are dimmed. */ -void modest_msg_view_window_update_model_replaced( - ModestHeaderViewObserver *observer, - GtkTreeModel *model, - const gchar *tny_folder_id){ +static void +modest_msg_view_window_update_model_replaced (ModestHeaderViewObserver *observer, + GtkTreeModel *model, + const gchar *tny_folder_id) +{ ModestMsgViewWindowPrivate *priv = NULL; ModestMsgViewWindow *window = NULL; @@ -1117,53 +1391,61 @@ void modest_msg_view_window_update_model_replaced( * not care about it's model (msg list). Else if the * header-view shows the folder the msg shown by us is in, we * shall replace our model reference and make some check. */ - if(tny_folder_id == NULL || !g_str_equal(tny_folder_id, priv->header_folder_id)) + if(model == NULL || tny_folder_id == NULL || + (priv->header_folder_id && !g_str_equal(tny_folder_id, priv->header_folder_id))) return; - + /* Model is changed(replaced), so we should forget the old * one. Because there might be other references and there * might be some change on the model even if we unreferenced * it, we need to disconnect our signals here. */ - if (g_signal_handler_is_connected(G_OBJECT (priv->header_model), - priv->row_changed_handler)) - g_signal_handler_disconnect(G_OBJECT (priv->header_model), - priv->row_changed_handler); - priv->row_changed_handler = 0; - if (g_signal_handler_is_connected(G_OBJECT (priv->header_model), - priv->row_deleted_handler)) - g_signal_handler_disconnect(G_OBJECT (priv->header_model), - priv->row_deleted_handler); - priv->row_deleted_handler = 0; - if (g_signal_handler_is_connected(G_OBJECT (priv->header_model), - priv->row_inserted_handler)) - g_signal_handler_disconnect(G_OBJECT (priv->header_model), - priv->row_inserted_handler); - priv->row_inserted_handler = 0; - if (g_signal_handler_is_connected(G_OBJECT (priv->header_model), - priv->rows_reordered_handler)) - g_signal_handler_disconnect(G_OBJECT (priv->header_model), - priv->rows_reordered_handler); - priv->rows_reordered_handler = 0; - g_object_unref(priv->header_model); - priv->header_model = NULL; - if (priv->row_reference) - g_object_unref(priv->row_reference); - priv->row_reference = NULL; - if (priv->next_row_reference) - g_object_unref(priv->next_row_reference); - priv->next_row_reference = NULL; + if (priv->header_model) { + if (g_signal_handler_is_connected(G_OBJECT (priv->header_model), + priv->row_changed_handler)) + g_signal_handler_disconnect(G_OBJECT (priv->header_model), + priv->row_changed_handler); + if (g_signal_handler_is_connected(G_OBJECT (priv->header_model), + priv->row_deleted_handler)) + g_signal_handler_disconnect(G_OBJECT (priv->header_model), + priv->row_deleted_handler); + if (g_signal_handler_is_connected(G_OBJECT (priv->header_model), + priv->row_inserted_handler)) + g_signal_handler_disconnect(G_OBJECT (priv->header_model), + priv->row_inserted_handler); + if (g_signal_handler_is_connected(G_OBJECT (priv->header_model), + priv->rows_reordered_handler)) + g_signal_handler_disconnect(G_OBJECT (priv->header_model), + priv->rows_reordered_handler); - modest_ui_actions_check_toolbar_dimming_rules(MODEST_WINDOW(window)); + /* Frees */ + if (priv->row_reference) + gtk_tree_row_reference_free (priv->row_reference); + if (priv->next_row_reference) + gtk_tree_row_reference_free (priv->next_row_reference); + g_object_unref(priv->header_model); + + /* Initialize */ + priv->row_changed_handler = 0; + priv->row_deleted_handler = 0; + priv->row_inserted_handler = 0; + priv->rows_reordered_handler = 0; + priv->next_row_reference = NULL; + priv->row_reference = NULL; + priv->header_model = NULL; + } - g_assert(model != NULL); + priv->header_model = g_object_ref (model); /* Also we must connect to the new model for row insertions. * Only for insertions now. We will need other ones only after * the msg is show by msg-view is added to the new model. */ - priv->row_inserted_handler = g_signal_connect ( - model, "row-inserted", - G_CALLBACK(modest_msg_view_window_on_row_inserted), - window); + priv->row_inserted_handler = + g_signal_connect (priv->header_model, "row-inserted", + G_CALLBACK(modest_msg_view_window_on_row_inserted), + window); + + modest_ui_actions_check_menu_dimming_rules(MODEST_WINDOW(window)); + modest_ui_actions_check_toolbar_dimming_rules(MODEST_WINDOW(window)); } gboolean @@ -1192,7 +1474,9 @@ modest_msg_view_window_get_header (ModestMsgViewWindow *self) /* If the message was not obtained from a treemodel, * for instance if it was opened directly by the search UI: */ - if (priv->header_model == NULL || priv->row_reference == NULL) { + if (priv->header_model == NULL || + priv->row_reference == NULL || + !gtk_tree_row_reference_valid (priv->row_reference)) { msg = modest_msg_view_window_get_message (self); if (msg) { header = tny_msg_get_header (msg); @@ -1202,12 +1486,6 @@ modest_msg_view_window_get_header (ModestMsgViewWindow *self) } /* Get iter of the currently selected message in the header view: */ - /* TODO: Why not just give this window a ref of the TnyHeader or TnyMessage, - * instead of sometimes retrieving it from the header view? - * Then we wouldn't be dependent on the message actually still being selected - * in the header view. murrayc. */ - if (!gtk_tree_row_reference_valid (priv->row_reference)) - return NULL; path = gtk_tree_row_reference_get_path (priv->row_reference); g_return_val_if_fail (path != NULL, NULL); gtk_tree_model_get_iter (priv->header_model, @@ -1264,6 +1542,7 @@ modest_msg_view_window_toggle_find_toolbar (GtkToggleAction *toggle, hildon_find_toolbar_highlight_entry (HILDON_FIND_TOOLBAR (priv->find_toolbar), TRUE); } else { gtk_widget_hide (priv->find_toolbar); + modest_msg_view_grab_focus (MODEST_MSG_VIEW (priv->msg_view)); } /* update the toggle buttons status */ @@ -1280,10 +1559,14 @@ modest_msg_view_window_find_toolbar_close (GtkWidget *widget, { GtkToggleAction *toggle; ModestWindowPrivate *parent_priv; + ModestMsgViewWindowPrivate *priv; + + priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (obj); parent_priv = MODEST_WINDOW_GET_PRIVATE (obj); toggle = GTK_TOGGLE_ACTION (gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/FindInMessage")); gtk_toggle_action_set_active (toggle, FALSE); + modest_msg_view_grab_focus (MODEST_MSG_VIEW (priv->msg_view)); } static void @@ -1302,7 +1585,7 @@ modest_msg_view_window_find_toolbar_search (GtkWidget *widget, if ((current_search == NULL) || (strcmp (current_search, "") == 0)) { g_free (current_search); - hildon_banner_show_information (NULL, NULL, dgettext("hildon-common-strings", "ecdg_ib_find_rep_enter_text")); + hildon_banner_show_information (NULL, NULL, _CS("ecdg_ib_find_rep_enter_text")); return; } @@ -1313,19 +1596,21 @@ modest_msg_view_window_find_toolbar_search (GtkWidget *widget, result = modest_isearch_view_search (MODEST_ISEARCH_VIEW (priv->msg_view), priv->last_search); if (!result) { - hildon_banner_show_information (NULL, NULL, dgettext("hildon-libs", "ckct_ib_find_no_matches")); + hildon_banner_show_information (NULL, NULL, _HL("ckct_ib_find_no_matches")); g_free (priv->last_search); priv->last_search = NULL; } else { modest_msg_view_grab_focus (MODEST_MSG_VIEW (priv->msg_view)); + hildon_find_toolbar_highlight_entry (HILDON_FIND_TOOLBAR (priv->find_toolbar), TRUE); } } else { if (!modest_isearch_view_search_next (MODEST_ISEARCH_VIEW (priv->msg_view))) { - hildon_banner_show_information (NULL, NULL, dgettext("hildon-libs", "ckct_ib_find_search_complete")); + hildon_banner_show_information (NULL, NULL, _HL("ckct_ib_find_search_complete")); g_free (priv->last_search); priv->last_search = NULL; } else { modest_msg_view_grab_focus (MODEST_MSG_VIEW (priv->msg_view)); + hildon_find_toolbar_highlight_entry (HILDON_FIND_TOOLBAR (priv->find_toolbar), TRUE); } } @@ -1379,7 +1664,7 @@ modest_msg_view_window_zoom_plus (ModestWindow *window) group = gtk_radio_action_get_group (zoom_radio_action); if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (group->data))) { - hildon_banner_show_information (NULL, NULL, dgettext("hildon-common-strings", "ckct_ib_max_zoom_level_reached")); + hildon_banner_show_information (NULL, NULL, _CS("ckct_ib_max_zoom_level_reached")); return FALSE; } @@ -1411,7 +1696,8 @@ modest_msg_view_window_zoom_minus (ModestWindow *window) gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (node->next->data), TRUE); return TRUE; } else { - hildon_banner_show_information (NULL, NULL, dgettext("hildon-common-strings", "ckct_ib_min_zoom_level_reached")); + hildon_banner_show_information (NULL, NULL, + _CS("ckct_ib_min_zoom_level_reached")); return FALSE; } break; @@ -1425,17 +1711,31 @@ modest_msg_view_window_key_event (GtkWidget *window, GdkEventKey *event, gpointer userdata) { - + GtkWidget *focus; + + focus = gtk_window_get_focus (GTK_WINDOW (window)); + + /* for the find toolbar case */ + if (focus && GTK_IS_ENTRY (focus)) { + if (event->keyval == GDK_BackSpace) { + GdkEvent *copy; + copy = gdk_event_copy ((GdkEvent *) event); + gtk_widget_event (focus, copy); + gdk_event_free (copy); + return TRUE; + } else + return FALSE; + } if (event->keyval == GDK_Up || event->keyval == GDK_KP_Up || event->keyval == GDK_Down || event->keyval == GDK_KP_Down || event->keyval == GDK_Page_Up || event->keyval == GDK_KP_Page_Up || event->keyval == GDK_Page_Down || event->keyval == GDK_KP_Page_Down || event->keyval == GDK_Home || event->keyval == GDK_KP_Home || event->keyval == GDK_End || event->keyval == GDK_KP_End) { - ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); - gboolean return_value; + /* ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); */ + /* gboolean return_value; */ - if (event->type == GDK_KEY_RELEASE) { + if (event->type == GDK_KEY_PRESS) { GtkScrollType scroll_type; switch (event->keyval) { @@ -1460,9 +1760,9 @@ modest_msg_view_window_key_event (GtkWidget *window, default: scroll_type = GTK_SCROLL_NONE; } - g_signal_emit_by_name (G_OBJECT (priv->main_scroll), "scroll-child", - scroll_type, FALSE, &return_value); - return TRUE; + /* g_signal_emit_by_name (G_OBJECT (priv->main_scroll), "scroll-child", */ + /* scroll_type, FALSE, &return_value); */ + return FALSE; } else { return FALSE; } @@ -1486,6 +1786,9 @@ modest_msg_view_window_last_message_selected (ModestMsgViewWindow *window) if (!priv->header_model || !priv->row_reference) return TRUE; + if (!gtk_tree_row_reference_valid (priv->row_reference)) + return TRUE; + path = gtk_tree_row_reference_get_path (priv->row_reference); if (path == NULL) return TRUE; @@ -1534,9 +1837,16 @@ modest_msg_view_window_is_search_result (ModestMsgViewWindow *window) static gboolean msg_is_visible (TnyHeader *header, gboolean check_outbox) { - return (!(tny_header_get_flags(header) & TNY_HEADER_FLAG_DELETED)) && - ( (!check_outbox) || (modest_tny_all_send_queues_get_msg_status (header) != MODEST_TNY_SEND_QUEUE_FAILED)) ; - + if ((tny_header_get_flags(header) & TNY_HEADER_FLAG_DELETED)) + return FALSE; + if (!check_outbox) { + return TRUE; + } else { + ModestTnySendQueueStatus status; + status = modest_tny_all_send_queues_get_msg_status (header); + return ((status != MODEST_TNY_SEND_QUEUE_FAILED) && + (status != MODEST_TNY_SEND_QUEUE_SENDING)); + } } gboolean @@ -1546,7 +1856,6 @@ modest_msg_view_window_first_message_selected (ModestMsgViewWindow *window) ModestMsgViewWindowPrivate *priv; gboolean is_first_selected; GtkTreeIter tmp_iter; -/* gchar * path_string;*/ g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), TRUE); priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); @@ -1555,18 +1864,13 @@ modest_msg_view_window_first_message_selected (ModestMsgViewWindow *window) if (!priv->header_model || !priv->row_reference) return TRUE; + if (!gtk_tree_row_reference_valid (priv->row_reference)) + return TRUE; + path = gtk_tree_row_reference_get_path (priv->row_reference); if (!path) return TRUE; -/* path_string = gtk_tree_path_to_string (path); - is_first_selected = strcmp (path_string, "0"); - - g_free (path_string); - gtk_tree_path_free (path); - - return is_first_selected;*/ - is_first_selected = TRUE; while (is_first_selected) { TnyHeader *header; @@ -1589,30 +1893,80 @@ modest_msg_view_window_first_message_selected (ModestMsgViewWindow *window) return is_first_selected; } -/** - * Reads the message whose summary item is @header. It takes care of - * several things, among others: - * - * If the message was not previously downloaded then ask the user - * before downloading. If there is no connection launch the connection - * dialog. Update toolbar dimming rules. - * - * Returns: TRUE if the mail operation was started, otherwise if the - * user do not want to download the message, or if the user do not - * want to connect, then the operation is not issued - **/ -static gboolean -message_reader (ModestMsgViewWindow *window, - ModestMsgViewWindowPrivate *priv, - TnyHeader *header, - GtkTreeRowReference *row_reference) -{ - ModestMailOperation *mail_op = NULL; - gboolean already_showing = FALSE; - ModestWindow *msg_window = NULL; - ModestWindowMgr *mgr; +typedef struct { + TnyHeader *header; + gchar *msg_uid; + TnyFolder *folder; + GtkTreeRowReference *row_reference; +} MsgReaderInfo; + +static void +message_reader_performer (gboolean canceled, + GError *err, + GtkWindow *parent_window, + TnyAccount *account, + gpointer user_data) +{ + ModestMailOperation *mail_op = NULL; + MsgReaderInfo *info; + + info = (MsgReaderInfo *) user_data; + if (canceled || err) { + goto frees; + } + + /* Register the header - it'll be unregistered in the callback */ + modest_window_mgr_register_header (modest_runtime_get_window_mgr (), info->header, NULL); + + /* New mail operation */ + mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT(parent_window), + modest_ui_actions_disk_operations_error_handler, + NULL, NULL); + + modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op); + if (info->header) + modest_mail_operation_get_msg (mail_op, info->header, TRUE, view_msg_cb, info->row_reference); + else + modest_mail_operation_find_msg (mail_op, info->folder, info->uid, TRUE, view_msg_cb); + g_object_unref (mail_op); + + /* Update dimming rules */ + modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (parent_window)); + modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (parent_window)); + + frees: + /* Frees. The row_reference will be freed by the view_msg_cb callback */ + g_free (info->uid); + g_object_unref (info->header); + g_slice_free (MsgReaderInfo, info); +} + - g_return_val_if_fail (row_reference != NULL, FALSE); +/** + * Reads the message whose summary item is @header. It takes care of + * several things, among others: + * + * If the message was not previously downloaded then ask the user + * before downloading. If there is no connection launch the connection + * dialog. Update toolbar dimming rules. + * + * Returns: TRUE if the mail operation was started, otherwise if the + * user do not want to download the message, or if the user do not + * want to connect, then the operation is not issued + **/ +static gboolean +message_reader (ModestMsgViewWindow *window, + ModestMsgViewWindowPrivate *priv, + TnyHeader *header, + const gchar *msg_uid, + TnyFolder *folder, + GtkTreeRowReference *row_reference) +{ + gboolean already_showing = FALSE; + ModestWindow *msg_window = NULL; + ModestWindowMgr *mgr; + TnyAccount *account; + MsgReaderInfo *info; mgr = modest_runtime_get_window_mgr (); already_showing = modest_window_mgr_find_registered_header (mgr, header, &msg_window); @@ -1625,42 +1979,62 @@ message_reader (ModestMsgViewWindow *window, } /* Msg download completed */ - if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED)) { + if (!header || !(tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED)) { /* Ask the user if he wants to download the message if we're not online */ if (!tny_device_is_online (modest_runtime_get_device())) { - TnyFolder *folder = NULL; GtkResponseType response; response = modest_platform_run_confirmation_dialog (GTK_WINDOW (window), _("mcen_nc_get_msg")); if (response == GTK_RESPONSE_CANCEL) return FALSE; - + + if (header) + folder = tny_header_get_folder (header); + else + g_object_ref (folder); + info = g_slice_new (MsgReaderInfo); + info->msg_uid = g_strdup (msg_uid); + if (header) + info->header = g_object_ref (header); + else + info->header = NULL; + if (row_reference) + info->row_reference = gtk_tree_row_reference_copy (row_reference); + else + info->row_reference = NULL; + /* Offer the connection dialog if necessary */ - folder = tny_header_get_folder (header); - if (folder) { - if (!modest_platform_connect_and_wait_if_network_folderstore (NULL, - TNY_FOLDER_STORE (folder))) { - g_object_unref (folder); - return FALSE; - } - g_object_unref (folder); - } + modest_platform_connect_if_remote_and_perform ((GtkWindow *) window, + TRUE, + TNY_FOLDER_STORE (folder), + message_reader_performer, + info); + g_object_unref (folder); + return TRUE; } } - /* New mail operation */ - mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT(window), - modest_ui_actions_get_msgs_full_error_handler, - NULL, NULL); - - modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op); - modest_mail_operation_get_msg (mail_op, header, view_msg_cb, row_reference); - g_object_unref (mail_op); - - /* Update toolbar dimming rules */ - modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window)); + if (header) + folder = tny_header_get_folder (header); + else + g_object_ref (folder); + account = tny_folder_get_account (folder); + info = g_slice_new (MsgReaderInfo); + info->msg_uid = g_strdup (msg_uid); + if (header) + info->header = g_object_ref (header); + else + info->header = NULL; + if (row_reference) + info->row_reference = gtk_tree_row_reference_copy (row_reference); + else + row_reference = NULL; + + message_reader_performer (FALSE, NULL, (GtkWindow *) window, account, info); + g_object_unref (account); + g_object_unref (folder); return TRUE; } @@ -1690,7 +2064,7 @@ modest_msg_view_window_select_next_message (ModestMsgViewWindow *window) if (!gtk_tree_row_reference_valid (priv->next_row_reference)) { if (gtk_tree_row_reference_valid (priv->row_reference)) { priv->next_row_reference = gtk_tree_row_reference_copy (priv->row_reference); - select_next_valid_row (priv->header_model, &(priv->next_row_reference), FALSE); + select_next_valid_row (priv->header_model, &(priv->next_row_reference), FALSE, priv->is_outbox); } } if (priv->next_row_reference) @@ -1710,63 +2084,24 @@ modest_msg_view_window_select_next_message (ModestMsgViewWindow *window) &header, -1); /* Read the message & show it */ - if (!message_reader (window, priv, header, row_reference)) { + if (!message_reader (window, priv, header, NULL, NULL, row_reference)) { retval = FALSE; - gtk_tree_row_reference_free (row_reference); } + gtk_tree_row_reference_free (row_reference); /* Free */ g_object_unref (header); - return retval; + return retval; } -gboolean -modest_msg_view_window_select_first_message (ModestMsgViewWindow *self) -{ - ModestMsgViewWindowPrivate *priv = NULL; - TnyHeader *header = NULL; - GtkTreeIter iter; - GtkTreePath *path = NULL; - GtkTreeRowReference *row_reference = NULL; - - g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self), FALSE); - priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self); - - /* Check that the model is not empty */ - if (!gtk_tree_model_get_iter_first (priv->header_model, &iter)) - return FALSE; - - /* Get the header */ - gtk_tree_model_get (priv->header_model, - &iter, - TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, - &header, -1); - g_return_val_if_fail (TNY_IS_HEADER (header), FALSE); - if (!msg_is_visible (header, priv->is_outbox)) { - g_object_unref (header); - return modest_msg_view_window_select_next_message (self); - } - - path = gtk_tree_model_get_path (priv->header_model, &iter); - row_reference = gtk_tree_row_reference_new (priv->header_model, path); - gtk_tree_path_free (path); - - /* Read the message & show it */ - message_reader (self, priv, header, row_reference); - - /* Free */ - g_object_unref (header); - - return TRUE; -} - gboolean modest_msg_view_window_select_previous_message (ModestMsgViewWindow *window) { ModestMsgViewWindowPrivate *priv = NULL; GtkTreePath *path; - GtkTreeRowReference *row_reference = NULL; + gboolean finished = FALSE; + gboolean retval = FALSE; g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), FALSE); priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); @@ -1776,7 +2111,7 @@ modest_msg_view_window_select_previous_message (ModestMsgViewWindow *window) return FALSE; path = gtk_tree_row_reference_get_path (priv->row_reference); - while (gtk_tree_path_prev (path)) { + while (!finished && gtk_tree_path_prev (path)) { TnyHeader *header; GtkTreeIter iter; @@ -1784,29 +2119,23 @@ modest_msg_view_window_select_previous_message (ModestMsgViewWindow *window) gtk_tree_model_get (priv->header_model, &iter, TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, &header, -1); - if (!header) - break; - if (!msg_is_visible (header, priv->is_outbox)) { - g_object_unref (header); - continue; - } - - row_reference = gtk_tree_row_reference_new (priv->header_model, path); - /* Read the message & show it */ - if (!message_reader (window, priv, header, row_reference)) { - gtk_tree_row_reference_free (row_reference); + finished = TRUE; + if (header) { + if (msg_is_visible (header, priv->is_outbox)) { + GtkTreeRowReference *row_reference; + row_reference = gtk_tree_row_reference_new (priv->header_model, path); + /* Read the message & show it */ + retval = message_reader (window, priv, header, NULL, NULL, row_reference); + gtk_tree_row_reference_free (row_reference); + } else { + finished = FALSE; + } g_object_unref (header); - break; } - - gtk_tree_path_free (path); - g_object_unref (header); - - return TRUE; } gtk_tree_path_free (path); - return FALSE; + return retval; } static void @@ -1821,10 +2150,20 @@ view_msg_cb (ModestMailOperation *mail_op, ModestMsgViewWindowPrivate *priv = NULL; GtkTreeRowReference *row_reference = NULL; - /* If there was any error */ + /* Unregister the header (it was registered before creating the mail operation) */ + modest_window_mgr_unregister_header (modest_runtime_get_window_mgr (), header); + row_reference = (GtkTreeRowReference *) user_data; + if (canceled) { + if (row_reference) + gtk_tree_row_reference_free (row_reference); + return; + } + + /* If there was any error */ if (!modest_ui_actions_msg_retrieval_check (mail_op, header, msg)) { - gtk_tree_row_reference_free (row_reference); + if (row_reference) + gtk_tree_row_reference_free (row_reference); return; } @@ -1834,21 +2173,27 @@ view_msg_cb (ModestMailOperation *mail_op, priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self); /* Update the row reference */ - gtk_tree_row_reference_free (priv->row_reference); - priv->row_reference = gtk_tree_row_reference_copy (row_reference); - priv->next_row_reference = gtk_tree_row_reference_copy (priv->row_reference); - select_next_valid_row (priv->header_model, &(priv->next_row_reference), TRUE); - gtk_tree_row_reference_free (row_reference); + if (priv->row_reference != NULL) { + gtk_tree_row_reference_free (priv->row_reference); + priv->row_reference = gtk_tree_row_reference_copy (row_reference); + if (priv->next_row_reference != NULL) { + gtk_tree_row_reference_free (priv->next_row_reference); + } + priv->next_row_reference = gtk_tree_row_reference_copy (priv->row_reference); + select_next_valid_row (priv->header_model, &(priv->next_row_reference), TRUE, priv->is_outbox); + } /* Mark header as read */ if (!(tny_header_get_flags (header) & TNY_HEADER_FLAG_SEEN)) tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN); /* Set new message */ - tny_msg_view_set_msg (TNY_MSG_VIEW (priv->msg_view), msg); - modest_msg_view_window_update_priority (self); - update_window_title (MODEST_MSG_VIEW_WINDOW (self)); - modest_msg_view_grab_focus (MODEST_MSG_VIEW (priv->msg_view)); + if (priv->msg_view != NULL && TNY_IS_MSG_VIEW (priv->msg_view)) { + tny_msg_view_set_msg (TNY_MSG_VIEW (priv->msg_view), msg); + modest_msg_view_window_update_priority (self); + update_window_title (MODEST_MSG_VIEW_WINDOW (self)); + modest_msg_view_grab_focus (MODEST_MSG_VIEW (priv->msg_view)); + } /* Set the new message uid of the window */ if (priv->msg_uid) { @@ -1860,8 +2205,10 @@ view_msg_cb (ModestMailOperation *mail_op, g_signal_emit (G_OBJECT (self), signals[MSG_CHANGED_SIGNAL], 0, priv->header_model, priv->row_reference); - /* Free new references */ + /* Frees */ g_object_unref (self); + if (row_reference) + gtk_tree_row_reference_free (row_reference); } TnyFolderType @@ -1881,7 +2228,7 @@ modest_msg_view_window_get_folder_type (ModestMsgViewWindow *window) folder = tny_msg_get_folder (msg); if (folder) { - folder_type = tny_folder_get_folder_type (folder); + folder_type = modest_tny_folder_guess_folder_type (folder); g_object_unref (folder); } g_object_unref (msg); @@ -1931,6 +2278,53 @@ modest_msg_view_window_update_priority (ModestMsgViewWindow *window) } +static void +toolbar_resize (ModestMsgViewWindow *self) +{ + ModestMsgViewWindowPrivate *priv = NULL; + ModestWindowPrivate *parent_priv = NULL; + GtkWidget *widget; + gint static_button_size; + ModestWindowMgr *mgr; + + g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self)); + priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self); + parent_priv = MODEST_WINDOW_GET_PRIVATE(self); + + mgr = modest_runtime_get_window_mgr (); + static_button_size = modest_window_mgr_get_fullscreen_mode (mgr)?118:108; + + if (parent_priv->toolbar) { + /* left size buttons */ + widget = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarMessageReply"); + gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), FALSE); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), FALSE); + gtk_widget_set_size_request (GTK_WIDGET (widget), static_button_size, -1); + widget = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarMessageMoveTo"); + gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), FALSE); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), FALSE); + gtk_widget_set_size_request (GTK_WIDGET (widget), static_button_size, -1); + widget = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarDeleteMessage"); + gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), FALSE); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), FALSE); + gtk_widget_set_size_request (GTK_WIDGET (widget), static_button_size, -1); + widget = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/FindInMessage"); + gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), FALSE); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), FALSE); + gtk_widget_set_size_request (GTK_WIDGET (widget), static_button_size, -1); + + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE); + gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE); + gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->next_toolitem), TRUE); + gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->next_toolitem), TRUE); + gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->prev_toolitem), TRUE); + gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->prev_toolitem), TRUE); + } + +} + static gboolean modest_msg_view_window_window_state_event (GtkWidget *widget, GdkEventWindowState *event, gpointer userdata) { @@ -1951,6 +2345,7 @@ modest_msg_view_window_window_state_event (GtkWidget *widget, GdkEventWindowStat if (is_fullscreen != active) { gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (fs_toggle_action), is_fullscreen); } + toolbar_resize (MODEST_MSG_VIEW_WINDOW (widget)); } return FALSE; @@ -1958,16 +2353,6 @@ modest_msg_view_window_window_state_event (GtkWidget *widget, GdkEventWindowStat } static void -set_homogeneous (GtkWidget *widget, - gpointer data) -{ - if (GTK_IS_TOOL_ITEM (widget)) { - gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), TRUE); - gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), TRUE); - } -} - -static void modest_msg_view_window_show_toolbar (ModestWindow *self, gboolean show_toolbar) { @@ -1990,21 +2375,14 @@ modest_msg_view_window_show_toolbar (ModestWindow *self, "/ToolBar"); gtk_widget_set_no_show_all (parent_priv->toolbar, TRUE); - /* Set homogeneous toolbar */ - gtk_container_foreach (GTK_CONTAINER (parent_priv->toolbar), - set_homogeneous, NULL); - priv->progress_toolitem = GTK_WIDGET (gtk_tool_item_new ()); priv->cancel_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarCancel"); priv->next_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNext"); priv->prev_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarMessageBack"); - gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE); - gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE); - gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE); - gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE); + toolbar_resize (MODEST_MSG_VIEW_WINDOW (self)); /* Add ProgressBar (Transfer toolbar) */ - priv->progress_bar = modest_progress_bar_widget_new (); + priv->progress_bar = modest_progress_bar_new (); gtk_widget_set_no_show_all (priv->progress_bar, TRUE); placeholder = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ProgressbarView"); insert_index = gtk_toolbar_get_item_index(GTK_TOOLBAR (parent_priv->toolbar), GTK_TOOL_ITEM(placeholder)); @@ -2070,7 +2448,7 @@ modest_msg_view_window_clipboard_owner_change (GtkClipboard *clipboard, if (!GTK_WIDGET_VISIBLE (window)) return; - modest_window_check_dimming_rules_group (MODEST_WINDOW (window), "ModestClipboardDimmingRules"); + modest_window_check_dimming_rules_group (MODEST_WINDOW (window), MODEST_DIMMING_RULES_CLIPBOARD); } gboolean @@ -2150,21 +2528,25 @@ on_mail_operation_started (ModestMailOperation *mail_op, ModestMailOperationTypeOperation op_type; GSList *tmp; ModestMsgViewWindowPrivate *priv; + GObject *source = NULL; self = MODEST_MSG_VIEW_WINDOW (user_data); priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self); op_type = modest_mail_operation_get_type_operation (mail_op); tmp = priv->progress_widgets; - - if (op_type == MODEST_MAIL_OPERATION_TYPE_RECEIVE || op_type == MODEST_MAIL_OPERATION_TYPE_OPEN ) { - set_toolbar_transfer_mode(self); - while (tmp) { - modest_progress_object_add_operation ( - MODEST_PROGRESS_OBJECT (tmp->data), - mail_op); - tmp = g_slist_next (tmp); + source = modest_mail_operation_get_source(mail_op); + if (G_OBJECT (self) == source) { + if (op_type == MODEST_MAIL_OPERATION_TYPE_RECEIVE ) { + set_toolbar_transfer_mode(self); + while (tmp) { + modest_progress_object_add_operation ( + MODEST_PROGRESS_OBJECT (tmp->data), + mail_op); + tmp = g_slist_next (tmp); + } } } + g_object_unref (source); } static void @@ -2181,11 +2563,10 @@ on_mail_operation_finished (ModestMailOperation *mail_op, op_type = modest_mail_operation_get_type_operation (mail_op); tmp = priv->progress_widgets; - if (op_type == MODEST_MAIL_OPERATION_TYPE_RECEIVE || op_type == MODEST_MAIL_OPERATION_TYPE_OPEN ) { + if (op_type == MODEST_MAIL_OPERATION_TYPE_RECEIVE ) { while (tmp) { - modest_progress_object_remove_operation ( - MODEST_PROGRESS_OBJECT (tmp->data), - mail_op); + modest_progress_object_remove_operation (MODEST_PROGRESS_OBJECT (tmp->data), + mail_op); tmp = g_slist_next (tmp); } @@ -2193,6 +2574,14 @@ on_mail_operation_finished (ModestMailOperation *mail_op, if (observers_empty (self)) { set_toolbar_mode (self, TOOLBAR_MODE_NORMAL); } + + /* Update dimming rules. We have to do this right here + and not in view_msg_cb because at that point the + transfer mode is still enabled so the dimming rule + won't let the user delete the message that has been + readed for example */ + modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (self)); + modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (self)); } } @@ -2231,11 +2620,11 @@ on_queue_changed (ModestMailOperationQueue *queue, } } -GList * +TnyList * modest_msg_view_window_get_attachments (ModestMsgViewWindow *win) { ModestMsgViewWindowPrivate *priv; - GList *selected_attachments = NULL; + TnyList *selected_attachments = NULL; g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), NULL); priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (win); @@ -2245,14 +2634,69 @@ modest_msg_view_window_get_attachments (ModestMsgViewWindow *win) return selected_attachments; } +typedef struct { + gchar *filepath; + GtkWidget *banner; + guint banner_idle_id; +} DecodeAsyncHelper; + +static gboolean +decode_async_banner_idle (gpointer user_data) +{ + DecodeAsyncHelper *helper = (DecodeAsyncHelper *) user_data; + + helper->banner_idle_id = 0; + helper->banner = hildon_banner_show_animation (NULL, NULL, _("mail_me_opening")); + g_object_ref (helper->banner); + + return FALSE; +} + +static void +on_decode_to_stream_async_handler (TnyMimePart *mime_part, + gboolean cancelled, + TnyStream *stream, + GError *err, + gpointer user_data) +{ + DecodeAsyncHelper *helper = (DecodeAsyncHelper *) user_data; + + if (helper->banner_idle_id > 0) { + g_source_remove (helper->banner_idle_id); + helper->banner_idle_id = 0; + } + if (helper->banner) { + gtk_widget_destroy (helper->banner); + } + if (cancelled || err) { + modest_platform_information_banner (NULL, NULL, + _("mail_ib_file_operation_failed")); + goto free; + } + + /* make the file read-only */ + g_chmod(helper->filepath, 0444); + + /* Activate the file */ + modest_platform_activate_file (helper->filepath, modest_tny_mime_part_get_content_type (mime_part)); + + free: + /* Frees */ + g_free (helper->filepath); + g_object_unref (helper->banner); + g_slice_free (DecodeAsyncHelper, helper); +} + void -modest_msg_view_window_view_attachment (ModestMsgViewWindow *window, TnyMimePart *mime_part) +modest_msg_view_window_view_attachment (ModestMsgViewWindow *window, + TnyMimePart *mime_part) { ModestMsgViewWindowPrivate *priv; const gchar *msg_uid; gchar *attachment_uid = NULL; gint attachment_index = 0; - GList *attachments; + TnyList *attachments; + TnyMimePart *window_msg; g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window)); g_return_if_fail (TNY_IS_MIME_PART (mime_part) || (mime_part == NULL)); @@ -2260,8 +2704,8 @@ modest_msg_view_window_view_attachment (ModestMsgViewWindow *window, TnyMimePart msg_uid = modest_msg_view_window_get_message_uid (MODEST_MSG_VIEW_WINDOW (window)); attachments = modest_msg_view_get_attachments (MODEST_MSG_VIEW (priv->msg_view)); - attachment_index = g_list_index (attachments, mime_part); - g_list_free (attachments); + attachment_index = modest_list_index (attachments, (GObject *) mime_part); + g_object_unref (attachments); if (msg_uid && attachment_index >= 0) { attachment_uid = g_strdup_printf ("%s/%d", msg_uid, attachment_index); @@ -2269,18 +2713,20 @@ modest_msg_view_window_view_attachment (ModestMsgViewWindow *window, TnyMimePart if (mime_part == NULL) { gboolean error = FALSE; - GList *selected_attachments = modest_msg_view_get_selected_attachments (MODEST_MSG_VIEW (priv->msg_view)); - if (selected_attachments == NULL) { + TnyList *selected_attachments = modest_msg_view_get_selected_attachments (MODEST_MSG_VIEW (priv->msg_view)); + if (selected_attachments == NULL || tny_list_get_length (selected_attachments) == 0) { error = TRUE; - } else if (g_list_length (selected_attachments) > 1) { + } else if (tny_list_get_length (selected_attachments) > 1) { hildon_banner_show_information (NULL, NULL, _("mcen_ib_unable_to_display_more")); error = TRUE; } else { - mime_part = (TnyMimePart *) selected_attachments->data; - g_object_ref (mime_part); + TnyIterator *iter; + iter = tny_list_create_iterator (selected_attachments); + mime_part = (TnyMimePart *) tny_iterator_get_current (iter); + g_object_unref (iter); } - g_list_foreach (selected_attachments, (GFunc) g_object_unref, NULL); - g_list_free (selected_attachments); + if (selected_attachments) + g_object_unref (selected_attachments); if (error) return; @@ -2293,35 +2739,82 @@ modest_msg_view_window_view_attachment (ModestMsgViewWindow *window, TnyMimePart return; } - if (!TNY_IS_MSG (mime_part)) { + /* we also check for mime_part == priv->msg, as this means it's a direct attachment + * shown as attachment, so it should behave as a file */ + window_msg = TNY_MIME_PART (tny_msg_view_get_msg (TNY_MSG_VIEW (priv->msg_view))); + if ((!modest_tny_mime_part_is_msg (mime_part) && tny_mime_part_get_filename (mime_part)) || + mime_part == window_msg) { gchar *filepath = NULL; const gchar *att_filename = tny_mime_part_get_filename (mime_part); - const gchar *content_type; + gboolean show_error_banner = FALSE; TnyFsStream *temp_stream = NULL; temp_stream = modest_utils_create_temp_stream (att_filename, attachment_uid, &filepath); if (temp_stream != NULL) { - content_type = tny_mime_part_get_content_type (mime_part); - tny_mime_part_decode_to_stream (mime_part, TNY_STREAM (temp_stream)); - - /* make the file read-only */ - if (g_chmod(filepath, 0444) != 0) - g_warning ("%s: failed to set file '%s' to read-only: %s", - __FUNCTION__, filepath, strerror(errno)); - - modest_platform_activate_file (filepath, content_type); + DecodeAsyncHelper *helper = g_slice_new (DecodeAsyncHelper); + helper->filepath = g_strdup (filepath); + helper->banner = NULL; + helper->banner_idle_id = g_timeout_add (1000, decode_async_banner_idle, helper); + tny_mime_part_decode_to_stream_async (mime_part, TNY_STREAM (temp_stream), + on_decode_to_stream_async_handler, + NULL, + helper); g_object_unref (temp_stream); - g_free (filepath); /* NOTE: files in the temporary area will be automatically * cleaned after some time if they are no longer in use */ - } else if (filepath != NULL) { - /* the file may already exist but it isn't writable, - * let's try to open it anyway */ - content_type = tny_mime_part_get_content_type (mime_part); - modest_platform_activate_file (filepath, content_type); + } else { + if (filepath) { + const gchar *content_type; + /* the file may already exist but it isn't writable, + * let's try to open it anyway */ + content_type = modest_tny_mime_part_get_content_type (mime_part); + modest_platform_activate_file (filepath, content_type); + } else { + g_warning ("%s: modest_utils_create_temp_stream failed", __FUNCTION__); + show_error_banner = TRUE; + } + } + if (filepath) g_free (filepath); + if (show_error_banner) + modest_platform_information_banner (NULL, NULL, _("mail_ib_file_operation_failed")); + } else if (!modest_tny_mime_part_is_msg (mime_part)) { + ModestWindowMgr *mgr; + ModestWindow *msg_win = NULL; + TnyMsg *current_msg; + gboolean found; + TnyHeader *header; + + current_msg = modest_msg_view_window_get_message (MODEST_MSG_VIEW_WINDOW (window)); + mgr = modest_runtime_get_window_mgr (); + header = tny_msg_get_header (TNY_MSG (current_msg)); + found = modest_window_mgr_find_registered_message_uid (mgr, + attachment_uid, + &msg_win); + + if (found) { + g_debug ("window for this body is already being created"); + } else { + + /* it's not found, so create a new window for it */ + modest_window_mgr_register_header (mgr, header, attachment_uid); /* register the uid before building the window */ + gchar *account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (window))); + const gchar *mailbox = modest_window_get_active_mailbox (MODEST_WINDOW (window)); + if (!account) + account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ()); + + msg_win = modest_msg_view_window_new_with_other_body (TNY_MSG (current_msg), TNY_MIME_PART (mime_part), + account, mailbox, attachment_uid); + + modest_window_set_zoom (MODEST_WINDOW (msg_win), + modest_window_get_zoom (MODEST_WINDOW (window))); + if (modest_window_mgr_register_window (mgr, msg_win, MODEST_WINDOW (window))) + gtk_widget_show_all (GTK_WIDGET (msg_win)); + else + gtk_widget_destroy (GTK_WIDGET (msg_win)); } + g_object_unref (current_msg); } else { /* message attachment */ TnyHeader *header = NULL; @@ -2339,21 +2832,22 @@ modest_msg_view_window_view_attachment (ModestMsgViewWindow *window, TnyMimePart else /* if it's found, but there is no msg_win, it's probably in the process of being created; * thus, we don't do anything */ - g_warning ("window for is already being created"); + g_debug ("window for is already being created"); } else { /* it's not found, so create a new window for it */ modest_window_mgr_register_header (mgr, header, attachment_uid); /* register the uid before building the window */ gchar *account = g_strdup (modest_window_get_active_account (MODEST_WINDOW (window))); if (!account) account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ()); - msg_win = modest_msg_view_window_new_for_attachment (TNY_MSG (mime_part), account, attachment_uid); + msg_win = modest_msg_view_window_new_for_attachment (TNY_MSG (mime_part), account, + NULL, attachment_uid); modest_window_set_zoom (MODEST_WINDOW (msg_win), modest_window_get_zoom (MODEST_WINDOW (window))); - modest_window_mgr_register_window (mgr, msg_win); - gtk_window_set_transient_for (GTK_WINDOW (msg_win), GTK_WINDOW (window)); + modest_window_mgr_register_window (mgr, msg_win, MODEST_WINDOW (window)); gtk_widget_show_all (GTK_WIDGET (msg_win)); } } + g_object_unref (window_msg); g_object_unref (mime_part); } @@ -2367,13 +2861,13 @@ typedef struct { GList *pairs; GtkWidget *banner; - gboolean result; + GnomeVFSResult result; } SaveMimePartInfo; static void save_mime_part_info_free (SaveMimePartInfo *info, gboolean with_struct); static gboolean idle_save_mime_part_show_result (SaveMimePartInfo *info); static gpointer save_mime_part_to_file (SaveMimePartInfo *info); -static void save_mime_parts_to_file_with_checks (SaveMimePartInfo *info); +static void save_mime_parts_to_file_with_checks (GtkWindow *parent, SaveMimePartInfo *info); static void save_mime_part_info_free (SaveMimePartInfo *info, gboolean with_struct) @@ -2390,7 +2884,6 @@ save_mime_part_info_free (SaveMimePartInfo *info, gboolean with_struct) info->pairs = NULL; if (with_struct) { gtk_widget_destroy (info->banner); - g_object_unref (info->banner); g_slice_free (SaveMimePartInfo, info); } } @@ -2401,18 +2894,19 @@ idle_save_mime_part_show_result (SaveMimePartInfo *info) if (info->pairs != NULL) { save_mime_part_to_file (info); } else { - gboolean result; - result = info->result; - /* This is a GDK lock because we are an idle callback and * hildon_banner_show_information is or does Gtk+ code */ gdk_threads_enter (); /* CHECKED */ save_mime_part_info_free (info, TRUE); - if (result) { + if (info->result == GNOME_VFS_OK) { hildon_banner_show_information (NULL, NULL, _CS("sfil_ib_saved")); + } else if (info->result == GNOME_VFS_ERROR_NO_SPACE) { + hildon_banner_show_information (NULL, NULL, + _KR("cerm_device_memory_full")); } else { - hildon_banner_show_information (NULL, NULL, _("mail_ib_file_operation_failed")); + hildon_banner_show_information (NULL, NULL, + _("mail_ib_file_operation_failed")); } gdk_threads_leave (); /* CHECKED */ } @@ -2423,23 +2917,26 @@ idle_save_mime_part_show_result (SaveMimePartInfo *info) static gpointer save_mime_part_to_file (SaveMimePartInfo *info) { - GnomeVFSResult result; GnomeVFSHandle *handle; TnyStream *stream; SaveMimePartPair *pair = (SaveMimePartPair *) info->pairs->data; - result = gnome_vfs_create (&handle, pair->filename, GNOME_VFS_OPEN_WRITE, FALSE, 0644); - if (result == GNOME_VFS_OK) { + info->result = gnome_vfs_create (&handle, pair->filename, GNOME_VFS_OPEN_WRITE, FALSE, 0644); + if (info->result == GNOME_VFS_OK) { + GError *error = NULL; stream = tny_vfs_stream_new (handle); - tny_mime_part_decode_to_stream (pair->part, stream); + if (tny_mime_part_decode_to_stream (pair->part, stream, &error) < 0) { + g_warning ("modest: could not save attachment %s: %d (%s)\n", pair->filename, error?error->code:-1, error?error->message:"Unknown error"); + + info->result = GNOME_VFS_ERROR_IO; + } g_object_unref (G_OBJECT (stream)); g_object_unref (pair->part); g_slice_free (SaveMimePartPair, pair); info->pairs = g_list_delete_link (info->pairs, info->pairs); - info->result = TRUE; } else { + g_warning ("modest: could not create save attachment %s: %s\n", pair->filename, gnome_vfs_result_to_string (info->result)); save_mime_part_info_free (info, FALSE); - info->result = FALSE; } g_idle_add ((GSourceFunc) idle_save_mime_part_show_result, info); @@ -2447,7 +2944,7 @@ save_mime_part_to_file (SaveMimePartInfo *info) } static void -save_mime_parts_to_file_with_checks (SaveMimePartInfo *info) +save_mime_parts_to_file_with_checks (GtkWindow *parent, SaveMimePartInfo *info) { gboolean is_ok = TRUE; gint replaced_files = 0; @@ -2461,14 +2958,12 @@ save_mime_parts_to_file_with_checks (SaveMimePartInfo *info) } } if (replaced_files) { - GtkWidget *confirm_overwrite_dialog; + gint response; const gchar *message = (replaced_files == 1) ? _FM("docm_nc_replace_file") : _FM("docm_nc_replace_multiple"); - confirm_overwrite_dialog = hildon_note_new_confirmation (NULL, message); - if (gtk_dialog_run (GTK_DIALOG (confirm_overwrite_dialog)) != GTK_RESPONSE_OK) { + response = modest_platform_run_confirmation_dialog (parent, message); + if (response != GTK_RESPONSE_OK) is_ok = FALSE; - } - gtk_widget_destroy (confirm_overwrite_dialog); } if (!is_ok) { @@ -2476,50 +2971,120 @@ save_mime_parts_to_file_with_checks (SaveMimePartInfo *info) } else { GtkWidget *banner = hildon_banner_show_animation (NULL, NULL, _CS("sfil_ib_saving")); - info->banner = g_object_ref (banner); + info->banner = banner; g_thread_create ((GThreadFunc)save_mime_part_to_file, info, FALSE, NULL); - g_object_unref (banner); } } +static void +save_attachments_response (GtkDialog *dialog, + gint arg1, + gpointer user_data) +{ + TnyList *mime_parts; + gchar *chooser_uri; + GList *files_to_save = NULL; + + mime_parts = TNY_LIST (user_data); + + if (arg1 != GTK_RESPONSE_OK) + goto end; + + chooser_uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog)); + + if (!modest_utils_folder_writable (chooser_uri)) { + hildon_banner_show_information + (NULL, NULL, _FM("sfil_ib_readonly_location")); + } else { + TnyIterator *iter; + + iter = tny_list_create_iterator (mime_parts); + while (!tny_iterator_is_done (iter)) { + TnyMimePart *mime_part = (TnyMimePart *) tny_iterator_get_current (iter); + + if ((modest_tny_mime_part_is_attachment_for_modest (mime_part)) && + !tny_mime_part_is_purged (mime_part) && + (tny_mime_part_get_filename (mime_part) != NULL)) { + SaveMimePartPair *pair; + + pair = g_slice_new0 (SaveMimePartPair); + + if (tny_list_get_length (mime_parts) > 1) { + gchar *escaped = + gnome_vfs_escape_slashes (tny_mime_part_get_filename (mime_part)); + pair->filename = g_build_filename (chooser_uri, escaped, NULL); + g_free (escaped); + } else { + pair->filename = g_strdup (chooser_uri); + } + pair->part = mime_part; + files_to_save = g_list_prepend (files_to_save, pair); + } + tny_iterator_next (iter); + } + g_object_unref (iter); + } + g_free (chooser_uri); + + if (files_to_save != NULL) { + SaveMimePartInfo *info = g_slice_new0 (SaveMimePartInfo); + info->pairs = files_to_save; + info->result = TRUE; + save_mime_parts_to_file_with_checks ((GtkWindow*) dialog, info); + } + + end: + /* Free and close the dialog */ + g_object_unref (mime_parts); + gtk_widget_destroy (GTK_WIDGET (dialog)); +} void -modest_msg_view_window_save_attachments (ModestMsgViewWindow *window, GList *mime_parts) +modest_msg_view_window_save_attachments (ModestMsgViewWindow *window, TnyList *mime_parts) { - gboolean clean_list = FALSE; ModestMsgViewWindowPrivate *priv; - GList *files_to_save = NULL; GtkWidget *save_dialog = NULL; gchar *folder = NULL; - gboolean canceled = FALSE; - const gchar *filename = NULL; + gchar *filename = NULL; gchar *save_multiple_str = NULL; + TnyMsg *window_msg; g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window)); priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); if (mime_parts == NULL) { mime_parts = modest_msg_view_get_selected_attachments (MODEST_MSG_VIEW (priv->msg_view)); - if (mime_parts == NULL) + if (mime_parts == NULL || tny_list_get_length (mime_parts) == 0) return; - clean_list = TRUE; + } else { + g_object_ref (mime_parts); } + window_msg = tny_msg_view_get_msg (TNY_MSG_VIEW (priv->msg_view)); /* prepare dialog */ - if (mime_parts->next == NULL) { + if (tny_list_get_length (mime_parts) == 1) { + TnyIterator *iter; /* only one attachment selected */ - TnyMimePart *mime_part = (TnyMimePart *) mime_parts->data; - if (!TNY_IS_MSG (mime_part) && tny_mime_part_is_attachment (mime_part)) { - filename = tny_mime_part_get_filename (mime_part); + iter = tny_list_create_iterator (mime_parts); + TnyMimePart *mime_part = (TnyMimePart *) tny_iterator_get_current (iter); + g_object_unref (iter); + if (!modest_tny_mime_part_is_msg (mime_part) && + modest_tny_mime_part_is_attachment_for_modest (mime_part) && + !tny_mime_part_is_purged (mime_part)) { + filename = g_strdup (tny_mime_part_get_filename (mime_part)); } else { + /* TODO: show any error? */ g_warning ("Tried to save a non-file attachment"); - canceled = TRUE; + g_object_unref (mime_parts); + return; } + g_object_unref (mime_part); } else { save_multiple_str = g_strdup_printf (_FM("sfil_va_number_of_objects_attachments"), - g_list_length (mime_parts)); + tny_list_get_length (mime_parts)); } + g_object_unref (window_msg); save_dialog = hildon_file_chooser_dialog_new (GTK_WINDOW (window), GTK_FILE_CHOOSER_ACTION_SAVE); @@ -2530,64 +3095,25 @@ modest_msg_view_window_save_attachments (ModestMsgViewWindow *window, GList *mim g_free (folder); /* set filename */ - if (filename != NULL) + if (filename) { gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (save_dialog), filename); + g_free (filename); + } /* if multiple, set multiple string */ if (save_multiple_str) { g_object_set (G_OBJECT (save_dialog), "save-multiple", save_multiple_str, NULL); - } - - /* show dialog */ - if (gtk_dialog_run (GTK_DIALOG (save_dialog)) == GTK_RESPONSE_OK) { - gchar *chooser_uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (save_dialog)); - - if (!modest_utils_folder_writable (chooser_uri)) { - hildon_banner_show_information - (NULL, NULL, dgettext("hildon-fm", "sfil_ib_readonly_location")); - } else { - GList *node = NULL; - - for (node = mime_parts; node != NULL; node = g_list_next (node)) { - TnyMimePart *mime_part = (TnyMimePart *) node->data; - - if (tny_mime_part_is_attachment (mime_part)) { - SaveMimePartPair *pair; - - if ((mime_parts->next != NULL) && - (tny_mime_part_get_filename (mime_part) == NULL)) - continue; - - pair = g_slice_new0 (SaveMimePartPair); - if (mime_parts->next == NULL) { - pair->filename = g_strdup (chooser_uri); - } else { - pair->filename = - g_build_filename (chooser_uri, - tny_mime_part_get_filename (mime_part), NULL); - } - pair->part = g_object_ref (mime_part); - files_to_save = g_list_prepend (files_to_save, pair); - } - } - } - g_free (chooser_uri); + gtk_window_set_title (GTK_WINDOW (save_dialog), _FM("sfil_ti_save_objects_files")); } - gtk_widget_destroy (save_dialog); + /* We must run this asynchronously, because the hildon dialog + performs a gtk_dialog_run by itself which leads to gdk + deadlocks */ + g_signal_connect (save_dialog, "response", + G_CALLBACK (save_attachments_response), mime_parts); - if (clean_list) { - g_list_foreach (mime_parts, (GFunc) g_object_unref, NULL); - g_list_free (mime_parts); - } - - if (files_to_save != NULL) { - SaveMimePartInfo *info = g_slice_new0 (SaveMimePartInfo); - info->pairs = files_to_save; - info->result = TRUE; - save_mime_parts_to_file_with_checks (info); - } + gtk_widget_show_all (save_dialog); } static gboolean @@ -2616,12 +3142,12 @@ void modest_msg_view_window_remove_attachments (ModestMsgViewWindow *window, gboolean get_all) { ModestMsgViewWindowPrivate *priv; - GList *mime_parts = NULL, *node; + TnyList *mime_parts = NULL; gchar *confirmation_message; gint response; gint n_attachments; TnyMsg *msg; -/* TnyFolder *folder; */ + TnyIterator *iter; g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window)); priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); @@ -2632,37 +3158,43 @@ modest_msg_view_window_remove_attachments (ModestMsgViewWindow *window, gboolean mime_parts = modest_msg_view_get_selected_attachments (MODEST_MSG_VIEW (priv->msg_view)); /* Remove already purged messages from mime parts list */ - node = mime_parts; - while (node != NULL) { - TnyMimePart *part = TNY_MIME_PART (node->data); + iter = tny_list_create_iterator (mime_parts); + while (!tny_iterator_is_done (iter)) { + TnyMimePart *part = TNY_MIME_PART (tny_iterator_get_current (iter)); + tny_iterator_next (iter); if (tny_mime_part_is_purged (part)) { - GList *deleted_node = node; - node = g_list_next (node); - g_object_unref (part); - mime_parts = g_list_delete_link (mime_parts, deleted_node); - } else { - node = g_list_next (node); + tny_list_remove (mime_parts, (GObject *) part); } + g_object_unref (part); } + g_object_unref (iter); - if (mime_parts == NULL) + if (tny_list_get_length (mime_parts) == 0) { + g_object_unref (mime_parts); return; + } - n_attachments = g_list_length (mime_parts); + n_attachments = tny_list_get_length (mime_parts); if (n_attachments == 1) { - const gchar *filename; + gchar *filename; + TnyMimePart *part; - if (TNY_IS_MSG (mime_parts->data)) { + iter = tny_list_create_iterator (mime_parts); + part = (TnyMimePart *) tny_iterator_get_current (iter); + g_object_unref (iter); + if (modest_tny_mime_part_is_msg (part)) { TnyHeader *header; - header = tny_msg_get_header (TNY_MSG (mime_parts->data)); - filename = tny_header_get_subject (header); + header = tny_msg_get_header (TNY_MSG (part)); + filename = tny_header_dup_subject (header); g_object_unref (header); if (filename == NULL) - filename = _("mail_va_no_subject"); + filename = g_strdup (_("mail_va_no_subject")); } else { - filename = tny_mime_part_get_filename (TNY_MIME_PART (mime_parts->data)); + filename = g_strdup (tny_mime_part_get_filename (TNY_MIME_PART (part))); } confirmation_message = g_strdup_printf (_("mcen_nc_purge_file_text"), filename); + g_free (filename); + g_object_unref (part); } else { confirmation_message = g_strdup_printf (ngettext("mcen_nc_purge_file_text", "mcen_nc_purge_files_text", @@ -2672,27 +3204,31 @@ modest_msg_view_window_remove_attachments (ModestMsgViewWindow *window, gboolean confirmation_message); g_free (confirmation_message); - if (response != GTK_RESPONSE_OK) + if (response != GTK_RESPONSE_OK) { + g_object_unref (mime_parts); return; + } priv->purge_timeout = g_timeout_add (2000, show_remove_attachment_information, window); -/* folder = tny_msg_get_folder (msg); */ -/* tny_msg_uncache_attachments (msg); */ -/* tny_folder_refresh (folder, NULL); */ -/* g_object_unref (folder); */ - for (node = mime_parts; node != NULL; node = g_list_next (node)) { - tny_mime_part_set_purged (TNY_MIME_PART (node->data)); -/* modest_msg_view_remove_attachment (MODEST_MSG_VIEW (priv->msg_view), node->data); */ + iter = tny_list_create_iterator (mime_parts); + while (!tny_iterator_is_done (iter)) { + TnyMimePart *part; + + part = (TnyMimePart *) tny_iterator_get_current (iter); + tny_mime_part_set_purged (TNY_MIME_PART (part)); + g_object_unref (part); + tny_iterator_next (iter); } + g_object_unref (iter); msg = tny_msg_view_get_msg (TNY_MSG_VIEW (priv->msg_view)); tny_msg_view_clear (TNY_MSG_VIEW (priv->msg_view)); tny_msg_rewrite_cache (msg); tny_msg_view_set_msg (TNY_MSG_VIEW (priv->msg_view), msg); + g_object_unref (msg); - g_list_foreach (mime_parts, (GFunc) g_object_unref, NULL); - g_list_free (mime_parts); + g_object_unref (mime_parts); if (priv->purge_timeout > 0) { g_source_remove (priv->purge_timeout); @@ -2715,18 +3251,29 @@ update_window_title (ModestMsgViewWindow *window) ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); TnyMsg *msg = NULL; TnyHeader *header = NULL; - const gchar *subject = NULL; + gchar *subject = NULL; msg = tny_msg_view_get_msg (TNY_MSG_VIEW (priv->msg_view)); - if (msg != NULL) { + if (priv->other_body) { + gchar *description; + + description = modest_tny_mime_part_get_header_value (priv->other_body, "Content-Description"); + if (description) { + g_strstrip (description); + subject = description; + } + } else if (msg != NULL) { header = tny_msg_get_header (msg); - subject = tny_header_get_subject (header); + subject = tny_header_dup_subject (header); + g_object_unref (header); g_object_unref (msg); } - if ((subject == NULL)||(subject[0] == '\0')) - subject = _("mail_va_no_subject"); + if ((subject == NULL)||(subject[0] == '\0')) { + g_free (subject); + subject = g_strdup (_("mail_va_no_subject")); + } gtk_window_set_title (GTK_WINDOW (window), subject); } @@ -2739,3 +3286,161 @@ static void on_move_focus (GtkWidget *widget, g_signal_stop_emission_by_name (G_OBJECT (widget), "move-focus"); } +static TnyStream * +fetch_image_open_stream (TnyStreamCache *self, gint64 *expected_size, gchar *uri) +{ + GnomeVFSResult result; + GnomeVFSHandle *handle = NULL; + GnomeVFSFileInfo *info = NULL; + TnyStream *stream; + + result = gnome_vfs_open (&handle, uri, GNOME_VFS_OPEN_READ); + if (result != GNOME_VFS_OK) { + *expected_size = 0; + return NULL; + } + + info = gnome_vfs_file_info_new (); + result = gnome_vfs_get_file_info_from_handle (handle, info, GNOME_VFS_FILE_INFO_DEFAULT); + if (result != GNOME_VFS_OK || ! (info->valid_fields & GNOME_VFS_FILE_INFO_FIELDS_SIZE)) { + /* We put a "safe" default size for going to cache */ + *expected_size = (300*1024); + } else { + *expected_size = info->size; + } + gnome_vfs_file_info_unref (info); + + stream = tny_vfs_stream_new (handle); + + return stream; + +} + +typedef struct { + gchar *uri; + gchar *cache_id; + TnyStream *output_stream; + GtkWidget *msg_view; +} FetchImageData; + +gboolean +on_fetch_image_idle_refresh_view (gpointer userdata) +{ + + FetchImageData *fidata = (FetchImageData *) userdata; + g_debug ("REFRESH VIEW"); + if (GTK_WIDGET_DRAWABLE (fidata->msg_view)) { + g_debug ("QUEUING DRAW"); + gtk_widget_queue_draw (fidata->msg_view); + } + g_object_unref (fidata->msg_view); + g_slice_free (FetchImageData, fidata); + return FALSE; +} + +static gpointer +on_fetch_image_thread (gpointer userdata) +{ + FetchImageData *fidata = (FetchImageData *) userdata; + TnyStreamCache *cache; + TnyStream *cache_stream; + + cache = modest_runtime_get_images_cache (); + cache_stream = tny_stream_cache_get_stream (cache, fidata->cache_id, (TnyStreamCacheOpenStreamFetcher) fetch_image_open_stream, (gpointer) fidata->uri); + g_free (fidata->cache_id); + g_free (fidata->uri); + + if (cache_stream != NULL) { + tny_stream_write_to_stream (cache_stream, fidata->output_stream); + tny_stream_close (cache_stream); + g_object_unref (cache_stream); + } + + tny_stream_close (fidata->output_stream); + g_object_unref (fidata->output_stream); + + + gdk_threads_enter (); + g_idle_add (on_fetch_image_idle_refresh_view, fidata); + gdk_threads_leave (); + + return NULL; +} + +static gboolean +on_fetch_image (ModestMsgView *msgview, + const gchar *uri, + TnyStream *stream, + ModestMsgViewWindow *window) +{ + const gchar *current_account; + ModestMsgViewWindowPrivate *priv; + FetchImageData *fidata; + + priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); + + current_account = modest_window_get_active_account (MODEST_WINDOW (window)); + + fidata = g_slice_new0 (FetchImageData); + fidata->msg_view = g_object_ref (msgview); + fidata->uri = g_strdup (uri); + fidata->cache_id = modest_images_cache_get_id (current_account, uri); + fidata->output_stream = g_object_ref (stream); + + if (g_thread_create (on_fetch_image_thread, fidata, FALSE, NULL) == NULL) { + g_object_unref (fidata->output_stream); + g_free (fidata->cache_id); + g_free (fidata->uri); + g_object_unref (fidata->msg_view); + g_slice_free (FetchImageData, fidata); + tny_stream_close (stream); + return FALSE; + } + + return TRUE;; +} + +void +modest_msg_view_window_add_to_contacts (ModestMsgViewWindow *self) +{ + modest_ui_actions_on_add_to_contacts (NULL, MODEST_WINDOW (self)); +} + + +void +modest_msg_view_window_fetch_images (ModestMsgViewWindow *self) +{ + ModestMsgViewWindowPrivate *priv; + priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self); + + modest_msg_view_request_fetch_images (MODEST_MSG_VIEW (priv->msg_view)); +} + +gboolean +modest_msg_view_window_has_blocked_external_images (ModestMsgViewWindow *self) +{ + ModestMsgViewWindowPrivate *priv; + priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self); + + g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self), FALSE); + + return modest_msg_view_has_blocked_external_images (MODEST_MSG_VIEW (priv->msg_view)); +} + +void +modest_msg_view_window_reload (ModestMsgViewWindow *self) +{ + ModestMsgViewWindowPrivate *priv; + TnyHeader *header; + + g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self)); + + priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self); + header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (self)); + + if (!message_reader (self, priv, header, NULL, NULL, priv->row_reference)) { + g_warning ("Shouldn't happen, trying to reload a message failed"); + } + + g_object_unref (header); +}