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