Avoid wait on taking screenshot. Now it shouldn't be required.
[modest] / src / hildon2 / modest-accounts-window.c
index 3d6b60c..9609add 100644 (file)
  */
 
 #include <modest-accounts-window.h>
-#include <modest-osso-state-saving.h>
-#include <libosso.h>
 #include <hildon/hildon-pannable-area.h>
 #include <hildon/hildon-banner.h>
+#include <hildon/hildon-helper.h>
 #include <modest-ui-actions.h>
 #include <modest-window-mgr.h>
 #include <modest-signal-mgr.h>
 #include <modest-runtime.h>
 #include <modest-platform.h>
 #include <hildon/hildon-program.h>
+#include <hildon/hildon-button.h>
 #include <modest-maemo-utils.h>
 #include <modest-icon-names.h>
 #include <modest-defs.h>
@@ -45,6 +45,9 @@
 #include <modest-ui-dimming-rules.h>
 #include <modest-ui-dimming-manager.h>
 #include <modest-window-priv.h>
+#include <modest-ui-constants.h>
+#include <modest-account-mgr-helpers.h>
+#include <modest-mailboxes-window.h>
 
 
 /* 'private'/'protected' functions */
@@ -66,6 +69,10 @@ static gboolean _modest_accounts_window_map_event (GtkWidget *widget,
                                                   GdkEvent *event,
                                                   gpointer userdata);
 static void update_progress_hint (ModestAccountsWindow *self);
+static void on_queue_changed    (ModestMailOperationQueue *queue,
+                                ModestMailOperation *mail_op,
+                                ModestMailOperationQueueNotification type,
+                                ModestAccountsWindow *self);
 static void on_row_inserted (GtkTreeModel *tree_model,
                             GtkTreePath  *path,
                             GtkTreeIter  *iter,
@@ -74,17 +81,27 @@ static void on_row_deleted (GtkTreeModel *tree_model,
                            GtkTreePath  *path,
                            gpointer      user_data);
 static void row_count_changed (ModestAccountsWindow *self);
+static gboolean on_key_press(GtkWidget *widget,
+                               GdkEventKey *event,
+                               gpointer user_data);
+static gboolean on_delete_event (GtkWidget *widget,
+                                GdkEvent *event,
+                                gpointer userdata);
 
 typedef struct _ModestAccountsWindowPrivate ModestAccountsWindowPrivate;
 struct _ModestAccountsWindowPrivate {
 
+       GtkWidget *box;
+       GtkWidget *pannable;
        GtkWidget *account_view;
-       GtkWidget *no_accounts_label;
+       GtkWidget *no_accounts_container;
+       GtkWidget *new_message_button;
 
        /* signals */
        GSList *sighandlers;
 
        gboolean progress_hint;
+       guint queue_change_handler;
 };
 #define MODEST_ACCOUNTS_WINDOW_GET_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE((o), \
                                                                            MODEST_TYPE_ACCOUNTS_WINDOW, \
@@ -92,6 +109,7 @@ struct _ModestAccountsWindowPrivate {
 
 /* globals */
 static GtkWindowClass *parent_class = NULL;
+static GtkWidget *pre_created_accounts_window = NULL;
 
 /************************************************************************/
 
@@ -171,6 +189,11 @@ modest_accounts_window_disconnect_signals (ModestWindow *self)
        ModestAccountsWindowPrivate *priv;      
        priv = MODEST_ACCOUNTS_WINDOW_GET_PRIVATE(self);
 
+       if (g_signal_handler_is_connected (G_OBJECT (modest_runtime_get_mail_operation_queue ()), 
+                                          priv->queue_change_handler))
+               g_signal_handler_disconnect (G_OBJECT (modest_runtime_get_mail_operation_queue ()), 
+                                            priv->queue_change_handler);
+
        modest_signal_mgr_disconnect_all_and_destroy (priv->sighandlers);
        priv->sighandlers = NULL;       
 }
@@ -209,54 +232,96 @@ connect_signals (ModestAccountsWindow *self)
                                           "row-deleted",
                                           G_CALLBACK (on_row_deleted), self);
 
+       priv->sighandlers = 
+               modest_signal_mgr_connect (priv->sighandlers,
+                                          G_OBJECT (priv->new_message_button),
+                                          "clicked",
+                                          G_CALLBACK (modest_ui_actions_on_new_msg), self);
+
        /* we don't register this in sighandlers, as it should be run
         * after disconnecting all signals, in destroy stage */
+
+
+       g_signal_connect(G_OBJECT(self), "key-press-event",
+                       G_CALLBACK(on_key_press), self);
 }
 
-ModestWindow *
-modest_accounts_window_new (void)
+static ModestWindow *
+modest_accounts_window_new_real (void)
 {
        ModestAccountsWindow *self = NULL;
        ModestAccountsWindowPrivate *priv = NULL;
-       HildonProgram *app;
        GdkPixbuf *window_icon;
-       GtkWidget *pannable;
-       GtkWidget *box;
+       GdkPixbuf *new_message_pixbuf;
+       guint accel_key;
+       GdkModifierType accel_mods;
+       GtkAccelGroup *accel_group;
+       GtkWidget *no_accounts_label;
+       GtkWidget *empty_view_new_message_button;
+       GtkWidget *box_alignment;
 
        self  = MODEST_ACCOUNTS_WINDOW(g_object_new(MODEST_TYPE_ACCOUNTS_WINDOW, NULL));
        priv = MODEST_ACCOUNTS_WINDOW_GET_PRIVATE(self);
 
-       box = gtk_vbox_new (FALSE, 0);
+       new_message_pixbuf = modest_platform_get_icon ("general_add", MODEST_ICON_SIZE_BIG);
 
-       priv->no_accounts_label = gtk_label_new (_("mcen_ia_noaccounts"));
-       gtk_misc_set_alignment (GTK_MISC (priv->no_accounts_label), 0.5, 0.0);
-       gtk_box_pack_start (GTK_BOX (box), priv->no_accounts_label, TRUE, TRUE, 0);
+       box_alignment = gtk_alignment_new (0, 0, 1.0, 1.0);
+       gtk_alignment_set_padding (GTK_ALIGNMENT (box_alignment), 
+                                  HILDON_MARGIN_HALF, 0,
+                                  HILDON_MARGIN_DOUBLE, HILDON_MARGIN_DOUBLE);
+       priv->box = gtk_vbox_new (FALSE, 0);
 
-       pannable = hildon_pannable_area_new ();
-       priv->account_view  = GTK_WIDGET (modest_account_view_new (modest_runtime_get_account_mgr ()));
+       no_accounts_label = gtk_label_new (_("mcen_ia_noaccounts"));
+       
+       gtk_misc_set_alignment (GTK_MISC (no_accounts_label), 0.5, 0.5);
+       hildon_helper_set_logical_font (no_accounts_label, "LargeSystemFont");
 
-       setup_menu (self);
+       empty_view_new_message_button = hildon_button_new (MODEST_EDITABLE_SIZE, HILDON_BUTTON_ARRANGEMENT_HORIZONTAL);
+       hildon_button_set_title (HILDON_BUTTON (empty_view_new_message_button), _("mcen_ti_new_message"));
+       hildon_button_set_image (HILDON_BUTTON (empty_view_new_message_button), gtk_image_new_from_pixbuf (new_message_pixbuf));
 
-       gtk_container_add (GTK_CONTAINER (pannable), priv->account_view);
-       gtk_box_pack_start (GTK_BOX (box), pannable, TRUE, TRUE, 0);
-       gtk_container_add (GTK_CONTAINER (self), box);
 
-       gtk_widget_show (priv->account_view);
-       gtk_widget_show (pannable);
-       gtk_widget_show (box);
+       priv->no_accounts_container = gtk_vbox_new (FALSE, 0);
+       gtk_box_pack_start (GTK_BOX (priv->no_accounts_container), empty_view_new_message_button, FALSE, FALSE, 0);
+       gtk_widget_show_all (empty_view_new_message_button);
+       gtk_box_pack_end (GTK_BOX (priv->no_accounts_container), no_accounts_label, TRUE, TRUE, 0);
+       gtk_widget_show (no_accounts_label);
+       gtk_box_pack_start (GTK_BOX (priv->box), priv->no_accounts_container, TRUE, TRUE, 0);
 
-       connect_signals (MODEST_ACCOUNTS_WINDOW (self));
+       g_signal_connect (G_OBJECT (empty_view_new_message_button),
+                         "clicked",
+                         G_CALLBACK (modest_ui_actions_on_new_msg), self);
+       
+       priv->pannable = hildon_pannable_area_new ();
+
+       priv->queue_change_handler =
+               g_signal_connect (G_OBJECT (modest_runtime_get_mail_operation_queue ()),
+                                 "queue-changed",
+                                 G_CALLBACK (on_queue_changed),
+                                 self);
+
+       priv->new_message_button = hildon_button_new (MODEST_EDITABLE_SIZE,
+                                                     HILDON_BUTTON_ARRANGEMENT_HORIZONTAL);
+
+       hildon_button_set_title (HILDON_BUTTON (priv->new_message_button), _("mcen_ti_new_message"));
+       hildon_button_set_image (HILDON_BUTTON (priv->new_message_button), gtk_image_new_from_pixbuf (new_message_pixbuf));
+
+       gtk_widget_show_all (priv->new_message_button);
+
+       g_object_unref (new_message_pixbuf);
+       setup_menu (self);
+
+       gtk_box_pack_start (GTK_BOX (priv->box), priv->pannable, TRUE, TRUE, 0);
+       gtk_container_add (GTK_CONTAINER (box_alignment), priv->box);
+       gtk_container_add (GTK_CONTAINER (self), box_alignment);
 
-       /* Load previous osso state, for instance if we are being restored from 
-        * hibernation:  */
-       modest_osso_load_state ();
+       gtk_widget_show (priv->pannable);
+       gtk_widget_show (priv->box);
+       gtk_widget_show (box_alignment);
 
        /* Get device name */
        modest_maemo_utils_get_device_name ();
 
-       app = hildon_program_get_instance ();
-       hildon_program_add_window (app, HILDON_WINDOW (self));
-       
        /* Set window icon */
        window_icon = modest_platform_get_icon (MODEST_APP_ICON, MODEST_ICON_SIZE_BIG);
        if (window_icon) {
@@ -264,6 +329,42 @@ modest_accounts_window_new (void)
                g_object_unref (window_icon);
        }
 
+       accel_group = gtk_accel_group_new ();
+       gtk_accelerator_parse ("<Control>n", &accel_key, &accel_mods);
+       gtk_widget_add_accelerator (priv->new_message_button, "clicked", accel_group,
+                                   accel_key, accel_mods, 0);
+       gtk_window_add_accel_group (GTK_WINDOW (self), accel_group);
+
+       return MODEST_WINDOW(self);
+}
+
+ModestWindow *
+modest_accounts_window_new (void)
+{
+       GtkWidget *action_area_box;
+       ModestWindow *self;
+       ModestAccountsWindowPrivate *priv = NULL;
+       HildonProgram *app;
+
+       if (pre_created_accounts_window) {
+               self = MODEST_WINDOW (pre_created_accounts_window);
+               pre_created_accounts_window = NULL;
+       } else {
+               self = modest_accounts_window_new_real ();
+       }
+       priv = MODEST_ACCOUNTS_WINDOW_GET_PRIVATE(self);
+       priv->account_view  = GTK_WIDGET (modest_account_view_new (modest_runtime_get_account_mgr ()));
+
+       action_area_box = hildon_tree_view_get_action_area_box (GTK_TREE_VIEW (priv->account_view));
+       gtk_box_pack_start (GTK_BOX (action_area_box), priv->new_message_button, TRUE, TRUE, 0);
+       hildon_tree_view_set_action_area_visible (GTK_TREE_VIEW (priv->account_view), TRUE);
+       gtk_container_add (GTK_CONTAINER (priv->pannable), priv->account_view);
+
+       connect_signals (MODEST_ACCOUNTS_WINDOW (self));
+
+       app = hildon_program_get_instance ();
+       hildon_program_add_window (app, HILDON_WINDOW (self));
+       
        /* Dont't restore settings here, 
         * because it requires a gtk_widget_show(), 
         * and we don't want to do that until later,
@@ -273,14 +374,18 @@ modest_accounts_window_new (void)
        g_signal_connect (G_OBJECT (self), "map-event",
                          G_CALLBACK (_modest_accounts_window_map_event),
                          G_OBJECT (self));
-       update_progress_hint (self);
+       g_signal_connect (G_OBJECT (self), "delete-event",
+                         G_CALLBACK (on_delete_event), self);
+       update_progress_hint (MODEST_ACCOUNTS_WINDOW (self));
 
-       row_count_changed (self);
+       row_count_changed (MODEST_ACCOUNTS_WINDOW (self));
 
+       gtk_window_set_title (GTK_WINDOW (self), _("mcen_ap_name"));
 
-       return MODEST_WINDOW(self);
+       return self;
 }
 
+
 ModestAccountView *
 modest_accounts_window_get_account_view (ModestAccountsWindow *self)
 {
@@ -302,24 +407,26 @@ setup_menu (ModestAccountsWindow *self)
        modest_hildon2_window_add_to_menu (MODEST_HILDON2_WINDOW (self), _("mcen_me_new_account"), NULL, 
                                           APP_MENU_CALLBACK (modest_ui_actions_on_new_account), 
                                           NULL);
-       modest_hildon2_window_add_to_menu (MODEST_HILDON2_WINDOW (self), _("mcen_me_edit_accounts"), NULL,
+       modest_hildon2_window_add_to_menu (MODEST_HILDON2_WINDOW (self), _("mcen_me_inbox_sendandreceive"), NULL,
+                                          APP_MENU_CALLBACK (modest_ui_actions_on_send_receive),
+                                          MODEST_DIMMING_CALLBACK (modest_ui_dimming_rules_on_send_receive_all));
+       modest_hildon2_window_add_to_menu (MODEST_HILDON2_WINDOW (self),
+                                          dngettext(GETTEXT_PACKAGE,
+                                                    "mcen_me_edit_account",
+                                                    "mcen_me_edit_accounts",
+                                                    2),
+                                          NULL,
                                           APP_MENU_CALLBACK (modest_ui_actions_on_accounts), 
-                                          NULL);
+                                          MODEST_DIMMING_CALLBACK (modest_ui_dimming_rules_on_edit_accounts));
        modest_hildon2_window_add_to_menu (MODEST_HILDON2_WINDOW (self), _("mcen_me_inbox_globalsmtpservers"), NULL,
                                           APP_MENU_CALLBACK (modest_ui_actions_on_smtp_servers),
                                           MODEST_DIMMING_CALLBACK (modest_ui_dimming_rules_on_tools_smtp_servers));
-       modest_hildon2_window_add_to_menu (MODEST_HILDON2_WINDOW (self), _("mcen_me_inbox_sendandreceive"), NULL,
-                                          APP_MENU_CALLBACK (modest_ui_actions_on_send_receive),
-                                          MODEST_DIMMING_CALLBACK (modest_ui_dimming_rules_on_send_receive_all));
        modest_hildon2_window_add_to_menu (MODEST_HILDON2_WINDOW (self), _("mcen_me_outbox_cancelsend"), NULL,
                                           APP_MENU_CALLBACK (modest_ui_actions_cancel_send),
                                           MODEST_DIMMING_CALLBACK (modest_ui_dimming_rules_on_cancel_sending_all));
        modest_hildon2_window_add_to_menu (MODEST_HILDON2_WINDOW (self), _("mcen_me_inbox_options"), NULL,
                                           APP_MENU_CALLBACK (modest_ui_actions_on_settings), 
                                           NULL);
-       modest_hildon2_window_add_to_menu (MODEST_HILDON2_WINDOW (self), _("mcen_me_new_message"), "<Control>n",
-                                          APP_MENU_CALLBACK (modest_ui_actions_on_new_msg),
-                                          MODEST_DIMMING_CALLBACK (modest_ui_dimming_rules_on_new_msg));
 }
 
 
@@ -331,8 +438,10 @@ on_account_activated (GtkTreeView *account_view,
 {
        ModestAccountsWindowPrivate *priv;
        gchar* account_name; 
-       GtkWidget *folder_window;
+       GtkWidget *new_window;
        gboolean registered;
+       ModestProtocolType store_protocol;
+       gboolean mailboxes_protocol;
 
        priv = MODEST_ACCOUNTS_WINDOW_GET_PRIVATE (self);
 
@@ -340,17 +449,32 @@ on_account_activated (GtkTreeView *account_view,
        if (!account_name)
                return;
 
-       folder_window = GTK_WIDGET (modest_folder_window_new (NULL));
+       /* If it's a multimailbox container, we have to show the mailboxes window */
+       store_protocol = modest_account_mgr_get_store_protocol (modest_runtime_get_account_mgr (), 
+                                                               account_name);
+       mailboxes_protocol = 
+               modest_protocol_registry_protocol_type_has_tag (modest_runtime_get_protocol_registry (),
+                                                               store_protocol,
+                                                               MODEST_PROTOCOL_REGISTRY_MULTI_MAILBOX_PROVIDER_PROTOCOLS);
+       if (mailboxes_protocol) {
+               new_window = GTK_WIDGET (modest_mailboxes_window_new (account_name));
+       } else {
+
+               new_window = GTK_WIDGET (modest_folder_window_new (NULL));
+       }
+
        registered = modest_window_mgr_register_window (modest_runtime_get_window_mgr (), 
-                                                       MODEST_WINDOW (folder_window),
+                                                       MODEST_WINDOW (new_window),
                                                        MODEST_WINDOW (self));
 
        if (!registered) {
-               gtk_widget_destroy (folder_window);
-               folder_window = NULL;
+               gtk_widget_destroy (new_window);
+               new_window = NULL;
        } else {
-               modest_folder_window_set_account (MODEST_FOLDER_WINDOW (folder_window), account_name);
-               gtk_widget_show (folder_window);
+               if (!mailboxes_protocol) {
+                       modest_folder_window_set_account (MODEST_FOLDER_WINDOW (new_window), account_name);
+               }
+               gtk_widget_show (new_window);
        }
        g_free (account_name);
 }
@@ -370,12 +494,45 @@ _modest_accounts_window_map_event (GtkWidget *widget,
        return FALSE;
 }
 
+static gboolean
+has_active_operations (ModestAccountsWindow *self)
+{
+       GSList *operations = NULL, *node;
+       ModestMailOperationQueue *queue;
+       gboolean has_active = FALSE;
+
+       queue = modest_runtime_get_mail_operation_queue ();
+       operations = modest_mail_operation_queue_get_by_source (queue, G_OBJECT (self));
+
+       for (node = operations; node != NULL; node = g_slist_next (node)) {
+               if (!modest_mail_operation_is_finished (MODEST_MAIL_OPERATION (node->data))) {
+                       has_active = TRUE;
+                       break;
+               }
+       }
+
+       if (operations) {
+               g_slist_foreach (operations, (GFunc) g_object_unref, NULL);
+               g_slist_free (operations);
+       }
+
+       return has_active;
+}
+
 static void
 update_progress_hint (ModestAccountsWindow *self)
 {
        ModestAccountsWindowPrivate *priv = MODEST_ACCOUNTS_WINDOW_GET_PRIVATE (self);
 
-       priv->progress_hint = modest_window_mgr_has_progress_operation (modest_runtime_get_window_mgr ());
+       if (has_active_operations (self)) {
+               priv->progress_hint = TRUE;
+       } else {
+               priv->progress_hint = FALSE;
+       }
+
+       if (!priv->progress_hint) {
+               priv->progress_hint = modest_window_mgr_has_progress_operation (modest_runtime_get_window_mgr ());
+       }
        
        if (GTK_WIDGET_VISIBLE (self)) {
                hildon_gtk_window_set_progress_indicator (GTK_WINDOW (self), priv->progress_hint?1:0);
@@ -414,12 +571,13 @@ on_row_deleted (GtkTreeModel *tree_model,
        row_count_changed (self);
 }
 
-static void row_count_changed (ModestAccountsWindow *self)
+static void 
+row_count_changed (ModestAccountsWindow *self)
 {
        ModestAccountsWindowPrivate *priv;
        GtkTreeModel *model;
        gint count;
-       
+
        priv = MODEST_ACCOUNTS_WINDOW_GET_PRIVATE (self);
        model = gtk_tree_view_get_model (GTK_TREE_VIEW (priv->account_view));
 
@@ -427,9 +585,143 @@ static void row_count_changed (ModestAccountsWindow *self)
 
        if (count == 0) {
                gtk_widget_hide (priv->account_view);
-               gtk_widget_show (priv->no_accounts_label);
+               gtk_widget_show (priv->no_accounts_container);
+               g_debug ("%s: hiding accounts view", __FUNCTION__);
        } else {
-               gtk_widget_hide (priv->no_accounts_label);
+               gtk_widget_hide (priv->no_accounts_container);
                gtk_widget_show (priv->account_view);
+               g_debug ("%s: showing accounts view", __FUNCTION__);
+       }
+       gtk_container_child_set (GTK_CONTAINER(priv->box), priv->pannable, 
+                                "expand", count > 0,
+                                "fill", count > 0,
+                                NULL);
+}
+
+static void 
+on_mail_operation_started (ModestMailOperation *mail_op,
+                          gpointer user_data)
+{
+       ModestAccountsWindow *self;
+       ModestMailOperationTypeOperation op_type;
+       GObject *source = NULL;
+
+       self = MODEST_ACCOUNTS_WINDOW (user_data);
+       op_type = modest_mail_operation_get_type_operation (mail_op);
+       source = modest_mail_operation_get_source(mail_op);
+       if (G_OBJECT (self) == source) {
+               update_progress_hint (self);
+       }
+       g_object_unref (source);
+}
+
+static void 
+on_mail_operation_finished (ModestMailOperation *mail_op,
+                           gpointer user_data)
+{
+       ModestAccountsWindow *self;
+
+       self = MODEST_ACCOUNTS_WINDOW (user_data);
+
+       /* Don't disable the progress hint if there are more pending
+          operations from this window */
+       update_progress_hint (self);
+
+       modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (self));
+}
+
+static void
+on_queue_changed (ModestMailOperationQueue *queue,
+                 ModestMailOperation *mail_op,
+                 ModestMailOperationQueueNotification type,
+                 ModestAccountsWindow *self)
+{
+       ModestAccountsWindowPrivate *priv;
+
+       priv = MODEST_ACCOUNTS_WINDOW_GET_PRIVATE (self);
+
+       /* If this operations was created by another window, do nothing */
+       if (!modest_mail_operation_is_mine (mail_op, G_OBJECT(self))) 
+               return;
+
+       if (type == MODEST_MAIL_OPERATION_QUEUE_OPERATION_ADDED) {
+               priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
+                                                              G_OBJECT (mail_op),
+                                                              "operation-started",
+                                                              G_CALLBACK (on_mail_operation_started),
+                                                              self);
+               priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
+                                                              G_OBJECT (mail_op),
+                                                              "operation-finished",
+                                                              G_CALLBACK (on_mail_operation_finished),
+                                                              self);
+       } else if (type == MODEST_MAIL_OPERATION_QUEUE_OPERATION_REMOVED) {
+               priv->sighandlers = modest_signal_mgr_disconnect (priv->sighandlers,
+                                                                 G_OBJECT (mail_op),
+                                                                 "operation-started");
+               priv->sighandlers = modest_signal_mgr_disconnect (priv->sighandlers,
+                                                                 G_OBJECT (mail_op),
+                                                                 "operation-finished");
        }
 }
+
+void 
+modest_accounts_window_pre_create (void)
+{
+       static gboolean pre_created = FALSE;
+       if (!pre_created) {
+               pre_created = TRUE;
+               pre_created_accounts_window = GTK_WIDGET (modest_accounts_window_new_real ());
+       }
+}
+
+
+static gboolean
+on_key_press(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
+{
+       ModestAccountsWindowPrivate *priv;
+       HildonPannableArea *pannable;
+
+       if (event->type == GDK_KEY_RELEASE)
+               return FALSE;
+
+       priv = MODEST_ACCOUNTS_WINDOW_GET_PRIVATE(user_data);
+
+       pannable = HILDON_PANNABLE_AREA (priv->pannable);
+
+       switch (event->keyval) {
+
+       case GDK_Up:
+               modest_maemo_utils_scroll_pannable(pannable, 0, -1);
+               break;
+
+       case GDK_Down:
+               modest_maemo_utils_scroll_pannable(pannable, 0, 1);
+               break;
+       }
+
+       return FALSE;
+}
+
+static gboolean
+on_delete_event (GtkWidget *widget,
+                GdkEvent *event,
+                gpointer userdata)
+{
+       ModestAccountsWindowPrivate *priv;
+
+       priv = MODEST_ACCOUNTS_WINDOW_GET_PRIVATE (widget);
+
+       modest_account_view_set_show_last_update (MODEST_ACCOUNT_VIEW (priv->account_view), FALSE);
+
+       gtk_widget_queue_resize (widget);
+
+       gdk_window_process_updates (priv->account_view->window, TRUE);
+
+       hildon_gtk_window_take_screenshot (GTK_WINDOW (widget), TRUE);
+
+       modest_account_view_set_show_last_update (MODEST_ACCOUNT_VIEW (priv->account_view), TRUE);
+
+       return FALSE;
+
+}