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 *accounts_popup;
  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->accounts_popup  = NULL;
 173         priv->style  = MODEST_MAIN_WINDOW_STYLE_SPLIT;
 174 }
 175
 176 static void
 177 modest_main_window_finalize (GObject *obj)
 178 {
 179         G_OBJECT_CLASS(parent_class)->finalize (obj);
 180 }
 181
 182 GtkWidget*
 183 modest_main_window_get_child_widget (ModestMainWindow *self,
 184                                      ModestWidgetType widget_type)
 185 {
 186         ModestMainWindowPrivate *priv;
 187         GtkWidget *widget;
 188
 189         g_return_val_if_fail (self, NULL);
 190         g_return_val_if_fail (widget_type >= 0 && widget_type < MODEST_WIDGET_TYPE_NUM,
 191                               NULL);
 192
 193         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 194
 195         switch (widget_type) {
 196         case MODEST_WIDGET_TYPE_HEADER_VIEW:
 197                 widget = (GtkWidget*)priv->header_view; break;
 198         case MODEST_WIDGET_TYPE_FOLDER_VIEW:
 199                 widget = (GtkWidget*)priv->folder_view; break;
 200         default:
 201                 return NULL;
 202         }
 203
 204         return widget ? GTK_WIDGET(widget) : NULL;
 205 }
 206
 207
 208
 209 static void
 210 restore_sizes (ModestMainWindow *self)
 211 {
 212         ModestConf *conf;
 213         ModestMainWindowPrivate *priv;
 214
 215         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 216
 217         conf = modest_runtime_get_conf ();
 218
 219         modest_widget_memory_restore (conf, G_OBJECT(priv->main_paned),
 220                                       "modest-main-paned");
 221         modest_widget_memory_restore (conf, G_OBJECT(priv->header_view),
 222                                       "header-view");
 223         modest_widget_memory_restore (conf, G_OBJECT(self),
 224                                       "modest-main-window");
 225 }
 226
 227
 228 static void
 229 save_sizes (ModestMainWindow *self)
 230 {
 231         ModestConf *conf;
 232         ModestMainWindowPrivate *priv;
 233
 234         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 235         conf = modest_runtime_get_conf ();
 236
 237         modest_widget_memory_save (conf,G_OBJECT(self), "modest-main-window");
 238         modest_widget_memory_save (conf, G_OBJECT(priv->main_paned),
 239                                    "modest-main-paned");
 240         modest_widget_memory_save (conf, G_OBJECT(priv->header_view), "header-view");
 241 }
 242
 243 static GtkWidget*
 244 wrapped_in_scrolled_window (GtkWidget *widget, gboolean needs_viewport)
 245 {
 246         GtkWidget *win;
 247
 248         win = gtk_scrolled_window_new (NULL, NULL);
 249         gtk_scrolled_window_set_policy
 250                 (GTK_SCROLLED_WINDOW (win),GTK_POLICY_NEVER,
 251                  GTK_POLICY_AUTOMATIC);
 252
 253         if (needs_viewport)
 254                 gtk_scrolled_window_add_with_viewport
 255                         (GTK_SCROLLED_WINDOW(win), widget);
 256         else
 257                 gtk_container_add (GTK_CONTAINER(win),
 258                                    widget);
 259
 260         return win;
 261 }
 262
 263
 264 static gboolean
 265 on_delete_event (GtkWidget *widget, GdkEvent  *event, ModestMainWindow *self)
 266 {
 267         save_sizes (self);
 268         return FALSE;
 269 }
 270
 271 static void
 272 connect_signals (ModestMainWindow *self)
 273 {
 274         ModestWindowPrivate *parent_priv;
 275         ModestMainWindowPrivate *priv;
 276         GtkWidget *menu;
 277
 278         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 279         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 280
 281         /* folder view */
 282         g_signal_connect (G_OBJECT(priv->folder_view), "key-press-event",
 283                           G_CALLBACK(on_inner_widgets_key_pressed), self);
 284         g_signal_connect (G_OBJECT(priv->folder_view), "folder_selection_changed",
 285                           G_CALLBACK(modest_ui_actions_on_folder_selection_changed), self);
 286         g_signal_connect (G_OBJECT(priv->folder_view), "folder-display-name-changed",
 287                           G_CALLBACK(modest_ui_actions_on_folder_display_name_changed), self);
 288
 289         menu = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/FolderViewContextMenu");
 290         gtk_widget_tap_and_hold_setup (GTK_WIDGET (priv->folder_view), menu, NULL, 0);
 291
 292         /* header view */
 293 /*      g_signal_connect (G_OBJECT(priv->header_view), "status_update", */
 294 /*                        G_CALLBACK(modest_ui_actions_on_header_status_update), self); */
 295         g_signal_connect (G_OBJECT(priv->header_view), "header_selected",
 296                           G_CALLBACK(modest_ui_actions_on_header_selected), self);
 297         g_signal_connect (G_OBJECT(priv->header_view), "header_activated",
 298                           G_CALLBACK(modest_ui_actions_on_header_activated), self);
 299         g_signal_connect (G_OBJECT(priv->header_view), "item_not_found",
 300                           G_CALLBACK(modest_ui_actions_on_item_not_found), self);
 301         g_signal_connect (G_OBJECT(priv->header_view), "key-press-event",
 302                           G_CALLBACK(on_inner_widgets_key_pressed), self);
 303
 304         /* window */
 305         g_signal_connect (G_OBJECT(self), "delete-event", G_CALLBACK(on_delete_event), self);
 306         g_signal_connect (G_OBJECT (self), "window-state-event",
 307                           G_CALLBACK (modest_main_window_window_state_event),
 308                           NULL);
 309         g_signal_connect (G_OBJECT(self), "delete-event", G_CALLBACK(on_delete_event), self);
 310
 311         /* Track account changes. We need to refresh the toolbar */
 312         g_signal_connect (G_OBJECT (modest_runtime_get_account_store ()),
 313                           "account_update",
 314                           G_CALLBACK (on_account_update),
 315                           self);
 316 }
 317
 318
 319 gboolean
 320 sync_accounts_cb (ModestMainWindow *win)
 321 {
 322         modest_ui_actions_on_send_receive (NULL, MODEST_WINDOW(win));
 323         return FALSE;
 324 }
 325
 326
 327 ModestWindow*
 328 modest_main_window_new (void)
 329 {
 330         ModestMainWindow *self;
 331         ModestMainWindowPrivate *priv;
 332         ModestWindowPrivate *parent_priv;
 333         GtkWidget *header_win, *folder_win;
 334         GtkActionGroup *action_group;
 335         GError *error = NULL;
 336         TnyFolderStoreQuery *query;
 337         GdkPixbuf *window_icon;
 338         ModestConf *conf;
 339         GtkAction *action;
 340
 341         self  = MODEST_MAIN_WINDOW(g_object_new(MODEST_TYPE_MAIN_WINDOW, NULL));
 342         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 343         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 344
 345         parent_priv->ui_manager = gtk_ui_manager_new();
 346         action_group = gtk_action_group_new ("ModestMainWindowActions");
 347         gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
 348
 349         /* Add common actions */
 350         gtk_action_group_add_actions (action_group,
 351                                       modest_action_entries,
 352                                       G_N_ELEMENTS (modest_action_entries),
 353                                       self);
 354
 355         gtk_action_group_add_toggle_actions (action_group,
 356                                              modest_toggle_action_entries,
 357                                              G_N_ELEMENTS (modest_toggle_action_entries),
 358                                              self);
 359
 360         gtk_ui_manager_insert_action_group (parent_priv->ui_manager, action_group, 0);
 361         g_object_unref (action_group);
 362
 363         /* Load the UI definition */
 364         gtk_ui_manager_add_ui_from_file (parent_priv->ui_manager,
 365                                          MODEST_UIDIR "modest-main-window-ui.xml", &error);
 366         if (error != NULL) {
 367                 g_warning ("Could not merge modest-ui.xml: %s", error->message);
 368                 g_error_free (error);
 369                 error = NULL;
 370         }
 371
 372         /* Add accelerators */
 373         gtk_window_add_accel_group (GTK_WINDOW (self),
 374                                     gtk_ui_manager_get_accel_group (parent_priv->ui_manager));
 375
 376         /* Menubar. Update the state of some toggles */
 377         parent_priv->menubar = modest_maemo_utils_menubar_to_menu (parent_priv->ui_manager);
 378         conf = modest_runtime_get_conf ();
 379         action = gtk_ui_manager_get_action (parent_priv->ui_manager,
 380                                             "/MenuBar/ViewMenu/ViewShowToolbarMainMenu/ViewShowToolbarNormalScreenMenu");
 381         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
 382                                       modest_conf_get_bool (conf, MODEST_CONF_SHOW_TOOLBAR, NULL));
 383         action = gtk_ui_manager_get_action (parent_priv->ui_manager,
 384                                             "/MenuBar/ViewMenu/ViewShowToolbarMainMenu/ViewShowToolbarFullScreenMenu");
 385         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
 386                                       modest_conf_get_bool (conf, MODEST_CONF_SHOW_TOOLBAR_FULLSCREEN, NULL));
 387         hildon_window_set_menu (HILDON_WINDOW (self), GTK_MENU (parent_priv->menubar));
 388
 389         /* folder view */
 390         query = tny_folder_store_query_new ();
 391         tny_folder_store_query_add_item (query, NULL,
 392                                          TNY_FOLDER_STORE_QUERY_OPTION_SUBSCRIBED);
 393         priv->folder_view = MODEST_FOLDER_VIEW(modest_folder_view_new (query));
 394         if (!priv->folder_view)
 395                 g_printerr ("modest: cannot instantiate folder view\n");
 396         g_object_unref (G_OBJECT (query));
 397         modest_maemo_utils_get_device_name ();
 398
 399         /* header view */
 400         priv->header_view  =
 401                 MODEST_HEADER_VIEW(modest_header_view_new (NULL, MODEST_HEADER_VIEW_STYLE_DETAILS));
 402         if (!priv->header_view)
 403                 g_printerr ("modest: cannot instantiate header view\n");
 404         modest_header_view_set_style (priv->header_view, MODEST_HEADER_VIEW_STYLE_TWOLINES);
 405
 406         folder_win = wrapped_in_scrolled_window (GTK_WIDGET(priv->folder_view), FALSE);
 407         header_win = wrapped_in_scrolled_window (GTK_WIDGET(priv->header_view), FALSE);
 408
 409         /* paned */
 410         priv->main_paned = gtk_hpaned_new ();
 411         gtk_paned_add1 (GTK_PANED(priv->main_paned), folder_win);
 412         gtk_paned_add2 (GTK_PANED(priv->main_paned), header_win);
 413         gtk_widget_show (GTK_WIDGET(priv->header_view));
 414         gtk_tree_view_columns_autosize (GTK_TREE_VIEW(priv->header_view));
 415
 416         /* putting it all together... */
 417         priv->main_vbox = gtk_vbox_new (FALSE, 6);
 418         gtk_box_pack_start (GTK_BOX(priv->main_vbox), priv->main_paned, TRUE, TRUE,0);
 419
 420         gtk_container_add (GTK_CONTAINER(self), priv->main_vbox);
 421         restore_sizes (MODEST_MAIN_WINDOW(self));
 422
 423         /* Set window icon */
 424         window_icon = modest_platform_get_icon (MODEST_APP_ICON);
 425         gtk_window_set_icon (GTK_WINDOW (self), window_icon);
 426
 427         /* Connect signals */
 428         connect_signals (self);
 429
 430         /* Set account store */
 431         tny_account_store_view_set_account_store (TNY_ACCOUNT_STORE_VIEW (priv->folder_view),
 432                                                   TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()));
 433         g_idle_add ((GSourceFunc)sync_accounts_cb, self);
 434         /* do send & receive when we are idle */
 435
 436         g_message ("online? %s",
 437                    tny_device_is_online (modest_runtime_get_device()) ? "yes" : "no");
 438
 439         return MODEST_WINDOW(self);
 440 }
 441
 442 gboolean
 443 modest_main_window_close_all (ModestMainWindow *self)
 444 {
 445         GtkWidget *note;
 446         GtkResponseType response;
 447
 448         /* Create the confirmation dialog MSG-NOT308 */
 449         note = hildon_note_new_confirmation_add_buttons (GTK_WINDOW (self),
 450                                                          _("emev_nc_close_windows"),
 451                                                          _("mcen_db_yes"), GTK_RESPONSE_YES,
 452                                                          _("mcen_db_no"), GTK_RESPONSE_NO,
 453                                                          NULL);
 454
 455         response = gtk_dialog_run (GTK_DIALOG (note));
 456         gtk_widget_destroy (GTK_WIDGET (note));
 457
 458         if (response == GTK_RESPONSE_YES)
 459                 return TRUE;
 460         else
 461                 return FALSE;
 462 }
 463
 464 void
 465 modest_main_window_set_style (ModestMainWindow *self,
 466                               ModestMainWindowStyle style)
 467 {
 468         ModestMainWindowPrivate *priv;
 469         GtkWidget *scrolled_win;
 470
 471         g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
 472
 473         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 474
 475         /* no change -> nothing to do */
 476         if (priv->style == style)
 477                 return;
 478
 479         priv->style = style;
 480         scrolled_win = gtk_widget_get_parent (GTK_WIDGET (priv->header_view));
 481
 482         switch (style) {
 483         case MODEST_MAIN_WINDOW_STYLE_SIMPLE:
 484                 /* Remove main paned */
 485                 g_object_ref (priv->main_paned);
 486                 gtk_container_remove (GTK_CONTAINER (priv->main_vbox), priv->main_paned);
 487
 488                 /* Reparent header view with scrolled window */
 489                 gtk_widget_reparent (scrolled_win, priv->main_vbox);
 490
 491                 break;
 492         case MODEST_MAIN_WINDOW_STYLE_SPLIT:
 493                 /* Remove header view */
 494                 g_object_ref (scrolled_win);
 495                 gtk_container_remove (GTK_CONTAINER (priv->main_vbox), scrolled_win);
 496
 497                 /* Reparent the main paned */
 498                 gtk_paned_add2 (GTK_PANED (priv->main_paned), scrolled_win);
 499                 gtk_container_add (GTK_CONTAINER (priv->main_vbox), priv->main_paned);
 500                 break;
 501         default:
 502                 g_return_if_reached ();
 503         }
 504
 505         /* Let header view grab the focus */
 506         gtk_widget_grab_focus (GTK_WIDGET (priv->header_view));
 507
 508         /* Show changes */
 509         gtk_widget_show_all (GTK_WIDGET (priv->main_vbox));
 510 }
 511
 512 ModestMainWindowStyle
 513 modest_main_window_get_style (ModestMainWindow *self)
 514 {
 515         ModestMainWindowPrivate *priv;
 516
 517         g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (self), -1);
 518
 519         priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
 520         return priv->style;
 521 }
 522
 523 static gboolean
 524 modest_main_window_window_state_event (GtkWidget *widget, GdkEventWindowState *event, gpointer userdata)
 525 {
 526         if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) {
 527                 ModestWindowPrivate *parent_priv;
 528                 ModestWindowMgr *mgr;
 529                 gboolean is_fullscreen;
 530                 GtkAction *fs_toggle_action;
 531                 gboolean active;
 532
 533                 mgr = modest_runtime_get_window_mgr ();
 534
 535                 is_fullscreen = modest_window_mgr_get_fullscreen_mode (mgr);
 536
 537                 parent_priv = MODEST_WINDOW_GET_PRIVATE (widget);
 538
 539                 fs_toggle_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/MenuBar/ViewMenu/ViewToggleFullscreenMenu");
 540                 active = (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (fs_toggle_action)))?1:0;
 541                 if (is_fullscreen != active) {
 542                         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (fs_toggle_action), is_fullscreen);
 543                 }
 544         }
 545
 546         return FALSE;
 547
 548 }
 549
 550 static void
 551 set_homogeneous (GtkWidget *widget,
 552                  gpointer data)
 553 {
 554         gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), TRUE);
 555         gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), TRUE);
 556 }
 557
 558 static void
 559 modest_main_window_show_toolbar (ModestWindow *self,
 560                                  gboolean show_toolbar)
 561 {
 562         ModestWindowPrivate *parent_priv;
 563         GtkWidget *reply_button = NULL, *menu = NULL;
 564
 565         parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
 566
 567         if (!parent_priv->toolbar && show_toolbar) {
 568                 parent_priv->toolbar = gtk_ui_manager_get_widget (parent_priv->ui_manager,
 569                                                                   "/ToolBar");
 570
 571                 /* Set homogeneous toolbar */
 572                 gtk_container_foreach (GTK_CONTAINER (parent_priv->toolbar),
 573                                        set_homogeneous, NULL);
 574
 575                 /* Add to window */
 576                 hildon_window_add_toolbar (HILDON_WINDOW (self),
 577                                            GTK_TOOLBAR (parent_priv->toolbar));
 578
 579                 /* Set reply button tap and hold menu */
 580                 reply_button = gtk_ui_manager_get_widget (parent_priv->ui_manager,
 581                                                           "/ToolBar/ToolbarMessageReply");
 582                 menu = gtk_ui_manager_get_widget (parent_priv->ui_manager,
 583                                                   "/ToolbarReplyContextMenu");
 584                 gtk_widget_tap_and_hold_setup (GTK_WIDGET (reply_button), menu, NULL, 0);
 585
 586                 /* Set send & receive button tap and hold menu */
 587                 on_account_update (TNY_ACCOUNT_STORE (modest_runtime_get_account_store ()),
 588                                    NULL, self);
 589         }
 590
 591
 592         if (show_toolbar)
 593                 gtk_widget_show (GTK_WIDGET (parent_priv->toolbar));
 594         else
 595                 gtk_widget_hide (GTK_WIDGET (parent_priv->toolbar));
 596 }
 597
 598 /*
 599  * TODO: modify the menu dinamically. Add handlers to each item of the
 600  * menu when created
 601  */
 602 static void
 603 on_account_update (TnyAccountStore *account_store,
 604                    gchar *accout_name,
 605                    gpointer user_data)
 606 {
 607         ModestMainWindow *self;
 608         ModestMainWindowPrivate *priv;
 609         ModestWindowPrivate *parent_priv;
 610         TnyList *account_list;
 611         GtkWidget *item, *send_receive_button;
 612         TnyIterator *iter;
 613         ModestAccountMgr *mgr;
 614         gchar *default_account;
 615
 616         self = MODEST_MAIN_WINDOW (user_data);
 617         priv = MODEST_MAIN_WINDOW_GET_PRIVATE (self);
 618         parent_priv = MODEST_WINDOW_GET_PRIVATE (self);
 619
 620         /* If there is no toolbar then exit */
 621         if (!parent_priv->toolbar)
 622                 return;
 623
 624         if (priv->accounts_popup)
 625                 gtk_menu_detach (GTK_MENU (priv->accounts_popup));
 626
 627         /* Get accounts */
 628         account_list = tny_simple_list_new ();
 629         tny_account_store_get_accounts (account_store,
 630                                         account_list,
 631                                         TNY_ACCOUNT_STORE_STORE_ACCOUNTS);
 632
 633         /* If there is only one account do not show any menu */
 634         if (tny_list_get_length (account_list) <= 1)
 635                 goto free;
 636
 637         /* Get send receive button */
 638         send_receive_button = gtk_ui_manager_get_widget (parent_priv->ui_manager,
 639                                                           "/ToolBar/ToolbarSendReceive");
 640
 641         /* Create the menu */
 642         priv->accounts_popup = gtk_menu_new ();
 643         item = gtk_menu_item_new_with_label (_("mcen_me_toolbar_sendreceive_all"));
 644         gtk_menu_shell_append (GTK_MENU_SHELL (priv->accounts_popup), GTK_WIDGET (item));
 645         item = gtk_separator_menu_item_new ();
 646         gtk_menu_shell_append (GTK_MENU_SHELL (priv->accounts_popup), GTK_WIDGET (item));
 647
 648         iter = tny_list_create_iterator (account_list);
 649         mgr = modest_runtime_get_account_mgr ();
 650         default_account = modest_account_mgr_get_default_account (mgr);
 651
 652         do {
 653                 TnyAccount *acc;
 654                 const gchar *acc_name;
 655                 gchar *display_name;
 656
 657                 /* Create tool item */
 658                 acc = TNY_ACCOUNT (tny_iterator_get_current (iter));
 659                 acc_name = tny_account_get_name (acc);
 660
 661                 /* Create display name */
 662                 if (!strcmp (default_account, acc_name))
 663                         display_name = g_strdup_printf (_("mcen_me_toolbar_sendreceive_default"), acc_name);
 664                 else
 665                         display_name = g_strdup_printf (_("mcen_me_toolbar_sendreceive_mailbox_n"), acc_name);
 666
 667                 item = gtk_menu_item_new_with_label (display_name);
 668
 669                 /* Free */
 670                 g_free (display_name);
 671                 g_object_unref (acc);
 672
 673                 /* Append item */
 674                 gtk_menu_shell_append (GTK_MENU_SHELL (priv->accounts_popup), GTK_WIDGET (item));
 675
 676                 /* Go to next */
 677                 tny_iterator_next (iter);
 678
 679         } while (!tny_iterator_is_done (iter));
 680
 681         g_object_unref (iter);
 682
 683         /* Mandatory in order to view the menu contents */
 684         gtk_widget_show_all (priv->accounts_popup);
 685
 686         /* Setup tap_and_hold */
 687         gtk_widget_tap_and_hold_setup (send_receive_button, priv->accounts_popup, NULL, 0);
 688
 689  free:
 690
 691         /* Free */
 692         g_object_unref (account_list);
 693 }
 694
 695 /*
 696  * This function manages the key events used to navigate between
 697  * header and folder views (when the window is in split view)
 698  *
 699  * FROM         KEY        ACTION
 700  * -------------------------------------------------
 701  * HeaderView   GDK_Left   Move focus to folder view
 702  * FolderView   GDK_Right  Move focus to header view
 703  *
 704  * There is no need to scroll to selected row, the widgets will be the
 705  * responsibles of doing that (probably managing the focus-in event
 706  */
 707 static gboolean
 708 on_inner_widgets_key_pressed (GtkWidget *widget,
 709                               GdkEventKey *event,
 710                               gpointer user_data)
 711 {
 712         ModestMainWindowPrivate *priv;
 713
 714         priv = MODEST_MAIN_WINDOW_GET_PRIVATE (user_data);
 715
 716         /* Do nothing if we're in SIMPLE style */
 717         if (priv->style == MODEST_MAIN_WINDOW_STYLE_SIMPLE)
 718                 return FALSE;
 719
 720         if (MODEST_IS_HEADER_VIEW (widget) && event->keyval == GDK_Left)
 721                 gtk_widget_grab_focus (GTK_WIDGET (priv->folder_view));
 722         else if (MODEST_IS_FOLDER_VIEW (widget) && event->keyval == GDK_Right)
 723                 gtk_widget_grab_focus (GTK_WIDGET (priv->header_view));
 724
 725         return FALSE;
 726 }