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 modest_window_mgr_register_window_default (ModestWindowMgr *self,
49 ModestWindow *parent);
50 static void modest_window_mgr_unregister_window_default (ModestWindowMgr *self,
51 ModestWindow *window);
52 static void modest_window_mgr_set_fullscreen_mode_default (ModestWindowMgr *self,
54 static gboolean modest_window_mgr_get_fullscreen_mode_default (ModestWindowMgr *self);
55 static void modest_window_mgr_show_toolbars_default (ModestWindowMgr *self,
57 gboolean show_toolbars,
59 static ModestWindow* modest_window_mgr_get_main_window_default (ModestWindowMgr *self, gboolean show);
60 static GtkWindow *modest_window_mgr_get_modal_default (ModestWindowMgr *self);
61 static void modest_window_mgr_set_modal_default (ModestWindowMgr *self,
64 static gboolean modest_window_mgr_close_all_windows_default (ModestWindowMgr *self);
65 static gboolean modest_window_mgr_find_registered_header_default (ModestWindowMgr *self,
68 static GList *modest_window_mgr_get_window_list_default (ModestWindowMgr *self);
72 WINDOW_LIST_EMPTY_SIGNAL,
76 typedef struct _ModestWindowMgrPrivate ModestWindowMgrPrivate;
77 struct _ModestWindowMgrPrivate {
80 ModestWindow *main_window;
82 GSList *windows_that_prevent_hibernation;
83 GSList *preregistered_uids;
87 GtkWidget *cached_view;
88 GtkWidget *cached_editor;
89 guint idle_load_view_id;
90 guint idle_load_editor_id;
93 #define MODEST_WINDOW_MGR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
94 MODEST_TYPE_WINDOW_MGR, \
95 ModestWindowMgrPrivate))
97 static GObjectClass *parent_class = NULL;
99 /* uncomment the following if you have defined any signals */
100 static guint signals[NUM_SIGNALS] = {0};
103 modest_window_mgr_get_type (void)
105 static GType my_type = 0;
107 static const GTypeInfo my_info = {
108 sizeof(ModestWindowMgrClass),
109 NULL, /* base init */
110 NULL, /* base finalize */
111 (GClassInitFunc) modest_window_mgr_class_init,
112 NULL, /* class finalize */
113 NULL, /* class data */
114 sizeof(ModestWindowMgr),
116 (GInstanceInitFunc) modest_window_mgr_init,
119 my_type = g_type_register_static (G_TYPE_OBJECT,
127 modest_window_mgr_class_init (ModestWindowMgrClass *klass)
129 GObjectClass *gobject_class;
130 ModestWindowMgrClass *mgr_class;
132 gobject_class = (GObjectClass*) klass;
133 mgr_class = (ModestWindowMgrClass *) klass;
135 parent_class = g_type_class_peek_parent (klass);
136 gobject_class->finalize = modest_window_mgr_finalize;
137 mgr_class->register_window = modest_window_mgr_register_window_default;
138 mgr_class->unregister_window = modest_window_mgr_unregister_window_default;
139 mgr_class->set_fullscreen_mode = modest_window_mgr_set_fullscreen_mode_default;
140 mgr_class->get_fullscreen_mode = modest_window_mgr_get_fullscreen_mode_default;
141 mgr_class->show_toolbars = modest_window_mgr_show_toolbars_default;
142 mgr_class->get_main_window = modest_window_mgr_get_main_window_default;
143 mgr_class->get_modal = modest_window_mgr_get_modal_default;
144 mgr_class->set_modal = modest_window_mgr_set_modal_default;
145 mgr_class->close_all_windows = modest_window_mgr_close_all_windows_default;
146 mgr_class->find_registered_header = modest_window_mgr_find_registered_header_default;
147 mgr_class->get_window_list = modest_window_mgr_get_window_list_default;
149 g_type_class_add_private (gobject_class, sizeof(ModestWindowMgrPrivate));
153 * ModestWindowMgr::window-list-empty
154 * @self: the #ModestWindowMgr that emits the signal
155 * @user_data: user data set when the signal handler was connected
157 * Issued whenever the window list becomes empty
159 signals[WINDOW_LIST_EMPTY_SIGNAL] =
160 g_signal_new ("window-list-empty",
161 G_TYPE_FROM_CLASS (gobject_class),
163 G_STRUCT_OFFSET (ModestWindowMgrClass, window_list_empty),
165 g_cclosure_marshal_VOID__VOID,
170 idle_load_view (ModestWindowMgr *mgr)
172 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (mgr);
174 priv->cached_view = g_object_new (MODEST_TYPE_MSG_VIEW_WINDOW, NULL);
175 priv->idle_load_view_id = 0;
180 idle_load_editor (ModestWindowMgr *mgr)
182 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (mgr);
184 priv->cached_editor = g_object_new (MODEST_TYPE_MSG_EDIT_WINDOW, NULL);
185 priv->idle_load_editor_id = 0;
190 load_new_view (ModestWindowMgr *self)
192 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
193 if ((priv->cached_view == NULL) && (priv->idle_load_view_id == 0))
194 priv->idle_load_view_id = g_idle_add ((GSourceFunc) idle_load_view, self);
198 load_new_editor (ModestWindowMgr *self)
200 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
201 if ((priv->cached_editor == NULL) && (priv->idle_load_editor_id == 0))
202 priv->idle_load_editor_id = g_idle_add ((GSourceFunc) idle_load_editor, self);
206 modest_window_mgr_init (ModestWindowMgr *obj)
208 ModestWindowMgrPrivate *priv;
210 priv = MODEST_WINDOW_MGR_GET_PRIVATE(obj);
211 priv->banner_counter = 0;
212 priv->main_window = NULL;
214 priv->preregistered_uids = NULL;
216 priv->closing_time = 0;
218 priv->cached_view = NULL;
219 priv->cached_editor = NULL;
221 priv->windows_that_prevent_hibernation = NULL;
225 modest_window_mgr_finalize (GObject *obj)
227 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE(obj);
229 if (priv->idle_load_view_id > 0) {
230 g_source_remove (priv->idle_load_view_id);
231 priv->idle_load_view_id = 0;
234 if (priv->idle_load_editor_id > 0) {
235 g_source_remove (priv->idle_load_editor_id);
236 priv->idle_load_editor_id = 0;
239 if (priv->cached_view) {
240 gtk_widget_destroy (priv->cached_view);
241 priv->cached_view = NULL;
243 if (priv->cached_editor) {
244 gtk_widget_destroy (priv->cached_editor);
245 priv->cached_editor = NULL;
248 if (priv->windows_that_prevent_hibernation) {
249 g_slist_free (priv->windows_that_prevent_hibernation);
250 priv->cached_editor = NULL;
253 g_slist_foreach (priv->preregistered_uids, (GFunc)g_free, NULL);
254 g_slist_free (priv->preregistered_uids);
256 G_OBJECT_CLASS(parent_class)->finalize (obj);
260 modest_window_mgr_new (void)
262 return MODEST_WINDOW_MGR(g_object_new(MODEST_TYPE_WINDOW_MGR, NULL));
268 /* do we have uid? */
270 has_uid (GSList *list, const gchar *uid)
272 GSList *cursor = list;
278 if (cursor->data && strcmp (cursor->data, uid) == 0)
280 cursor = g_slist_next (cursor);
286 /* remove all from the list have have uid = uid */
288 remove_uid (GSList *list, const gchar *uid)
290 GSList *cursor = list, *start = list;
296 GSList *next = g_slist_next (cursor);
297 if (cursor->data && strcmp (cursor->data, uid) == 0) {
298 g_free (cursor->data);
299 start = g_slist_delete_link (start, cursor);
308 append_uid (GSList *list, const gchar *uid)
310 return g_slist_append (list, g_strdup(uid));
316 modest_window_mgr_register_header (ModestWindowMgr *self, TnyHeader *header, const gchar *alt_uid)
318 ModestWindowMgrPrivate *priv;
321 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
322 g_return_if_fail (TNY_IS_HEADER(header));
324 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
325 uid = modest_tny_folder_get_header_unique_id (header);
328 uid = g_strdup (alt_uid);
330 if (!has_uid (priv->preregistered_uids, uid)) {
331 MODEST_DEBUG_BLOCK(g_debug ("registering new uid %s", uid););
332 priv->preregistered_uids = append_uid (priv->preregistered_uids, uid);
334 MODEST_DEBUG_BLOCK(g_debug ("already had uid %s", uid););
340 modest_window_mgr_unregister_header (ModestWindowMgr *self, TnyHeader *header)
342 ModestWindowMgrPrivate *priv;
345 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
346 g_return_if_fail (TNY_IS_HEADER(header));
348 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
349 uid = modest_tny_folder_get_header_unique_id (header);
351 if (!has_uid (priv->preregistered_uids, uid)) {
352 MODEST_DEBUG_BLOCK(g_debug ("trying to unregister non-existing uid %s", uid););
353 priv->preregistered_uids = append_uid (priv->preregistered_uids, uid);
355 MODEST_DEBUG_BLOCK(g_debug ("unregistering uid %s", uid););
357 if (has_uid (priv->preregistered_uids, uid)) {
358 priv->preregistered_uids = remove_uid (priv->preregistered_uids, uid);
359 if (has_uid (priv->preregistered_uids, uid))
360 g_debug ("BUG: uid %s NOT removed", uid);
362 MODEST_DEBUG_BLOCK(g_debug ("uid %s removed", uid););
369 #define MODEST_WINDOW_HELP_ID_PARAM "help-id"
372 modest_window_mgr_register_help_id (ModestWindowMgr *self, GtkWindow *win, const gchar* help_id)
374 /* we don't need 'self', but for API consistency... */
375 g_return_if_fail (self && MODEST_IS_WINDOW_MGR(self));
377 g_return_if_fail (win && GTK_IS_WINDOW(win));
378 g_return_if_fail (help_id);
380 g_object_set_data_full (G_OBJECT(win), MODEST_WINDOW_HELP_ID_PARAM,
381 g_strdup(help_id), g_free);
386 modest_window_mgr_get_help_id (ModestWindowMgr *self, GtkWindow *win)
388 /* we don't need 'self', but for API consistency... */
389 g_return_val_if_fail (self && MODEST_IS_WINDOW_MGR (self), NULL);
390 g_return_val_if_fail (win, NULL);
392 return g_object_get_data (G_OBJECT(win), MODEST_WINDOW_HELP_ID_PARAM);
396 modest_window_mgr_close_all_windows (ModestWindowMgr *self)
398 return MODEST_WINDOW_MGR_GET_CLASS (self)->close_all_windows (self);
402 modest_window_mgr_close_all_windows_default (ModestWindowMgr *self)
409 modest_window_mgr_find_registered_header (ModestWindowMgr *self, TnyHeader *header,
412 return MODEST_WINDOW_MGR_GET_CLASS (self)->find_registered_header (self, header, win);
416 modest_window_mgr_find_registered_header_default (ModestWindowMgr *self, TnyHeader *header,
419 ModestWindowMgrPrivate *priv = NULL;
421 gboolean has_header = FALSE;
423 g_return_val_if_fail (MODEST_IS_WINDOW_MGR (self), FALSE);
424 g_return_val_if_fail (TNY_IS_HEADER(header), FALSE);
426 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
428 uid = modest_tny_folder_get_header_unique_id (header);
433 has_header = has_uid (priv->preregistered_uids, uid);
439 modest_window_mgr_get_window_list (ModestWindowMgr *self)
441 return MODEST_WINDOW_MGR_GET_CLASS (self)->get_window_list (self);
445 modest_window_mgr_get_window_list_default (ModestWindowMgr *self)
451 modest_window_mgr_register_window (ModestWindowMgr *self,
452 ModestWindow *window,
453 ModestWindow *parent)
455 return MODEST_WINDOW_MGR_GET_CLASS (self)->register_window (self, window, parent);
459 modest_window_mgr_register_window_default (ModestWindowMgr *self,
460 ModestWindow *window,
461 ModestWindow *parent)
463 ModestWindowMgrPrivate *priv;
465 g_return_val_if_fail (MODEST_IS_WINDOW_MGR (self), FALSE);
466 g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
468 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
470 /* Check that it's not a second main window */
471 if (MODEST_IS_MAIN_WINDOW (window)) {
472 if (priv->main_window) {
473 g_warning ("%s: trying to register a second main window",
477 priv->main_window = window;
478 load_new_view (self);
479 load_new_editor (self);
483 /* remove from the list of pre-registered uids */
484 if (MODEST_IS_MSG_VIEW_WINDOW(window)) {
485 const gchar *uid = modest_msg_view_window_get_message_uid
486 (MODEST_MSG_VIEW_WINDOW (window));
488 if (!has_uid (priv->preregistered_uids, uid))
489 g_debug ("weird: no uid for window (%s)", uid);
491 MODEST_DEBUG_BLOCK(g_debug ("registering window for %s", uid ? uid : "<none>"););
493 priv->preregistered_uids =
494 remove_uid (priv->preregistered_uids,
495 modest_msg_view_window_get_message_uid
496 (MODEST_MSG_VIEW_WINDOW (window)));
497 } else if (MODEST_IS_MSG_EDIT_WINDOW(window)) {
498 const gchar *uid = modest_msg_edit_window_get_message_uid
499 (MODEST_MSG_EDIT_WINDOW (window));
501 MODEST_DEBUG_BLOCK(g_debug ("registering window for %s", uid););
503 priv->preregistered_uids =
504 remove_uid (priv->preregistered_uids,
505 modest_msg_edit_window_get_message_uid
506 (MODEST_MSG_EDIT_WINDOW (window)));
513 modest_window_mgr_unregister_window (ModestWindowMgr *self,
514 ModestWindow *window)
516 MODEST_WINDOW_MGR_GET_CLASS (self)->unregister_window (self, window);
520 modest_window_mgr_unregister_window_default (ModestWindowMgr *self,
521 ModestWindow *window)
523 ModestWindowMgrPrivate *priv;
525 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
526 g_return_if_fail (MODEST_IS_WINDOW (window));
528 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
531 modest_window_save_state (window);
533 /* Disconnect all the window signals */
534 modest_window_disconnect_signals (window);
536 /* Destroy the window */
537 gtk_widget_destroy (GTK_WIDGET (window));
543 modest_window_mgr_set_fullscreen_mode (ModestWindowMgr *self,
546 MODEST_WINDOW_MGR_GET_CLASS (self)->set_fullscreen_mode (self, on);
550 modest_window_mgr_set_fullscreen_mode_default (ModestWindowMgr *self,
557 modest_window_mgr_get_fullscreen_mode (ModestWindowMgr *self)
559 return MODEST_WINDOW_MGR_GET_CLASS (self)->get_fullscreen_mode (self);
563 modest_window_mgr_get_fullscreen_mode_default (ModestWindowMgr *self)
569 modest_window_mgr_show_toolbars (ModestWindowMgr *self,
571 gboolean show_toolbars,
574 return MODEST_WINDOW_MGR_GET_CLASS (self)->show_toolbars (self, window_type, show_toolbars, fullscreen);
578 modest_window_mgr_show_toolbars_default (ModestWindowMgr *self,
580 gboolean show_toolbars,
587 modest_window_mgr_set_main_window (ModestWindowMgr *self, ModestWindow *win)
589 ModestWindowMgrPrivate *priv;
591 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
593 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
594 priv->main_window = win;
598 modest_window_mgr_get_main_window (ModestWindowMgr *self, gboolean show)
600 return MODEST_WINDOW_MGR_GET_CLASS (self)->get_main_window (self, show);
604 modest_window_mgr_get_main_window_default (ModestWindowMgr *self, gboolean show)
606 ModestWindowMgrPrivate *priv;
608 g_return_val_if_fail (MODEST_IS_WINDOW_MGR (self), NULL);
610 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
611 if (priv->main_window)
612 return priv->main_window;
615 return modest_main_window_new ();
621 modest_window_mgr_main_window_exists (ModestWindowMgr *self)
623 ModestWindowMgrPrivate *priv;
625 g_return_val_if_fail (MODEST_IS_WINDOW_MGR (self), FALSE);
626 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
628 return priv->main_window != NULL;
633 modest_window_mgr_get_modal (ModestWindowMgr *self)
635 return MODEST_WINDOW_MGR_GET_CLASS (self)->get_modal (self);
639 modest_window_mgr_get_modal_default (ModestWindowMgr *self)
646 modest_window_mgr_set_modal (ModestWindowMgr *self,
650 MODEST_WINDOW_MGR_GET_CLASS (self)->set_modal (self, window, parent);
654 modest_window_mgr_set_modal_default (ModestWindowMgr *self,
663 on_nonhibernating_window_hide(GtkWidget *widget, gpointer user_data)
665 ModestWindowMgr *self = MODEST_WINDOW_MGR (user_data);
666 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
668 /* Forget this window,
669 * so hibernation will be allowed again if no windows are remembered: */
670 priv->windows_that_prevent_hibernation =
671 g_slist_remove (priv->windows_that_prevent_hibernation, GTK_WINDOW(widget));
675 on_nonhibernating_window_show(GtkWidget *widget, gpointer user_data)
677 ModestWindowMgr *self = MODEST_WINDOW_MGR (user_data);
678 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
680 GtkWindow *window = GTK_WINDOW (widget);
682 priv->windows_that_prevent_hibernation =
683 g_slist_append (priv->windows_that_prevent_hibernation, window);
685 /* Allow hibernation again when the window has been hidden: */
686 g_signal_connect (window, "hide",
687 G_CALLBACK (on_nonhibernating_window_hide), self);
691 modest_window_mgr_prevent_hibernation_while_window_is_shown (ModestWindowMgr *self,
694 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
696 if (GTK_WIDGET_VISIBLE(window)) {
697 on_nonhibernating_window_show (GTK_WIDGET (window), self);
699 /* Wait for it to be shown: */
700 g_signal_connect (window, "show",
701 G_CALLBACK (on_nonhibernating_window_show), self);
706 modest_window_mgr_get_hibernation_is_prevented (ModestWindowMgr *self)
708 g_return_val_if_fail (MODEST_IS_WINDOW_MGR (self), FALSE);
710 ModestWindowMgrPrivate *priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
712 /* Prevent hibernation if any open windows are currently
713 * preventing hibernation: */
714 return (g_slist_length (priv->windows_that_prevent_hibernation) > 0);
719 modest_window_mgr_save_state_for_all_windows (ModestWindowMgr *self)
723 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
725 /* Iterate over all windows */
726 window_list = modest_window_mgr_get_window_list (self);
729 ModestWindow *window = MODEST_WINDOW (node->data);
731 /* This calls the vfunc,
732 * so each window can do its own thing: */
733 modest_window_save_state (window);
736 node = g_list_next (node);
738 g_list_free (window_list);
742 modest_window_mgr_num_windows (ModestWindowMgr *self)
744 ModestWindowMgrPrivate *priv;
745 gint num_windows = 0;
748 g_return_val_if_fail (self && MODEST_IS_WINDOW_MGR(self), -1);
750 priv = MODEST_WINDOW_MGR_GET_PRIVATE(self);
752 window_list = modest_window_mgr_get_window_list (self);
755 num_windows = g_list_length (window_list);
756 g_list_free (window_list);
759 /* Do not take into account the main window if it was hidden */
760 if (priv->main_window && !GTK_WIDGET_VISIBLE (priv->main_window))
763 return num_windows + priv->banner_counter;
767 modest_window_mgr_get_msg_edit_window (ModestWindowMgr *self)
770 ModestWindowMgrPrivate *priv;
772 g_return_val_if_fail (self && MODEST_IS_WINDOW_MGR(self), NULL);
774 priv = MODEST_WINDOW_MGR_GET_PRIVATE(self);
776 if (priv->cached_editor) {
777 result = priv->cached_editor;
778 priv->cached_editor = NULL;
779 load_new_editor (self);
781 result = g_object_new (MODEST_TYPE_MSG_EDIT_WINDOW, NULL);
788 modest_window_mgr_get_msg_view_window (ModestWindowMgr *self)
791 ModestWindowMgrPrivate *priv;
793 g_return_val_if_fail (self && MODEST_IS_WINDOW_MGR(self), NULL);
795 priv = MODEST_WINDOW_MGR_GET_PRIVATE(self);
797 if (priv->cached_view) {
798 result = priv->cached_view;
799 priv->cached_view = NULL;
800 load_new_view (self);
802 result = g_object_new (MODEST_TYPE_MSG_VIEW_WINDOW, NULL);
809 modest_window_mgr_register_banner (ModestWindowMgr *self)
811 ModestWindowMgrPrivate *priv;
813 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
814 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
816 priv->banner_counter++;
821 modest_window_mgr_unregister_banner (ModestWindowMgr *self)
823 ModestWindowMgrPrivate *priv;
825 g_return_if_fail (MODEST_IS_WINDOW_MGR (self));
826 priv = MODEST_WINDOW_MGR_GET_PRIVATE (self);
828 priv->banner_counter--;
829 if (modest_window_mgr_num_windows (self) == 0)
830 g_signal_emit (self, signals[WINDOW_LIST_EMPTY_SIGNAL], 0);