git.maemo.org Git - modest/blob - src/hildon2/modest-hildon2-window-mgr.c

   1 /* Copyright (c) 2008, Nokia Corporation
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   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.
  16  *
  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.
  28  */
  29
  30 #include <string.h>
  31 #include <hildon/hildon.h>
  32 #include "modest-hildon2-window.h"
  33 #include "modest-hildon2-window-mgr.h"
  34 #include "modest-msg-edit-window.h"
  35 #include "modest-mailboxes-window.h"
  36 #include "modest-header-window.h"
  37 #include "modest-main-window.h"
  38 #include "modest-conf.h"
  39 #include "modest-defs.h"
  40 #include "modest-signal-mgr.h"
  41 #include "modest-runtime.h"
  42 #include "modest-platform.h"
  43 #include "modest-ui-actions.h"
  44 #include "modest-debug.h"
  45 #include "modest-tny-folder.h"
  46 #include "modest-folder-window.h"
  47 #include "modest-accounts-window.h"
  48 #include "modest-maemo-utils.h"
  49 #include "modest-utils.h"
  50 #include "modest-tny-msg.h"
  51 #include <tny-merge-folder.h>
  52
  53 /* 'private'/'protected' functions */
  54 static void modest_hildon2_window_mgr_class_init (ModestHildon2WindowMgrClass *klass);
  55 static void modest_hildon2_window_mgr_instance_init (ModestHildon2WindowMgr *obj);
  56 static void modest_hildon2_window_mgr_finalize   (GObject *obj);
  57
  58 static gboolean on_window_destroy        (ModestWindow *window,
  59                                           GdkEvent *event,
  60                                           ModestHildon2WindowMgr *self);
  61
  62 static gboolean modest_hildon2_window_mgr_register_window (ModestWindowMgr *self,
  63                                                            ModestWindow *window,
  64                                                            ModestWindow *parent);
  65 static void modest_hildon2_window_mgr_unregister_window (ModestWindowMgr *self,
  66                                                          ModestWindow *window);
  67 static void modest_hildon2_window_mgr_set_fullscreen_mode (ModestWindowMgr *self,
  68                                                            gboolean on);
  69 static gboolean modest_hildon2_window_mgr_get_fullscreen_mode (ModestWindowMgr *self);
  70 static void modest_hildon2_window_mgr_show_toolbars (ModestWindowMgr *self,
  71                                                      GType window_type,
  72                                                      gboolean show_toolbars,
  73                                                      gboolean fullscreen);
  74 static ModestWindow* modest_hildon2_window_mgr_get_main_window (ModestWindowMgr *self, gboolean show);
  75 static GtkWindow *modest_hildon2_window_mgr_get_modal (ModestWindowMgr *self);
  76 static void modest_hildon2_window_mgr_set_modal (ModestWindowMgr *self,
  77                                                  GtkWindow *window,
  78                                                  GtkWindow *parent);
  79 static gboolean modest_hildon2_window_mgr_find_registered_header (ModestWindowMgr *self,
  80                                                                   TnyHeader *header,
  81                                                                   ModestWindow **win);
  82 static gboolean modest_hildon2_window_mgr_find_registered_message_uid (ModestWindowMgr *self,
  83                                                                        const gchar *msg_uid,
  84                                                                        ModestWindow **win);
  85 static GList *modest_hildon2_window_mgr_get_window_list (ModestWindowMgr *self);
  86 static gboolean modest_hildon2_window_mgr_close_all_windows (ModestWindowMgr *self);
  87 static gboolean window_can_close (ModestWindow *window);
  88 static gboolean window_has_modals (ModestWindow *window);
  89 static ModestWindow *modest_hildon2_window_mgr_show_initial_window (ModestWindowMgr *self);
  90 static ModestWindow *modest_hildon2_window_mgr_get_current_top (ModestWindowMgr *self);
  91 static gboolean modest_hildon2_window_mgr_screen_is_on (ModestWindowMgr *self);
  92 static void modest_hildon2_window_mgr_create_caches (ModestWindowMgr *self);
  93 static void osso_display_event_cb (osso_display_state_t state,
  94                                    gpointer data);
  95 static void on_account_removed (TnyAccountStore *acc_store,
  96                                 TnyAccount *account,
  97                                 gpointer user_data);
  98
  99 typedef struct _ModestHildon2WindowMgrPrivate ModestHildon2WindowMgrPrivate;
 100 struct _ModestHildon2WindowMgrPrivate {
 101         GList        *window_list;
 102         GMutex       *queue_lock;
 103         GQueue       *modal_windows;
 104
 105         gboolean     fullscreen_mode;
 106
 107         GHashTable   *destroy_handlers;
 108         GHashTable   *viewer_handlers;
 109         GSList       *window_state_uids;
 110
 111         guint        closing_time;
 112
 113         GSList       *modal_handler_uids;
 114         ModestWindow *current_top;
 115
 116         gulong        accounts_handler;
 117
 118         /* Display state */
 119         osso_display_state_t display_state;
 120 };
 121 #define MODEST_HILDON2_WINDOW_MGR_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
 122                                                                                    MODEST_TYPE_HILDON2_WINDOW_MGR, \
 123                                                                                    ModestHildon2WindowMgrPrivate))
 124 /* globals */
 125 static GObjectClass *parent_class = NULL;
 126
 127 GType
 128 modest_hildon2_window_mgr_get_type (void)
 129 {
 130         static GType my_type = 0;
 131         if (!my_type) {
 132                 static const GTypeInfo my_info = {
 133                         sizeof(ModestHildon2WindowMgrClass),
 134                         NULL,           /* base init */
 135                         NULL,           /* base finalize */
 136                         (GClassInitFunc) modest_hildon2_window_mgr_class_init,
 137                         NULL,           /* class finalize */
 138                         NULL,           /* class data */
 139                         sizeof(ModestHildon2WindowMgr),
 140                         1,              /* n_preallocs */
 141                         (GInstanceInitFunc) modest_hildon2_window_mgr_instance_init,
 142                         NULL
 143                 };
 144                 my_type = g_type_register_static (MODEST_TYPE_WINDOW_MGR,
 145                                                   "ModestHildon2WindowMgr",
 146                                                   &my_info, 0);
 147         }
 148         return my_type;
 149 }
 150
 151 static void
 152 modest_hildon2_window_mgr_class_init (ModestHildon2WindowMgrClass *klass)
 153 {
 154         GObjectClass *gobject_class;
 155         ModestWindowMgrClass *mgr_class;
 156
 157         gobject_class = (GObjectClass*) klass;
 158         mgr_class = (ModestWindowMgrClass *) klass;
 159
 160         parent_class            = g_type_class_peek_parent (klass);
 161         gobject_class->finalize = modest_hildon2_window_mgr_finalize;
 162         mgr_class->register_window = modest_hildon2_window_mgr_register_window;
 163         mgr_class->unregister_window = modest_hildon2_window_mgr_unregister_window;
 164         mgr_class->set_fullscreen_mode = modest_hildon2_window_mgr_set_fullscreen_mode;
 165         mgr_class->get_fullscreen_mode = modest_hildon2_window_mgr_get_fullscreen_mode;
 166         mgr_class->show_toolbars = modest_hildon2_window_mgr_show_toolbars;
 167         mgr_class->get_main_window = modest_hildon2_window_mgr_get_main_window;
 168         mgr_class->get_modal = modest_hildon2_window_mgr_get_modal;
 169         mgr_class->set_modal = modest_hildon2_window_mgr_set_modal;
 170         mgr_class->find_registered_header = modest_hildon2_window_mgr_find_registered_header;
 171         mgr_class->find_registered_message_uid = modest_hildon2_window_mgr_find_registered_message_uid;
 172         mgr_class->get_window_list = modest_hildon2_window_mgr_get_window_list;
 173         mgr_class->close_all_windows = modest_hildon2_window_mgr_close_all_windows;
 174         mgr_class->show_initial_window = modest_hildon2_window_mgr_show_initial_window;
 175         mgr_class->get_current_top = modest_hildon2_window_mgr_get_current_top;
 176         mgr_class->screen_is_on = modest_hildon2_window_mgr_screen_is_on;
 177         mgr_class->create_caches = modest_hildon2_window_mgr_create_caches;
 178
 179         g_type_class_add_private (gobject_class, sizeof(ModestHildon2WindowMgrPrivate));
 180
 181 }
 182
 183 static void
 184 modest_hildon2_window_mgr_instance_init (ModestHildon2WindowMgr *obj)
 185 {
 186         ModestHildon2WindowMgrPrivate *priv;
 187
 188         priv = MODEST_HILDON2_WINDOW_MGR_GET_PRIVATE(obj);
 189         priv->window_list = NULL;
 190         priv->fullscreen_mode = FALSE;
 191         priv->window_state_uids = NULL;
 192
 193         priv->modal_windows = g_queue_new ();
 194         priv->queue_lock = g_mutex_new ();
 195
 196         /* Could not initialize it from gconf, singletons are not
 197            ready yet */
 198         priv->destroy_handlers = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free);
 199         priv->viewer_handlers = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free);
 200
 201         priv->closing_time = 0;
 202
 203         priv->modal_handler_uids = NULL;
 204         priv->display_state = OSSO_DISPLAY_ON;
 205
 206         /* Listen for changes in the screen, we don't want to show a
 207            led pattern when the display is on for example */
 208         osso_hw_set_display_event_cb (modest_maemo_utils_get_osso_context (),
 209                                       osso_display_event_cb,
 210                                       obj);
 211
 212 }
 213
 214 static void
 215 modest_hildon2_window_mgr_finalize (GObject *obj)
 216 {
 217         ModestHildon2WindowMgrPrivate *priv = MODEST_HILDON2_WINDOW_MGR_GET_PRIVATE(obj);
 218         ModestTnyAccountStore *acc_store;
 219
 220         modest_signal_mgr_disconnect_all_and_destroy (priv->window_state_uids);
 221         priv->window_state_uids = NULL;
 222
 223         osso_hw_set_display_event_cb (modest_maemo_utils_get_osso_context (),
 224                                       NULL, NULL);
 225
 226         acc_store = modest_runtime_get_account_store ();
 227         if (acc_store && g_signal_handler_is_connected (acc_store, priv->accounts_handler))
 228                 g_signal_handler_disconnect (acc_store, priv->accounts_handler);
 229
 230         if (priv->window_list) {
 231                 GList *iter = priv->window_list;
 232                 /* unregister pending windows */
 233                 while (iter) {
 234                         ModestWindow *window = (ModestWindow *) iter->data;
 235                         iter = g_list_next (iter);
 236                         modest_window_mgr_unregister_window (MODEST_WINDOW_MGR (obj), window);
 237                 }
 238                 g_list_free (priv->window_list);
 239                 priv->window_list = NULL;
 240         }
 241
 242         /* Free the hash table with the handlers */
 243         if (priv->destroy_handlers) {
 244                 g_hash_table_destroy (priv->destroy_handlers);
 245                 priv->destroy_handlers = NULL;
 246         }
 247
 248         if (priv->viewer_handlers) {
 249                 g_hash_table_destroy (priv->viewer_handlers);
 250                 priv->viewer_handlers = NULL;
 251         }
 252
 253         modest_signal_mgr_disconnect_all_and_destroy (priv->modal_handler_uids);
 254         priv->modal_handler_uids = NULL;
 255
 256         if (priv->modal_windows) {
 257                 g_mutex_lock (priv->queue_lock);
 258                 g_queue_free (priv->modal_windows);
 259                 priv->modal_windows = NULL;
 260                 g_mutex_unlock (priv->queue_lock);
 261         }
 262         g_mutex_free (priv->queue_lock);
 263
 264         /* Do not unref priv->main_window because it does not hold a
 265            new reference */
 266
 267         G_OBJECT_CLASS(parent_class)->finalize (obj);
 268 }
 269
 270 ModestWindowMgr*
 271 modest_hildon2_window_mgr_new (void)
 272 {
 273         return MODEST_WINDOW_MGR(g_object_new(MODEST_TYPE_HILDON2_WINDOW_MGR, NULL));
 274 }
 275
 276 static gboolean
 277 modest_hildon2_window_mgr_close_all_windows (ModestWindowMgr *self)
 278 {
 279         ModestHildon2WindowMgrPrivate *priv = NULL;
 280         gboolean ret_value = FALSE;
 281         GtkWidget *window;
 282         HildonWindowStack *stack;
 283         gboolean failed = FALSE;
 284
 285         g_return_val_if_fail (MODEST_IS_HILDON2_WINDOW_MGR (self), FALSE);
 286         priv = MODEST_HILDON2_WINDOW_MGR_GET_PRIVATE (self);
 287
 288         stack = hildon_window_stack_get_default ();
 289
 290         while ((window = hildon_window_stack_peek (stack)) != NULL) {
 291                 g_signal_emit_by_name (G_OBJECT (window), "delete-event", NULL, &ret_value);
 292                 if (ret_value == TRUE) {
 293                         failed = TRUE;
 294                         break;
 295                 }
 296         }
 297
 298         return !failed;
 299 }
 300
 301 static gint
 302 compare_msguids (ModestWindow *win,
 303                  const gchar *uid)
 304 {
 305         const gchar *msg_uid;
 306
 307         if ((!MODEST_IS_MSG_EDIT_WINDOW (win)) && (!MODEST_IS_MSG_VIEW_WINDOW (win)))
 308                 return 1;
 309
 310         /* Get message uid from msg window */
 311         if (MODEST_IS_MSG_EDIT_WINDOW (win)) {
 312                 msg_uid = modest_msg_edit_window_get_message_uid (MODEST_MSG_EDIT_WINDOW (win));
 313                 if (msg_uid && uid &&!strcmp (msg_uid, uid))
 314                         return 0;
 315         } else {
 316                 msg_uid = modest_msg_view_window_get_message_uid (MODEST_MSG_VIEW_WINDOW (win));
 317         }
 318
 319         if (msg_uid && uid &&!strcmp (msg_uid, uid))
 320                 return 0;
 321         else
 322                 return 1;
 323 }
 324
 325 static gint
 326 compare_headers (ModestWindow *win,
 327                  TnyHeader *header)
 328 {
 329         TnyHeader *my_header;
 330         gint result = 1;
 331
 332         if (!MODEST_IS_MSG_VIEW_WINDOW (win))
 333                 return 1;
 334
 335         /* Get message uid from msg window */
 336         my_header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (win));
 337         if (my_header) {
 338                 if (my_header == header)
 339                         result = 0;
 340                 g_object_unref (my_header);
 341         }
 342         return result;
 343 }
 344
 345
 346 static gboolean
 347 modest_hildon2_window_mgr_find_registered_header (ModestWindowMgr *self, TnyHeader *header,
 348                                                   ModestWindow **win)
 349 {
 350         ModestHildon2WindowMgrPrivate *priv = NULL;
 351         gchar* uid = NULL;
 352         gboolean has_header, has_window = FALSE;
 353         GList *item = NULL;
 354
 355         g_return_val_if_fail (MODEST_IS_HILDON2_WINDOW_MGR (self), FALSE);
 356         g_return_val_if_fail (TNY_IS_HEADER(header), FALSE);
 357
 358         priv = MODEST_HILDON2_WINDOW_MGR_GET_PRIVATE (self);
 359
 360         has_header = MODEST_WINDOW_MGR_CLASS (parent_class)->find_registered_header (self, header, win);
 361
 362         uid = modest_tny_folder_get_header_unique_id (header);
 363
 364         item = g_list_find_custom (priv->window_list, uid, (GCompareFunc) compare_msguids);
 365         if (item) {
 366                 has_window = TRUE;
 367                 if (win) {
 368                         if ((!MODEST_IS_MSG_VIEW_WINDOW(item->data)) &&
 369                             (!MODEST_IS_MSG_EDIT_WINDOW (item->data)))
 370                                 g_debug ("not a valid window!");
 371                         else {
 372                                 g_debug ("found a window");
 373                                 *win = MODEST_WINDOW (item->data);
 374                         }
 375                 }
 376         }
 377         g_free (uid);
 378
 379         return has_header || has_window;
 380 }
 381
 382 static gboolean
 383 modest_hildon2_window_mgr_find_registered_message_uid (ModestWindowMgr *self, const gchar *msg_uid,
 384                                                        ModestWindow **win)
 385 {
 386         ModestHildon2WindowMgrPrivate *priv = NULL;
 387         gboolean has_header, has_window = FALSE;
 388         GList *item = NULL;
 389
 390         g_return_val_if_fail (MODEST_IS_HILDON2_WINDOW_MGR (self), FALSE);
 391         g_return_val_if_fail (msg_uid && msg_uid[0] != '\0', FALSE);
 392
 393         priv = MODEST_HILDON2_WINDOW_MGR_GET_PRIVATE (self);
 394
 395         has_header = MODEST_WINDOW_MGR_CLASS (parent_class)->find_registered_message_uid (self, msg_uid, win);
 396
 397         item = g_list_find_custom (priv->window_list, msg_uid, (GCompareFunc) compare_msguids);
 398         if (item) {
 399                 has_window = TRUE;
 400                 if (win) {
 401                         if ((!MODEST_IS_MSG_VIEW_WINDOW(item->data)) &&
 402                             (!MODEST_IS_MSG_EDIT_WINDOW (item->data)))
 403                                 g_debug ("not a valid window!");
 404                         else {
 405                                 g_debug ("found a window");
 406                                 *win = MODEST_WINDOW (item->data);
 407                         }
 408                 }
 409         }
 410
 411         return has_header || has_window;
 412 }
 413
 414 static GList *
 415 modest_hildon2_window_mgr_get_window_list (ModestWindowMgr *self)
 416 {
 417         ModestHildon2WindowMgrPrivate *priv;
 418
 419         g_return_val_if_fail (MODEST_IS_HILDON2_WINDOW_MGR (self), NULL);
 420         priv = MODEST_HILDON2_WINDOW_MGR_GET_PRIVATE (self);
 421
 422         return g_list_copy (priv->window_list);
 423 }
 424
 425 static gboolean
 426 modest_hildon2_window_mgr_register_window (ModestWindowMgr *self,
 427                                            ModestWindow *window,
 428                                            ModestWindow *parent)
 429 {
 430         GList *win;
 431         ModestHildon2WindowMgrPrivate *priv;
 432         gint *handler_id;
 433         HildonWindowStack *stack;
 434         gboolean nested_msg = FALSE;
 435         ModestWindow *current_top;
 436         GtkWidget *modal;
 437
 438         g_return_val_if_fail (MODEST_IS_HILDON2_WINDOW_MGR (self), FALSE);
 439         g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
 440
 441         priv = MODEST_HILDON2_WINDOW_MGR_GET_PRIVATE (self);
 442
 443         /* Check that there is no active modal dialog */
 444         modal = (GtkWidget *) modest_window_mgr_get_modal (self);
 445         while (modal && GTK_IS_DIALOG (modal)) {
 446                 GtkWidget *parent;
 447
 448                 /* Get the parent */
 449                 parent = (GtkWidget *) gtk_window_get_transient_for (GTK_WINDOW (modal));
 450
 451                 /* Try to close it */
 452                 gtk_dialog_response (GTK_DIALOG (modal), GTK_RESPONSE_DELETE_EVENT);
 453
 454                 /* Maybe the dialog was not closed, because a close
 455                    confirmation dialog for example. Then ignore the
 456                    register process */
 457                 if (GTK_IS_WINDOW (modal)) {
 458                         gtk_window_present (GTK_WINDOW (modal));
 459                         return FALSE;
 460                 }
 461
 462                 /* Get next modal */
 463                 modal = parent;
 464         }
 465
 466         stack = hildon_window_stack_get_default ();
 467         current_top = (ModestWindow *) hildon_window_stack_peek (stack);
 468
 469         win = g_list_find (priv->window_list, window);
 470         if (win) {
 471                 /* this is for the case we want to register the window
 472                    and it was already registered */
 473                 gtk_window_present (GTK_WINDOW (window));
 474                 return FALSE;
 475         }
 476
 477         /* Do not allow standalone editors or standalone viewers */
 478         if (!current_top &&
 479             (MODEST_IS_MSG_VIEW_WINDOW (window) ||
 480              MODEST_IS_MSG_EDIT_WINDOW (window)))
 481                 modest_window_mgr_show_initial_window (self);
 482
 483         if (MODEST_IS_MSG_VIEW_WINDOW (window)) {
 484                 gchar *uid;
 485                 TnyHeader *header;
 486
 487                 uid = g_strdup (modest_msg_view_window_get_message_uid (MODEST_MSG_VIEW_WINDOW (window)));
 488
 489                 header = modest_msg_view_window_get_header (MODEST_MSG_VIEW_WINDOW (window));
 490
 491                 if (uid == NULL)
 492                         uid = modest_tny_folder_get_header_unique_id (header);
 493                 /* Embedded messages do not have uid */
 494                 if (uid) {
 495                         if (g_list_find_custom (priv->window_list, uid, (GCompareFunc) compare_msguids)) {
 496                                 g_debug ("%s found another view window showing the same header", __FUNCTION__);
 497                                 g_free (uid);
 498                                 g_object_unref (header);
 499                                 return FALSE;
 500                         }
 501                         g_free (uid);
 502                 } else if (header) {
 503                         if (g_list_find_custom (priv->window_list, header, (GCompareFunc) compare_headers)) {
 504                                 g_debug ("%s found another view window showing the same header", __FUNCTION__);
 505                                 g_object_unref (header);
 506                                 return FALSE;
 507                         }
 508                 }
 509                 if (header)
 510                         g_object_unref (header);
 511         }
 512
 513         /* Do not go backwards */
 514         if ((MODEST_IS_MSG_VIEW_WINDOW (current_top) || MODEST_IS_MSG_EDIT_WINDOW (current_top)) &&
 515             (MODEST_IS_FOLDER_WINDOW (window) || MODEST_IS_ACCOUNTS_WINDOW (window) ||
 516              MODEST_IS_MAILBOXES_WINDOW (window))) {
 517                 gtk_window_present (GTK_WINDOW (window));
 518                 return FALSE;
 519         }
 520
 521         if (MODEST_IS_FOLDER_WINDOW (current_top) && MODEST_IS_FOLDER_WINDOW (window)) {
 522                 gtk_window_present (GTK_WINDOW (window));
 523                 return FALSE;
 524         }
 525
 526         if (MODEST_IS_MAILBOXES_WINDOW (current_top) && MODEST_IS_MAILBOXES_WINDOW (window)) {
 527                 gtk_window_present (GTK_WINDOW (window));
 528                 return FALSE;
 529         }
 530
 531         /* Mailboxes window can not replace folder windows */
 532         if (MODEST_IS_FOLDER_WINDOW (current_top) && MODEST_IS_MAILBOXES_WINDOW (window)) {
 533                 gtk_window_present (GTK_WINDOW (current_top));
 534                 return FALSE;
 535         }
 536
 537         /* Trying to open a folders window and a mailboxes window at
 538            the same time from the accounts window is not allowed */
 539         if (MODEST_IS_MAILBOXES_WINDOW (current_top) &&
 540             MODEST_IS_FOLDER_WINDOW (window) &&
 541             MODEST_IS_ACCOUNTS_WINDOW (parent)) {
 542                 gtk_window_present (GTK_WINDOW (window));
 543                 return FALSE;
 544         }
 545
 546         if (MODEST_IS_HEADER_WINDOW (current_top) && MODEST_IS_HEADER_WINDOW (window)) {
 547                 g_debug ("Trying to register a second header window is not allowed");
 548                 gtk_window_present (GTK_WINDOW (current_top));
 549                 return FALSE;
 550         }
 551
 552         if (!MODEST_WINDOW_MGR_CLASS (parent_class)->register_window (self, window, parent))
 553                 goto fail;
 554
 555         /* Add to list. Keep a reference to the window */
 556         g_object_ref (window);
 557         priv->window_list = g_list_prepend (priv->window_list, window);
 558
 559         nested_msg = MODEST_IS_MSG_VIEW_WINDOW (window) &&
 560                 MODEST_IS_MSG_VIEW_WINDOW (parent);
 561
 562         /* Close views if they're being shown. Nevertheless we must
 563            allow nested messages */
 564         if (!nested_msg &&
 565             (MODEST_IS_MSG_EDIT_WINDOW (current_top) ||
 566              MODEST_IS_MSG_VIEW_WINDOW (current_top))) {
 567                 gboolean retval;
 568
 569                 /* If the current view has modal dialogs then
 570                    we fail to register the new view */
 571                 if ((current_top != NULL) &&
 572                     window_has_modals (MODEST_WINDOW (current_top))) {
 573                         /* Window on top but it has opened dialogs */
 574                         goto fail;
 575                 }
 576
 577                 /* Close the current view */
 578                 g_signal_emit_by_name (G_OBJECT (current_top), "delete-event", NULL, &retval);
 579                 if (retval == TRUE) {
 580                         /* Cancelled closing top window, then we fail to register */
 581                         goto fail;
 582                 }
 583         }
 584
 585         /* Listen to object destruction */
 586         handler_id = g_malloc0 (sizeof (gint));
 587         *handler_id = g_signal_connect (window, "delete-event", G_CALLBACK (on_window_destroy), self);
 588         g_hash_table_insert (priv->destroy_handlers, window, handler_id);
 589
 590         /* Show toolbar always */
 591         modest_window_show_toolbar (window, TRUE);
 592
 593         return TRUE;
 594 fail:
 595         /* Add to list. Keep a reference to the window */
 596         priv->window_list = g_list_remove (priv->window_list, window);
 597         g_object_unref (window);
 598         current_top = (ModestWindow *) hildon_window_stack_peek (stack);
 599         if (current_top)
 600                 gtk_window_present (GTK_WINDOW (current_top));
 601         return FALSE;
 602 }
 603
 604 static void
 605 cancel_window_operations (ModestWindow *window)
 606 {
 607         GSList* pending_ops = NULL;
 608
 609         /* cancel open and receive operations */
 610         pending_ops = modest_mail_operation_queue_get_by_source (modest_runtime_get_mail_operation_queue (),
 611                                                                  G_OBJECT (window));
 612         while (pending_ops != NULL) {
 613                 ModestMailOperationTypeOperation type;
 614                 GSList* tmp_list = NULL;
 615
 616                 type = modest_mail_operation_get_type_operation (MODEST_MAIL_OPERATION (pending_ops->data));
 617                 if (type == MODEST_MAIL_OPERATION_TYPE_RECEIVE ||
 618                     type == MODEST_MAIL_OPERATION_TYPE_OPEN ||
 619                     type == MODEST_MAIL_OPERATION_TYPE_SEND_AND_RECEIVE) {
 620                         modest_mail_operation_cancel (pending_ops->data);
 621                 }
 622                 g_object_unref (G_OBJECT (pending_ops->data));
 623                 tmp_list = pending_ops;
 624                 pending_ops = g_slist_next (pending_ops);
 625                 g_slist_free_1 (tmp_list);
 626         }
 627 }
 628
 629 static gboolean
 630 window_has_modals (ModestWindow *window)
 631 {
 632         GList *toplevels;
 633         GList *node;
 634         gboolean retvalue = FALSE;
 635
 636         /* First we fetch all toplevels */
 637         toplevels = gtk_window_list_toplevels ();
 638         for (node = toplevels; node != NULL; node = g_list_next (node)) {
 639                 if (GTK_IS_WINDOW (node->data) &&
 640                     gtk_window_get_transient_for (GTK_WINDOW (node->data)) == GTK_WINDOW (window) &&
 641                     GTK_WIDGET_VISIBLE (node->data)) {
 642                         retvalue = TRUE;
 643                         break;
 644                 }
 645         }
 646         g_list_free (toplevels);
 647         return retvalue;
 648 }
 649
 650 static gboolean
 651 window_can_close (ModestWindow *window)
 652 {
 653         /* An editor can be always closed no matter the dialogs it has
 654          * on top. */
 655         if (MODEST_IS_MSG_EDIT_WINDOW (window))
 656                 return TRUE;
 657
 658         return !window_has_modals (window);
 659 }
 660
 661 static gboolean
 662 on_window_destroy (ModestWindow *window,
 663                    GdkEvent *event,
 664                    ModestHildon2WindowMgr *self)
 665 {
 666         gboolean no_propagate = FALSE;
 667
 668         if (!window_can_close (window))
 669                 return TRUE;
 670
 671         if (MODEST_IS_MSG_EDIT_WINDOW (window)) {
 672                 gboolean sent = FALSE;
 673                 sent = modest_msg_edit_window_get_sent (MODEST_MSG_EDIT_WINDOW (window));
 674                 /* Save currently edited message to Drafts if it was not sent */
 675                 if (!sent && modest_msg_edit_window_is_modified (MODEST_MSG_EDIT_WINDOW (window))) {
 676                         ModestMsgEditWindow *edit_window;
 677                         MsgData *data;
 678
 679                         edit_window = MODEST_MSG_EDIT_WINDOW (window);
 680                         data = modest_msg_edit_window_get_msg_data (edit_window);
 681
 682                         if (data) {
 683                                 gint parts_count;
 684                                 guint64 parts_size, available_size, expected_size;
 685
 686                                 available_size = modest_utils_get_available_space (NULL);
 687                                 modest_msg_edit_window_get_parts_size (edit_window, &parts_count, &parts_size);
 688                                 expected_size = modest_tny_msg_estimate_size (data->plain_body,
 689                                                                               data->html_body,
 690                                                                               parts_count,
 691                                                                               parts_size);
 692                                 modest_msg_edit_window_free_msg_data (edit_window, data);
 693                                 data = NULL;
 694
 695                                 /* If there is not enough space
 696                                    available for saving the message
 697                                    then show an error and close the
 698                                    window without saving */
 699                                 if (expected_size >= available_size) {
 700                                         modest_platform_run_information_dialog (GTK_WINDOW (edit_window),
 701                                                                                 _("mail_in_ui_save_error"),
 702                                                                                 FALSE);
 703                                 } else {
 704                                         if (!modest_ui_actions_on_save_to_drafts (NULL, MODEST_MSG_EDIT_WINDOW (window)))
 705                                                 return TRUE;
 706                                 }
 707                         } else {
 708                                 g_warning ("Edit window without message data. This is probably a bug");
 709                         }
 710                 }
 711         }
 712
 713         /* Unregister window */
 714         modest_window_mgr_unregister_window (MODEST_WINDOW_MGR (self), window);
 715         no_propagate = FALSE;
 716
 717         return no_propagate;
 718 }
 719
 720 static void
 721 modest_hildon2_window_mgr_unregister_window (ModestWindowMgr *self,
 722                                              ModestWindow *window)
 723 {
 724         GList *win;
 725         ModestHildon2WindowMgrPrivate *priv;
 726         gulong *tmp, handler_id;
 727         guint num_windows;
 728
 729         g_return_if_fail (MODEST_IS_HILDON2_WINDOW_MGR (self));
 730         g_return_if_fail (MODEST_IS_WINDOW (window));
 731
 732         priv = MODEST_HILDON2_WINDOW_MGR_GET_PRIVATE (self);
 733
 734         win = g_list_find (priv->window_list, window);
 735         if (!win) {
 736                 g_debug ("Trying to unregister a window that has not being registered yet");
 737                 return;
 738         }
 739
 740         /* Remove the viewer window handler from the hash table. The
 741            HashTable could not exist if the main window was closed
 742            when there were other windows remaining */
 743         if (MODEST_IS_MSG_VIEW_WINDOW (window) && priv->viewer_handlers) {
 744                 tmp = (gulong *) g_hash_table_lookup (priv->viewer_handlers, window);
 745                 /* If the viewer was created without a main window
 746                    (for example when opening a message through D-Bus
 747                    the viewer handlers was not registered */
 748                 if (tmp) {
 749                         g_signal_handler_disconnect (window, *tmp);
 750                         g_hash_table_remove (priv->viewer_handlers, window);
 751                 }
 752         }
 753
 754         /* Remove from list & hash table */
 755         priv->window_list = g_list_remove_link (priv->window_list, win);
 756         tmp = g_hash_table_lookup (priv->destroy_handlers, window);
 757         handler_id = *tmp;
 758
 759         g_hash_table_remove (priv->destroy_handlers, window);
 760
 761         /* cancel open and receive operations */
 762         cancel_window_operations (window);
 763
 764         /* Disconnect the "window-state-event" handler, we won't need it anymore */
 765         if (priv->window_state_uids) {
 766                 priv->window_state_uids =
 767                         modest_signal_mgr_disconnect (priv->window_state_uids,
 768                                                       G_OBJECT (window),
 769                                                       "notify::is-topmost");
 770         }
 771
 772         /* Disconnect the "delete-event" handler, we won't need it anymore */
 773         g_signal_handler_disconnect (window, handler_id);
 774
 775         /* Destroy the window */
 776         g_object_unref (win->data);
 777         g_list_free (win);
 778
 779         MODEST_WINDOW_MGR_CLASS (parent_class)->unregister_window (self, window);
 780
 781         /* We have to get the number of windows here in order not to
 782            emit the signal too many times */
 783         num_windows = modest_window_mgr_get_num_windows (self);
 784
 785         /* If there are no more windows registered emit the signal */
 786         if (num_windows == 0)
 787                 g_signal_emit_by_name (self, "window-list-empty");
 788 }
 789
 790
 791 static void
 792 modest_hildon2_window_mgr_set_fullscreen_mode (ModestWindowMgr *self,
 793                                                gboolean on)
 794 {
 795         g_return_if_fail (MODEST_IS_HILDON2_WINDOW_MGR (self));
 796
 797         return;
 798 }
 799
 800 static gboolean
 801 modest_hildon2_window_mgr_get_fullscreen_mode (ModestWindowMgr *self)
 802 {
 803         return FALSE;
 804 }
 805
 806 static void
 807 modest_hildon2_window_mgr_show_toolbars (ModestWindowMgr *self,
 808                                          GType window_type,
 809                                          gboolean show_toolbars,
 810                                          gboolean fullscreen)
 811 {
 812         g_return_if_fail (MODEST_IS_HILDON2_WINDOW_MGR (self));
 813
 814         return;
 815 }
 816
 817 static ModestWindow*
 818 modest_hildon2_window_mgr_get_main_window (ModestWindowMgr *self, gboolean show)
 819 {
 820         ModestHildon2WindowMgrPrivate *priv;
 821         ModestWindow *result;
 822
 823         g_return_val_if_fail (MODEST_IS_HILDON2_WINDOW_MGR (self), NULL);
 824         priv = MODEST_HILDON2_WINDOW_MGR_GET_PRIVATE (self);
 825
 826         /* TODO: make this return NULL always */
 827
 828         result = MODEST_WINDOW_MGR_CLASS (parent_class)->get_main_window (self, FALSE);
 829         /* create the main window, if it hasn't been created yet */
 830         if (!result && show) {
 831                 /* modest_window_mgr_register_window will set priv->main_window */
 832                 result = modest_main_window_new ();
 833                 /* We have to remove all other windows */
 834                 if (!modest_window_mgr_close_all_windows (self)) {
 835                         gtk_widget_destroy (GTK_WIDGET (result));
 836                         return NULL;
 837                 }
 838                 if (!modest_window_mgr_register_window (self, result, NULL)) {
 839                         gtk_widget_destroy (GTK_WIDGET (result));
 840                         return NULL;
 841                 }
 842                 MODEST_DEBUG_BLOCK(
 843                         g_debug ("%s: created main window: %p\n", __FUNCTION__, result);
 844                 );
 845         }
 846         if (show) {
 847                 gtk_widget_show_all (GTK_WIDGET (result));
 848                 gtk_window_present (GTK_WINDOW (result));
 849         }
 850
 851         return result;
 852 }
 853
 854 static gint
 855 look_for_transient (gconstpointer a,
 856                     gconstpointer b)
 857 {
 858         GtkWindow *win, *child;
 859
 860         if (a == b)
 861                 return 1;
 862
 863         child = (GtkWindow *) b;
 864         win = (GtkWindow *) a;
 865
 866         if (gtk_window_get_transient_for (win) == child)
 867                 return 0;
 868         else
 869                 return 1;
 870 }
 871
 872 static GtkWindow *
 873 modest_hildon2_window_mgr_get_modal (ModestWindowMgr *self)
 874 {
 875         ModestHildon2WindowMgrPrivate *priv;
 876         GList *toplevel_list;
 877         GtkWidget *current_top, *toplevel;
 878         HildonWindowStack *stack;
 879
 880         g_return_val_if_fail (MODEST_IS_HILDON2_WINDOW_MGR (self), NULL);
 881         priv = MODEST_HILDON2_WINDOW_MGR_GET_PRIVATE (self);
 882
 883         /* Get current top */
 884         stack = hildon_window_stack_get_default ();
 885         current_top = hildon_window_stack_peek (stack);
 886         toplevel = current_top;
 887         toplevel_list = gtk_window_list_toplevels ();
 888
 889         while (toplevel) {
 890                 GList *parent_link;
 891
 892                 parent_link = g_list_find_custom (toplevel_list, toplevel, look_for_transient);
 893                 if (parent_link)
 894                         toplevel = (GtkWidget *) parent_link->data;
 895                 else
 896                         break;
 897         }
 898
 899         if (toplevel && GTK_WIDGET_VISIBLE (toplevel) && gtk_window_get_modal ((GtkWindow *) toplevel))
 900                 return (GtkWindow *) toplevel;
 901         else
 902                 return NULL;
 903 }
 904
 905
 906 static void
 907 modest_hildon2_window_mgr_set_modal (ModestWindowMgr *self,
 908                                      GtkWindow *window,
 909                                      GtkWindow *parent)
 910 {
 911         g_return_if_fail (MODEST_IS_HILDON2_WINDOW_MGR (self));
 912         g_return_if_fail (GTK_IS_WINDOW (window));
 913
 914         gtk_window_set_modal (window, TRUE);
 915         gtk_window_set_transient_for (window, parent);
 916         gtk_window_set_destroy_with_parent (window, TRUE);
 917 }
 918
 919 static void
 920 close_all_but_first (HildonWindowStack *stack)
 921 {
 922         gint num_windows, i;
 923         gboolean retval;
 924
 925         num_windows = hildon_window_stack_size (stack);
 926
 927         for (i = 0; i < (num_windows - 1); i++) {
 928                 GtkWidget *current_top;
 929
 930                 /* Close window */
 931                 current_top = hildon_window_stack_peek (stack);
 932                 g_signal_emit_by_name (G_OBJECT (current_top), "delete-event", NULL, &retval);
 933         }
 934 }
 935
 936 static void
 937 on_account_removed (TnyAccountStore *acc_store,
 938                     TnyAccount *account,
 939                     gpointer user_data)
 940 {
 941         HildonWindowStack *stack;
 942         ModestWindow *current_top;
 943
 944         /* Ignore transport account removals */
 945         if (TNY_IS_TRANSPORT_ACCOUNT (account))
 946                 return;
 947
 948         stack = hildon_window_stack_get_default ();
 949         current_top = (ModestWindow *) hildon_window_stack_peek (stack);
 950
 951         /* if we're showing the header view of the currently deleted
 952            account, or the outbox and we deleted the last account,
 953            then close the window */
 954         if (current_top && MODEST_IS_HEADER_WINDOW (current_top)) {
 955                 ModestHeaderView *header_view;
 956                 TnyFolder *folder;
 957
 958                 header_view = modest_header_window_get_header_view (MODEST_HEADER_WINDOW (current_top));
 959                 folder = modest_header_view_get_folder (header_view);
 960                 if (folder) {
 961                         /* Close if it's my account */
 962                         if (!TNY_IS_MERGE_FOLDER (folder)) {
 963                                 TnyAccount *my_account;
 964
 965                                 my_account = tny_folder_get_account (folder);
 966                                 if (my_account) {
 967                                         if (my_account == account)
 968                                                 close_all_but_first (stack);
 969
 970                                         g_object_unref (my_account);
 971                                 }
 972                         }
 973
 974                         /* Close if viewing outbox and no account left */
 975                         if (tny_folder_get_folder_type (folder) == TNY_FOLDER_TYPE_OUTBOX)
 976                                 close_all_but_first (stack);
 977
 978                         g_object_unref (folder);
 979                 }
 980         }
 981 }
 982
 983 static ModestWindow *
 984 modest_hildon2_window_mgr_show_initial_window (ModestWindowMgr *self)
 985 {
 986         ModestWindow *initial_window = NULL;
 987         ModestHildon2WindowMgrPrivate *priv;
 988
 989         priv = MODEST_HILDON2_WINDOW_MGR_GET_PRIVATE (self);
 990
 991         /* Connect to the account store "account-removed" signal". We
 992            do this here because in the init the singletons are still
 993            not initialized properly */
 994         if (!g_signal_handler_is_connected (modest_runtime_get_account_store (),
 995                                             priv->accounts_handler)) {
 996                 priv->accounts_handler = g_signal_connect (modest_runtime_get_account_store (),
 997                                                            "account-removed",
 998                                                            G_CALLBACK (on_account_removed),
 999                                                            self);
1000         }
1001
1002         /* Return accounts window */
1003         initial_window = MODEST_WINDOW (modest_accounts_window_new ());
1004         modest_window_mgr_register_window (self, initial_window, NULL);
1005
1006         return initial_window;
1007 }
1008
1009
1010 static ModestWindow *
1011 modest_hildon2_window_mgr_get_current_top (ModestWindowMgr *self)
1012 {
1013         HildonWindowStack *stack;
1014         stack = hildon_window_stack_get_default ();
1015         return (ModestWindow *) hildon_window_stack_peek (stack);
1016 }
1017
1018 static gint
1019 find_folder_window (gconstpointer a,
1020                     gconstpointer b)
1021 {
1022         return (MODEST_IS_FOLDER_WINDOW (a)) ? 0 : 1;
1023 }
1024
1025 ModestWindow *
1026 modest_hildon2_window_mgr_get_folder_window (ModestHildon2WindowMgr *self)
1027 {
1028         ModestHildon2WindowMgrPrivate *priv;
1029         GList *window;
1030
1031         g_return_val_if_fail (MODEST_IS_HILDON2_WINDOW_MGR (self), NULL);
1032
1033         priv = MODEST_HILDON2_WINDOW_MGR_GET_PRIVATE (self);
1034
1035         window = g_list_find_custom (priv->window_list,
1036                                      NULL,
1037                                      find_folder_window);
1038
1039         return (window != NULL) ? MODEST_WINDOW (window->data) : NULL;
1040 }
1041
1042 static gboolean
1043 modest_hildon2_window_mgr_screen_is_on (ModestWindowMgr *self)
1044 {
1045         ModestHildon2WindowMgrPrivate *priv = NULL;
1046
1047         g_return_val_if_fail (MODEST_IS_HILDON2_WINDOW_MGR (self), FALSE);
1048
1049         priv = MODEST_HILDON2_WINDOW_MGR_GET_PRIVATE (self);
1050
1051         return (priv->display_state == OSSO_DISPLAY_ON) ? TRUE : FALSE;
1052 }
1053
1054 static void
1055 modest_hildon2_window_mgr_create_caches (ModestWindowMgr *self)
1056 {
1057         g_return_if_fail (MODEST_IS_HILDON2_WINDOW_MGR (self));
1058
1059         modest_accounts_window_pre_create ();
1060
1061         MODEST_WINDOW_MGR_CLASS(parent_class)->create_caches (self);
1062
1063 }
1064
1065 static void
1066 osso_display_event_cb (osso_display_state_t state,
1067                        gpointer data)
1068 {
1069         ModestHildon2WindowMgrPrivate *priv = MODEST_HILDON2_WINDOW_MGR_GET_PRIVATE (data);
1070
1071         priv->display_state = state;
1072
1073         /* Stop blinking if the screen becomes on */
1074         if (priv->display_state == OSSO_DISPLAY_ON)
1075                 modest_platform_remove_new_mail_notifications (TRUE);
1076 }
1077