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

   1 /* Copyright (c) 2006, 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 <glib/gi18n.h>
  31 #include <gtk/gtktreeviewcolumn.h>
  32 #include <tny-account-store-view.h>
  33 #include <tny-simple-list.h>
  34 #include "modest-hildon-includes.h"
  35 #include "modest-defs.h"
  36 #include <string.h>
  37
  38 #include "widgets/modest-main-window.h"
  39 #include "widgets/modest-msg-edit-window.h"
  40 #include "widgets/modest-account-view-window.h"
  41 #include "modest-runtime.h"
  42 #include "modest-account-mgr-helpers.h"
  43 #include "modest-platform.h"
  44 #include "modest-widget-memory.h"
  45 #include "modest-window-priv.h"
  46 #include "modest-main-window-ui.h"
  47 #include "modest-account-mgr.h"
  48 #include "modest-tny-account.h"
  49 #include "modest-conf.h"
  50 #include <modest-maemo-utils.h>
  51 #include "modest-tny-platform-factory.h"
  52 #include "modest-tny-msg.h"
  53 #include "modest-mail-operation.h"
  54 #include "modest-icon-names.h"
  55 #include "modest-progress-bar-widget.h"
  56
  57 /* 'private'/'protected' functions */
  58 static void modest_main_window_class_init    (ModestMainWindowClass *klass);
  59 static void modest_main_window_init          (ModestMainWindow *obj);
  60 static void modest_main_window_finalize      (GObject *obj);
  61 static gboolean modest_main_window_window_state_event (GtkWidget *widget,
  62                                                            GdkEventWindowState *event,
  63                                                            gpointer userdata);
  64
  65 static void connect_signals (ModestMainWindow *self);
  66 static void restore_sizes (ModestMainWindow *self);
  67 static void save_sizes (ModestMainWindow *self);
  68
  69 static void modest_main_window_show_toolbar   (ModestWindow *window,
  70                                                gboolean show_toolbar);
  71
  72 static void cancel_progressbar (GtkToolButton *toolbutton,
  73                                 ModestMainWindow *self);
  74
  75 static void         on_queue_changed                     (ModestMailOperationQueue *queue,
  76                                                           ModestMailOperation *mail_op,
  77                                                           ModestMailOperationQueueNotification type,
  78                                                           ModestMainWindow *self);
  79
  80 static void on_account_update                 (TnyAccountStore *account_store,
  81                                                gchar *account_name,
  82                                                gpointer user_data);
  83
  84 static gboolean on_inner_widgets_key_pressed  (GtkWidget *widget,
  85                                                GdkEventKey *event,
  86                                                gpointer user_data);
  87
  88 static void on_configuration_key_changed      (ModestConf* conf,
  89                                                const gchar *key,
  90                                                ModestConfEvent event,
  91                                                ModestMainWindow *self);
  92
  93 static void
  94 set_toolbar_mode (ModestMainWindow *self,
  95                   ModestToolBarModes mode);
  96
  97 /* list my signals */
  98 enum {
  99         /* MY_SIGNAL_1, */
 100         /* MY_SIGNAL_2, */
 101         LAST_SIGNAL
 102 };
 103
 104
 105 typedef struct _ModestMainWindowPrivate ModestMainWindowPrivate;
 106 struct _ModestMainWindowPrivate {
 107         GtkWidget *msg_paned;
 108         GtkWidget *main_paned;
 109         GtkWidget *main_vbox;
 110         GtkWidget *contents_widget;
 111
 112         /* Progress observers */
 113         GtkWidget        *progress_bar;
 114         GSList           *progress_widgets;
 115
 116         /* Tollbar items */
 117         GtkWidget   *progress_toolitem;
 118         GtkWidget   *cancel_toolitem;
 119         GtkWidget   *sort_toolitem;
 120         GtkWidget   *refresh_toolitem;
 121         ModestToolBarModes current_toolbar_mode;
 122
 123         /* On-demand widgets */
 124         GtkWidget *accounts_popup;
 125         GtkWidget *details_widget;
 126
 127
 128         ModestHeaderView *header_view;
 129         ModestFolderView *folder_view;
 130
 131         ModestMainWindowStyle style;
 132         ModestMainWindowContentsStyle contents_style;
 133 };
 134 #define MODEST_MAIN_WINDOW_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
 135                                                 MODEST_TYPE_MAIN_WINDOW, \
 136                                                 ModestMainWindowPrivate))
 137
 138 typedef struct _GetMsgAsyncHelper {
 139         ModestMainWindowPrivate *main_window_private;
 140         guint action;
 141         ModestTnyMsgReplyType reply_type;
 142         ModestTnyMsgForwardType forward_type;
 143         gchar *from;
 144         TnyIterator *iter;
 145 } GetMsgAsyncHelper;
 146
 147
 148 /* globals */
 149 static GtkWindowClass *parent_class = NULL;
 150
 151
 152 /* Private actions */
 153 static const GtkActionEntry modest_folder_view_action_entries [] = {
 154
 155         /* Folder View CSM actions */
 156         { "FolderViewCSMNewFolder", NULL, N_("FIXME: New Folder"), NULL, NULL, G_CALLBACK (modest_ui_actions_on_new_folder) },
 157         { "FolderViewCSMRenameFolder", NULL, N_("mcen_me_user_renamefolder"), NULL, NULL, G_CALLBACK (modest_ui_actions_on_rename_folder) },
 158         { "FolderViewCSMPasteMsgs", NULL, N_("FIXME: Paste"), NULL, NULL, NULL },
 159         { "FolderViewCSMDeleteFolder", NULL, N_("FIXME: Delete"), NULL, NULL, G_CALLBACK (modest_ui_actions_on_delete_folder) },
 160         { "FolderViewCSMSearchMessages", NULL, N_("mcen_me_inbox_search"), NULL, NULL, NULL },
 161         { "FolderViewCSMHelp", NULL, N_("mcen_me_inbox_help"), NULL, NULL, NULL },
 162 };
 163
 164
 165 static const GtkToggleActionEntry modest_main_window_toggle_action_entries [] = {
 166         { "ToolbarToggleView", MODEST_STOCK_SPLIT_VIEW, N_("gqn_toolb_rss_fldonoff"), "<CTRL>t", NULL, G_CALLBACK (modest_ui_actions_toggle_folders_view), FALSE },
 167 };
 168
 169
 170 /************************************************************************/
 171
 172 GType
 173 modest_main_window_get_type (void)
 174 {
 175         static GType my_type = 0;
 176         if (!my_type) {
 177                 static const GTypeInfo my_info = {
 178                         sizeof(ModestMainWindowClass),
 179                         NULL,           /* base init */
 180                         NULL,           /* base finalize */
 181                         (GClassInitFunc) modest_main_window_class_init,
 182                         NULL,           /* class finalize */
 183                         NULL,           /* class data */
 184                         sizeof(ModestMainWindow),
 185                         1,              /* n_preallocs */
 186                         (GInstanceInitFunc) modest_main_window_init,
 187                         NULL
 188                 };
 189                 my_type = g_type_register_static (MODEST_TYPE_WINDOW,
 190                                                   "ModestMainWindow",
 191                                                   &my_info, 0);
 192         }
 193         return my_type;
 194 }
 195
 196 static void
 197 modest_main_window_class_init (ModestMainWindowClass *klass)
 198 {
 199         GObjectClass *gobject_class;
 200         gobject_class = (GObjectClass*) klass;
 201         ModestWindowClass *modest_window_class;
 202
 203         modest_window_class = (ModestWindowClass *) klass;
 204
 205         parent_class            = g_type_class_peek_parent (klass);
 206         gobject_class->finalize = modest_main_window_finalize;
 207
 208         modest_window_class->show_toolbar_func = modest_main_window_show_toolbar;
 209
 210         g_type_class_add_private (gobject_class, sizeof(ModestMainWindowPrivate));
 211 }
 212
 213 static void
 214 modest_main_window_init (ModestMainWindow *obj)
 215 {
 216         ModestMainWindowPrivate *priv;
 217
 218         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(obj);
 219
 220         priv->msg_paned    = NULL;
 221         priv->main_paned   = NULL;
 222         priv->main_vbox    = NULL;
 223         priv->header_view  = NULL;
 224         priv->folder_view  = NULL;
 225         priv->contents_widget  = NULL;
 226         priv->accounts_popup  = NULL;
 227         priv->details_widget  = NULL;
 228
 229         priv->progress_widgets  = NULL;
 230         priv->progress_bar = NULL;
 231         priv->current_toolbar_mode = TOOLBAR_MODE_NORMAL;
 232
 233         priv->style  = MODEST_MAIN_WINDOW_STYLE_SPLIT;
 234         priv->contents_style  = MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS;
 235 }
 236
 237 static void
 238 modest_main_window_finalize (GObject *obj)
 239 {
 240         ModestMainWindowPrivate *priv;
 241
 242         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(obj);
 243
 244         g_slist_free (priv->progress_widgets);
 245
 246         G_OBJECT_CLASS(parent_class)->finalize (obj);
 247 }
 248
 249 GtkWidget*
 250 modest_main_window_get_child_widget (ModestMainWindow *self,
 251                                      ModestWidgetType widget_type)
 252 {
 253         ModestMainWindowPrivate *priv;
 254         GtkWidget *widget;
 255
 256         g_return_val_if_fail (self, NULL);
 257         g_return_val_if_fail (widget_type >= 0 && widget_type < MODEST_WIDGET_TYPE_NUM,
 258                               NULL);
 259
 260         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 261
 262         switch (widget_type) {
 263         case MODEST_WIDGET_TYPE_HEADER_VIEW:
 264                 widget = (GtkWidget*)priv->header_view; break;
 265         case MODEST_WIDGET_TYPE_FOLDER_VIEW:
 266                 widget = (GtkWidget*)priv->folder_view; break;
 267         default:
 268                 return NULL;
 269         }
 270
 271         return widget ? GTK_WIDGET(widget) : NULL;
 272 }
 273
 274
 275
 276 static void
 277 restore_sizes (ModestMainWindow *self)
 278 {
 279         ModestConf *conf;
 280         ModestMainWindowPrivate *priv;
 281
 282         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 283
 284         conf = modest_runtime_get_conf ();
 285
 286         modest_widget_memory_restore (conf, G_OBJECT(priv->main_paned),
 287                                       MODEST_CONF_MAIN_PANED_KEY);
 288         modest_widget_memory_restore (conf, G_OBJECT(priv->header_view),
 289                                       MODEST_CONF_HEADER_VIEW_KEY);
 290         modest_widget_memory_restore (conf, G_OBJECT(self),
 291                                       MODEST_CONF_MAIN_WINDOW_KEY);
 292 }
 293
 294
 295 static void
 296 save_sizes (ModestMainWindow *self)
 297 {
 298         ModestConf *conf;
 299         ModestMainWindowPrivate *priv;
 300
 301         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 302         conf = modest_runtime_get_conf ();
 303
 304         modest_widget_memory_save (conf,G_OBJECT(self),
 305                                    MODEST_CONF_MAIN_WINDOW_KEY);
 306         modest_widget_memory_save (conf, G_OBJECT(priv->main_paned),
 307                                    MODEST_CONF_MAIN_PANED_KEY);
 308         modest_widget_memory_save (conf, G_OBJECT(priv->header_view),
 309                                    MODEST_CONF_HEADER_VIEW_KEY);
 310 }
 311
 312 static void
 313 wrap_in_scrolled_window (GtkWidget *win, GtkWidget *widget)
 314 {
 315         if (!gtk_widget_set_scroll_adjustments (widget, NULL, NULL))
 316                 gtk_scrolled_window_add_with_viewport
 317                         (GTK_SCROLLED_WINDOW(win), widget);
 318         else
 319                 gtk_container_add (GTK_CONTAINER(win),
 320                                    widget);
 321 }
 322
 323
 324 static gboolean
 325 on_delete_event (GtkWidget *widget, GdkEvent  *event, ModestMainWindow *self)
 326 {
 327         save_sizes (self);
 328         return FALSE;
 329 }
 330
 331
 332 static void
 333 on_connection_changed (TnyDevice *device, gboolean online, ModestMainWindow *self)
 334 {
 335         /* When going online, do the equivalent of pressing the send/receive button,
 336          * as per the specification:
 337          * (without the check for >0 accounts, though that is not specified): */
 338         if (online) {
 339                 do_send_receive (MODEST_WINDOW (self));
 340         }
 341 }
 342
 343
 344
 345 static void
 346 connect_signals (ModestMainWindow *self)
 347 {
 348         ModestWindowPrivate *parent_priv;
 349         ModestMainWindowPrivate *priv;
 350         GtkWidget *menu;
 351
 352         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 353         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 354
 355         /* folder view */
 356         g_signal_connect (G_OBJECT(priv->folder_view), "key-press-event",
 357                           G_CALLBACK(on_inner_widgets_key_pressed), self);
 358         g_signal_connect (G_OBJECT(priv->folder_view), "folder_selection_changed",
 359                           G_CALLBACK(modest_ui_actions_on_folder_selection_changed), self);
 360         g_signal_connect (G_OBJECT(priv->folder_view), "folder-display-name-changed",
 361                           G_CALLBACK(modest_ui_actions_on_folder_display_name_changed), self);
 362
 363         menu = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/FolderViewCSM");
 364         gtk_widget_tap_and_hold_setup (GTK_WIDGET (priv->folder_view), menu, NULL, 0);
 365
 366         /* header view */
 367 /*      g_signal_connect (G_OBJECT(priv->header_view), "status_update", */
 368 /*                        G_CALLBACK(modest_ui_actions_on_header_status_update), self); */
 369         g_signal_connect (G_OBJECT(priv->header_view), "header_selected",
 370                           G_CALLBACK(modest_ui_actions_on_header_selected), self);
 371         g_signal_connect (G_OBJECT(priv->header_view), "header_activated",
 372                           G_CALLBACK(modest_ui_actions_on_header_activated), self);
 373         g_signal_connect (G_OBJECT(priv->header_view), "item_not_found",
 374                           G_CALLBACK(modest_ui_actions_on_item_not_found), self);
 375         g_signal_connect (G_OBJECT(priv->header_view), "key-press-event",
 376                           G_CALLBACK(on_inner_widgets_key_pressed), self);
 377
 378         /* window */
 379         g_signal_connect (G_OBJECT(self), "delete-event", G_CALLBACK(on_delete_event), self);
 380         g_signal_connect (G_OBJECT (self), "window-state-event",
 381                           G_CALLBACK (modest_main_window_window_state_event),
 382                           NULL);
 383         g_signal_connect (G_OBJECT(self), "delete-event", G_CALLBACK(on_delete_event), self);
 384
 385         /* Mail Operation Queue */
 386         g_signal_connect (G_OBJECT (modest_runtime_get_mail_operation_queue ()),
 387                           "queue-changed",
 388                           G_CALLBACK (on_queue_changed),
 389                           self);
 390
 391         /* Track changes in the device name */
 392         g_signal_connect (G_OBJECT(modest_runtime_get_conf ()),
 393                           "key_changed",
 394                           G_CALLBACK (on_configuration_key_changed),
 395                           self);
 396
 397         /* Track account changes. We need to refresh the toolbar */
 398         g_signal_connect (G_OBJECT (modest_runtime_get_account_store ()),
 399                           "account_update",
 400                           G_CALLBACK (on_account_update),
 401                           self);
 402
 403         /* Device */
 404         g_signal_connect (G_OBJECT(modest_runtime_get_device()), "connection_changed",
 405                           G_CALLBACK(on_connection_changed), self);
 406 }
 407
 408 /** Idle handler, to send/receive at startup .*/
 409 gboolean
 410 sync_accounts_cb (ModestMainWindow *win)
 411 {
 412         do_send_receive (MODEST_WINDOW(win));
 413         return FALSE; /* Do not call this idle handler again. */
 414 }
 415
 416
 417 ModestWindow*
 418 modest_main_window_new (void)
 419 {
 420         ModestMainWindow *self;
 421         ModestMainWindowPrivate *priv;
 422         ModestWindowPrivate *parent_priv;
 423         GtkWidget *folder_win;
 424         GtkActionGroup *action_group;
 425         GError *error = NULL;
 426         TnyFolderStoreQuery *query;
 427         GdkPixbuf *window_icon;
 428         ModestConf *conf;
 429         GtkAction *action;
 430
 431         self  = MODEST_MAIN_WINDOW(g_object_new(MODEST_TYPE_MAIN_WINDOW, NULL));
 432         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 433         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 434
 435         parent_priv->ui_manager = gtk_ui_manager_new();
 436         action_group = gtk_action_group_new ("ModestMainWindowActions");
 437         gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
 438
 439         /* Add common actions */
 440         gtk_action_group_add_actions (action_group,
 441                                       modest_action_entries,
 442                                       G_N_ELEMENTS (modest_action_entries),
 443                                       self);
 444
 445         gtk_action_group_add_actions (action_group,
 446                                       modest_folder_view_action_entries,
 447                                       G_N_ELEMENTS (modest_folder_view_action_entries),
 448                                       self);
 449
 450         gtk_action_group_add_toggle_actions (action_group,
 451                                              modest_toggle_action_entries,
 452                                              G_N_ELEMENTS (modest_toggle_action_entries),
 453                                              self);
 454
 455         gtk_action_group_add_toggle_actions (action_group,
 456                                              modest_main_window_toggle_action_entries,
 457                                              G_N_ELEMENTS (modest_main_window_toggle_action_entries),
 458                                              self);
 459
 460         gtk_ui_manager_insert_action_group (parent_priv->ui_manager, action_group, 0);
 461         g_object_unref (action_group);
 462
 463         /* Load the UI definition */
 464         gtk_ui_manager_add_ui_from_file (parent_priv->ui_manager,
 465                                          MODEST_UIDIR "modest-main-window-ui.xml", &error);
 466         if (error != NULL) {
 467                 g_warning ("Could not merge modest-ui.xml: %s", error->message);
 468                 g_error_free (error);
 469                 error = NULL;
 470         }
 471
 472         /* Add accelerators */
 473         gtk_window_add_accel_group (GTK_WINDOW (self),
 474                                     gtk_ui_manager_get_accel_group (parent_priv->ui_manager));
 475
 476         /* Menubar. Update the state of some toggles */
 477         parent_priv->menubar = modest_maemo_utils_menubar_to_menu (parent_priv->ui_manager);
 478         conf = modest_runtime_get_conf ();
 479         action = gtk_ui_manager_get_action (parent_priv->ui_manager,
 480                                             "/MenuBar/ViewMenu/ViewShowToolbarMainMenu/ViewShowToolbarNormalScreenMenu");
 481         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
 482                                       modest_conf_get_bool (conf, MODEST_CONF_SHOW_TOOLBAR, NULL));
 483         action = gtk_ui_manager_get_action (parent_priv->ui_manager,
 484                                             "/MenuBar/ViewMenu/ViewShowToolbarMainMenu/ViewShowToolbarFullScreenMenu");
 485         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
 486                                       modest_conf_get_bool (conf, MODEST_CONF_SHOW_TOOLBAR_FULLSCREEN, NULL));
 487         hildon_window_set_menu (HILDON_WINDOW (self), GTK_MENU (parent_priv->menubar));
 488
 489         /* folder view */
 490         query = tny_folder_store_query_new ();
 491         tny_folder_store_query_add_item (query, NULL,
 492                                          TNY_FOLDER_STORE_QUERY_OPTION_SUBSCRIBED);
 493         priv->folder_view = MODEST_FOLDER_VIEW(modest_folder_view_new (query));
 494         if (!priv->folder_view)
 495                 g_printerr ("modest: cannot instantiate folder view\n");
 496         g_object_unref (G_OBJECT (query));
 497         modest_folder_view_set_style (priv->folder_view,
 498                                       MODEST_FOLDER_VIEW_STYLE_SHOW_ONE);
 499
 500         /* Get device name */
 501         modest_maemo_utils_get_device_name ();
 502
 503         /* header view */
 504         priv->header_view  =
 505                 MODEST_HEADER_VIEW(modest_header_view_new (NULL, MODEST_HEADER_VIEW_STYLE_DETAILS));
 506         if (!priv->header_view)
 507                 g_printerr ("modest: cannot instantiate header view\n");
 508         modest_header_view_set_style (priv->header_view, MODEST_HEADER_VIEW_STYLE_TWOLINES);
 509
 510         /* Create scrolled windows */
 511         folder_win = gtk_scrolled_window_new (NULL, NULL);
 512         priv->contents_widget = gtk_scrolled_window_new (NULL, NULL);
 513         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (folder_win),
 514                                         GTK_POLICY_NEVER,
 515                                         GTK_POLICY_AUTOMATIC);
 516         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->contents_widget),
 517                                         GTK_POLICY_NEVER,
 518                                         GTK_POLICY_AUTOMATIC);
 519
 520         wrap_in_scrolled_window (folder_win, GTK_WIDGET(priv->folder_view));
 521         wrap_in_scrolled_window (priv->contents_widget, GTK_WIDGET(priv->header_view));
 522
 523         /* paned */
 524         priv->main_paned = gtk_hpaned_new ();
 525         gtk_paned_add1 (GTK_PANED(priv->main_paned), folder_win);
 526         gtk_paned_add2 (GTK_PANED(priv->main_paned), priv->contents_widget);
 527         gtk_widget_show (GTK_WIDGET(priv->header_view));
 528         gtk_tree_view_columns_autosize (GTK_TREE_VIEW(priv->header_view));
 529
 530         /* putting it all together... */
 531         priv->main_vbox = gtk_vbox_new (FALSE, 6);
 532         gtk_box_pack_start (GTK_BOX(priv->main_vbox), priv->main_paned, TRUE, TRUE,0);
 533
 534         gtk_container_add (GTK_CONTAINER(self), priv->main_vbox);
 535         restore_sizes (MODEST_MAIN_WINDOW(self));
 536
 537         /* Set window icon */
 538         window_icon = modest_platform_get_icon (MODEST_APP_ICON);
 539         gtk_window_set_icon (GTK_WINDOW (self), window_icon);
 540
 541         /* Connect signals */
 542         connect_signals (self);
 543
 544         /* Set account store */
 545         tny_account_store_view_set_account_store (TNY_ACCOUNT_STORE_VIEW (priv->folder_view),
 546                                                   TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
 547
 548         /* do send & receive when we are idle */
 549         g_idle_add ((GSourceFunc)sync_accounts_cb, self);
 550
 551         return MODEST_WINDOW(self);
 552 }
 553
 554 gboolean
 555 modest_main_window_close_all (ModestMainWindow *self)
 556 {
 557         GtkWidget *note;
 558         GtkResponseType response;
 559
 560         /* Create the confirmation dialog MSG-NOT308 */
 561         note = hildon_note_new_confirmation_add_buttons (GTK_WINDOW (self),
 562                                                          _("emev_nc_close_windows"),
 563                                                          _("mcen_bd_yes"), GTK_RESPONSE_YES,
 564                                                          _("mcen_bd_no"), GTK_RESPONSE_NO,
 565                                                          NULL);
 566
 567         response = gtk_dialog_run (GTK_DIALOG (note));
 568         gtk_widget_destroy (GTK_WIDGET (note));
 569
 570         if (response == GTK_RESPONSE_YES)
 571                 return TRUE;
 572         else
 573                 return FALSE;
 574 }
 575
 576
 577 void
 578 modest_main_window_set_style (ModestMainWindow *self,
 579                               ModestMainWindowStyle style)
 580 {
 581         ModestMainWindowPrivate *priv;
 582         ModestWindowPrivate *parent_priv;
 583         GtkAction *action;
 584
 585         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
 586
 587         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 588         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 589
 590         /* no change -> nothing to do */
 591         if (priv->style == style)
 592                 return;
 593
 594         /* Get toggle button */
 595         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarToggleView");
 596
 597         priv->style = style;
 598
 599         switch (style) {
 600         case MODEST_MAIN_WINDOW_STYLE_SIMPLE:
 601                 /* Remove main paned */
 602                 g_object_ref (priv->main_paned);
 603                 gtk_container_remove (GTK_CONTAINER (priv->main_vbox), priv->main_paned);
 604
 605                 /* Reparent the contents widget to the main vbox */
 606                 gtk_widget_reparent (priv->contents_widget, priv->main_vbox);
 607
 608                 g_signal_handlers_block_by_func (action, modest_ui_actions_toggle_folders_view, self);
 609                 gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE);
 610                 g_signal_handlers_unblock_by_func (action, modest_ui_actions_toggle_folders_view, self);
 611
 612                 break;
 613         case MODEST_MAIN_WINDOW_STYLE_SPLIT:
 614                 /* Remove header view */
 615                 g_object_ref (priv->contents_widget);
 616                 gtk_container_remove (GTK_CONTAINER (priv->main_vbox), priv->contents_widget);
 617
 618                 /* Reparent the main paned */
 619                 gtk_paned_add2 (GTK_PANED (priv->main_paned), priv->contents_widget);
 620                 gtk_container_add (GTK_CONTAINER (priv->main_vbox), priv->main_paned);
 621
 622                 g_signal_handlers_block_by_func (action, modest_ui_actions_toggle_folders_view, self);
 623                 gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), FALSE);
 624                 g_signal_handlers_unblock_by_func (action, modest_ui_actions_toggle_folders_view, self);
 625
 626                 break;
 627         default:
 628                 g_return_if_reached ();
 629         }
 630
 631         /* Let header view grab the focus if it's being shown */
 632         if (priv->contents_style == MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
 633                 gtk_widget_grab_focus (GTK_WIDGET (priv->header_view));
 634         else
 635                 gtk_widget_grab_focus (GTK_WIDGET (priv->contents_widget));
 636
 637         /* Show changes */
 638         gtk_widget_show_all (GTK_WIDGET (priv->main_vbox));
 639 }
 640
 641 ModestMainWindowStyle
 642 modest_main_window_get_style (ModestMainWindow *self)
 643 {
 644         ModestMainWindowPrivate *priv;
 645
 646         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (self), -1);
 647
 648         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 649         return priv->style;
 650 }
 651
 652
 653
 654 static gboolean
 655 modest_main_window_window_state_event (GtkWidget *widget, GdkEventWindowState *event, gpointer userdata)
 656 {
 657         if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) {
 658                 ModestWindowPrivate *parent_priv;
 659                 ModestWindowMgr *mgr;
 660                 gboolean is_fullscreen;
 661                 GtkAction *fs_toggle_action;
 662                 gboolean active;
 663
 664                 mgr = modest_runtime_get_window_mgr ();
 665
 666                 is_fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
 667
 668                 parent_priv = MODEST_WINDOW_GET_PRIVATE (widget);
 669
 670                 fs_toggle_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ViewMenu/ViewToggleFullscreenMenu");
 671                 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (fs_toggle_action)))?1:0;
 672                 if (is_fullscreen != active) {
 673                         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (fs_toggle_action), is_fullscreen);
 674                 }
 675         }
 676
 677         return FALSE;
 678
 679 }
 680
 681 static void
 682 set_homogeneous (GtkWidget *widget,
 683                  gpointer data)
 684 {
 685         gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), TRUE);
 686         gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), TRUE);
 687 }
 688
 689 static void
 690 modest_main_window_show_toolbar (ModestWindow *self,
 691                                  gboolean show_toolbar)
 692 {
 693         ModestMainWindowPrivate *priv = NULL;
 694         ModestWindowPrivate *parent_priv = NULL;
 695         GtkWidget *reply_button = NULL, *menu = NULL;
 696         GtkWidget *placeholder = NULL;
 697         gint insert_index;
 698
 699         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 700         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 701
 702         if (!parent_priv->toolbar && show_toolbar) {
 703                 parent_priv->toolbar = gtk_ui_manager_get_widget (parent_priv->ui_manager,
 704                                                                   "/ToolBar");
 705
 706                 /* Set homogeneous toolbar */
 707                 gtk_container_foreach (GTK_CONTAINER (parent_priv->toolbar),
 708                                        set_homogeneous, NULL);
 709
 710                 priv->progress_toolitem = GTK_WIDGET (gtk_tool_item_new ());
 711                 priv->cancel_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarCancel");
 712                 priv->refresh_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarSendReceive");
 713                 priv->sort_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarSort");
 714                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
 715                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
 716                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE);
 717                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE);
 718
 719                 /* Add ProgressBar (Transfer toolbar) */
 720                 priv->progress_bar = modest_progress_bar_widget_new ();
 721                 gtk_widget_set_no_show_all (priv->progress_bar, TRUE);
 722                 placeholder = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ProgressBarView");
 723                 insert_index = gtk_toolbar_get_item_index(GTK_TOOLBAR (parent_priv->toolbar), GTK_TOOL_ITEM(placeholder));
 724                 gtk_container_add (GTK_CONTAINER (priv->progress_toolitem), priv->progress_bar);
 725                 gtk_toolbar_insert(GTK_TOOLBAR(parent_priv->toolbar), GTK_TOOL_ITEM (priv->progress_toolitem), insert_index);
 726
 727                 /* Connect cancel 'clicked' signal to abort progress mode */
 728                 g_signal_connect(priv->cancel_toolitem, "clicked",
 729                                  G_CALLBACK(cancel_progressbar),
 730                                  self);
 731
 732                 /* Add it to the observers list */
 733                 priv->progress_widgets = g_slist_prepend(priv->progress_widgets, priv->progress_bar);
 734
 735                 /* Add to window */
 736                 hildon_window_add_toolbar (HILDON_WINDOW (self),
 737                                            GTK_TOOLBAR (parent_priv->toolbar));
 738
 739                 /* Set reply button tap and hold menu */
 740                 reply_button = gtk_ui_manager_get_widget (parent_priv->ui_manager,
 741                                                           "/ToolBar/ToolbarMessageReply");
 742                 menu = gtk_ui_manager_get_widget (parent_priv->ui_manager,
 743                                                   "/ToolbarReplyCSM");
 744                 gtk_widget_tap_and_hold_setup (GTK_WIDGET (reply_button), menu, NULL, 0);
 745
 746                 /* Set send & receive button tap and hold menu */
 747                 on_account_update (TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()),
 748                                    NULL, self);
 749         }
 750
 751         /* TODO: Why is this sometimes NULL? murrayc */
 752         if (parent_priv->toolbar) {
 753                 if (show_toolbar) {
 754                         gtk_widget_show (GTK_WIDGET (parent_priv->toolbar));
 755                         set_toolbar_mode (MODEST_MAIN_WINDOW(self), TOOLBAR_MODE_NORMAL);
 756                 } else
 757                         gtk_widget_hide (GTK_WIDGET (parent_priv->toolbar));
 758         }
 759 }
 760
 761 /*
 762  * TODO: modify the menu dynamically. Add handlers to each item of the
 763  * menu when created
 764  */
 765 static void
 766 on_account_update (TnyAccountStore *account_store,
 767                    gchar *accout_name,
 768                    gpointer user_data)
 769 {
 770         ModestMainWindow *self;
 771         ModestMainWindowPrivate *priv;
 772         ModestWindowPrivate *parent_priv;
 773         TnyList *account_list;
 774         GtkWidget *item, *send_receive_button;
 775         TnyIterator *iter;
 776         ModestAccountMgr *mgr;
 777         gchar *default_account;
 778
 779         self = MODEST_MAIN_WINDOW (user_data);
 780         priv = MODEST_MAIN_WINDOW_GET_PRIVATE (self);
 781         parent_priv = MODEST_WINDOW_GET_PRIVATE (self);
 782
 783         /* If there is no toolbar then exit */
 784         if (!parent_priv->toolbar)
 785                 return;
 786
 787         if (priv->accounts_popup && gtk_menu_get_attach_widget (GTK_MENU (priv->accounts_popup)) ) {
 788                 /* gtk_menu_detach will also unreference the popup,
 789                  * so we can forget about this instance, and create a new one later:
 790                  */
 791                 gtk_menu_detach (GTK_MENU (priv->accounts_popup));
 792                 priv->accounts_popup = NULL;
 793         }
 794
 795         /* Get accounts */
 796         account_list = tny_simple_list_new ();
 797         tny_account_store_get_accounts (account_store,
 798                                         account_list,
 799                                         TNY_ACCOUNT_STORE_STORE_ACCOUNTS);
 800
 801         /* If there is only one account do not show any menu */
 802         if (tny_list_get_length (account_list) <= 1)
 803                 goto free;
 804
 805         /* Get send receive button */
 806         send_receive_button = gtk_ui_manager_get_widget (parent_priv->ui_manager,
 807                                                           "/ToolBar/ToolbarSendReceive");
 808
 809         /* Create the menu */
 810         priv->accounts_popup = gtk_menu_new ();
 811         item = gtk_menu_item_new_with_label (_("mcen_me_toolbar_sendreceive_all"));
 812         gtk_menu_shell_append (GTK_MENU_SHELL (priv->accounts_popup), GTK_WIDGET (item));
 813         item = gtk_separator_menu_item_new ();
 814         gtk_menu_shell_append (GTK_MENU_SHELL (priv->accounts_popup), GTK_WIDGET (item));
 815
 816         iter = tny_list_create_iterator (account_list);
 817         mgr = modest_runtime_get_account_mgr ();
 818         default_account = modest_account_mgr_get_default_account (mgr);
 819
 820         do {
 821                 TnyAccount *acc = NULL;
 822                 const gchar *acc_name = NULL;
 823
 824                 /* Create tool item */
 825                 acc = TNY_ACCOUNT (tny_iterator_get_current (iter));
 826                 if (acc)
 827                         acc_name = tny_account_get_name (acc);
 828
 829                 /* Create display name */
 830                 gchar *display_name = NULL;
 831                 if (acc_name) {
 832                         if (default_account && !(strcmp (default_account, acc_name) == 0))
 833                                 display_name = g_strdup_printf (_("mcen_me_toolbar_sendreceive_default"), acc_name);
 834                         else
 835                                 display_name = g_strdup_printf (_("mcen_me_toolbar_sendreceive_mailbox_n"), acc_name);
 836                 }
 837                 else
 838                 {
 839                         /* TODO: This probably should never happen: */
 840                         display_name = g_strdup_printf (_("mcen_me_toolbar_sendreceive_default"), "");
 841                 }
 842
 843
 844                 item = gtk_menu_item_new_with_label (display_name);
 845
 846                 /* Free */
 847                 g_free (display_name);
 848                 g_object_unref (acc);
 849
 850                 /* Append item */
 851                 gtk_menu_shell_append (GTK_MENU_SHELL (priv->accounts_popup), GTK_WIDGET (item));
 852
 853                 /* Go to next */
 854                 tny_iterator_next (iter);
 855
 856         } while (!tny_iterator_is_done (iter));
 857
 858         g_object_unref (iter);
 859
 860         /* Mandatory in order to view the menu contents */
 861         gtk_widget_show_all (priv->accounts_popup);
 862
 863         /* Setup tap_and_hold */
 864         gtk_widget_tap_and_hold_setup (send_receive_button, priv->accounts_popup, NULL, 0);
 865
 866  free:
 867
 868         /* Free */
 869         g_object_unref (account_list);
 870 }
 871
 872 /*
 873  * This function manages the key events used to navigate between
 874  * header and folder views (when the window is in split view)
 875  *
 876  * FROM         KEY        ACTION
 877  * -------------------------------------------------
 878  * HeaderView   GDK_Left   Move focus to folder view
 879  * FolderView   GDK_Right  Move focus to header view
 880  *
 881  * There is no need to scroll to selected row, the widgets will be the
 882  * responsibles of doing that (probably managing the focus-in event
 883  */
 884 static gboolean
 885 on_inner_widgets_key_pressed (GtkWidget *widget,
 886                               GdkEventKey *event,
 887                               gpointer user_data)
 888 {
 889         ModestMainWindowPrivate *priv;
 890
 891         priv = MODEST_MAIN_WINDOW_GET_PRIVATE (user_data);
 892
 893         /* Do nothing if we're in SIMPLE style */
 894         if (priv->style == MODEST_MAIN_WINDOW_STYLE_SIMPLE)
 895                 return FALSE;
 896
 897         if (MODEST_IS_HEADER_VIEW (widget) && event->keyval == GDK_Left)
 898                 gtk_widget_grab_focus (GTK_WIDGET (priv->folder_view));
 899         else if (MODEST_IS_FOLDER_VIEW (widget) && event->keyval == GDK_Right)
 900                 gtk_widget_grab_focus (GTK_WIDGET (priv->header_view));
 901
 902         return FALSE;
 903 }
 904
 905 static void
 906 set_alignment (GtkWidget *widget,
 907                gpointer data)
 908 {
 909         gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0);
 910         gtk_misc_set_padding (GTK_MISC (widget), 0, 0);
 911 }
 912
 913 static GtkWidget *
 914 create_details_widget (TnyAccount *account)
 915 {
 916         GtkWidget *vbox;
 917         gchar *label;
 918
 919         vbox = gtk_vbox_new (FALSE, 0);
 920
 921         /* Account description */
 922         if (!strcmp (tny_account_get_id (account), MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
 923                 gchar *device_name;
 924
 925                 /* Get device name */
 926                 device_name = modest_conf_get_string (modest_runtime_get_conf(),
 927                                                       MODEST_CONF_DEVICE_NAME, NULL);
 928
 929                 label = g_strdup_printf ("%s: %s",
 930                                          _("mcen_fi_localroot_description"),
 931                                          device_name);
 932                 gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new (label), FALSE, FALSE, 0);
 933                 g_free (device_name);
 934                 g_free (label);
 935         } else if (!strcmp (tny_account_get_id (account), MODEST_MMC_ACCOUNT_ID)) {
 936                 /* TODO: MMC ? */
 937                 gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new ("FIXME: MMC ?"), FALSE, FALSE, 0);
 938         } else {
 939                 GString *proto;
 940
 941                 /* Put proto in uppercase */
 942                 proto = g_string_new (tny_account_get_proto (account));
 943                 proto = g_string_ascii_up (proto);
 944
 945                 label = g_strdup_printf ("%s %s: %s",
 946                                          proto->str,
 947                                          _("mcen_fi_remoteroot_account"),
 948                                          tny_account_get_name (account));
 949                 gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new (label), FALSE, FALSE, 0);
 950                 g_string_free (proto, TRUE);
 951                 g_free (label);
 952         }
 953
 954         /* Message count */
 955         label = g_strdup_printf ("%s: %d", _("mcen_fi_rootfolder_messages"),
 956                                  modest_tny_account_get_message_count (account));
 957         gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new (label), FALSE, FALSE, 0);
 958         g_free (label);
 959
 960         /* Folder count */
 961         label = g_strdup_printf ("%s: %d", _("mcen_fi_rootfolder_folders"),
 962                                  modest_tny_account_get_folder_count (account));
 963         gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new (label), FALSE, FALSE, 0);
 964         g_free (label);
 965
 966         /* Size / Date */
 967         if (!strcmp (tny_account_get_id (account), MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
 968                 /* FIXME: format size */
 969                 label = g_strdup_printf ("%s: %d", _("mcen_fi_rootfolder_size"),
 970                                          modest_tny_account_get_local_size (account));
 971                 gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new (label), FALSE, FALSE, 0);
 972                 g_free (label);
 973         } else if (!strcmp (tny_account_get_id (account), MODEST_MMC_ACCOUNT_ID)) {
 974                 gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new ("FIXME: MMC ?"), FALSE, FALSE, 0);
 975         } else {
 976                 label = g_strdup_printf ("%s: %s", _("mcen_ti_lastupdated"), "08/08/08");
 977                 gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new (label), FALSE, FALSE, 0);
 978                 g_free (label);
 979         }
 980
 981         /* Set alignment */
 982         gtk_container_foreach (GTK_CONTAINER (vbox), (GtkCallback) set_alignment, NULL);
 983
 984         return vbox;
 985 }
 986
 987 void
 988 modest_main_window_set_contents_style (ModestMainWindow *self,
 989                                        ModestMainWindowContentsStyle style)
 990 {
 991         ModestMainWindowPrivate *priv;
 992         GtkWidget *content;
 993         TnyAccount *account;
 994
 995         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
 996
 997         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 998
 999         /* We allow to set the same content style than the previously
1000            set if there are details, because it could happen when we're
1001            selecting different accounts consecutively */
1002         if ((priv->contents_style == style) &&
1003             (priv->contents_style == MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS))
1004                 return;
1005
1006         /* Remove previous child. Delete it if it was an account
1007            details widget */
1008         content = gtk_bin_get_child (GTK_BIN (priv->contents_widget));
1009         if (priv->contents_style != MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS)
1010                 g_object_ref (content);
1011         gtk_container_remove (GTK_CONTAINER (priv->contents_widget), content);
1012
1013         priv->contents_style = style;
1014
1015         switch (priv->contents_style) {
1016         case MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS:
1017                 wrap_in_scrolled_window (priv->contents_widget, GTK_WIDGET (priv->header_view));
1018                 break;
1019         case MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS:
1020                 /* TODO: show here account details */
1021                 account = TNY_ACCOUNT (modest_folder_view_get_selected (priv->folder_view));
1022                 priv->details_widget = create_details_widget (account);
1023
1024                 wrap_in_scrolled_window (priv->contents_widget,
1025                                          priv->details_widget);
1026                 break;
1027         default:
1028                 g_return_if_reached ();
1029         }
1030
1031         /* Show */
1032         gtk_widget_show_all (priv->contents_widget);
1033 }
1034
1035 static void
1036 on_configuration_key_changed (ModestConf* conf,
1037                               const gchar *key,
1038                               ModestConfEvent event,
1039                               ModestMainWindow *self)
1040 {
1041         ModestMainWindowPrivate *priv;
1042         TnyAccount *account;
1043
1044         if (!key || strcmp (key, MODEST_CONF_DEVICE_NAME))
1045                 return;
1046
1047         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1048
1049         if (priv->contents_style != MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS)
1050                 return;
1051
1052         account = (TnyAccount *) modest_folder_view_get_selected (priv->folder_view);
1053         if (TNY_IS_ACCOUNT (account) &&
1054             !strcmp (tny_account_get_id (account), MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1055                 GList *children;
1056                 GtkLabel *label;
1057                 const gchar *device_name;
1058                 gchar *new_text;
1059
1060                 /* Get label */
1061                 children = gtk_container_get_children (GTK_CONTAINER (priv->details_widget));
1062                 label = GTK_LABEL (children->data);
1063
1064                 device_name = modest_conf_get_string (modest_runtime_get_conf(),
1065                                                       MODEST_CONF_DEVICE_NAME, NULL);
1066
1067                 new_text = g_strdup_printf ("%s: %s",
1068                                             _("mcen_fi_localroot_description"),
1069                                             device_name);
1070
1071                 gtk_label_set_text (label, new_text);
1072                 gtk_widget_show (GTK_WIDGET (label));
1073
1074                 g_free (new_text);
1075                 g_list_free (children);
1076         }
1077 }
1078
1079 static void
1080 set_toolbar_mode (ModestMainWindow *self,
1081                   ModestToolBarModes mode)
1082 {
1083         ModestWindowPrivate *parent_priv;
1084         ModestMainWindowPrivate *priv;
1085         GtkAction *sort_action, *refresh_action, *cancel_action;
1086
1087         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
1088
1089         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
1090         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1091
1092         sort_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarSort");
1093         refresh_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarSendReceive");
1094         cancel_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarCancel");
1095
1096         /* Sets current toolbar mode */
1097         priv->current_toolbar_mode = mode;
1098
1099         /* Show and hide toolbar items */
1100         switch (mode) {
1101         case TOOLBAR_MODE_NORMAL:
1102                 if (sort_action)
1103                         gtk_action_set_visible (sort_action, TRUE);
1104                 if (refresh_action)
1105                         gtk_action_set_visible (refresh_action, TRUE);
1106                 if (priv->progress_toolitem) {
1107                         gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
1108                         gtk_widget_hide (priv->progress_toolitem);
1109                 }
1110                 if (priv->progress_bar)
1111                         gtk_widget_hide (priv->progress_bar);
1112
1113                 if (cancel_action)
1114                         gtk_action_set_visible (cancel_action, FALSE);
1115                 break;
1116         case TOOLBAR_MODE_TRANSFER:
1117                 if (sort_action)
1118                         gtk_action_set_visible (sort_action, FALSE);
1119                 if (refresh_action)
1120                         gtk_action_set_visible (refresh_action, FALSE);
1121                 if (cancel_action)
1122                         gtk_action_set_visible (cancel_action, TRUE);
1123                 if (priv->progress_toolitem) {
1124                         gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
1125                         gtk_widget_show (priv->progress_toolitem);
1126                 }
1127                 if (priv->progress_bar)
1128                         gtk_widget_show (priv->progress_bar);
1129                 break;
1130         default:
1131                 g_return_if_reached ();
1132         }
1133
1134         gtk_widget_show_all (GTK_WIDGET (self));
1135 }
1136
1137 static void
1138 cancel_progressbar (GtkToolButton *toolbutton,
1139                     ModestMainWindow *self)
1140 {
1141         GSList *tmp;
1142         ModestMainWindowPrivate *priv;
1143
1144         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1145
1146         /* Get operation observers and cancel its current operation */
1147         tmp = priv->progress_widgets;
1148         while (tmp) {
1149                 modest_progress_object_cancel_current_operation (MODEST_PROGRESS_OBJECT(tmp->data));
1150                 tmp=g_slist_next(tmp);
1151         }
1152 }
1153
1154 static gboolean
1155 observers_empty (ModestMainWindow *self)
1156 {
1157         GSList *tmp = NULL;
1158         ModestMainWindowPrivate *priv;
1159         gboolean is_empty = TRUE;
1160         guint pending_ops = 0;
1161
1162         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1163         tmp = priv->progress_widgets;
1164
1165         /* Check all observers */
1166         while (tmp && is_empty)  {
1167                 pending_ops = modest_progress_object_num_pending_operations (MODEST_PROGRESS_OBJECT(tmp->data));
1168                 is_empty = pending_ops == 0;
1169
1170                 tmp = g_slist_next(tmp);
1171         }
1172
1173         return is_empty;
1174 }
1175
1176 static void
1177 on_queue_changed (ModestMailOperationQueue *queue,
1178                   ModestMailOperation *mail_op,
1179                   ModestMailOperationQueueNotification type,
1180                   ModestMainWindow *self)
1181 {
1182         ModestMainWindowPrivate *priv;
1183         ModestMailOperationId op_id;
1184         ModestToolBarModes mode;
1185         GSList *tmp;
1186         gboolean mode_changed = FALSE;
1187
1188         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
1189         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1190
1191         /* Get toolbar mode from operation id*/
1192         op_id = modest_mail_operation_get_id (mail_op);
1193         switch (op_id) {
1194         case MODEST_MAIL_OPERATION_ID_SEND:
1195         case MODEST_MAIL_OPERATION_ID_RECEIVE:
1196                 mode = TOOLBAR_MODE_TRANSFER;
1197                 if (priv->current_toolbar_mode == TOOLBAR_MODE_NORMAL)
1198                         mode_changed = TRUE;
1199                 break;
1200         default:
1201                 mode = TOOLBAR_MODE_NORMAL;
1202
1203         }
1204
1205
1206         /* Add operation observers and change toolbar if neccessary*/
1207         tmp = priv->progress_widgets;
1208         switch (type) {
1209         case MODEST_MAIL_OPERATION_QUEUE_OPERATION_ADDED:
1210                 if (mode_changed)
1211                         set_toolbar_mode (self, mode);
1212                 if (mode == TOOLBAR_MODE_TRANSFER) {
1213                         while (tmp) {
1214                                 modest_progress_object_add_operation (MODEST_PROGRESS_OBJECT (tmp->data),
1215                                                                       mail_op);
1216                                 tmp = g_slist_next (tmp);
1217                         }
1218                 }
1219                 break;
1220         case MODEST_MAIL_OPERATION_QUEUE_OPERATION_REMOVED:
1221                 if (mode == TOOLBAR_MODE_TRANSFER) {
1222                         while (tmp) {
1223                                 modest_progress_object_remove_operation (MODEST_PROGRESS_OBJECT (tmp->data),
1224                                                                          mail_op);
1225                                 tmp = g_slist_next (tmp);
1226                         }
1227
1228                         /* If no more operations are being observed, NORMAL mode is enabled again */
1229                         if (observers_empty (self))
1230                                 set_toolbar_mode (self, TOOLBAR_MODE_NORMAL);
1231                 }
1232                 break;
1233         }
1234 }