#include <string.h>
#include <tny-account-store.h>
#include <tny-simple-list.h>
-#include <tny-header.h>
+#include <tny-msg.h>
+#include <tny-mime-part.h>
+#include <tny-vfs-stream.h>
+#include "modest-marshal.h"
#include "modest-platform.h"
+#include <modest-utils.h>
+#include <modest-maemo-utils.h>
#include <modest-tny-msg.h>
#include <modest-msg-view-window.h>
#include <modest-main-window-ui.h>
+#include "modest-msg-view-window-ui-dimming.h"
#include <modest-widget-memory.h>
#include <modest-runtime.h>
#include <modest-window-priv.h>
#include <modest-tny-folder.h>
#include <modest-text-utils.h>
-#include "modest-progress-bar-widget.h"
+#include <modest-account-mgr-helpers.h>
+#include "modest-progress-bar.h"
#include "modest-defs.h"
#include "modest-hildon-includes.h"
-#include <gtkhtml/gtkhtml-search.h>
+#include "modest-ui-dimming-manager.h"
#include <gdk/gdkkeysyms.h>
+#include <modest-tny-account.h>
+#include <modest-mime-part-view.h>
+#include <modest-isearch-view.h>
+#include <modest-tny-mime-part.h>
+#include <math.h>
+#include <errno.h>
+#include <glib/gstdio.h>
+#include <modest-debug.h>
+
+#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);
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);
-static gboolean modest_msg_view_window_key_release_event (GtkWidget *window,
- GdkEventKey *event,
- gpointer userdata);
+static gboolean modest_msg_view_window_key_event (GtkWidget *window,
+ GdkEventKey *event,
+ gpointer userdata);
static gboolean modest_msg_view_window_window_state_event (GtkWidget *widget,
GdkEventWindowState *event,
gpointer userdata);
-static void modest_msg_view_window_scroll_up (ModestWindow *window);
-static void modest_msg_view_window_scroll_down (ModestWindow *window);
-static gboolean modest_msg_view_window_is_last_message (ModestMsgViewWindow *window);
-static gboolean modest_msg_view_window_is_first_message (ModestMsgViewWindow *window);
-static TnyFolderType modest_msg_view_window_get_folder_type (ModestMsgViewWindow *window);
-static void modest_msg_view_window_update_dimmed (ModestMsgViewWindow *window);
static void modest_msg_view_window_update_priority (ModestMsgViewWindow *window);
static void modest_msg_view_window_show_toolbar (ModestWindow *window,
GdkEvent *event,
ModestMsgViewWindow *window);
-static void cancel_progressbar (GtkToolButton *toolbutton,
- ModestMsgViewWindow *self);
+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);
+
+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 on_queue_changed (ModestMailOperationQueue *queue,
- ModestMailOperation *mail_op,
- ModestMailOperationQueueNotification type,
- ModestMsgViewWindow *self);
+static void on_move_focus (GtkWidget *widget,
+ GtkDirectionType direction,
+ gpointer userdata);
-static void view_msg_cb (const GObject *obj, const TnyMsg *msg, gpointer user_data);
+static void view_msg_cb (ModestMailOperation *mail_op,
+ TnyHeader *header,
+ gboolean canceled,
+ TnyMsg *msg,
+ GError *error,
+ gpointer user_data);
-static void set_toolbar_mode (ModestMsgViewWindow *self,
- ModestToolBarModes mode);
+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 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);
/* list my signals */
enum {
- /* MY_SIGNAL_1, */
- /* MY_SIGNAL_2, */
+ MSG_CHANGED_SIGNAL,
LAST_SIGNAL
};
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"), "<CTRL>F", NULL, G_CALLBACK (modest_msg_view_window_toggle_find_toolbar), FALSE },
};
static const GtkRadioActionEntry msg_view_zoom_action_entries [] = {
GtkWidget *cancel_toolitem;
GtkWidget *prev_toolitem;
GtkWidget *next_toolitem;
+ ModestToolBarModes current_toolbar_mode;
/* Optimized view enabled */
gboolean optimized_view;
+ /* Whether this was created via the *_new_for_search_result() function. */
+ gboolean is_search_result;
+
+ /* Whether the message is in outbox */
+ gboolean is_outbox;
+
+ /* 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;
- GtkTreeIter iter;
+ 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 purge_timeout;
+ GtkWidget *remove_attachment_banner;
- guint clipboard_change_handler;
- guint queue_change_handler;
+ guint progress_bar_timeout;
+
+ gchar *msg_uid;
+
+ GSList *sighandlers;
};
#define MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
static GtkWindowClass *parent_class = NULL;
/* uncomment the following if you have defined any signals */
-/* static guint signals[LAST_SIGNAL] = {0}; */
+static guint signals[LAST_SIGNAL] = {0};
GType
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;
}
static void
+save_state (ModestWindow *self)
+{
+ modest_widget_memory_save (modest_runtime_get_conf (),
+ G_OBJECT(self),
+ MODEST_CONF_MSG_VIEW_WINDOW_KEY);
+}
+
+
+static void
+restore_settings (ModestMsgViewWindow *self)
+{
+ ModestConf *conf;
+ ModestWindowPrivate *parent_priv = MODEST_WINDOW_GET_PRIVATE (self);
+ GtkAction *action;
+
+ conf = modest_runtime_get_conf ();
+ action = gtk_ui_manager_get_action (parent_priv->ui_manager,
+ "/MenuBar/ViewMenu/ViewShowToolbarMenu/ViewShowToolbarNormalScreenMenu");
+ gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
+ modest_conf_get_bool (conf, MODEST_CONF_MSG_VIEW_WINDOW_SHOW_TOOLBAR, NULL));
+ action = gtk_ui_manager_get_action (parent_priv->ui_manager,
+ "/MenuBar/ViewMenu/ViewShowToolbarMenu/ViewShowToolbarFullScreenMenu");
+ gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
+ modest_conf_get_bool (conf, MODEST_CONF_MSG_VIEW_WINDOW_SHOW_TOOLBAR_FULLSCREEN, NULL));
+ modest_widget_memory_restore (conf,
+ G_OBJECT(self),
+ MODEST_CONF_MSG_VIEW_WINDOW_KEY);
+}
+
+static void
modest_msg_view_window_class_init (ModestMsgViewWindowClass *klass)
{
GObjectClass *gobject_class;
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));
+
+ modest_window_class->save_state_func = save_state;
+
+ signals[MSG_CHANGED_SIGNAL] =
+ g_signal_new ("msg-changed",
+ G_TYPE_FROM_CLASS (gobject_class),
+ G_SIGNAL_RUN_FIRST,
+ G_STRUCT_OFFSET (ModestMsgViewWindowClass, msg_changed),
+ NULL, NULL,
+ modest_marshal_VOID__POINTER_POINTER,
+ 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;
+ ModestWindowPrivate *parent_priv = NULL;
+ GtkActionGroup *action_group = NULL;
+ GError *error = NULL;
+ GdkPixbuf *window_icon;
+
priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(obj);
+ parent_priv = MODEST_WINDOW_GET_PRIVATE(obj);
+ parent_priv->ui_manager = gtk_ui_manager_new();
+
+ action_group = gtk_action_group_new ("ModestMsgViewWindowActions");
+ gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
+
+ /* Add common actions */
+ gtk_action_group_add_actions (action_group,
+ modest_action_entries,
+ G_N_ELEMENTS (modest_action_entries),
+ obj);
+ gtk_action_group_add_toggle_actions (action_group,
+ modest_toggle_action_entries,
+ G_N_ELEMENTS (modest_toggle_action_entries),
+ obj);
+ gtk_action_group_add_toggle_actions (action_group,
+ msg_view_toggle_action_entries,
+ G_N_ELEMENTS (msg_view_toggle_action_entries),
+ obj);
+ gtk_action_group_add_radio_actions (action_group,
+ msg_view_zoom_action_entries,
+ G_N_ELEMENTS (msg_view_zoom_action_entries),
+ 100,
+ G_CALLBACK (modest_ui_actions_on_change_zoom),
+ obj);
+
+ gtk_ui_manager_insert_action_group (parent_priv->ui_manager, action_group, 0);
+ g_object_unref (action_group);
+
+ /* Load the UI definition */
+ gtk_ui_manager_add_ui_from_file (parent_priv->ui_manager, MODEST_UIDIR "modest-msg-view-window-ui.xml",
+ &error);
+ if (error) {
+ g_printerr ("modest: could not merge modest-msg-view-window-ui.xml: %s\n", error->message);
+ g_error_free (error);
+ error = NULL;
+ }
+ /* ****** */
+
+ /* Add accelerators */
+ gtk_window_add_accel_group (GTK_WINDOW (obj),
+ gtk_ui_manager_get_accel_group (parent_priv->ui_manager));
+
+ priv->is_search_result = FALSE;
+ priv->is_outbox = 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;
+
+ priv->sighandlers = NULL;
+
+ /* Init window */
+ init_window (MODEST_MSG_VIEW_WINDOW(obj));
+
+ /* Set window icon */
+ window_icon = modest_platform_get_icon (MODEST_APP_MSG_VIEW_ICON, MODEST_ICON_SIZE_BIG);
+ if (window_icon) {
+ gtk_window_set_icon (GTK_WINDOW (obj), window_icon);
+ g_object_unref (window_icon);
+ }
+
+ hildon_program_add_window (hildon_program_get_instance(),
+ HILDON_WINDOW(obj));
+ modest_window_mgr_register_help_id (modest_runtime_get_window_mgr(),
+ GTK_WINDOW(obj),"applications_email_viewer");
}
-static void
-save_settings (ModestMsgViewWindow *self)
+
+static gboolean
+set_toolbar_transfer_mode (ModestMsgViewWindow *self)
{
- modest_widget_memory_save (modest_runtime_get_conf (),
- G_OBJECT(self),
- MODEST_CONF_MSG_VIEW_WINDOW_KEY);
-}
+ ModestMsgViewWindowPrivate *priv = NULL;
+
+ g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self), FALSE);
+ priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
-static void
-restore_settings (ModestMsgViewWindow *self)
-{
- modest_widget_memory_restore (modest_runtime_get_conf (),
- G_OBJECT(self),
- MODEST_CONF_MSG_VIEW_WINDOW_KEY);
+ set_toolbar_mode (self, TOOLBAR_MODE_TRANSFER);
+
+ if (priv->progress_bar_timeout > 0) {
+ g_source_remove (priv->progress_bar_timeout);
+ priv->progress_bar_timeout = 0;
+ }
+
+ return FALSE;
}
-
static void
set_toolbar_mode (ModestMsgViewWindow *self,
ModestToolBarModes mode)
{
ModestWindowPrivate *parent_priv;
ModestMsgViewWindowPrivate *priv;
- GtkAction *widget = NULL;
+/* GtkWidget *widget = NULL; */
g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self));
parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
- switch (mode) {
- case TOOLBAR_MODE_NORMAL:
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNew");
- gtk_action_set_sensitive (widget, TRUE);
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageReply");
- gtk_action_set_sensitive (widget, TRUE);
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarDeleteMessage");
- gtk_action_set_sensitive (widget, TRUE);
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageMoveTo");
- gtk_action_set_sensitive (widget, TRUE);
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/FindInMessage");
- gtk_action_set_sensitive (widget, TRUE);
+ /* Sets current toolbar mode */
+ priv->current_toolbar_mode = mode;
- if (priv->prev_toolitem)
- gtk_widget_show (priv->prev_toolitem);
-
- if (priv->next_toolitem)
- gtk_widget_show (priv->next_toolitem);
-
- if (priv->progress_toolitem)
+ /* Update toolbar dimming state */
+ modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (self));
+
+ switch (mode) {
+ case TOOLBAR_MODE_NORMAL:
+ if (priv->progress_toolitem) {
gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
+ gtk_widget_hide (priv->progress_toolitem);
+ }
+
if (priv->progress_bar)
gtk_widget_hide (priv->progress_bar);
if (priv->cancel_toolitem)
gtk_widget_hide (priv->cancel_toolitem);
+ if (priv->prev_toolitem)
+ gtk_widget_show (priv->prev_toolitem);
+
+ if (priv->next_toolitem)
+ gtk_widget_show (priv->next_toolitem);
+
/* Hide toolbar if optimized view is enabled */
if (priv->optimized_view) {
gtk_widget_set_no_show_all (parent_priv->toolbar, TRUE);
break;
case TOOLBAR_MODE_TRANSFER:
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNew");
- gtk_action_set_sensitive (widget, FALSE);
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageReply");
- gtk_action_set_sensitive (widget, FALSE);
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarDeleteMessage");
- gtk_action_set_sensitive (widget, FALSE);
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageMoveTo");
- gtk_action_set_sensitive (widget, FALSE);
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/FindInMessage");
- gtk_action_set_sensitive (widget, FALSE);
-
if (priv->prev_toolitem)
gtk_widget_hide (priv->prev_toolitem);
if (priv->next_toolitem)
gtk_widget_hide (priv->next_toolitem);
- if (priv->progress_toolitem)
- gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
if (priv->progress_bar)
gtk_widget_show (priv->progress_bar);
+
+ if (priv->progress_toolitem) {
+ gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
+ gtk_widget_show (priv->progress_toolitem);
+ }
if (priv->cancel_toolitem)
gtk_widget_show (priv->cancel_toolitem);
}
-static GtkWidget *
-menubar_to_menu (GtkUIManager *ui_manager)
-{
- GtkWidget *main_menu;
- GtkWidget *menubar;
- GList *iter;
-
- /* Create new main menu */
- main_menu = gtk_menu_new();
-
- /* Get the menubar from the UI manager */
- menubar = gtk_ui_manager_get_widget (ui_manager, "/MenuBar");
-
- iter = gtk_container_get_children (GTK_CONTAINER (menubar));
- while (iter) {
- GtkWidget *menu;
-
- menu = GTK_WIDGET (iter->data);
- gtk_widget_reparent(menu, main_menu);
-
- iter = g_list_next (iter);
- }
- return main_menu;
-}
-
static void
-init_window (ModestMsgViewWindow *obj, TnyMsg *msg)
+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 = modest_msg_view_new (msg);
+ 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);
main_vbox = gtk_vbox_new (FALSE, 6);
- /* Menubar */
- parent_priv->menubar = menubar_to_menu (parent_priv->ui_manager);
- gtk_widget_show_all (GTK_WIDGET(parent_priv->menubar));
- hildon_window_set_menu (HILDON_WINDOW(obj), GTK_MENU(parent_priv->menubar));
-
+#ifdef MODEST_USE_MOZEMBED
+ priv->main_scroll = priv->msg_view;
+ gtk_widget_set_size_request (priv->msg_view, -1, 1600);
+#else
priv->main_scroll = gtk_scrolled_window_new (NULL, NULL);
+ gtk_container_add (GTK_CONTAINER (priv->main_scroll), priv->msg_view);
+#endif
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);
- /* TODO: I dont knonw why, but when get_msg_async is used, */
- /* this code makes application doest not work (jfernandez) */
- if (FALSE) {
- 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);
- modest_msg_view_window_clipboard_owner_change (gtk_clipboard_get (GDK_SELECTION_PRIMARY), NULL, 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;
+ ModestWindow *main_window = NULL;
+
+ priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self);
+
+ if (gtk_clipboard_get (GDK_SELECTION_PRIMARY) &&
+ 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 (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_signal_mgr_disconnect_all_and_destroy (priv->sighandlers);
+ priv->sighandlers = NULL;
+
+ main_window = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(),
+ FALSE); /* don't create */
+ if (!main_window)
+ return;
+
+ header_view = MODEST_HEADER_VIEW(
+ modest_main_window_get_child_widget(
+ MODEST_MAIN_WINDOW(main_window),
+ MODEST_MAIN_WINDOW_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)
ModestMsgViewWindowPrivate *priv;
priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (obj);
+
+ /* 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;
}
- 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->progress_bar_timeout > 0) {
+ g_source_remove (priv->progress_bar_timeout);
+ priv->progress_bar_timeout = 0;
}
- /* disconnet operations queue observer */
- 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;
+ if (priv->remove_attachment_banner) {
+ gtk_widget_destroy (priv->remove_attachment_banner);
+ g_object_unref (priv->remove_attachment_banner);
+ priv->remove_attachment_banner = NULL;
}
-
- G_OBJECT_CLASS(parent_class)->finalize (obj);
-}
+ 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;
+ }
-static gboolean
-on_delete_event (GtkWidget *widget, GdkEvent *event, ModestMsgViewWindow *self)
-{
- save_settings (self);
- return FALSE;
+ 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;
+ }
+
+ G_OBJECT_CLASS(parent_class)->finalize (obj);
}
-ModestWindow *
-modest_msg_view_window_new_with_header_model (TnyMsg *msg, const gchar *account_name,
- GtkTreeModel *model, GtkTreeIter iter)
+static gboolean
+select_next_valid_row (GtkTreeModel *model,
+ GtkTreeRowReference **row_reference,
+ gboolean cycle,
+ gboolean is_outbox)
{
- ModestMsgViewWindow *window = NULL;
- ModestMsgViewWindowPrivate *priv = NULL;
+ GtkTreeIter tmp_iter;
+ GtkTreePath *path;
+ GtkTreePath *next = NULL;
+ gboolean retval = FALSE, finished;
- window = MODEST_MSG_VIEW_WINDOW(modest_msg_view_window_new (msg, account_name));
- g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), NULL);
+ g_return_val_if_fail (gtk_tree_row_reference_valid (*row_reference), FALSE);
- priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
+ 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;
- g_object_ref (model);
- priv->header_model = model;
- priv->iter = iter;
+ finished = FALSE;
+ do {
+ TnyHeader *header = NULL;
- modest_msg_view_window_update_priority (window);
+ 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);
+ 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;
+ }
+ } 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);
- modest_msg_view_window_update_dimmed (window);
+ /* Free */
+ gtk_tree_path_free (path);
+ if (next)
+ gtk_tree_path_free (next);
- 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,
+ const gchar *modest_account_name,
+ const gchar *msg_uid)
{
- GObject *obj;
- ModestMsgViewWindowPrivate *priv;
- ModestWindowPrivate *parent_priv;
- GtkActionGroup *action_group;
- GError *error = NULL;
- GdkPixbuf *window_icon = NULL;
+ GObject *obj = NULL;
+ ModestMsgViewWindowPrivate *priv = NULL;
+ ModestWindowPrivate *parent_priv = NULL;
+ ModestDimmingRulesGroup *menu_rules_group = NULL;
+ ModestDimmingRulesGroup *toolbar_rules_group = NULL;
+ ModestDimmingRulesGroup *clipboard_rules_group = NULL;
- g_return_val_if_fail (msg, NULL);
-
- 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);
-
- parent_priv->ui_manager = gtk_ui_manager_new();
- action_group = gtk_action_group_new ("ModestMsgViewWindowActions");
- gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
- /* Add common actions */
- gtk_action_group_add_actions (action_group,
- modest_action_entries,
- G_N_ELEMENTS (modest_action_entries),
- obj);
- gtk_action_group_add_toggle_actions (action_group,
- modest_toggle_action_entries,
- G_N_ELEMENTS (modest_toggle_action_entries),
- obj);
- gtk_action_group_add_toggle_actions (action_group,
- msg_view_toggle_action_entries,
- G_N_ELEMENTS (msg_view_toggle_action_entries),
- obj);
- gtk_action_group_add_radio_actions (action_group,
- msg_view_zoom_action_entries,
- G_N_ELEMENTS (msg_view_zoom_action_entries),
- 100,
- G_CALLBACK (modest_ui_actions_on_change_zoom),
- obj);
+ priv->msg_uid = g_strdup (msg_uid);
- gtk_ui_manager_insert_action_group (parent_priv->ui_manager, action_group, 0);
- g_object_unref (action_group);
+ /* Menubar */
+ 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 (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,
+ modest_msg_view_menu_dimming_entries,
+ G_N_ELEMENTS (modest_msg_view_menu_dimming_entries),
+ MODEST_WINDOW (self));
+ modest_dimming_rules_group_add_rules (toolbar_rules_group,
+ modest_msg_view_toolbar_dimming_entries,
+ G_N_ELEMENTS (modest_msg_view_toolbar_dimming_entries),
+ MODEST_WINDOW (self));
+ modest_dimming_rules_group_add_rules (clipboard_rules_group,
+ modest_msg_view_clipboard_dimming_entries,
+ G_N_ELEMENTS (modest_msg_view_clipboard_dimming_entries),
+ MODEST_WINDOW (self));
+
+ /* Insert dimming rules group for this window */
+ modest_ui_dimming_manager_insert_rules_group (parent_priv->ui_dimming_manager, menu_rules_group);
+ modest_ui_dimming_manager_insert_rules_group (parent_priv->ui_dimming_manager, toolbar_rules_group);
+ modest_ui_dimming_manager_insert_rules_group (parent_priv->ui_dimming_manager, clipboard_rules_group);
+ g_object_unref (menu_rules_group);
+ g_object_unref (toolbar_rules_group);
+ g_object_unref (clipboard_rules_group);
- /* Load the UI definition */
- gtk_ui_manager_add_ui_from_file (parent_priv->ui_manager, MODEST_UIDIR "modest-msg-view-window-ui.xml",
- &error);
- if (error) {
- g_printerr ("modest: could not merge modest-msg-view-window-ui.xml: %s\n", error->message);
- g_error_free (error);
- error = NULL;
- }
- /* ****** */
-
- /* Add accelerators */
- gtk_window_add_accel_group (GTK_WINDOW (obj),
- gtk_ui_manager_get_accel_group (parent_priv->ui_manager));
-
- /* Init window */
- 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);
+ /* g_signal_connect (G_OBJECT(obj), "delete-event", G_CALLBACK(on_delete_event), obj); */
- g_signal_connect (G_OBJECT(priv->msg_view), "link_clicked",
+ 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);
+ g_signal_connect (G_OBJECT(priv->msg_view), "activate_link",
G_CALLBACK (modest_ui_actions_on_msg_link_clicked), obj);
g_signal_connect (G_OBJECT(priv->msg_view), "link_hover",
G_CALLBACK (modest_ui_actions_on_msg_link_hover), obj);
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_release_event),
+ G_CALLBACK (modest_msg_view_window_key_event),
+ NULL);
+
+ g_signal_connect (G_OBJECT (obj), "key-press-event",
+ G_CALLBACK (modest_msg_view_window_key_event),
NULL);
g_signal_connect (G_OBJECT (obj), "window-state-event",
G_CALLBACK (modest_msg_view_window_window_state_event),
NULL);
+ g_signal_connect (G_OBJECT (obj), "move-focus",
+ G_CALLBACK (on_move_focus), obj);
+
/* Mail Operation Queue */
priv->queue_change_handler = g_signal_connect (G_OBJECT (modest_runtime_get_mail_operation_queue ()),
"queue-changed",
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);
+
+ 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->last_search = NULL;
- modest_msg_view_window_update_dimmed (MODEST_MSG_VIEW_WINDOW (obj));
+ /* Init the clipboard actions dim status */
+ modest_msg_view_grab_focus(MODEST_MSG_VIEW (priv->msg_view));
- /* Set window icon */
- window_icon = modest_platform_get_icon (MODEST_APP_MSG_VIEW_ICON);
- gtk_window_set_icon (GTK_WINDOW (obj), window_icon);
+ update_window_title (MODEST_MSG_VIEW_WINDOW (obj));
+
+
+}
+
+/* FIXME: parameter checks */
+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;
+ 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);
+
+ modest_msg_view_window_construct (window, 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: */
+
+ main_window = modest_window_mgr_get_main_window(mgr, FALSE); /* don't create */
+ if (main_window) {
+ header_view = MODEST_HEADER_VIEW(modest_main_window_get_child_widget(
+ MODEST_MAIN_WINDOW(main_window),
+ MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW));
+ }
+
+ if (header_view != NULL){
+ header_folder = modest_header_view_get_folder(header_view);
+ /* 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);
+ }
+ }
+
+ /* 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, priv->is_outbox);
+ } else {
+ priv->row_reference = NULL;
+ priv->next_row_reference = NULL;
+ }
+
+ /* 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,
+ MODEST_HEADER_VIEW_OBSERVER(window));
+ }
+
+ 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 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);
+}
+
+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;
+ ModestWindowMgr *mgr = 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, 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;
+
+ 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);
+}
+
+ModestWindow *
+modest_msg_view_window_new_for_attachment (TnyMsg *msg,
+ const gchar *modest_account_name,
+ const gchar *msg_uid)
+{
+ GObject *obj = NULL;
+ ModestMsgViewWindowPrivate *priv;
+ ModestWindowMgr *mgr = NULL;
+
+ g_return_val_if_fail (msg, NULL);
+ mgr = modest_runtime_get_window_mgr ();
+ obj = G_OBJECT (modest_window_mgr_get_msg_view_window (mgr));
+ priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (obj);
+ 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);
+ update_window_title (MODEST_MSG_VIEW_WINDOW (obj));
- gtk_widget_grab_focus (priv->msg_view);
+ 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);
}
+static void
+modest_msg_view_window_on_row_changed (GtkTreeModel *header_model,
+ GtkTreePath *arg1,
+ GtkTreeIter *arg2,
+ ModestMsgViewWindow *window)
+{
+ check_dimming_rules_after_change (window);
+}
+
+static void
+modest_msg_view_window_on_row_deleted(GtkTreeModel *header_model,
+ GtkTreePath *arg1,
+ ModestMsgViewWindow *window)
+{
+ check_dimming_rules_after_change (window);
+}
+
+static gboolean
+check_dimming_rules_after_change_in_idle (gpointer data)
+{
+ /* The window could have dissapeared */
+ if (MODEST_IS_WINDOW (data)) {
+ ModestWindow *win = MODEST_WINDOW (data);
+ gdk_threads_enter ();
+ modest_ui_actions_check_menu_dimming_rules (win);
+ modest_ui_actions_check_toolbar_dimming_rules (win);
+ gdk_threads_leave ();
+ }
+
+ return FALSE;
+}
+
+static void
+check_dimming_rules_after_change (ModestMsgViewWindow *window)
+{
+ static guint dimming_delayer = 0;
+
+ if (dimming_delayer > 0)
+ g_source_remove (dimming_delayer);
+
+ /* We're expecting a lot of changes at the same time so don't
+ need to check dimming rules for every change that
+ happens */
+ dimming_delayer = g_timeout_add (100, check_dimming_rules_after_change_in_idle, 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.)
+ */
+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;
+
+ g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
+ priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
+
+ 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 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));
+ }
+
+ 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 (priv->header_model, tree_path);
+ if (priv->row_reference == NULL) {
+ g_warning("No reference for msg header item.");
+ return;
+ }
+
+ /* Now set up next_row_reference. */
+ 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 (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);
+}
+
+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
+ * 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.
+ */
+static 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(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 (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);
+
+ /* 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;
+ }
+
+ 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 (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
+modest_msg_view_window_toolbar_on_transfer_mode (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->current_toolbar_mode == TOOLBAR_MODE_TRANSFER;
+}
+
+TnyHeader*
+modest_msg_view_window_get_header (ModestMsgViewWindow *self)
+{
+ ModestMsgViewWindowPrivate *priv= NULL;
+ TnyMsg *msg = NULL;
+ TnyHeader *header = NULL;
+ GtkTreePath *path = NULL;
+ GtkTreeIter iter;
+
+ g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self), NULL);
+ priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (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 ||
+ !gtk_tree_row_reference_valid (priv->row_reference)) {
+ msg = modest_msg_view_window_get_message (self);
+ if (msg) {
+ header = tny_msg_get_header (msg);
+ g_object_unref (msg);
+ }
+ return header;
+ }
+
+ /* Get iter of the currently selected message in the header view: */
+ 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,
+ &iter,
+ path);
+
+ /* Get current message header */
+ gtk_tree_model_get (priv->header_model, &iter,
+ TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
+ &header, -1);
+ gtk_tree_path_free (path);
+ return header;
+}
TnyMsg*
modest_msg_view_window_get_message (ModestMsgViewWindow *self)
{
- ModestMsgView *msg_view;
ModestMsgViewWindowPrivate *priv;
-
+
g_return_val_if_fail (self, NULL);
-
+
priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
-
- msg_view = MODEST_MSG_VIEW (priv->msg_view);
-
- return modest_msg_view_get_message (msg_view);
+
+ return tny_msg_view_get_msg (TNY_MSG_VIEW (priv->msg_view));
}
const gchar*
modest_msg_view_window_get_message_uid (ModestMsgViewWindow *self)
{
- TnyMsg *msg;
- TnyHeader *header;
- const gchar *retval = NULL;
-
- msg = modest_msg_view_window_get_message (self);
+ ModestMsgViewWindowPrivate *priv;
- if (!msg)
- return NULL;
+ g_return_val_if_fail (self, NULL);
+
+ priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self);
- header = tny_msg_get_header (msg);
- if (header) {
- retval = tny_header_get_uid (header);
- g_object_unref (header);
- }
- return retval;
+ return (const gchar*) priv->msg_uid;
}
static void
{
ModestMsgViewWindow *window = MODEST_MSG_VIEW_WINDOW (data);
ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
+ ModestWindowPrivate *parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
+ gboolean is_active;
+ GtkAction *action;
- if (gtk_toggle_action_get_active (toggle)) {
+ is_active = gtk_toggle_action_get_active (toggle);
+
+ if (is_active) {
gtk_widget_show (priv->find_toolbar);
+ hildon_find_toolbar_highlight_entry (HILDON_FIND_TOOLBAR (priv->find_toolbar), TRUE);
} else {
gtk_widget_hide (priv->find_toolbar);
}
+ /* update the toggle buttons status */
+ action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/FindInMessage");
+ modest_utils_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");
+ modest_utils_toggle_action_set_active_block_notify (GTK_TOGGLE_ACTION (action), is_active);
}
{
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
gchar *current_search;
ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (obj);
+ if (modest_mime_part_view_is_empty (MODEST_MIME_PART_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)) {
+ 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"));
return;
}
gboolean result;
g_free (priv->last_search);
priv->last_search = g_strdup (current_search);
- result = modest_msg_view_search (MODEST_MSG_VIEW (priv->msg_view),
- priv->last_search);
+ 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"));
+ 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 {
- modest_msg_view_search_next (MODEST_MSG_VIEW (priv->msg_view));
+ 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"));
+ 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);
+ }
}
g_free (current_search);
gdouble zoom)
{
ModestMsgViewWindowPrivate *priv;
+ ModestWindowPrivate *parent_priv;
+ GtkAction *action = NULL;
+ gint int_zoom = (gint) rint (zoom*100.0+0.1);
g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
- modest_msg_view_set_zoom (MODEST_MSG_VIEW (priv->msg_view), zoom);
+ parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
+ modest_zoomable_set_zoom (MODEST_ZOOMABLE (priv->msg_view), zoom);
+
+ action = gtk_ui_manager_get_action (parent_priv->ui_manager,
+ "/MenuBar/ViewMenu/ZoomMenu/Zoom50Menu");
+
+ gtk_radio_action_set_current_value (GTK_RADIO_ACTION (action), int_zoom);
}
static gdouble
g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), 1.0);
priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
- return modest_msg_view_get_zoom (MODEST_MSG_VIEW (priv->msg_view));
+ return modest_zoomable_get_zoom (MODEST_ZOOMABLE (priv->msg_view));
}
static gboolean
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, _("mcen_ib_max_zoom_level"));
+ hildon_banner_show_information (NULL, NULL, dgettext("hildon-common-strings", "ckct_ib_max_zoom_level_reached"));
return FALSE;
}
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (node->next->data), TRUE);
return TRUE;
} else {
- hildon_banner_show_information (NULL, NULL, _("mcen_ib_min_zoom_level"));
+ hildon_banner_show_information (NULL, NULL, dgettext("hildon-common-strings", "ckct_ib_min_zoom_level_reached"));
return FALSE;
}
break;
}
static gboolean
-modest_msg_view_window_key_release_event (GtkWidget *window,
- GdkEventKey *event,
- gpointer userdata)
-{
- if (event->type == GDK_KEY_RELEASE) {
- switch (event->keyval) {
- case GDK_Up:
- modest_msg_view_window_scroll_up (MODEST_WINDOW (window));
+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;
- break;
- case GDK_Down:
- modest_msg_view_window_scroll_down (MODEST_WINDOW (window));
+ } 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;
+
+ if (event->type == GDK_KEY_RELEASE) {
+ GtkScrollType scroll_type;
+
+ switch (event->keyval) {
+ case GDK_Up:
+ case GDK_KP_Up:
+ scroll_type = GTK_SCROLL_STEP_UP; break;
+ case GDK_Down:
+ case GDK_KP_Down:
+ scroll_type = GTK_SCROLL_STEP_DOWN; break;
+ case GDK_Page_Up:
+ case GDK_KP_Page_Up:
+ scroll_type = GTK_SCROLL_PAGE_UP; break;
+ case GDK_Page_Down:
+ case GDK_KP_Page_Down:
+ scroll_type = GTK_SCROLL_PAGE_DOWN; break;
+ case GDK_Home:
+ case GDK_KP_Home:
+ scroll_type = GTK_SCROLL_START; break;
+ case GDK_End:
+ case GDK_KP_End:
+ scroll_type = GTK_SCROLL_END; break;
+ 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;
- break;
- default:
+ } else {
return FALSE;
- break;
- };
+ }
} else {
return FALSE;
}
}
-static void
-modest_msg_view_window_scroll_up (ModestWindow *window)
+gboolean
+modest_msg_view_window_last_message_selected (ModestMsgViewWindow *window)
{
+ GtkTreePath *path;
ModestMsgViewWindowPrivate *priv;
+ GtkTreeIter tmp_iter;
+ gboolean is_last_selected;
+ g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), TRUE);
priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
- g_signal_emit_by_name (G_OBJECT (priv->main_scroll), "scroll-child", GTK_SCROLL_STEP_UP, FALSE);
+
+ /*if no model (so no rows at all), then virtually we are the last*/
+ if (!priv->header_model || !priv->row_reference)
+ 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 (header) {
+ if (msg_is_visible (header, priv->is_outbox))
+ is_last_selected = FALSE;
+ g_object_unref(G_OBJECT(header));
+ }
+ }
+ gtk_tree_path_free (path);
+ return is_last_selected;
}
-static void
-modest_msg_view_window_scroll_down (ModestWindow *window)
+gboolean
+modest_msg_view_window_has_headers_model (ModestMsgViewWindow *window)
{
ModestMsgViewWindowPrivate *priv;
+ g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), TRUE);
priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
- g_signal_emit_by_name (G_OBJECT (priv->main_scroll), "scroll-child", GTK_SCROLL_STEP_DOWN, FALSE);
+
+ return priv->header_model != NULL;
}
-static gboolean
-modest_msg_view_window_is_last_message (ModestMsgViewWindow *window)
+gboolean
+modest_msg_view_window_is_search_result (ModestMsgViewWindow *window)
{
- GtkTreePath *path;
ModestMsgViewWindowPrivate *priv;
- GtkTreeIter tmp_iter;
- gboolean has_next = FALSE;
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_model_get_path (priv->header_model, &priv->iter);
- if (!path)
- return TRUE;
- 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 {
+ return priv->is_search_result;
+}
+
+static gboolean
+msg_is_visible (TnyHeader *header, gboolean check_outbox)
+{
+ 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));
}
-
}
-static gboolean
-modest_msg_view_window_is_first_message (ModestMsgViewWindow *window)
+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_model_get_path (priv->header_model, &priv->iter);
- if (!path)
- return TRUE;
+ /*if no model (so no rows at all), then virtually we are the first*/
+ if (!priv->header_model || !priv->row_reference)
+ 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);
+ 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 (header) {
+ if (msg_is_visible (header, priv->is_outbox))
+ is_first_selected = FALSE;
+ g_object_unref(G_OBJECT(header));
}
- gtk_tree_path_free (path);
- return result;
- } else {
+ }
+ gtk_tree_path_free (path);
+ return is_first_selected;
+}
+
+typedef struct {
+ TnyHeader *header;
+ 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);
+ modest_mail_operation_get_msg (mail_op, info->header, TRUE, view_msg_cb, info->row_reference);
+ 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_object_unref (info->header);
+ g_slice_free (MsgReaderInfo, info);
+}
+
+
+/**
+ * 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)
+{
+ gboolean already_showing = FALSE;
+ ModestWindow *msg_window = NULL;
+ ModestWindowMgr *mgr;
+ TnyAccount *account;
+ TnyFolder *folder;
+ MsgReaderInfo *info;
+
+ g_return_val_if_fail (row_reference != 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)) {
+ /* Ask the user if he wants to download the message if
+ we're not online */
+ if (!tny_device_is_online (modest_runtime_get_device())) {
+ GtkResponseType response;
+
+ response = modest_platform_run_confirmation_dialog (GTK_WINDOW (window),
+ _("mcen_nc_get_msg"));
+ if (response == GTK_RESPONSE_CANCEL)
+ return FALSE;
+
+ folder = tny_header_get_folder (header);
+ info = g_slice_new (MsgReaderInfo);
+ info->header = g_object_ref (header);
+ info->row_reference = gtk_tree_row_reference_copy (row_reference);
+
+ /* Offer the connection dialog if necessary */
+ modest_platform_connect_if_remote_and_perform ((GtkWindow *) window,
+ TRUE,
+ TNY_FOLDER_STORE (folder),
+ message_reader_performer,
+ info);
+ g_object_unref (folder);
+ return TRUE;
+ }
+ }
+
+ folder = tny_header_get_folder (header);
+ account = tny_folder_get_account (folder);
+ info = g_slice_new (MsgReaderInfo);
+ info->header = g_object_ref (header);
+ info->row_reference = gtk_tree_row_reference_copy (row_reference);
+ message_reader_performer (FALSE, NULL, (GtkWindow *) window, account, info);
+ g_object_unref (account);
+ g_object_unref (folder);
+
+ return TRUE;
}
gboolean
modest_msg_view_window_select_next_message (ModestMsgViewWindow *window)
{
- ModestMailOperation *mail_op = NULL;
ModestMsgViewWindowPrivate *priv;
+ GtkTreePath *path= NULL;
GtkTreeIter tmp_iter;
+ TnyHeader *header;
+ gboolean retval = TRUE;
+ GtkTreeRowReference *row_reference = NULL;
g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window), FALSE);
priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
- if (priv->header_model) {
- tmp_iter = priv->iter;
- while (gtk_tree_model_iter_next (priv->header_model, &tmp_iter)) {
- TnyHeader *header;
- guint op_status;
-
- priv->iter = tmp_iter;
- gtk_tree_model_get (priv->header_model, &(priv->iter), TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
- &header, -1);
- if (!header)
- break;
- if (tny_header_get_flags (header) & TNY_HEADER_FLAG_DELETED)
- continue;
+ if (!priv->row_reference)
+ return FALSE;
- /* New mail operation */
- mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(window));
- modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
- modest_mail_operation_get_msg (mail_op, header, view_msg_cb, NULL);
- op_status = modest_mail_operation_get_status (mail_op);
+ /* 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, priv->is_outbox);
+ }
+ }
+ if (priv->next_row_reference)
+ path = gtk_tree_row_reference_get_path (priv->next_row_reference);
+ if (path == NULL)
+ return FALSE;
- g_object_unref (mail_op);
+ row_reference = gtk_tree_row_reference_copy (priv->next_row_reference);
- if (op_status == MODEST_MAIL_OPERATION_STATUS_FAILED)
- return FALSE;
- else
- return TRUE;
- }
+ gtk_tree_model_get_iter (priv->header_model,
+ &tmp_iter,
+ path);
+ gtk_tree_path_free (path);
- return FALSE;
- } else {
- return FALSE;
+ 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, row_reference)) {
+ retval = FALSE;
}
+ gtk_tree_row_reference_free (row_reference);
+
+ /* Free */
+ g_object_unref (header);
+
+ return retval;
}
gboolean
modest_msg_view_window_select_previous_message (ModestMsgViewWindow *window)
{
ModestMsgViewWindowPrivate *priv = NULL;
- ModestMailOperation *mail_op = NULL;
+ GtkTreePath *path;
+ 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);
- if (priv->header_model) {
- GtkTreePath *path;
-
- path = gtk_tree_model_get_path (priv->header_model, &(priv->iter));
- while (gtk_tree_path_prev (path)) {
- TnyHeader *header;
- guint op_status;
+ /* Return inmediatly if there is no header model */
+ if (!priv->header_model || !priv->row_reference)
+ return FALSE;
- gtk_tree_model_get_iter (priv->header_model, &(priv->iter), path);
- gtk_tree_model_get (priv->header_model, &(priv->iter), TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
- &header, -1);
- if (!header)
- break;
- if (tny_header_get_flags (header) & TNY_HEADER_FLAG_DELETED)
- continue;
-
- /* New mail operation */
- mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE, G_OBJECT(window));
- modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
- modest_mail_operation_get_msg (mail_op, header, view_msg_cb, NULL);
-
- gtk_tree_path_free (path);
+ path = gtk_tree_row_reference_get_path (priv->row_reference);
+ while (!finished && gtk_tree_path_prev (path)) {
+ TnyHeader *header;
+ GtkTreeIter iter;
- op_status = modest_mail_operation_get_status (mail_op);
- if (op_status == MODEST_MAIL_OPERATION_STATUS_FAILED)
- return FALSE;
- else
- return TRUE;
+ gtk_tree_model_get_iter (priv->header_model, &iter, path);
+ gtk_tree_model_get (priv->header_model, &iter,
+ TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
+ &header, -1);
+ 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, row_reference);
+ gtk_tree_row_reference_free (row_reference);
+ } else {
+ finished = FALSE;
+ }
+ g_object_unref (header);
}
- } else {
- return FALSE;
}
- return FALSE;
+ gtk_tree_path_free (path);
+ return retval;
}
static void
-view_msg_cb(const GObject *obj, const TnyMsg *msg, gpointer user_data)
+view_msg_cb (ModestMailOperation *mail_op,
+ TnyHeader *header,
+ gboolean canceled,
+ TnyMsg *msg,
+ GError *error,
+ gpointer user_data)
{
ModestMsgViewWindow *self = NULL;
ModestMsgViewWindowPrivate *priv = NULL;
- TnyMsg *new_msg = NULL;
-
- g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (obj));
- g_return_if_fail (TNY_IS_MSG (msg));
- self = MODEST_MSG_VIEW_WINDOW (obj);
+ GtkTreeRowReference *row_reference = NULL;
+
+ /* 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) {
+ 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);
+ return;
+ }
+
+ /* Get the window */
+ self = (ModestMsgViewWindow *) modest_mail_operation_get_source (mail_op);
+ g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self));
priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self);
+ /* Update the 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 */
- new_msg = g_object_ref (G_OBJECT(msg));
- modest_msg_view_set_message (MODEST_MSG_VIEW (priv->msg_view), new_msg);
- modest_msg_view_window_update_dimmed (self);
- modest_msg_view_window_update_priority (self);
- gtk_widget_grab_focus (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) {
+ g_free (priv->msg_uid);
+ priv->msg_uid = modest_tny_folder_get_header_unique_id (header);
+ }
+
+ /* Notify the observers */
+ g_signal_emit (G_OBJECT (self), signals[MSG_CHANGED_SIGNAL],
+ 0, priv->header_model, priv->row_reference);
+
+ /* Frees */
+ g_object_unref (self);
+ gtk_tree_row_reference_free (row_reference);
}
-static TnyFolderType
+TnyFolderType
modest_msg_view_window_get_folder_type (ModestMsgViewWindow *window)
{
ModestMsgViewWindowPrivate *priv;
folder_type = TNY_FOLDER_TYPE_UNKNOWN;
- msg = modest_msg_view_get_message (MODEST_MSG_VIEW (priv->msg_view));
+ msg = tny_msg_view_get_msg (TNY_MSG_VIEW (priv->msg_view));
if (msg) {
TnyFolder *folder;
folder = tny_msg_get_folder (msg);
-
if (folder) {
- folder_type = tny_folder_get_folder_type (folder);
-
- if (folder_type == TNY_FOLDER_TYPE_NORMAL || folder_type == TNY_FOLDER_TYPE_UNKNOWN) {
- const gchar *fname = tny_folder_get_name (folder);
- folder_type = modest_tny_folder_guess_folder_type_from_name (fname);
- }
-
+ folder_type = modest_tny_folder_guess_folder_type (folder);
g_object_unref (folder);
}
+ g_object_unref (msg);
}
return folder_type;
}
-static void
-modest_msg_view_window_update_dimmed (ModestMsgViewWindow *window)
-{
- ModestWindowPrivate *parent_priv;
- GtkAction *widget;
- gboolean is_first, is_last;
- TnyFolderType folder_type;
- gboolean is_not_sent;
-
- parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
-
- is_first = modest_msg_view_window_is_first_message (window);
- is_last = modest_msg_view_window_is_last_message (window);
-
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageBack");
- gtk_action_set_sensitive (widget, !is_first);
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ViewMenu/ViewPreviousMessageMenu");
- gtk_action_set_sensitive (widget, !is_first);
-
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNext");
- gtk_action_set_sensitive (widget, !is_last);
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ViewMenu/ViewNextMessageMenu");
- gtk_action_set_sensitive (widget, !is_last);
-
- folder_type = modest_msg_view_window_get_folder_type (MODEST_MSG_VIEW_WINDOW (window));
- is_not_sent = ((folder_type == TNY_FOLDER_TYPE_DRAFTS)||(folder_type == TNY_FOLDER_TYPE_OUTBOX));
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageReply");
- gtk_action_set_sensitive (widget, !is_not_sent);
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/MessageMenu/MessageReplyMenu");
- gtk_action_set_sensitive (widget, !is_not_sent);
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/MessageMenu/MessageReplyAllMenu");
- gtk_action_set_sensitive (widget, !is_not_sent);
- widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/MessageMenu/MessageForwardMenu");
- gtk_action_set_sensitive (widget, !is_not_sent);
-
-}
static void
modest_msg_view_window_update_priority (ModestMsgViewWindow *window)
{
ModestMsgViewWindowPrivate *priv;
+ TnyHeader *header = NULL;
TnyHeaderFlags flags = 0;
priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
- if (priv->header_model) {
- TnyHeader *header;
+ if (priv->header_model && priv->row_reference) {
+ GtkTreeIter iter;
+ GtkTreePath *path = NULL;
- gtk_tree_model_get (priv->header_model, &(priv->iter), TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
+ path = gtk_tree_row_reference_get_path (priv->row_reference);
+ g_return_if_fail (path != NULL);
+ gtk_tree_model_get_iter (priv->header_model,
+ &iter,
+ gtk_tree_row_reference_get_path (priv->row_reference));
+
+ gtk_tree_model_get (priv->header_model, &iter, TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
&header, -1);
+ gtk_tree_path_free (path);
+ } else {
+ TnyMsg *msg;
+ msg = tny_msg_view_get_msg (TNY_MSG_VIEW (priv->msg_view));
+ if (msg) {
+ header = tny_msg_get_header (msg);
+ g_object_unref (msg);
+ }
+ }
+
+ if (header) {
flags = tny_header_get_flags (header);
+ g_object_unref(G_OBJECT(header));
}
modest_msg_view_set_priority (MODEST_MSG_VIEW(priv->msg_view), flags);
}
+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)
{
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;
}
-void
-modest_msg_view_window_toggle_fullscreen (ModestMsgViewWindow *window)
-{
- ModestWindowPrivate *parent_priv;
- GtkAction *fs_toggle_action;
- parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
-
- fs_toggle_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ViewMenu/ViewToggleFullscreenMenu");
- gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (fs_toggle_action),
- !gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (fs_toggle_action)));
-}
-
-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)
GtkWidget *reply_button = NULL, *menu = NULL;
GtkWidget *placeholder = NULL;
gint insert_index;
+ const gchar *action_name;
+ GtkAction *action;
parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
if (!parent_priv->toolbar) {
parent_priv->toolbar = gtk_ui_manager_get_widget (parent_priv->ui_manager,
"/ToolBar");
-
- /* Set homogeneous toolbar */
- gtk_container_foreach (GTK_CONTAINER (parent_priv->toolbar),
- set_homogeneous, NULL);
+ gtk_widget_set_no_show_all (parent_priv->toolbar, TRUE);
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), FALSE);
- gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
- 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));
hildon_window_add_toolbar (HILDON_WINDOW (self),
GTK_TOOLBAR (parent_priv->toolbar));
-
/* Set reply button tap and hold menu */
reply_button = gtk_ui_manager_get_widget (parent_priv->ui_manager,
"/ToolBar/ToolbarMessageReply");
/* Quick hack: this prevents toolbar icons "dance" when progress bar show status is changed */
/* TODO: resize mode migth be GTK_RESIZE_QUEUE, in order to avoid unneccesary shows */
gtk_container_set_resize_mode (GTK_CONTAINER(parent_priv->toolbar), GTK_RESIZE_IMMEDIATE);
-
+
gtk_widget_show (GTK_WIDGET (parent_priv->toolbar));
- set_toolbar_mode (MODEST_MSG_VIEW_WINDOW(self), TOOLBAR_MODE_NORMAL);
+ if (modest_msg_view_window_transfer_mode_enabled (MODEST_MSG_VIEW_WINDOW (self)))
+ set_toolbar_mode (MODEST_MSG_VIEW_WINDOW (self), TOOLBAR_MODE_TRANSFER);
+ else
+ set_toolbar_mode (MODEST_MSG_VIEW_WINDOW (self), TOOLBAR_MODE_NORMAL);
+
} else {
gtk_widget_set_no_show_all (parent_priv->toolbar, TRUE);
gtk_widget_hide (GTK_WIDGET (parent_priv->toolbar));
}
+
+ /* Update also the actions (to update the toggles in the
+ menus), we have to do it manually because some other window
+ of the same time could have changed it (remember that the
+ toolbar fullscreen mode is shared by all the windows of the
+ same type */
+ if (modest_window_mgr_get_fullscreen_mode (modest_runtime_get_window_mgr ()))
+ action_name = "/MenuBar/ViewMenu/ViewShowToolbarMenu/ViewShowToolbarFullScreenMenu";
+ else
+ action_name = "/MenuBar/ViewMenu/ViewShowToolbarMenu/ViewShowToolbarNormalScreenMenu";
+
+ action = gtk_ui_manager_get_action (parent_priv->ui_manager, action_name);
+ modest_utils_toggle_action_set_active_block_notify (GTK_TOGGLE_ACTION (action),
+ show_toolbar);
}
static void
GdkEvent *event,
ModestMsgViewWindow *window)
{
- ModestWindowPrivate *parent_priv;
- GtkAction *action;
- gboolean is_address;
- gchar *selection;
+ if (!GTK_WIDGET_VISIBLE (window))
+ return;
- parent_priv = MODEST_WINDOW_GET_PRIVATE (window);
- selection = gtk_clipboard_wait_for_text (clipboard);
+ modest_window_check_dimming_rules_group (MODEST_WINDOW (window), MODEST_DIMMING_RULES_CLIPBOARD);
+}
- g_message ("SELECTION %s", selection);
- is_address = ((selection != NULL) && (modest_text_utils_validate_recipient (selection)));
- g_free (selection);
-
- action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ToolsMenu/ToolsAddToContactsMenu");
- gtk_action_set_sensitive (action, is_address);
+gboolean
+modest_msg_view_window_transfer_mode_enabled (ModestMsgViewWindow *self)
+{
+ ModestMsgViewWindowPrivate *priv;
+ g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self), FALSE);
+ priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
+
+ return priv->current_toolbar_mode == TOOLBAR_MODE_TRANSFER;
}
static void
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_mail_operation_started (ModestMailOperation *mail_op,
+ gpointer user_data)
+{
+ ModestMsgViewWindow *self;
+ 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;
+ source = modest_mail_operation_get_source(mail_op);
+ if (G_OBJECT (self) == source) {
+ 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);
+ }
+ }
+ }
+ g_object_unref (source);
+}
+
+static void
+on_mail_operation_finished (ModestMailOperation *mail_op,
+ gpointer user_data)
+{
+ ModestMsgViewWindow *self;
+ ModestMailOperationTypeOperation op_type;
+ GSList *tmp;
+ ModestMsgViewWindowPrivate *priv;
+
+ 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 ) {
+ while (tmp) {
+ modest_progress_object_remove_operation (MODEST_PROGRESS_OBJECT (tmp->data),
+ mail_op);
+ tmp = g_slist_next (tmp);
+ }
+
+ /* If no more operations are being observed, NORMAL mode is enabled again */
+ 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));
+ }
+}
static void
on_queue_changed (ModestMailOperationQueue *queue,
ModestMailOperation *mail_op,
ModestMailOperationQueueNotification type,
ModestMsgViewWindow *self)
-{
- GSList *tmp;
+{
ModestMsgViewWindowPrivate *priv;
- ModestMailOperationId op_id;
- ModestToolBarModes mode;
-
- g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self));
- priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
+
+ priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (self);
/* If this operations was created by another window, do nothing */
if (!modest_mail_operation_is_mine (mail_op, G_OBJECT(self)))
return;
- /* Get toolbar mode from operation id*/
- op_id = modest_mail_operation_get_id (mail_op);
- switch (op_id) {
- case MODEST_MAIL_OPERATION_ID_SEND:
- case MODEST_MAIL_OPERATION_ID_RECEIVE:
- mode = TOOLBAR_MODE_TRANSFER;
- break;
- default:
- mode = TOOLBAR_MODE_NORMAL;
-
+ if (type == MODEST_MAIL_OPERATION_QUEUE_OPERATION_ADDED) {
+ priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
+ G_OBJECT (mail_op),
+ "operation-started",
+ G_CALLBACK (on_mail_operation_started),
+ self);
+ priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
+ G_OBJECT (mail_op),
+ "operation-finished",
+ G_CALLBACK (on_mail_operation_finished),
+ self);
+ } else if (type == MODEST_MAIL_OPERATION_QUEUE_OPERATION_REMOVED) {
+ priv->sighandlers = modest_signal_mgr_disconnect (priv->sighandlers,
+ G_OBJECT (mail_op),
+ "operation-started");
+ priv->sighandlers = modest_signal_mgr_disconnect (priv->sighandlers,
+ G_OBJECT (mail_op),
+ "operation-finished");
}
+}
+
+TnyList *
+modest_msg_view_window_get_attachments (ModestMsgViewWindow *win)
+{
+ ModestMsgViewWindowPrivate *priv;
+ TnyList *selected_attachments = NULL;
+
+ g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (win), NULL);
+ priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (win);
+
+ selected_attachments = modest_msg_view_get_selected_attachments (MODEST_MSG_VIEW (priv->msg_view));
+
+ return selected_attachments;
+}
+
+void
+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;
+ TnyList *attachments;
+
+ g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
+ g_return_if_fail (TNY_IS_MIME_PART (mime_part) || (mime_part == NULL));
+ priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
+
+ 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 = 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);
+ }
+
+ if (mime_part == NULL) {
+ gboolean error = FALSE;
+ 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 (tny_list_get_length (selected_attachments) > 1) {
+ hildon_banner_show_information (NULL, NULL, _("mcen_ib_unable_to_display_more"));
+ error = TRUE;
+ } else {
+ TnyIterator *iter;
+ iter = tny_list_create_iterator (selected_attachments);
+ mime_part = (TnyMimePart *) tny_iterator_get_current (iter);
+ g_object_unref (iter);
+ }
+ g_object_unref (selected_attachments);
+
+ if (error)
+ return;
+ } else {
+ g_object_ref (mime_part);
+ }
+
+ if (tny_mime_part_is_purged (mime_part)) {
+ g_object_unref (mime_part);
+ return;
+ }
+
+ if (!modest_tny_mime_part_is_msg (mime_part)) {
+ gchar *filepath = NULL;
+ const gchar *att_filename = tny_mime_part_get_filename (mime_part);
+ const gchar *content_type;
+ gboolean show_error_banner = FALSE;
+ GError *err;
+ TnyFsStream *temp_stream = NULL;
+ temp_stream = modest_utils_create_temp_stream (att_filename, attachment_uid,
+ &filepath);
- /* Add operation observers and change toolbar if neccessary*/
- tmp = priv->progress_widgets;
- switch (type) {
- case MODEST_MAIL_OPERATION_QUEUE_OPERATION_ADDED:
- if (mode == TOOLBAR_MODE_TRANSFER) {
- while (tmp) {
- modest_progress_object_add_operation (MODEST_PROGRESS_OBJECT (tmp->data),
- mail_op);
- tmp = g_slist_next (tmp);
+ if (temp_stream != NULL) {
+ content_type = tny_mime_part_get_content_type (mime_part);
+ if (tny_mime_part_decode_to_stream (mime_part, TNY_STREAM (temp_stream), &err) >= 0) {
+ /* 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);
+ } else {
+ /* error while saving attachment, maybe cerm_device_memory_full */
+ show_error_banner = TRUE;
+ if (err != NULL) {
+ g_warning ("%s: tny_mime_part_decode_to_stream failed (%s)", __FUNCTION__, err->message);
+ g_error_free (err);
+ }
+ }
+ 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);
+ g_free (filepath);
+ } else {
+ g_warning ("%s: modest_utils_create_temp_stream failed", __FUNCTION__);
+ show_error_banner = TRUE;
}
-
- /* Enable transfer toolbar mode */
- set_toolbar_mode (MODEST_MSG_VIEW_WINDOW(self), mode);
}
- break;
- case MODEST_MAIL_OPERATION_QUEUE_OPERATION_REMOVED:
- if (mode == TOOLBAR_MODE_TRANSFER) {
- while (tmp) {
- modest_progress_object_remove_operation (MODEST_PROGRESS_OBJECT (tmp->data),
- mail_op);
- tmp = g_slist_next (tmp);
-
+ if (show_error_banner)
+ modest_platform_information_banner (NULL, NULL, _("mail_ib_file_operation_failed"));
+ } else {
+ /* message attachment */
+ TnyHeader *header = NULL;
+ ModestWindowMgr *mgr;
+ ModestWindow *msg_win = NULL;
+ gboolean found;
+
+ header = tny_msg_get_header (TNY_MSG (mime_part));
+ mgr = modest_runtime_get_window_mgr ();
+ found = modest_window_mgr_find_registered_header (mgr, header, &msg_win);
+
+ if (found) {
+ if (msg_win) /* there is already a window for this uid; top it */
+ gtk_window_present (GTK_WINDOW(msg_win));
+ 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");
+ } 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);
+ modest_window_set_zoom (MODEST_WINDOW (msg_win),
+ modest_window_get_zoom (MODEST_WINDOW (window)));
+ modest_window_mgr_register_window (mgr, msg_win);
+ gtk_widget_show_all (GTK_WIDGET (msg_win));
+ }
+ }
+ g_object_unref (mime_part);
+}
+
+typedef struct
+{
+ gchar *filename;
+ TnyMimePart *part;
+} SaveMimePartPair;
+
+typedef struct
+{
+ GList *pairs;
+ GtkWidget *banner;
+ 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_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_slice_free (SaveMimePartInfo, info);
+ }
+}
+
+static gboolean
+idle_save_mime_part_show_result (SaveMimePartInfo *info)
+{
+ if (info->pairs != NULL) {
+ save_mime_part_to_file (info);
+ } else {
+ /* 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 (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, dgettext("ke-recv",
+ "cerm_device_memory_full"));
+ } 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)
+{
+ GnomeVFSHandle *handle;
+ TnyStream *stream;
+ SaveMimePartPair *pair = (SaveMimePartPair *) info->pairs->data;
+
+ info->result = gnome_vfs_create (&handle, pair->filename, GNOME_VFS_OPEN_WRITE, FALSE, 0644);
+ if (info->result == GNOME_VFS_OK) {
+ stream = tny_vfs_stream_new (handle);
+ if (tny_mime_part_decode_to_stream (pair->part, stream, NULL) < 0) {
+ 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);
+ } else {
+ save_mime_part_info_free (info, FALSE);
+ }
+
+ g_idle_add ((GSourceFunc) idle_save_mime_part_show_result, info);
+ return NULL;
+}
+
+static void
+save_mime_parts_to_file_with_checks (SaveMimePartInfo *info)
+{
+ gboolean is_ok = TRUE;
+ gint replaced_files = 0;
+ const GList *files = info->pairs;
+ const GList *iter;
+
+ for (iter = files; (iter != NULL) && (replaced_files < 2); iter = g_list_next(iter)) {
+ SaveMimePartPair *pair = iter->data;
+ if (modest_utils_file_exists (pair->filename)) {
+ replaced_files++;
+ }
+ }
+ if (replaced_files) {
+ GtkWidget *confirm_overwrite_dialog;
+ 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) {
+ is_ok = FALSE;
+ }
+ gtk_widget_destroy (confirm_overwrite_dialog);
+ }
+
+ if (!is_ok) {
+ save_mime_part_info_free (info, TRUE);
+ } else {
+ GtkWidget *banner = hildon_banner_show_animation (NULL, NULL,
+ _CS("sfil_ib_saving"));
+ info->banner = banner;
+ g_thread_create ((GThreadFunc)save_mime_part_to_file, info, FALSE, NULL);
+ }
+
+}
+
+
+void
+modest_msg_view_window_save_attachments (ModestMsgViewWindow *window, TnyList *mime_parts)
+{
+ ModestMsgViewWindowPrivate *priv;
+ GList *files_to_save = NULL;
+ GtkWidget *save_dialog = NULL;
+ gchar *folder = NULL;
+ 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) {
+ mime_parts = modest_msg_view_get_selected_attachments (MODEST_MSG_VIEW (priv->msg_view));
+ if (mime_parts == NULL || tny_list_get_length (mime_parts) == 0)
+ return;
+ } else {
+ g_object_ref (mime_parts);
+ }
+
+ /* prepare dialog */
+ if (tny_list_get_length (mime_parts) == 1) {
+ TnyIterator *iter;
+ /* only one attachment selected */
+ 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");
+ 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"),
+ tny_list_get_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) {
+ 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);
+ gtk_window_set_title (GTK_WINDOW (save_dialog), _FM("sfil_ti_save_objects_files"));
+ }
+
+ /* 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 {
+ 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 (save_multiple_str) {
+ 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);
+ }
+
+ gtk_widget_destroy (save_dialog);
+
+ g_object_unref (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);
+ }
+}
+
+static gboolean
+show_remove_attachment_information (gpointer userdata)
+{
+ ModestMsgViewWindow *window = (ModestMsgViewWindow *) userdata;
+ ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
+
+ /* We're outside the main lock */
+ gdk_threads_enter ();
+
+ 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")));
- /* If no more operations are being observed, NORMAL mode is enabled again */
- if (observers_empty (self))
- set_toolbar_mode (self, TOOLBAR_MODE_NORMAL);
+ gdk_threads_leave ();
+
+ return FALSE;
+}
+
+void
+modest_msg_view_window_remove_attachments (ModestMsgViewWindow *window, gboolean get_all)
+{
+ ModestMsgViewWindowPrivate *priv;
+ TnyList *mime_parts = NULL;
+ gchar *confirmation_message;
+ gint response;
+ gint n_attachments;
+ TnyMsg *msg;
+ TnyIterator *iter;
+/* TnyFolder *folder; */
+
+ g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (window));
+ priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
+
+ if (get_all)
+ mime_parts = modest_msg_view_get_attachments (MODEST_MSG_VIEW (priv->msg_view));
+ else
+ mime_parts = modest_msg_view_get_selected_attachments (MODEST_MSG_VIEW (priv->msg_view));
+
+ /* Remove already purged messages from mime parts list */
+ 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)) {
+ tny_list_remove (mime_parts, (GObject *) part);
}
- break;
+ g_object_unref (part);
+ }
+ g_object_unref (iter);
+
+ if (tny_list_get_length (mime_parts) == 0) {
+ g_object_unref (mime_parts);
+ return;
+ }
+
+ n_attachments = tny_list_get_length (mime_parts);
+ if (n_attachments == 1) {
+ gchar *filename;
+ TnyMimePart *part;
+
+ 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 (part));
+ filename = tny_header_dup_subject (header);
+ g_object_unref (header);
+ if (filename == NULL)
+ filename = g_strdup (_("mail_va_no_subject"));
+ } else {
+ 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",
+ n_attachments), n_attachments);
+ }
+ response = modest_platform_run_confirmation_dialog (GTK_WINDOW (window),
+ confirmation_message);
+ g_free (confirmation_message);
+
+ 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); */
+
+ 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));
+/* modest_msg_view_remove_attachment (MODEST_MSG_VIEW (priv->msg_view), node->data); */
+ 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_object_unref (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;
+ }
+
+
+}
+
+
+static void
+update_window_title (ModestMsgViewWindow *window)
+{
+ ModestMsgViewWindowPrivate *priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE (window);
+ TnyMsg *msg = NULL;
+ TnyHeader *header = NULL;
+ gchar *subject = NULL;
+
+ msg = tny_msg_view_get_msg (TNY_MSG_VIEW (priv->msg_view));
+
+ if (msg != NULL) {
+ header = tny_msg_get_header (msg);
+ subject = tny_header_dup_subject (header);
+ g_object_unref (header);
+ g_object_unref (msg);
+ }
+
+ if ((subject == NULL)||(subject[0] == '\0')) {
+ g_free (subject);
+ subject = g_strdup (_("mail_va_no_subject"));
+ }
+
+ gtk_window_set_title (GTK_WINDOW (window), subject);
+}
+
+
+static void on_move_focus (GtkWidget *widget,
+ GtkDirectionType direction,
+ gpointer userdata)
+{
+ 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_message ("REFRESH VIEW");
+ if (GTK_WIDGET_DRAWABLE (fidata->msg_view)) {
+ g_message ("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;;
}
projects / modest / blobdiff