1 /* Copyright (c) 2006,2007 Nokia Corporation
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * * Neither the name of the Nokia Corporation nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
18 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
20 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
21 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 #include "modest-window-mgr.h"
32 #include "modest-runtime.h"
33 #include "modest-tny-folder.h"
34 #include "modest-ui-actions.h"
35 #include "modest-platform.h"
36 #include "widgets/modest-main-window.h"
37 #include "widgets/modest-msg-edit-window.h"
38 #include "widgets/modest-msg-view-window.h"
39 #include "modest-debug.h"
42 /* 'private'/'protected' functions */
43 static void modest_window_mgr_class_init (ModestWindowMgrClass *klass);
44 static void modest_window_mgr_init (ModestWindowMgr *obj);
45 static void modest_window_mgr_finalize (GObject *obj);
47 static gboolean on_window_destroy (ModestWindow *window,
49 ModestWindowMgr *self);
51 static gboolean on_modal_window_close (GtkWidget *widget,
55 static void on_modal_dialog_destroy (GtkObject *object,
58 static void on_modal_dialog_close (GtkDialog *dialog,
62 static const gchar* get_show_toolbar_key (GType window_type,
67 WINDOW_LIST_EMPTY_SIGNAL,
71 typedef struct _ModestWindowMgrPrivate ModestWindowMgrPrivate;
72 struct _ModestWindowMgrPrivate {
76 ModestWindow *main_window;
79 GQueue *modal_windows;
81 gboolean fullscreen_mode;
83 GSList *windows_that_prevent_hibernation;
84 GSList *preregistered_uids;
85 GHashTable *destroy_handlers;
86 GHashTable *viewer_handlers;
87 GSList *window_state_uids;
91 GSList *modal_handler_uids;
92 GtkWidget *cached_view;
93 GtkWidget *cached_editor;
94 guint idle_load_view_id;
95 guint idle_load_editor_id;
97 ModestWindow *current_top;
99 #define MODEST_WINDOW_MGR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
100 MODEST_TYPE_WINDOW_MGR, \
101 ModestWindowMgrPrivate))
103 static GObjectClass *parent_class = NULL;
105 /* uncomment the following if you have defined any signals */
106 static guint signals[NUM_SIGNALS] = {0};
109 modest_window_mgr_get_type (void)
111 static GType my_type = 0;
113 static const GTypeInfo my_info = {
114 sizeof(ModestWindowMgrClass),
115 NULL, /* base init */
116 NULL, /* base finalize */
117 (GClassInitFunc) modest_window_mgr_class_init,
118 NULL, /* class finalize */
119 NULL, /* class data */
120 sizeof(ModestWindowMgr),
122 (GInstanceInitFunc) modest_window_mgr_init,
125 my_type = g_type_register_static (G_TYPE_OBJECT,
133 modest_window_mgr_class_init (ModestWindowMgrClass *klass)
135 GObjectClass *gobject_class;
136 gobject_class = (GObjectClass*) klass;
138 parent_class = g_type_class_peek_parent (klass);
139 gobject_class->finalize = modest_window_mgr_finalize;
141 g_type_class_add_private (gobject_class, sizeof(ModestWindowMgrPrivate));
145 * ModestWindowMgr::window-list-empty
146 * @self: the #ModestWindowMgr that emits the signal
147 * @user_data: user data set when the signal handler was connected
149 * Issued whenever the window list becomes empty
151 signals[WINDOW_LIST_EMPTY_SIGNAL] =
152 g_signal_new ("window-list-empty",
153 G_TYPE_FROM_CLASS (gobject_class),
155 G_STRUCT_OFFSET (ModestWindowMgrClass, window_list_empty),
157 g_cclosure_marshal_VOID__VOID,
162 idle_load_view (ModestWindowMgr *mgr)
164 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (mgr);
166 priv->cached_view = g_object_new (MODEST_TYPE_MSG_VIEW_WINDOW, NULL);
167 priv->idle_load_view_id = 0;
172 idle_load_editor (ModestWindowMgr *mgr)
174 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (mgr);
176 priv->cached_editor = g_object_new (MODEST_TYPE_MSG_EDIT_WINDOW, NULL);
177 priv->idle_load_editor_id = 0;
182 load_new_view (ModestWindowMgr *self)
184 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
185 if ((priv->cached_view == NULL) && (priv->idle_load_view_id == 0))
186 priv->idle_load_view_id = g_idle_add ((GSourceFunc) idle_load_view, self);
190 load_new_editor (ModestWindowMgr *self)
192 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
193 if ((priv->cached_editor == NULL) && (priv->idle_load_editor_id == 0))
194 priv->idle_load_editor_id = g_idle_add ((GSourceFunc) idle_load_editor, self);
198 modest_window_mgr_init (ModestWindowMgr *obj)
200 ModestWindowMgrPrivate *priv;
202 priv = MODEST_WINDOW_MGR_GET_PRIVATE(obj);
203 priv->window_list = NULL;
204 priv->banner_counter = 0;
205 priv->main_window = NULL;
206 priv->fullscreen_mode = FALSE;
207 priv->current_top = NULL;
208 priv->window_state_uids = NULL;
210 priv->modal_windows = g_queue_new ();
211 priv->queue_lock = g_mutex_new ();
213 priv->preregistered_uids = NULL;
215 /* Could not initialize it from gconf, singletons are not
217 priv->destroy_handlers = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free);
218 priv->viewer_handlers = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free);
220 priv->closing_time = 0;
222 priv->modal_handler_uids = NULL;
223 priv->cached_view = NULL;
224 priv->cached_editor = NULL;
228 modest_window_mgr_finalize (GObject *obj)
230 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE(obj);
232 if (priv->idle_load_view_id > 0) {
233 g_source_remove (priv->idle_load_view_id);
234 priv->idle_load_view_id = 0;
237 if (priv->idle_load_editor_id > 0) {
238 g_source_remove (priv->idle_load_editor_id);
239 priv->idle_load_editor_id = 0;
242 if (priv->cached_view) {
243 gtk_widget_destroy (priv->cached_view);
244 priv->cached_view = NULL;
246 if (priv->cached_editor) {
247 gtk_widget_destroy (priv->cached_editor);
248 priv->cached_editor = NULL;
251 modest_signal_mgr_disconnect_all_and_destroy (priv->window_state_uids);
252 priv->window_state_uids = NULL;
254 if (priv->window_list) {
255 GList *iter = priv->window_list;
256 /* unregister pending windows */
258 modest_window_mgr_unregister_window (MODEST_WINDOW_MGR (obj),
259 MODEST_WINDOW (iter->data));
260 iter = g_list_next (iter);
262 g_list_free (priv->window_list);
263 priv->window_list = NULL;
266 g_slist_foreach (priv->preregistered_uids, (GFunc)g_free, NULL);
267 g_slist_free (priv->preregistered_uids);
270 /* Free the hash table with the handlers */
271 if (priv->destroy_handlers) {
272 g_hash_table_destroy (priv->destroy_handlers);
273 priv->destroy_handlers = NULL;
276 if (priv->viewer_handlers) {
277 g_hash_table_destroy (priv->viewer_handlers);
278 priv->viewer_handlers = NULL;
281 modest_signal_mgr_disconnect_all_and_destroy (priv->modal_handler_uids);
282 priv->modal_handler_uids = NULL;
284 if (priv->modal_windows) {
285 g_mutex_lock (priv->queue_lock);
286 g_queue_free (priv->modal_windows);
287 priv->modal_windows = NULL;
288 g_mutex_unlock (priv->queue_lock);
290 g_mutex_free (priv->queue_lock);
292 /* Do not unref priv->main_window because it does not hold a
296 G_OBJECT_CLASS(parent_class)->finalize (obj);
300 modest_window_mgr_new (void)
302 return MODEST_WINDOW_MGR(g_object_new(MODEST_TYPE_WINDOW_MGR, NULL));
308 /* do we have uid? */
310 has_uid (GSList *list, const gchar *uid)
312 GSList *cursor = list;
318 if (cursor->data && strcmp (cursor->data, uid) == 0)
320 cursor = g_slist_next (cursor);
326 /* remove all from the list have have uid = uid */
328 remove_uid (GSList *list, const gchar *uid)
330 GSList *cursor = list, *start = list;
336 GSList *next = g_slist_next (cursor);
337 if (cursor->data && strcmp (cursor->data, uid) == 0) {
338 g_free (cursor->data);
339 start = g_slist_delete_link (start, cursor);
348 append_uid (GSList *list, const gchar *uid)
350 return g_slist_append (list, g_strdup(uid));
356 modest_window_mgr_register_header (ModestWindowMgr *self, TnyHeader *header, const gchar *alt_uid)
358 ModestWindowMgrPrivate *priv;
361 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
362 g_return_if_fail (TNY_IS_HEADER(header));
364 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
365 uid = modest_tny_folder_get_header_unique_id (header);
368 uid = g_strdup (alt_uid);
370 if (!has_uid (priv->preregistered_uids, uid)) {
371 MODEST_DEBUG_BLOCK(g_debug ("registering new uid %s", uid););
372 priv->preregistered_uids = append_uid (priv->preregistered_uids, uid);
374 MODEST_DEBUG_BLOCK(g_debug ("already had uid %s", uid););
380 modest_window_mgr_unregister_header (ModestWindowMgr *self, TnyHeader *header)
382 ModestWindowMgrPrivate *priv;
385 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
386 g_return_if_fail (TNY_IS_HEADER(header));
388 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
389 uid = modest_tny_folder_get_header_unique_id (header);
391 if (!has_uid (priv->preregistered_uids, uid)) {
392 MODEST_DEBUG_BLOCK(g_debug ("trying to unregister non-existing uid %s", uid););
393 priv->preregistered_uids = append_uid (priv->preregistered_uids, uid);
395 MODEST_DEBUG_BLOCK(g_debug ("unregistering uid %s", uid););
397 if (has_uid (priv->preregistered_uids, uid)) {
398 priv->preregistered_uids = remove_uid (priv->preregistered_uids, uid);
399 if (has_uid (priv->preregistered_uids, uid))
400 g_debug ("BUG: uid %s NOT removed", uid);
402 MODEST_DEBUG_BLOCK(g_debug ("uid %s removed", uid););
409 #define MODEST_WINDOW_HELP_ID_PARAM "help-id"
412 modest_window_mgr_register_help_id (ModestWindowMgr *self, GtkWindow *win, const gchar* help_id)
414 /* we don't need 'self', but for API consistency... */
415 g_return_if_fail (self && MODEST_IS_WINDOW_MGR(self));
417 g_return_if_fail (win && GTK_IS_WINDOW(win));
418 g_return_if_fail (help_id);
420 g_object_set_data_full (G_OBJECT(win), MODEST_WINDOW_HELP_ID_PARAM,
421 g_strdup(help_id), g_free);
426 modest_window_mgr_get_help_id (ModestWindowMgr *self, GtkWindow *win)
428 const gchar* help_id = NULL;
430 /* we don't need 'self', but for API consistency... */
431 g_return_val_if_fail (self && MODEST_IS_WINDOW_MGR(self), NULL);
433 g_return_val_if_fail (win, NULL);
434 g_return_val_if_fail (GTK_IS_WINDOW(win), NULL);
436 if (MODEST_IS_MAIN_WINDOW (win)) {
437 GtkWidget *folder_view;
438 TnyFolderStore *folder_store;
440 /* Get selected folder */
441 folder_view = modest_main_window_get_child_widget (MODEST_MAIN_WINDOW (win),
442 MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW);
443 folder_store = modest_folder_view_get_selected (MODEST_FOLDER_VIEW (folder_view));
446 if (folder_store && TNY_IS_FOLDER (folder_store)) {
447 help_id = modest_tny_folder_get_help_id (TNY_FOLDER (folder_store));
449 g_warning ("%s: BUG: did not get a valid help_id", __FUNCTION__);
452 g_object_unref (folder_store);
456 help_id = g_object_get_data (G_OBJECT(win), MODEST_WINDOW_HELP_ID_PARAM);
462 compare_msguids (ModestWindow *win,
465 const gchar *msg_uid;
467 if ((!MODEST_IS_MSG_EDIT_WINDOW (win)) && (!MODEST_IS_MSG_VIEW_WINDOW (win)))
470 /* Get message uid from msg window */
471 if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
472 msg_uid = modest_msg_edit_window_get_message_uid (MODEST_MSG_EDIT_WINDOW (win));
473 if (msg_uid && uid &&!strcmp (msg_uid, uid))
476 msg_uid = modest_msg_view_window_get_message_uid (MODEST_MSG_VIEW_WINDOW (win));
479 if (msg_uid && uid &&!strcmp (msg_uid, uid))
486 modest_window_mgr_close_all_windows (ModestWindowMgr *self)
488 ModestWindowMgrPrivate *priv = NULL;
489 gboolean ret_value = FALSE;
491 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
492 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
494 /* If there is a main window then try to close it, and it will
495 close the others if needed */
496 if (priv->main_window) {
497 g_signal_emit_by_name (priv->main_window, "delete-event", NULL, &ret_value);
499 GList *wins = NULL, *next = NULL;
501 /* delete-event handler actually removes window_list item, */
502 wins = priv->window_list;
504 next = g_list_next (wins);
505 g_signal_emit_by_name (G_OBJECT (wins->data), "delete-event", NULL, &ret_value);
513 modest_window_mgr_find_registered_header (ModestWindowMgr *self, TnyHeader *header,
516 ModestWindowMgrPrivate *priv = NULL;
518 gboolean has_header, has_window = FALSE;
521 g_return_val_if_fail (MODEST_IS_WINDOW_MGR (self), FALSE);
522 g_return_val_if_fail (TNY_IS_HEADER(header), FALSE);
524 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
526 uid = modest_tny_folder_get_header_unique_id (header);
531 has_header = has_uid (priv->preregistered_uids, uid);
533 item = g_list_find_custom (priv->window_list, uid, (GCompareFunc) compare_msguids);
537 if ((!MODEST_IS_MSG_VIEW_WINDOW(item->data)) &&
538 (!MODEST_IS_MSG_EDIT_WINDOW (item->data)))
539 g_debug ("not a valid window!");
541 g_debug ("found a window");
542 *win = MODEST_WINDOW (item->data);
548 return has_header || has_window;
552 get_show_toolbar_key (GType window_type,
555 const gchar *key = NULL;
557 if (window_type == MODEST_TYPE_MAIN_WINDOW)
559 MODEST_CONF_MAIN_WINDOW_SHOW_TOOLBAR_FULLSCREEN :
560 MODEST_CONF_MAIN_WINDOW_SHOW_TOOLBAR;
561 else if (window_type == MODEST_TYPE_MSG_VIEW_WINDOW)
563 MODEST_CONF_MSG_VIEW_WINDOW_SHOW_TOOLBAR_FULLSCREEN :
564 MODEST_CONF_MSG_VIEW_WINDOW_SHOW_TOOLBAR;
565 else if (window_type == MODEST_TYPE_MSG_EDIT_WINDOW)
567 MODEST_CONF_EDIT_WINDOW_SHOW_TOOLBAR_FULLSCREEN :
568 MODEST_CONF_EDIT_WINDOW_SHOW_TOOLBAR;
570 g_return_val_if_reached (NULL);
575 #ifdef MODEST_PLATFORM_MAEMO
577 on_window_is_topmost (GObject *gobject,
581 ModestWindowMgr *self;
582 ModestWindowMgrPrivate *priv;
583 ModestWindow *win = (ModestWindow *) gobject;
585 g_return_if_fail (MODEST_IS_WINDOW_MGR (user_data));
587 self = MODEST_WINDOW_MGR (user_data);
588 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
590 if (hildon_window_get_is_topmost (HILDON_WINDOW (win)))
591 priv->current_top = win;
596 on_window_state_event (GtkWidget *widget,
597 GdkEventWindowState *event,
600 ModestWindowMgr *self;
601 ModestWindowMgrPrivate *priv;
603 g_return_val_if_fail (MODEST_IS_WINDOW_MGR (user_data), FALSE);
605 self = MODEST_WINDOW_MGR (user_data);
606 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
609 if (event->changed_mask & GDK_WINDOW_STATE_WITHDRAWN)
610 g_print ("GDK_WINDOW_STATE_WITHDRAWN\n");
611 if (event->changed_mask & GDK_WINDOW_STATE_ICONIFIED)
612 g_print ("GDK_WINDOW_STATE_ICONIFIED\n");
613 if (event->changed_mask & GDK_WINDOW_STATE_MAXIMIZED)
614 g_print ("GDK_WINDOW_STATE_MAXIMIZED\n");
615 if (event->changed_mask & GDK_WINDOW_STATE_STICKY)
616 g_print ("GDK_WINDOW_STATE_STICKY\n");
617 if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN)
618 g_print ("GDK_WINDOW_STATE_FULLSCREEN\n");
619 if (event->changed_mask & GDK_WINDOW_STATE_ABOVE)
620 g_print ("GDK_WINDOW_STATE_ABOVE\n");
621 if (event->changed_mask & GDK_WINDOW_STATE_BELOW)
622 g_print ("GDK_WINDOW_STATE_BELOW\n");
624 if (event->changed_mask & GDK_WINDOW_STATE_WITHDRAWN ||
625 event->changed_mask & GDK_WINDOW_STATE_ABOVE) {
626 priv->current_top = MODEST_WINDOW (widget);
634 modest_window_mgr_register_window (ModestWindowMgr *self,
635 ModestWindow *window)
638 ModestWindowMgrPrivate *priv;
642 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
643 g_return_if_fail (GTK_IS_WINDOW (window));
645 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
647 win = g_list_find (priv->window_list, window);
649 /* this is for the case we want to register the window and it was already
650 * registered. We leave silently.
655 /* Check that it's not a second main window */
656 if (MODEST_IS_MAIN_WINDOW (window)) {
657 if (priv->main_window) {
658 g_warning ("%s: trying to register a second main window",
662 priv->main_window = window;
663 load_new_view (self);
664 load_new_editor (self);
668 /* remove from the list of pre-registered uids */
669 if (MODEST_IS_MSG_VIEW_WINDOW(window)) {
670 const gchar *uid = modest_msg_view_window_get_message_uid
671 (MODEST_MSG_VIEW_WINDOW (window));
673 if (!has_uid (priv->preregistered_uids, uid))
674 g_debug ("weird: no uid for window (%s)", uid);
676 MODEST_DEBUG_BLOCK(g_debug ("registering window for %s", uid ? uid : "<none>"););
678 priv->preregistered_uids =
679 remove_uid (priv->preregistered_uids,
680 modest_msg_view_window_get_message_uid
681 (MODEST_MSG_VIEW_WINDOW (window)));
682 } else if (MODEST_IS_MSG_EDIT_WINDOW(window)) {
683 const gchar *uid = modest_msg_edit_window_get_message_uid
684 (MODEST_MSG_EDIT_WINDOW (window));
686 MODEST_DEBUG_BLOCK(g_debug ("registering window for %s", uid););
688 priv->preregistered_uids =
689 remove_uid (priv->preregistered_uids,
690 modest_msg_edit_window_get_message_uid
691 (MODEST_MSG_EDIT_WINDOW (window)));
694 /* Add to list. Keep a reference to the window */
695 g_object_ref (window);
696 priv->window_list = g_list_prepend (priv->window_list, window);
698 /* Listen to window state changes. Unfortunately
699 window-state-event does not properly work for the Maemo
700 version, so we need to use is-topmost and the ifdef */
701 #ifdef MODEST_PLATFORM_MAEMO
702 priv->window_state_uids =
703 modest_signal_mgr_connect (priv->window_state_uids,
705 "notify::is-topmost",
706 G_CALLBACK (on_window_is_topmost),
709 priv->window_state_uids =
710 modest_signal_mgr_connect (priv->window_state_uids,
712 "window-state-event",
713 G_CALLBACK (on_window_state_event),
716 /* Listen to object destruction */
717 handler_id = g_malloc0 (sizeof (gint));
718 *handler_id = g_signal_connect (window, "delete-event", G_CALLBACK (on_window_destroy), self);
719 g_hash_table_insert (priv->destroy_handlers, window, handler_id);
721 /* If there is a msg view window, let the main window listen the msg-changed signal */
722 if (MODEST_IS_MSG_VIEW_WINDOW(window) && priv->main_window) {
724 handler = g_malloc0 (sizeof (gulong));
725 *handler = g_signal_connect (window, "msg-changed",
726 G_CALLBACK (modest_main_window_on_msg_view_window_msg_changed),
728 g_hash_table_insert (priv->viewer_handlers, window, handler);
731 /* Put into fullscreen if needed */
732 if (priv->fullscreen_mode)
733 gtk_window_fullscreen (GTK_WINDOW (window));
735 /* Show/hide toolbar & fullscreen */
736 key = get_show_toolbar_key (G_TYPE_FROM_INSTANCE (window), priv->fullscreen_mode);
737 modest_window_show_toolbar (window, modest_conf_get_bool (modest_runtime_get_conf (), key, NULL));
741 cancel_window_operations (ModestWindow *window)
743 GSList* pending_ops = NULL;
745 /* cancel open and receive operations */
746 pending_ops = modest_mail_operation_queue_get_by_source (modest_runtime_get_mail_operation_queue (),
748 while (pending_ops != NULL) {
749 ModestMailOperationTypeOperation type;
750 GSList* tmp_list = NULL;
752 type = modest_mail_operation_get_type_operation (MODEST_MAIL_OPERATION (pending_ops->data));
753 if (type == MODEST_MAIL_OPERATION_TYPE_RECEIVE || type == MODEST_MAIL_OPERATION_TYPE_OPEN) {
754 modest_mail_operation_cancel (pending_ops->data);
756 g_object_unref (G_OBJECT (pending_ops->data));
757 tmp_list = pending_ops;
758 pending_ops = g_slist_next (pending_ops);
759 g_slist_free_1 (tmp_list);
766 on_window_destroy (ModestWindow *window,
768 ModestWindowMgr *self)
770 gint dialog_response = GTK_RESPONSE_NONE;
771 gboolean no_propagate = FALSE;
773 /* Specific stuff first */
774 if (MODEST_IS_MAIN_WINDOW (window)) {
775 ModestWindowMgrPrivate *priv;
776 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
778 /* If more than one window already opened */
779 if (g_list_length (priv->window_list) > 1) {
781 /* Present the window if it's not visible now */
782 if (!gtk_window_has_toplevel_focus (GTK_WINDOW (window)))
783 gtk_window_present (GTK_WINDOW (window));
784 /* Create the confirmation dialog MSG-NOT308 */
785 dialog_response = modest_platform_run_confirmation_dialog (
786 GTK_WINDOW (window), _("emev_nc_close_windows"));
788 /* If the user wants to close all the windows */
789 if ((dialog_response == GTK_RESPONSE_OK)
790 || (dialog_response == GTK_RESPONSE_ACCEPT)
791 || (dialog_response == GTK_RESPONSE_YES)) {
792 GList *iter = priv->window_list;
794 if (iter->data != window) {
795 GList *tmp = iter->next;
796 on_window_destroy (MODEST_WINDOW (iter->data),
801 iter = g_list_next (iter);
809 /* Do not unregister it, just hide */
810 gtk_widget_hide_all (GTK_WIDGET (window));
812 /* Cancel pending operations */
813 cancel_window_operations (window);
815 /* Fake the window system, make it think that there is no window */
816 if (modest_window_mgr_num_windows (self) == 0)
817 g_signal_emit (self, signals[WINDOW_LIST_EMPTY_SIGNAL], 0);
822 if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
823 gboolean sent = FALSE;
824 gint response = GTK_RESPONSE_ACCEPT;
825 sent = modest_msg_edit_window_get_sent (MODEST_MSG_EDIT_WINDOW (window));
826 /* Save currently edited message to Drafts if it was not sent */
827 if (!sent && modest_msg_edit_window_is_modified (MODEST_MSG_EDIT_WINDOW (window))) {
829 /* Raise the window if it's minimized */
830 if (!gtk_window_has_toplevel_focus (GTK_WINDOW (window)))
831 gtk_window_present (GTK_WINDOW (window));
834 modest_platform_run_confirmation_dialog (GTK_WINDOW (window),
835 _("mcen_nc_no_email_message_modified_save_changes"));
837 if (response == GTK_RESPONSE_OK)
838 if (!modest_ui_actions_on_save_to_drafts (NULL, MODEST_MSG_EDIT_WINDOW (window)))
842 /* Unregister window */
843 modest_window_mgr_unregister_window (self, window);
844 no_propagate = FALSE;
851 disconnect_msg_changed (gpointer key,
856 handler_id = GPOINTER_TO_UINT(value);
858 if (key && G_IS_OBJECT(key))
859 g_signal_handler_disconnect (G_OBJECT (key), handler_id);
863 modest_window_mgr_unregister_window (ModestWindowMgr *self,
864 ModestWindow *window)
867 ModestWindowMgrPrivate *priv;
868 gulong *tmp, handler_id;
870 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
871 g_return_if_fail (MODEST_IS_WINDOW (window));
873 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
875 win = g_list_find (priv->window_list, window);
877 g_warning ("Trying to unregister a window that has not being registered yet");
881 /* If it's the main window unset it */
882 if (priv->main_window == window) {
883 priv->main_window = NULL;
885 /* Disconnect all emissions of msg-changed */
886 if (priv->viewer_handlers) {
887 g_hash_table_foreach (priv->viewer_handlers,
888 disconnect_msg_changed,
890 g_hash_table_destroy (priv->viewer_handlers);
891 priv->viewer_handlers = NULL;
895 /* Remove the viewer window handler from the hash table. The
896 HashTable could not exist if the main window was closed
897 when there were other windows remaining */
898 if (MODEST_IS_MSG_VIEW_WINDOW (window) && priv->viewer_handlers) {
899 tmp = (gulong *) g_hash_table_lookup (priv->viewer_handlers, window);
900 /* If the viewer was created without a main window
901 (for example when opening a message through D-Bus
902 the viewer handlers was not registered */
904 g_signal_handler_disconnect (window, *tmp);
905 g_hash_table_remove (priv->viewer_handlers, window);
910 modest_window_save_state (window);
912 /* Remove from list & hash table */
913 priv->window_list = g_list_remove_link (priv->window_list, win);
914 tmp = g_hash_table_lookup (priv->destroy_handlers, window);
916 g_hash_table_remove (priv->destroy_handlers, window);
918 /* cancel open and receive operations */
919 cancel_window_operations (window);
921 /* Check if it's the topmost window, and remove the window from the stack.
922 * This is needed for the cases there's no other topmost window that will
923 * replace it in topmost handler.
925 if (window == priv->current_top)
926 priv->current_top = NULL;
928 /* Disconnect the "window-state-event" handler, we won't need it anymore */
929 if (priv->window_state_uids) {
930 #ifdef MODEST_PLATFORM_MAEMO
931 priv->window_state_uids =
932 modest_signal_mgr_disconnect (priv->window_state_uids,
934 "notify::is-topmost");
936 priv->window_state_uids =
937 modest_signal_mgr_disconnect (priv->window_state_uids,
939 "window-state-event");
943 /* Disconnect the "delete-event" handler, we won't need it anymore */
944 g_signal_handler_disconnect (window, handler_id);
946 /* Disconnect all the window signals */
947 modest_window_disconnect_signals (window);
949 /* Destroy the window */
950 gtk_widget_destroy (win->data);
952 /* If there are no more windows registered emit the signal */
953 if (modest_window_mgr_num_windows (self) == 0)
954 g_signal_emit (self, signals[WINDOW_LIST_EMPTY_SIGNAL], 0);
960 modest_window_mgr_set_fullscreen_mode (ModestWindowMgr *self,
963 ModestWindowMgrPrivate *priv;
967 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
969 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
971 /* If there is no change do nothing */
972 if (priv->fullscreen_mode == on)
975 priv->fullscreen_mode = on;
977 conf = modest_runtime_get_conf ();
980 win = priv->window_list;
983 const gchar *key = NULL;
985 /* Getting this from gconf everytime is not that
986 expensive, we'll do it just a few times */
987 key = get_show_toolbar_key (G_TYPE_FROM_INSTANCE (win->data), on);
988 show = modest_conf_get_bool (conf, key, NULL);
990 /* Set fullscreen/unfullscreen */
992 gtk_window_fullscreen (GTK_WINDOW (win->data));
994 gtk_window_unfullscreen (GTK_WINDOW (win->data));
996 /* Show/Hide toolbar */
997 modest_window_show_toolbar (MODEST_WINDOW (win->data), show);
999 win = g_list_next (win);
1004 modest_window_mgr_get_fullscreen_mode (ModestWindowMgr *self)
1006 ModestWindowMgrPrivate *priv;
1008 g_return_val_if_fail (MODEST_IS_WINDOW_MGR (self), FALSE);
1010 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
1012 return priv->fullscreen_mode;
1016 modest_window_mgr_show_toolbars (ModestWindowMgr *self,
1018 gboolean show_toolbars,
1019 gboolean fullscreen)
1021 ModestWindowMgrPrivate *priv;
1023 const gchar *key = NULL;
1025 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
1027 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
1028 conf = modest_runtime_get_conf ();
1030 /* If nothing changes then return */
1031 key = get_show_toolbar_key (window_type, fullscreen);
1032 conf = modest_runtime_get_conf ();
1033 if (modest_conf_get_bool (conf, key, NULL) == show_toolbars)
1037 modest_conf_set_bool (conf, key, show_toolbars, NULL);
1039 /* Apply now if the view mode is the right one */
1040 if ((fullscreen && priv->fullscreen_mode) ||
1041 (!fullscreen && !priv->fullscreen_mode)) {
1043 GList *win = priv->window_list;
1046 if (G_TYPE_FROM_INSTANCE (win->data) == window_type)
1047 modest_window_show_toolbar (MODEST_WINDOW (win->data),
1049 win = g_list_next (win);
1055 modest_window_mgr_get_main_window (ModestWindowMgr *self, gboolean create)
1057 ModestWindowMgrPrivate *priv;
1059 g_return_val_if_fail (MODEST_IS_WINDOW_MGR (self), NULL);
1060 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
1062 /* create the main window, if it hasn't been created yet */
1063 if (!priv->main_window && create) {
1064 /* modest_window_mgr_register_window will set priv->main_window */
1065 modest_window_mgr_register_window (self, modest_main_window_new ());
1067 g_debug ("%s: created main window: %p\n", __FUNCTION__, priv->main_window);
1071 return priv->main_window;
1076 modest_window_mgr_main_window_exists (ModestWindowMgr *self)
1078 ModestWindowMgrPrivate *priv;
1080 g_return_val_if_fail (MODEST_IS_WINDOW_MGR (self), FALSE);
1081 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
1083 return priv->main_window != NULL;
1088 modest_window_mgr_get_modal (ModestWindowMgr *self)
1090 ModestWindowMgrPrivate *priv;
1092 g_return_val_if_fail (MODEST_IS_WINDOW_MGR (self), NULL);
1093 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
1095 return g_queue_peek_head (priv->modal_windows);
1100 modest_window_mgr_set_modal (ModestWindowMgr *self,
1103 GtkWindow *old_modal;
1104 ModestWindowMgrPrivate *priv;
1106 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
1107 g_return_if_fail (GTK_IS_WINDOW (window));
1109 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
1110 g_mutex_lock (priv->queue_lock);
1111 old_modal = g_queue_peek_head (priv->modal_windows);
1112 g_mutex_unlock (priv->queue_lock);
1115 /* make us transient wrt the main window then */
1116 if (priv->current_top && ((GtkWindow *) priv->current_top != window)) {
1117 gtk_window_set_transient_for (window, GTK_WINDOW(priv->current_top));
1119 ModestWindow *main_win = modest_window_mgr_get_main_window (self, FALSE);
1120 if (GTK_WINDOW(main_win) != window) /* they should not be the same */
1121 gtk_window_set_transient_for (window, GTK_WINDOW(main_win));
1123 gtk_window_set_modal (window, TRUE);
1125 /* un-modalize the old one; the one on top should be the
1127 gtk_window_set_transient_for (window, GTK_WINDOW(old_modal));
1128 gtk_window_set_modal (window, TRUE);
1131 /* this will be the new modal window */
1132 g_mutex_lock (priv->queue_lock);
1133 g_queue_push_head (priv->modal_windows, window);
1134 g_mutex_unlock (priv->queue_lock);
1136 if (GTK_IS_DIALOG (window)) {
1137 /* Note that response is not always enough because it
1138 could be captured and removed easily by dialogs but
1139 works for most of situations */
1140 priv->modal_handler_uids =
1141 modest_signal_mgr_connect (priv->modal_handler_uids,
1144 G_CALLBACK (on_modal_dialog_close),
1146 /* We need this as well because dialogs are often
1147 destroyed with gtk_widget_destroy and this one will
1148 prevent response from happening */
1149 priv->modal_handler_uids =
1150 modest_signal_mgr_connect (priv->modal_handler_uids,
1153 G_CALLBACK (on_modal_dialog_destroy),
1156 priv->modal_handler_uids =
1157 modest_signal_mgr_connect (priv->modal_handler_uids,
1160 G_CALLBACK (on_modal_window_close),
1163 /* Destroy width parent */
1164 gtk_window_set_destroy_with_parent (window, TRUE);
1169 on_nonhibernating_window_hide(GtkWidget *widget, gpointer user_data)
1171 ModestWindowMgr *self = MODEST_WINDOW_MGR (user_data);
1172 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
1174 /* Forget this window,
1175 * so hibernation will be allowed again if no windows are remembered: */
1176 priv->windows_that_prevent_hibernation =
1177 g_slist_remove (priv->windows_that_prevent_hibernation, GTK_WINDOW(widget));
1181 on_nonhibernating_window_show(GtkWidget *widget, gpointer user_data)
1183 ModestWindowMgr *self = MODEST_WINDOW_MGR (user_data);
1184 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
1186 GtkWindow *window = GTK_WINDOW (widget);
1188 priv->windows_that_prevent_hibernation =
1189 g_slist_append (priv->windows_that_prevent_hibernation, window);
1191 /* Allow hibernation again when the window has been hidden: */
1192 g_signal_connect (window, "hide",
1193 G_CALLBACK (on_nonhibernating_window_hide), self);
1197 modest_window_mgr_prevent_hibernation_while_window_is_shown (ModestWindowMgr *self,
1200 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
1202 if (GTK_WIDGET_VISIBLE(window)) {
1203 on_nonhibernating_window_show (GTK_WIDGET (window), self);
1205 /* Wait for it to be shown: */
1206 g_signal_connect (window, "show",
1207 G_CALLBACK (on_nonhibernating_window_show), self);
1212 modest_window_mgr_get_hibernation_is_prevented (ModestWindowMgr *self)
1214 g_return_val_if_fail (MODEST_IS_WINDOW_MGR (self), FALSE);
1216 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
1218 /* Prevent hibernation if any open windows are currently
1219 * preventing hibernation: */
1220 return (g_slist_length (priv->windows_that_prevent_hibernation) > 0);
1225 modest_window_mgr_save_state_for_all_windows (ModestWindowMgr *self)
1227 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
1229 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
1231 /* Iterate over all windows */
1232 GList *win = priv->window_list;
1234 ModestWindow *window = MODEST_WINDOW (win->data);
1236 /* This calls the vfunc,
1237 * so each window can do its own thing: */
1238 modest_window_save_state (window);
1241 win = g_list_next (win);
1246 idle_top_modal (gpointer data)
1248 ModestWindowMgr *self = MODEST_WINDOW_MGR (data);
1249 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
1252 /* Get the top modal */
1253 g_mutex_lock (priv->queue_lock);
1254 topmost = (GtkWindow *) g_queue_peek_head (priv->modal_windows);
1255 g_mutex_unlock (priv->queue_lock);
1259 gdk_threads_enter ();
1260 gtk_window_present (topmost);
1261 gdk_threads_leave ();
1268 remove_modal_from_queue (GtkWidget *widget,
1269 ModestWindowMgr *self)
1271 ModestWindowMgrPrivate *priv;
1274 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
1276 /* Remove from queue. We don't use remove, because we want to
1277 exit if the widget does not belong to the queue */
1278 g_mutex_lock (priv->queue_lock);
1279 item = g_queue_find (priv->modal_windows, widget);
1281 g_warning ("Trying to remove a modal window that is not registered");
1282 g_mutex_unlock (priv->queue_lock);
1285 g_queue_unlink (priv->modal_windows, item);
1286 g_mutex_unlock (priv->queue_lock);
1288 /* Disconnect handler */
1289 priv->modal_handler_uids =
1290 modest_signal_mgr_disconnect (priv->modal_handler_uids,
1292 GTK_IS_DIALOG (widget) ?
1295 if (GTK_IS_DIALOG (widget))
1296 priv->modal_handler_uids =
1297 modest_signal_mgr_disconnect (priv->modal_handler_uids,
1301 /* Schedule the next one for being shown */
1302 g_idle_add (idle_top_modal, self);
1306 on_modal_window_close (GtkWidget *widget,
1310 ModestWindowMgr *self = MODEST_WINDOW_MGR (user_data);
1312 /* Remove modal window from queue */
1313 remove_modal_from_queue (widget, self);
1320 on_modal_dialog_close (GtkDialog *dialog,
1324 ModestWindowMgr *self = MODEST_WINDOW_MGR (user_data);
1326 /* Remove modal window from queue. Note that if "destroy"
1327 signal was invoked before the response the window could be
1329 remove_modal_from_queue (GTK_WIDGET (dialog), self);
1333 on_modal_dialog_destroy (GtkObject *object,
1336 ModestWindowMgr *self = MODEST_WINDOW_MGR (user_data);
1338 /* Remove modal window from queue */
1339 remove_modal_from_queue (GTK_WIDGET (object), self);
1343 modest_window_mgr_num_windows (ModestWindowMgr *self)
1345 ModestWindowMgrPrivate *priv;
1346 gint num_windows = 0;
1348 g_return_val_if_fail (self && MODEST_IS_WINDOW_MGR(self), -1);
1350 priv = MODEST_WINDOW_MGR_GET_PRIVATE(self);
1352 if (priv->window_list)
1353 num_windows = g_list_length (priv->window_list);
1355 /* Do not take into account the main window if it was hidden */
1356 if (priv->main_window && !GTK_WIDGET_VISIBLE (priv->main_window))
1359 return num_windows + priv->banner_counter;
1363 modest_window_mgr_get_msg_edit_window (ModestWindowMgr *self)
1366 ModestWindowMgrPrivate *priv;
1368 g_return_val_if_fail (self && MODEST_IS_WINDOW_MGR(self), NULL);
1370 priv = MODEST_WINDOW_MGR_GET_PRIVATE(self);
1372 if (priv->cached_editor) {
1373 result = priv->cached_editor;
1374 priv->cached_editor = NULL;
1375 load_new_editor (self);
1377 result = g_object_new (MODEST_TYPE_MSG_EDIT_WINDOW, NULL);
1384 modest_window_mgr_get_msg_view_window (ModestWindowMgr *self)
1387 ModestWindowMgrPrivate *priv;
1389 g_return_val_if_fail (self && MODEST_IS_WINDOW_MGR(self), NULL);
1391 priv = MODEST_WINDOW_MGR_GET_PRIVATE(self);
1393 if (priv->cached_view) {
1394 result = priv->cached_view;
1395 priv->cached_view = NULL;
1396 load_new_view (self);
1398 result = g_object_new (MODEST_TYPE_MSG_VIEW_WINDOW, NULL);
1405 modest_window_mgr_register_banner (ModestWindowMgr *self)
1407 ModestWindowMgrPrivate *priv;
1409 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
1410 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
1412 priv->banner_counter++;
1417 modest_window_mgr_unregister_banner (ModestWindowMgr *self)
1419 ModestWindowMgrPrivate *priv;
1421 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
1422 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
1424 priv->banner_counter--;
1425 if (modest_window_mgr_num_windows (self) == 0)
1426 g_signal_emit (self, signals[WINDOW_LIST_EMPTY_SIGNAL], 0);