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 <hildon-widgets/hildon-window.h>
  31 #include <hildon-widgets/hildon-note.h>
  32
  33 #include <glib/gi18n.h>
  34 #include <gtk/gtktreeviewcolumn.h>
  35 #include <tny-account-store-view.h>
  36 #include <tny-simple-list.h>
  37
  38 #include <string.h>
  39
  40 #include "widgets/modest-main-window.h"
  41 #include "widgets/modest-msg-edit-window.h"
  42 #include "widgets/modest-account-view-window.h"
  43 #include "modest-runtime.h"
  44 #include "modest-account-mgr-helpers.h"
  45 #include "modest-platform.h"
  46 #include "modest-widget-memory.h"
  47 #include "modest-window-priv.h"
  48 #include "modest-main-window-ui.h"
  49 #include "modest-account-mgr.h"
  50 #include "modest-conf.h"
  51 #include <modest-maemo-utils.h>
  52 #include "modest-tny-platform-factory.h"
  53 #include "modest-tny-msg.h"
  54 #include "modest-mail-operation.h"
  55 #include "modest-icon-names.h"
  56
  57 /* 'private'/'protected' functions */
  58 static void modest_main_window_class_init    (ModestMainWindowClass *klass);
  59 static void modest_main_window_init          (ModestMainWindow *obj);
  60 static void modest_main_window_finalize      (GObject *obj);
  61 static gboolean modest_main_window_window_state_event (GtkWidget *widget,
  62                                                            GdkEventWindowState *event,
  63                                                            gpointer userdata);
  64
  65 static void connect_signals (ModestMainWindow *self);
  66 static void restore_sizes (ModestMainWindow *self);
  67 static void save_sizes (ModestMainWindow *self);
  68
  69 static void modest_main_window_show_toolbar   (ModestWindow *window,
  70                                                gboolean show_toolbar);
  71
  72 static void on_account_update                 (TnyAccountStore *account_store,
  73                                                gchar *account_name,
  74                                                gpointer user_data);
  75
  76 static gboolean on_inner_widgets_key_pressed  (GtkWidget *widget,
  77                                                GdkEventKey *event,
  78                                                gpointer user_data);
  79
  80 /* list my signals */
  81 enum {
  82         /* MY_SIGNAL_1, */
  83         /* MY_SIGNAL_2, */
  84         LAST_SIGNAL
  85 };
  86
  87 typedef struct _ModestMainWindowPrivate ModestMainWindowPrivate;
  88 struct _ModestMainWindowPrivate {
  89         GtkWidget *msg_paned;
  90         GtkWidget *main_paned;
  91         GtkWidget *main_vbox;
  92         GtkWidget *progress_bar;
  93
  94         ModestHeaderView *header_view;
  95         ModestFolderView *folder_view;
  96
  97         ModestMainWindowStyle style;
  98 };
  99 #define MODEST_MAIN_WINDOW_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
 100                                                 MODEST_TYPE_MAIN_WINDOW, \
 101                                                 ModestMainWindowPrivate))
 102
 103 typedef struct _GetMsgAsyncHelper {
 104         ModestMainWindowPrivate *main_window_private;
 105         guint action;
 106         ModestTnyMsgReplyType reply_type;
 107         ModestTnyMsgForwardType forward_type;
 108         gchar *from;
 109         TnyIterator *iter;
 110 } GetMsgAsyncHelper;
 111
 112
 113 /* globals */
 114 static GtkWindowClass *parent_class = NULL;
 115
 116 /* uncomment the following if you have defined any signals */
 117 /* static guint signals[LAST_SIGNAL] = {0}; */
 118
 119 GType
 120 modest_main_window_get_type (void)
 121 {
 122         static GType my_type = 0;
 123         if (!my_type) {
 124                 static const GTypeInfo my_info = {
 125                         sizeof(ModestMainWindowClass),
 126                         NULL,           /* base init */
 127                         NULL,           /* base finalize */
 128                         (GClassInitFunc) modest_main_window_class_init,
 129                         NULL,           /* class finalize */
 130                         NULL,           /* class data */
 131                         sizeof(ModestMainWindow),
 132                         1,              /* n_preallocs */
 133                         (GInstanceInitFunc) modest_main_window_init,
 134                         NULL
 135                 };
 136                 my_type = g_type_register_static (MODEST_TYPE_WINDOW,
 137                                                   "ModestMainWindow",
 138                                                   &my_info, 0);
 139         }
 140         return my_type;
 141 }
 142
 143 static void
 144 modest_main_window_class_init (ModestMainWindowClass *klass)
 145 {
 146         GObjectClass *gobject_class;
 147         gobject_class = (GObjectClass*) klass;
 148         ModestWindowClass *modest_window_class;
 149
 150         modest_window_class = (ModestWindowClass *) klass;
 151
 152         parent_class            = g_type_class_peek_parent (klass);
 153         gobject_class->finalize = modest_main_window_finalize;
 154
 155         modest_window_class->show_toolbar_func = modest_main_window_show_toolbar;
 156
 157         g_type_class_add_private (gobject_class, sizeof(ModestMainWindowPrivate));
 158 }
 159
 160 static void
 161 modest_main_window_init (ModestMainWindow *obj)
 162 {
 163         ModestMainWindowPrivate *priv;
 164
 165         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(obj);
 166
 167         priv->msg_paned    = NULL;
 168         priv->main_paned   = NULL;
 169         priv->main_vbox    = NULL;
 170         priv->header_view  = NULL;
 171         priv->folder_view  = NULL;
 172         priv->style  = MODEST_MAIN_WINDOW_STYLE_SPLIT;
 173
 174         /* progress bar */
 175         priv->progress_bar = gtk_progress_bar_new ();
 176         gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(priv->progress_bar), 1.0);
 177         gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR(priv->progress_bar),
 178                                         PANGO_ELLIPSIZE_END);
 179 }
 180
 181 static void
 182 modest_main_window_finalize (GObject *obj)
 183 {
 184         G_OBJECT_CLASS(parent_class)->finalize (obj);
 185 }
 186
 187 GtkWidget*
 188 modest_main_window_get_child_widget (ModestMainWindow *self,
 189                                      ModestWidgetType widget_type)
 190 {
 191         ModestMainWindowPrivate *priv;
 192         GtkWidget *widget;
 193
 194         g_return_val_if_fail (self, NULL);
 195         g_return_val_if_fail (widget_type >= 0 && widget_type < MODEST_WIDGET_TYPE_NUM,
 196                               NULL);
 197
 198         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 199
 200         switch (widget_type) {
 201         case MODEST_WIDGET_TYPE_HEADER_VIEW:
 202                 widget = (GtkWidget*)priv->header_view; break;
 203         case MODEST_WIDGET_TYPE_FOLDER_VIEW:
 204                 widget = (GtkWidget*)priv->folder_view; break;
 205         default:
 206                 return NULL;
 207         }
 208
 209         return widget ? GTK_WIDGET(widget) : NULL;
 210 }
 211
 212
 213
 214 static void
 215 restore_sizes (ModestMainWindow *self)
 216 {
 217         ModestConf *conf;
 218         ModestMainWindowPrivate *priv;
 219
 220         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 221
 222         conf = modest_runtime_get_conf ();
 223
 224         modest_widget_memory_restore (conf, G_OBJECT(priv->main_paned),
 225                                       "modest-main-paned");
 226         modest_widget_memory_restore (conf, G_OBJECT(priv->header_view),
 227                                       "header-view");
 228         modest_widget_memory_restore (conf, G_OBJECT(self),
 229                                       "modest-main-window");
 230 }
 231
 232
 233 static void
 234 save_sizes (ModestMainWindow *self)
 235 {
 236         ModestConf *conf;
 237         ModestMainWindowPrivate *priv;
 238
 239         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 240         conf = modest_runtime_get_conf ();
 241
 242         modest_widget_memory_save (conf,G_OBJECT(self), "modest-main-window");
 243         modest_widget_memory_save (conf, G_OBJECT(priv->main_paned),
 244                                    "modest-main-paned");
 245         modest_widget_memory_save (conf, G_OBJECT(priv->header_view), "header-view");
 246 }
 247
 248 static GtkWidget*
 249 wrapped_in_scrolled_window (GtkWidget *widget, gboolean needs_viewport)
 250 {
 251         GtkWidget *win;
 252
 253         win = gtk_scrolled_window_new (NULL, NULL);
 254         gtk_scrolled_window_set_policy
 255                 (GTK_SCROLLED_WINDOW (win),GTK_POLICY_NEVER,
 256                  GTK_POLICY_AUTOMATIC);
 257
 258         if (needs_viewport)
 259                 gtk_scrolled_window_add_with_viewport
 260                         (GTK_SCROLLED_WINDOW(win), widget);
 261         else
 262                 gtk_container_add (GTK_CONTAINER(win),
 263                                    widget);
 264
 265         return win;
 266 }
 267
 268
 269 static gboolean
 270 on_delete_event (GtkWidget *widget, GdkEvent  *event, ModestMainWindow *self)
 271 {
 272         save_sizes (self);
 273         return FALSE;
 274 }
 275
 276 static void
 277 connect_signals (ModestMainWindow *self)
 278 {
 279         ModestWindowPrivate *parent_priv;
 280         ModestMainWindowPrivate *priv;
 281         GtkWidget *menu;
 282
 283         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 284         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 285
 286         /* folder view */
 287         g_signal_connect (G_OBJECT(priv->folder_view), "key-press-event",
 288                           G_CALLBACK(on_inner_widgets_key_pressed), self);
 289         g_signal_connect (G_OBJECT(priv->folder_view), "folder_selection_changed",
 290                           G_CALLBACK(modest_ui_actions_on_folder_selection_changed), self);
 291
 292         menu = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/FolderViewContextMenu");
 293         gtk_widget_tap_and_hold_setup (GTK_WIDGET (priv->folder_view), menu, NULL, 0);
 294
 295         /* header view */
 296 /*      g_signal_connect (G_OBJECT(priv->header_view), "status_update", */
 297 /*                        G_CALLBACK(modest_ui_actions_on_header_status_update), self); */
 298         g_signal_connect (G_OBJECT(priv->header_view), "header_selected",
 299                           G_CALLBACK(modest_ui_actions_on_header_selected), self);
 300         g_signal_connect (G_OBJECT(priv->header_view), "header_activated",
 301                           G_CALLBACK(modest_ui_actions_on_header_activated), self);
 302         g_signal_connect (G_OBJECT(priv->header_view), "item_not_found",
 303                           G_CALLBACK(modest_ui_actions_on_item_not_found), self);
 304         g_signal_connect (G_OBJECT(priv->header_view), "key-press-event",
 305                           G_CALLBACK(on_inner_widgets_key_pressed), self);
 306
 307         /* window */
 308         g_signal_connect (G_OBJECT(self), "delete-event", G_CALLBACK(on_delete_event), self);
 309         g_signal_connect (G_OBJECT (self), "window-state-event",
 310                           G_CALLBACK (modest_main_window_window_state_event),
 311                           NULL);
 312         g_signal_connect (G_OBJECT(self), "delete-event", G_CALLBACK(on_delete_event), self);
 313
 314         /* Track account changes. We need to refresh the toolbar */
 315         g_signal_connect (G_OBJECT (modest_runtime_get_account_store ()),
 316                           "account_update",
 317                           G_CALLBACK (on_account_update),
 318                           self);
 319 }
 320
 321
 322 gboolean
 323 sync_accounts_cb (ModestMainWindow *win)
 324 {
 325         modest_ui_actions_on_send_receive (NULL, MODEST_WINDOW(win));
 326         return FALSE;
 327 }
 328
 329
 330 ModestWindow*
 331 modest_main_window_new (void)
 332 {
 333         ModestMainWindow *self;
 334         ModestMainWindowPrivate *priv;
 335         ModestWindowPrivate *parent_priv;
 336         GtkWidget *header_win, *folder_win;
 337         GtkActionGroup *action_group;
 338         GError *error = NULL;
 339         TnyFolderStoreQuery *query;
 340         GdkPixbuf *window_icon;
 341         ModestConf *conf;
 342         GtkAction *action;
 343
 344         self  = MODEST_MAIN_WINDOW(g_object_new(MODEST_TYPE_MAIN_WINDOW, NULL));
 345         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 346         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 347
 348         parent_priv->ui_manager = gtk_ui_manager_new();
 349         action_group = gtk_action_group_new ("ModestMainWindowActions");
 350         gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
 351
 352         /* Add common actions */
 353         gtk_action_group_add_actions (action_group,
 354                                       modest_action_entries,
 355                                       G_N_ELEMENTS (modest_action_entries),
 356                                       self);
 357
 358         gtk_action_group_add_toggle_actions (action_group,
 359                                              modest_toggle_action_entries,
 360                                              G_N_ELEMENTS (modest_toggle_action_entries),
 361                                              self);
 362
 363         gtk_ui_manager_insert_action_group (parent_priv->ui_manager, action_group, 0);
 364         g_object_unref (action_group);
 365
 366         /* Load the UI definition */
 367         gtk_ui_manager_add_ui_from_file (parent_priv->ui_manager,
 368                                          MODEST_UIDIR "modest-main-window-ui.xml", &error);
 369         if (error != NULL) {
 370                 g_warning ("Could not merge modest-ui.xml: %s", error->message);
 371                 g_error_free (error);
 372                 error = NULL;
 373         }
 374
 375         /* Add accelerators */
 376         gtk_window_add_accel_group (GTK_WINDOW (self),
 377                                     gtk_ui_manager_get_accel_group (parent_priv->ui_manager));
 378
 379         /* Menubar. Update the state of some toggles */
 380         parent_priv->menubar = modest_maemo_utils_menubar_to_menu (parent_priv->ui_manager);
 381         conf = modest_runtime_get_conf ();
 382         action = gtk_ui_manager_get_action (parent_priv->ui_manager,
 383                                             "/MenuBar/ViewMenu/ViewShowToolbarMainMenu/ViewShowToolbarNormalScreenMenu");
 384         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
 385                                       modest_conf_get_bool (conf, MODEST_CONF_SHOW_TOOLBAR, NULL));
 386         action = gtk_ui_manager_get_action (parent_priv->ui_manager,
 387                                             "/MenuBar/ViewMenu/ViewShowToolbarMainMenu/ViewShowToolbarFullScreenMenu");
 388         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
 389                                       modest_conf_get_bool (conf, MODEST_CONF_SHOW_TOOLBAR_FULLSCREEN, NULL));
 390         hildon_window_set_menu (HILDON_WINDOW (self), GTK_MENU (parent_priv->menubar));
 391
 392         /* folder view */
 393         query = tny_folder_store_query_new ();
 394         tny_folder_store_query_add_item (query, NULL,
 395                                          TNY_FOLDER_STORE_QUERY_OPTION_SUBSCRIBED);
 396         priv->folder_view = MODEST_FOLDER_VIEW(modest_folder_view_new (query));
 397         if (!priv->folder_view)
 398                 g_printerr ("modest: cannot instantiate folder view\n");
 399         g_object_unref (G_OBJECT (query));
 400         modest_maemo_utils_get_device_name ();
 401
 402         /* header view */
 403         priv->header_view  =
 404                 MODEST_HEADER_VIEW(modest_header_view_new (NULL, MODEST_HEADER_VIEW_STYLE_DETAILS));
 405         if (!priv->header_view)
 406                 g_printerr ("modest: cannot instantiate header view\n");
 407         modest_header_view_set_style (priv->header_view, MODEST_HEADER_VIEW_STYLE_TWOLINES);
 408
 409         folder_win = wrapped_in_scrolled_window (GTK_WIDGET(priv->folder_view), FALSE);
 410         header_win = wrapped_in_scrolled_window (GTK_WIDGET(priv->header_view), FALSE);
 411
 412         /* paned */
 413         priv->main_paned = gtk_hpaned_new ();
 414         gtk_paned_add1 (GTK_PANED(priv->main_paned), folder_win);
 415         gtk_paned_add2 (GTK_PANED(priv->main_paned), header_win);
 416         gtk_widget_show (GTK_WIDGET(priv->header_view));
 417         gtk_tree_view_columns_autosize (GTK_TREE_VIEW(priv->header_view));
 418
 419         /* putting it all together... */
 420         priv->main_vbox = gtk_vbox_new (FALSE, 6);
 421         gtk_box_pack_start (GTK_BOX(priv->main_vbox), priv->main_paned, TRUE, TRUE,0);
 422
 423         gtk_container_add (GTK_CONTAINER(self), priv->main_vbox);
 424         restore_sizes (MODEST_MAIN_WINDOW(self));
 425
 426         /* Set window icon */
 427         window_icon = modest_platform_get_icon (MODEST_APP_ICON);
 428         gtk_window_set_icon (GTK_WINDOW (self), window_icon);
 429
 430         /* Connect signals */
 431         connect_signals (self);
 432
 433         /* Set account store */
 434         tny_account_store_view_set_account_store (TNY_ACCOUNT_STORE_VIEW (priv->folder_view),
 435                                                   TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
 436         g_idle_add ((GSourceFunc)sync_accounts_cb, self);
 437         /* do send & receive when we are idle */
 438
 439         g_message ("online? %s",
 440                    tny_device_is_online (modest_runtime_get_device()) ? "yes" : "no");
 441
 442         return MODEST_WINDOW(self);
 443 }
 444
 445 gboolean
 446 modest_main_window_close_all (ModestMainWindow *self)
 447 {
 448         GtkWidget *note;
 449         GtkResponseType response;
 450
 451         /* Create the confirmation dialog MSG-NOT308 */
 452         note = hildon_note_new_confirmation_add_buttons (GTK_WINDOW (self),
 453                                                          _("emev_nc_close_windows"),
 454                                                          _("mcen_db_yes"), GTK_RESPONSE_YES,
 455                                                          _("mcen_db_no"), GTK_RESPONSE_NO,
 456                                                          NULL);
 457
 458         response = gtk_dialog_run (GTK_DIALOG (note));
 459         gtk_widget_destroy (GTK_WIDGET (note));
 460
 461         if (response == GTK_RESPONSE_YES)
 462                 return TRUE;
 463         else
 464                 return FALSE;
 465 }
 466
 467 void
 468 modest_main_window_set_style (ModestMainWindow *self,
 469                               ModestMainWindowStyle style)
 470 {
 471         ModestMainWindowPrivate *priv;
 472         GtkWidget *scrolled_win;
 473
 474         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
 475
 476         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 477
 478         /* no change -> nothing to do */
 479         if (priv->style == style)
 480                 return;
 481
 482         priv->style = style;
 483         scrolled_win = gtk_widget_get_parent (GTK_WIDGET (priv->header_view));
 484
 485         switch (style) {
 486         case MODEST_MAIN_WINDOW_STYLE_SIMPLE:
 487                 /* Remove main paned */
 488                 g_object_ref (priv->main_paned);
 489                 gtk_container_remove (GTK_CONTAINER (priv->main_vbox), priv->main_paned);
 490
 491                 /* Reparent header view with scrolled window */
 492                 gtk_widget_reparent (scrolled_win, priv->main_vbox);
 493
 494                 break;
 495         case MODEST_MAIN_WINDOW_STYLE_SPLIT:
 496                 /* Remove header view */
 497                 g_object_ref (scrolled_win);
 498                 gtk_container_remove (GTK_CONTAINER (priv->main_vbox), scrolled_win);
 499
 500                 /* Reparent the main paned */
 501                 gtk_paned_add2 (GTK_PANED (priv->main_paned), scrolled_win);
 502                 gtk_container_add (GTK_CONTAINER (priv->main_vbox), priv->main_paned);
 503                 break;
 504         default:
 505                 g_return_if_reached ();
 506         }
 507
 508         /* Let header view grab the focus */
 509         gtk_widget_grab_focus (GTK_WIDGET (priv->header_view));
 510
 511         /* Show changes */
 512         gtk_widget_show_all (GTK_WIDGET (priv->main_vbox));
 513 }
 514
 515 ModestMainWindowStyle
 516 modest_main_window_get_style (ModestMainWindow *self)
 517 {
 518         ModestMainWindowPrivate *priv;
 519
 520         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (self), -1);
 521
 522         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 523         return priv->style;
 524 }
 525
 526 static gboolean
 527 modest_main_window_window_state_event (GtkWidget *widget, GdkEventWindowState *event, gpointer userdata)
 528 {
 529         if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) {
 530                 ModestWindowPrivate *parent_priv;
 531                 ModestWindowMgr *mgr;
 532                 gboolean is_fullscreen;
 533                 GtkAction *fs_toggle_action;
 534                 gboolean active;
 535
 536                 mgr = modest_runtime_get_window_mgr ();
 537
 538                 is_fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
 539
 540                 parent_priv = MODEST_WINDOW_GET_PRIVATE (widget);
 541
 542                 fs_toggle_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ViewMenu/ViewToggleFullscreenMenu");
 543                 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (fs_toggle_action)))?1:0;
 544                 if (is_fullscreen != active) {
 545                         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (fs_toggle_action), is_fullscreen);
 546                 }
 547         }
 548
 549         return FALSE;
 550
 551 }
 552
 553 static void
 554 set_homogeneous (GtkWidget *widget,
 555                  gpointer data)
 556 {
 557         gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), TRUE);
 558         gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), TRUE);
 559 }
 560
 561 static void
 562 modest_main_window_show_toolbar (ModestWindow *self,
 563                                  gboolean show_toolbar)
 564 {
 565         ModestWindowPrivate *parent_priv;
 566         GtkWidget *reply_button = NULL, *menu = NULL;
 567
 568         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 569
 570         if (!parent_priv->toolbar && show_toolbar) {
 571                 parent_priv->toolbar = gtk_ui_manager_get_widget (parent_priv->ui_manager,
 572                                                                   "/ToolBar");
 573
 574                 /* Set homogeneous toolbar */
 575                 gtk_container_foreach (GTK_CONTAINER (parent_priv->toolbar),
 576                                        set_homogeneous, NULL);
 577
 578                 /* Add to window */
 579                 hildon_window_add_toolbar (HILDON_WINDOW (self),
 580                                            GTK_TOOLBAR (parent_priv->toolbar));
 581
 582                 /* Set reply button tap and hold menu */
 583                 reply_button = gtk_ui_manager_get_widget (parent_priv->ui_manager,
 584                                                           "/ToolBar/ToolbarMessageReply");
 585                 menu = gtk_ui_manager_get_widget (parent_priv->ui_manager,
 586                                                   "/ToolbarReplyContextMenu");
 587                 gtk_widget_tap_and_hold_setup (GTK_WIDGET (reply_button), menu, NULL, 0);
 588
 589                 /* Set send & receive button tap and hold menu */
 590                 on_account_update (TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()),
 591                                    NULL, self);
 592         }
 593
 594
 595         if (show_toolbar)
 596                 gtk_widget_show (GTK_WIDGET (parent_priv->toolbar));
 597         else
 598                 gtk_widget_hide (GTK_WIDGET (parent_priv->toolbar));
 599 }
 600
 601 /*
 602  * TODO: modify the menu dinamically. Add handlers to each item of the
 603  * menu when created
 604  */
 605 static void
 606 on_account_update (TnyAccountStore *account_store,
 607                    gchar *accout_name,
 608                    gpointer user_data)
 609 {
 610         ModestMainWindow *self;
 611         ModestWindowPrivate *parent_priv;
 612         TnyList *account_list;
 613         GtkWidget *popup = NULL, *item, *send_receive_button;
 614         TnyIterator *iter;
 615         ModestAccountMgr *mgr;
 616         gchar *default_account;
 617
 618         self = MODEST_MAIN_WINDOW (user_data);
 619         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 620
 621         /* If there is no toolbar then exit */
 622         if (!parent_priv->toolbar)
 623                 return;
 624
 625         /* Get accounts */
 626         account_list = tny_simple_list_new ();
 627         tny_account_store_get_accounts (account_store,
 628                                         account_list,
 629                                         TNY_ACCOUNT_STORE_STORE_ACCOUNTS);
 630
 631         /* If there is only one account do not show any menu */
 632         if (tny_list_get_length (account_list) <= 1)
 633                 goto free;
 634
 635         /* Get send receive button */
 636         send_receive_button = gtk_ui_manager_get_widget (parent_priv->ui_manager,
 637                                                           "/ToolBar/ToolbarSendReceive");
 638
 639         /* Create the menu */
 640         popup = gtk_menu_new ();
 641         item = gtk_menu_item_new_with_label (_("FIXME All"));
 642         gtk_menu_shell_append (GTK_MENU_SHELL (popup), GTK_WIDGET (item));
 643         item = gtk_separator_menu_item_new ();
 644         gtk_menu_shell_append (GTK_MENU_SHELL (popup), GTK_WIDGET (item));
 645
 646         iter = tny_list_create_iterator (account_list);
 647         mgr = modest_runtime_get_account_mgr ();
 648         default_account = modest_account_mgr_get_default_account (mgr);
 649
 650         do {
 651                 TnyAccount *acc;
 652                 const gchar *acc_name;
 653
 654                 /* Create tool item */
 655                 acc = TNY_ACCOUNT (tny_iterator_get_current (iter));
 656                 acc_name = tny_account_get_name (acc);
 657
 658                 if (!strcmp (default_account, acc_name)) {
 659                         gchar *bold_name;
 660                         bold_name = g_strdup_printf ("<b>%s</b>", acc_name);
 661                         item = gtk_menu_item_new_with_label (bold_name);
 662                         g_free (bold_name);
 663                 } else {
 664                         item = gtk_menu_item_new_with_label (acc_name);
 665                 }
 666                 g_object_unref (acc);
 667
 668                 /* Append item */
 669                 gtk_menu_shell_append (GTK_MENU_SHELL (popup), GTK_WIDGET (item));
 670
 671                 /* Go to next */
 672                 tny_iterator_next (iter);
 673
 674         } while (!tny_iterator_is_done (iter));
 675
 676         g_object_unref (iter);
 677
 678         /* Mandatory in order to view the menu contents */
 679         gtk_widget_show_all (popup);
 680
 681         /* Setup tap_and_hold */
 682         gtk_widget_tap_and_hold_setup (send_receive_button, popup, NULL, 0);
 683
 684  free:
 685
 686         /* Free */
 687         g_object_unref (account_list);
 688 }
 689
 690 /*
 691  * This function manages the key events used to navigate between
 692  * header and folder views (when the window is in split view)
 693  *
 694  * FROM         KEY        ACTION
 695  * -------------------------------------------------
 696  * HeaderView   GDK_Left   Move focus to folder view
 697  * FolderView   GDK_Right  Move focus to header view
 698  *
 699  * There is no need to scroll to selected row, the widgets will be the
 700  * responsibles of doing that (probably managing the focus-in event
 701  */
 702 static gboolean
 703 on_inner_widgets_key_pressed (GtkWidget *widget,
 704                               GdkEventKey *event,
 705                               gpointer user_data)
 706 {
 707         ModestMainWindowPrivate *priv;
 708
 709         priv = MODEST_MAIN_WINDOW_GET_PRIVATE (user_data);
 710
 711         /* Do nothing if we're in SIMPLE style */
 712         if (priv->style == MODEST_MAIN_WINDOW_STYLE_SIMPLE)
 713                 return FALSE;
 714
 715         if (MODEST_IS_HEADER_VIEW (widget) && event->keyval == GDK_Left)
 716                 gtk_widget_grab_focus (GTK_WIDGET (priv->folder_view));
 717         else if (MODEST_IS_FOLDER_VIEW (widget) && event->keyval == GDK_Right)
 718                 gtk_widget_grab_focus (GTK_WIDGET (priv->header_view));
 719
 720         return FALSE;
 721 }