+
+gboolean
+modest_window_mgr_get_fullscreen_mode (ModestWindowMgr *self)
+{
+ ModestWindowMgrPrivate *priv;
+
+ g_return_val_if_fail (MODEST_IS_WINDOW_MGR (self), FALSE);
+
+ priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
+
+ return priv->fullscreen_mode;
+}
+
+void
+modest_window_mgr_show_toolbars (ModestWindowMgr *self,
+ GType window_type,
+ gboolean show_toolbars,
+ gboolean fullscreen)
+{
+ ModestWindowMgrPrivate *priv;
+ ModestConf *conf;
+ const gchar *key = NULL;
+
+ g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
+
+ priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
+ conf = modest_runtime_get_conf ();
+
+ /* If nothing changes then return */
+ key = get_show_toolbar_key (window_type, fullscreen);
+ conf = modest_runtime_get_conf ();
+ if (modest_conf_get_bool (conf, key, NULL) == show_toolbars)
+ return;
+
+ /* Save in conf */
+ modest_conf_set_bool (conf, key, show_toolbars, NULL);
+
+ /* Apply now if the view mode is the right one */
+ if ((fullscreen && priv->fullscreen_mode) ||
+ (!fullscreen && !priv->fullscreen_mode)) {
+
+ GList *win = priv->window_list;
+
+ while (win) {
+ if (G_TYPE_FROM_INSTANCE (win->data) == window_type)
+ modest_window_show_toolbar (MODEST_WINDOW (win->data),
+ show_toolbars);
+ win = g_list_next (win);
+ }
+ }
+}
+
+ModestWindow*
+modest_window_mgr_get_main_window (ModestWindowMgr *self, gboolean create)
+{
+ ModestWindowMgrPrivate *priv;
+
+ g_return_val_if_fail (MODEST_IS_WINDOW_MGR (self), NULL);
+ priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
+
+ /* create the main window, if it hasn't been created yet */
+ 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 ());
+ MODEST_DEBUG_BLOCK(
+ g_debug ("%s: created main window: %p\n", __FUNCTION__, priv->main_window);
+ );
+ }
+
+ return priv->main_window;
+}
+
+
+gboolean
+modest_window_mgr_main_window_exists (ModestWindowMgr *self)
+{
+ ModestWindowMgrPrivate *priv;
+
+ g_return_val_if_fail (MODEST_IS_WINDOW_MGR (self), FALSE);
+ priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
+
+ return priv->main_window != NULL;
+}
+
+
+GtkWindow *
+modest_window_mgr_get_modal (ModestWindowMgr *self)
+{
+ ModestWindowMgrPrivate *priv;
+
+ g_return_val_if_fail (MODEST_IS_WINDOW_MGR (self), NULL);
+ priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
+
+ return g_queue_peek_head (priv->modal_windows);
+}
+
+
+void
+modest_window_mgr_set_modal (ModestWindowMgr *self,
+ GtkWindow *window)
+{
+ GtkWindow *old_modal;
+ ModestWindowMgrPrivate *priv;
+
+ g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
+ g_return_if_fail (GTK_IS_WINDOW (window));
+
+ priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
+ g_mutex_lock (priv->queue_lock);
+ old_modal = g_queue_peek_head (priv->modal_windows);
+ g_mutex_unlock (priv->queue_lock);
+
+ if (!old_modal) {
+ /* make us transient wrt the main window then */
+ if (priv->current_top && ((GtkWindow *) priv->current_top != window)) {
+ gtk_window_set_transient_for (window, GTK_WINDOW(priv->current_top));
+ } else {
+ ModestWindow *main_win = modest_window_mgr_get_main_window (self, FALSE);
+ if (GTK_WINDOW(main_win) != window) /* they should not be the same */
+ gtk_window_set_transient_for (window, GTK_WINDOW(main_win));
+ }
+ gtk_window_set_modal (window, TRUE);
+ } else {
+ /* un-modalize the old one; the one on top should be the
+ * modal one */
+ gtk_window_set_transient_for (window, GTK_WINDOW(old_modal));
+ gtk_window_set_modal (window, TRUE);
+ }
+
+ /* this will be the new modal window */
+ g_mutex_lock (priv->queue_lock);
+ g_queue_push_head (priv->modal_windows, window);
+ g_mutex_unlock (priv->queue_lock);
+
+ if (GTK_IS_DIALOG (window)) {
+ /* Note that response is not always enough because it
+ could be captured and removed easily by dialogs but
+ works for most of situations */
+ priv->modal_handler_uids =
+ modest_signal_mgr_connect (priv->modal_handler_uids,
+ G_OBJECT (window),
+ "response",
+ G_CALLBACK (on_modal_dialog_close),
+ self);
+ /* We need this as well because dialogs are often
+ destroyed with gtk_widget_destroy and this one will
+ prevent response from happening */
+ priv->modal_handler_uids =
+ modest_signal_mgr_connect (priv->modal_handler_uids,
+ G_OBJECT (window),
+ "destroy",
+ G_CALLBACK (on_modal_dialog_destroy),
+ self);
+ } else {
+ priv->modal_handler_uids =
+ modest_signal_mgr_connect (priv->modal_handler_uids,
+ G_OBJECT (window),
+ "delete-event",
+ G_CALLBACK (on_modal_window_close),
+ self);
+ }
+ /* Destroy width parent */
+ gtk_window_set_destroy_with_parent (window, TRUE);
+}
+
+
+static void
+on_nonhibernating_window_hide(GtkWidget *widget, gpointer user_data)
+{
+ ModestWindowMgr *self = MODEST_WINDOW_MGR (user_data);
+ ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
+
+ /* Forget this window,
+ * so hibernation will be allowed again if no windows are remembered: */
+ priv->windows_that_prevent_hibernation =
+ g_slist_remove (priv->windows_that_prevent_hibernation, GTK_WINDOW(widget));
+}
+
+static void
+on_nonhibernating_window_show(GtkWidget *widget, gpointer user_data)
+{
+ ModestWindowMgr *self = MODEST_WINDOW_MGR (user_data);
+ ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
+
+ GtkWindow *window = GTK_WINDOW (widget);
+
+ priv->windows_that_prevent_hibernation =
+ g_slist_append (priv->windows_that_prevent_hibernation, window);
+
+ /* Allow hibernation again when the window has been hidden: */
+ g_signal_connect (window, "hide",
+ G_CALLBACK (on_nonhibernating_window_hide), self);
+}
+
+void
+modest_window_mgr_prevent_hibernation_while_window_is_shown (ModestWindowMgr *self,
+ GtkWindow *window)
+{
+ g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
+
+ if (GTK_WIDGET_VISIBLE(window)) {
+ on_nonhibernating_window_show (GTK_WIDGET (window), self);
+ } else {
+ /* Wait for it to be shown: */
+ g_signal_connect (window, "show",
+ G_CALLBACK (on_nonhibernating_window_show), self);
+ }
+}
+
+gboolean
+modest_window_mgr_get_hibernation_is_prevented (ModestWindowMgr *self)
+{
+ g_return_val_if_fail (MODEST_IS_WINDOW_MGR (self), FALSE);
+
+ ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
+
+ /* Prevent hibernation if any open windows are currently
+ * preventing hibernation: */
+ return (g_slist_length (priv->windows_that_prevent_hibernation) > 0);
+}
+
+
+void
+modest_window_mgr_save_state_for_all_windows (ModestWindowMgr *self)
+{
+ g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
+
+ ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
+
+ /* Iterate over all windows */
+ GList *win = priv->window_list;
+ while (win) {
+ ModestWindow *window = MODEST_WINDOW (win->data);
+ if (window) {
+ /* This calls the vfunc,
+ * so each window can do its own thing: */
+ modest_window_save_state (window);
+ }
+
+ win = g_list_next (win);
+ }
+}
+
+static gboolean
+idle_top_modal (gpointer data)
+{
+ ModestWindowMgr *self = MODEST_WINDOW_MGR (data);
+ ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
+ GtkWindow *topmost;
+
+ /* Get the top modal */
+ g_mutex_lock (priv->queue_lock);
+ topmost = (GtkWindow *) g_queue_peek_head (priv->modal_windows);
+ g_mutex_unlock (priv->queue_lock);
+
+ /* Show it */
+ if (topmost) {
+ gdk_threads_enter ();
+ gtk_window_present (topmost);
+ /* It seems that the window looses modality if some
+ other is shown on top of it after set_transient_for
+ and set_parent */
+ gtk_window_set_modal (topmost, TRUE);
+ gdk_threads_leave ();
+ }
+
+ return FALSE;
+}
+
+static void
+remove_modal_from_queue (GtkWidget *widget,
+ ModestWindowMgr *self)
+{
+ ModestWindowMgrPrivate *priv;
+ GList *item = NULL;
+
+ priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
+
+ /* Remove from queue. We don't use remove, because we want to
+ exit if the widget does not belong to the queue */
+ g_mutex_lock (priv->queue_lock);
+ item = g_queue_find (priv->modal_windows, widget);
+ if (!item) {
+ g_warning ("Trying to remove a modal window that is not registered");
+ g_mutex_unlock (priv->queue_lock);
+ return;
+ }
+ g_queue_unlink (priv->modal_windows, item);
+ g_mutex_unlock (priv->queue_lock);
+
+ /* Disconnect handler */
+ priv->modal_handler_uids =
+ modest_signal_mgr_disconnect (priv->modal_handler_uids,
+ G_OBJECT (widget),
+ GTK_IS_DIALOG (widget) ?
+ "response" :
+ "delete-event");
+ if (GTK_IS_DIALOG (widget))
+ priv->modal_handler_uids =
+ modest_signal_mgr_disconnect (priv->modal_handler_uids,
+ G_OBJECT (widget),
+ "destroy");
+
+ /* Schedule the next one for being shown */
+ g_idle_add (idle_top_modal, self);
+}
+
+static gboolean
+on_modal_window_close (GtkWidget *widget,
+ GdkEvent *event,
+ gpointer user_data)
+{
+ ModestWindowMgr *self = MODEST_WINDOW_MGR (user_data);
+
+ /* Remove modal window from queue */
+ remove_modal_from_queue (widget, self);
+
+ /* Continue */
+ return FALSE;
+}
+
+static void
+on_modal_dialog_close (GtkDialog *dialog,
+ gint arg1,
+ gpointer user_data)
+{
+ ModestWindowMgr *self = MODEST_WINDOW_MGR (user_data);
+
+ /* Remove modal window from queue. Note that if "destroy"
+ signal was invoked before the response the window could be
+ already deleted */
+ remove_modal_from_queue (GTK_WIDGET (dialog), self);
+}
+
+static void
+on_modal_dialog_destroy (GtkObject *object,
+ gpointer user_data)
+{
+ ModestWindowMgr *self = MODEST_WINDOW_MGR (user_data);
+
+ /* Remove modal window from queue */
+ remove_modal_from_queue (GTK_WIDGET (object), 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);
+
+ /* Do not take into account the main window if it was hidden */
+ if (priv->main_window && !GTK_WIDGET_VISIBLE (priv->main_window))
+ num_windows--;
+
+ 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++;
+
+}
+
+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--;
+ if (modest_window_mgr_num_windows (self) == 0)
+ g_signal_emit (self, signals[WINDOW_LIST_EMPTY_SIGNAL], 0);
+}