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                         /* Quick hack: this prevents toolbar icons "dance" when progress bar show status is changed */
 755                         /* TODO: resize mode migth be GTK_RESIZE_QUEUE, in order to avoid unneccesary shows */
 756                         gtk_container_set_resize_mode (GTK_CONTAINER(parent_priv->toolbar), GTK_RESIZE_IMMEDIATE);
 757
 758                         gtk_widget_show (GTK_WIDGET (parent_priv->toolbar));
 759                         set_toolbar_mode (MODEST_MAIN_WINDOW(self), TOOLBAR_MODE_NORMAL);
 760                 } else
 761                         gtk_widget_hide (GTK_WIDGET (parent_priv->toolbar));
 762         }
 763 }
 764
 765 /*
 766  * TODO: modify the menu dynamically. Add handlers to each item of the
 767  * menu when created
 768  */
 769 static void
 770 on_account_update (TnyAccountStore *account_store,
 771                    gchar *accout_name,
 772                    gpointer user_data)
 773 {
 774         ModestMainWindow *self;
 775         ModestMainWindowPrivate *priv;
 776         ModestWindowPrivate *parent_priv;
 777         TnyList *account_list;
 778         GtkWidget *item, *send_receive_button;
 779         TnyIterator *iter;
 780         ModestAccountMgr *mgr;
 781         gchar *default_account;
 782
 783         self = MODEST_MAIN_WINDOW (user_data);
 784         priv = MODEST_MAIN_WINDOW_GET_PRIVATE (self);
 785         parent_priv = MODEST_WINDOW_GET_PRIVATE (self);
 786
 787         /* If there is no toolbar then exit */
 788         if (!parent_priv->toolbar)
 789                 return;
 790
 791         if (priv->accounts_popup && gtk_menu_get_attach_widget (GTK_MENU (priv->accounts_popup)) ) {
 792                 /* gtk_menu_detach will also unreference the popup,
 793                  * so we can forget about this instance, and create a new one later:
 794                  */
 795                 gtk_menu_detach (GTK_MENU (priv->accounts_popup));
 796                 priv->accounts_popup = NULL;
 797         }
 798
 799         /* Get accounts */
 800         account_list = tny_simple_list_new ();
 801         tny_account_store_get_accounts (account_store,
 802                                         account_list,
 803                                         TNY_ACCOUNT_STORE_STORE_ACCOUNTS);
 804
 805         /* If there is only one account do not show any menu */
 806         if (tny_list_get_length (account_list) <= 1)
 807                 goto free;
 808
 809         /* Get send receive button */
 810         send_receive_button = gtk_ui_manager_get_widget (parent_priv->ui_manager,
 811                                                           "/ToolBar/ToolbarSendReceive");
 812
 813         /* Create the menu */
 814         priv->accounts_popup = gtk_menu_new ();
 815         item = gtk_menu_item_new_with_label (_("mcen_me_toolbar_sendreceive_all"));
 816         gtk_menu_shell_append (GTK_MENU_SHELL (priv->accounts_popup), GTK_WIDGET (item));
 817         item = gtk_separator_menu_item_new ();
 818         gtk_menu_shell_append (GTK_MENU_SHELL (priv->accounts_popup), GTK_WIDGET (item));
 819
 820         iter = tny_list_create_iterator (account_list);
 821         mgr = modest_runtime_get_account_mgr ();
 822         default_account = modest_account_mgr_get_default_account (mgr);
 823
 824         do {
 825                 TnyAccount *acc = NULL;
 826                 const gchar *acc_name = NULL;
 827
 828                 /* Create tool item */
 829                 acc = TNY_ACCOUNT (tny_iterator_get_current (iter));
 830                 if (acc)
 831                         acc_name = tny_account_get_name (acc);
 832
 833                 /* Create display name */
 834                 gchar *display_name = NULL;
 835                 if (acc_name) {
 836                         if (default_account && !(strcmp (default_account, acc_name) == 0))
 837                                 display_name = g_strdup_printf (_("mcen_me_toolbar_sendreceive_default"), acc_name);
 838                         else
 839                                 display_name = g_strdup_printf (_("mcen_me_toolbar_sendreceive_mailbox_n"), acc_name);
 840                 }
 841                 else
 842                 {
 843                         /* TODO: This probably should never happen: */
 844                         display_name = g_strdup_printf (_("mcen_me_toolbar_sendreceive_default"), "");
 845                 }
 846
 847
 848                 item = gtk_menu_item_new_with_label (display_name);
 849
 850                 /* Free */
 851                 g_free (display_name);
 852                 g_object_unref (acc);
 853
 854                 /* Append item */
 855                 gtk_menu_shell_append (GTK_MENU_SHELL (priv->accounts_popup), GTK_WIDGET (item));
 856
 857                 /* Go to next */
 858                 tny_iterator_next (iter);
 859
 860         } while (!tny_iterator_is_done (iter));
 861
 862         g_object_unref (iter);
 863
 864         /* Mandatory in order to view the menu contents */
 865         gtk_widget_show_all (priv->accounts_popup);
 866
 867         /* Setup tap_and_hold */
 868         gtk_widget_tap_and_hold_setup (send_receive_button, priv->accounts_popup, NULL, 0);
 869
 870  free:
 871
 872         /* Free */
 873         g_object_unref (account_list);
 874 }
 875
 876 /*
 877  * This function manages the key events used to navigate between
 878  * header and folder views (when the window is in split view)
 879  *
 880  * FROM         KEY        ACTION
 881  * -------------------------------------------------
 882  * HeaderView   GDK_Left   Move focus to folder view
 883  * FolderView   GDK_Right  Move focus to header view
 884  *
 885  * There is no need to scroll to selected row, the widgets will be the
 886  * responsibles of doing that (probably managing the focus-in event
 887  */
 888 static gboolean
 889 on_inner_widgets_key_pressed (GtkWidget *widget,
 890                               GdkEventKey *event,
 891                               gpointer user_data)
 892 {
 893         ModestMainWindowPrivate *priv;
 894
 895         priv = MODEST_MAIN_WINDOW_GET_PRIVATE (user_data);
 896
 897         /* Do nothing if we're in SIMPLE style */
 898         if (priv->style == MODEST_MAIN_WINDOW_STYLE_SIMPLE)
 899                 return FALSE;
 900
 901         if (MODEST_IS_HEADER_VIEW (widget) && event->keyval == GDK_Left)
 902                 gtk_widget_grab_focus (GTK_WIDGET (priv->folder_view));
 903         else if (MODEST_IS_FOLDER_VIEW (widget) && event->keyval == GDK_Right)
 904                 gtk_widget_grab_focus (GTK_WIDGET (priv->header_view));
 905
 906         return FALSE;
 907 }
 908
 909 static void
 910 set_alignment (GtkWidget *widget,
 911                gpointer data)
 912 {
 913         gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0);
 914         gtk_misc_set_padding (GTK_MISC (widget), 0, 0);
 915 }
 916
 917 static GtkWidget *
 918 create_details_widget (TnyAccount *account)
 919 {
 920         GtkWidget *vbox;
 921         gchar *label;
 922
 923         vbox = gtk_vbox_new (FALSE, 0);
 924
 925         /* Account description */
 926         if (!strcmp (tny_account_get_id (account), MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
 927                 gchar *device_name;
 928
 929                 /* Get device name */
 930                 device_name = modest_conf_get_string (modest_runtime_get_conf(),
 931                                                       MODEST_CONF_DEVICE_NAME, NULL);
 932
 933                 label = g_strdup_printf ("%s: %s",
 934                                          _("mcen_fi_localroot_description"),
 935                                          device_name);
 936                 gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new (label), FALSE, FALSE, 0);
 937                 g_free (device_name);
 938                 g_free (label);
 939         } else if (!strcmp (tny_account_get_id (account), MODEST_MMC_ACCOUNT_ID)) {
 940                 /* TODO: MMC ? */
 941                 gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new ("FIXME: MMC ?"), FALSE, FALSE, 0);
 942         } else {
 943                 GString *proto;
 944
 945                 /* Put proto in uppercase */
 946                 proto = g_string_new (tny_account_get_proto (account));
 947                 proto = g_string_ascii_up (proto);
 948
 949                 label = g_strdup_printf ("%s %s: %s",
 950                                          proto->str,
 951                                          _("mcen_fi_remoteroot_account"),
 952                                          tny_account_get_name (account));
 953                 gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new (label), FALSE, FALSE, 0);
 954                 g_string_free (proto, TRUE);
 955                 g_free (label);
 956         }
 957
 958         /* Message count */
 959         label = g_strdup_printf ("%s: %d", _("mcen_fi_rootfolder_messages"),
 960                                  modest_tny_account_get_message_count (account));
 961         gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new (label), FALSE, FALSE, 0);
 962         g_free (label);
 963
 964         /* Folder count */
 965         label = g_strdup_printf ("%s: %d", _("mcen_fi_rootfolder_folders"),
 966                                  modest_tny_account_get_folder_count (account));
 967         gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new (label), FALSE, FALSE, 0);
 968         g_free (label);
 969
 970         /* Size / Date */
 971         if (!strcmp (tny_account_get_id (account), MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
 972                 /* FIXME: format size */
 973                 label = g_strdup_printf ("%s: %d", _("mcen_fi_rootfolder_size"),
 974                                          modest_tny_account_get_local_size (account));
 975                 gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new (label), FALSE, FALSE, 0);
 976                 g_free (label);
 977         } else if (!strcmp (tny_account_get_id (account), MODEST_MMC_ACCOUNT_ID)) {
 978                 gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new ("FIXME: MMC ?"), FALSE, FALSE, 0);
 979         } else {
 980                 label = g_strdup_printf ("%s: %s", _("mcen_ti_lastupdated"), "08/08/08");
 981                 gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new (label), FALSE, FALSE, 0);
 982                 g_free (label);
 983         }
 984
 985         /* Set alignment */
 986         gtk_container_foreach (GTK_CONTAINER (vbox), (GtkCallback) set_alignment, NULL);
 987
 988         return vbox;
 989 }
 990
 991 void
 992 modest_main_window_set_contents_style (ModestMainWindow *self,
 993                                        ModestMainWindowContentsStyle style)
 994 {
 995         ModestMainWindowPrivate *priv;
 996         GtkWidget *content;
 997         TnyAccount *account;
 998
 999         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
1000
1001         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1002
1003         /* We allow to set the same content style than the previously
1004            set if there are details, because it could happen when we're
1005            selecting different accounts consecutively */
1006         if ((priv->contents_style == style) &&
1007             (priv->contents_style == MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS))
1008                 return;
1009
1010         /* Remove previous child. Delete it if it was an account
1011            details widget */
1012         content = gtk_bin_get_child (GTK_BIN (priv->contents_widget));
1013         if (priv->contents_style != MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS)
1014                 g_object_ref (content);
1015         gtk_container_remove (GTK_CONTAINER (priv->contents_widget), content);
1016
1017         priv->contents_style = style;
1018
1019         switch (priv->contents_style) {
1020         case MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS:
1021                 wrap_in_scrolled_window (priv->contents_widget, GTK_WIDGET (priv->header_view));
1022                 break;
1023         case MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS:
1024                 /* TODO: show here account details */
1025                 account = TNY_ACCOUNT (modest_folder_view_get_selected (priv->folder_view));
1026                 priv->details_widget = create_details_widget (account);
1027
1028                 wrap_in_scrolled_window (priv->contents_widget,
1029                                          priv->details_widget);
1030                 break;
1031         default:
1032                 g_return_if_reached ();
1033         }
1034
1035         /* Show */
1036         gtk_widget_show_all (priv->contents_widget);
1037 }
1038
1039 static void
1040 on_configuration_key_changed (ModestConf* conf,
1041                               const gchar *key,
1042                               ModestConfEvent event,
1043                               ModestMainWindow *self)
1044 {
1045         ModestMainWindowPrivate *priv;
1046         TnyAccount *account;
1047
1048         if (!key || strcmp (key, MODEST_CONF_DEVICE_NAME))
1049                 return;
1050
1051         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1052
1053         if (priv->contents_style != MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS)
1054                 return;
1055
1056         account = (TnyAccount *) modest_folder_view_get_selected (priv->folder_view);
1057         if (TNY_IS_ACCOUNT (account) &&
1058             !strcmp (tny_account_get_id (account), MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1059                 GList *children;
1060                 GtkLabel *label;
1061                 const gchar *device_name;
1062                 gchar *new_text;
1063
1064                 /* Get label */
1065                 children = gtk_container_get_children (GTK_CONTAINER (priv->details_widget));
1066                 label = GTK_LABEL (children->data);
1067
1068                 device_name = modest_conf_get_string (modest_runtime_get_conf(),
1069                                                       MODEST_CONF_DEVICE_NAME, NULL);
1070
1071                 new_text = g_strdup_printf ("%s: %s",
1072                                             _("mcen_fi_localroot_description"),
1073                                             device_name);
1074
1075                 gtk_label_set_text (label, new_text);
1076                 gtk_widget_show (GTK_WIDGET (label));
1077
1078                 g_free (new_text);
1079                 g_list_free (children);
1080         }
1081 }
1082
1083 static void
1084 set_toolbar_mode (ModestMainWindow *self,
1085                   ModestToolBarModes mode)
1086 {
1087         ModestWindowPrivate *parent_priv;
1088         ModestMainWindowPrivate *priv;
1089         GtkAction *sort_action, *refresh_action, *cancel_action;
1090
1091         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
1092
1093         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
1094         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1095
1096         sort_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarSort");
1097         refresh_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarSendReceive");
1098         cancel_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarCancel");
1099
1100         /* Sets current toolbar mode */
1101         priv->current_toolbar_mode = mode;
1102
1103         /* Show and hide toolbar items */
1104         switch (mode) {
1105         case TOOLBAR_MODE_NORMAL:
1106                 if (sort_action)
1107                         gtk_action_set_visible (sort_action, TRUE);
1108                 if (refresh_action)
1109                         gtk_action_set_visible (refresh_action, TRUE);
1110                 if (priv->progress_toolitem) {
1111                         gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
1112                         gtk_widget_hide (priv->progress_toolitem);
1113                 }
1114                 if (priv->progress_bar)
1115                         gtk_widget_hide (priv->progress_bar);
1116
1117                 if (cancel_action)
1118                         gtk_action_set_visible (cancel_action, FALSE);
1119                 break;
1120         case TOOLBAR_MODE_TRANSFER:
1121                 if (sort_action)
1122                         gtk_action_set_visible (sort_action, FALSE);
1123                 if (refresh_action)
1124                         gtk_action_set_visible (refresh_action, FALSE);
1125                 if (cancel_action)
1126                         gtk_action_set_visible (cancel_action, TRUE);
1127                 if (priv->progress_toolitem) {
1128                         gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
1129                         gtk_widget_show (priv->progress_toolitem);
1130                 }
1131                 if (priv->progress_bar)
1132                         gtk_widget_show (priv->progress_bar);
1133                 break;
1134         default:
1135                 g_return_if_reached ();
1136         }
1137
1138         gtk_widget_show_all (GTK_WIDGET (self));
1139 }
1140
1141 static void
1142 cancel_progressbar (GtkToolButton *toolbutton,
1143                     ModestMainWindow *self)
1144 {
1145         GSList *tmp;
1146         ModestMainWindowPrivate *priv;
1147
1148         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1149
1150         /* Get operation observers and cancel its current operation */
1151         tmp = priv->progress_widgets;
1152         while (tmp) {
1153                 modest_progress_object_cancel_current_operation (MODEST_PROGRESS_OBJECT(tmp->data));
1154                 tmp=g_slist_next(tmp);
1155         }
1156 }
1157
1158 static gboolean
1159 observers_empty (ModestMainWindow *self)
1160 {
1161         GSList *tmp = NULL;
1162         ModestMainWindowPrivate *priv;
1163         gboolean is_empty = TRUE;
1164         guint pending_ops = 0;
1165
1166         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1167         tmp = priv->progress_widgets;
1168
1169         /* Check all observers */
1170         while (tmp && is_empty)  {
1171                 pending_ops = modest_progress_object_num_pending_operations (MODEST_PROGRESS_OBJECT(tmp->data));
1172                 is_empty = pending_ops == 0;
1173
1174                 tmp = g_slist_next(tmp);
1175         }
1176
1177         return is_empty;
1178 }
1179
1180 static void
1181 on_queue_changed (ModestMailOperationQueue *queue,
1182                   ModestMailOperation *mail_op,
1183                   ModestMailOperationQueueNotification type,
1184                   ModestMainWindow *self)
1185 {
1186         ModestMainWindowPrivate *priv;
1187         ModestMailOperationId op_id;
1188         ModestToolBarModes mode;
1189         GSList *tmp;
1190         gboolean mode_changed = FALSE;
1191
1192         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
1193         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1194
1195         /* Get toolbar mode from operation id*/
1196         op_id = modest_mail_operation_get_id (mail_op);
1197         switch (op_id) {
1198         case MODEST_MAIL_OPERATION_ID_SEND:
1199         case MODEST_MAIL_OPERATION_ID_RECEIVE:
1200                 mode = TOOLBAR_MODE_TRANSFER;
1201                 if (priv->current_toolbar_mode == TOOLBAR_MODE_NORMAL)
1202                         mode_changed = TRUE;
1203                 break;
1204         default:
1205                 mode = TOOLBAR_MODE_NORMAL;
1206
1207         }
1208
1209
1210         /* Add operation observers and change toolbar if neccessary*/
1211         tmp = priv->progress_widgets;
1212         switch (type) {
1213         case MODEST_MAIL_OPERATION_QUEUE_OPERATION_ADDED:
1214                 if (mode_changed)
1215                         set_toolbar_mode (self, mode);
1216                 if (mode == TOOLBAR_MODE_TRANSFER) {
1217                         while (tmp) {
1218                                 modest_progress_object_add_operation (MODEST_PROGRESS_OBJECT (tmp->data),
1219                                                                       mail_op);
1220                                 tmp = g_slist_next (tmp);
1221                         }
1222                 }
1223                 break;
1224         case MODEST_MAIL_OPERATION_QUEUE_OPERATION_REMOVED:
1225                 if (mode == TOOLBAR_MODE_TRANSFER) {
1226                         while (tmp) {
1227                                 modest_progress_object_remove_operation (MODEST_PROGRESS_OBJECT (tmp->data),
1228                                                                          mail_op);
1229                                 tmp = g_slist_next (tmp);
1230                         }
1231
1232                         /* If no more operations are being observed, NORMAL mode is enabled again */
1233                         if (observers_empty (self))
1234                                 set_toolbar_mode (self, TOOLBAR_MODE_NORMAL);
1235                 }
1236                 break;
1237         }
1238 }