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 <tny-list.h>
  35 #include <tny-iterator.h>
  36 #include <tny-maemo-conic-device.h>
  37 #include <tny-error.h>
  38 #include "modest-hildon-includes.h"
  39 #include "modest-defs.h"
  40 #include <string.h>
  41 #include "widgets/modest-header-view-priv.h"
  42 #include "widgets/modest-main-window.h"
  43 #include "widgets/modest-msg-edit-window.h"
  44 #include "widgets/modest-account-view-window.h"
  45 #include "modest-runtime.h"
  46 #include "modest-account-mgr-helpers.h"
  47 #include "modest-platform.h"
  48 #include "modest-widget-memory.h"
  49 #include "modest-window-priv.h"
  50 #include "modest-main-window-ui.h"
  51 #include "modest-main-window-ui-dimming.h"
  52 #include "modest-account-mgr.h"
  53 #include "modest-tny-account.h"
  54 #include "modest-tny-folder.h"
  55 #include "modest-conf.h"
  56 #include <modest-maemo-utils.h>
  57 #include "modest-tny-platform-factory.h"
  58 #include "modest-tny-msg.h"
  59 #include "modest-mail-operation.h"
  60 #include "modest-icon-names.h"
  61 #include "modest-progress-bar-widget.h"
  62 #include "modest-text-utils.h"
  63 #include "modest-ui-dimming-manager.h"
  64 #include "maemo/modest-osso-state-saving.h"
  65 #include "modest-text-utils.h"
  66 #include "modest-signal-mgr.h"
  67
  68 #ifdef MODEST_HAVE_HILDON0_WIDGETS
  69 #include <hildon-widgets/hildon-program.h>
  70 #else
  71 #include <hildon/hildon-program.h>
  72 #endif /*MODEST_HAVE_HILDON0_WIDGETS*/
  73
  74 #define MODEST_MAIN_WINDOW_ACTION_GROUP_ADDITIONS "ModestMainWindowActionAdditions"
  75
  76 #define XALIGN 0.5
  77 #define YALIGN 0.0
  78 #define XSPACE 1
  79 #define YSPACE 0
  80
  81 /* 'private'/'protected' functions */
  82 static void modest_main_window_class_init  (ModestMainWindowClass *klass);
  83 static void modest_main_window_init        (ModestMainWindow *obj);
  84 static void modest_main_window_finalize    (GObject *obj);
  85
  86 static gboolean modest_main_window_window_state_event (GtkWidget *widget,
  87                                                            GdkEventWindowState *event,
  88                                                            gpointer userdata);
  89
  90 static void connect_signals (ModestMainWindow *self);
  91
  92 static void modest_main_window_disconnect_signals (ModestWindow *self);
  93
  94 static void restore_settings (ModestMainWindow *self,
  95                               gboolean do_folder_view_too);
  96
  97 static void save_state (ModestWindow *self);
  98
  99 static void
 100 update_menus (ModestMainWindow* self);
 101
 102 static void modest_main_window_show_toolbar   (ModestWindow *window,
 103                                                gboolean show_toolbar);
 104
 105 static void cancel_progressbar (GtkToolButton *toolbutton,
 106                                 ModestMainWindow *self);
 107
 108 static void on_queue_changed   (ModestMailOperationQueue *queue,
 109                                 ModestMailOperation *mail_op,
 110                                 ModestMailOperationQueueNotification type,
 111                                 ModestMainWindow *self);
 112
 113 static gboolean on_zoom_minus_plus_not_implemented (ModestWindow *window);
 114
 115 static void
 116 on_account_inserted (TnyAccountStore *accoust_store,
 117                      TnyAccount *account,
 118                      gpointer user_data);
 119
 120 static void
 121 on_account_removed (TnyAccountStore *accoust_store,
 122                     TnyAccount *account,
 123                     gpointer user_data);
 124
 125 static void
 126 on_default_account_changed (ModestAccountMgr* mgr,
 127                             gpointer user_data);
 128
 129 static gboolean on_inner_widgets_key_pressed  (GtkWidget *widget,
 130                                                GdkEventKey *event,
 131                                                gpointer user_data);
 132
 133 static void on_configuration_key_changed      (ModestConf* conf,
 134                                                const gchar *key,
 135                                                ModestConfEvent event,
 136                                                ModestConfNotificationId id,
 137                                                ModestMainWindow *self);
 138
 139 static void set_toolbar_mode                  (ModestMainWindow *self,
 140                                                ModestToolBarModes mode);
 141
 142 static gboolean set_toolbar_transfer_mode     (ModestMainWindow *self);
 143
 144 static void on_show_account_action_toggled      (GtkToggleAction *action,
 145                                                  gpointer user_data);
 146
 147 static void on_refresh_account_action_activated   (GtkAction *action,
 148                                                    gpointer user_data);
 149
 150 static void on_send_receive_csm_activated         (GtkMenuItem *item,
 151                                                    gpointer user_data);
 152
 153 static void on_msg_count_changed (ModestHeaderView *header_view,
 154                                   TnyFolder *folder,
 155                                   TnyFolderChange *change,
 156                                   ModestMainWindow *main_window);
 157
 158 static void modest_main_window_cleanup_queue_error_signals (ModestMainWindow *self);
 159
 160
 161 static GtkWidget * create_empty_view (void);
 162
 163 static gboolean  on_folder_view_focus_in (GtkWidget *widget,
 164                                           GdkEventFocus *event,
 165                                           gpointer userdata);
 166
 167 static gboolean  on_header_view_focus_in (GtkWidget *widget,
 168                                           GdkEventFocus *event,
 169                                           gpointer userdata);
 170
 171 static void      modest_main_window_on_folder_selection_changed (ModestFolderView *folder_view,
 172                                                                  TnyFolderStore *folder_store,
 173                                                                  gboolean selected,
 174                                                                  ModestMainWindow *main_window);
 175
 176 static void set_at_least_one_account_visible(ModestMainWindow *self);
 177
 178 typedef struct _ModestMainWindowPrivate ModestMainWindowPrivate;
 179 struct _ModestMainWindowPrivate {
 180         GtkWidget *msg_paned;
 181         GtkWidget *main_paned;
 182         GtkWidget *main_vbox;
 183         GtkWidget *contents_widget;
 184         GtkWidget *empty_view;
 185
 186         /* Progress observers */
 187         GtkWidget   *progress_bar;
 188         GSList      *progress_widgets;
 189
 190         /* Tollbar items */
 191         GtkWidget   *progress_toolitem;
 192         GtkWidget   *cancel_toolitem;
 193         GtkWidget   *sort_toolitem;
 194         GtkWidget   *refresh_toolitem;
 195         ModestToolBarModes current_toolbar_mode;
 196
 197         /* Merge ids used to add/remove accounts to the ViewMenu*/
 198         GByteArray *merge_ids;
 199         GtkActionGroup *view_additions_group;
 200
 201         /* On-demand widgets */
 202         GtkWidget *accounts_popup;
 203         GtkWidget *details_widget;
 204
 205         /* Optimized view enabled */
 206         gboolean optimized_view;
 207
 208         /* Optimized view enabled */
 209         gboolean send_receive_in_progress;
 210
 211         ModestHeaderView *header_view;
 212         ModestFolderView *folder_view;
 213
 214         ModestMainWindowStyle style;
 215         ModestMainWindowContentsStyle contents_style;
 216
 217         guint progress_bar_timeout;
 218
 219         /* Signal handler UIDs */
 220         GList *queue_err_signals;
 221         GSList *sighandlers;
 222 };
 223 #define MODEST_MAIN_WINDOW_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
 224                                                 MODEST_TYPE_MAIN_WINDOW, \
 225                                                 ModestMainWindowPrivate))
 226
 227 typedef struct _GetMsgAsyncHelper {
 228         ModestMainWindowPrivate *main_window_private;
 229         guint action;
 230         ModestTnyMsgReplyType reply_type;
 231         ModestTnyMsgForwardType forward_type;
 232         gchar *from;
 233         TnyIterator *iter;
 234 } GetMsgAsyncHelper;
 235
 236
 237 /* globals */
 238 static GtkWindowClass *parent_class = NULL;
 239
 240
 241 /* Private actions */
 242 /* This is the context sensitive menu: */
 243 static const GtkActionEntry modest_folder_view_action_entries [] = {
 244
 245         /* Folder View CSM actions */
 246         { "FolderViewCSMNewFolder", NULL, N_("mcen_ti_new_folder"), NULL, NULL, G_CALLBACK (modest_ui_actions_on_new_folder) },
 247         { "FolderViewCSMRenameFolder", NULL, N_("mcen_me_user_renamefolder"), NULL, NULL, G_CALLBACK (modest_ui_actions_on_rename_folder) },
 248         { "FolderViewCSMPasteMsgs", NULL, N_("mcen_me_inbox_paste"), NULL, NULL,  G_CALLBACK (modest_ui_actions_on_paste)},
 249         { "FolderViewCSMDeleteFolder", NULL, N_("mcen_me_inbox_delete"), NULL, NULL, G_CALLBACK (modest_ui_actions_on_delete_folder) },
 250         { "FolderViewCSMSearchMessages", NULL, N_("mcen_me_inbox_search"), NULL, NULL, G_CALLBACK (modest_ui_actions_on_search_messages) },
 251         { "FolderViewCSMHelp", NULL, N_("mcen_me_inbox_help"), NULL, NULL, G_CALLBACK (modest_ui_actions_on_help) },
 252 };
 253
 254 static const GtkActionEntry modest_header_view_action_entries [] = {
 255
 256         /* Header View CSM actions */
 257         { "HeaderViewCSMOpen",          NULL,  N_("mcen_me_inbox_open"),        NULL,       NULL, G_CALLBACK (modest_ui_actions_on_open) },
 258         { "HeaderViewCSMReply",         NULL,  N_("mcen_me_inbox_reply"),       NULL,      NULL, G_CALLBACK (modest_ui_actions_on_reply) },
 259         { "HeaderViewCSMReplyAll",      NULL,  N_("mcen_me_inbox_replytoall"),  NULL,      NULL, G_CALLBACK (modest_ui_actions_on_reply_all) },
 260         { "HeaderViewCSMForward",       NULL,  N_("mcen_me_inbox_forward"),     NULL,      NULL, G_CALLBACK (modest_ui_actions_on_forward) },
 261         { "HeaderViewCSMCut",           NULL,  N_("mcen_me_inbox_cut"),         "<CTRL>X", NULL, G_CALLBACK (modest_ui_actions_on_cut) },
 262         { "HeaderViewCSMCopy",          NULL,  N_("mcen_me_inbox_copy"),        "<CTRL>C", NULL, G_CALLBACK (modest_ui_actions_on_copy) },
 263         { "HeaderViewCSMPaste",         NULL,  N_("mcen_me_inbox_paste"),       "<CTRL>V", NULL, G_CALLBACK (modest_ui_actions_on_paste) },
 264         { "HeaderViewCSMDelete",        NULL,  N_("mcen_me_inbox_delete"),      NULL,      NULL, G_CALLBACK (modest_ui_actions_on_delete_message) },
 265         { "HeaderViewCSMCancelSending", NULL,  N_("mcen_me_outbox_cancelsend"), NULL,      NULL, G_CALLBACK (modest_ui_actions_cancel_send) },
 266         { "HeaderViewCSMHelp",          NULL,  N_("mcen_me_inbox_help"),        NULL,      NULL, G_CALLBACK (modest_ui_actions_on_help) },
 267 };
 268
 269 static const GtkToggleActionEntry modest_main_window_toggle_action_entries [] = {
 270         { "ToggleFolders",     MODEST_STOCK_SPLIT_VIEW, N_("mcen_me_inbox_hidefolders"), "<CTRL>t", NULL, G_CALLBACK (modest_ui_actions_toggle_folders_view), TRUE },
 271 };
 272
 273 /************************************************************************/
 274
 275 GType
 276 modest_main_window_get_type (void)
 277 {
 278         static GType my_type = 0;
 279         if (!my_type) {
 280                 static const GTypeInfo my_info = {
 281                         sizeof(ModestMainWindowClass),
 282                         NULL,           /* base init */
 283                         NULL,           /* base finalize */
 284                         (GClassInitFunc) modest_main_window_class_init,
 285                         NULL,           /* class finalize */
 286                         NULL,           /* class data */
 287                         sizeof(ModestMainWindow),
 288                         1,              /* n_preallocs */
 289                         (GInstanceInitFunc) modest_main_window_init,
 290                         NULL
 291                 };
 292                 my_type = g_type_register_static (MODEST_TYPE_WINDOW,
 293                                                   "ModestMainWindow",
 294                                                   &my_info, 0);
 295         }
 296         return my_type;
 297 }
 298
 299 static void
 300 modest_main_window_class_init (ModestMainWindowClass *klass)
 301 {
 302         GObjectClass *gobject_class;
 303         gobject_class = (GObjectClass*) klass;
 304         ModestWindowClass *modest_window_class = (ModestWindowClass *) klass;
 305
 306         parent_class            = g_type_class_peek_parent (klass);
 307         gobject_class->finalize = modest_main_window_finalize;
 308
 309         g_type_class_add_private (gobject_class, sizeof(ModestMainWindowPrivate));
 310
 311         modest_window_class->show_toolbar_func = modest_main_window_show_toolbar;
 312         modest_window_class->save_state_func = save_state;
 313         modest_window_class->zoom_minus_func = on_zoom_minus_plus_not_implemented;
 314         modest_window_class->zoom_plus_func = on_zoom_minus_plus_not_implemented;
 315         modest_window_class->disconnect_signals_func = modest_main_window_disconnect_signals;
 316 }
 317
 318 static void
 319 modest_main_window_init (ModestMainWindow *obj)
 320 {
 321         ModestMainWindowPrivate *priv;
 322
 323         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(obj);
 324
 325         priv->queue_err_signals = NULL;
 326         priv->msg_paned    = NULL;
 327         priv->main_paned   = NULL;
 328         priv->main_vbox    = NULL;
 329         priv->header_view  = NULL;
 330         priv->folder_view  = NULL;
 331         priv->contents_widget  = NULL;
 332         priv->accounts_popup  = NULL;
 333         priv->details_widget  = NULL;
 334         priv->empty_view  = NULL;
 335         priv->progress_widgets  = NULL;
 336         priv->progress_bar = NULL;
 337         priv->current_toolbar_mode = TOOLBAR_MODE_NORMAL;
 338         priv->style  = MODEST_MAIN_WINDOW_STYLE_SPLIT;
 339         priv->contents_style  = -1; /* invalid contents style. We need this to select it for the first time */
 340         priv->merge_ids = NULL;
 341         priv->optimized_view  = FALSE;
 342         priv->send_receive_in_progress  = FALSE;
 343         priv->progress_bar_timeout = 0;
 344         priv->sighandlers = NULL;
 345 }
 346
 347 static void
 348 modest_main_window_finalize (GObject *obj)
 349 {
 350         ModestMainWindowPrivate *priv;
 351
 352         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(obj);
 353
 354         /* Sanity check: shouldn't be needed, the window mgr should
 355            call this function before */
 356         modest_main_window_disconnect_signals (MODEST_WINDOW (obj));
 357
 358         modest_main_window_cleanup_queue_error_signals ((ModestMainWindow *) obj);
 359
 360         g_slist_free (priv->progress_widgets);
 361
 362         g_byte_array_free (priv->merge_ids, TRUE);
 363
 364         if (priv->progress_bar_timeout > 0) {
 365                 g_source_remove (priv->progress_bar_timeout);
 366                 priv->progress_bar_timeout = 0;
 367         }
 368
 369         G_OBJECT_CLASS(parent_class)->finalize (obj);
 370 }
 371
 372 GtkWidget*
 373 modest_main_window_get_child_widget (ModestMainWindow *self,
 374                                      ModestMainWindowWidgetType widget_type)
 375 {
 376         ModestMainWindowPrivate *priv;
 377         GtkWidget *widget;
 378
 379         g_return_val_if_fail (self, NULL);
 380         g_return_val_if_fail (widget_type >= 0 && widget_type < MODEST_MAIN_WINDOW_WIDGET_TYPE_NUM,
 381                               NULL);
 382
 383         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 384
 385         switch (widget_type) {
 386         case MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW:
 387                 widget = (GtkWidget*)priv->header_view; break;
 388         case MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW:
 389                 widget = (GtkWidget*)priv->folder_view; break;
 390         default:
 391                 return NULL;
 392         }
 393
 394         return widget ? GTK_WIDGET(widget) : NULL;
 395 }
 396
 397
 398 static void
 399 restore_settings (ModestMainWindow *self, gboolean do_folder_view_too)
 400 {
 401         ModestConf *conf;
 402         ModestMainWindowPrivate *priv;
 403
 404         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 405
 406         conf = modest_runtime_get_conf ();
 407
 408         modest_widget_memory_restore (conf, G_OBJECT(self),
 409                                       MODEST_CONF_MAIN_WINDOW_KEY);
 410
 411         modest_widget_memory_restore (conf, G_OBJECT(priv->header_view),
 412                                       MODEST_CONF_HEADER_VIEW_KEY);
 413
 414         if (do_folder_view_too)
 415                 modest_widget_memory_restore (conf, G_OBJECT(priv->folder_view),
 416                                       MODEST_CONF_FOLDER_VIEW_KEY);
 417
 418         modest_widget_memory_restore (conf, G_OBJECT(priv->main_paned),
 419                                       MODEST_CONF_MAIN_PANED_KEY);
 420
 421         /* We need to force a redraw here in order to get the right
 422            position of the horizontal paned separator */
 423         gtk_widget_show (GTK_WIDGET (self));
 424 }
 425
 426
 427 static void
 428 save_state (ModestWindow *window)
 429 {
 430         ModestConf *conf;
 431         ModestMainWindow* self = MODEST_MAIN_WINDOW(window);
 432         ModestMainWindowPrivate *priv;
 433
 434         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 435         conf = modest_runtime_get_conf ();
 436
 437         modest_widget_memory_save (conf,G_OBJECT(self),
 438                                    MODEST_CONF_MAIN_WINDOW_KEY);
 439         modest_widget_memory_save (conf, G_OBJECT(priv->main_paned),
 440                                    MODEST_CONF_MAIN_PANED_KEY);
 441         //      modest_widget_memory_save (conf, G_OBJECT(priv->header_view),
 442         //                         MODEST_CONF_HEADER_VIEW_KEY);
 443         modest_widget_memory_save (conf, G_OBJECT(priv->folder_view),
 444                                    MODEST_CONF_FOLDER_VIEW_KEY);
 445 }
 446
 447 static gint
 448 compare_display_names (ModestAccountData *a,
 449                        ModestAccountData *b)
 450 {
 451         return strcmp (a->display_name, b->display_name);
 452 }
 453
 454 static void
 455 update_menus (ModestMainWindow* self)
 456 {
 457         GSList *account_names, *iter, *accounts;
 458         ModestMainWindowPrivate *priv;
 459         ModestWindowPrivate *parent_priv;
 460         ModestAccountMgr *mgr;
 461         gint i, num_accounts;
 462         GList *groups;
 463         gchar *default_account;
 464         GtkWidget *send_receive_button, *item;
 465         GtkAction *send_receive_all = NULL;
 466         GSList *radio_group;
 467
 468         priv = MODEST_MAIN_WINDOW_GET_PRIVATE (self);
 469         parent_priv = MODEST_WINDOW_GET_PRIVATE (self);
 470
 471         /* Get enabled account IDs */
 472         mgr = modest_runtime_get_account_mgr ();
 473         account_names = modest_account_mgr_account_names (mgr, TRUE);
 474         iter = account_names;
 475         accounts = NULL;
 476
 477         while (iter) {
 478                 ModestAccountData *account_data =
 479                         modest_account_mgr_get_account_data (mgr, (gchar*) iter->data);
 480                 accounts = g_slist_prepend (accounts, account_data);
 481
 482                 iter = iter->next;
 483         }
 484         modest_account_mgr_free_account_names (account_names);
 485         account_names = NULL;
 486
 487         /* Order the list of accounts by its display name */
 488         accounts = g_slist_sort (accounts, (GCompareFunc) compare_display_names);
 489         num_accounts = g_slist_length (accounts);
 490
 491         send_receive_all = gtk_ui_manager_get_action (parent_priv->ui_manager,
 492                                                       "/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsSendReceiveAllMenu");
 493         gtk_action_set_visible (send_receive_all, num_accounts > 1);
 494
 495         /* Delete old send&receive popup items. We can not just do a
 496            menu_detach because it does not work well with
 497            tap_and_hold */
 498         if (priv->accounts_popup)
 499                 gtk_container_foreach (GTK_CONTAINER (priv->accounts_popup),
 500                                        (GtkCallback) gtk_widget_destroy, NULL);
 501
 502         /* Delete old entries in the View menu. Do not free groups, it
 503            belongs to Gtk+ */
 504         groups = gtk_ui_manager_get_action_groups (parent_priv->ui_manager);
 505         while (groups) {
 506                 if (!strcmp (MODEST_MAIN_WINDOW_ACTION_GROUP_ADDITIONS,
 507                              gtk_action_group_get_name (GTK_ACTION_GROUP (groups->data)))) {
 508                         gtk_ui_manager_remove_action_group (parent_priv->ui_manager,
 509                                                             GTK_ACTION_GROUP (groups->data));
 510                         groups = NULL;
 511                         /* Remove uis */
 512                         if (priv->merge_ids) {
 513                                 for (i = 0; i < priv->merge_ids->len; i++)
 514                                         gtk_ui_manager_remove_ui (parent_priv->ui_manager, priv->merge_ids->data[i]);
 515                                 g_byte_array_free (priv->merge_ids, TRUE);
 516                         }
 517                         /* We need to call this in order to ensure
 518                            that the new actions are added in the right
 519                            order (alphabetical */
 520                         gtk_ui_manager_ensure_update (parent_priv->ui_manager);
 521                 } else
 522                         groups = g_list_next (groups);
 523         }
 524         priv->merge_ids = g_byte_array_sized_new (num_accounts);
 525
 526         /* Get send receive button */
 527         send_receive_button = gtk_ui_manager_get_widget (parent_priv->ui_manager,
 528                                                           "/ToolBar/ToolbarSendReceive");
 529
 530         /* Create the menu */
 531         if (num_accounts > 1) {
 532                 if (!priv->accounts_popup)
 533                         priv->accounts_popup = gtk_menu_new ();
 534                 item = gtk_menu_item_new_with_label (_("mcen_me_toolbar_sendreceive_all"));
 535                 gtk_menu_shell_append (GTK_MENU_SHELL (priv->accounts_popup), GTK_WIDGET (item));
 536                 g_signal_connect (G_OBJECT (item),
 537                                   "activate",
 538                                   G_CALLBACK (on_send_receive_csm_activated),
 539                                   NULL);
 540                 item = gtk_separator_menu_item_new ();
 541                 gtk_menu_shell_prepend (GTK_MENU_SHELL (priv->accounts_popup), GTK_WIDGET (item));
 542         }
 543
 544         /* Create a new action group */
 545         default_account = modest_account_mgr_get_default_account (mgr);
 546         priv->view_additions_group = gtk_action_group_new (MODEST_MAIN_WINDOW_ACTION_GROUP_ADDITIONS);
 547         radio_group = NULL;
 548         for (i = 0; i < num_accounts; i++) {
 549                 gchar *display_name = NULL;
 550
 551                 ModestAccountData *account_data = (ModestAccountData *) g_slist_nth_data (accounts, i);
 552
 553                 /* Create display name. The UI specification specifies a different format string
 554                  * to use for the default account, though both seem to be "%s", so
 555                  * I don't see what the point is. murrayc. */
 556                 if (default_account && account_data->account_name &&
 557                         !(strcmp (default_account, account_data->account_name) == 0)) {
 558                         display_name = g_strdup_printf (_("mcen_me_toolbar_sendreceive_default"),
 559                                                         account_data->display_name);
 560                 }
 561                 else {
 562                         display_name = g_strdup_printf (_("mcen_me_toolbar_sendreceive_mailbox_n"),
 563                                                         account_data->display_name);
 564                 }
 565
 566                 /* Create action and add it to the action group. The
 567                    action name must be the account name, this way we
 568                    could know in the handlers the account to show */
 569                 if(account_data && account_data->account_name) {
 570                         gchar* item_name, *refresh_action_name;
 571                         guint8 merge_id = 0;
 572                         GtkAction *view_account_action, *refresh_account_action;
 573
 574                         view_account_action = GTK_ACTION (gtk_radio_action_new (account_data->account_name,
 575                                                                                 display_name, NULL, NULL, 0));
 576                         gtk_action_group_add_action (priv->view_additions_group, view_account_action);
 577                         gtk_radio_action_set_group (GTK_RADIO_ACTION (view_account_action), radio_group);
 578                         radio_group = gtk_radio_action_get_group (GTK_RADIO_ACTION (view_account_action));
 579
 580                         if (default_account && account_data->account_name &&
 581                             (strcmp (default_account, account_data->account_name) == 0)) {
 582                                 gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (view_account_action), TRUE);
 583                         }
 584
 585                         /* Add ui from account data. We allow 2^9-1 account
 586                            changes in a single execution because we're
 587                            downcasting the guint to a guint8 in order to use a
 588                            GByteArray. It should be enough. */
 589                         item_name = g_strconcat (account_data->account_name, "Menu", NULL);
 590                         merge_id = (guint8) gtk_ui_manager_new_merge_id (parent_priv->ui_manager);
 591                         priv->merge_ids = g_byte_array_append (priv->merge_ids, &merge_id, 1);
 592                         gtk_ui_manager_add_ui (parent_priv->ui_manager,
 593                                                merge_id,
 594                                                "/MenuBar/ViewMenu/ViewMenuAdditions",
 595                                                item_name,
 596                                                account_data->account_name,
 597                                                GTK_UI_MANAGER_MENUITEM,
 598                                                FALSE);
 599
 600                         /* Connect the action signal "activate" */
 601                         g_signal_connect_after (G_OBJECT (view_account_action),
 602                                                 "toggled",
 603                                                 G_CALLBACK (on_show_account_action_toggled),
 604                                                 self);
 605
 606                         /* Create the items for the Tools->Send&Receive submenu */
 607                         refresh_action_name = g_strconcat ("SendReceive", account_data->account_name, NULL);
 608                         refresh_account_action = gtk_action_new ((const gchar*) refresh_action_name,
 609                                                                  display_name, NULL, NULL);
 610                         gtk_action_group_add_action (priv->view_additions_group, refresh_account_action);
 611
 612                         merge_id = (guint8) gtk_ui_manager_new_merge_id (parent_priv->ui_manager);
 613                         priv->merge_ids = g_byte_array_append (priv->merge_ids, &merge_id, 1);
 614                         gtk_ui_manager_add_ui (parent_priv->ui_manager,
 615                                                merge_id,
 616                                                "/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsMenuAdditions",
 617                                                item_name,
 618                                                refresh_action_name,
 619                                                GTK_UI_MANAGER_MENUITEM,
 620                                                FALSE);
 621                         g_free (refresh_action_name);
 622
 623                         g_signal_connect_data (G_OBJECT (refresh_account_action),
 624                                                "activate",
 625                                                G_CALLBACK (on_refresh_account_action_activated),
 626                                                g_strdup (account_data->account_name),
 627                                                (GClosureNotify) g_free,
 628                                                0);
 629
 630                         /* Create item and add it to the send&receive
 631                            CSM. If there is only one account then
 632                            it'll be no menu */
 633                         if (priv->accounts_popup) {
 634                                 GtkWidget *label = gtk_label_new(NULL);
 635                                 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 636                                 if (default_account && (strcmp(account_data->account_name, default_account) == 0))
 637                                 {
 638                                         gchar *escaped = g_markup_printf_escaped ("<b>%s</b>", display_name);
 639                                         gtk_label_set_markup (GTK_LABEL (label), escaped);
 640                                         g_free (escaped);
 641                                 }
 642                                 else
 643                                 {
 644                                         gtk_label_set_text (GTK_LABEL (label), display_name);
 645                                 }
 646
 647                                 item = gtk_menu_item_new ();
 648                                 gtk_container_add (GTK_CONTAINER (item), label);
 649
 650                                 gtk_menu_shell_prepend (GTK_MENU_SHELL (priv->accounts_popup), GTK_WIDGET (item));
 651                                 g_signal_connect_data (G_OBJECT (item),
 652                                                        "activate",
 653                                                        G_CALLBACK (on_send_receive_csm_activated),
 654                                                        g_strdup (account_data->account_name),
 655                                                        (GClosureNotify) g_free,
 656                                                        0);
 657                         }
 658                         g_free (item_name);
 659                 }
 660
 661                 /* Frees */
 662                 g_free (display_name);
 663         }
 664
 665         gtk_ui_manager_insert_action_group (parent_priv->ui_manager, priv->view_additions_group, 1);
 666
 667         /* We cannot do this in the loop above because this relies on the action
 668          * group being inserted. This makes the default account appear in bold.
 669          * I agree it is a rather ugly way, but I don't see another possibility. armin. */
 670         for (i = 0; i < num_accounts; i++) {
 671                 ModestAccountData *account_data = (ModestAccountData *) g_slist_nth_data (accounts, i);
 672
 673                 if(account_data->account_name && default_account &&
 674                    strcmp (account_data->account_name, default_account) == 0) {
 675                         gchar *item_name = g_strconcat (account_data->account_name, "Menu", NULL);
 676
 677                         gchar *path = g_strconcat ("/MenuBar/ViewMenu/ViewMenuAdditions/", item_name, NULL);
 678                         GtkWidget *item = gtk_ui_manager_get_widget (parent_priv->ui_manager, path);
 679                         g_free(path);
 680
 681                         if (item) {
 682                                 GtkWidget *child = gtk_bin_get_child (GTK_BIN (item));
 683                                 if (GTK_IS_LABEL (child)) {
 684                                         const gchar *cur_name = gtk_label_get_text (GTK_LABEL (child));
 685                                         gchar *bold_name = g_markup_printf_escaped("<b>%s</b>", cur_name);
 686                                         gtk_label_set_markup (GTK_LABEL (child), bold_name);
 687                                         g_free (bold_name);
 688                                 }
 689                         }
 690
 691                         path = g_strconcat("/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsMenuAdditions/", item_name, NULL);
 692                         item = gtk_ui_manager_get_widget (parent_priv->ui_manager, path);
 693                         g_free (path);
 694
 695                         if (item) {
 696                                 GtkWidget *child = gtk_bin_get_child (GTK_BIN (item));
 697                                 if (GTK_IS_LABEL (child)) {
 698                                         const gchar *cur_name = gtk_label_get_text (GTK_LABEL (child));
 699                                         gchar *bold_name = g_markup_printf_escaped("<b>%s</b>", cur_name);
 700                                         gtk_label_set_markup (GTK_LABEL (child), bold_name);
 701                                         g_free (bold_name);
 702                                 }
 703                         }
 704
 705                         g_free(item_name);
 706                 }
 707
 708                 modest_account_mgr_free_account_data (mgr, account_data);
 709         }
 710
 711         if (priv->accounts_popup) {
 712                 /* Mandatory in order to view the menu contents */
 713                 gtk_widget_show_all (priv->accounts_popup);
 714
 715                 /* Setup tap_and_hold just if was not done before*/
 716                 if (!gtk_menu_get_attach_widget (GTK_MENU (priv->accounts_popup)))
 717                         gtk_widget_tap_and_hold_setup (send_receive_button, priv->accounts_popup, NULL, 0);
 718         }
 719
 720         /* Frees */
 721         g_slist_free (accounts);
 722         g_free (default_account);
 723
 724
 725         /* Make sure that at least one account is viewed if there are any
 726          * accounts, for instance when adding the first account: */
 727         set_at_least_one_account_visible (self);
 728 }
 729
 730 static void
 731 wrap_in_scrolled_window (GtkWidget *win, GtkWidget *widget)
 732 {
 733         if (!gtk_widget_set_scroll_adjustments (widget, NULL, NULL))
 734                 gtk_scrolled_window_add_with_viewport
 735                         (GTK_SCROLLED_WINDOW(win), widget);
 736         else
 737                 gtk_container_add (GTK_CONTAINER(win),
 738                                    widget);
 739 }
 740
 741
 742 typedef struct {
 743         TnySendQueue *queue;
 744         guint signal;
 745 } QueueErrorSignal;
 746
 747 static void
 748 modest_main_window_cleanup_queue_error_signals (ModestMainWindow *self)
 749 {
 750         ModestMainWindowPrivate *priv = MODEST_MAIN_WINDOW_GET_PRIVATE (self);
 751
 752         GList *oerrsignals = priv->queue_err_signals;
 753         while (oerrsignals) {
 754                 QueueErrorSignal *esignal = (QueueErrorSignal *) oerrsignals->data;
 755                 g_signal_handler_disconnect (esignal->queue, esignal->signal);
 756                 g_slice_free (QueueErrorSignal, esignal);
 757                 oerrsignals = g_list_next (oerrsignals);
 758         }
 759         g_list_free (priv->queue_err_signals);
 760         priv->queue_err_signals = NULL;
 761 }
 762
 763
 764 static void
 765 _folder_view_csm_menu_activated (GtkWidget *widget, gpointer user_data)
 766 {
 767         g_return_if_fail (MODEST_IS_MAIN_WINDOW (user_data));
 768
 769         /* Update dimmed */
 770         modest_window_check_dimming_rules_group (MODEST_WINDOW (user_data), "ModestMenuDimmingRules");
 771 }
 772
 773 static void
 774 _header_view_csm_menu_activated (GtkWidget *widget, gpointer user_data)
 775 {
 776         g_return_if_fail (MODEST_IS_MAIN_WINDOW (user_data));
 777
 778         /* Update visibility */
 779
 780         /* Update dimmed */
 781         modest_window_check_dimming_rules_group (MODEST_WINDOW (user_data), "ModestMenuDimmingRules");
 782 }
 783
 784 static void
 785 modest_main_window_disconnect_signals (ModestWindow *self)
 786 {
 787         ModestMainWindowPrivate *priv;
 788         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 789
 790         modest_signal_mgr_disconnect_all_and_destroy (priv->sighandlers);
 791         priv->sighandlers = NULL;
 792 }
 793
 794 static void
 795 connect_signals (ModestMainWindow *self)
 796 {
 797         ModestWindowPrivate *parent_priv;
 798         ModestMainWindowPrivate *priv;
 799         GtkWidget *menu;
 800
 801         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 802         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 803
 804         /* folder view */
 805
 806         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
 807                                                        G_OBJECT(priv->folder_view), "key-press-event",
 808                                                        G_CALLBACK(on_inner_widgets_key_pressed), self);
 809         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers, G_OBJECT(priv->folder_view), "folder_selection_changed",
 810                                                        G_CALLBACK (modest_main_window_on_folder_selection_changed), self);
 811         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->folder_view), "folder-display-name-changed",
 812                                                        G_CALLBACK (modest_ui_actions_on_folder_display_name_changed), self);
 813         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (priv->folder_view), "focus-in-event",
 814                                                        G_CALLBACK (on_folder_view_focus_in), self);
 815
 816         /* Folder view CSM */
 817         menu = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/FolderViewCSM");
 818         gtk_widget_tap_and_hold_setup (GTK_WIDGET (priv->folder_view), menu, NULL, 0);
 819         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers, G_OBJECT(priv->folder_view), "tap-and-hold",
 820                                                        G_CALLBACK(_folder_view_csm_menu_activated),
 821                                                        self);
 822         /* header view */
 823         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "header_selected",
 824                                                        G_CALLBACK(modest_ui_actions_on_header_selected), self);
 825         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "header_activated",
 826                                                        G_CALLBACK(modest_ui_actions_on_header_activated), self);
 827         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "item_not_found",
 828                                                        G_CALLBACK(modest_ui_actions_on_item_not_found), self);
 829         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "key-press-event",
 830                                                        G_CALLBACK(on_inner_widgets_key_pressed), self);
 831         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "msg_count_changed",
 832                                                        G_CALLBACK(on_msg_count_changed), self);
 833         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (priv->header_view), "focus-in-event",
 834                                                        G_CALLBACK (on_header_view_focus_in), self);
 835
 836         /* Header view CSM */
 837         menu = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/HeaderViewCSM");
 838         gtk_widget_tap_and_hold_setup (GTK_WIDGET (priv->header_view), menu, NULL, 0);
 839         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "tap-and-hold",
 840                                                        G_CALLBACK(_header_view_csm_menu_activated),
 841                                                        self);
 842
 843         /* window */
 844         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (self), "window-state-event",
 845                           G_CALLBACK (modest_main_window_window_state_event),
 846                           NULL);
 847
 848         /* Mail Operation Queue */
 849         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (modest_runtime_get_mail_operation_queue ()),
 850                                                        "queue-changed", G_CALLBACK (on_queue_changed), self);
 851
 852         /* Track changes in the device name */
 853         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(modest_runtime_get_conf ()),
 854                                                        "key_changed", G_CALLBACK (on_configuration_key_changed),
 855                                                        self);
 856
 857         /* Track account changes. We need to refresh the toolbar */
 858         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (modest_runtime_get_account_store ()),
 859                                                        "account_inserted", G_CALLBACK (on_account_inserted),
 860                                                        self);
 861         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (modest_runtime_get_account_store ()),
 862                                                        "account_removed", G_CALLBACK (on_account_removed),
 863                                                        self);
 864
 865         /* We need to refresh the send & receive menu to change the bold
 866          * account when the default account changes. */
 867         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
 868                                                        G_OBJECT (modest_runtime_get_account_mgr ()),
 869                                                        "default_account_changed",
 870                                                        G_CALLBACK (on_default_account_changed),
 871                                                        self);
 872
 873         /* Account store */
 874         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (modest_runtime_get_account_store()),
 875                                                        "password_requested",
 876                                                        G_CALLBACK (modest_ui_actions_on_password_requested), self);
 877 }
 878
 879 #if 0
 880 /** Idle handler, to send/receive at startup .*/
 881 gboolean
 882 sync_accounts_cb (ModestMainWindow *win)
 883 {
 884         modest_ui_actions_do_send_receive (NULL, MODEST_WINDOW (win));
 885         return FALSE; /* Do not call this idle handler again. */
 886 }
 887 #endif
 888
 889 static void
 890 on_hildon_program_is_topmost_notify(GObject *self,
 891                                     GParamSpec *propert_param, gpointer user_data)
 892 {
 893         HildonProgram *app = HILDON_PROGRAM (self);
 894
 895         /*
 896         ModestWindow* self = MODEST_WINDOW(user_data);
 897         */
 898
 899         /* Note that use of hildon_program_set_can_hibernate()
 900          * is generally referred to as "setting the killable flag",
 901          * though hibernation does not seem equal to death.
 902          * murrayc */
 903
 904         if (hildon_program_get_is_topmost (app)) {
 905                 /* Prevent hibernation when the progam comes to the foreground,
 906                  * because hibernation should only happen when the application
 907                  * is in the background: */
 908                 hildon_program_set_can_hibernate (app, FALSE);
 909         } else {
 910                 /* Allow hibernation if the program has gone to the background: */
 911
 912                 /* However, prevent hibernation while the settings are being changed: */
 913                 const gboolean hibernation_prevented =
 914                         modest_window_mgr_get_hibernation_is_prevented (
 915         modest_runtime_get_window_mgr ());
 916
 917                 if (hibernation_prevented)
 918                         hildon_program_set_can_hibernate (app, FALSE);
 919                 else {
 920                         /* Allow hibernation, after saving the state: */
 921                         modest_osso_save_state();
 922                         hildon_program_set_can_hibernate (app, TRUE);
 923                 }
 924         }
 925
 926 }
 927
 928 static void
 929 modest_main_window_on_show (GtkWidget *self, gpointer user_data)
 930 {
 931         GtkWidget *folder_win = (GtkWidget *) user_data;
 932         ModestMainWindowPrivate *priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 933
 934         priv->folder_view = MODEST_FOLDER_VIEW (modest_platform_create_folder_view (NULL));
 935         wrap_in_scrolled_window (folder_win, GTK_WIDGET(priv->folder_view));
 936 /*      wrap_in_scrolled_window (priv->contents_widget, GTK_WIDGET(priv->header_view)); */
 937
 938         gtk_widget_show (GTK_WIDGET (priv->folder_view));
 939
 940         /* Connect signals */
 941         connect_signals ((ModestMainWindow*)self);
 942
 943         /* Set account store */
 944         tny_account_store_view_set_account_store (TNY_ACCOUNT_STORE_VIEW (priv->folder_view),
 945                                                   TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
 946
 947         /* Load previous osso state, for instance if we are being restored from
 948          * hibernation:  */
 949         modest_osso_load_state ();
 950
 951         /* Restore window & widget settings */
 952
 953         restore_settings (MODEST_MAIN_WINDOW(self), TRUE);
 954
 955         /* The UI spec wants us to show a connection dialog when the application is
 956          * started by the user, if there is no connection.
 957          * Do this before showing the account wizard,
 958          * because wizard needs a connection to discover capabilities. */
 959          modest_platform_connect_and_wait (GTK_WINDOW (self), NULL);
 960
 961         /* Check if accounts exist and show the account wizard if not */
 962         gboolean accounts_exist =
 963                 modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
 964
 965         if (!accounts_exist) {
 966                 /* This is necessary to have the main window shown behind the dialog
 967                 It's an ugly hack... jschmid */
 968                 gtk_widget_show_all(GTK_WIDGET(self));
 969                 modest_ui_actions_on_accounts (NULL, MODEST_WINDOW(self));
 970         } else {
 971                 GSList *accounts;
 972                 GtkAction *send_receive_all;
 973                 ModestWindowPrivate *parent_priv = MODEST_WINDOW_GET_PRIVATE (self);
 974                 accounts = modest_account_mgr_account_names (modest_runtime_get_account_mgr (), TRUE);
 975                 send_receive_all = gtk_ui_manager_get_action (parent_priv->ui_manager,
 976                                                               "/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsSendReceiveAllMenu");
 977                 gtk_action_set_visible (send_receive_all, g_slist_length (accounts) > 1);
 978                 modest_account_mgr_free_account_names (accounts);
 979         }
 980 }
 981
 982 ModestWindow *
 983 modest_main_window_new (void)
 984 {
 985         ModestMainWindow *self = NULL;
 986         ModestMainWindowPrivate *priv = NULL;
 987         ModestWindowPrivate *parent_priv = NULL;
 988         GtkWidget *folder_win = NULL;
 989         ModestDimmingRulesGroup *menu_rules_group = NULL;
 990         ModestDimmingRulesGroup *toolbar_rules_group = NULL;
 991         GtkActionGroup *action_group = NULL;
 992         GError *error = NULL;
 993         ModestConf *conf = NULL;
 994         GtkAction *action = NULL;
 995         GdkPixbuf *window_icon;
 996
 997         self  = MODEST_MAIN_WINDOW(g_object_new(MODEST_TYPE_MAIN_WINDOW, NULL));
 998         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 999         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
1000
1001         parent_priv->ui_manager = gtk_ui_manager_new();
1002         parent_priv->ui_dimming_manager = modest_ui_dimming_manager_new();
1003
1004         action_group = gtk_action_group_new ("ModestMainWindowActions");
1005         gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
1006
1007         menu_rules_group = modest_dimming_rules_group_new ("ModestMenuDimmingRules", FALSE);
1008         toolbar_rules_group = modest_dimming_rules_group_new ("ModestToolbarDimmingRules", TRUE);
1009
1010         /* Add common actions */
1011         gtk_action_group_add_actions (action_group,
1012                                       modest_action_entries,
1013                                       G_N_ELEMENTS (modest_action_entries),
1014                                       self);
1015
1016         gtk_action_group_add_actions (action_group,
1017                                       modest_folder_view_action_entries,
1018                                       G_N_ELEMENTS (modest_folder_view_action_entries),
1019                                       self);
1020
1021         gtk_action_group_add_actions (action_group,
1022                                       modest_header_view_action_entries,
1023                                       G_N_ELEMENTS (modest_header_view_action_entries),
1024                                       self);
1025
1026         gtk_action_group_add_toggle_actions (action_group,
1027                                              modest_toggle_action_entries,
1028                                              G_N_ELEMENTS (modest_toggle_action_entries),
1029                                              self);
1030
1031         gtk_action_group_add_toggle_actions (action_group,
1032                                              modest_main_window_toggle_action_entries,
1033                                              G_N_ELEMENTS (modest_main_window_toggle_action_entries),
1034                                              self);
1035
1036         gtk_ui_manager_insert_action_group (parent_priv->ui_manager, action_group, 0);
1037         g_object_unref (action_group);
1038
1039         /* Load the UI definition */
1040         gtk_ui_manager_add_ui_from_file (parent_priv->ui_manager,
1041                                          MODEST_UIDIR "modest-main-window-ui.xml", &error);
1042         if (error != NULL) {
1043                 g_warning ("Could not merge modest-ui.xml: %s", error->message);
1044                 g_error_free (error);
1045                 error = NULL;
1046         }
1047
1048         /* Add common dimming rules */
1049         modest_dimming_rules_group_add_rules (menu_rules_group,
1050                                               modest_main_window_menu_dimming_entries,
1051                                               G_N_ELEMENTS (modest_main_window_menu_dimming_entries),
1052                                               MODEST_WINDOW (self));
1053         modest_dimming_rules_group_add_rules (toolbar_rules_group,
1054                                               modest_main_window_toolbar_dimming_entries,
1055                                               G_N_ELEMENTS (modest_main_window_toolbar_dimming_entries),
1056                                               MODEST_WINDOW (self));
1057
1058         /* Insert dimming rules group for this window */
1059         modest_ui_dimming_manager_insert_rules_group (parent_priv->ui_dimming_manager, menu_rules_group);
1060         modest_ui_dimming_manager_insert_rules_group (parent_priv->ui_dimming_manager, toolbar_rules_group);
1061         g_object_unref (menu_rules_group);
1062         g_object_unref (toolbar_rules_group);
1063
1064         /* Add accelerators */
1065         gtk_window_add_accel_group (GTK_WINDOW (self),
1066                                     gtk_ui_manager_get_accel_group (parent_priv->ui_manager));
1067
1068         /* Menubar. Update the state of some toggles */
1069         parent_priv->menubar = modest_maemo_utils_menubar_to_menu (parent_priv->ui_manager);
1070         conf = modest_runtime_get_conf ();
1071         action = gtk_ui_manager_get_action (parent_priv->ui_manager,
1072                                             "/MenuBar/ViewMenu/ViewShowToolbarMainMenu/ViewShowToolbarNormalScreenMenu");
1073         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
1074                                       modest_conf_get_bool (conf, MODEST_CONF_MAIN_WINDOW_SHOW_TOOLBAR, NULL));
1075         action = gtk_ui_manager_get_action (parent_priv->ui_manager,
1076                                             "/MenuBar/ViewMenu/ViewShowToolbarMainMenu/ViewShowToolbarFullScreenMenu");
1077         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
1078                                       modest_conf_get_bool (conf, MODEST_CONF_MAIN_WINDOW_SHOW_TOOLBAR_FULLSCREEN, NULL));
1079         hildon_window_set_menu (HILDON_WINDOW (self), GTK_MENU (parent_priv->menubar));
1080         gtk_widget_show (parent_priv->menubar);
1081
1082         /* Get device name */
1083         modest_maemo_utils_get_device_name ();
1084
1085         /* header view */
1086         priv->header_view =
1087                 MODEST_HEADER_VIEW (modest_header_view_new (NULL, MODEST_HEADER_VIEW_STYLE_DETAILS));
1088         if (!priv->header_view)
1089                 g_printerr ("modest: cannot instantiate header view\n");
1090         modest_header_view_set_style (priv->header_view, MODEST_HEADER_VIEW_STYLE_TWOLINES);
1091         modest_widget_memory_restore (modest_runtime_get_conf (), G_OBJECT(priv->header_view),
1092                                       MODEST_CONF_HEADER_VIEW_KEY);
1093
1094         /* Other style properties of header view */
1095         g_object_set (G_OBJECT (priv->header_view),
1096                       "rules-hint", FALSE,
1097                       NULL);
1098         /* gtk_widget_show (priv->header_view); */
1099
1100         /* Empty view */
1101         priv->empty_view = create_empty_view ();
1102         gtk_widget_show (priv->empty_view);
1103
1104         /* Create scrolled windows */
1105         folder_win = gtk_scrolled_window_new (NULL, NULL);
1106         priv->contents_widget = gtk_scrolled_window_new (NULL, NULL);
1107         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (folder_win),
1108                                         GTK_POLICY_NEVER,
1109                                         GTK_POLICY_AUTOMATIC);
1110         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->contents_widget),
1111                                         GTK_POLICY_NEVER,
1112                                         GTK_POLICY_AUTOMATIC);
1113         /* gtk_widget_show (priv->contents_widget); */
1114
1115         /* paned */
1116         priv->main_paned = gtk_hpaned_new ();
1117         gtk_paned_pack1 (GTK_PANED(priv->main_paned), folder_win, TRUE, TRUE);
1118         gtk_paned_pack2 (GTK_PANED(priv->main_paned), priv->contents_widget, TRUE, TRUE);
1119         gtk_tree_view_columns_autosize (GTK_TREE_VIEW(priv->header_view));
1120
1121         /* putting it all together... */
1122         priv->main_vbox = gtk_vbox_new (FALSE, 6);
1123         gtk_box_pack_start (GTK_BOX(priv->main_vbox), priv->main_paned, TRUE, TRUE,0);
1124         gtk_widget_show (priv->main_vbox);
1125
1126         gtk_container_add (GTK_CONTAINER(self), priv->main_vbox);
1127
1128         HildonProgram *app = hildon_program_get_instance ();
1129         hildon_program_add_window (app, HILDON_WINDOW (self));
1130
1131         g_signal_connect (G_OBJECT(app), "notify::is-topmost",
1132                 G_CALLBACK (on_hildon_program_is_topmost_notify), self);
1133
1134         g_signal_connect (G_OBJECT(self), "show",
1135                           G_CALLBACK (modest_main_window_on_show), folder_win);
1136
1137         /* Set window icon */
1138         window_icon = modest_platform_get_icon (MODEST_APP_ICON);
1139         if (window_icon) {
1140                 gtk_window_set_icon (GTK_WINDOW (self), window_icon);
1141                 g_object_unref (window_icon);
1142         }
1143
1144         /* Dont't restore settings here,
1145          * because it requires a gtk_widget_show(),
1146          * and we don't want to do that until later,
1147          * so that the UI is not visible for non-menu D-Bus activation.
1148          */
1149         /* restore_settings (MODEST_MAIN_WINDOW(self), FALSE); */
1150
1151         return MODEST_WINDOW(self);
1152 }
1153
1154 gboolean
1155 modest_main_window_close_all (ModestMainWindow *self)
1156 {
1157         GtkWidget *note;
1158         GtkResponseType response;
1159
1160         /* Create the confirmation dialog MSG-NOT308 */
1161         note = hildon_note_new_confirmation_add_buttons (GTK_WINDOW (self),
1162                                                          _("emev_nc_close_windows"),
1163                                                          _("mcen_bd_yes"), GTK_RESPONSE_YES,
1164                                                          _("mcen_bd_no"), GTK_RESPONSE_NO,
1165                                                          NULL);
1166
1167         response = gtk_dialog_run (GTK_DIALOG (note));
1168         gtk_widget_destroy (GTK_WIDGET (note));
1169
1170         if (response == GTK_RESPONSE_YES)
1171                 return TRUE;
1172         else
1173                 return FALSE;
1174 }
1175
1176
1177 void
1178 modest_main_window_set_style (ModestMainWindow *self,
1179                               ModestMainWindowStyle style)
1180 {
1181         ModestMainWindowPrivate *priv;
1182         ModestWindowPrivate *parent_priv;
1183         GtkAction *action;
1184         gboolean active;
1185
1186         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
1187
1188         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1189         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
1190
1191         /* no change -> nothing to do */
1192         if (priv->style == style)
1193                 return;
1194
1195        /* Get toggle button and update the state if needed. This will
1196           happen only when the set_style is not invoked from the UI,
1197           for example when it's called from widget memory */
1198        action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToggleFolders");
1199        active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
1200        if ((active && style == MODEST_MAIN_WINDOW_STYLE_SIMPLE) ||
1201            (!active && style == MODEST_MAIN_WINDOW_STYLE_SPLIT)) {
1202                g_signal_handlers_block_by_func (action, modest_ui_actions_toggle_folders_view, self);
1203                gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), !active);
1204                g_signal_handlers_unblock_by_func (action, modest_ui_actions_toggle_folders_view, self);
1205        }
1206
1207         priv->style = style;
1208         switch (style) {
1209         case MODEST_MAIN_WINDOW_STYLE_SIMPLE:
1210                 /* Remove main paned */
1211                 g_object_ref (priv->main_paned);
1212                 gtk_container_remove (GTK_CONTAINER (priv->main_vbox), priv->main_paned);
1213
1214                 /* Reparent the contents widget to the main vbox */
1215                 gtk_widget_reparent (priv->contents_widget, priv->main_vbox);
1216
1217                 break;
1218         case MODEST_MAIN_WINDOW_STYLE_SPLIT:
1219                 /* Remove header view */
1220                 g_object_ref (priv->contents_widget);
1221                 gtk_container_remove (GTK_CONTAINER (priv->main_vbox), priv->contents_widget);
1222
1223                 /* Reparent the main paned */
1224                 gtk_paned_add2 (GTK_PANED (priv->main_paned), priv->contents_widget);
1225                 gtk_container_add (GTK_CONTAINER (priv->main_vbox), priv->main_paned);
1226
1227                 break;
1228         default:
1229                 g_return_if_reached ();
1230         }
1231
1232         /* Let header view grab the focus if it's being shown */
1233         if (priv->contents_style == MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
1234                 gtk_widget_grab_focus (GTK_WIDGET (priv->header_view));
1235         else
1236                 gtk_widget_grab_focus (GTK_WIDGET (priv->contents_widget));
1237
1238         /* Show changes */
1239         gtk_widget_show_all (GTK_WIDGET (priv->main_vbox));
1240 }
1241
1242 ModestMainWindowStyle
1243 modest_main_window_get_style (ModestMainWindow *self)
1244 {
1245         ModestMainWindowPrivate *priv;
1246
1247         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (self), -1);
1248
1249         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1250         return priv->style;
1251 }
1252
1253
1254
1255 static gboolean
1256 modest_main_window_window_state_event (GtkWidget *widget, GdkEventWindowState *event, gpointer userdata)
1257 {
1258         if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) {
1259                 ModestWindowPrivate *parent_priv;
1260                 ModestWindowMgr *mgr;
1261                 gboolean is_fullscreen;
1262                 GtkAction *fs_toggle_action;
1263                 gboolean active;
1264
1265                 mgr = modest_runtime_get_window_mgr ();
1266
1267                 is_fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
1268
1269                 parent_priv = MODEST_WINDOW_GET_PRIVATE (widget);
1270
1271                 fs_toggle_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ViewMenu/ViewToggleFullscreenMenu");
1272                 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (fs_toggle_action)))?1:0;
1273                 if (is_fullscreen != active) {
1274                         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (fs_toggle_action), is_fullscreen);
1275                 }
1276         }
1277
1278         return FALSE;
1279
1280 }
1281
1282 static void
1283 set_homogeneous (GtkWidget *widget,
1284                  gpointer data)
1285 {
1286         gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), TRUE);
1287         gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), TRUE);
1288 }
1289
1290 static void
1291 modest_main_window_show_toolbar (ModestWindow *self,
1292                                  gboolean show_toolbar)
1293 {
1294         ModestMainWindowPrivate *priv = NULL;
1295         ModestWindowPrivate *parent_priv = NULL;
1296         GtkWidget *reply_button = NULL, *menu = NULL;
1297         GtkWidget *placeholder = NULL;
1298         gint insert_index;
1299         const gchar *action_name;
1300         GtkAction *action;
1301
1302         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
1303         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1304         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
1305
1306         /* Set optimized view status */
1307         priv->optimized_view = !show_toolbar;
1308
1309         if (!parent_priv->toolbar) {
1310                 parent_priv->toolbar = gtk_ui_manager_get_widget (parent_priv->ui_manager,
1311                                                                   "/ToolBar");
1312                 gtk_widget_set_no_show_all (parent_priv->toolbar, TRUE);
1313
1314                 /* Set homogeneous toolbar */
1315                 gtk_container_foreach (GTK_CONTAINER (parent_priv->toolbar),
1316                                        set_homogeneous, NULL);
1317
1318                 priv->progress_toolitem = GTK_WIDGET (gtk_tool_item_new ());
1319                 priv->cancel_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarCancel");
1320                 priv->refresh_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarSendReceive");
1321                 priv->sort_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarSort");
1322                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
1323                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
1324                 gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE);
1325                 gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE);
1326
1327                 /* Add ProgressBar (Transfer toolbar) */
1328                 priv->progress_bar = modest_progress_bar_widget_new ();
1329                 gtk_widget_set_no_show_all (priv->progress_bar, TRUE);
1330                 placeholder = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ProgressBarView");
1331                 insert_index = gtk_toolbar_get_item_index(GTK_TOOLBAR (parent_priv->toolbar), GTK_TOOL_ITEM(placeholder));
1332                 gtk_container_add (GTK_CONTAINER (priv->progress_toolitem), priv->progress_bar);
1333                 gtk_toolbar_insert(GTK_TOOLBAR(parent_priv->toolbar), GTK_TOOL_ITEM (priv->progress_toolitem), insert_index);
1334
1335                 /* Connect cancel 'clicked' signal to abort progress mode */
1336                 g_signal_connect(priv->cancel_toolitem, "clicked",
1337                                  G_CALLBACK(cancel_progressbar),
1338                                  self);
1339
1340                 /* Add it to the observers list */
1341                 priv->progress_widgets = g_slist_prepend(priv->progress_widgets, priv->progress_bar);
1342
1343                 /* Add to window */
1344                 hildon_window_add_toolbar (HILDON_WINDOW (self),
1345                                            GTK_TOOLBAR (parent_priv->toolbar));
1346
1347                 /* Set reply button tap and hold menu */
1348                 reply_button = gtk_ui_manager_get_widget (parent_priv->ui_manager,
1349                                                           "/ToolBar/ToolbarMessageReply");
1350                 menu = gtk_ui_manager_get_widget (parent_priv->ui_manager,
1351                                                   "/ToolbarReplyCSM");
1352                 gtk_widget_tap_and_hold_setup (GTK_WIDGET (reply_button), menu, NULL, 0);
1353
1354                 /* Set send & receive button tap and hold menu */
1355                 update_menus (MODEST_MAIN_WINDOW (self));
1356         }
1357
1358         if (show_toolbar) {
1359                 /* Quick hack: this prevents toolbar icons "dance" when progress bar show status is changed */
1360                 /* TODO: resize mode migth be GTK_RESIZE_QUEUE, in order to avoid unneccesary shows */
1361                 gtk_container_set_resize_mode (GTK_CONTAINER(parent_priv->toolbar), GTK_RESIZE_IMMEDIATE);
1362
1363                 gtk_widget_show (GTK_WIDGET (parent_priv->toolbar));
1364                 set_toolbar_mode (MODEST_MAIN_WINDOW(self), TOOLBAR_MODE_NORMAL);
1365         } else {
1366                 gtk_widget_hide (GTK_WIDGET (parent_priv->toolbar));
1367
1368         }
1369
1370         /* Update also the actions (to update the toggles in the
1371            menus), we have to do it manually because some other window
1372            of the same time could have changed it (remember that the
1373            toolbar fullscreen mode is shared by all the windows of the
1374            same type */
1375         if (modest_window_mgr_get_fullscreen_mode (modest_runtime_get_window_mgr ()))
1376                 action_name = "/MenuBar/ViewMenu/ViewShowToolbarMenu/ViewShowToolbarFullScreenMenu";
1377         else
1378                 action_name = "/MenuBar/ViewMenu/ViewShowToolbarMenu/ViewShowToolbarNormalScreenMenu";
1379
1380         action = gtk_ui_manager_get_action (parent_priv->ui_manager, action_name);
1381         modest_maemo_toggle_action_set_active_block_notify (GTK_TOGGLE_ACTION (action),
1382                                                             show_toolbar);
1383 }
1384
1385 static void
1386 on_account_inserted (TnyAccountStore *accoust_store,
1387                      TnyAccount *account,
1388                      gpointer user_data)
1389 {
1390         update_menus (MODEST_MAIN_WINDOW (user_data));
1391 }
1392
1393 static void
1394 on_default_account_changed (ModestAccountMgr* mgr,
1395                             gpointer user_data)
1396 {
1397         update_menus (MODEST_MAIN_WINDOW (user_data));
1398 }
1399
1400 static void
1401 on_account_removed (TnyAccountStore *accoust_store,
1402                      TnyAccount *account,
1403                      gpointer user_data)
1404 {
1405         update_menus (MODEST_MAIN_WINDOW (user_data));
1406 }
1407
1408 /*
1409  * This function manages the key events used to navigate between
1410  * header and folder views (when the window is in split view)
1411  *
1412  * FROM         KEY        ACTION
1413  * -------------------------------------------------
1414  * HeaderView   GDK_Left   Move focus to folder view
1415  * FolderView   GDK_Right  Move focus to header view
1416  *
1417  * There is no need to scroll to selected row, the widgets will be the
1418  * responsibles of doing that (probably managing the focus-in event
1419  */
1420 static gboolean
1421 on_inner_widgets_key_pressed (GtkWidget *widget,
1422                               GdkEventKey *event,
1423                               gpointer user_data)
1424 {
1425         ModestMainWindowPrivate *priv;
1426
1427         priv = MODEST_MAIN_WINDOW_GET_PRIVATE (user_data);
1428
1429         /* Do nothing if we're in SIMPLE style */
1430         if (priv->style == MODEST_MAIN_WINDOW_STYLE_SIMPLE)
1431                 return FALSE;
1432
1433         if (MODEST_IS_HEADER_VIEW (widget) && event->keyval == GDK_Left)
1434                 gtk_widget_grab_focus (GTK_WIDGET (priv->folder_view));
1435         else if (MODEST_IS_FOLDER_VIEW (widget) && event->keyval == GDK_Right)
1436                 gtk_widget_grab_focus (GTK_WIDGET (priv->header_view));
1437
1438         return FALSE;
1439 }
1440
1441 static void
1442 set_alignment (GtkWidget *widget,
1443                gpointer data)
1444 {
1445         gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0);
1446         gtk_misc_set_padding (GTK_MISC (widget), 0, 0);
1447 }
1448
1449 static GtkWidget *
1450 create_empty_view (void)
1451 {
1452         GtkLabel *label = NULL;
1453         GtkWidget *align = NULL;
1454
1455         align = gtk_alignment_new(XALIGN, YALIGN, XSPACE, YSPACE);
1456         label = GTK_LABEL(gtk_label_new (_("mcen_ia_nomessages")));
1457         gtk_label_set_justify (label, GTK_JUSTIFY_CENTER);
1458         gtk_container_add (GTK_CONTAINER (align), GTK_WIDGET(label));
1459
1460         return GTK_WIDGET(align);
1461 }
1462
1463 static GtkWidget *
1464 create_details_widget (GtkWidget *styled_widget, TnyAccount *account)
1465 {
1466         /* TODO: Clean up this function. It's a mess, with lots of copy/paste. murrayc. */
1467
1468         GtkWidget *vbox;
1469         GtkWidget *label_w;
1470         gchar *label;
1471         gchar *gray_color_markup;
1472
1473         vbox = gtk_vbox_new (FALSE, 0);
1474
1475         /* Obtain the secondary text color. We need a realized widget, that's why
1476            we get styled_widget from outside */
1477 #ifndef MODEST_HAVE_HILDON0_WIDGETS
1478         GdkColor color;
1479         gtk_style_lookup_color (styled_widget->style, "SecondaryTextColor", &color);
1480         gray_color_markup = modest_text_utils_get_color_string (&color);
1481 #else
1482         // gray_color_markup is freed below
1483         gray_color_markup = g_strdup ("#BBBBBB");
1484 #endif
1485         /* Account description: */
1486
1487         if (modest_tny_account_is_virtual_local_folders (account)
1488                 || (modest_tny_account_is_memory_card_account (account))) {
1489                 gchar *tmp;
1490                 /* Local folders: */
1491
1492                 /* Get device name */
1493                 gchar *device_name = NULL;
1494                 if (modest_tny_account_is_virtual_local_folders (account))
1495                         device_name = modest_conf_get_string (modest_runtime_get_conf(),
1496                                                       MODEST_CONF_DEVICE_NAME, NULL);
1497                 else
1498                         device_name = g_strdup (tny_account_get_name (account));
1499
1500                 tmp = g_strdup_printf (_("mcen_fi_localroot_description"), ""); //TODO: Why the ""?
1501                 label = g_markup_printf_escaped ("<span color='%s'>%s</span>%s",
1502                                                  gray_color_markup, tmp, device_name);
1503                 g_free (tmp);
1504                 label_w = gtk_label_new (NULL);
1505                 gtk_label_set_markup (GTK_LABEL (label_w), label);
1506                 gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
1507                 g_free (device_name);
1508                 g_free (label);
1509         } else {
1510                 if(!strcmp (tny_account_get_id (account), MODEST_MMC_ACCOUNT_ID)) {
1511                         gtk_box_pack_start (GTK_BOX (vbox),
1512                                 gtk_label_new (tny_account_get_name (account)),
1513                                 FALSE, FALSE, 0);
1514                 } else {
1515                         /* Other accounts, such as IMAP and POP: */
1516
1517                         GString *proto;
1518                         gchar *tmp;
1519
1520                         /* Put proto in uppercase */
1521                         proto = g_string_new (tny_account_get_proto (account));
1522                         proto = g_string_ascii_up (proto);
1523
1524                         /* note: mcen_fi_localroot_description is something like "%s account"
1525                          * however, we should display "%s account: %s"... therefore, ugly tmp */
1526                         tmp   = g_strdup_printf (_("mcen_fi_remoteroot_account"),proto->str);
1527                         label = g_markup_printf_escaped ("<span color='%s'>%s:</span> %s",
1528                                                          gray_color_markup, tmp, tny_account_get_name (account));
1529                         g_free (tmp);
1530
1531                         label_w = gtk_label_new (NULL);
1532                         gtk_label_set_markup (GTK_LABEL (label_w), label);
1533                         gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
1534                         g_string_free (proto, TRUE);
1535                         g_free (label);
1536                 }
1537         }
1538
1539         /* Message count */
1540         TnyFolderStore *folder_store = TNY_FOLDER_STORE (account);
1541         label = g_markup_printf_escaped ("<span color='%s'>%s:</span> %d",
1542                                          gray_color_markup, _("mcen_fi_rootfolder_messages"),
1543                                          modest_tny_folder_store_get_message_count (folder_store));
1544         label_w = gtk_label_new (NULL);
1545         gtk_label_set_markup (GTK_LABEL (label_w), label);
1546         gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
1547         g_free (label);
1548
1549         /* Folder count */
1550         label = g_markup_printf_escaped ("<span color='%s'>%s</span>: %d",
1551                                          gray_color_markup,
1552                                          _("mcen_fi_rootfolder_folders"),
1553                                          modest_tny_folder_store_get_folder_count (folder_store));
1554         label_w = gtk_label_new (NULL);
1555         gtk_label_set_markup (GTK_LABEL (label_w), label);
1556         gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
1557         g_free (label);
1558
1559         /* Size / Date */
1560         if (modest_tny_account_is_virtual_local_folders (account)
1561                 || modest_tny_account_is_memory_card_account (account)) {
1562
1563                 gchar *size = modest_text_utils_get_display_size (
1564                         modest_tny_folder_store_get_local_size (folder_store));
1565
1566                 label = g_markup_printf_escaped ("<span color='%s'>%s:</span> %s",
1567                                                  gray_color_markup, _("mcen_fi_rootfolder_size"),
1568                                                  size);
1569                 g_free (size);
1570
1571                 label_w = gtk_label_new (NULL);
1572                 gtk_label_set_markup (GTK_LABEL (label_w), label);
1573                 gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
1574                 g_free (label);
1575         } else if (TNY_IS_ACCOUNT(folder_store)) {
1576                 TnyAccount *account = TNY_ACCOUNT(folder_store);
1577
1578                 time_t last_updated;
1579                 gchar *last_updated_string;
1580                 /* Get last updated from configuration */
1581                 last_updated = modest_account_mgr_get_int (modest_runtime_get_account_mgr (),
1582                                                           tny_account_get_id (account),
1583                                                           MODEST_ACCOUNT_LAST_UPDATED,
1584                                                           TRUE);
1585                 if (last_updated > 0)
1586                         last_updated_string = modest_text_utils_get_display_date(last_updated);
1587                 else
1588                         last_updated_string = g_strdup (_("mcen_va_never"));
1589
1590                 label = g_markup_printf_escaped ("<span color='%s'>%s:</span> %s",
1591                                                  gray_color_markup, _("mcen_ti_lastupdated"), last_updated_string);
1592                 label_w = gtk_label_new (NULL);
1593                 gtk_label_set_markup (GTK_LABEL (label_w), label);
1594                 gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
1595                 g_free (last_updated_string);
1596                 g_free (label);
1597         }
1598
1599         g_free (gray_color_markup);
1600
1601         /* Set alignment */
1602         gtk_container_foreach (GTK_CONTAINER (vbox), (GtkCallback) set_alignment, NULL);
1603
1604         return vbox;
1605 }
1606
1607 gboolean
1608 modest_main_window_send_receive_in_progress (ModestMainWindow *self)
1609 {
1610         ModestMainWindowPrivate *priv = NULL;
1611
1612         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (self), FALSE);
1613
1614         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1615
1616         return priv->send_receive_in_progress;
1617 }
1618
1619 void
1620 modest_main_window_notify_send_receive_initied (ModestMainWindow *self)
1621 {
1622         GtkAction *action = NULL;
1623         GtkWidget *widget = NULL;
1624         ModestMainWindowPrivate *priv = NULL;
1625
1626         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
1627         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1628
1629         priv->send_receive_in_progress  = TRUE;
1630
1631         action = modest_window_get_action (MODEST_WINDOW(self), "/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsSendReceiveAllMenu");
1632         gtk_action_set_sensitive (action, FALSE);
1633 /*         action = modest_window_get_action (MODEST_WINDOW(self), "/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsSendReceiveCancelSendingMenu"); */
1634 /*      gtk_action_set_sensitive (action, FALSE); */
1635         widget = modest_window_get_action_widget (MODEST_WINDOW(self), "/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsMenuAdditions");
1636         gtk_widget_set_sensitive (widget, FALSE);
1637 }
1638
1639 void
1640 modest_main_window_notify_send_receive_completed (ModestMainWindow *self)
1641 {
1642         GtkAction *action = NULL;
1643         GtkWidget *widget = NULL;
1644         ModestMainWindowPrivate *priv = NULL;
1645
1646         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
1647         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1648
1649         priv->send_receive_in_progress  = FALSE;
1650
1651         action = modest_window_get_action (MODEST_WINDOW(self), "/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsSendReceiveAllMenu");
1652         gtk_action_set_sensitive (action, TRUE);
1653 /*         action = modest_window_get_action (MODEST_WINDOW(self), "/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsSendReceiveCancelSendingMenu");     */
1654 /*      gtk_action_set_sensitive (action, TRUE); */
1655         widget = modest_window_get_action_widget (MODEST_WINDOW(self), "/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsMenuAdditions");
1656         gtk_widget_set_sensitive (widget, TRUE);
1657 }
1658
1659
1660 static void
1661 on_msg_count_changed (ModestHeaderView *header_view,
1662                       TnyFolder *folder,
1663                       TnyFolderChange *change,
1664                       ModestMainWindow *main_window)
1665 {
1666         gboolean folder_empty = FALSE;
1667         gboolean all_marked_as_deleted = FALSE;
1668         TnyFolderChangeChanged changed;
1669         ModestMainWindowPrivate *priv;
1670
1671         g_return_if_fail (MODEST_IS_MAIN_WINDOW (main_window));
1672         g_return_if_fail (TNY_IS_FOLDER(folder));
1673         g_return_if_fail (TNY_IS_FOLDER_CHANGE(change));
1674         priv = MODEST_MAIN_WINDOW_GET_PRIVATE (main_window);
1675
1676         changed = tny_folder_change_get_changed (change);
1677
1678         /* If something changes */
1679         if ((changed) & TNY_FOLDER_CHANGE_CHANGED_ALL_COUNT)
1680                 folder_empty = (tny_folder_change_get_new_all_count (change) == 0);
1681         else
1682                 folder_empty = (tny_folder_get_all_count (TNY_FOLDER (folder)) == 0);
1683
1684 /*      Check header removed  (hide marked as DELETED headers) */
1685         if (changed & TNY_FOLDER_CHANGE_CHANGED_EXPUNGED_HEADERS) {
1686                 modest_header_view_refilter (MODEST_HEADER_VIEW(priv->header_view));
1687         }
1688
1689         /* Check if all messages are marked to be deleted */
1690         all_marked_as_deleted = modest_header_view_is_empty (header_view);
1691         folder_empty = folder_empty || all_marked_as_deleted ;
1692
1693         /* Set contents style of headers view */
1694         if (folder_empty)  {
1695                 modest_main_window_set_contents_style (main_window,
1696                                                        MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
1697                 gtk_widget_grab_focus (GTK_WIDGET (priv->folder_view));
1698         }
1699         else {
1700                 modest_main_window_set_contents_style (main_window,
1701                                                        MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1702         }
1703 }
1704
1705
1706 void
1707 modest_main_window_set_contents_style (ModestMainWindow *self,
1708                                        ModestMainWindowContentsStyle style)
1709 {
1710         ModestMainWindowPrivate *priv;
1711
1712         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
1713
1714         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1715
1716         /* We allow to set the same content style than the previously
1717            set if there are details, because it could happen when we're
1718            selecting different accounts consecutively */
1719         if ((priv->contents_style == style) &&
1720             (priv->contents_style != MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS))
1721                 return;
1722
1723         /* Remove previous child. Delete it if it was an account
1724            details widget */
1725         GtkWidget *content = gtk_bin_get_child (GTK_BIN (priv->contents_widget));
1726         if (content) {
1727                 if (priv->contents_style == MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
1728                         g_object_ref (content);
1729                 else if (priv->contents_style == MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY) {
1730                         g_object_ref (priv->empty_view);
1731                         gtk_container_remove (GTK_CONTAINER (content), priv->empty_view);
1732                 }
1733
1734                 gtk_container_remove (GTK_CONTAINER (priv->contents_widget), content);
1735         }
1736
1737         priv->contents_style = style;
1738
1739         switch (priv->contents_style) {
1740         case MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS:
1741                 wrap_in_scrolled_window (priv->contents_widget, GTK_WIDGET (priv->header_view));
1742                 modest_maemo_set_thumbable_scrollbar (GTK_SCROLLED_WINDOW(priv->contents_widget),
1743                                                       TRUE);
1744                 break;
1745         case MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS:
1746         {
1747                 /* if we're started without main win, there may not be a folder
1748                  * view. this fixes a GLib-Critical */
1749                 if (priv->folder_view) {
1750                         TnyFolderStore *selected_folderstore =
1751                                 modest_folder_view_get_selected (priv->folder_view);
1752                         if (TNY_IS_ACCOUNT (selected_folderstore)) {
1753                                 priv->details_widget = create_details_widget (GTK_WIDGET (self),
1754                                                                 TNY_ACCOUNT (selected_folderstore));
1755
1756                                 wrap_in_scrolled_window (priv->contents_widget,
1757                                                          priv->details_widget);
1758                         }
1759                         g_object_unref (selected_folderstore);
1760                         modest_maemo_set_thumbable_scrollbar (GTK_SCROLLED_WINDOW(priv->contents_widget),
1761                                                               FALSE);
1762                 }
1763                 break;
1764         }
1765         case MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY:
1766                 wrap_in_scrolled_window (priv->contents_widget, GTK_WIDGET (priv->empty_view));
1767                 modest_maemo_set_thumbable_scrollbar (GTK_SCROLLED_WINDOW(priv->contents_widget),
1768                                                       FALSE);
1769                 break;
1770         default:
1771                 g_return_if_reached ();
1772         }
1773
1774         /* Show */
1775         gtk_widget_show_all (priv->contents_widget);
1776 }
1777
1778 ModestMainWindowContentsStyle
1779 modest_main_window_get_contents_style (ModestMainWindow *self)
1780 {
1781         ModestMainWindowPrivate *priv;
1782
1783         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (self), -1);
1784
1785         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1786         return priv->contents_style;
1787 }
1788
1789
1790 static void
1791 on_configuration_key_changed (ModestConf* conf,
1792                               const gchar *key,
1793                               ModestConfEvent event,
1794                               ModestConfNotificationId id,
1795                               ModestMainWindow *self)
1796 {
1797         ModestMainWindowPrivate *priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1798         TnyAccount *account = NULL;
1799
1800         if (!key || strcmp (key, MODEST_CONF_DEVICE_NAME))
1801                 return;
1802
1803         if (priv->contents_style != MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS)
1804                 return;
1805
1806         if (priv->folder_view)
1807                 account = (TnyAccount *) modest_folder_view_get_selected (priv->folder_view);
1808
1809         if (account && TNY_IS_ACCOUNT (account) &&
1810             strcmp (tny_account_get_id (account), MODEST_LOCAL_FOLDERS_ACCOUNT_ID) == 0) {
1811                 GList *children;
1812                 GtkLabel *label;
1813                 const gchar *device_name;
1814                 gchar *new_text;
1815
1816                 /* Get label */
1817                 children = gtk_container_get_children (GTK_CONTAINER (priv->details_widget));
1818                 label = GTK_LABEL (children->data);
1819
1820                 device_name = modest_conf_get_string (modest_runtime_get_conf(),
1821                                                       MODEST_CONF_DEVICE_NAME, NULL);
1822
1823                 new_text = g_strdup_printf ("%s: %s",
1824                                             _("mcen_fi_localroot_description"),
1825                                             device_name);
1826
1827                 gtk_label_set_text (label, new_text);
1828                 gtk_widget_show (GTK_WIDGET (label));
1829
1830                 g_free (new_text);
1831                 g_list_free (children);
1832         }
1833         g_object_unref (account);
1834 }
1835
1836 static gboolean
1837 set_toolbar_transfer_mode (ModestMainWindow *self)
1838 {
1839         ModestMainWindowPrivate *priv = NULL;
1840
1841         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (self), FALSE);
1842
1843         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1844
1845         set_toolbar_mode (self, TOOLBAR_MODE_TRANSFER);
1846
1847         if (priv->progress_bar_timeout > 0) {
1848                 g_source_remove (priv->progress_bar_timeout);
1849                 priv->progress_bar_timeout = 0;
1850         }
1851
1852         return FALSE;
1853 }
1854
1855 static void
1856 set_toolbar_mode (ModestMainWindow *self,
1857                   ModestToolBarModes mode)
1858 {
1859         ModestWindowPrivate *parent_priv = NULL;
1860         ModestMainWindowPrivate *priv = NULL;
1861         GtkAction *sort_action = NULL, *refresh_action = NULL, *cancel_action = NULL;
1862
1863         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
1864
1865         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
1866         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1867
1868         /* In case this was called before the toolbar exists: */
1869         if (!(parent_priv->toolbar))
1870                 return;
1871
1872         g_return_if_fail (GTK_IS_TOOLBAR(parent_priv->toolbar));
1873
1874         sort_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarSort");
1875         refresh_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarSendReceive");
1876         cancel_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarCancel");
1877
1878         /* Sets current toolbar mode */
1879         priv->current_toolbar_mode = mode;
1880
1881         /* Checks the dimming rules */
1882         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (self));
1883
1884         /* Show and hide toolbar items */
1885         switch (mode) {
1886         case TOOLBAR_MODE_NORMAL:
1887                 if (sort_action)
1888                         gtk_action_set_visible (sort_action, TRUE);
1889                 if (refresh_action)
1890                         gtk_action_set_visible (refresh_action, TRUE);
1891                 if (priv->progress_toolitem) {
1892                         gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
1893                         gtk_widget_hide (priv->progress_toolitem);
1894                 }
1895                 if (priv->progress_bar)
1896                         gtk_widget_hide (priv->progress_bar);
1897
1898                 if (cancel_action)
1899                         gtk_action_set_visible (cancel_action, FALSE);
1900
1901                 /* Hide toolbar if optimized view is enabled */
1902                 if (priv->optimized_view)
1903                         gtk_widget_hide (GTK_WIDGET(parent_priv->toolbar));
1904                 break;
1905         case TOOLBAR_MODE_TRANSFER:
1906                 if (sort_action)
1907                         gtk_action_set_visible (sort_action, FALSE);
1908                 if (refresh_action)
1909                         gtk_action_set_visible (refresh_action, FALSE);
1910                 if (cancel_action)
1911                         gtk_action_set_visible (cancel_action, TRUE);
1912                 if (priv->progress_toolitem) {
1913                         gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
1914                         gtk_widget_show (priv->progress_toolitem);
1915                 }
1916                 if (priv->progress_bar)
1917                         gtk_widget_show (priv->progress_bar);
1918
1919                 /* Show toolbar if it's hiden (optimized view ) */
1920                 if (priv->optimized_view)
1921                         gtk_widget_show (GTK_WIDGET (parent_priv->toolbar));
1922                 break;
1923         default:
1924                 g_return_if_reached ();
1925         }
1926 }
1927
1928 gboolean
1929 modest_main_window_transfer_mode_enabled (ModestMainWindow *self)
1930 {
1931         ModestMainWindowPrivate *priv;
1932
1933         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (self), FALSE);
1934         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1935
1936         return priv->current_toolbar_mode == TOOLBAR_MODE_TRANSFER;
1937 }
1938
1939 static void
1940 cancel_progressbar (GtkToolButton *toolbutton,
1941                     ModestMainWindow *self)
1942 {
1943         GSList *tmp;
1944         ModestMainWindowPrivate *priv;
1945
1946         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1947
1948         /* Get operation observers and cancel all the operations */
1949         tmp = priv->progress_widgets;
1950         while (tmp) {
1951                 modest_progress_object_cancel_all_operations (MODEST_PROGRESS_OBJECT(tmp->data));
1952                 tmp=g_slist_next(tmp);
1953         }
1954 }
1955
1956 static gboolean
1957 observers_empty (ModestMainWindow *self)
1958 {
1959         GSList *tmp = NULL;
1960         ModestMainWindowPrivate *priv;
1961         gboolean is_empty = TRUE;
1962         guint pending_ops = 0;
1963
1964         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1965         tmp = priv->progress_widgets;
1966
1967         /* Check all observers */
1968         while (tmp && is_empty)  {
1969                 pending_ops = modest_progress_object_num_pending_operations (MODEST_PROGRESS_OBJECT(tmp->data));
1970                 is_empty = pending_ops == 0;
1971
1972                 tmp = g_slist_next(tmp);
1973         }
1974
1975         return is_empty;
1976 }
1977
1978 static void
1979 on_queue_changed (ModestMailOperationQueue *queue,
1980                   ModestMailOperation *mail_op,
1981                   ModestMailOperationQueueNotification type,
1982                   ModestMainWindow *self)
1983 {
1984         ModestMainWindowPrivate *priv;
1985         ModestMailOperationTypeOperation op_type;
1986         ModestToolBarModes mode;
1987         GSList *tmp;
1988         gboolean mode_changed = FALSE;
1989
1990         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
1991         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1992
1993         /* Get toolbar mode from operation id*/
1994         op_type = modest_mail_operation_get_type_operation (mail_op);
1995         switch (op_type) {
1996         case MODEST_MAIL_OPERATION_TYPE_RECEIVE:
1997         case MODEST_MAIL_OPERATION_TYPE_OPEN:
1998                 mode = TOOLBAR_MODE_TRANSFER;
1999                 if (priv->current_toolbar_mode == TOOLBAR_MODE_NORMAL)
2000                         mode_changed = TRUE;
2001                 break;
2002         default:
2003                 mode = TOOLBAR_MODE_NORMAL;
2004
2005         }
2006
2007
2008         /* Add operation observers and change toolbar if neccessary*/
2009         tmp = priv->progress_widgets;
2010         switch (type) {
2011         case MODEST_MAIL_OPERATION_QUEUE_OPERATION_ADDED:
2012                 if (mode == TOOLBAR_MODE_TRANSFER) {
2013                         if (mode_changed) {
2014                                 set_toolbar_transfer_mode(self);
2015                         }
2016                         while (tmp) {
2017                                 modest_progress_object_add_operation (MODEST_PROGRESS_OBJECT (tmp->data),
2018                                                                       mail_op);
2019                                 tmp = g_slist_next (tmp);
2020                         }
2021                 }
2022                 break;
2023         case MODEST_MAIL_OPERATION_QUEUE_OPERATION_REMOVED:
2024                 /* Change toolbar mode */
2025                 if (mode == TOOLBAR_MODE_TRANSFER) {
2026                         while (tmp) {
2027                                 modest_progress_object_remove_operation (MODEST_PROGRESS_OBJECT (tmp->data),
2028                                                                          mail_op);
2029                                 tmp = g_slist_next (tmp);
2030                         }
2031
2032                         /* If no more operations are being observed, NORMAL mode is enabled again */
2033                         if (observers_empty (self)) {
2034                                 set_toolbar_mode (self, TOOLBAR_MODE_NORMAL);
2035                         }
2036                 }
2037
2038                 break;
2039         }
2040
2041 }
2042
2043 static void
2044 set_account_visible(ModestMainWindow *self, const gchar *acc_name)
2045 {
2046         ModestMainWindowPrivate *priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
2047         GtkAction *action;
2048
2049         /* Get account data */
2050         ModestAccountMgr *mgr = modest_runtime_get_account_mgr ();
2051         ModestAccountData *acc_data = modest_account_mgr_get_account_data (mgr, acc_name);
2052
2053         /* Set the new visible & active account */
2054         if (acc_data && acc_data->store_account) {
2055                 modest_folder_view_set_account_id_of_visible_server_account (priv->folder_view,
2056                                                                              acc_data->store_account->account_name);
2057                 modest_window_set_active_account (MODEST_WINDOW (self), acc_data->account_name);
2058                 action = gtk_action_group_get_action (priv->view_additions_group, acc_data->account_name);
2059                 if (action != NULL) {
2060                         if (!gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))) {
2061                                 modest_maemo_toggle_action_set_active_block_notify (
2062                                         GTK_TOGGLE_ACTION (action),
2063                                         TRUE);
2064                         }
2065                 }
2066         }
2067
2068         modest_folder_view_select_first_inbox_or_local (priv->folder_view);
2069
2070
2071         /* Free */
2072         if (acc_data)
2073                 modest_account_mgr_free_account_data (mgr, acc_data);
2074 }
2075
2076 /* Make sure that at least one account is "viewed": */
2077 static void
2078 set_at_least_one_account_visible(ModestMainWindow *self)
2079 {
2080         ModestMainWindowPrivate *priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
2081         ModestAccountMgr *account_mgr = modest_runtime_get_account_mgr();
2082
2083         if (!(priv->folder_view)) {
2084                 /* It is too early to do this. */
2085                 return;
2086         }
2087
2088         const gchar *active_server_account_name =
2089                 modest_folder_view_get_account_id_of_visible_server_account (priv->folder_view);
2090         if (!active_server_account_name ||
2091                 !modest_account_mgr_account_exists (account_mgr, active_server_account_name, TRUE))
2092         {
2093                 gchar* first_modest_name = modest_account_mgr_get_first_account_name (account_mgr);
2094                 if (first_modest_name) {
2095                         set_account_visible (self, first_modest_name);
2096                         g_free (first_modest_name);
2097                 }
2098         }
2099 }
2100
2101 static void
2102 on_show_account_action_toggled  (GtkToggleAction *action,
2103                                    gpointer user_data)
2104 {
2105         ModestMainWindow *self = MODEST_MAIN_WINDOW (user_data);
2106
2107         const gchar *acc_name = gtk_action_get_name (GTK_ACTION (action));
2108         if (gtk_toggle_action_get_active (action))
2109                 set_account_visible (self, acc_name);
2110 }
2111
2112 static void
2113 refresh_account (const gchar *account_name)
2114 {
2115         ModestWindow *win;
2116
2117         win = MODEST_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
2118
2119         /* If account_name == NULL, we must update all (option All) */
2120         if (!account_name)
2121                 modest_ui_actions_do_send_receive_all (win);
2122         else
2123                 modest_ui_actions_do_send_receive (account_name, win);
2124
2125 }
2126
2127 static void
2128 on_refresh_account_action_activated  (GtkAction *action,
2129                                       gpointer user_data)
2130 {
2131         refresh_account ((const gchar*) user_data);
2132 }
2133
2134 static void
2135 on_send_receive_csm_activated (GtkMenuItem *item,
2136                                gpointer user_data)
2137 {
2138         refresh_account ((const gchar*) user_data);
2139 }
2140
2141 static gboolean
2142 on_zoom_minus_plus_not_implemented (ModestWindow *window)
2143 {
2144         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (window), FALSE);
2145
2146         hildon_banner_show_information (NULL, NULL, dgettext("hildon-common-strings", "ckct_ib_cannot_zoom_here"));
2147         return FALSE;
2148
2149 }
2150
2151 static gboolean
2152 on_folder_view_focus_in (GtkWidget *widget,
2153                          GdkEventFocus *event,
2154                          gpointer userdata)
2155 {
2156         ModestMainWindow *main_window = NULL;
2157
2158         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (userdata), FALSE);
2159         main_window = MODEST_MAIN_WINDOW (userdata);
2160
2161         /* Update toolbar dimming state */
2162         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2163
2164         return FALSE;
2165 }
2166
2167 static gboolean
2168 on_header_view_focus_in (GtkWidget *widget,
2169                          GdkEventFocus *event,
2170                          gpointer userdata)
2171 {
2172         ModestMainWindow *main_window = NULL;
2173         ModestMainWindowPrivate *priv = NULL;
2174
2175         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (userdata), FALSE);
2176         main_window = MODEST_MAIN_WINDOW (userdata);
2177         priv = MODEST_MAIN_WINDOW_GET_PRIVATE (main_window);
2178
2179         /* Update toolbar dimming state */
2180         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2181
2182         return FALSE;
2183 }
2184
2185 static void
2186 modest_main_window_on_folder_selection_changed (ModestFolderView *folder_view,
2187                                                 TnyFolderStore *folder_store,
2188                                                 gboolean selected,
2189                                                 ModestMainWindow *main_window)
2190 {
2191         ModestWindowPrivate *parent_priv = MODEST_WINDOW_GET_PRIVATE (main_window);
2192         GtkAction *action = NULL;
2193         gboolean show_reply = TRUE;
2194         gboolean show_forward = TRUE;
2195         gboolean show_cancel_send = FALSE;
2196         gboolean show_clipboard = TRUE;
2197         gboolean show_delete = TRUE;
2198
2199         if (selected) {
2200                 if (TNY_IS_ACCOUNT (folder_store)) {
2201                         show_reply = show_forward = show_cancel_send = show_clipboard = show_delete = FALSE;
2202                 } else if (TNY_IS_FOLDER (folder_store)) {
2203                         if (modest_tny_folder_is_local_folder (TNY_FOLDER (folder_store))) {
2204                                 TnyFolderType folder_type = modest_tny_folder_get_local_or_mmc_folder_type (
2205                                         TNY_FOLDER (folder_store));
2206                                 switch (folder_type) {
2207                                 case TNY_FOLDER_TYPE_DRAFTS:
2208                                         show_clipboard = show_delete = TRUE;
2209                                         show_reply = show_forward = show_cancel_send = FALSE;
2210                                         break;
2211                                 case TNY_FOLDER_TYPE_SENT:
2212                                         show_forward = show_clipboard = show_delete = TRUE;
2213                                         show_reply = show_cancel_send = FALSE;
2214                                         break;
2215                                 case TNY_FOLDER_TYPE_OUTBOX:
2216                                         show_clipboard = show_delete = show_cancel_send = TRUE;
2217                                         show_reply = show_forward = FALSE;
2218                                         break;
2219                                 default:
2220                                         show_reply = show_forward = show_clipboard = show_delete = TRUE;
2221                                         show_cancel_send = FALSE;
2222                                 }
2223                         } else {
2224                                 show_reply = show_forward = show_clipboard = show_delete = TRUE;
2225                                 show_cancel_send = FALSE;
2226                         }
2227                 }
2228         }
2229
2230         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMReply");
2231         gtk_action_set_visible (action, show_reply);
2232         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMReplyAll");
2233         gtk_action_set_visible (action, show_reply);
2234         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMForward");
2235         gtk_action_set_visible (action, show_forward);
2236         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMCancelSending");
2237         gtk_action_set_visible (action, show_cancel_send);
2238         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMDelete");
2239         gtk_action_set_visible (action, show_delete);
2240
2241         /* We finally call to the ui actions handler, after updating properly
2242          * the header view CSM */
2243         modest_ui_actions_on_folder_selection_changed (folder_view, folder_store, selected, main_window);
2244 }
2245
2246 gboolean
2247 modest_main_window_on_msg_view_window_msg_changed (ModestMsgViewWindow *view_window,
2248                                                    GtkTreeModel *model,
2249                                                    GtkTreeRowReference *row_reference,
2250                                                    ModestMainWindow *self)
2251 {
2252         ModestMainWindowPrivate *priv = NULL;
2253         GtkTreeModel *header_model = NULL;
2254         GtkTreePath *path = NULL;
2255
2256         g_return_val_if_fail (MODEST_IS_MSG_VIEW_WINDOW (view_window), FALSE);
2257         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (self), FALSE);
2258         g_return_val_if_fail (gtk_tree_row_reference_valid (row_reference), FALSE);
2259
2260         priv = MODEST_MAIN_WINDOW_GET_PRIVATE (self);
2261         header_model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->header_view));
2262
2263         /* Do nothing if we changed the folder in the main view */
2264         if (header_model != model)
2265                 return FALSE;
2266
2267         /* Select the message in the header view */
2268         path = gtk_tree_row_reference_get_path (row_reference);
2269         gtk_tree_view_set_cursor (GTK_TREE_VIEW (priv->header_view),
2270                                   path, NULL, FALSE);
2271         gtk_tree_path_free (path);
2272
2273         return TRUE;
2274 }
2275