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_name) {
1339                         gchar* item_name, *refresh_action_name;
1340                         guint8 merge_id;
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                         gtk_action_group_add_action (action_group, refresh_account_action);
1373
1374                         merge_id = (guint8) gtk_ui_manager_new_merge_id (parent_priv->ui_manager);
1375                         priv->merge_ids = g_byte_array_append (priv->merge_ids, &merge_id, 1);
1376                         gtk_ui_manager_add_ui (parent_priv->ui_manager,
1377                                                merge_id,
1378                                                "/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsMenuAdditions",
1379                                                item_name,
1380                                                refresh_action_name,
1381                                                GTK_UI_MANAGER_MENUITEM,
1382                                                FALSE);
1383                         g_free (refresh_action_name);
1384
1385                         g_signal_connect_data (G_OBJECT (refresh_account_action),
1386                                                "activate",
1387                                                G_CALLBACK (on_refresh_account_action_activated),
1388                                                g_strdup (account_data->account_name),
1389                                                (GClosureNotify) g_free,
1390                                                0);
1391
1392                         /* Create item and add it to the send&receive
1393                            CSM. If there is only one account then
1394                            it'll be no menu */
1395                         if (priv->accounts_popup) {
1396                                 GtkWidget *label = gtk_label_new(NULL);
1397                                 gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
1398                                 if (default_account && (strcmp(account_data->account_name, default_account) == 0))
1399                                 {
1400                                         gchar *escaped = g_markup_printf_escaped ("<b>%s</b>", display_name);
1401                                         gtk_label_set_markup (GTK_LABEL (label), escaped);
1402                                         g_free (escaped);
1403                                 }
1404                                 else
1405                                 {
1406                                         gtk_label_set_text (GTK_LABEL (label), display_name);
1407                                 }
1408
1409                                 item = gtk_menu_item_new ();
1410                                 gtk_container_add (GTK_CONTAINER (item), label);
1411
1412                                 gtk_menu_shell_prepend (GTK_MENU_SHELL (priv->accounts_popup), GTK_WIDGET (item));
1413                                 g_signal_connect_data (G_OBJECT (item),
1414                                                        "activate",
1415                                                        G_CALLBACK (on_send_receive_csm_activated),
1416                                                        g_strdup (account_data->account_name),
1417                                                        (GClosureNotify) g_free,
1418                                                        0);
1419                         }
1420                         g_free (item_name);
1421                 }
1422
1423                 /* Frees */
1424                 g_free (display_name);
1425         }
1426
1427         gtk_ui_manager_insert_action_group (parent_priv->ui_manager, action_group, 1);
1428
1429         /* We cannot do this in the loop above because this relies on the action
1430          * group being inserted. This makes the default account appear in bold.
1431          * I agree it is a rather ugly way, but I don't see another possibility. armin. */
1432         for (i = 0; i < num_accounts; i++) {
1433                 ModestAccountData *account_data = (ModestAccountData *) g_slist_nth_data (accounts, i);
1434
1435                 if(account_data->account_name &&
1436                    strcmp (account_data->account_name, default_account) == 0) {
1437                         gchar *item_name = g_strconcat (account_data->account_name, "Menu", NULL);
1438
1439                         gchar *path = g_strconcat ("/MenuBar/ViewMenu/ViewMenuAdditions/", item_name, NULL);
1440                         GtkWidget *item = gtk_ui_manager_get_widget (parent_priv->ui_manager, path);
1441                         g_free(path);
1442
1443                         if (item) {
1444                                 GtkWidget *child = gtk_bin_get_child (GTK_BIN (item));
1445                                 if (GTK_IS_LABEL (child)) {
1446                                         const gchar *cur_name = gtk_label_get_text (GTK_LABEL (child));
1447                                         gchar *bold_name = g_markup_printf_escaped("<b>%s</b>", cur_name);
1448                                         gtk_label_set_markup (GTK_LABEL (child), bold_name);
1449                                         g_free (bold_name);
1450                                 }
1451                         }
1452
1453                         path = g_strconcat("/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsMenuAdditions/", item_name, NULL);
1454                         item = gtk_ui_manager_get_widget (parent_priv->ui_manager, path);
1455                         g_free (path);
1456
1457                         if (item) {
1458                                 GtkWidget *child = gtk_bin_get_child (GTK_BIN (item));
1459                                 if (GTK_IS_LABEL (child)) {
1460                                         const gchar *cur_name = gtk_label_get_text (GTK_LABEL (child));
1461                                         gchar *bold_name = g_markup_printf_escaped("<b>%s</b>", cur_name);
1462                                         gtk_label_set_markup (GTK_LABEL (child), bold_name);
1463                                         g_free (bold_name);
1464                                 }
1465                         }
1466
1467                         g_free(item_name);
1468                 }
1469
1470                 modest_account_mgr_free_account_data (mgr, account_data);
1471         }
1472
1473         if (priv->accounts_popup) {
1474                 /* Mandatory in order to view the menu contents */
1475                 gtk_widget_show_all (priv->accounts_popup);
1476
1477                 /* Setup tap_and_hold just if was not done before*/
1478                 if (!gtk_menu_get_attach_widget (GTK_MENU (priv->accounts_popup)))
1479                         gtk_widget_tap_and_hold_setup (send_receive_button, priv->accounts_popup, NULL, 0);
1480         }
1481
1482         /* Frees */
1483         g_slist_free (accounts);
1484         g_free (default_account);
1485 }
1486
1487 /*
1488  * This function manages the key events used to navigate between
1489  * header and folder views (when the window is in split view)
1490  *
1491  * FROM         KEY        ACTION
1492  * -------------------------------------------------
1493  * HeaderView   GDK_Left   Move focus to folder view
1494  * FolderView   GDK_Right  Move focus to header view
1495  *
1496  * There is no need to scroll to selected row, the widgets will be the
1497  * responsibles of doing that (probably managing the focus-in event
1498  */
1499 static gboolean
1500 on_inner_widgets_key_pressed (GtkWidget *widget,
1501                               GdkEventKey *event,
1502                               gpointer user_data)
1503 {
1504         ModestMainWindowPrivate *priv;
1505
1506         priv = MODEST_MAIN_WINDOW_GET_PRIVATE (user_data);
1507
1508         /* Do nothing if we're in SIMPLE style */
1509         if (priv->style == MODEST_MAIN_WINDOW_STYLE_SIMPLE)
1510                 return FALSE;
1511
1512         if (MODEST_IS_HEADER_VIEW (widget) && event->keyval == GDK_Left)
1513                 gtk_widget_grab_focus (GTK_WIDGET (priv->folder_view));
1514         else if (MODEST_IS_FOLDER_VIEW (widget) && event->keyval == GDK_Right)
1515                 gtk_widget_grab_focus (GTK_WIDGET (priv->header_view));
1516
1517         return FALSE;
1518 }
1519
1520 static void
1521 set_alignment (GtkWidget *widget,
1522                gpointer data)
1523 {
1524         gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0);
1525         gtk_misc_set_padding (GTK_MISC (widget), 0, 0);
1526 }
1527
1528 static GtkWidget *
1529 create_empty_view (void)
1530 {
1531         GtkLabel *label = NULL;
1532         GtkWidget *align = NULL;
1533
1534         align = gtk_alignment_new(XALIGN, YALIGN, XSPACE, YSPACE);
1535         label = GTK_LABEL(gtk_label_new (_("mcen_ia_nomessages")));
1536         gtk_label_set_justify (label, GTK_JUSTIFY_CENTER);
1537         gtk_container_add (GTK_CONTAINER (align), GTK_WIDGET(label));
1538
1539         return GTK_WIDGET(align);
1540 }
1541
1542 static GtkWidget *
1543 create_details_widget (GtkWidget *styled_widget, TnyAccount *account)
1544 {
1545         /* TODO: Clean up this function. It's a mess, with lots of copy/paste. murrayc. */
1546
1547         GtkWidget *vbox;
1548         GtkWidget *label_w;
1549         gchar *label;
1550         gchar *gray_color_markup;
1551
1552         vbox = gtk_vbox_new (FALSE, 0);
1553
1554         /* Obtain the secondary text color. We need a realized widget, that's why
1555            we get styled_widget from outside */
1556 #ifndef MODEST_HAVE_HILDON0_WIDGETS
1557         GdkColor color;
1558         gtk_style_lookup_color (styled_widget->style, "SecondaryTextColor", &color);
1559         gray_color_markup = modest_text_utils_get_color_string (&color);
1560 #else
1561         // gray_color_markup is freed below
1562         gray_color_markup = g_strdup ("#BBBBBB");
1563 #endif
1564         /* Account description: */
1565
1566         if (modest_tny_account_is_virtual_local_folders (account)
1567                 || (modest_tny_account_is_memory_card_account (account))) {
1568                 gchar *tmp;
1569                 /* Local folders: */
1570
1571                 /* Get device name */
1572                 gchar *device_name = NULL;
1573                 if (modest_tny_account_is_virtual_local_folders (account))
1574                         device_name = modest_conf_get_string (modest_runtime_get_conf(),
1575                                                       MODEST_CONF_DEVICE_NAME, NULL);
1576                 else
1577                         device_name = g_strdup (tny_account_get_name (account));
1578
1579                 tmp = g_strdup_printf (_("mcen_fi_localroot_description"), ""); //TODO: Why the ""?
1580                 label = g_markup_printf_escaped ("<span color='%s'>%s</span>%s",
1581                                                  gray_color_markup, tmp, device_name);
1582                 g_free (tmp);
1583                 label_w = gtk_label_new (NULL);
1584                 gtk_label_set_markup (GTK_LABEL (label_w), label);
1585                 gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
1586                 g_free (device_name);
1587                 g_free (label);
1588         } else {
1589                 if(!strcmp (tny_account_get_id (account), MODEST_MMC_ACCOUNT_ID)) {
1590                         gtk_box_pack_start (GTK_BOX (vbox),
1591                                 gtk_label_new (tny_account_get_name (account)),
1592                                 FALSE, FALSE, 0);
1593                 } else {
1594                         /* Other accounts, such as IMAP and POP: */
1595
1596                         GString *proto;
1597                         gchar *tmp;
1598
1599                         /* Put proto in uppercase */
1600                         proto = g_string_new (tny_account_get_proto (account));
1601                         proto = g_string_ascii_up (proto);
1602
1603                         /* note: mcen_fi_localroot_description is something like "%s account"
1604                          * however, we should display "%s account: %s"... therefore, ugly tmp */
1605                         tmp   = g_strdup_printf (_("mcen_fi_remoteroot_account"),proto->str);
1606                         label = g_markup_printf_escaped ("<span color='%s'>%s:</span> %s",
1607                                                          gray_color_markup, tmp, tny_account_get_name (account));
1608                         g_free (tmp);
1609
1610                         label_w = gtk_label_new (NULL);
1611                         gtk_label_set_markup (GTK_LABEL (label_w), label);
1612                         gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
1613                         g_string_free (proto, TRUE);
1614                         g_free (label);
1615                 }
1616         }
1617
1618         /* Message count */
1619         TnyFolderStore *folder_store = TNY_FOLDER_STORE (account);
1620         label = g_markup_printf_escaped ("<span color='%s'>%s:</span> %d",
1621                                          gray_color_markup, _("mcen_fi_rootfolder_messages"),
1622                                          modest_tny_folder_store_get_message_count (folder_store));
1623         label_w = gtk_label_new (NULL);
1624         gtk_label_set_markup (GTK_LABEL (label_w), label);
1625         gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
1626         g_free (label);
1627
1628         /* Folder count */
1629         label = g_markup_printf_escaped ("<span color='%s'>%s</span>: %d",
1630                                          gray_color_markup,
1631                                          _("mcen_fi_rootfolder_folders"),
1632                                          modest_tny_folder_store_get_folder_count (folder_store));
1633         label_w = gtk_label_new (NULL);
1634         gtk_label_set_markup (GTK_LABEL (label_w), label);
1635         gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
1636         g_free (label);
1637
1638         /* Size / Date */
1639         if (modest_tny_account_is_virtual_local_folders (account)
1640                 || modest_tny_account_is_memory_card_account (account)) {
1641
1642                 gchar *size = modest_text_utils_get_display_size (
1643                         modest_tny_folder_store_get_local_size (folder_store));
1644
1645                 label = g_markup_printf_escaped ("<span color='%s'>%s:</span> %s",
1646                                                  gray_color_markup, _("mcen_fi_rootfolder_size"),
1647                                                  size);
1648                 g_free (size);
1649
1650                 label_w = gtk_label_new (NULL);
1651                 gtk_label_set_markup (GTK_LABEL (label_w), label);
1652                 gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
1653                 g_free (label);
1654         } else if (TNY_IS_ACCOUNT(folder_store)) {
1655                 TnyAccount *account = TNY_ACCOUNT(folder_store);
1656
1657                 time_t last_updated;
1658                 gchar *last_updated_string;
1659                 /* Get last updated from configuration */
1660                 last_updated = modest_account_mgr_get_int (modest_runtime_get_account_mgr (),
1661                                                           tny_account_get_id (account),
1662                                                           MODEST_ACCOUNT_LAST_UPDATED,
1663                                                           TRUE);
1664                 if (last_updated > 0)
1665                         last_updated_string = modest_text_utils_get_display_date(last_updated);
1666                 else
1667                         last_updated_string = g_strdup (_("mcen_va_never"));
1668
1669                 label = g_markup_printf_escaped ("<span color='%s'>%s:</span> %s",
1670                                                  gray_color_markup, _("mcen_ti_lastupdated"), last_updated_string);
1671                 label_w = gtk_label_new (NULL);
1672                 gtk_label_set_markup (GTK_LABEL (label_w), label);
1673                 gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
1674                 g_free (last_updated_string);
1675                 g_free (label);
1676         }
1677
1678         g_free (gray_color_markup);
1679
1680         /* Set alignment */
1681         gtk_container_foreach (GTK_CONTAINER (vbox), (GtkCallback) set_alignment, NULL);
1682
1683         return vbox;
1684 }
1685
1686 gboolean
1687 modest_main_window_send_receive_in_progress (ModestMainWindow *self)
1688 {
1689         ModestMainWindowPrivate *priv = NULL;
1690
1691         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (self), FALSE);
1692
1693         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1694
1695         return priv->send_receive_in_progress;
1696 }
1697
1698 void
1699 modest_main_window_notify_send_receive_initied (ModestMainWindow *self)
1700 {
1701         GtkAction *action = NULL;
1702         GtkWidget *widget = NULL;
1703         ModestMainWindowPrivate *priv = NULL;
1704
1705         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
1706         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1707
1708         priv->send_receive_in_progress  = TRUE;
1709
1710         action = modest_window_get_action (MODEST_WINDOW(self), "/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsSendReceiveAllMenu");
1711         gtk_action_set_sensitive (action, FALSE);
1712 /*         action = modest_window_get_action (MODEST_WINDOW(self), "/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsSendReceiveCancelSendingMenu"); */
1713 /*      gtk_action_set_sensitive (action, FALSE); */
1714         widget = modest_window_get_action_widget (MODEST_WINDOW(self), "/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsMenuAdditions");
1715         gtk_widget_set_sensitive (widget, FALSE);
1716 }
1717
1718 void
1719 modest_main_window_notify_send_receive_completed (ModestMainWindow *self)
1720 {
1721         GtkAction *action = NULL;
1722         GtkWidget *widget = NULL;
1723         ModestMainWindowPrivate *priv = NULL;
1724
1725         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
1726         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1727
1728         priv->send_receive_in_progress  = FALSE;
1729
1730         action = modest_window_get_action (MODEST_WINDOW(self), "/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsSendReceiveAllMenu");
1731         gtk_action_set_sensitive (action, TRUE);
1732 /*         action = modest_window_get_action (MODEST_WINDOW(self), "/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsSendReceiveCancelSendingMenu");     */
1733 /*      gtk_action_set_sensitive (action, TRUE); */
1734         widget = modest_window_get_action_widget (MODEST_WINDOW(self), "/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsMenuAdditions");
1735         gtk_widget_set_sensitive (widget, TRUE);
1736 }
1737
1738
1739 static void
1740 _on_msg_count_changed (ModestHeaderView *header_view,
1741                        TnyFolder *folder,
1742                        TnyFolderChange *change,
1743                        ModestMainWindow *main_window)
1744 {
1745         printf ("DEBUG: %s\n", __FUNCTION__);
1746         gboolean folder_empty = FALSE;
1747         TnyFolderChangeChanged changed;
1748
1749         g_return_if_fail (MODEST_IS_MAIN_WINDOW (main_window));
1750         g_return_if_fail (TNY_IS_FOLDER(folder));
1751         g_return_if_fail (TNY_IS_FOLDER_CHANGE(change));
1752
1753         changed = tny_folder_change_get_changed (change);
1754
1755         /* If something changes */
1756         if ((changed) & TNY_FOLDER_CHANGE_CHANGED_ALL_COUNT)
1757                 folder_empty = (tny_folder_change_get_new_all_count (change) == 0);
1758         else
1759                 folder_empty = (tny_folder_get_all_count (TNY_FOLDER (folder)) == 0);
1760
1761         printf ("DEBUG: %s: folder_empty=%d\n", __FUNCTION__, folder_empty);
1762
1763         /* Set contents style of headers view */
1764         if (folder_empty)  {
1765                 modest_main_window_set_contents_style (main_window,
1766                                                        MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
1767         }
1768         else {
1769                 modest_main_window_set_contents_style (main_window,
1770                                                        MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
1771         }
1772 }
1773
1774
1775 void
1776 modest_main_window_set_contents_style (ModestMainWindow *self,
1777                                        ModestMainWindowContentsStyle style)
1778 {
1779         ModestMainWindowPrivate *priv;
1780
1781         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
1782
1783         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1784
1785         /* We allow to set the same content style than the previously
1786            set if there are details, because it could happen when we're
1787            selecting different accounts consecutively */
1788         if ((priv->contents_style == style) &&
1789             (priv->contents_style != MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS))
1790                 return;
1791
1792         /* Remove previous child. Delete it if it was an account
1793            details widget */
1794         GtkWidget *content = gtk_bin_get_child (GTK_BIN (priv->contents_widget));
1795         if (content) {
1796                 if (priv->contents_style == MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
1797                         g_object_ref (content);
1798                 else if (priv->contents_style == MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY) {
1799                         g_object_ref (priv->empty_view);
1800                         gtk_container_remove (GTK_CONTAINER (content), priv->empty_view);
1801                 }
1802
1803                 gtk_container_remove (GTK_CONTAINER (priv->contents_widget), content);
1804         }
1805
1806         priv->contents_style = style;
1807
1808         switch (priv->contents_style) {
1809         case MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS:
1810                 wrap_in_scrolled_window (priv->contents_widget, GTK_WIDGET (priv->header_view));
1811                 modest_maemo_set_thumbable_scrollbar (GTK_SCROLLED_WINDOW(priv->contents_widget),
1812                                                       TRUE);
1813                 break;
1814         case MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS:
1815         {
1816                 TnyFolderStore *selected_folderstore =
1817                         modest_folder_view_get_selected (priv->folder_view);
1818                 if (TNY_IS_ACCOUNT (selected_folderstore)) {
1819                   priv->details_widget = create_details_widget (GTK_WIDGET (self),
1820                                                                 TNY_ACCOUNT (selected_folderstore));
1821
1822                         wrap_in_scrolled_window (priv->contents_widget,
1823                                          priv->details_widget);
1824                 }
1825                 g_object_unref (selected_folderstore);
1826                 modest_maemo_set_thumbable_scrollbar (GTK_SCROLLED_WINDOW(priv->contents_widget),
1827                                                       FALSE);
1828
1829
1830                 break;
1831         }
1832         case MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY:
1833                 wrap_in_scrolled_window (priv->contents_widget, GTK_WIDGET (priv->empty_view));
1834                 modest_maemo_set_thumbable_scrollbar (GTK_SCROLLED_WINDOW(priv->contents_widget),
1835                                                       FALSE);
1836                 break;
1837         default:
1838                 g_return_if_reached ();
1839         }
1840
1841         /* Show */
1842         gtk_widget_show_all (priv->contents_widget);
1843 }
1844
1845 ModestMainWindowContentsStyle
1846 modest_main_window_get_contents_style (ModestMainWindow *self)
1847 {
1848         ModestMainWindowPrivate *priv;
1849
1850         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (self), -1);
1851
1852         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1853         return priv->contents_style;
1854 }
1855
1856
1857 static void
1858 on_configuration_key_changed (ModestConf* conf,
1859                               const gchar *key,
1860                               ModestConfEvent event,
1861                               ModestMainWindow *self)
1862 {
1863         ModestMainWindowPrivate *priv;
1864         TnyAccount *account;
1865
1866         if (!key || strcmp (key, MODEST_CONF_DEVICE_NAME))
1867                 return;
1868
1869         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1870
1871         if (priv->contents_style != MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS)
1872                 return;
1873
1874         account = (TnyAccount *) modest_folder_view_get_selected (priv->folder_view);
1875         if (TNY_IS_ACCOUNT (account) &&
1876             !strcmp (tny_account_get_id (account), MODEST_LOCAL_FOLDERS_ACCOUNT_ID)) {
1877                 GList *children;
1878                 GtkLabel *label;
1879                 const gchar *device_name;
1880                 gchar *new_text;
1881
1882                 /* Get label */
1883                 children = gtk_container_get_children (GTK_CONTAINER (priv->details_widget));
1884                 label = GTK_LABEL (children->data);
1885
1886                 device_name = modest_conf_get_string (modest_runtime_get_conf(),
1887                                                       MODEST_CONF_DEVICE_NAME, NULL);
1888
1889                 new_text = g_strdup_printf ("%s: %s",
1890                                             _("mcen_fi_localroot_description"),
1891                                             device_name);
1892
1893                 gtk_label_set_text (label, new_text);
1894                 gtk_widget_show (GTK_WIDGET (label));
1895
1896                 g_free (new_text);
1897                 g_list_free (children);
1898         }
1899         g_object_unref (account);
1900 }
1901
1902 static gboolean
1903 set_toolbar_transfer_mode (ModestMainWindow *self)
1904 {
1905         ModestMainWindowPrivate *priv = NULL;
1906
1907         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (self), FALSE);
1908
1909         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1910
1911         set_toolbar_mode (self, TOOLBAR_MODE_TRANSFER);
1912
1913         if (priv->progress_bar_timeout > 0) {
1914                 g_source_remove (priv->progress_bar_timeout);
1915                 priv->progress_bar_timeout = 0;
1916         }
1917
1918         return FALSE;
1919 }
1920
1921 static void
1922 set_toolbar_mode (ModestMainWindow *self,
1923                   ModestToolBarModes mode)
1924 {
1925         ModestWindowPrivate *parent_priv = NULL;
1926         ModestMainWindowPrivate *priv = NULL;
1927         GtkAction *sort_action = NULL, *refresh_action = NULL, *cancel_action = NULL;
1928
1929         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
1930
1931         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
1932         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
1933
1934         /* In case this was called before the toolbar exists: */
1935         if (!(parent_priv->toolbar))
1936                 return;
1937
1938         g_return_if_fail (GTK_IS_TOOLBAR(parent_priv->toolbar));
1939
1940         sort_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarSort");
1941         refresh_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarSendReceive");
1942         cancel_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarCancel");
1943
1944         /* Sets current toolbar mode */
1945         priv->current_toolbar_mode = mode;
1946
1947         /* Show and hide toolbar items */
1948         switch (mode) {
1949         case TOOLBAR_MODE_NORMAL:
1950                 if (sort_action)
1951                         gtk_action_set_visible (sort_action, TRUE);
1952                 if (refresh_action)
1953                         gtk_action_set_visible (refresh_action, TRUE);
1954                 if (priv->progress_toolitem) {
1955                         gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
1956                         gtk_widget_hide (priv->progress_toolitem);
1957                 }
1958                 if (priv->progress_bar)
1959                         gtk_widget_hide (priv->progress_bar);
1960
1961                 if (cancel_action)
1962                         gtk_action_set_visible (cancel_action, FALSE);
1963 /*              if (priv->sort_toolitem) */
1964 /*                      gtk_widget_show (priv->sort_toolitem); */
1965
1966 /*              if (priv->refresh_toolitem) */
1967 /*                      gtk_widget_show (priv->refresh_toolitem); */
1968
1969 /*              if (priv->progress_toolitem) */
1970 /*                      gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE); */
1971 /*              if (priv->progress_bar) */
1972 /*                      gtk_widget_hide (priv->progress_bar); */
1973
1974 /*              if (priv->cancel_toolitem) */
1975 /*                      gtk_widget_hide (priv->cancel_toolitem); */
1976
1977                 /* Hide toolbar if optimized view is enabled */
1978                 if (priv->optimized_view)
1979                         gtk_widget_hide (GTK_WIDGET(parent_priv->toolbar));
1980                 break;
1981         case TOOLBAR_MODE_TRANSFER:
1982                 if (sort_action)
1983                         gtk_action_set_visible (sort_action, FALSE);
1984                 if (refresh_action)
1985                         gtk_action_set_visible (refresh_action, FALSE);
1986                 if (cancel_action)
1987                         gtk_action_set_visible (cancel_action, TRUE);
1988                 if (priv->progress_toolitem) {
1989                         gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
1990                         gtk_widget_show (priv->progress_toolitem);
1991                 }
1992                 if (priv->progress_bar)
1993                         gtk_widget_show (priv->progress_bar);
1994
1995 /*              if (priv->sort_toolitem) */
1996 /*                      gtk_widget_hide (priv->sort_toolitem); */
1997
1998 /*              if (priv->refresh_toolitem) */
1999 /*                      gtk_widget_hide (priv->refresh_toolitem); */
2000
2001 /*              if (priv->progress_toolitem) */
2002 /*                      gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE); */
2003 /*              if (priv->progress_bar) */
2004 /*                      gtk_widget_show (priv->progress_bar); */
2005
2006 /*              if (priv->cancel_toolitem) */
2007 /*                      gtk_widget_show (priv->cancel_toolitem); */
2008
2009                 /* Show toolbar if it's hiden (optimized view ) */
2010                 if (priv->optimized_view)
2011                         gtk_widget_show (GTK_WIDGET (parent_priv->toolbar));
2012                 break;
2013         default:
2014                 g_return_if_reached ();
2015         }
2016 }
2017
2018 static void
2019 cancel_progressbar (GtkToolButton *toolbutton,
2020                     ModestMainWindow *self)
2021 {
2022         GSList *tmp;
2023         ModestMainWindowPrivate *priv;
2024
2025         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
2026
2027         /* Get operation observers and cancel all the operations */
2028         tmp = priv->progress_widgets;
2029         while (tmp) {
2030                 modest_progress_object_cancel_all_operations (MODEST_PROGRESS_OBJECT(tmp->data));
2031                 tmp=g_slist_next(tmp);
2032         }
2033 }
2034
2035 static gboolean
2036 observers_empty (ModestMainWindow *self)
2037 {
2038         GSList *tmp = NULL;
2039         ModestMainWindowPrivate *priv;
2040         gboolean is_empty = TRUE;
2041         guint pending_ops = 0;
2042
2043         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
2044         tmp = priv->progress_widgets;
2045
2046         /* Check all observers */
2047         while (tmp && is_empty)  {
2048                 pending_ops = modest_progress_object_num_pending_operations (MODEST_PROGRESS_OBJECT(tmp->data));
2049                 is_empty = pending_ops == 0;
2050
2051                 tmp = g_slist_next(tmp);
2052         }
2053
2054         return is_empty;
2055 }
2056
2057 static void
2058 on_queue_changed (ModestMailOperationQueue *queue,
2059                   ModestMailOperation *mail_op,
2060                   ModestMailOperationQueueNotification type,
2061                   ModestMainWindow *self)
2062 {
2063         ModestMainWindowPrivate *priv;
2064         ModestMailOperationTypeOperation op_type;
2065         ModestToolBarModes mode;
2066         GSList *tmp;
2067         gboolean mode_changed = FALSE;
2068 /*      ModestMailOperationStatus status; */
2069
2070         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
2071         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
2072
2073         /* Get toolbar mode from operation id*/
2074         op_type = modest_mail_operation_get_type_operation (mail_op);
2075         switch (op_type) {
2076 /*      case MODEST_MAIL_OPERATION_TYPE_SEND: */
2077         case MODEST_MAIL_OPERATION_TYPE_RECEIVE:
2078         case MODEST_MAIL_OPERATION_TYPE_OPEN:
2079                 mode = TOOLBAR_MODE_TRANSFER;
2080                 if (priv->current_toolbar_mode == TOOLBAR_MODE_NORMAL)
2081                         mode_changed = TRUE;
2082                 break;
2083         default:
2084                 mode = TOOLBAR_MODE_NORMAL;
2085
2086         }
2087
2088
2089         /* Add operation observers and change toolbar if neccessary*/
2090         tmp = priv->progress_widgets;
2091         switch (type) {
2092         case MODEST_MAIL_OPERATION_QUEUE_OPERATION_ADDED:
2093                 if (mode == TOOLBAR_MODE_TRANSFER) {
2094                         if (mode_changed)
2095                                 set_toolbar_transfer_mode(self);
2096                         while (tmp) {
2097                                 modest_progress_object_add_operation (MODEST_PROGRESS_OBJECT (tmp->data),
2098                                                                       mail_op);
2099                                 tmp = g_slist_next (tmp);
2100                         }
2101                 }
2102                 break;
2103         case MODEST_MAIL_OPERATION_QUEUE_OPERATION_REMOVED:
2104                 /* Change toolbar mode */
2105                 if (mode == TOOLBAR_MODE_TRANSFER) {
2106                         while (tmp) {
2107                                 modest_progress_object_remove_operation (MODEST_PROGRESS_OBJECT (tmp->data),
2108                                                                          mail_op);
2109                                 tmp = g_slist_next (tmp);
2110                         }
2111
2112                         /* If no more operations are being observed, NORMAL mode is enabled again */
2113                         if (observers_empty (self)) {
2114                                 set_toolbar_mode (self, TOOLBAR_MODE_NORMAL);
2115
2116                         }
2117                 }
2118
2119                 break;
2120         }
2121
2122 }
2123
2124 static void
2125 on_show_account_action_activated  (GtkAction *action,
2126                                    gpointer user_data)
2127 {
2128         ModestAccountData *acc_data;
2129         ModestMainWindow *self;
2130         ModestMainWindowPrivate *priv;
2131         ModestAccountMgr *mgr;
2132         const gchar *acc_name;
2133
2134         self = MODEST_MAIN_WINDOW (user_data);
2135         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
2136
2137         /* Get account data */
2138         acc_name = gtk_action_get_name (action);
2139         mgr = modest_runtime_get_account_mgr ();
2140         acc_data = modest_account_mgr_get_account_data (mgr, acc_name);
2141
2142         /* Set the new visible & active account */
2143         if (acc_data->store_account) {
2144                 modest_folder_view_set_account_id_of_visible_server_account (priv->folder_view,
2145                                                                              acc_data->store_account->account_name);
2146                 modest_window_set_active_account (MODEST_WINDOW (self), acc_data->account_name);
2147         }
2148
2149         modest_folder_view_select_first_inbox_or_local (priv->folder_view);
2150
2151         /* Free */
2152         modest_account_mgr_free_account_data (mgr, acc_data);
2153 }
2154
2155 static void
2156 refresh_account (const gchar *account_name)
2157 {
2158         ModestWindow *win;
2159
2160         win = MODEST_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
2161
2162         /* If account_name == NULL, we must update all (option All) */
2163         if (!account_name)
2164                 modest_ui_actions_do_send_receive_all (win);
2165         else
2166                 modest_ui_actions_do_send_receive (account_name, win);
2167
2168 }
2169
2170 static void
2171 on_refresh_account_action_activated  (GtkAction *action,
2172                                       gpointer user_data)
2173 {
2174         refresh_account ((const gchar*) user_data);
2175 }
2176
2177 static void
2178 on_send_receive_csm_activated (GtkMenuItem *item,
2179                                gpointer user_data)
2180 {
2181         refresh_account ((const gchar*) user_data);
2182 }
2183
2184 static gboolean
2185 on_zoom_minus_plus_not_implemented (ModestWindow *window)
2186 {
2187         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (window), FALSE);
2188
2189         hildon_banner_show_information (NULL, NULL, dgettext("hildon-common-strings", "ckct_ib_cannot_zoom_here"));
2190         return FALSE;
2191
2192 }
2193
2194 static gboolean
2195 on_folder_view_focus_in (GtkWidget *widget,
2196                          GdkEventFocus *event,
2197                          gpointer userdata)
2198 {
2199         ModestMainWindow *main_window = NULL;
2200
2201         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (userdata), FALSE);
2202         main_window = MODEST_MAIN_WINDOW (userdata);
2203
2204         /* Update toolbar dimming state */
2205         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2206
2207         return FALSE;
2208 }
2209
2210 static gboolean
2211 on_header_view_focus_in (GtkWidget *widget,
2212                          GdkEventFocus *event,
2213                          gpointer userdata)
2214 {
2215         ModestMainWindow *main_window = NULL;
2216         ModestMainWindowPrivate *priv = NULL;
2217
2218         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (userdata), FALSE);
2219         main_window = MODEST_MAIN_WINDOW (userdata);
2220         priv = MODEST_MAIN_WINDOW_GET_PRIVATE (main_window);
2221
2222         if (modest_header_view_has_selected_headers (MODEST_HEADER_VIEW (priv->header_view))) {
2223                 TnyList *selection = modest_header_view_get_selected_headers (MODEST_HEADER_VIEW (priv->header_view));
2224                 TnyIterator *iterator = tny_list_create_iterator (selection);
2225                 TnyHeader *header;
2226
2227                 tny_iterator_first (iterator);
2228                 header = TNY_HEADER (tny_iterator_get_current (iterator));
2229
2230                 if (tny_header_get_subject (header))
2231                         gtk_window_set_title (GTK_WINDOW(main_window), tny_header_get_subject (header));
2232                 else
2233                         gtk_window_set_title (GTK_WINDOW (main_window), _("mail_va_no_subject"));
2234
2235                 if (header)
2236                         g_object_unref (header);
2237
2238                 g_object_unref (iterator);
2239                 g_object_unref (selection);
2240         }
2241
2242
2243         /* Update toolbar dimming state */
2244         modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
2245
2246         return FALSE;
2247 }
2248
2249 static void
2250 modest_main_window_on_folder_selection_changed (ModestFolderView *folder_view,
2251                                                 TnyFolderStore *folder_store,
2252                                                 gboolean selected,
2253                                                 ModestMainWindow *main_window)
2254 {
2255         ModestWindowPrivate *parent_priv = MODEST_WINDOW_GET_PRIVATE (main_window);
2256         GtkAction *action = NULL;
2257         gboolean show_reply = TRUE;
2258         gboolean show_forward = TRUE;
2259         gboolean show_cancel_send = FALSE;
2260         gboolean show_clipboard = TRUE;
2261         gboolean show_delete = TRUE;
2262
2263         if (selected) {
2264                 if (TNY_IS_ACCOUNT (folder_store)) {
2265                         show_reply = show_forward = show_cancel_send = show_clipboard = show_delete = FALSE;
2266                 } else if (TNY_IS_FOLDER (folder_store)) {
2267                         if (modest_tny_folder_is_local_folder (TNY_FOLDER (folder_store))) {
2268                                 TnyFolderType folder_type = modest_tny_folder_get_local_or_mmc_folder_type (
2269                                         TNY_FOLDER (folder_store));
2270                                 switch (folder_type) {
2271                                 case TNY_FOLDER_TYPE_DRAFTS:
2272                                         show_clipboard = show_delete = TRUE;
2273                                         show_reply = show_forward = show_cancel_send = FALSE;
2274                                         break;
2275                                 case TNY_FOLDER_TYPE_SENT:
2276                                         show_forward = show_clipboard = show_delete = TRUE;
2277                                         show_reply = show_cancel_send = FALSE;
2278                                         break;
2279                                 case TNY_FOLDER_TYPE_OUTBOX:
2280                                         show_clipboard = show_delete = show_cancel_send = TRUE;
2281                                         show_reply = show_forward = FALSE;
2282                                         break;
2283                                 default:
2284                                         show_reply = show_forward = show_clipboard = show_delete = TRUE;
2285                                         show_cancel_send = FALSE;
2286                                 }
2287                         } else {
2288                                 show_reply = show_forward = show_clipboard = show_delete = TRUE;
2289                                 show_cancel_send = FALSE;
2290                         }
2291                 }
2292         }
2293
2294         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMReply");
2295         gtk_action_set_visible (action, show_reply);
2296         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMReplyAll");
2297         gtk_action_set_visible (action, show_reply);
2298         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMForward");
2299         gtk_action_set_visible (action, show_forward);
2300         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMCancelSending");
2301         gtk_action_set_visible (action, show_cancel_send);
2302         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMCut");
2303         gtk_action_set_visible (action, show_clipboard);
2304         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMCopy");
2305         gtk_action_set_visible (action, show_clipboard);
2306         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMPaste");
2307         gtk_action_set_visible (action, show_clipboard);
2308         action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMDelete");
2309         gtk_action_set_visible (action, show_delete);
2310
2311         /* We finally call to the ui actions handler, after updating properly
2312          * the header view CSM */
2313         modest_ui_actions_on_folder_selection_changed (folder_view, folder_store, selected, main_window);
2314
2315 }
2316
2317 gboolean
2318 modest_main_window_on_msg_view_window_msg_changed (ModestMsgViewWindow *view_window,
2319                                                    GtkTreeModel *model,
2320                                                    GtkTreeRowReference *row_reference,
2321                                                    ModestMainWindow *self)
2322 {
2323         ModestMainWindowPrivate *priv = NULL;
2324         GtkTreeModel *header_model = NULL;
2325         GtkTreePath *path = NULL;
2326
2327         g_return_val_if_fail (MODEST_MSG_VIEW_WINDOW (view_window), FALSE);
2328         g_return_val_if_fail (MODEST_MAIN_WINDOW (self), FALSE);
2329         g_return_val_if_fail (gtk_tree_row_reference_valid (row_reference), FALSE);
2330
2331         priv = MODEST_MAIN_WINDOW_GET_PRIVATE (self);
2332         header_model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->header_view));
2333
2334         /* Do nothing if we changed the folder in the main view */
2335         if (header_model != model)
2336                 return FALSE;
2337
2338         /* Select the message in the header view */
2339         path = gtk_tree_row_reference_get_path (row_reference);
2340         gtk_tree_view_set_cursor (GTK_TREE_VIEW (priv->header_view),
2341                                   path, NULL, FALSE);
2342         gtk_tree_path_free (path);
2343
2344         return TRUE;
2345 }