X-Git-Url: http://git.maemo.org/git/?a=blobdiff_plain;f=src%2Fmaemo%2Fmodest-msg-view-window.c;h=59c1651d674c0669e68edabd25bcd316a60f7d96;hb=5619278be034c3032ce89fc8ce0a2d52ef351e7b;hp=5db77240a22cf4c889634ff01287907c3d83870c;hpb=e88463756e12926277a032f2db233bd90b4694b0;p=modest diff --git a/src/maemo/modest-msg-view-window.c b/src/maemo/modest-msg-view-window.c index 5db7724..59c1651 100644 --- a/src/maemo/modest-msg-view-window.c +++ b/src/maemo/modest-msg-view-window.c @@ -53,11 +53,14 @@ #include #include "modest-ui-dimming-manager.h" #include +#include #define DEFAULT_FOLDER "MyDocs/.documents" static void modest_msg_view_window_class_init (ModestMsgViewWindowClass *klass); static void modest_msg_view_window_init (ModestMsgViewWindow *obj); +static void modest_header_view_observer_init( + ModestHeaderViewObserverIface *iface_class); static void modest_msg_view_window_finalize (GObject *obj); static void modest_msg_view_window_toggle_find_toolbar (GtkToggleAction *obj, gpointer data); @@ -66,8 +69,9 @@ static void modest_msg_view_window_find_toolbar_close (GtkWidget *widget, static void modest_msg_view_window_find_toolbar_search (GtkWidget *widget, ModestMsgViewWindow *obj); -static void modest_msg_view_window_set_zoom (ModestWindow *window, - gdouble zoom); +static void modest_msg_view_window_disconnect_signals (ModestWindow *self); +static void modest_msg_view_window_set_zoom (ModestWindow *window, + gdouble zoom); static gdouble modest_msg_view_window_get_zoom (ModestWindow *window); static gboolean modest_msg_view_window_zoom_minus (ModestWindow *window); static gboolean modest_msg_view_window_zoom_plus (ModestWindow *window); @@ -87,24 +91,59 @@ 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 cancel_progressbar (GtkToolButton *toolbutton, + ModestMsgViewWindow *self); + +static void on_queue_changed (ModestMailOperationQueue *queue, + ModestMailOperation *mail_op, + ModestMailOperationQueueNotification type, + ModestMsgViewWindow *self); + +static void on_account_removed (TnyAccountStore *account_store, + TnyAccount *account, + gpointer user_data); + +static void view_msg_cb (ModestMailOperation *mail_op, + TnyHeader *header, + TnyMsg *msg, + gpointer user_data); + +static void set_toolbar_mode (ModestMsgViewWindow *self, + ModestToolBarModes mode); -static void cancel_progressbar (GtkToolButton *toolbutton, - ModestMsgViewWindow *self); - -static void on_queue_changed (ModestMailOperationQueue *queue, - ModestMailOperation *mail_op, - ModestMailOperationQueueNotification type, - ModestMsgViewWindow *self); - -static void view_msg_cb (ModestMailOperation *mail_op, TnyHeader *header, TnyMsg *msg, gpointer user_data); - -static void set_toolbar_mode (ModestMsgViewWindow *self, - ModestToolBarModes mode); +static void update_window_title (ModestMsgViewWindow *window); static gboolean set_toolbar_transfer_mode (ModestMsgViewWindow *self); -static void update_window_title (ModestMsgViewWindow *window); - /* list my signals */ enum { @@ -113,7 +152,7 @@ enum { }; static const GtkToggleActionEntry msg_view_toggle_action_entries [] = { - { "FindInMessage", GTK_STOCK_FIND, N_("qgn_toolb_gene_find"), NULL, NULL, G_CALLBACK (modest_msg_view_window_toggle_find_toolbar), FALSE }, + { "FindInMessage", MODEST_TOOLBAR_ICON_FIND, N_("qgn_toolb_gene_find"), NULL, NULL, G_CALLBACK (modest_msg_view_window_toggle_find_toolbar), FALSE }, { "ToolsFindInMessage", NULL, N_("mcen_me_viewer_find"), NULL, NULL, G_CALLBACK (modest_msg_view_window_toggle_find_toolbar), FALSE }, }; @@ -148,11 +187,28 @@ struct _ModestMsgViewWindowPrivate { /* Optimized view enabled */ gboolean optimized_view; + /* Whether this was created via the *_new_for_search_result() function. */ + gboolean is_search_result; + + /* A reference to the @model of the header view + * to allow selecting previous/next messages, + * if the message is currently selected in the header view. + */ + const gchar *header_folder_id; GtkTreeModel *header_model; GtkTreeRowReference *row_reference; + GtkTreeRowReference *next_row_reference; + + gulong clipboard_change_handler; + gulong queue_change_handler; + gulong account_removed_handler; + gulong row_changed_handler; + gulong row_deleted_handler; + gulong row_inserted_handler; + gulong rows_reordered_handler; - guint clipboard_change_handler; - guint queue_change_handler; + guint purge_timeout; + GtkWidget *remove_attachment_banner; guint progress_bar_timeout; @@ -188,6 +244,17 @@ modest_msg_view_window_get_type (void) my_type = g_type_register_static (MODEST_TYPE_WINDOW, "ModestMsgViewWindow", &my_info, 0); + + static const GInterfaceInfo modest_header_view_observer_info = + { + (GInterfaceInitFunc) modest_header_view_observer_init, + NULL, /* interface_finalize */ + NULL /* interface_data */ + }; + + g_type_add_interface_static (my_type, + MODEST_TYPE_HEADER_VIEW_OBSERVER, + &modest_header_view_observer_info); } return my_type; } @@ -225,6 +292,7 @@ modest_msg_view_window_class_init (ModestMsgViewWindowClass *klass) modest_window_class->zoom_minus_func = modest_msg_view_window_zoom_minus; modest_window_class->zoom_plus_func = modest_msg_view_window_zoom_plus; 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)); @@ -240,19 +308,36 @@ modest_msg_view_window_class_init (ModestMsgViewWindowClass *klass) G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_POINTER); } +static void modest_header_view_observer_init( + ModestHeaderViewObserverIface *iface_class) +{ + iface_class->update_func = modest_msg_view_window_update_model_replaced; +} + static void modest_msg_view_window_init (ModestMsgViewWindow *obj) { ModestMsgViewWindowPrivate *priv; priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(obj); + priv->is_search_result = FALSE; + priv->msg_view = NULL; priv->header_model = NULL; + priv->header_folder_id = NULL; priv->clipboard_change_handler = 0; + priv->queue_change_handler = 0; + priv->account_removed_handler = 0; + priv->row_changed_handler = 0; + priv->row_deleted_handler = 0; + priv->row_inserted_handler = 0; + priv->rows_reordered_handler = 0; priv->current_toolbar_mode = TOOLBAR_MODE_NORMAL; priv->optimized_view = FALSE; priv->progress_bar_timeout = 0; + priv->purge_timeout = 0; + priv->remove_attachment_banner = NULL; priv->msg_uid = NULL; } @@ -412,22 +497,86 @@ init_window (ModestMsgViewWindow *obj, TnyMsg *msg) priv->main_scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->main_scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (priv->main_scroll), GTK_SHADOW_NONE); + modest_maemo_set_thumbable_scrollbar (GTK_SCROLLED_WINDOW(priv->main_scroll), TRUE); gtk_container_add (GTK_CONTAINER (priv->main_scroll), priv->msg_view); gtk_box_pack_start (GTK_BOX(main_vbox), priv->main_scroll, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER(obj), main_vbox); priv->find_toolbar = hildon_find_toolbar_new (NULL); + hildon_window_add_toolbar (HILDON_WINDOW (obj), GTK_TOOLBAR (priv->find_toolbar)); gtk_widget_set_no_show_all (priv->find_toolbar, TRUE); g_signal_connect (G_OBJECT (priv->find_toolbar), "close", G_CALLBACK (modest_msg_view_window_find_toolbar_close), obj); g_signal_connect (G_OBJECT (priv->find_toolbar), "search", G_CALLBACK (modest_msg_view_window_find_toolbar_search), obj); priv->clipboard_change_handler = g_signal_connect (G_OBJECT (gtk_clipboard_get (GDK_SELECTION_PRIMARY)), "owner-change", G_CALLBACK (modest_msg_view_window_clipboard_owner_change), obj); gtk_widget_show_all (GTK_WIDGET(main_vbox)); - gtk_box_pack_end (GTK_BOX (main_vbox), priv->find_toolbar, FALSE, FALSE, 0); +} -} +static void +modest_msg_view_window_disconnect_signals (ModestWindow *self) +{ + ModestMsgViewWindowPrivate *priv; + ModestHeaderView *header_view = NULL; + ModestMainWindow *main_window = NULL; + ModestWindowMgr *window_mgr = NULL; + priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self); + + if (g_signal_handler_is_connected (gtk_clipboard_get (GDK_SELECTION_PRIMARY), + priv->clipboard_change_handler)) + g_signal_handler_disconnect (gtk_clipboard_get (GDK_SELECTION_PRIMARY), + priv->clipboard_change_handler); + + if (g_signal_handler_is_connected (G_OBJECT (modest_runtime_get_mail_operation_queue ()), + priv->queue_change_handler)) + g_signal_handler_disconnect (G_OBJECT (modest_runtime_get_mail_operation_queue ()), + priv->queue_change_handler); + + if (g_signal_handler_is_connected (G_OBJECT (modest_runtime_get_account_store ()), + priv->account_removed_handler)) + g_signal_handler_disconnect (G_OBJECT (modest_runtime_get_account_store ()), + priv->account_removed_handler); + + 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); + + window_mgr = modest_runtime_get_window_mgr(); + g_assert(window_mgr != NULL); + + main_window = MODEST_MAIN_WINDOW( + modest_window_mgr_get_main_window(window_mgr)); + + if(main_window == NULL) + return; + + header_view = MODEST_HEADER_VIEW( + modest_main_window_get_child_widget( + main_window, MODEST_WIDGET_TYPE_HEADER_VIEW)); + + if (header_view == NULL) + return; + + modest_header_view_remove_observer(header_view, + MODEST_HEADER_VIEW_OBSERVER(self)); +} static void modest_msg_view_window_finalize (GObject *obj) @@ -435,31 +584,42 @@ modest_msg_view_window_finalize (GObject *obj) ModestMsgViewWindowPrivate *priv; priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (obj); - if (priv->clipboard_change_handler > 0) { - g_signal_handler_disconnect (gtk_clipboard_get (GDK_SELECTION_PRIMARY), priv->clipboard_change_handler); - priv->clipboard_change_handler = 0; - } - if (priv->queue_change_handler > 0) { - g_signal_handler_disconnect (G_OBJECT (modest_runtime_get_mail_operation_queue ()), priv->queue_change_handler); - priv->queue_change_handler = 0; - } + + /* Sanity check: shouldn't be needed, the window mgr should + call this function before */ + modest_msg_view_window_disconnect_signals (MODEST_WINDOW (obj)); + if (priv->header_model != NULL) { g_object_unref (priv->header_model); priv->header_model = NULL; } - /* disconnet operations queue observer */ - if (priv->progress_bar_timeout > 0) { g_source_remove (priv->progress_bar_timeout); priv->progress_bar_timeout = 0; } + if (priv->remove_attachment_banner) { + gtk_widget_destroy (priv->remove_attachment_banner); + g_object_unref (priv->remove_attachment_banner); + priv->remove_attachment_banner = NULL; + } + + if (priv->purge_timeout > 0) { + g_source_remove (priv->purge_timeout); + priv->purge_timeout = 0; + } + if (priv->row_reference) { gtk_tree_row_reference_free (priv->row_reference); priv->row_reference = NULL; } + if (priv->next_row_reference) { + gtk_tree_row_reference_free (priv->next_row_reference); + priv->next_row_reference = NULL; + } + if (priv->msg_uid) { g_free (priv->msg_uid); priv->msg_uid = NULL; @@ -468,49 +628,48 @@ modest_msg_view_window_finalize (GObject *obj) G_OBJECT_CLASS(parent_class)->finalize (obj); } - - -/* static gboolean */ -/* on_delete_event (GtkWidget *widget, GdkEvent *event, ModestMsgViewWindow *self) */ -/* { */ -/* modest_window_save_state (MODEST_WINDOW (self)); */ -/* return FALSE; */ -/* } */ - -ModestWindow * -modest_msg_view_window_new_with_header_model (TnyMsg *msg, - const gchar *account_name, - const gchar *msg_uid, - GtkTreeModel *model, - GtkTreeRowReference *row_reference) +static gboolean +select_next_valid_row (GtkTreeModel *model, + GtkTreeRowReference **row_reference, + gboolean cycle) { - ModestMsgViewWindow *window = NULL; - ModestMsgViewWindowPrivate *priv = NULL; - - window = MODEST_MSG_VIEW_WINDOW(modest_msg_view_window_new (msg, account_name, msg_uid)); - g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), NULL); - - priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); - - g_object_ref (model); - priv->header_model = model; - priv->row_reference = gtk_tree_row_reference_copy (row_reference); - - modest_msg_view_window_update_priority (window); + GtkTreeIter tmp_iter; + GtkTreePath *path, *next; + gboolean retval = FALSE; + + g_return_val_if_fail (gtk_tree_row_reference_valid (*row_reference), FALSE); + + path = gtk_tree_row_reference_get_path (*row_reference); + gtk_tree_model_get_iter (model, &tmp_iter, path); + 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; + } + } - /* Check toolbar dimming rules */ - modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window)); + /* Free */ + gtk_tree_path_free (path); - return MODEST_WINDOW(window); + return retval; } - -ModestWindow * -modest_msg_view_window_new (TnyMsg *msg, - const gchar *account_name, +/* TODO: This should be in _init(), with the parameters as properties. */ +static void +modest_msg_view_window_construct (ModestMsgViewWindow *self, TnyMsg *msg, + const gchar *modest_account_name, const gchar *msg_uid) { - ModestMsgViewWindow *self = NULL; GObject *obj = NULL; ModestMsgViewWindowPrivate *priv = NULL; ModestWindowPrivate *parent_priv = NULL; @@ -518,13 +677,13 @@ modest_msg_view_window_new (TnyMsg *msg, ModestDimmingRulesGroup *toolbar_rules_group = NULL; GtkActionGroup *action_group = NULL; GError *error = NULL; + GdkPixbuf *window_icon; - g_return_val_if_fail (msg, NULL); + g_return_if_fail (msg); - obj = g_object_new(MODEST_TYPE_MSG_VIEW_WINDOW, NULL); + obj = G_OBJECT (self); priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(obj); parent_priv = MODEST_WINDOW_GET_PRIVATE(obj); - self = MODEST_MSG_VIEW_WINDOW (obj); priv->msg_uid = g_strdup (msg_uid); @@ -594,7 +753,14 @@ modest_msg_view_window_new (TnyMsg *msg, init_window (MODEST_MSG_VIEW_WINDOW(obj), msg); restore_settings (MODEST_MSG_VIEW_WINDOW(obj)); -/* g_signal_connect (G_OBJECT(obj), "delete-event", G_CALLBACK(on_delete_event), obj); */ + /* Set window icon */ + window_icon = modest_platform_get_icon (MODEST_APP_MSG_VIEW_ICON); + if (window_icon) { + gtk_window_set_icon (GTK_WINDOW (obj), window_icon); + g_object_unref (window_icon); + } + + /* g_signal_connect (G_OBJECT(obj), "delete-event", G_CALLBACK(on_delete_event), obj); */ g_signal_connect (G_OBJECT(priv->msg_view), "link_clicked", G_CALLBACK (modest_ui_actions_on_msg_link_clicked), obj); @@ -621,7 +787,13 @@ modest_msg_view_window_new (TnyMsg *msg, G_CALLBACK (on_queue_changed), obj); - modest_window_set_active_account (MODEST_WINDOW(obj), account_name); + /* Account manager */ + priv->account_removed_handler = g_signal_connect (G_OBJECT (modest_runtime_get_account_store ()), + "account_removed", + G_CALLBACK(on_account_removed), + obj); + + modest_window_set_active_account (MODEST_WINDOW(obj), modest_account_name); priv->last_search = NULL; @@ -632,10 +804,297 @@ modest_msg_view_window_new (TnyMsg *msg, /* Check toolbar dimming rules */ modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (obj)); + +} + +ModestWindow * +modest_msg_view_window_new_with_header_model (TnyMsg *msg, + const gchar *modest_account_name, + const gchar *msg_uid, + GtkTreeModel *model, + GtkTreeRowReference *row_reference) +{ + ModestMsgViewWindow *window = NULL; + ModestMsgViewWindowPrivate *priv = NULL; + TnyFolder *header_folder = NULL; + ModestHeaderView *header_view = NULL; + ModestMainWindow *main_window = NULL; + ModestWindowMgr *window_mgr = NULL; + + window = g_object_new(MODEST_TYPE_MSG_VIEW_WINDOW, NULL); + g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), NULL); + modest_msg_view_window_construct (window, msg, modest_account_name, msg_uid); + + priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); + + /* Remember the message list's TreeModel so we can detect changes + * and change the list selection when necessary: */ + window_mgr = modest_runtime_get_window_mgr(); + g_assert(window_mgr != NULL); + main_window = MODEST_MAIN_WINDOW( + modest_window_mgr_get_main_window(window_mgr)); + g_assert(main_window != NULL); + header_view = MODEST_HEADER_VIEW(modest_main_window_get_child_widget( + main_window, MODEST_WIDGET_TYPE_HEADER_VIEW)); + if (header_view != NULL){ + header_folder = modest_header_view_get_folder(header_view); + 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); + } + + priv->header_model = g_object_ref(model); + 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); + + 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, + MODEST_HEADER_VIEW_OBSERVER(window)); + } + + modest_msg_view_window_update_priority (window); + + /* Check toolbar dimming rules */ + modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (window)); + + return MODEST_WINDOW(window); +} + +ModestWindow * +modest_msg_view_window_new_for_search_result (TnyMsg *msg, + const gchar *modest_account_name, + const gchar *msg_uid) +{ + ModestMsgViewWindow *window = NULL; + ModestMsgViewWindowPrivate *priv = NULL; + + window = g_object_new(MODEST_TYPE_MSG_VIEW_WINDOW, NULL); + g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), NULL); + modest_msg_view_window_construct (window, msg, modest_account_name, msg_uid); + + priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); + + /* Remember that this is a search result, + * so we can disable some UI appropriately: */ + priv->is_search_result = TRUE; + + return MODEST_WINDOW(window); +} + +ModestWindow * +modest_msg_view_window_new_for_attachment (TnyMsg *msg, + const gchar *modest_account_name, + const gchar *msg_uid) +{ + GObject *obj = NULL; + g_return_val_if_fail (msg, NULL); + + obj = g_object_new(MODEST_TYPE_MSG_VIEW_WINDOW, NULL); + modest_msg_view_window_construct (MODEST_MSG_VIEW_WINDOW (obj), + msg, modest_account_name, msg_uid); 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)); +} + +void modest_msg_view_window_on_row_deleted( + GtkTreeModel *header_model, + GtkTreePath *arg1, + ModestMsgViewWindow *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 + * still dimmed. Once the message that is shown by msg-view is found, the + * new model of header-view will be attached and the references will be set. + * On each further insertions dimming rules will be checked. However + * this requires extra CPU time at least works. + * (An message might be deleted from TnyFolder and thus will not be + * 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){ + 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){ + 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; + } + + /* 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)){ + g_free(uid); + return; + } + g_free(uid); + + /* Setup row_reference for the actual msg. */ + priv->row_reference = gtk_tree_row_reference_new( + new_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); + + modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (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)); +} + +/* The modest_msg_view_window_update_model_replaced implements update + * function for ModestHeaderViewObserver. Checks whether the TnyFolder + * actually belongs to the header-view is the same as the TnyFolder of + * the message of msg-view or not. If they are different, there is + * nothing to do. If they are the same, then the model has replaced and + * the reference in msg-view shall be replaced from the old model to + * 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){ + ModestMsgViewWindowPrivate *priv = NULL; + ModestMsgViewWindow *window = NULL; + + g_assert(MODEST_IS_HEADER_VIEW_OBSERVER(observer)); + g_assert(MODEST_IS_MSG_VIEW_WINDOW(observer)); + + window = MODEST_MSG_VIEW_WINDOW(observer); + priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(window); + + /* If there is an other folder in the header-view then we do + * 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)) + 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; + g_object_unref(priv->row_reference); + priv->row_reference = NULL; + g_object_unref(priv->next_row_reference); + priv->next_row_reference = NULL; + + modest_ui_actions_check_toolbar_dimming_rules(MODEST_WINDOW(window)); + + if(tny_folder_id == NULL) + return; + + g_assert(model != NULL); + + /* 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); +} gboolean modest_msg_view_window_toolbar_on_transfer_mode (ModestMsgViewWindow *self) @@ -660,7 +1119,9 @@ modest_msg_view_window_get_header (ModestMsgViewWindow *self) g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self), NULL); priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self); - /* Message is not obtained from a treemodel (Attachment ?) */ + /* 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) { msg = modest_msg_view_window_get_message (self); header = tny_msg_get_header (msg); @@ -668,7 +1129,11 @@ modest_msg_view_window_get_header (ModestMsgViewWindow *self) return header; } - /* Get current message iter */ + /* 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. */ 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, @@ -711,28 +1176,6 @@ modest_msg_view_window_get_message_uid (ModestMsgViewWindow *self) return (const gchar*) priv->msg_uid; } -static void -toggle_action_set_active_block_notify (GtkToggleAction *action, - gboolean value) -{ - GSList *proxies = NULL; - - for (proxies = gtk_action_get_proxies (GTK_ACTION (action)); - proxies != NULL; proxies = g_slist_next (proxies)) { - GtkWidget *widget = (GtkWidget *) proxies->data; - gtk_action_block_activate_from (GTK_ACTION (action), widget); - } - - gtk_toggle_action_set_active (action, value); - - for (proxies = gtk_action_get_proxies (GTK_ACTION (action)); - proxies != NULL; proxies = g_slist_next (proxies)) { - GtkWidget *widget = (GtkWidget *) proxies->data; - gtk_action_unblock_activate_from (GTK_ACTION (action), widget); - } -} - - static void modest_msg_view_window_toggle_find_toolbar (GtkToggleAction *toggle, gpointer data) @@ -754,9 +1197,9 @@ modest_msg_view_window_toggle_find_toolbar (GtkToggleAction *toggle, /* update the toggle buttons status */ action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/FindInMessage"); - toggle_action_set_active_block_notify (GTK_TOGGLE_ACTION (action), is_active); + modest_maemo_toggle_action_set_active_block_notify (GTK_TOGGLE_ACTION (action), is_active); action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ToolsMenu/ToolsFindInMessageMenu"); - toggle_action_set_active_block_notify (GTK_TOGGLE_ACTION (action), is_active); + modest_maemo_toggle_action_set_active_block_notify (GTK_TOGGLE_ACTION (action), is_active); } @@ -779,6 +1222,11 @@ modest_msg_view_window_find_toolbar_search (GtkWidget *widget, gchar *current_search; ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (obj); + if (modest_msg_view_get_message_is_empty (MODEST_MSG_VIEW (priv->msg_view))) { + hildon_banner_show_information (NULL, NULL, _("mail_ib_nothing_to_find")); + return; + } + g_object_get (G_OBJECT (widget), "prefix", ¤t_search, NULL); if ((current_search == NULL) || (strcmp (current_search, "") == 0)) { @@ -938,32 +1386,33 @@ modest_msg_view_window_last_message_selected (ModestMsgViewWindow *window) GtkTreePath *path; ModestMsgViewWindowPrivate *priv; GtkTreeIter tmp_iter; - gboolean has_next = FALSE; + gboolean is_last_selected; g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), TRUE); priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); - if (priv->header_model) { - path = gtk_tree_row_reference_get_path (priv->row_reference); - if (path == NULL) return FALSE; - while (!has_next) { - TnyHeader *header; - gtk_tree_path_next (path); - if (!gtk_tree_model_get_iter (priv->header_model, &tmp_iter, path)) - break; - gtk_tree_model_get (priv->header_model, &tmp_iter, TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, - &header, -1); - if (!(tny_header_get_flags(header)&TNY_HEADER_FLAG_DELETED)) { - has_next = TRUE; - break; - } - } - gtk_tree_path_free (path); - return !has_next; - } else { + /*if no model (so no rows at all), then virtually we are the last*/ + if (!priv->header_model) + return TRUE; + + path = gtk_tree_row_reference_get_path (priv->row_reference); + if (path == NULL) return TRUE; + + is_last_selected = TRUE; + while (is_last_selected) { + TnyHeader *header; + gtk_tree_path_next (path); + if (!gtk_tree_model_get_iter (priv->header_model, &tmp_iter, path)) + break; + gtk_tree_model_get (priv->header_model, &tmp_iter, + TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, + &header, -1); + if (!(tny_header_get_flags(header) & TNY_HEADER_FLAG_DELETED)) + is_last_selected = FALSE; } - + gtk_tree_path_free (path); + return is_last_selected; } gboolean @@ -978,57 +1427,61 @@ modest_msg_view_window_has_headers_model (ModestMsgViewWindow *window) } gboolean +modest_msg_view_window_is_search_result (ModestMsgViewWindow *window) +{ + ModestMsgViewWindowPrivate *priv; + + g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), TRUE); + priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); + + return priv->is_search_result; +} + +gboolean modest_msg_view_window_first_message_selected (ModestMsgViewWindow *window) { GtkTreePath *path; ModestMsgViewWindowPrivate *priv; - gboolean result; + 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); - if (priv->header_model) { - gchar * path_string; - path = gtk_tree_row_reference_get_path (priv->row_reference); - if (!path) - return TRUE; + /*if no model (so no rows at all), then virtually we are the first*/ + if (!priv->header_model) + return TRUE; - path_string = gtk_tree_path_to_string (path); - result = (strcmp (path_string, "0")==0); - if (result) { - g_free (path_string); - gtk_tree_path_free (path); - return result; - } + path = gtk_tree_row_reference_get_path (priv->row_reference); + if (!path) + return TRUE; - while (result) { - TnyHeader *header; +/* path_string = gtk_tree_path_to_string (path); + is_first_selected = strcmp (path_string, "0"); - gtk_tree_path_prev (path); - - if (!gtk_tree_model_get_iter (priv->header_model, &tmp_iter, path)) - break; - gtk_tree_model_get (priv->header_model, &tmp_iter, TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, - &header, -1); - if (!(tny_header_get_flags(header)&TNY_HEADER_FLAG_DELETED)) { - result = FALSE; - break; - } + g_free (path_string); + gtk_tree_path_free (path); - path_string = gtk_tree_path_to_string (path); - if (strcmp(path_string, "0")==0) { - g_free (path_string); - break; - } - g_free (path_string); - } - gtk_tree_path_free (path); - return result; - } else { - return TRUE; + return is_first_selected;*/ + + is_first_selected = TRUE; + while (is_first_selected) { + TnyHeader *header; + if(!gtk_tree_path_prev (path)) + break; + /* Here the 'if' is needless for logic, but let make sure + * iter is valid for gtk_tree_model_get. */ + if (!gtk_tree_model_get_iter (priv->header_model, &tmp_iter, path)) + break; + gtk_tree_model_get (priv->header_model, &tmp_iter, + TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, + &header, -1); + if (!(tny_header_get_flags(header) & TNY_HEADER_FLAG_DELETED)) + is_first_selected = FALSE; } - + gtk_tree_path_free (path); + return is_first_selected; } /** @@ -1047,11 +1500,25 @@ static gboolean message_reader (ModestMsgViewWindow *window, ModestMsgViewWindowPrivate *priv, TnyHeader *header, - GtkTreeIter iter) + GtkTreePath *path) { ModestMailOperation *mail_op = NULL; - GtkTreePath *path = NULL; ModestMailOperationTypeOperation op_type; + gboolean already_showing = FALSE; + ModestWindow *msg_window = NULL; + ModestWindowMgr *mgr; + + g_return_val_if_fail (path != NULL, FALSE); + + mgr = modest_runtime_get_window_mgr (); + already_showing = modest_window_mgr_find_registered_header (mgr, header, &msg_window); + if (already_showing && (msg_window != MODEST_WINDOW (window))) { + gboolean retval; + if (msg_window) + gtk_window_present (GTK_WINDOW (msg_window)); + g_signal_emit_by_name (G_OBJECT (window), "delete-event", NULL, &retval); + return TRUE; + } /* Msg download completed */ if (tny_header_get_flags (header) & TNY_HEADER_FLAG_CACHED) { @@ -1082,9 +1549,6 @@ message_reader (ModestMsgViewWindow *window, } } - /* Get the path, will be freed by the callback */ - path = gtk_tree_model_get_path (priv->header_model, &iter); - /* New mail operation */ mail_op = modest_mail_operation_new_with_error_handling (op_type, G_OBJECT(window), @@ -1107,45 +1571,47 @@ modest_msg_view_window_select_next_message (ModestMsgViewWindow *window) ModestMsgViewWindowPrivate *priv; GtkTreePath *path= NULL; GtkTreeIter tmp_iter; + TnyHeader *header; + gboolean retval = TRUE; g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), FALSE); priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); - if (priv->header_model) { - path = gtk_tree_row_reference_get_path (priv->row_reference); - if (path == NULL) return FALSE; - - gtk_tree_model_get_iter (priv->header_model, - &tmp_iter, - path); - while (gtk_tree_model_iter_next (priv->header_model, &tmp_iter)) { - TnyHeader *header; - - gtk_tree_model_get (priv->header_model, &tmp_iter, - TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, - &header, -1); - if (!header) - break; - - if (tny_header_get_flags (header) & TNY_HEADER_FLAG_DELETED) { - g_object_unref (header); - continue; - } - - /* Read the message & show it */ - if (!message_reader (window, priv, header, tmp_iter)) { - g_object_unref (header); - break; - } + /* Update the next row reference if it's not valid. This could + happen if for example the header which it was pointing to, + was deleted. The best place to do it is in the row-deleted + handler but the tinymail model do not work like the glib + tree models and reports the deletion when the row is still + there */ + 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); + } + } + if (priv->next_row_reference) + path = gtk_tree_row_reference_get_path (priv->next_row_reference); + if (path == NULL) + return FALSE; - /* Free */ - g_object_unref (header); + gtk_tree_model_get_iter (priv->header_model, + &tmp_iter, + path); - return TRUE; - } + gtk_tree_model_get (priv->header_model, &tmp_iter, + TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, + &header, -1); + + /* Read the message & show it */ + if (!message_reader (window, priv, header, path)) { + retval = FALSE; gtk_tree_path_free (path); } - return FALSE; + + /* Free */ + g_object_unref (header); + + return retval; } gboolean @@ -1154,6 +1620,7 @@ modest_msg_view_window_select_first_message (ModestMsgViewWindow *self) ModestMsgViewWindowPrivate *priv = NULL; TnyHeader *header = NULL; GtkTreeIter iter; + GtkTreePath *path; g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self), FALSE); priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self); @@ -1167,15 +1634,16 @@ modest_msg_view_window_select_first_message (ModestMsgViewWindow *self) &iter, TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN, &header, -1); - g_return_val_if_fail (TNY_IS_HEADER (header), FALSE); if (tny_header_get_flags (header) & TNY_HEADER_FLAG_DELETED) { g_object_unref (header); return modest_msg_view_window_select_next_message (self); } + path = gtk_tree_model_get_path (priv->header_model, &iter); + /* Read the message & show it */ - message_reader (self, priv, header, iter); + message_reader (self, priv, header, path); /* Free */ g_object_unref (header); @@ -1213,7 +1681,7 @@ modest_msg_view_window_select_previous_message (ModestMsgViewWindow *window) } /* Read the message & show it */ - if (!message_reader (window, priv, header, iter)) { + if (!message_reader (window, priv, header, path)) { g_object_unref (header); break; } @@ -1252,6 +1720,8 @@ view_msg_cb (ModestMailOperation *mail_op, /* Update the row reference */ gtk_tree_row_reference_free (priv->row_reference); priv->row_reference = gtk_tree_row_reference_new (priv->header_model, path); + 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_path_free (path); /* Mark header as read */ @@ -1476,6 +1946,9 @@ modest_msg_view_window_clipboard_owner_change (GtkClipboard *clipboard, gchar *selection; GtkWidget *focused; + if (!GTK_WIDGET_VISIBLE (window)) + return; + parent_priv = MODEST_WINDOW_GET_PRIVATE (window); selection = gtk_clipboard_wait_for_text (clipboard); @@ -1546,6 +2019,25 @@ observers_empty (ModestMsgViewWindow *self) return is_empty; } +static void +on_account_removed (TnyAccountStore *account_store, + TnyAccount *account, + gpointer user_data) +{ + /* Do nothing if it's a transport account, because we only + show the messages of a store account */ + if (tny_account_get_account_type(account) == TNY_ACCOUNT_TYPE_STORE) { + const gchar *parent_acc = NULL; + const gchar *our_acc = NULL; + + our_acc = modest_window_get_active_account (MODEST_WINDOW (user_data)); + parent_acc = modest_tny_account_get_parent_modest_account_name_for_server_account (account); + + /* Close this window if I'm showing a message of the removed account */ + if (strcmp (parent_acc, our_acc) == 0) + modest_ui_actions_on_close_window (NULL, MODEST_WINDOW (user_data)); + } +} static void on_queue_changed (ModestMailOperationQueue *queue, @@ -1568,7 +2060,7 @@ on_queue_changed (ModestMailOperationQueue *queue, /* Get toolbar mode from operation id*/ op_type = modest_mail_operation_get_type_operation (mail_op); switch (op_type) { - case MODEST_MAIL_OPERATION_TYPE_SEND: +/* case MODEST_MAIL_OPERATION_TYPE_SEND: */ case MODEST_MAIL_OPERATION_TYPE_RECEIVE: case MODEST_MAIL_OPERATION_TYPE_OPEN: mode = TOOLBAR_MODE_TRANSFER; @@ -1657,7 +2149,6 @@ modest_msg_view_window_view_attachment (ModestMsgViewWindow *window, TnyMimePart if (tny_mime_part_is_purged (mime_part)) { g_object_unref (mime_part); - hildon_banner_show_information (NULL, NULL, _("mail_ib_attach_not_local")); return; } @@ -1709,7 +2200,9 @@ modest_msg_view_window_view_attachment (ModestMsgViewWindow *window, TnyMimePart 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 (TNY_MSG (mime_part), account, NULL); + msg_win = modest_msg_view_window_new_for_attachment (TNY_MSG (mime_part), account, NULL); + 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)); gtk_widget_show_all (GTK_WIDGET (msg_win)); @@ -1718,49 +2211,139 @@ modest_msg_view_window_view_attachment (ModestMsgViewWindow *window, TnyMimePart g_object_unref (mime_part); } +typedef struct +{ + gchar *filename; + TnyMimePart *part; +} SaveMimePartPair; + +typedef struct +{ + GList *pairs; + GtkWidget *banner; + gboolean 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_part_info_free (SaveMimePartInfo *info, gboolean with_struct) +{ + + GList *node; + for (node = info->pairs; node != NULL; node = g_list_next (node)) { + SaveMimePartPair *pair = (SaveMimePartPair *) node->data; + g_free (pair->filename); + g_object_unref (pair->part); + g_slice_free (SaveMimePartPair, pair); + } + g_list_free (info->pairs); + info->pairs = NULL; + if (with_struct) { + gtk_widget_destroy (info->banner); + g_object_unref (info->banner); + g_slice_free (SaveMimePartInfo, info); + } +} + static gboolean -save_mime_part_to_file (const gchar *filename, TnyMimePart *mime_part) +idle_save_mime_part_show_result (SaveMimePartInfo *info) +{ + if (info->pairs != NULL) { + /* This is a GDK lock because we are an idle callback and + * save_mime_parts_to_file_with_checks can contain Gtk+ code */ + + gdk_threads_enter (); /* CHECKED */ + save_mime_parts_to_file_with_checks (info); + gdk_threads_leave (); /* CHECKED */ + } 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) { + hildon_banner_show_information (NULL, NULL, _CS("sfil_ib_saved")); + } else { + hildon_banner_show_information (NULL, NULL, _("mail_ib_file_operation_failed")); + } + gdk_threads_leave (); /* CHECKED */ + } + + return FALSE; +} + +static gpointer +save_mime_part_to_file (SaveMimePartInfo *info) { GnomeVFSResult result; GnomeVFSHandle *handle; TnyStream *stream; - - hildon_banner_show_information (NULL, NULL, _("mail_ib_saving_mime_part")); - result = gnome_vfs_create (&handle, filename, GNOME_VFS_OPEN_WRITE, FALSE, 0777); - if (result != GNOME_VFS_OK) { - hildon_banner_show_information (NULL, NULL, _("mail_ib_file_operation_failed")); - return FALSE; + SaveMimePartPair *pair = (SaveMimePartPair *) info->pairs->data; + + result = gnome_vfs_create (&handle, pair->filename, GNOME_VFS_OPEN_WRITE, FALSE, 0777); + if (result == GNOME_VFS_OK) { + stream = tny_vfs_stream_new (handle); + tny_mime_part_decode_to_stream (pair->part, stream); + 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 { + save_mime_part_info_free (info, FALSE); + info->result = FALSE; } - stream = tny_vfs_stream_new (handle); - tny_mime_part_decode_to_stream (mime_part, stream); - g_object_unref (G_OBJECT (stream)); - return TRUE; + + g_idle_add ((GSourceFunc) idle_save_mime_part_show_result, info); + return NULL; } -static gboolean -save_mime_part_to_file_with_checks (GtkWindow *parent, const gchar *filename, TnyMimePart *mime_part) +static void +save_mime_parts_to_file_with_checks (SaveMimePartInfo *info) { - if (modest_maemo_utils_file_exists (filename)) { + SaveMimePartPair *pair; + gboolean is_ok = TRUE; + + pair = info->pairs->data; + if (modest_maemo_utils_file_exists (pair->filename)) { GtkWidget *confirm_overwrite_dialog; - confirm_overwrite_dialog = hildon_note_new_confirmation (GTK_WINDOW (parent), + confirm_overwrite_dialog = hildon_note_new_confirmation (NULL, _("emev_nc_replace_files")); if (gtk_dialog_run (GTK_DIALOG (confirm_overwrite_dialog)) != GTK_RESPONSE_OK) { - gtk_widget_destroy (confirm_overwrite_dialog); - return FALSE; + is_ok = FALSE; } gtk_widget_destroy (confirm_overwrite_dialog); } - return save_mime_part_to_file (filename, mime_part); + if (!is_ok) { + save_mime_part_info_free (info, TRUE); + } else { + g_thread_create ((GThreadFunc)save_mime_part_to_file, info, FALSE, NULL); + } + } + void modest_msg_view_window_save_attachments (ModestMsgViewWindow *window, GList *mime_parts) { gboolean clean_list = FALSE; ModestMsgViewWindowPrivate *priv; - g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window)); + GList *files_to_save = NULL; + GtkWidget *save_dialog = NULL; + gchar *folder = NULL; + gboolean canceled = FALSE; + const gchar *filename = NULL; + gchar *save_multiple_str = NULL; + g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window)); priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); if (mime_parts == NULL) { @@ -1770,87 +2353,109 @@ modest_msg_view_window_save_attachments (ModestMsgViewWindow *window, GList *mim clean_list = TRUE; } + /* prepare dialog */ if (mime_parts->next == NULL) { /* only one attachment selected */ - GtkWidget *save_dialog = NULL; TnyMimePart *mime_part = (TnyMimePart *) mime_parts->data; if (!TNY_IS_MSG (mime_part) && tny_mime_part_is_attachment (mime_part)) { - const gchar *filename; - gchar *folder; - save_dialog = hildon_file_chooser_dialog_new (GTK_WINDOW (window), GTK_FILE_CHOOSER_ACTION_SAVE); - folder = g_build_filename (g_get_home_dir (), DEFAULT_FOLDER, NULL); - gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (save_dialog), folder); - g_free (folder); filename = tny_mime_part_get_filename (mime_part); - if (filename != NULL) - gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (save_dialog), filename); - while (gtk_dialog_run (GTK_DIALOG (save_dialog)) == GTK_RESPONSE_OK) { - gchar *filename_tmp = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (save_dialog)); - gboolean save_result; - if (!modest_maemo_utils_folder_writable (filename_tmp)) { - g_free (filename_tmp); - hildon_banner_show_information (NULL, NULL, _("TODO: read only location")); - continue; - } - save_result = save_mime_part_to_file_with_checks (GTK_WINDOW (save_dialog), - filename_tmp, mime_part); - g_free (filename_tmp); - if (save_result) - break; - else - continue; - } - gtk_widget_destroy (save_dialog); } else { g_warning ("Tried to save a non-file attachment"); + canceled = TRUE; } } else { - GtkWidget *save_dialog = NULL; - gchar *folder; - gchar *save_multiple_str = g_strdup_printf (_("FIXME: %d attachments"), - g_list_length (mime_parts)); - save_dialog = hildon_file_chooser_dialog_new (GTK_WINDOW (window), GTK_FILE_CHOOSER_ACTION_SAVE); + save_multiple_str = g_strdup_printf (_FM("sfil_va_number_of_objects_attachments"), + g_list_length (mime_parts)); + } + + save_dialog = hildon_file_chooser_dialog_new (GTK_WINDOW (window), + GTK_FILE_CHOOSER_ACTION_SAVE); + + /* set folder */ + folder = g_build_filename (g_get_home_dir (), DEFAULT_FOLDER, NULL); + gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (save_dialog), folder); + g_free (folder); + + /* set filename */ + if (filename != NULL) + gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (save_dialog), + filename); + + /* if multiple, set multiple string */ + if (save_multiple_str) { g_object_set (G_OBJECT (save_dialog), "save-multiple", save_multiple_str, NULL); + } - folder = g_build_filename (g_get_home_dir (), DEFAULT_FOLDER, NULL); - gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (save_dialog), folder); - g_free (folder); - if (gtk_dialog_run (GTK_DIALOG (save_dialog)) == GTK_RESPONSE_OK) { - gchar *foldername = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (save_dialog)); + /* 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_maemo_utils_folder_writable (chooser_uri)) { + hildon_banner_show_information + (NULL, NULL, dgettext("hildon-fm", "sfil_ib_readonly_location")); + } else { GList *node = NULL; - gboolean attachment_found = FALSE; - if (!modest_maemo_utils_folder_writable (foldername)) { - g_free (foldername); - hildon_banner_show_information (NULL, NULL, _("TODO: read only location")); - } + 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)) { - const gchar *att_filename = tny_mime_part_get_filename (mime_part); - if (att_filename != NULL) { - gchar *full_filename; - gboolean save_result; - full_filename = g_build_filename (foldername, att_filename, NULL); - attachment_found = TRUE; - - save_result = save_mime_part_to_file_with_checks (GTK_WINDOW (save_dialog), - full_filename, mime_part); - g_free (full_filename); - if (!save_result) - break; + 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); } } - gtk_widget_destroy (save_dialog); - } else { - g_warning ("Tried to save a non-file attachment"); } - /* more than one attachment selected */ + g_free (chooser_uri); } + + gtk_widget_destroy (save_dialog); + 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); + GtkWidget *banner = hildon_banner_show_animation (NULL, NULL, + _CS("sfil_ib_saving")); + info->pairs = files_to_save; + info->banner = banner; + info->result = TRUE; + g_object_ref (banner); + save_mime_parts_to_file_with_checks (info); + } +} + +static gboolean +show_remove_attachment_information (gpointer userdata) +{ + ModestMsgViewWindow *window = (ModestMsgViewWindow *) userdata; + ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window); + + if (priv->remove_attachment_banner != NULL) { + gtk_widget_destroy (priv->remove_attachment_banner); + g_object_unref (priv->remove_attachment_banner); + } + + priv->remove_attachment_banner = g_object_ref ( + hildon_banner_show_animation (NULL, NULL, _("mcen_ib_removing_attachment"))); + + return FALSE; } void @@ -1916,13 +2521,12 @@ modest_msg_view_window_remove_attachments (ModestMsgViewWindow *window, gboolean if (response != GTK_RESPONSE_OK) 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); */ - modest_platform_information_banner (NULL, NULL, _("mcen_ib_removing_attachment")); - 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); */ @@ -1936,6 +2540,17 @@ modest_msg_view_window_remove_attachments (ModestMsgViewWindow *window, gboolean g_list_foreach (mime_parts, (GFunc) g_object_unref, NULL); g_list_free (mime_parts); + if (priv->purge_timeout > 0) { + g_source_remove (priv->purge_timeout); + priv->purge_timeout = 0; + } + + if (priv->remove_attachment_banner) { + gtk_widget_destroy (priv->remove_attachment_banner); + g_object_unref (priv->remove_attachment_banner); + priv->remove_attachment_banner = NULL; + } + }