X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fwidgets%2Fmodest-window-mgr.c;h=464a7d6d2e482e32dc9618705e20739b96cc9223;hp=3b94951ecaad1e91c47a6bfbaf0aa266b2f3a122;hb=f9d5e914ab3837c0f2c28513674cbb400d46b5f4;hpb=d4537d8a01b0789310de9a11d3344147ee9691c0 diff --git a/src/widgets/modest-window-mgr.c b/src/widgets/modest-window-mgr.c index 3b94951..464a7d6 100644 --- a/src/widgets/modest-window-mgr.c +++ b/src/widgets/modest-window-mgr.c @@ -36,6 +36,7 @@ #include "widgets/modest-main-window.h" #include "widgets/modest-msg-edit-window.h" #include "widgets/modest-msg-view-window.h" +#include "modest-debug.h" /* 'private'/'protected' functions */ @@ -60,14 +61,14 @@ static const gchar* get_show_toolbar_key (GType window_type, /* list my signals */ enum { - /* MY_SIGNAL_1, */ - /* MY_SIGNAL_2, */ - LAST_SIGNAL + WINDOW_LIST_EMPTY_SIGNAL, + NUM_SIGNALS }; typedef struct _ModestWindowMgrPrivate ModestWindowMgrPrivate; struct _ModestWindowMgrPrivate { GList *window_list; + guint banner_counter; ModestWindow *main_window; @@ -84,6 +85,10 @@ struct _ModestWindowMgrPrivate { guint closing_time; GSList *modal_handler_uids; + GtkWidget *cached_view; + GtkWidget *cached_editor; + guint idle_load_view_id; + guint idle_load_editor_id; }; #define MODEST_WINDOW_MGR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \ MODEST_TYPE_WINDOW_MGR, \ @@ -92,7 +97,7 @@ struct _ModestWindowMgrPrivate { static GObjectClass *parent_class = NULL; /* uncomment the following if you have defined any signals */ -/* static guint signals[LAST_SIGNAL] = {0}; */ +static guint signals[NUM_SIGNALS] = {0}; GType modest_window_mgr_get_type (void) @@ -128,6 +133,59 @@ modest_window_mgr_class_init (ModestWindowMgrClass *klass) gobject_class->finalize = modest_window_mgr_finalize; g_type_class_add_private (gobject_class, sizeof(ModestWindowMgrPrivate)); + + + /** + * ModestWindowMgr::window-list-empty + * @self: the #ModestWindowMgr that emits the signal + * @user_data: user data set when the signal handler was connected + * + * Issued whenever the window list becomes empty + */ + signals[WINDOW_LIST_EMPTY_SIGNAL] = + g_signal_new ("window-list-empty", + G_TYPE_FROM_CLASS (gobject_class), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (ModestWindowMgrClass, window_list_empty), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); +} + +static gboolean +idle_load_view (ModestWindowMgr *mgr) +{ + ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (mgr); + + priv->cached_view = g_object_new (MODEST_TYPE_MSG_VIEW_WINDOW, NULL); + priv->idle_load_view_id = 0; + return FALSE; +} + +static gboolean +idle_load_editor (ModestWindowMgr *mgr) +{ + ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (mgr); + + priv->cached_editor = g_object_new (MODEST_TYPE_MSG_EDIT_WINDOW, NULL); + priv->idle_load_editor_id = 0; + return FALSE; +} + +static void +load_new_view (ModestWindowMgr *self) +{ + ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self); + if ((priv->cached_view == NULL) && (priv->idle_load_view_id == 0)) + priv->idle_load_view_id = g_idle_add ((GSourceFunc) idle_load_view, self); +} + +static void +load_new_editor (ModestWindowMgr *self) +{ + ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self); + if ((priv->cached_editor == NULL) && (priv->idle_load_editor_id == 0)) + priv->idle_load_editor_id = g_idle_add ((GSourceFunc) idle_load_editor, self); } static void @@ -137,6 +195,7 @@ modest_window_mgr_init (ModestWindowMgr *obj) priv = MODEST_WINDOW_MGR_GET_PRIVATE(obj); priv->window_list = NULL; + priv->banner_counter = 0; priv->main_window = NULL; priv->fullscreen_mode = FALSE; @@ -153,6 +212,8 @@ modest_window_mgr_init (ModestWindowMgr *obj) priv->closing_time = 0; priv->modal_handler_uids = NULL; + priv->cached_view = NULL; + priv->cached_editor = NULL; } static void @@ -160,6 +221,25 @@ modest_window_mgr_finalize (GObject *obj) { ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE(obj); + if (priv->idle_load_view_id > 0) { + g_source_remove (priv->idle_load_view_id); + priv->idle_load_view_id = 0; + } + + if (priv->idle_load_editor_id > 0) { + g_source_remove (priv->idle_load_editor_id); + priv->idle_load_editor_id = 0; + } + + if (priv->cached_view) { + gtk_widget_destroy (priv->cached_view); + priv->cached_view = NULL; + } + if (priv->cached_editor) { + gtk_widget_destroy (priv->cached_editor); + priv->cached_editor = NULL; + } + if (priv->window_list) { GList *iter = priv->window_list; /* unregister pending windows */ @@ -276,10 +356,10 @@ modest_window_mgr_register_header (ModestWindowMgr *self, TnyHeader *header, co uid = g_strdup (alt_uid); if (!has_uid (priv->preregistered_uids, uid)) { - g_debug ("registering new uid %s", uid); + MODEST_DEBUG_BLOCK(g_debug ("registering new uid %s", uid);); priv->preregistered_uids = append_uid (priv->preregistered_uids, uid); } else - g_debug ("already had uid %s", uid); + MODEST_DEBUG_BLOCK(g_debug ("already had uid %s", uid);); g_free (uid); } @@ -297,17 +377,17 @@ modest_window_mgr_unregister_header (ModestWindowMgr *self, TnyHeader *header) uid = modest_tny_folder_get_header_unique_id (header); if (!has_uid (priv->preregistered_uids, uid)) { - g_debug ("trying to unregister non-existing uid %s", uid); + MODEST_DEBUG_BLOCK(g_debug ("trying to unregister non-existing uid %s", uid);); priv->preregistered_uids = append_uid (priv->preregistered_uids, uid); } else - g_debug ("unregistering uid %s", uid); + MODEST_DEBUG_BLOCK(g_debug ("unregistering uid %s", uid);); if (has_uid (priv->preregistered_uids, uid)) { priv->preregistered_uids = remove_uid (priv->preregistered_uids, uid); if (has_uid (priv->preregistered_uids, uid)) g_debug ("BUG: uid %s NOT removed", uid); else - g_debug ("uid %s removed", uid); + MODEST_DEBUG_BLOCK(g_debug ("uid %s removed", uid);); } g_free (uid); @@ -366,15 +446,6 @@ modest_window_mgr_get_help_id (ModestWindowMgr *self, GtkWindow *win) return help_id; } - - - - - - - - - static gint compare_msguids (ModestWindow *win, const gchar *uid) @@ -403,19 +474,25 @@ void modest_window_mgr_close_all_windows (ModestWindowMgr *self) { ModestWindowMgrPrivate *priv = NULL; - GList *wins = NULL; gboolean ret_value = FALSE; g_return_if_fail (MODEST_IS_WINDOW_MGR (self)); priv = MODEST_WINDOW_MGR_GET_PRIVATE (self); - /* delete-event handler already removes window_list item, */ - /* so no next its required on this loop */ - wins = priv->window_list; - while (wins) { - g_signal_emit_by_name (G_OBJECT (wins->data), "delete-event", NULL, &ret_value); + /* If there is a main window then try to close it, and it will + close the others if needed */ + if (priv->main_window) { + g_signal_emit_by_name (priv->main_window, "delete-event", NULL, &ret_value); + } else { + GList *wins = NULL, *next = NULL; + /* delete-event handler actually removes window_list item, */ wins = priv->window_list; + while (wins) { + next = g_list_next (wins); + g_signal_emit_by_name (G_OBJECT (wins->data), "delete-event", NULL, &ret_value); + wins = next; + } } } @@ -499,8 +576,9 @@ modest_window_mgr_register_window (ModestWindowMgr *self, win = g_list_find (priv->window_list, window); if (win) { - g_warning ("%s: trying to re-register a window", - __FUNCTION__); + /* this is for the case we want to register the window and it was already + * registered. We leave silently. + */ return; } @@ -512,6 +590,8 @@ modest_window_mgr_register_window (ModestWindowMgr *self, return; } else { priv->main_window = window; + load_new_view (self); + load_new_editor (self); } } @@ -523,7 +603,7 @@ modest_window_mgr_register_window (ModestWindowMgr *self, if (!has_uid (priv->preregistered_uids, uid)) g_debug ("weird: no uid for window (%s)", uid); - g_debug ("registering window for %s", uid ? uid : ""); + MODEST_DEBUG_BLOCK(g_debug ("registering window for %s", uid ? uid : "");); priv->preregistered_uids = remove_uid (priv->preregistered_uids, @@ -533,7 +613,7 @@ modest_window_mgr_register_window (ModestWindowMgr *self, const gchar *uid = modest_msg_edit_window_get_message_uid (MODEST_MSG_EDIT_WINDOW (window)); - g_debug ("registering window for %s", uid); + MODEST_DEBUG_BLOCK(g_debug ("registering window for %s", uid);); priv->preregistered_uids = remove_uid (priv->preregistered_uids, @@ -584,6 +664,9 @@ on_window_destroy (ModestWindow *window, /* If more than one window already opened */ if (g_list_length (priv->window_list) > 1) { + /* Present the window if it's not visible now */ + if (!gtk_window_has_toplevel_focus (GTK_WINDOW (window))) + gtk_window_present (GTK_WINDOW (window)); /* Create the confirmation dialog MSG-NOT308 */ dialog_response = modest_platform_run_confirmation_dialog ( GTK_WINDOW (window), _("emev_nc_close_windows")); @@ -628,7 +711,7 @@ on_window_destroy (ModestWindow *window, modest_platform_run_confirmation_dialog (GTK_WINDOW (window), _("mcen_nc_no_email_message_modified_save_changes")); /* Save to drafts */ - if (response != GTK_RESPONSE_CANCEL) + if (response != GTK_RESPONSE_CANCEL) modest_ui_actions_on_save_to_drafts (NULL, MODEST_MSG_EDIT_WINDOW (window)); } } @@ -652,62 +735,6 @@ disconnect_msg_changed (gpointer key, g_signal_handler_disconnect (G_OBJECT (key), handler_id); } - - -/* interval before retrying to close the application */ -#define CLOSING_RETRY_INTERVAL 3000 -/* interval before cancel whatever is left in the queue, and closing anyway */ -#define MAX_WAIT_FOR_CLOSING 30 * 1000 - -static gboolean -on_quit_maybe (ModestWindowMgr *self) -{ - ModestWindowMgrPrivate *priv; - guint queue_num; - - priv = MODEST_WINDOW_MGR_GET_PRIVATE (self); - - /* it seems, in the meantime some windows were - * created. in that case, stop 'on_quit_maybe' */ - if (priv->window_list) { - priv->closing_time = 0; - return FALSE; - } - - if (priv->closing_time >= MAX_WAIT_FOR_CLOSING) { - /* we waited long enough: cancel all remaining operations */ - g_debug ("%s: we waited long enough (%ds), cancelling queue and quiting", - __FUNCTION__, priv->closing_time/1000); - /* FIXME: below gives me a lot of: - * GLIB CRITICAL ** default - modest_mail_operation_cancel: - * assertion `priv->account' failed - * which means there is no account for the given operation - * so, we're not trying to be nice, we're just quiting. - */ - //modest_mail_operation_queue_cancel_all - // (modest_runtime_get_mail_operation_queue()); - } else { - - /* if there is anything left in our operation queue, - * wait another round - */ - queue_num = modest_mail_operation_queue_num_elements - (modest_runtime_get_mail_operation_queue()); - if (queue_num > 0) { - g_debug ("%s: waiting, there are still %d operation(s) queued", - __FUNCTION__, queue_num); - priv->closing_time += CLOSING_RETRY_INTERVAL; - return TRUE; - } - } - - /* so: no windows left, nothing in the queue: quit */ - priv->closing_time = 0; - gtk_main_quit (); - return FALSE; -} - - void modest_window_mgr_unregister_window (ModestWindowMgr *self, ModestWindow *window) @@ -764,6 +791,26 @@ modest_window_mgr_unregister_window (ModestWindowMgr *self, handler_id = *tmp; g_hash_table_remove (priv->destroy_handlers, window); + /* cancel open and receive operations */ + if (MODEST_IS_MSG_VIEW_WINDOW (window)) { + ModestMailOperationTypeOperation type; + GSList* pending_ops = NULL; + GSList* tmp_list = NULL; + pending_ops = modest_mail_operation_queue_get_by_source ( + modest_runtime_get_mail_operation_queue (), + G_OBJECT (window)); + while (pending_ops != NULL) { + type = modest_mail_operation_get_type_operation (MODEST_MAIL_OPERATION (pending_ops->data)); + if (type == MODEST_MAIL_OPERATION_TYPE_RECEIVE || type == MODEST_MAIL_OPERATION_TYPE_OPEN) { + modest_mail_operation_cancel (pending_ops->data); + } + g_object_unref (G_OBJECT (pending_ops->data)); + tmp_list = pending_ops; + pending_ops = g_slist_next (pending_ops); + g_slist_free_1 (tmp_list); + } + } + /* Disconnect the "delete-event" handler, we won't need it anymore */ g_signal_handler_disconnect (window, handler_id); @@ -773,10 +820,9 @@ modest_window_mgr_unregister_window (ModestWindowMgr *self, /* Destroy the window */ gtk_widget_destroy (win->data); - /* If there are no more windows registered then exit program */ - if (priv->window_list == NULL) - g_timeout_add (CLOSING_RETRY_INTERVAL, - (GSourceFunc)on_quit_maybe, self); + /* If there are no more windows registered emit the signal */ + if (priv->window_list == NULL && priv->banner_counter == 0) + g_signal_emit (self, signals[WINDOW_LIST_EMPTY_SIGNAL], 0); } @@ -888,7 +934,9 @@ modest_window_mgr_get_main_window (ModestWindowMgr *self, gboolean create) if (!priv->main_window && create) { /* modest_window_mgr_register_window will set priv->main_window */ modest_window_mgr_register_window (self, modest_main_window_new ()); - g_debug ("%s: created main window: %p\n", __FUNCTION__, priv->main_window); + MODEST_DEBUG_BLOCK( + g_debug ("%s: created main window: %p\n", __FUNCTION__, priv->main_window); + ); } return priv->main_window; @@ -1122,3 +1170,90 @@ on_modal_dialog_close (GtkDialog *dialog, remove_modal_from_queue (GTK_WIDGET (dialog), self); } +gint +modest_window_mgr_num_windows (ModestWindowMgr *self) +{ + ModestWindowMgrPrivate *priv; + gint num_windows = 0; + + g_return_val_if_fail (self && MODEST_IS_WINDOW_MGR(self), -1); + + priv = MODEST_WINDOW_MGR_GET_PRIVATE(self); + + if (priv->window_list) + num_windows = g_list_length (priv->window_list); + + return num_windows + priv->banner_counter; +} + +GtkWidget * +modest_window_mgr_get_msg_edit_window (ModestWindowMgr *self) +{ + GtkWidget *result; + ModestWindowMgrPrivate *priv; + + g_return_val_if_fail (self && MODEST_IS_WINDOW_MGR(self), NULL); + + priv = MODEST_WINDOW_MGR_GET_PRIVATE(self); + + if (priv->cached_editor) { + result = priv->cached_editor; + priv->cached_editor = NULL; + load_new_editor (self); + } else { + result = g_object_new (MODEST_TYPE_MSG_EDIT_WINDOW, NULL); + } + + return result; +} + +GtkWidget * +modest_window_mgr_get_msg_view_window (ModestWindowMgr *self) +{ + GtkWidget *result; + ModestWindowMgrPrivate *priv; + + g_return_val_if_fail (self && MODEST_IS_WINDOW_MGR(self), NULL); + + priv = MODEST_WINDOW_MGR_GET_PRIVATE(self); + + if (priv->cached_view) { + result = priv->cached_view; + priv->cached_view = NULL; + load_new_view (self); + } else { + result = g_object_new (MODEST_TYPE_MSG_VIEW_WINDOW, NULL); + } + + return result; +} + +void +modest_window_mgr_register_banner (ModestWindowMgr *self) +{ + ModestWindowMgrPrivate *priv; + + g_return_if_fail (MODEST_IS_WINDOW_MGR (self)); + priv = MODEST_WINDOW_MGR_GET_PRIVATE (self); + + priv->banner_counter++; + g_message ("REGISTER BANNER -> %d", priv->banner_counter); + +} + +void +modest_window_mgr_unregister_banner (ModestWindowMgr *self) +{ + ModestWindowMgrPrivate *priv; + + g_return_if_fail (MODEST_IS_WINDOW_MGR (self)); + priv = MODEST_WINDOW_MGR_GET_PRIVATE (self); + + priv->banner_counter--; + g_message ("UNREGISTER BANNER -> %d", priv->banner_counter); + if (priv->window_list == NULL && priv->banner_counter == 0) { + g_signal_emit (self, signals[WINDOW_LIST_EMPTY_SIGNAL], 0); + g_message ("WINDOW LIST EMPTY"); + } + +}