git.maemo.org Git - modest/blob - src/widgets/modest-header-window.c

   1 /* Copyright (c) 2008, 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 <modest-header-window.h>
  31 #ifdef MODEST_TOOLKIT_HILDON2
  32 #include <hildon/hildon.h>
  33 #include <modest-maemo-utils.h>
  34 #endif
  35 #include <modest-scrollable.h>
  36 #include <modest-window-mgr.h>
  37 #include <modest-window-priv.h>
  38 #include <modest-signal-mgr.h>
  39 #include <modest-runtime.h>
  40 #include <modest-platform.h>
  41 #include <modest-icon-names.h>
  42 #include <modest-ui-constants.h>
  43 #include <modest-account-mgr.h>
  44 #include <modest-account-mgr-helpers.h>
  45 #include <modest-defs.h>
  46 #include <modest-widget-memory.h>
  47 #include <modest-ui-actions.h>
  48 #include <modest-platform.h>
  49 #include <modest-text-utils.h>
  50 #include <modest-ui-dimming-rules.h>
  51 #include <modest-tny-folder.h>
  52 #include <tny-simple-list.h>
  53 #include <gdk/gdkkeysyms.h>
  54 #include <modest-isearch-toolbar.h>
  55
  56 typedef enum {
  57         CONTENTS_STATE_NONE = 0,
  58         CONTENTS_STATE_EMPTY = 1,
  59         CONTENTS_STATE_HEADERS = 2
  60 } ContentsState;
  61
  62 #ifdef MODEST_TOOLKIT_HILDON2
  63 typedef enum {
  64         EDIT_MODE_COMMAND_MOVE = 1,
  65         EDIT_MODE_COMMAND_DELETE = 2,
  66 } EditModeCommand;
  67 #endif
  68
  69 typedef struct _ModestHeaderWindowPrivate ModestHeaderWindowPrivate;
  70 struct _ModestHeaderWindowPrivate {
  71
  72         GtkWidget *header_view;
  73         GtkWidget *empty_view;
  74         GtkWidget *contents_view;
  75         GtkWidget *top_vbox;
  76         GtkWidget *new_message_button;
  77         GtkWidget *show_more_button;
  78
  79         /* state bar */
  80         ContentsState contents_state;
  81
  82         /* autoscroll */
  83         gboolean autoscroll;
  84
  85         /* banners */
  86         GtkWidget *updating_banner;
  87         guint updating_banner_timeout;
  88
  89         /* signals */
  90         GSList *sighandlers;
  91         gulong queue_change_handler;
  92         gulong notify_model;
  93
  94         /* progress hint */
  95         gboolean progress_hint;
  96         gchar *current_store_account;
  97
  98         /* CSM menu */
  99         GtkWidget *csm_menu;
 100         gdouble x_coord;
 101         gdouble y_coord;
 102
 103         /* weak refs */
 104         GtkTreeModel *model_weak_ref;
 105
 106         GtkWidget   *isearch_toolbar;
 107 };
 108 #define MODEST_HEADER_WINDOW_GET_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE((o), \
 109                                                                           MODEST_TYPE_HEADER_WINDOW, \
 110                                                                           ModestHeaderWindowPrivate))
 111
 112 /* 'private'/'protected' functions */
 113 static void modest_header_window_class_init  (ModestHeaderWindowClass *klass);
 114 static void modest_header_window_init        (ModestHeaderWindow *obj);
 115 static void modest_header_window_finalize    (GObject *obj);
 116 static void modest_header_window_dispose     (GObject *obj);
 117
 118 static void connect_signals (ModestHeaderWindow *self);
 119 static void modest_header_window_disconnect_signals (ModestWindow *self);
 120
 121 static void setup_menu (ModestHeaderWindow *self);
 122 static GtkWidget *create_empty_view (ModestWindow *self);
 123 static GtkWidget *create_header_view (ModestWindow *progress_window,
 124                                       TnyFolder *folder);
 125
 126 static void update_view (ModestHeaderWindow *self,
 127                          TnyFolderChange *change);
 128 static void set_contents_state (ModestHeaderWindow *window,
 129                                 ContentsState state);
 130
 131 static void on_msg_count_changed (ModestHeaderView *header_view,
 132                                   TnyFolder *folder,
 133                                   TnyFolderChange *change,
 134                                   ModestHeaderWindow *header_window);
 135 static void on_header_activated (ModestHeaderView *header_view,
 136                                  TnyHeader *header,
 137                                  GtkTreePath *path,
 138                                  ModestHeaderWindow *header_window);
 139 static void on_updating_msg_list (ModestHeaderView *header_view,
 140                                   gboolean starting,
 141                                   gpointer user_data);
 142 #ifdef MODEST_TOOLKIT_HILDON2
 143 static void set_delete_edit_mode (GtkButton *button,
 144                                   ModestHeaderWindow *self);
 145 static void set_moveto_edit_mode (GtkButton *button,
 146                                   ModestHeaderWindow *self);
 147 #endif
 148 static gboolean on_expose_event(GtkTreeView *header_view,
 149                                 GdkEventExpose *event,
 150                                 gpointer user_data);
 151 static gboolean on_map_event (GtkWidget *widget,
 152                               GdkEvent *event,
 153                               gpointer userdata);
 154 #ifdef MODEST_TOOLKIT_HILDON2
 155 static void on_vertical_movement (HildonPannableArea *area,
 156                                   HildonMovementDirection direction,
 157                                   gdouble x, gdouble y, gpointer user_data);
 158 static void on_horizontal_movement (HildonPannableArea *hildonpannable,
 159                                     gint                direction,
 160                                     gdouble             initial_x,
 161                                     gdouble             initial_y,
 162                                     gpointer            user_data);
 163 #endif
 164 static void on_queue_changed    (ModestMailOperationQueue *queue,
 165                                  ModestMailOperation *mail_op,
 166                                  ModestMailOperationQueueNotification type,
 167                                  ModestHeaderWindow *self);
 168 static void modest_header_window_pack_toolbar (ModestWindow *self,
 169                                                GtkPackType pack_type,
 170                                                GtkWidget *toolbar);
 171 #ifdef MODEST_TOOLKIT_HILDON2
 172 static void edit_mode_changed (ModestHeaderWindow *header_window,
 173                                gint edit_mode_id,
 174                                gboolean enabled,
 175                                ModestHeaderWindow *self);
 176 #endif
 177 static void on_progress_list_changed (ModestWindowMgr *mgr,
 178                                       ModestHeaderWindow *self);
 179 static void update_progress_hint (ModestHeaderWindow *self);
 180 static void on_header_view_model_destroyed (gpointer user_data,
 181                                             GObject *model);
 182 #ifdef MODEST_TOOLKIT_HILDON2
 183 static gboolean on_key_press(GtkWidget *widget,
 184                                         GdkEventKey *event,
 185                                         gpointer user_data);
 186 #endif
 187
 188 static void  isearch_toolbar_close  (GtkWidget *widget,
 189                                      ModestHeaderWindow *obj);
 190 static void  isearch_toolbar_search (GtkWidget *widget,
 191                                      ModestHeaderWindow *obj);
 192 #ifndef MODEST_TOOLKIT_HILDON2
 193 static void  show_isearch_toolbar   (GtkWidget *obj, gpointer data);
 194 static void  toggle_isearch_toolbar (GtkWidget *obj,
 195                                      gpointer data);
 196 #endif
 197
 198
 199 /* globals */
 200 static GtkWindowClass *parent_class = NULL;
 201
 202 #define EMPTYVIEW_XALIGN 0.5
 203 #define EMPTYVIEW_YALIGN 0.5
 204 #define EMPTYVIEW_XSPACE 1.0
 205 #define EMPTYVIEW_YSPACE 1.0
 206
 207
 208
 209 /************************************************************************/
 210
 211 GType
 212 modest_header_window_get_type (void)
 213 {
 214         static GType my_type = 0;
 215         if (!my_type) {
 216                 static const GTypeInfo my_info = {
 217                         sizeof(ModestHeaderWindowClass),
 218                         NULL,           /* base init */
 219                         NULL,           /* base finalize */
 220                         (GClassInitFunc) modest_header_window_class_init,
 221                         NULL,           /* class finalize */
 222                         NULL,           /* class data */
 223                         sizeof(ModestHeaderWindow),
 224                         1,              /* n_preallocs */
 225                         (GInstanceInitFunc) modest_header_window_init,
 226                         NULL
 227                 };
 228                 my_type = g_type_register_static (
 229 #ifdef MODEST_TOOLKIT_HILDON2
 230                                                   MODEST_TYPE_HILDON2_WINDOW,
 231 #else
 232                                                   MODEST_TYPE_SHELL_WINDOW,
 233 #endif
 234                                                   "ModestHeaderWindow",
 235                                                   &my_info, 0);
 236         }
 237         return my_type;
 238 }
 239
 240 static void
 241 modest_header_window_class_init (ModestHeaderWindowClass *klass)
 242 {
 243         GObjectClass *gobject_class;
 244         gobject_class = (GObjectClass*) klass;
 245         ModestWindowClass *modest_window_class = (ModestWindowClass *) klass;
 246
 247         parent_class            = g_type_class_peek_parent (klass);
 248         gobject_class->finalize = modest_header_window_finalize;
 249         gobject_class->dispose = modest_header_window_dispose;
 250
 251         g_type_class_add_private (gobject_class, sizeof(ModestHeaderWindowPrivate));
 252
 253         modest_window_class->disconnect_signals_func = modest_header_window_disconnect_signals;
 254         modest_window_class->pack_toolbar_func = modest_header_window_pack_toolbar;
 255 }
 256
 257 static void
 258 modest_header_window_init (ModestHeaderWindow *obj)
 259 {
 260         ModestHeaderWindowPrivate *priv;
 261
 262         priv = MODEST_HEADER_WINDOW_GET_PRIVATE(obj);
 263
 264         priv->sighandlers = NULL;
 265
 266         priv->header_view = NULL;
 267         priv->empty_view = NULL;
 268         priv->top_vbox = NULL;
 269         priv->contents_view = NULL;
 270         priv->contents_state = CONTENTS_STATE_NONE;
 271         priv->updating_banner = NULL;
 272         priv->updating_banner_timeout = 0;
 273         priv->autoscroll = TRUE;
 274         priv->progress_hint = FALSE;
 275         priv->queue_change_handler = 0;
 276         priv->model_weak_ref = NULL;
 277         priv->current_store_account = NULL;
 278         priv->new_message_button = NULL;
 279         priv->x_coord = 0;
 280         priv->y_coord = 0;
 281         priv->notify_model = 0;
 282
 283 }
 284
 285 static void
 286 modest_header_window_dispose (GObject *obj)
 287 {
 288         ModestHeaderWindowPrivate *priv;
 289         TnyFolder *folder;
 290
 291         priv = MODEST_HEADER_WINDOW_GET_PRIVATE(obj);
 292
 293         folder = modest_header_view_get_folder ((ModestHeaderView *) priv->header_view);
 294         if (folder) {
 295                 tny_folder_sync_async (folder, TRUE, NULL, NULL, NULL);
 296                 g_object_unref (folder);
 297         }
 298
 299         G_OBJECT_CLASS(parent_class)->dispose (obj);
 300 }
 301
 302 static void
 303 modest_header_window_finalize (GObject *obj)
 304 {
 305         ModestHeaderWindowPrivate *priv;
 306
 307         priv = MODEST_HEADER_WINDOW_GET_PRIVATE(obj);
 308
 309         if (priv->model_weak_ref) {
 310                 g_object_weak_unref ((GObject *) priv->model_weak_ref,
 311                                      on_header_view_model_destroyed,
 312                                      obj);
 313                 on_header_view_model_destroyed (obj, (GObject *) priv->model_weak_ref);
 314         }
 315
 316         modest_header_window_disconnect_signals (MODEST_WINDOW (obj));
 317
 318         g_object_unref (priv->header_view);
 319         g_object_unref (priv->empty_view);
 320
 321         if (priv->current_store_account) {
 322                 g_free (priv->current_store_account);
 323                 priv->current_store_account = NULL;
 324         }
 325
 326         if (priv->updating_banner_timeout > 0) {
 327                 g_source_remove (priv->updating_banner_timeout);
 328                 priv->updating_banner_timeout = 0;
 329         }
 330         if (priv->updating_banner) {
 331                 gtk_widget_destroy (priv->updating_banner);
 332                 priv->updating_banner = NULL;
 333         }
 334
 335         G_OBJECT_CLASS(parent_class)->finalize (obj);
 336 }
 337
 338 static void
 339 modest_header_window_disconnect_signals (ModestWindow *self)
 340 {
 341         ModestHeaderWindowPrivate *priv;
 342
 343         priv = MODEST_HEADER_WINDOW_GET_PRIVATE(self);
 344
 345         if (g_signal_handler_is_connected ((GObject*) priv->header_view, priv->notify_model)) {
 346                 g_signal_handler_disconnect ((GObject*) priv->header_view, priv->notify_model);
 347                 priv->notify_model = 0;
 348         }
 349
 350         if (g_signal_handler_is_connected (G_OBJECT (modest_runtime_get_mail_operation_queue ()),
 351                                            priv->queue_change_handler)) {
 352                 g_signal_handler_disconnect (G_OBJECT (modest_runtime_get_mail_operation_queue ()),
 353                                              priv->queue_change_handler);
 354                 priv->queue_change_handler = 0;
 355         }
 356
 357         modest_signal_mgr_disconnect_all_and_destroy (priv->sighandlers);
 358         priv->sighandlers = NULL;
 359
 360 }
 361
 362 static void
 363 connect_signals (ModestHeaderWindow *self)
 364 {
 365         ModestHeaderWindowPrivate *priv = MODEST_HEADER_WINDOW_GET_PRIVATE(self);
 366
 367         /* header view */
 368
 369         priv->sighandlers =
 370                 modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view),
 371                                            "msg_count_changed",
 372                                            G_CALLBACK(on_msg_count_changed), self);
 373         priv->sighandlers =
 374                 modest_signal_mgr_connect (priv->sighandlers, G_OBJECT (priv->header_view),
 375                                            "header-activated",
 376                                            G_CALLBACK (on_header_activated), self);
 377         priv->sighandlers =
 378                 modest_signal_mgr_connect (priv->sighandlers,
 379                                            G_OBJECT (priv->header_view),
 380                                            "updating-msg-list",
 381                                            G_CALLBACK (on_updating_msg_list),
 382                                            self);
 383         priv->sighandlers =
 384                 modest_signal_mgr_connect (priv->sighandlers,
 385                                            G_OBJECT (priv->header_view),
 386                                            "expose-event",
 387                                            G_CALLBACK (on_expose_event),
 388                                            self);
 389
 390         priv->sighandlers =
 391                 modest_signal_mgr_connect (priv->sighandlers,
 392                                            G_OBJECT (self),
 393                                            "map-event",
 394                                            G_CALLBACK (on_map_event),
 395                                            self);
 396 #ifdef MODEST_TOOLKIT_HILDON2
 397         if (HILDON_IS_PANNABLE_AREA (priv->contents_view)) {
 398                 priv->sighandlers =
 399                         modest_signal_mgr_connect (priv->sighandlers,
 400                                                    G_OBJECT (priv->contents_view),
 401                                                    "vertical-movement",
 402                                                    G_CALLBACK (on_vertical_movement),
 403                                                    self);
 404         }
 405 #endif
 406
 407         /* Mail Operation Queue */
 408         priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
 409                                                        G_OBJECT (modest_runtime_get_window_mgr ()),
 410                                                        "progress-list-changed",
 411                                                        G_CALLBACK (on_progress_list_changed), self);
 412
 413 #ifdef MODEST_TOOLKIT_HILDON2
 414         priv->sighandlers =
 415                 modest_signal_mgr_connect (priv->sighandlers,
 416                                            G_OBJECT (priv->new_message_button),
 417                                            "clicked",
 418                                            G_CALLBACK (modest_ui_actions_on_new_msg), self);
 419
 420         /* Delete using horizontal gesture */
 421         /* DISABLED because it's unreliabile */
 422         if (HILDON_IS_PANNABLE_AREA (priv->contents_view)) {
 423                 if (FALSE) {
 424                         priv->sighandlers =
 425                                 modest_signal_mgr_connect (priv->sighandlers,
 426                                                            (GObject *) priv->contents_view,
 427                                                            "horizontal-movement",
 428                                                            G_CALLBACK (on_horizontal_movement),
 429                                                            self);
 430                 }
 431         }
 432 #endif
 433
 434
 435 #ifdef MODEST_TOOLKIT_HILDON2
 436         g_signal_connect(G_OBJECT(self), "key-press-event",
 437                         G_CALLBACK(on_key_press), self);
 438 #endif
 439 }
 440
 441 static void
 442 folder_refreshed_cb (ModestMailOperation *mail_op,
 443                      TnyFolder *folder,
 444                      gpointer user_data)
 445 {
 446         /* Update the view (folder could be empty) */
 447         update_view (MODEST_HEADER_WINDOW (user_data), NULL);
 448 }
 449
 450 #ifdef MAEMO_CHANGES
 451 static gboolean
 452 tap_and_hold_query_cb (GtkWidget *header_view,
 453                        GdkEvent *event,
 454                        gpointer user_data)
 455 {
 456         ModestHeaderWindow *self;
 457         ModestHeaderWindowPrivate *priv;
 458
 459         self = (ModestHeaderWindow *) user_data;
 460         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
 461
 462         if (event->type == GDK_BUTTON_PRESS) {
 463                 TnyHeader *header;
 464
 465                 priv->x_coord = ((GdkEventButton*)event)->x;
 466                 priv->y_coord = ((GdkEventButton*)event)->y;
 467
 468                 /* Enable/Disable mark as (un)read */
 469                 header = modest_header_view_get_header_at_pos ((ModestHeaderView *) header_view,
 470                                                                priv->x_coord, priv->y_coord);
 471                 if (header) {
 472                         GList *children;
 473                         GtkWidget *mark_read_item, *mark_unread_item;
 474
 475                         /* Show "mark as read" or "mark as unread" */
 476                         children = gtk_container_get_children (GTK_CONTAINER (priv->csm_menu));
 477                         mark_read_item = (GtkWidget *) g_list_nth_data (children, 1);
 478                         mark_unread_item = (GtkWidget *) g_list_nth_data (children, 2);
 479
 480                         if (tny_header_get_flags (header) & TNY_HEADER_FLAG_SEEN) {
 481                                 gtk_widget_show (mark_unread_item);
 482                                 gtk_widget_hide (mark_read_item);
 483                         } else {
 484                                 gtk_widget_show (mark_read_item);
 485                                 gtk_widget_hide (mark_unread_item);
 486                         }
 487                         g_object_unref (header);
 488                 } else {
 489                         /* Do not show the CSM if there is no header below */
 490                         return TRUE;
 491                 }
 492         }
 493
 494         return FALSE;
 495 }
 496 #endif
 497
 498 static void
 499 delete_header (GtkWindow *parent,
 500                TnyHeader *header)
 501 {
 502         gint response;
 503         gchar *subject, *msg;
 504
 505         subject = tny_header_dup_subject (header);
 506         if (!subject)
 507                 subject = g_strdup (_("mail_va_no_subject"));
 508
 509         msg = g_strdup_printf (ngettext("emev_nc_delete_message", "emev_nc_delete_messages", 1),
 510                                subject);
 511         g_free (subject);
 512
 513         /* Confirmation dialog */
 514         response = modest_platform_run_confirmation_dialog (parent, msg);
 515         g_free (msg);
 516
 517         if (response == GTK_RESPONSE_OK) {
 518                 ModestMailOperation *mail_op;
 519                 TnyList *header_list;
 520
 521                 header_list = tny_simple_list_new ();
 522                 tny_list_append (header_list, (GObject *) header);
 523                 mail_op = modest_mail_operation_new ((GObject *) parent);
 524                 modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
 525                                                  mail_op);
 526                 modest_mail_operation_remove_msgs (mail_op, header_list, FALSE);
 527                 g_object_unref (mail_op);
 528                 g_object_unref (header_list);
 529         }
 530 }
 531
 532
 533 static void
 534 on_delete_csm_activated (GtkMenuItem *item,
 535                          gpointer user_data)
 536 {
 537         TnyHeader *header;
 538         ModestHeaderWindow *self;
 539         ModestHeaderWindowPrivate *priv;
 540
 541         self = (ModestHeaderWindow *) user_data;
 542         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
 543
 544         header = modest_header_view_get_header_at_pos ((ModestHeaderView *) priv->header_view,
 545                                                        priv->x_coord, priv->y_coord);
 546         if (header) {
 547                 delete_header ((GtkWindow *) self, header);
 548                 g_object_unref (header);
 549         }
 550 }
 551
 552 static void
 553 on_mark_read_csm_activated (GtkMenuItem *item,
 554                             gpointer user_data)
 555 {
 556         TnyHeader *header;
 557         ModestHeaderWindow *self;
 558         ModestHeaderWindowPrivate *priv;
 559
 560         self = (ModestHeaderWindow *) user_data;
 561         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
 562
 563         header = modest_header_view_get_header_at_pos ((ModestHeaderView *) priv->header_view,
 564                                                        priv->x_coord, priv->y_coord);
 565
 566         if (header) {
 567                 gchar *uid;
 568                 tny_header_set_flag (header, TNY_HEADER_FLAG_SEEN);
 569                 uid = modest_tny_folder_get_header_unique_id (header);
 570                 modest_platform_emit_msg_read_changed_signal (uid, TRUE);
 571                 g_free (uid);
 572                 g_object_unref (header);
 573         }
 574 }
 575
 576 static void
 577 on_mark_unread_csm_activated (GtkMenuItem *item,
 578                               gpointer user_data)
 579 {
 580         TnyHeader *header;
 581         ModestHeaderWindow *self;
 582         ModestHeaderWindowPrivate *priv;
 583
 584         self = (ModestHeaderWindow *) user_data;
 585         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
 586
 587         header = modest_header_view_get_header_at_pos ((ModestHeaderView *) priv->header_view,
 588                                                        priv->x_coord, priv->y_coord);
 589
 590         if (header) {
 591                 gchar *uid;
 592                 tny_header_unset_flag (header, TNY_HEADER_FLAG_SEEN);
 593                 uid = modest_tny_folder_get_header_unique_id (header);
 594                 modest_platform_emit_msg_read_changed_signal (uid, FALSE);
 595                 g_free (uid);
 596                 g_object_unref (header);
 597         }
 598 }
 599
 600 static void
 601 on_header_view_model_destroyed (gpointer user_data,
 602                                 GObject *model)
 603 {
 604         ModestHeaderWindow *self;
 605         ModestHeaderWindowPrivate *priv;
 606
 607         self = (ModestHeaderWindow *) user_data;
 608         if (!GTK_IS_WIDGET (self))
 609                 return;
 610
 611         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
 612         priv->model_weak_ref = NULL;
 613
 614 }
 615
 616 static void
 617 on_header_view_model_changed (GObject *gobject,
 618                               GParamSpec *arg1,
 619                               gpointer user_data)
 620 {
 621         ModestHeaderWindow *self = (ModestHeaderWindow *) user_data;
 622         ModestHeaderWindowPrivate *priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
 623         GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (gobject));
 624
 625         if (priv->model_weak_ref ) {
 626                 g_object_weak_unref ((GObject *) priv->model_weak_ref,
 627                                      on_header_view_model_destroyed,
 628                                      self);
 629                 on_header_view_model_destroyed (self, (GObject *) priv->model_weak_ref);
 630         }
 631
 632         if (!model)
 633                 return;
 634
 635         /* Connect the signal. Listen to object destruction to disconnect it */
 636         priv->model_weak_ref = model;
 637         g_object_weak_ref ((GObject *) model, on_header_view_model_destroyed, self);
 638 }
 639
 640 static GtkWidget *
 641 create_header_view (ModestWindow *self, TnyFolder *folder)
 642 {
 643         GtkWidget *header_view;
 644         GtkWidget *delete_item, *mark_read_item, *mark_unread_item;
 645         ModestHeaderWindowPrivate *priv;
 646
 647         header_view  = modest_header_view_new (NULL, MODEST_HEADER_VIEW_STYLE_TWOLINES);
 648         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
 649         priv->notify_model = g_signal_connect ((GObject*) header_view, "notify::model",
 650                                                G_CALLBACK (on_header_view_model_changed), self);
 651
 652         modest_header_view_set_folder (MODEST_HEADER_VIEW (header_view), folder,
 653                                        TRUE, self, folder_refreshed_cb, self);
 654         modest_header_view_set_filter (MODEST_HEADER_VIEW (header_view),
 655                                        MODEST_HEADER_VIEW_FILTER_NONE);
 656         modest_widget_memory_restore (modest_runtime_get_conf (), G_OBJECT(header_view),
 657                                       MODEST_CONF_HEADER_VIEW_KEY);
 658
 659         /* Create CSM menu */
 660         priv->csm_menu = gtk_menu_new ();
 661         delete_item = gtk_menu_item_new_with_label (_HL_DELETE);
 662         mark_read_item = gtk_menu_item_new_with_label (_("mcen_me_inbox_mark_as_read"));
 663         mark_unread_item = gtk_menu_item_new_with_label (_("mcen_me_inbox_mark_as_unread"));
 664         gtk_menu_shell_append (GTK_MENU_SHELL (priv->csm_menu), delete_item);
 665         gtk_menu_shell_append (GTK_MENU_SHELL (priv->csm_menu), mark_read_item);
 666         gtk_menu_shell_append (GTK_MENU_SHELL (priv->csm_menu), mark_unread_item);
 667 #ifdef MAEMO_CHANGES
 668         hildon_gtk_widget_set_theme_size (delete_item, MODEST_EDITABLE_SIZE);
 669         hildon_gtk_widget_set_theme_size (mark_unread_item, MODEST_EDITABLE_SIZE);
 670         hildon_gtk_widget_set_theme_size (mark_read_item, MODEST_EDITABLE_SIZE);
 671 #endif
 672         gtk_widget_show_all (priv->csm_menu);
 673
 674         /* Connect signals */
 675 #ifdef MAEMO_CHANGES
 676         g_signal_connect ((GObject *) header_view, "tap-and-hold-query",
 677                           G_CALLBACK (tap_and_hold_query_cb), self);
 678 #endif
 679         g_signal_connect ((GObject *) delete_item, "activate",
 680                           G_CALLBACK (on_delete_csm_activated), self);
 681         g_signal_connect ((GObject *) mark_read_item, "activate",
 682                           G_CALLBACK (on_mark_read_csm_activated), self);
 683         g_signal_connect ((GObject *) mark_unread_item, "activate",
 684                           G_CALLBACK (on_mark_unread_csm_activated), self);
 685
 686         /* Add tap&hold handling */
 687 #ifdef MAEMO_CHANGES
 688         gtk_widget_tap_and_hold_setup (header_view, priv->csm_menu, NULL, 0);
 689 #endif
 690
 691         return header_view;
 692 }
 693
 694 static GtkWidget *
 695 create_empty_view (ModestWindow *self)
 696 {
 697         GtkWidget *viewport = NULL;
 698         GtkWidget *label = NULL;
 699         GtkWidget *align = NULL;
 700         GtkWidget *vbox = NULL;
 701
 702         vbox = gtk_vbox_new (0, FALSE);
 703
 704         align = gtk_alignment_new(EMPTYVIEW_XALIGN, EMPTYVIEW_YALIGN, EMPTYVIEW_XSPACE, EMPTYVIEW_YSPACE);
 705         label = gtk_label_new (_("mcen_ia_nomessages"));
 706 #ifdef MODEST_TOOLKIT_HILDON2
 707         hildon_helper_set_logical_font (label, "LargeSystemFont");
 708 #endif
 709         gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
 710         gtk_widget_show (label);
 711         gtk_widget_show (align);
 712         gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER);
 713         gtk_container_add (GTK_CONTAINER (align), label);
 714         gtk_box_pack_end (GTK_BOX (vbox), align, TRUE, TRUE, 0);
 715
 716 #ifdef MODEST_TOOLKIT_HILDON2
 717         GdkPixbuf *new_message_pixbuf;
 718         GtkWidget *button = NULL;
 719         button = hildon_button_new (MODEST_EDITABLE_SIZE,
 720                                     HILDON_BUTTON_ARRANGEMENT_HORIZONTAL);
 721
 722         hildon_button_set_title (HILDON_BUTTON (button), _("mcen_ti_new_message"));
 723         new_message_pixbuf = modest_platform_get_icon ("general_add", MODEST_ICON_SIZE_BIG);
 724         hildon_button_set_image (HILDON_BUTTON (button),
 725                                  gtk_image_new_from_pixbuf (new_message_pixbuf));
 726         g_object_unref (new_message_pixbuf);
 727         gtk_widget_show_all (button);
 728         gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 729 #endif
 730
 731         gtk_widget_show (vbox);
 732
 733 #ifdef MODEST_TOOLKIT_HILDON2
 734         g_signal_connect (button,
 735                           "clicked",
 736                           G_CALLBACK (modest_ui_actions_on_new_msg), self);
 737 #endif
 738
 739         viewport = gtk_viewport_new ((GtkAdjustment *) gtk_adjustment_new (0, 0, 0, 0, 0, 0),
 740                                      (GtkAdjustment *) gtk_adjustment_new (0, 0, 0, 0, 0, 0));
 741         gtk_container_add (GTK_CONTAINER (viewport), vbox);
 742
 743         return viewport;
 744 }
 745
 746 #ifdef MODEST_TOOLKIT_HILDON2
 747 static void
 748 on_vertical_movement (HildonPannableArea *area,
 749                       HildonMovementDirection direction,
 750                       gdouble x, gdouble y, gpointer user_data)
 751 {
 752         ModestHeaderWindow *self = (ModestHeaderWindow *) user_data;
 753         ModestHeaderWindowPrivate *priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
 754
 755         priv->autoscroll = FALSE;
 756 }
 757 #endif
 758
 759 ModestWindow *
 760 modest_header_window_new (TnyFolder *folder, const gchar *account_name, const gchar *mailbox)
 761 {
 762         ModestHeaderWindow *self = NULL;
 763         ModestHeaderWindowPrivate *priv = NULL;
 764         GdkPixbuf *window_icon;
 765         ModestAccountMgr *mgr;
 766         ModestAccountSettings *settings = NULL;
 767         ModestServerAccountSettings *store_settings = NULL;
 768         GtkWidget *alignment;
 769         gchar *account_display_name = NULL;
 770 #ifdef MODEST_TOOLKIT_HILDON2
 771         GtkWidget *live_search;
 772 #endif
 773
 774         self  = MODEST_HEADER_WINDOW(g_object_new(MODEST_TYPE_HEADER_WINDOW, NULL));
 775         priv = MODEST_HEADER_WINDOW_GET_PRIVATE(self);
 776
 777         priv->contents_view = modest_toolkit_factory_create_scrollable (modest_runtime_get_toolkit_factory ());
 778         alignment = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
 779         gtk_alignment_set_padding (GTK_ALIGNMENT (alignment),
 780                                    MODEST_MARGIN_HALF, 0,
 781                                    MODEST_MARGIN_DOUBLE, MODEST_MARGIN_DOUBLE);
 782
 783         /* We need to do this here to properly listen for mail
 784            operations because create_header_view launches a mail
 785            operation */
 786         priv->queue_change_handler =
 787                 g_signal_connect (G_OBJECT (modest_runtime_get_mail_operation_queue ()),
 788                                   "queue-changed",
 789                                   G_CALLBACK (on_queue_changed),
 790                                   self);
 791
 792         priv->header_view  = create_header_view (MODEST_WINDOW (self), folder);
 793 #ifdef MODEST_TOOLKIT_HILDON2
 794         live_search = modest_header_view_setup_live_search (MODEST_HEADER_VIEW (priv->header_view));
 795         hildon_live_search_widget_hook (HILDON_LIVE_SEARCH (live_search), GTK_WIDGET (self), priv->header_view);
 796 #endif
 797         priv->empty_view = create_empty_view (MODEST_WINDOW (self));
 798
 799         /* Transform the floating reference in a "hard" reference. We
 800            need to do this because the widgets could be added/removed
 801            to containers many times so we always need to keep a
 802            reference. It could happen also that some widget is never
 803            added to any container */
 804         g_object_ref_sink (priv->header_view);
 805         g_object_ref_sink (priv->empty_view);
 806
 807 #ifdef MODEST_TOOLKIT_HILDON2
 808         GdkPixbuf *new_message_pixbuf;
 809         GtkWidget *action_area_box;
 810
 811         g_signal_connect (G_OBJECT (self), "edit-mode-changed",
 812                           G_CALLBACK (edit_mode_changed), (gpointer) self);
 813
 814         action_area_box = hildon_tree_view_get_action_area_box (GTK_TREE_VIEW (priv->header_view));
 815         priv->new_message_button = hildon_button_new (MODEST_EDITABLE_SIZE, HILDON_BUTTON_ARRANGEMENT_HORIZONTAL);
 816
 817         hildon_button_set_title (HILDON_BUTTON (priv->new_message_button), _("mcen_ti_new_message"));
 818         new_message_pixbuf = modest_platform_get_icon ("general_add", MODEST_ICON_SIZE_BIG);
 819         hildon_button_set_image (HILDON_BUTTON (priv->new_message_button), gtk_image_new_from_pixbuf (new_message_pixbuf));
 820         g_object_unref (new_message_pixbuf);
 821
 822         gtk_box_pack_start (GTK_BOX (action_area_box), priv->new_message_button, TRUE, TRUE, 0);
 823         gtk_widget_show_all (priv->new_message_button);
 824         hildon_tree_view_set_action_area_visible (GTK_TREE_VIEW (priv->header_view), TRUE);
 825 #endif
 826
 827         setup_menu (self);
 828
 829         priv->top_vbox = gtk_vbox_new (FALSE, 0);
 830         gtk_container_add (GTK_CONTAINER (alignment), priv->contents_view);
 831 #ifdef MODEST_TOOLKIT_HILDON2
 832         gtk_box_pack_end (GTK_BOX (priv->top_vbox), live_search, FALSE, FALSE, 0);
 833 #endif
 834         gtk_box_pack_end (GTK_BOX (priv->top_vbox), alignment, TRUE, TRUE, 0);
 835
 836         gtk_container_add (GTK_CONTAINER (self), priv->top_vbox);
 837
 838         gtk_widget_show (alignment);
 839         gtk_widget_show (priv->contents_view);
 840         gtk_widget_show (priv->top_vbox);
 841
 842         connect_signals (MODEST_HEADER_WINDOW (self));
 843
 844         update_view (self, NULL);
 845
 846 #ifdef MODEST_TOOLKIT_HILDON2
 847         HildonProgram *app;
 848
 849         /* Get device name */
 850         modest_maemo_utils_get_device_name ();
 851         app = hildon_program_get_instance ();
 852         hildon_program_add_window (app, HILDON_WINDOW (self));
 853 #endif
 854
 855
 856         /* Set window icon */
 857         window_icon = modest_platform_get_icon (MODEST_APP_ICON, MODEST_ICON_SIZE_BIG);
 858         if (window_icon) {
 859                 gtk_window_set_icon (GTK_WINDOW (self), window_icon);
 860                 g_object_unref (window_icon);
 861         }
 862
 863         /* Dont't restore settings here,
 864          * because it requires a gtk_widget_show(),
 865          * and we don't want to do that until later,
 866          * so that the UI is not visible for non-menu D-Bus activation.
 867          */
 868
 869         /* setup edit modes */
 870 #ifdef MODEST_TOOLKIT_HILDON2
 871         modest_hildon2_window_register_edit_mode (MODEST_HILDON2_WINDOW (self), EDIT_MODE_COMMAND_DELETE,
 872                                                   _("mcen_ti_edit_delete"), _HL_DELETE,
 873                                                   GTK_TREE_VIEW (priv->header_view),
 874                                                   GTK_SELECTION_MULTIPLE,
 875                                                   EDIT_MODE_CALLBACK (modest_ui_actions_on_edit_mode_delete_message));
 876         modest_hildon2_window_register_edit_mode (MODEST_HILDON2_WINDOW (self), EDIT_MODE_COMMAND_MOVE,
 877                                                   _("mcen_ti_edit_move"), _HL_MOVE,
 878                                                   GTK_TREE_VIEW (priv->header_view),
 879                                                   GTK_SELECTION_MULTIPLE,
 880                                                   EDIT_MODE_CALLBACK (modest_ui_actions_on_edit_mode_move_to));
 881 #endif
 882
 883         priv->isearch_toolbar = modest_toolkit_factory_create_isearch_toolbar (modest_runtime_get_toolkit_factory (),
 884                                                                                NULL);
 885         modest_window_add_toolbar (MODEST_WINDOW (self), GTK_TOOLBAR (priv->isearch_toolbar));
 886         g_signal_connect (G_OBJECT (priv->isearch_toolbar), "isearch-close",
 887                           G_CALLBACK (isearch_toolbar_close), self);
 888         g_signal_connect (G_OBJECT (priv->isearch_toolbar), "isearch-search",
 889                           G_CALLBACK (isearch_toolbar_search), self);
 890
 891
 892         modest_window_set_active_account (MODEST_WINDOW (self), account_name);
 893         modest_window_set_active_mailbox (MODEST_WINDOW (self), mailbox);
 894         mgr = modest_runtime_get_account_mgr ();
 895         settings = modest_account_mgr_load_account_settings (mgr, account_name);
 896         if (settings) {
 897                 account_display_name = g_strdup (modest_account_settings_get_display_name (settings));
 898                 store_settings = modest_account_settings_get_store_settings (settings);
 899                 if (store_settings) {
 900                         priv->current_store_account =
 901                                 g_strdup (modest_server_account_settings_get_account_name (store_settings));
 902                         g_object_unref (store_settings);
 903                 }
 904                 g_object_unref (settings);
 905         }
 906         /* Set window title */
 907         if (TNY_IS_FOLDER (folder)) {
 908                 gchar *folder_name;
 909
 910                 if (tny_folder_get_folder_type (folder) == TNY_FOLDER_TYPE_INBOX) {
 911                         const gchar *box_name;
 912                         box_name = mailbox;
 913                         if (box_name == NULL || box_name[0] == '\0') {
 914                                 box_name = account_display_name;
 915                         }
 916                         folder_name = g_strconcat (_("mcen_me_folder_inbox"), " - ", box_name, NULL);
 917                 } else {
 918                         folder_name = modest_tny_folder_get_display_name (folder);
 919                 }
 920
 921                 modest_window_set_title (MODEST_WINDOW (self), folder_name);
 922                 g_free (folder_name);
 923         }
 924         g_free (account_display_name);
 925
 926
 927         update_progress_hint (self);
 928
 929         return MODEST_WINDOW(self);
 930 }
 931
 932 ModestHeaderView *
 933 modest_header_window_get_header_view (ModestHeaderWindow *self)
 934 {
 935         ModestHeaderWindowPrivate *priv = NULL;
 936
 937         g_return_val_if_fail (MODEST_IS_HEADER_WINDOW(self), FALSE);
 938
 939         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
 940
 941         return MODEST_HEADER_VIEW (priv->header_view);
 942 }
 943
 944 static void setup_menu (ModestHeaderWindow *self)
 945 {
 946         ModestHeaderWindowPrivate *priv;
 947
 948         g_return_if_fail (MODEST_IS_HEADER_WINDOW(self));
 949         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
 950
 951         modest_window_add_to_menu (MODEST_WINDOW (self), _("mcen_me_new_message"), "<Control>n",
 952                                    MODEST_WINDOW_MENU_CALLBACK (modest_ui_actions_on_new_msg),
 953                                    MODEST_DIMMING_CALLBACK (modest_ui_dimming_rules_on_new_msg));
 954         modest_window_add_to_menu (MODEST_WINDOW (self), _("mcen_me_inbox_sendandreceive"), NULL,
 955                                    MODEST_WINDOW_MENU_CALLBACK (modest_ui_actions_on_send_receive),
 956                                    MODEST_DIMMING_CALLBACK (modest_ui_dimming_rules_on_send_receive));
 957 #ifdef MODEST_TOOLKIT_HILDON2
 958         modest_window_add_to_menu (MODEST_WINDOW (self),
 959                                    dngettext(GETTEXT_PACKAGE,
 960                                              "mcen_me_move_message",
 961                                              "mcen_me_move_messages",
 962                                              2),
 963                                    NULL,
 964                                    MODEST_WINDOW_MENU_CALLBACK (set_moveto_edit_mode),
 965                                    MODEST_DIMMING_CALLBACK (modest_ui_dimming_rules_on_move_to));
 966         modest_window_add_to_menu (MODEST_WINDOW (self), _("mcen_me_delete_messages"), NULL,
 967                                    MODEST_WINDOW_MENU_CALLBACK (set_delete_edit_mode),
 968                                    MODEST_DIMMING_CALLBACK (modest_ui_dimming_rules_on_delete));
 969 #else
 970         modest_window_add_to_menu (MODEST_WINDOW (self),
 971                                    dngettext(GETTEXT_PACKAGE,
 972                                              "mcen_me_move_message",
 973                                              "mcen_me_move_messages",
 974                                              2),
 975                                    NULL,
 976                                    MODEST_WINDOW_MENU_CALLBACK (modest_ui_actions_on_move_to),
 977                                    MODEST_DIMMING_CALLBACK (modest_ui_dimming_rules_on_move_to));
 978         modest_window_add_to_menu (MODEST_WINDOW (self), _("mcen_me_delete_messages"), NULL,
 979                                    MODEST_WINDOW_MENU_CALLBACK (modest_ui_actions_on_delete_message),
 980                                    MODEST_DIMMING_CALLBACK (modest_ui_dimming_rules_on_delete));
 981 #endif
 982         modest_window_add_to_menu (MODEST_WINDOW (self), _("mcen_me_folder_details"), NULL,
 983                                    MODEST_WINDOW_MENU_CALLBACK (modest_ui_actions_on_details),
 984                                    MODEST_DIMMING_CALLBACK (modest_ui_dimming_rules_on_details));
 985
 986 #ifdef MODEST_TOOLKIT_HILDON2
 987         priv->show_more_button = hildon_button_new (MODEST_EDITABLE_SIZE, HILDON_BUTTON_ARRANGEMENT_VERTICAL);
 988         hildon_button_set_title (HILDON_BUTTON (priv->show_more_button), _("mcen_va_more"));
 989         hildon_button_set_alignment (HILDON_BUTTON (priv->show_more_button), 0.5, 0.5, 1.0, 1.0);
 990         hildon_button_set_title_alignment (HILDON_BUTTON (priv->show_more_button), 0.5, 0.5);
 991         hildon_button_set_value_alignment (HILDON_BUTTON (priv->show_more_button), 0.5, 0.5);
 992         modest_window_add_item_to_menu (MODEST_WINDOW (self), priv->show_more_button,
 993                                         NULL);
 994         gtk_widget_hide_all (priv->show_more_button);
 995 #endif
 996
 997         modest_window_add_to_menu (MODEST_WINDOW (self), _("mcen_me_outbox_cancelsend"), NULL,
 998                                    MODEST_WINDOW_MENU_CALLBACK (modest_ui_actions_cancel_send),
 999                                    MODEST_DIMMING_CALLBACK (modest_ui_dimming_rules_on_cancel_sending_all));
1000 #ifndef MODEST_TOOLKIT_HILDON2
1001         modest_window_add_to_menu (MODEST_WINDOW (self), _HL("wdgt_bd_search"), "<Control>f",
1002                                    MODEST_WINDOW_MENU_CALLBACK (toggle_isearch_toolbar), NULL);
1003 #endif
1004 }
1005
1006 static void
1007 update_view (ModestHeaderWindow *self,
1008              TnyFolderChange *change)
1009 {
1010         ModestHeaderWindowPrivate *priv = NULL;
1011         gboolean refilter = FALSE;
1012         gboolean folder_empty = FALSE;
1013         gboolean all_marked_as_deleted = FALSE;
1014         TnyFolder *folder;
1015
1016         g_return_if_fail (MODEST_IS_HEADER_WINDOW(self));
1017
1018         /* It could happen when some event is received and the window
1019            was previously closed */
1020         if (!MODEST_IS_HEADER_WINDOW (self))
1021                 return;
1022
1023         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
1024
1025         folder = modest_header_view_get_folder ((ModestHeaderView *) priv->header_view);
1026         if (!folder)
1027                 return;
1028
1029         if (change != NULL) {
1030                 TnyFolderChangeChanged changed;
1031
1032                 changed = tny_folder_change_get_changed (change);
1033                 /* If something changes */
1034                 if ((changed) & TNY_FOLDER_CHANGE_CHANGED_ALL_COUNT)
1035                         folder_empty = (((guint) tny_folder_change_get_new_all_count (change)) == 0);
1036                 else
1037                         folder_empty = (((guint) tny_folder_get_all_count (folder)) == 0);
1038
1039                 if ((changed) & TNY_FOLDER_CHANGE_CHANGED_EXPUNGED_HEADERS)
1040                         refilter = TRUE;
1041         } else {
1042                 folder_empty = (((guint) tny_folder_get_all_count (folder)) == 0);
1043         }
1044         g_object_unref (folder);
1045
1046         /* Check if all messages are marked to be deleted */
1047         all_marked_as_deleted = modest_header_view_is_empty (MODEST_HEADER_VIEW (priv->header_view));
1048         folder_empty = folder_empty || all_marked_as_deleted;
1049
1050         /* Set style of headers view */
1051         set_contents_state (self, folder_empty?CONTENTS_STATE_EMPTY:CONTENTS_STATE_HEADERS);
1052
1053         if (refilter)
1054                 modest_header_view_refilter (MODEST_HEADER_VIEW (priv->header_view));
1055 }
1056
1057 static void
1058 set_contents_state (ModestHeaderWindow *self,
1059                     ContentsState state)
1060 {
1061         ModestHeaderWindowPrivate *priv = NULL;
1062
1063         g_return_if_fail (MODEST_IS_HEADER_WINDOW(self));
1064         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
1065
1066         if (priv->contents_state == state)
1067                 return;
1068
1069         /* Remove from container the old content */
1070         switch (priv->contents_state) {
1071         case CONTENTS_STATE_EMPTY:
1072                 gtk_container_remove (GTK_CONTAINER (priv->contents_view), priv->empty_view);
1073                 break;
1074         case CONTENTS_STATE_HEADERS:
1075                 gtk_container_remove (GTK_CONTAINER (priv->contents_view), priv->header_view);
1076                 break;
1077         case CONTENTS_STATE_NONE:
1078                 break;
1079         }
1080
1081         /* Add the new content */
1082         switch (state) {
1083         case CONTENTS_STATE_EMPTY:
1084                 gtk_container_add (GTK_CONTAINER (priv->contents_view), priv->empty_view);
1085                 gtk_widget_show (priv->empty_view);
1086                 break;
1087         case CONTENTS_STATE_HEADERS:
1088                 gtk_container_add (GTK_CONTAINER (priv->contents_view), priv->header_view);
1089                 gtk_widget_show (priv->header_view);
1090                 break;
1091         case CONTENTS_STATE_NONE:
1092                 break;
1093         }
1094         priv->contents_state = state;
1095 }
1096
1097 static void
1098 on_msg_count_changed (ModestHeaderView *header_view,
1099                       TnyFolder *folder,
1100                       TnyFolderChange *change,
1101                       ModestHeaderWindow *header_window)
1102 {
1103         g_return_if_fail (MODEST_IS_HEADER_WINDOW (header_window));
1104
1105         update_view (MODEST_HEADER_WINDOW (header_window), change);
1106 }
1107
1108 static void
1109 on_header_activated (ModestHeaderView *header_view,
1110                      TnyHeader *header,
1111                      GtkTreePath *path,
1112                      ModestHeaderWindow *header_window)
1113 {
1114         modest_ui_actions_on_header_activated (header_view, header, path, MODEST_WINDOW (header_window));
1115 }
1116
1117 static void
1118 updating_banner_destroyed (gpointer data,
1119                            GObject *where_the_object_was)
1120 {
1121         ModestHeaderWindowPrivate *priv = NULL;
1122
1123         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (data);
1124
1125         priv->updating_banner = NULL;
1126 }
1127
1128 static gboolean
1129 show_updating_banner (gpointer user_data)
1130 {
1131         ModestHeaderWindowPrivate *priv = NULL;
1132
1133         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (user_data);
1134
1135         if (priv->updating_banner == NULL) {
1136
1137                 /* We're outside the main lock */
1138                 gdk_threads_enter ();
1139                 priv->updating_banner =
1140                         modest_platform_animation_banner (GTK_WIDGET (user_data), NULL,
1141                                                           _CS_UPDATING);
1142
1143                 /* We need this because banners in Maemo could be
1144                    destroyed by dialogs so we need to properly update
1145                    our reference to it */
1146                 g_object_weak_ref (G_OBJECT (priv->updating_banner),
1147                                    updating_banner_destroyed,
1148                                    user_data);
1149                 gdk_threads_leave ();
1150         }
1151
1152         /* Remove timeout */
1153         priv->updating_banner_timeout = 0;
1154         return FALSE;
1155 }
1156
1157 /**
1158  * We use this function to show/hide a progress banner showing
1159  * "Updating" while the header view is being filled. We're not showing
1160  * it unless the update takes more than 2 seconds
1161  *
1162  * If starting = TRUE then the refresh is starting, otherwise it means
1163  * that is has just finished
1164  */
1165 static void
1166 on_updating_msg_list (ModestHeaderView *header_view,
1167                       gboolean starting,
1168                       gpointer user_data)
1169 {
1170         ModestHeaderWindowPrivate *priv = NULL;
1171
1172         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (user_data);
1173
1174         /* Remove old timeout */
1175         if (priv->updating_banner_timeout > 0) {
1176                 g_source_remove (priv->updating_banner_timeout);
1177                 priv->updating_banner_timeout = 0;
1178         }
1179
1180         /* Create a new timeout */
1181         if (starting) {
1182                 priv->updating_banner_timeout =
1183                         g_timeout_add (2000, show_updating_banner, user_data);
1184         } else {
1185                 /* Remove the banner if exists */
1186                 if (priv->updating_banner) {
1187                         gtk_widget_destroy (priv->updating_banner);
1188                         priv->updating_banner = NULL;
1189                 }
1190         }
1191 }
1192
1193 #ifdef MODEST_TOOLKIT_HILDON2
1194 static void
1195 set_delete_edit_mode (GtkButton *button,
1196                       ModestHeaderWindow *self)
1197 {
1198         modest_hildon2_window_set_edit_mode (MODEST_HILDON2_WINDOW (self), EDIT_MODE_COMMAND_DELETE);
1199 }
1200
1201 static void
1202 set_moveto_edit_mode (GtkButton *button,
1203                     ModestHeaderWindow *self)
1204 {
1205         modest_hildon2_window_set_edit_mode (MODEST_HILDON2_WINDOW (self), EDIT_MODE_COMMAND_MOVE);
1206 }
1207 #endif
1208
1209 static gboolean
1210 on_expose_event(GtkTreeView *header_view,
1211                 GdkEventExpose *event,
1212                 gpointer user_data)
1213 {
1214         ModestHeaderWindow *self = (ModestHeaderWindow *) user_data;
1215
1216         g_return_val_if_fail (MODEST_IS_HEADER_WINDOW (self), FALSE);
1217
1218 #ifdef MODEST_TOOLKIT_HILDON2
1219         ModestHeaderWindowPrivate *priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
1220
1221         if (priv->autoscroll)
1222                 modest_scrollable_jump_to (MODEST_SCROLLABLE (priv->contents_view), 0.0, 0.0);
1223 #endif
1224
1225         return FALSE;
1226 }
1227
1228 static gboolean
1229 on_map_event(GtkWidget *widget,
1230              GdkEvent *event,
1231              gpointer user_data)
1232 {
1233         ModestHeaderWindow *self = (ModestHeaderWindow *) user_data;
1234         ModestHeaderWindowPrivate *priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
1235
1236         g_return_val_if_fail (MODEST_IS_HEADER_WINDOW (self), FALSE);
1237
1238         if (priv->progress_hint) {
1239                 modest_window_show_progress (MODEST_WINDOW (self), TRUE);
1240         }
1241         return FALSE;
1242 }
1243
1244 static void
1245 on_progress_list_changed (ModestWindowMgr *mgr,
1246                           ModestHeaderWindow *self)
1247 {
1248         update_progress_hint (self);
1249 }
1250
1251 static gboolean
1252 has_active_operations (ModestHeaderWindow *self)
1253 {
1254         GSList *operations = NULL, *node;
1255         ModestMailOperationQueue *queue;
1256         gboolean has_active = FALSE;
1257
1258         queue = modest_runtime_get_mail_operation_queue ();
1259         operations = modest_mail_operation_queue_get_by_source (queue, G_OBJECT (self));
1260
1261         for (node = operations; node != NULL; node = g_slist_next (node)) {
1262                 if (!modest_mail_operation_is_finished (MODEST_MAIL_OPERATION (node->data))) {
1263                         has_active = TRUE;
1264                         break;
1265                 }
1266         }
1267
1268         if (operations) {
1269                 g_slist_foreach (operations, (GFunc) g_object_unref, NULL);
1270                 g_slist_free (operations);
1271         }
1272
1273         return has_active;
1274 }
1275
1276 static void
1277 update_progress_hint (ModestHeaderWindow *self)
1278 {
1279         ModestHeaderWindowPrivate *priv;
1280
1281         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
1282
1283         priv->progress_hint = FALSE;
1284
1285         if (has_active_operations (self)) {
1286                 priv->progress_hint = TRUE;
1287         } else {
1288                 priv->progress_hint = FALSE;
1289         }
1290
1291         if (!priv->progress_hint && priv->current_store_account) {
1292                 priv->progress_hint =
1293                         modest_window_mgr_has_progress_operation_on_account (modest_runtime_get_window_mgr (),
1294                                                                              priv->current_store_account);
1295         }
1296
1297         modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (self));
1298
1299         if (GTK_WIDGET_VISIBLE (self)) {
1300                 modest_window_show_progress (MODEST_WINDOW (self), priv->progress_hint?1:0);
1301         }
1302 }
1303
1304 gboolean
1305 modest_header_window_toolbar_on_transfer_mode     (ModestHeaderWindow *self)
1306 {
1307         ModestHeaderWindowPrivate *priv= NULL;
1308
1309         g_return_val_if_fail (MODEST_IS_HEADER_WINDOW (self), FALSE);
1310         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
1311
1312         return priv->progress_hint;
1313 }
1314
1315 gboolean
1316 modest_header_window_transfer_mode_enabled (ModestHeaderWindow *self)
1317 {
1318         ModestHeaderWindowPrivate *priv;
1319
1320         g_return_val_if_fail (MODEST_IS_HEADER_WINDOW (self), FALSE);
1321         priv = MODEST_HEADER_WINDOW_GET_PRIVATE(self);
1322
1323         return priv->progress_hint;
1324 }
1325
1326 static void
1327 on_mail_operation_started (ModestMailOperation *mail_op,
1328                            gpointer user_data)
1329 {
1330         ModestHeaderWindow *self;
1331         ModestMailOperationTypeOperation op_type;
1332         GObject *source = NULL;
1333
1334         self = MODEST_HEADER_WINDOW (user_data);
1335         op_type = modest_mail_operation_get_type_operation (mail_op);
1336         source = modest_mail_operation_get_source(mail_op);
1337         if (G_OBJECT (self) == source) {
1338                 update_progress_hint (self);
1339         }
1340         g_object_unref (source);
1341 }
1342
1343 static void
1344 on_mail_operation_finished (ModestMailOperation *mail_op,
1345                             gpointer user_data)
1346 {
1347         ModestHeaderWindow *self;
1348
1349         self = MODEST_HEADER_WINDOW (user_data);
1350
1351         /* Don't disable the progress hint if there are more pending
1352            operations from this window */
1353         update_progress_hint (self);
1354
1355         modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (self));
1356 }
1357
1358 static void
1359 on_queue_changed (ModestMailOperationQueue *queue,
1360                   ModestMailOperation *mail_op,
1361                   ModestMailOperationQueueNotification type,
1362                   ModestHeaderWindow *self)
1363 {
1364         ModestHeaderWindowPrivate *priv;
1365
1366         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
1367
1368         /* If this operations was created by another window, do nothing */
1369         if (!modest_mail_operation_is_mine (mail_op, G_OBJECT(self)))
1370                 return;
1371
1372         if (type == MODEST_MAIL_OPERATION_QUEUE_OPERATION_ADDED) {
1373                 priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
1374                                                                G_OBJECT (mail_op),
1375                                                                "operation-started",
1376                                                                G_CALLBACK (on_mail_operation_started),
1377                                                                self);
1378                 priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
1379                                                                G_OBJECT (mail_op),
1380                                                                "operation-finished",
1381                                                                G_CALLBACK (on_mail_operation_finished),
1382                                                                self);
1383         } else if (type == MODEST_MAIL_OPERATION_QUEUE_OPERATION_REMOVED) {
1384                 priv->sighandlers = modest_signal_mgr_disconnect (priv->sighandlers,
1385                                                                   G_OBJECT (mail_op),
1386                                                                   "operation-started");
1387                 priv->sighandlers = modest_signal_mgr_disconnect (priv->sighandlers,
1388                                                                   G_OBJECT (mail_op),
1389                                                                   "operation-finished");
1390         }
1391 }
1392
1393 static void
1394 modest_header_window_pack_toolbar (ModestWindow *self,
1395                                    GtkPackType pack_type,
1396                                    GtkWidget *toolbar)
1397 {
1398         ModestHeaderWindowPrivate *priv;
1399
1400         g_return_if_fail (MODEST_IS_HEADER_WINDOW (self));
1401         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
1402
1403         if (pack_type == GTK_PACK_START) {
1404                 gtk_box_pack_start (GTK_BOX (priv->top_vbox), toolbar, FALSE, FALSE, 0);
1405         } else {
1406                 gtk_box_pack_end (GTK_BOX (priv->top_vbox), toolbar, FALSE, FALSE, 0);
1407         }
1408 }
1409
1410 #ifdef MODEST_TOOLKIT_HILDON2
1411 static void
1412 edit_mode_changed (ModestHeaderWindow *header_window,
1413                    gint edit_mode_id,
1414                    gboolean enabled,
1415                    ModestHeaderWindow *self)
1416 {
1417         ModestHeaderWindowPrivate *priv;
1418         ModestHeaderViewFilter filter = MODEST_HEADER_VIEW_FILTER_NONE;
1419
1420         g_return_if_fail (MODEST_IS_HEADER_WINDOW (self));
1421         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (self);
1422
1423         switch (edit_mode_id) {
1424         case EDIT_MODE_COMMAND_MOVE:
1425                 filter = MODEST_HEADER_VIEW_FILTER_MOVEABLE;
1426                 break;
1427         case EDIT_MODE_COMMAND_DELETE:
1428                 filter = MODEST_HEADER_VIEW_FILTER_DELETABLE;
1429                 break;
1430         case MODEST_HILDON2_WINDOW_EDIT_MODE_NONE:
1431                 filter = MODEST_HEADER_VIEW_FILTER_NONE;
1432                 break;
1433         }
1434
1435         hildon_tree_view_set_action_area_visible (GTK_TREE_VIEW (priv->header_view), !enabled);
1436         if (enabled) {
1437                 modest_header_view_set_filter (MODEST_HEADER_VIEW (priv->header_view),
1438                                                filter);
1439         } else {
1440                 GtkTreeSelection *sel;
1441
1442                 /* Unselect all. This will prevent us from keeping a
1443                    reference to a TnyObject that we don't want to
1444                    have */
1445                 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->header_view));
1446                 gtk_tree_selection_unselect_all (sel);
1447
1448                 modest_header_view_unset_filter (MODEST_HEADER_VIEW (priv->header_view),
1449                                                  filter);
1450         }
1451 }
1452 #endif
1453
1454 #ifdef MODEST_TOOLKIT_HILDON2
1455 static void
1456 on_horizontal_movement (HildonPannableArea *hildonpannable,
1457                         gint                direction,
1458                         gdouble             initial_x,
1459                         gdouble             initial_y,
1460                         gpointer            user_data)
1461 {
1462         ModestHeaderWindowPrivate *priv;
1463         gint dest_x, dest_y;
1464         TnyHeader *header;
1465
1466         /* Ignore right to left movement */
1467         if (direction == HILDON_MOVEMENT_LEFT)
1468                 return;
1469
1470         /* Get the header to delete */
1471         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (user_data);
1472
1473         /* Get tree view coordinates */
1474         if (!gtk_widget_translate_coordinates ((GtkWidget *) hildonpannable,
1475                                                priv->header_view,
1476                                                initial_x,
1477                                                initial_y,
1478                                                &dest_x,
1479                                                &dest_y))
1480             return;
1481
1482         header = modest_header_view_get_header_at_pos ((ModestHeaderView *) priv->header_view,
1483                                                        dest_x, dest_y);
1484         if (header) {
1485                 delete_header ((GtkWindow *) user_data, header);
1486                 g_object_unref (header);
1487         }
1488 }
1489 #endif
1490
1491 #ifdef MODEST_TOOLKIT_HILDON2
1492 static gboolean
1493 on_key_press(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
1494 {
1495         ModestHeaderWindowPrivate *priv;
1496         ModestScrollable *scrollable;
1497         /* FIXME: set scroll_speed depends on for how long the key was pressed */
1498         gint scroll_speed = 3;
1499
1500         if (event->type == GDK_KEY_RELEASE)
1501                 return FALSE;
1502
1503         priv = MODEST_HEADER_WINDOW_GET_PRIVATE(user_data);
1504
1505         scrollable = MODEST_SCROLLABLE (priv->contents_view);
1506
1507         switch (event->keyval) {
1508
1509         case GDK_Up:
1510                 priv->autoscroll = FALSE;
1511                 modest_scrollable_scroll (scrollable, 0, -scroll_speed);
1512                 break;
1513
1514         case GDK_Down:
1515                 priv->autoscroll = FALSE;
1516                 modest_scrollable_scroll (scrollable, 0, scroll_speed);
1517                 break;
1518         }
1519
1520         return FALSE;
1521 }
1522 #endif
1523
1524 #ifndef MODEST_TOOLKIT_HILDON2
1525 /* Used for the Ctrl+F accelerator */
1526 static void
1527 toggle_isearch_toolbar (GtkWidget *obj,
1528                         gpointer data)
1529 {
1530         ModestHeaderWindow *window = MODEST_HEADER_WINDOW (data);
1531         ModestHeaderWindowPrivate *priv = MODEST_HEADER_WINDOW_GET_PRIVATE (window);
1532
1533         if (GTK_WIDGET_VISIBLE (priv->isearch_toolbar)) {
1534                 isearch_toolbar_close (obj, data);
1535        } else {
1536                 show_isearch_toolbar (obj, data);
1537        }
1538 }
1539
1540 /* Handler for menu option */
1541 static void
1542 show_isearch_toolbar (GtkWidget *obj,
1543                       gpointer data)
1544 {
1545         ModestHeaderWindow *window = MODEST_HEADER_WINDOW (data);
1546         ModestHeaderWindowPrivate *priv = MODEST_HEADER_WINDOW_GET_PRIVATE (window);
1547
1548         gtk_widget_show (priv->isearch_toolbar);
1549         modest_isearch_toolbar_highlight_entry (MODEST_ISEARCH_TOOLBAR (priv->isearch_toolbar), TRUE);
1550 }
1551 #endif
1552
1553 /* Handler for click on the "X" close button in isearch toolbar */
1554 static void
1555 isearch_toolbar_close (GtkWidget *widget,
1556                        ModestHeaderWindow *obj)
1557 {
1558         ModestHeaderWindowPrivate *priv;
1559
1560         priv = MODEST_HEADER_WINDOW_GET_PRIVATE (obj);
1561
1562         /* Hide toolbar */
1563         gtk_widget_hide (priv->isearch_toolbar);
1564
1565         modest_header_view_set_filter_string (MODEST_HEADER_VIEW (priv->header_view), NULL);
1566 }
1567
1568 static void
1569 isearch_toolbar_search (GtkWidget *widget,
1570                         ModestHeaderWindow *obj)
1571 {
1572         ModestHeaderWindowPrivate *priv = MODEST_HEADER_WINDOW_GET_PRIVATE (obj);
1573
1574         /* TODO: set filter */
1575         modest_header_view_set_filter_string (MODEST_HEADER_VIEW (priv->header_view),
1576                                               modest_isearch_toolbar_get_search (MODEST_ISEARCH_TOOLBAR (priv->isearch_toolbar)));
1577
1578 }