#include "modest-tny-account.h"
#include "modest-tny-folder.h"
#include "modest-conf.h"
+#include <modest-utils.h>
#include <modest-maemo-utils.h>
#include "modest-tny-platform-factory.h"
#include "modest-tny-msg.h"
#include "modest-mail-operation.h"
#include "modest-icon-names.h"
-#include "modest-progress-bar-widget.h"
+#include "modest-progress-bar.h"
#include "modest-text-utils.h"
#include "modest-ui-dimming-manager.h"
#include "maemo/modest-osso-state-saving.h"
#include "modest-text-utils.h"
#include "modest-signal-mgr.h"
-#ifdef MODEST_HAVE_HILDON0_WIDGETS
-#include <hildon-widgets/hildon-program.h>
-#else
-#include <hildon/hildon-program.h>
-#endif /*MODEST_HAVE_HILDON0_WIDGETS*/
-
#define MODEST_MAIN_WINDOW_ACTION_GROUP_ADDITIONS "ModestMainWindowActionAdditions"
#define XALIGN 0.5
static void modest_main_window_finalize (GObject *obj);
static gboolean modest_main_window_window_state_event (GtkWidget *widget,
- GdkEventWindowState *event,
- gpointer userdata);
+ GdkEventWindowState *event,
+ gpointer userdata);
static void connect_signals (ModestMainWindow *self);
static void save_state (ModestWindow *self);
-static void
-update_menus (ModestMainWindow* self);
+static void update_menus (ModestMainWindow* self);
static void modest_main_window_show_toolbar (ModestWindow *window,
gboolean show_toolbar);
static gboolean on_zoom_minus_plus_not_implemented (ModestWindow *window);
-static void
-on_account_inserted (TnyAccountStore *accoust_store,
- TnyAccount *account,
- gpointer user_data);
+static void on_account_inserted (TnyAccountStore *accoust_store,
+ TnyAccount *account,
+ gpointer user_data);
-static void
-on_account_removed (TnyAccountStore *accoust_store,
- TnyAccount *account,
- gpointer user_data);
+static void on_account_removed (TnyAccountStore *accoust_store,
+ TnyAccount *account,
+ gpointer user_data);
-static void
-on_account_changed (ModestAccountMgr* mgr,
- const gchar* account,
- gpointer user_data);
+static void on_account_changed (TnyAccountStore *account_store,
+ TnyAccount *account,
+ gpointer user_data);
+
+static void on_default_account_changed (ModestAccountMgr* mgr,
+ gpointer user_data);
static gboolean on_inner_widgets_key_pressed (GtkWidget *widget,
GdkEventKey *event,
static gboolean set_toolbar_transfer_mode (ModestMainWindow *self);
-static void on_show_account_action_activated (GtkAction *action,
- gpointer user_data);
+static void on_show_account_action_toggled (GtkToggleAction *action,
+ gpointer user_data);
static void on_refresh_account_action_activated (GtkAction *action,
gpointer user_data);
static void on_send_receive_csm_activated (GtkMenuItem *item,
gpointer user_data);
-static void
-_on_msg_count_changed (ModestHeaderView *header_view,
- TnyFolder *folder,
- TnyFolderChange *change,
- ModestMainWindow *main_window);
+static void on_msg_count_changed (ModestHeaderView *header_view,
+ TnyFolder *folder,
+ TnyFolderChange *change,
+ ModestMainWindow *main_window);
-static void
-modest_main_window_cleanup_queue_error_signals (ModestMainWindow *self);
+static void modest_main_window_cleanup_queue_error_signals (ModestMainWindow *self);
static GtkWidget * create_empty_view (void);
-static gboolean
-on_folder_view_focus_in (GtkWidget *widget,
- GdkEventFocus *event,
- gpointer userdata);
-static gboolean
-on_header_view_focus_in (GtkWidget *widget,
- GdkEventFocus *event,
- gpointer userdata);
-static void
-modest_main_window_on_folder_selection_changed (ModestFolderView *folder_view,
- TnyFolderStore *folder_store,
- gboolean selected,
- ModestMainWindow *main_window);
+static gboolean on_folder_view_focus_in (GtkWidget *widget,
+ GdkEventFocus *event,
+ gpointer userdata);
+
+static gboolean on_header_view_focus_in (GtkWidget *widget,
+ GdkEventFocus *event,
+ gpointer userdata);
+
+static void on_folder_selection_changed (ModestFolderView *folder_view,
+ TnyFolderStore *folder_store,
+ gboolean selected,
+ ModestMainWindow *main_window);
-static void
-set_at_least_one_account_visible(ModestMainWindow *self);
+static void set_at_least_one_account_visible(ModestMainWindow *self);
+static void on_updating_msg_list (ModestHeaderView *header_view,
+ gboolean starting,
+ gpointer user_data);
-/* list my signals */
-enum {
- /* MY_SIGNAL_1, */
- /* MY_SIGNAL_2, */
- LAST_SIGNAL
-};
+static gboolean restore_paned_timeout_handler (gpointer *data);
+
+static gboolean show_retrieving_banner (gpointer user_data);
+
+static void on_window_destroy (GtkObject *widget,
+ gpointer userdata);
+
+static void on_window_hide (GObject *gobject,
+ GParamSpec *arg1,
+ gpointer user_data);
typedef struct _ModestMainWindowPrivate ModestMainWindowPrivate;
struct _ModestMainWindowPrivate {
/* Merge ids used to add/remove accounts to the ViewMenu*/
GByteArray *merge_ids;
+ GtkActionGroup *view_additions_group;
/* On-demand widgets */
GtkWidget *accounts_popup;
ModestMainWindowStyle style;
ModestMainWindowContentsStyle contents_style;
+ gboolean wait_for_settings;
guint progress_bar_timeout;
+ guint restore_paned_timeout;
/* Signal handler UIDs */
GList *queue_err_signals;
GSList *sighandlers;
-
- ModestConfNotificationId notification_id;
+
+ /* "Updating" banner for header view */
+ GtkWidget *updating_banner;
+ guint updating_banner_timeout;
+
+ /* "Retrieving" banner for header view */
+ GtkWidget *retrieving_banner;
+ guint retrieving_banner_timeout;
+
+ /* Display state */
+ osso_display_state_t display_state;
};
#define MODEST_MAIN_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
MODEST_TYPE_MAIN_WINDOW, \
{ "FolderViewCSMPasteMsgs", NULL, N_("mcen_me_inbox_paste"), NULL, NULL, G_CALLBACK (modest_ui_actions_on_paste)},
{ "FolderViewCSMDeleteFolder", NULL, N_("mcen_me_inbox_delete"), NULL, NULL, G_CALLBACK (modest_ui_actions_on_delete_folder) },
{ "FolderViewCSMSearchMessages", NULL, N_("mcen_me_inbox_search"), NULL, NULL, G_CALLBACK (modest_ui_actions_on_search_messages) },
- { "FolderViewCSMHelp", NULL, N_("mcen_me_inbox_help"), NULL, NULL, G_CALLBACK (modest_ui_actions_on_help) },
+ { "FolderViewCSMHelp", NULL, N_("mcen_me_inbox_help"), NULL, NULL, G_CALLBACK (modest_ui_actions_on_csm_help) },
};
static const GtkActionEntry modest_header_view_action_entries [] = {
priv->progress_bar = NULL;
priv->current_toolbar_mode = TOOLBAR_MODE_NORMAL;
priv->style = MODEST_MAIN_WINDOW_STYLE_SPLIT;
+ priv->wait_for_settings = TRUE;
priv->contents_style = -1; /* invalid contents style. We need this to select it for the first time */
priv->merge_ids = NULL;
priv->optimized_view = FALSE;
priv->send_receive_in_progress = FALSE;
priv->progress_bar_timeout = 0;
+ priv->restore_paned_timeout = 0;
priv->sighandlers = NULL;
+ priv->updating_banner = NULL;
+ priv->updating_banner_timeout = 0;
+ priv->retrieving_banner = NULL;
+ priv->retrieving_banner_timeout = 0;
+ priv->display_state = OSSO_DISPLAY_ON;
+
+ modest_window_mgr_register_help_id (modest_runtime_get_window_mgr(),
+ GTK_WINDOW(obj),
+ "applications_email_mainview");
}
static void
priv = MODEST_MAIN_WINDOW_GET_PRIVATE(obj);
- if (priv->notification_id) {
- modest_conf_forget_namespace (modest_runtime_get_conf (),
- MODEST_CONF_NAMESPACE,
- priv->notification_id);
- }
-
/* Sanity check: shouldn't be needed, the window mgr should
call this function before */
- modest_main_window_disconnect_signals (MODEST_WINDOW (obj));
-
+ modest_main_window_disconnect_signals (MODEST_WINDOW (obj));
modest_main_window_cleanup_queue_error_signals ((ModestMainWindow *) obj);
+ if (priv->empty_view) {
+ g_object_unref (priv->empty_view);
+ priv->empty_view = NULL;
+ }
+
+ if (priv->header_view) {
+ g_object_unref (priv->header_view);
+ priv->header_view = NULL;
+ }
+
g_slist_free (priv->progress_widgets);
g_byte_array_free (priv->merge_ids, TRUE);
priv->progress_bar_timeout = 0;
}
+ if (priv->updating_banner_timeout > 0) {
+ g_source_remove (priv->updating_banner_timeout);
+ priv->updating_banner_timeout = 0;
+ }
+
+ if (priv->updating_banner) {
+ gtk_widget_destroy (priv->updating_banner);
+ priv->updating_banner = NULL;
+ }
+
+ if (priv->retrieving_banner_timeout > 0) {
+ g_source_remove (priv->retrieving_banner_timeout);
+ priv->retrieving_banner_timeout = 0;
+ }
+
+ if (priv->retrieving_banner) {
+ gtk_widget_destroy (priv->retrieving_banner);
+ priv->retrieving_banner = NULL;
+ }
+
+ if (priv->restore_paned_timeout > 0) {
+ g_source_remove (priv->restore_paned_timeout);
+ priv->restore_paned_timeout = 0;
+ }
+
G_OBJECT_CLASS(parent_class)->finalize (obj);
}
GtkWidget*
modest_main_window_get_child_widget (ModestMainWindow *self,
- ModestWidgetType widget_type)
+ ModestMainWindowWidgetType widget_type)
{
ModestMainWindowPrivate *priv;
GtkWidget *widget;
- g_return_val_if_fail (self, NULL);
- g_return_val_if_fail (widget_type >= 0 && widget_type < MODEST_WIDGET_TYPE_NUM,
+ g_return_val_if_fail (self && MODEST_IS_MAIN_WINDOW(self), NULL);
+ g_return_val_if_fail (widget_type >= 0 && widget_type < MODEST_MAIN_WINDOW_WIDGET_TYPE_NUM,
NULL);
priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
switch (widget_type) {
- case MODEST_WIDGET_TYPE_HEADER_VIEW:
+ case MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW:
widget = (GtkWidget*)priv->header_view; break;
- case MODEST_WIDGET_TYPE_FOLDER_VIEW:
+ case MODEST_MAIN_WINDOW_WIDGET_TYPE_FOLDER_VIEW:
widget = (GtkWidget*)priv->folder_view; break;
default:
return NULL;
}
- return widget ? GTK_WIDGET(widget) : NULL;
+ /* Note that the window could have been destroyed, and so
+ their children, but still have some references */
+ return (widget && GTK_IS_WIDGET(widget)) ? GTK_WIDGET(widget) : NULL;
+}
+
+static gboolean
+restore_paned_timeout_handler (gpointer *data)
+{
+ ModestMainWindow *main_window = MODEST_MAIN_WINDOW (data);
+ ModestMainWindowPrivate *priv = MODEST_MAIN_WINDOW_GET_PRIVATE (main_window);
+ ModestConf *conf;
+
+ /* Timeouts are outside the main lock */
+ gdk_threads_enter ();
+ if (GTK_WIDGET_VISIBLE (main_window)) {
+ conf = modest_runtime_get_conf ();
+ modest_widget_memory_restore (conf, G_OBJECT(priv->main_paned),
+ MODEST_CONF_MAIN_PANED_KEY);
+ }
+ gdk_threads_leave ();
+
+ return FALSE;
}
modest_widget_memory_restore (conf, G_OBJECT(priv->folder_view),
MODEST_CONF_FOLDER_VIEW_KEY);
- modest_widget_memory_restore (conf, G_OBJECT(priv->main_paned),
- MODEST_CONF_MAIN_PANED_KEY);
+/* modest_widget_memory_restore (conf, G_OBJECT(priv->main_paned), */
+/* MODEST_CONF_MAIN_PANED_KEY); */
+
+ g_timeout_add (250, (GSourceFunc) restore_paned_timeout_handler, self);
/* We need to force a redraw here in order to get the right
position of the horizontal paned separator */
modest_widget_memory_save (conf,G_OBJECT(self),
MODEST_CONF_MAIN_WINDOW_KEY);
- modest_widget_memory_save (conf, G_OBJECT(priv->main_paned),
- MODEST_CONF_MAIN_PANED_KEY);
- // modest_widget_memory_save (conf, G_OBJECT(priv->header_view),
- // MODEST_CONF_HEADER_VIEW_KEY);
+ /* Only save main paned position if we're in split mode */
+ if (priv->style == MODEST_MAIN_WINDOW_STYLE_SPLIT)
+ modest_widget_memory_save (conf, G_OBJECT(priv->main_paned),
+ MODEST_CONF_MAIN_PANED_KEY);
modest_widget_memory_save (conf, G_OBJECT(priv->folder_view),
MODEST_CONF_FOLDER_VIEW_KEY);
}
static gint
-compare_display_names (ModestAccountData *a,
- ModestAccountData *b)
+compare_display_names (ModestAccountSettings *a,
+ ModestAccountSettings *b)
+{
+ return g_utf8_collate (modest_account_settings_get_display_name (a),
+ modest_account_settings_get_display_name (b));
+
+}
+
+/* We use this function to prevent the send&receive CSM to be shown
+ when there are less than two account */
+static gboolean
+tap_and_hold_query_cb (GtkWidget *widget, GdkEvent *event)
{
- return strcmp (a->display_name, b->display_name);
+ return TRUE;
}
static void
ModestWindowPrivate *parent_priv;
ModestAccountMgr *mgr;
gint i, num_accounts;
- GtkActionGroup *action_group;
GList *groups;
gchar *default_account;
+ const gchar *active_account_name;
GtkWidget *send_receive_button, *item;
GtkAction *send_receive_all = NULL;
+ GSList *radio_group;
priv = MODEST_MAIN_WINDOW_GET_PRIVATE (self);
parent_priv = MODEST_WINDOW_GET_PRIVATE (self);
accounts = NULL;
while (iter) {
- ModestAccountData *account_data =
- modest_account_mgr_get_account_data (mgr, (gchar*) iter->data);
- accounts = g_slist_prepend (accounts, account_data);
+ ModestAccountSettings *settings =
+ modest_account_mgr_load_account_settings (mgr, (gchar*) iter->data);
+ accounts = g_slist_prepend (accounts, settings);
iter = iter->next;
}
send_receive_all = gtk_ui_manager_get_action (parent_priv->ui_manager,
"/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsSendReceiveAllMenu");
- gtk_action_set_visible (send_receive_all, num_accounts > 1);
+ gtk_action_set_visible (send_receive_all, num_accounts > 0);
/* Delete old send&receive popup items. We can not just do a
menu_detach because it does not work well with
}
/* We need to call this in order to ensure
that the new actions are added in the right
- order (alphabetical */
+ order (alphabetical) */
gtk_ui_manager_ensure_update (parent_priv->ui_manager);
} else
groups = g_list_next (groups);
/* Create a new action group */
default_account = modest_account_mgr_get_default_account (mgr);
- action_group = gtk_action_group_new (MODEST_MAIN_WINDOW_ACTION_GROUP_ADDITIONS);
+ active_account_name = modest_window_get_active_account (MODEST_WINDOW (self));
+
+ if (!active_account_name)
+ modest_window_set_active_account (MODEST_WINDOW (self), default_account);
+
+ priv->view_additions_group = gtk_action_group_new (MODEST_MAIN_WINDOW_ACTION_GROUP_ADDITIONS);
+ radio_group = NULL;
for (i = 0; i < num_accounts; i++) {
- gchar *display_name = NULL;
-
- ModestAccountData *account_data = (ModestAccountData *) g_slist_nth_data (accounts, i);
+ gchar *display_name = NULL;
+ const gchar *account_name;
+ ModestAccountSettings *settings = (ModestAccountSettings *) g_slist_nth_data (accounts, i);
- /* Create display name. The UI specification specifies a different format string
- * to use for the default account, though both seem to be "%s", so
- * I don't see what the point is. murrayc. */
- if (default_account && account_data->account_name &&
- !(strcmp (default_account, account_data->account_name) == 0)) {
- display_name = g_strdup_printf (_("mcen_me_toolbar_sendreceive_default"),
- account_data->display_name);
+ if (!settings) {
+ g_warning ("%s: BUG: account_data == NULL", __FUNCTION__);
+ continue;
}
- else {
+ account_name = modest_account_settings_get_account_name (settings);
+
+ if (default_account && account_name &&
+ !(strcmp (default_account, account_name) == 0)) {
+ display_name = g_strdup_printf (_("mcen_me_toolbar_sendreceive_default"),
+ modest_account_settings_get_display_name (settings));
+ } else {
display_name = g_strdup_printf (_("mcen_me_toolbar_sendreceive_mailbox_n"),
- account_data->display_name);
+ modest_account_settings_get_display_name (settings));
}
+
+
/* Create action and add it to the action group. The
action name must be the account name, this way we
could know in the handlers the account to show */
- if(account_data && account_data->account_name) {
+ if (settings && account_name) {
gchar* item_name, *refresh_action_name;
guint8 merge_id = 0;
GtkAction *view_account_action, *refresh_account_action;
+ gchar *escaped_display_name;
+
+ escaped_display_name = modest_text_utils_escape_mnemonics (display_name);
- view_account_action = gtk_action_new (account_data->account_name,
- display_name, NULL, NULL);
- gtk_action_group_add_action (action_group, view_account_action);
+ view_account_action = GTK_ACTION (gtk_radio_action_new (account_name,
+ escaped_display_name, NULL, NULL, 0));
+ g_free (escaped_display_name);
+ gtk_action_group_add_action (priv->view_additions_group, view_account_action);
+ gtk_radio_action_set_group (GTK_RADIO_ACTION (view_account_action), radio_group);
+ radio_group = gtk_radio_action_get_group (GTK_RADIO_ACTION (view_account_action));
+
+ if (active_account_name) {
+ if (active_account_name && account_name &&
+ (strcmp (active_account_name, account_name) == 0)) {
+ gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (view_account_action), TRUE);
+ }
+ }
/* Add ui from account data. We allow 2^9-1 account
changes in a single execution because we're
downcasting the guint to a guint8 in order to use a
- GByteArray. It should be enough. */
- item_name = g_strconcat (account_data->account_name, "Menu", NULL);
+ GByteArray. It should be enough :-) */
+ item_name = g_strconcat (account_name, "Menu", NULL);
merge_id = (guint8) gtk_ui_manager_new_merge_id (parent_priv->ui_manager);
priv->merge_ids = g_byte_array_append (priv->merge_ids, &merge_id, 1);
gtk_ui_manager_add_ui (parent_priv->ui_manager,
merge_id,
"/MenuBar/ViewMenu/ViewMenuAdditions",
item_name,
- account_data->account_name,
+ account_name,
GTK_UI_MANAGER_MENUITEM,
FALSE);
/* Connect the action signal "activate" */
- g_signal_connect (G_OBJECT (view_account_action),
- "activate",
- G_CALLBACK (on_show_account_action_activated),
- self);
+ g_signal_connect_after (G_OBJECT (view_account_action),
+ "toggled",
+ G_CALLBACK (on_show_account_action_toggled),
+ self);
/* Create the items for the Tools->Send&Receive submenu */
- refresh_action_name = g_strconcat ("SendReceive", account_data->account_name, NULL);
+ refresh_action_name = g_strconcat ("SendReceive", account_name, NULL);
refresh_account_action = gtk_action_new ((const gchar*) refresh_action_name,
display_name, NULL, NULL);
- printf("DEBUG: %s: menu display_name=%s\n", __FUNCTION__, display_name);
- gtk_action_group_add_action (action_group, refresh_account_action);
+ gtk_action_group_add_action (priv->view_additions_group, refresh_account_action);
merge_id = (guint8) gtk_ui_manager_new_merge_id (parent_priv->ui_manager);
priv->merge_ids = g_byte_array_append (priv->merge_ids, &merge_id, 1);
g_signal_connect_data (G_OBJECT (refresh_account_action),
"activate",
G_CALLBACK (on_refresh_account_action_activated),
- g_strdup (account_data->account_name),
+ g_strdup (account_name),
(GClosureNotify) g_free,
0);
/* Create item and add it to the send&receive
CSM. If there is only one account then
it'll be no menu */
- if (priv->accounts_popup) {
+ if (num_accounts > 1) {
GtkWidget *label = gtk_label_new(NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- if (default_account && (strcmp(account_data->account_name, default_account) == 0))
- {
+ if (default_account && (strcmp(account_name, default_account) == 0)) {
gchar *escaped = g_markup_printf_escaped ("<b>%s</b>", display_name);
gtk_label_set_markup (GTK_LABEL (label), escaped);
g_free (escaped);
- }
- else
- {
+ } else {
gtk_label_set_text (GTK_LABEL (label), display_name);
}
item = gtk_menu_item_new ();
gtk_container_add (GTK_CONTAINER (item), label);
- gtk_menu_shell_prepend (GTK_MENU_SHELL (priv->accounts_popup), GTK_WIDGET (item));
+ gtk_menu_shell_prepend (GTK_MENU_SHELL (priv->accounts_popup),
+ GTK_WIDGET (item));
g_signal_connect_data (G_OBJECT (item),
"activate",
G_CALLBACK (on_send_receive_csm_activated),
- g_strdup (account_data->account_name),
+ g_strdup (account_name),
(GClosureNotify) g_free,
0);
}
g_free (display_name);
}
- gtk_ui_manager_insert_action_group (parent_priv->ui_manager, action_group, 1);
+ gtk_ui_manager_insert_action_group (parent_priv->ui_manager, priv->view_additions_group, 1);
/* We cannot do this in the loop above because this relies on the action
* group being inserted. This makes the default account appear in bold.
* I agree it is a rather ugly way, but I don't see another possibility. armin. */
for (i = 0; i < num_accounts; i++) {
- ModestAccountData *account_data = (ModestAccountData *) g_slist_nth_data (accounts, i);
-
- if(account_data->account_name && default_account &&
- strcmp (account_data->account_name, default_account) == 0) {
- gchar *item_name = g_strconcat (account_data->account_name, "Menu", NULL);
-
- gchar *path = g_strconcat ("/MenuBar/ViewMenu/ViewMenuAdditions/", item_name, NULL);
- GtkWidget *item = gtk_ui_manager_get_widget (parent_priv->ui_manager, path);
- g_free(path);
-
- if (item) {
- GtkWidget *child = gtk_bin_get_child (GTK_BIN (item));
- if (GTK_IS_LABEL (child)) {
- const gchar *cur_name = gtk_label_get_text (GTK_LABEL (child));
+ gchar *item_name, *path;
+ GtkWidget *item;
+ ModestAccountSettings *settings;
+ const gchar *account_name;
+ gboolean is_default;
+
+ settings = (ModestAccountSettings *) g_slist_nth_data (accounts, i);
+ account_name = modest_account_settings_get_account_name (settings);
+ is_default = (account_name && default_account && !strcmp (account_name, default_account));
+
+ /* Get the item of the view menu */
+ item_name = g_strconcat (account_name, "Menu", NULL);
+ path = g_strconcat ("/MenuBar/ViewMenu/ViewMenuAdditions/", item_name, NULL);
+ item = gtk_ui_manager_get_widget (parent_priv->ui_manager, path);
+ g_free(path);
+
+ if (item) {
+ GtkWidget *child = gtk_bin_get_child (GTK_BIN (item));
+ if (GTK_IS_LABEL (child)) {
+ const gchar *cur_name = gtk_label_get_text (GTK_LABEL (child));
+ if (is_default) {
gchar *bold_name = g_markup_printf_escaped("<b>%s</b>", cur_name);
gtk_label_set_markup (GTK_LABEL (child), bold_name);
g_free (bold_name);
}
+ gtk_label_set_ellipsize (GTK_LABEL (child), PANGO_ELLIPSIZE_END);
}
-
- path = g_strconcat("/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsMenuAdditions/", item_name, NULL);
- item = gtk_ui_manager_get_widget (parent_priv->ui_manager, path);
- g_free (path);
-
- if (item) {
- GtkWidget *child = gtk_bin_get_child (GTK_BIN (item));
- if (GTK_IS_LABEL (child)) {
- const gchar *cur_name = gtk_label_get_text (GTK_LABEL (child));
+ }
+
+ /* Get the item of the tools menu */
+ path = g_strconcat("/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsMenuAdditions/", item_name, NULL);
+ item = gtk_ui_manager_get_widget (parent_priv->ui_manager, path);
+ g_free (path);
+
+ if (item) {
+ GtkWidget *child = gtk_bin_get_child (GTK_BIN (item));
+ if (GTK_IS_LABEL (child)) {
+ const gchar *cur_name = gtk_label_get_text (GTK_LABEL (child));
+ if (is_default) {
gchar *bold_name = g_markup_printf_escaped("<b>%s</b>", cur_name);
gtk_label_set_markup (GTK_LABEL (child), bold_name);
g_free (bold_name);
}
+ gtk_label_set_ellipsize (GTK_LABEL (child), PANGO_ELLIPSIZE_END);
}
-
- g_free(item_name);
}
- modest_account_mgr_free_account_data (mgr, account_data);
+ g_free(item_name);
+ g_object_unref (settings);
}
- if (priv->accounts_popup) {
+ if (num_accounts > 1) {
+ /* Disconnect the tap-and-hold-query if it's connected */
+ if (modest_signal_mgr_is_connected (priv->sighandlers,
+ G_OBJECT (send_receive_button),
+ "tap-and-hold-query"))
+ priv->sighandlers = modest_signal_mgr_disconnect (priv->sighandlers,
+ G_OBJECT (send_receive_button),
+ "tap-and-hold-query");
+
/* Mandatory in order to view the menu contents */
gtk_widget_show_all (priv->accounts_popup);
/* Setup tap_and_hold just if was not done before*/
if (!gtk_menu_get_attach_widget (GTK_MENU (priv->accounts_popup)))
gtk_widget_tap_and_hold_setup (send_receive_button, priv->accounts_popup, NULL, 0);
+ } else {
+ /* Connect the tap-and-hold-query in order not to show the CSM */
+ if (!modest_signal_mgr_is_connected (priv->sighandlers,
+ G_OBJECT (send_receive_button),
+ "tap-and-hold-query"))
+ priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
+ G_OBJECT (send_receive_button),
+ "tap-and-hold-query",
+ G_CALLBACK (tap_and_hold_query_cb),
+ NULL);
}
/* Frees */
}
-/* static gboolean */
-/* on_delete_event (GtkWidget *widget, GdkEvent *event, ModestMainWindow *self) */
-/* { */
-/* modest_window_save_state (MODEST_WINDOW(self)); */
-/* return FALSE; */
-/* } */
-
-/* static void */
-/* on_sendqueue_error_happened (TnySendQueue *self, TnyHeader *header, TnyMsg *msg, GError *err, ModestMainWindow *user_data) */
-/* { */
-/* if (err) { */
-/* printf ("DEBUG: %s: err->code=%d, err->message=%s\n", __FUNCTION__, err->code, err->message); */
-
-/* if (err->code == TNY_ACCOUNT_ERROR_TRY_CONNECT_USER_CANCEL) */
-/* /\* Don't show waste the user's time by showing him a dialog telling him */
-/* * that he has just cancelled something: *\/ */
-/* return; */
-/* } */
-
-/* /\* Get the server name: *\/ */
-/* const gchar* server_name = NULL; */
-
-/* TnyCamelTransportAccount* server_account = tny_camel_send_queue_get_transport_account ( */
-/* TNY_CAMEL_SEND_QUEUE (self)); */
-/* if (server_account) { */
-/* server_name = tny_account_get_hostname (TNY_ACCOUNT (server_account)); */
-
-/* g_object_unref (server_account); */
-/* server_account = NULL; */
-/* } */
-
-/* if (!server_name) */
-/* server_name = _("Unknown Server"); */
-
-/* /\* Show the appropriate message text for the GError: *\/ */
-/* gchar *message = NULL; */
-/* if (err) { */
-/* switch (err->code) { */
-/* case TNY_TRANSPORT_ACCOUNT_ERROR_SEND_HOST_LOOKUP_FAILED: */
-/* message = g_strdup_printf (_("emev_ib_ui_smtp_server_invalid"), server_name); */
-/* break; */
-/* case TNY_TRANSPORT_ACCOUNT_ERROR_SEND_SERVICE_UNAVAILABLE: */
-/* message = g_strdup_printf (_("emev_ib_ui_smtp_server_invalid"), server_name); */
-/* break; */
-/* case TNY_TRANSPORT_ACCOUNT_ERROR_SEND_AUTHENTICATION_NOT_SUPPORTED: */
-/* /\* TODO: This logical ID seems more suitable for a wrong username or password than for a */
-/* * wrong authentication method. The user is unlikely to guess at the real cause. */
-/* *\/ */
-/* message = g_strdup_printf (_("eemev_ni_ui_smtp_authentication_fail_error"), server_name); */
-/* break; */
-/* case TNY_TRANSPORT_ACCOUNT_ERROR_SEND: */
-/* /\* TODO: Tinymail is still sending this sometimes when it should */
-/* * send TNY_ACCOUNT_ERROR_TRY_CONNECT_USER_CANCEL. *\/ */
-/* default: */
-/* message = g_strdup (_("emev_ib_ui_smtp_send_error")); */
-/* break; */
-/* } */
-/* } else { */
-/* message = g_strdup (_("emev_ib_ui_smtp_send_error")); */
-/* } */
-
-/* modest_maemo_show_information_note_and_forget (GTK_WINDOW (user_data), message); */
-/* g_free (message); */
-
-/* /\* TODO: Offer to remove the message, to avoid messages in future? *\/ */
-/* /\* */
-/* TnyFolder *outbox = tny_send_queue_get_outbox (queue); */
-/* tny_folder_remove_msg (outbox, header, NULL); */
-/* tny_folder_sync (outbox, TRUE, NULL); */
-/* g_object_unref (outbox); */
-/* *\/ */
-/* } */
-
typedef struct {
TnySendQueue *queue;
guint signal;
priv->queue_err_signals = NULL;
}
-/* static void */
-/* on_account_store_connecting_finished (TnyAccountStore *store, ModestMainWindow *self) */
-/* { */
-/* ModestMainWindowPrivate *priv = MODEST_MAIN_WINDOW_GET_PRIVATE (self); */
-
-/* /\* When going online, do the equivalent of pressing the send/receive button, */
-/* * as per the specification: */
-/* * (without the check for >0 accounts, though that is not specified): *\/ */
-
-/* TnyDevice *device = tny_account_store_get_device (store); */
-
-/* /\* modest_folder_view_update_model (MODEST_FOLDER_VIEW (priv->folder_view), store); *\/ */
-
-/* /\* Check that we are really online. */
-/* * This signal should not be emitted when we are not connected, */
-/* * but it seems to happen sometimes: *\/ */
-/* if (!tny_device_is_online (device)) */
-/* return; */
-
-/* const gchar *iap_id = tny_maemo_conic_device_get_current_iap_id (TNY_MAEMO_CONIC_DEVICE (device)); */
-/* printf ("DEBUG: %s: connection id=%s\n", __FUNCTION__, iap_id); */
-
-/* /\* Stop the existing send queues: *\/ */
-/* modest_runtime_remove_all_send_queues (); */
-
-/* /\* Create the send queues again, using the appropriate transport accounts */
-/* * for this new connection. */
-/* * This could be the first time that they are created if this is the first */
-/* * connection. *\/ */
-/* /\* TODO: Does this really destroy the TnySendQueues and their threads */
-/* * We do not want 2 TnySendQueues to exist with the same underlying */
-/* * outbox directory. *\/ */
-
-/* modest_main_window_cleanup_queue_error_signals (self); */
-
-/* GSList *account_names = modest_account_mgr_account_names ( */
-/* modest_runtime_get_account_mgr(), */
-/* TRUE /\* enabled accounts only *\/); */
-/* GSList *iter = account_names; */
-/* while (iter) { */
-/* const gchar *account_name = (const gchar*)(iter->data); */
-/* if (account_name) { */
-/* TnyTransportAccount *account = TNY_TRANSPORT_ACCOUNT ( */
-/* modest_tny_account_store_get_transport_account_for_open_connection */
-/* (modest_runtime_get_account_store(), account_name)); */
-/* if (account) { */
-/* /\* Q: Is this the first location where the send-queues are requested? *\/ */
-/* QueueErrorSignal *esignal = g_slice_new (QueueErrorSignal); */
-/* printf ("debug: %s:\n Transport account for %s: %s\n", __FUNCTION__, account_name, */
-/* tny_account_get_id(TNY_ACCOUNT(account))); */
-/* esignal->queue = TNY_SEND_QUEUE (modest_runtime_get_send_queue (account)); */
-/* esignal->signal = g_signal_connect (G_OBJECT (esignal->queue), "error-happened", */
-/* G_CALLBACK (on_sendqueue_error_happened), self); */
-/* priv->queue_err_signals = g_list_prepend (priv->queue_err_signals, esignal); */
-/* } */
-/* } */
-
-/* iter = g_slist_next (iter); */
-/* } */
-
-/* modest_account_mgr_free_account_names (account_names); */
-/* account_names = NULL; */
-
-/* modest_ui_actions_do_send_receive (NULL, MODEST_WINDOW (self)); */
-/* } */
static void
_folder_view_csm_menu_activated (GtkWidget *widget, gpointer user_data)
{
g_return_if_fail (MODEST_IS_MAIN_WINDOW (user_data));
- /* Update dimmed */
- modest_window_check_dimming_rules_group (MODEST_WINDOW (user_data), "ModestMenuDimmingRules");
+ /* Update dimmed */
+ modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW(user_data));
}
static void
/* Update visibility */
- /* Update dimmed */
- modest_window_check_dimming_rules_group (MODEST_WINDOW (user_data), "ModestMenuDimmingRules");
+ /* Update dimmed */
+ modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW(user_data));
}
static void
/* folder view */
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
- G_OBJECT(priv->folder_view), "key-press-event",
- G_CALLBACK(on_inner_widgets_key_pressed), self);
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->folder_view), "folder_selection_changed",
- G_CALLBACK(modest_main_window_on_folder_selection_changed), self);
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->folder_view), "folder-display-name-changed",
- G_CALLBACK(modest_ui_actions_on_folder_display_name_changed), self);
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (priv->folder_view), "focus-in-event",
- G_CALLBACK (on_folder_view_focus_in), self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,
+ G_OBJECT(priv->folder_view), "key-press-event",
+ G_CALLBACK(on_inner_widgets_key_pressed), self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers, G_OBJECT(priv->folder_view),
+ "folder_selection_changed",
+ G_CALLBACK (on_folder_selection_changed),
+ self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->folder_view),
+ "folder-display-name-changed",
+ G_CALLBACK (modest_ui_actions_on_folder_display_name_changed),
+ self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (priv->folder_view),
+ "focus-in-event",
+ G_CALLBACK (on_folder_view_focus_in),
+ self);
/* Folder view CSM */
menu = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/FolderViewCSM");
G_CALLBACK(_folder_view_csm_menu_activated),
self);
/* header view */
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "header_selected",
- G_CALLBACK(modest_ui_actions_on_header_selected), self);
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "header_activated",
- G_CALLBACK(modest_ui_actions_on_header_activated), self);
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "item_not_found",
- G_CALLBACK(modest_ui_actions_on_item_not_found), self);
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "key-press-event",
- G_CALLBACK(on_inner_widgets_key_pressed), self);
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "msg_count_changed",
- G_CALLBACK(_on_msg_count_changed), self);
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (priv->header_view), "focus-in-event",
- G_CALLBACK (on_header_view_focus_in), self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "header_selected",
+ G_CALLBACK(modest_ui_actions_on_header_selected), self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "header_activated",
+ G_CALLBACK(modest_ui_actions_on_header_activated), self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "item_not_found",
+ G_CALLBACK(modest_ui_actions_on_item_not_found), self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "key-press-event",
+ G_CALLBACK(on_inner_widgets_key_pressed), self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "msg_count_changed",
+ G_CALLBACK(on_msg_count_changed), self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (priv->header_view), "focus-in-event",
+ G_CALLBACK (on_header_view_focus_in), self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,
+ G_OBJECT (priv->header_view),
+ "updating-msg-list",
+ G_CALLBACK (on_updating_msg_list),
+ self);
/* Header view CSM */
menu = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/HeaderViewCSM");
gtk_widget_tap_and_hold_setup (GTK_WIDGET (priv->header_view), menu, NULL, 0);
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "tap-and-hold",
- G_CALLBACK(_header_view_csm_menu_activated),
- self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(priv->header_view), "tap-and-hold",
+ G_CALLBACK(_header_view_csm_menu_activated),
+ self);
/* window */
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (self), "window-state-event",
- G_CALLBACK (modest_main_window_window_state_event),
- NULL);
-
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (self), "window-state-event",
+ G_CALLBACK (modest_main_window_window_state_event),
+ NULL);
+ /* 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), "destroy", G_CALLBACK (on_window_destroy), NULL);
+
+ g_signal_connect (G_OBJECT (self), "notify::visible", G_CALLBACK (on_window_hide), NULL);
+
/* Mail Operation Queue */
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (modest_runtime_get_mail_operation_queue ()),
- "queue-changed", G_CALLBACK (on_queue_changed), self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,
+ G_OBJECT (modest_runtime_get_mail_operation_queue ()),
+ "queue-changed",
+ G_CALLBACK (on_queue_changed), self);
/* Track changes in the device name */
- priv->notification_id = modest_conf_listen_to_namespace (modest_runtime_get_conf (),
- MODEST_CONF_NAMESPACE);
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT(modest_runtime_get_conf ()),
- "key_changed", G_CALLBACK (on_configuration_key_changed),
- self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,
+ G_OBJECT(modest_runtime_get_conf ()),
+ "key_changed",
+ G_CALLBACK (on_configuration_key_changed),
+ self);
/* Track account changes. We need to refresh the toolbar */
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (modest_runtime_get_account_store ()),
- "account_inserted", G_CALLBACK (on_account_inserted),
- self);
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (modest_runtime_get_account_store ()),
- "account_removed", G_CALLBACK (on_account_removed),
- self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,
+ G_OBJECT (modest_runtime_get_account_store ()),
+ "account_inserted",
+ G_CALLBACK (on_account_inserted),
+ self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,
+ G_OBJECT (modest_runtime_get_account_store ()),
+ "account_removed",
+ G_CALLBACK (on_account_removed),
+ self);
/* We need to refresh the send & receive menu to change the bold
* account when the default account changes. */
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (modest_runtime_get_account_mgr ()),
- "account_changed", G_CALLBACK (on_account_changed),
- self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,
+ G_OBJECT (modest_runtime_get_account_mgr ()),
+ "default_account_changed",
+ G_CALLBACK (on_default_account_changed),
+ self);
/* Account store */
- priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,G_OBJECT (modest_runtime_get_account_store()),
- "password_requested",
- G_CALLBACK (modest_ui_actions_on_password_requested), self);
+ priv->sighandlers =
+ modest_signal_mgr_connect (priv->sighandlers,
+ G_OBJECT (modest_runtime_get_account_store ()),
+ "account_changed",
+ G_CALLBACK (on_account_changed),
+ self);
}
-#if 0
-/** Idle handler, to send/receive at startup .*/
-gboolean
-sync_accounts_cb (ModestMainWindow *win)
-{
- modest_ui_actions_do_send_receive (NULL, MODEST_WINDOW (win));
- return FALSE; /* Do not call this idle handler again. */
-}
-#endif
-
-static void on_hildon_program_is_topmost_notify(GObject *self,
- GParamSpec *propert_param, gpointer user_data)
+static void
+on_hildon_program_is_topmost_notify(GObject *self,
+ GParamSpec *propert_param,
+ gpointer user_data)
{
HildonProgram *app = HILDON_PROGRAM (self);
- /*
- ModestWindow* self = MODEST_WINDOW(user_data);
- */
-
/* Note that use of hildon_program_set_can_hibernate()
* is generally referred to as "setting the killable flag",
* though hibernation does not seem equal to death.
* because hibernation should only happen when the application
* is in the background: */
hildon_program_set_can_hibernate (app, FALSE);
+
+ /* Remove new mail visual notifications */
+ modest_platform_remove_new_mail_notifications (TRUE);
} else {
/* Allow hibernation if the program has gone to the background: */
/* However, prevent hibernation while the settings are being changed: */
const gboolean hibernation_prevented =
modest_window_mgr_get_hibernation_is_prevented (
- modest_runtime_get_window_mgr ());
+ modest_runtime_get_window_mgr ());
if (hibernation_prevented)
hildon_program_set_can_hibernate (app, FALSE);
modest_osso_save_state();
hildon_program_set_can_hibernate (app, TRUE);
}
- }
-
+ }
}
+typedef struct
+{
+ GtkWidget *folder_win;
+ gulong handler_id;
+} ShowHelper;
+
static void
modest_main_window_on_show (GtkWidget *self, gpointer user_data)
{
- GtkWidget *folder_win = (GtkWidget *) user_data;
+ ShowHelper *helper = (ShowHelper *) user_data;
+ GtkWidget *folder_win = helper->folder_win;
ModestMainWindowPrivate *priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
priv->folder_view = MODEST_FOLDER_VIEW (modest_platform_create_folder_view (NULL));
wrap_in_scrolled_window (folder_win, GTK_WIDGET(priv->folder_view));
-/* wrap_in_scrolled_window (priv->contents_widget, GTK_WIDGET(priv->header_view)); */
gtk_widget_show (GTK_WIDGET (priv->folder_view));
/* Connect signals */
- connect_signals ((ModestMainWindow*)self);
+ connect_signals (MODEST_MAIN_WINDOW (self));
/* Set account store */
tny_account_store_view_set_account_store (TNY_ACCOUNT_STORE_VIEW (priv->folder_view),
* hibernation: */
modest_osso_load_state ();
- /* Restore window & widget settings */
-
+ /* Restore window & widget settings */
+ priv->wait_for_settings = TRUE;
restore_settings (MODEST_MAIN_WINDOW(self), TRUE);
+ priv->wait_for_settings = FALSE;
- /* The UI spec wants us to show a connection dialog when the application is
- * started by the user, if there is no connection.
- * Do this before showing the account wizard,
- * because wizard needs a connection to discover capabilities. */
- modest_platform_connect_and_wait (GTK_WINDOW (self), NULL);
-
/* Check if accounts exist and show the account wizard if not */
gboolean accounts_exist =
modest_account_mgr_has_accounts(modest_runtime_get_account_mgr(), TRUE);
accounts = modest_account_mgr_account_names (modest_runtime_get_account_mgr (), TRUE);
send_receive_all = gtk_ui_manager_get_action (parent_priv->ui_manager,
"/MenuBar/ToolsMenu/ToolsSendReceiveMainMenu/ToolsSendReceiveAllMenu");
- gtk_action_set_visible (send_receive_all, g_slist_length (accounts) > 1);
+ gtk_action_set_visible (send_receive_all, g_slist_length (accounts) > 0);
modest_account_mgr_free_account_names (accounts);
+ update_menus (MODEST_MAIN_WINDOW (self));
}
+
+ /* Never call this function again (NOTE that it could happen
+ as we hide the main window instead of closing it while
+ there are operations ongoing) and free the helper */
+ g_signal_handler_disconnect (self, helper->handler_id);
+ g_slice_free (ShowHelper, helper);
+}
+
+static void
+osso_display_event_cb (osso_display_state_t state,
+ gpointer data)
+{
+ ModestMainWindowPrivate *priv = MODEST_MAIN_WINDOW_GET_PRIVATE (data);
+
+ priv->display_state = state;
+
+ /* Stop blinking if the screen becomes on */
+ if (priv->display_state == OSSO_DISPLAY_ON)
+ modest_platform_remove_new_mail_notifications (TRUE);
}
ModestWindow *
ModestDimmingRulesGroup *toolbar_rules_group = NULL;
GtkActionGroup *action_group = NULL;
GError *error = NULL;
+ HildonProgram *app;
ModestConf *conf = NULL;
GtkAction *action = NULL;
GdkPixbuf *window_icon;
+ ShowHelper *helper;
self = MODEST_MAIN_WINDOW(g_object_new(MODEST_TYPE_MAIN_WINDOW, NULL));
priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
action_group = gtk_action_group_new ("ModestMainWindowActions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
- menu_rules_group = modest_dimming_rules_group_new ("ModestMenuDimmingRules", FALSE);
- toolbar_rules_group = modest_dimming_rules_group_new ("ModestToolbarDimmingRules", TRUE);
+ menu_rules_group = modest_dimming_rules_group_new (MODEST_DIMMING_RULES_MENU, FALSE);
+ toolbar_rules_group = modest_dimming_rules_group_new (MODEST_DIMMING_RULES_TOOLBAR, TRUE);
/* Add common actions */
gtk_action_group_add_actions (action_group,
modest_dimming_rules_group_add_rules (menu_rules_group,
modest_main_window_menu_dimming_entries,
G_N_ELEMENTS (modest_main_window_menu_dimming_entries),
- self);
+ MODEST_WINDOW (self));
modest_dimming_rules_group_add_rules (toolbar_rules_group,
modest_main_window_toolbar_dimming_entries,
G_N_ELEMENTS (modest_main_window_toolbar_dimming_entries),
- self);
+ MODEST_WINDOW (self));
/* Insert dimming rules group for this window */
modest_ui_dimming_manager_insert_rules_group (parent_priv->ui_dimming_manager, menu_rules_group);
gtk_ui_manager_get_accel_group (parent_priv->ui_manager));
/* Menubar. Update the state of some toggles */
- parent_priv->menubar = modest_maemo_utils_menubar_to_menu (parent_priv->ui_manager);
+ parent_priv->menubar = modest_maemo_utils_get_manager_menubar_as_menu (parent_priv->ui_manager, "/MenuBar");
conf = modest_runtime_get_conf ();
action = gtk_ui_manager_get_action (parent_priv->ui_manager,
"/MenuBar/ViewMenu/ViewShowToolbarMainMenu/ViewShowToolbarNormalScreenMenu");
/* header view */
priv->header_view =
MODEST_HEADER_VIEW (modest_header_view_new (NULL, MODEST_HEADER_VIEW_STYLE_DETAILS));
+ g_object_ref (priv->header_view);
if (!priv->header_view)
g_printerr ("modest: cannot instantiate header view\n");
modest_header_view_set_style (priv->header_view, MODEST_HEADER_VIEW_STYLE_TWOLINES);
/* Empty view */
priv->empty_view = create_empty_view ();
gtk_widget_show (priv->empty_view);
+ g_object_ref (priv->empty_view);
/* Create scrolled windows */
folder_win = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER(self), priv->main_vbox);
- HildonProgram *app = hildon_program_get_instance ();
+ app = hildon_program_get_instance ();
hildon_program_add_window (app, HILDON_WINDOW (self));
g_signal_connect (G_OBJECT(app), "notify::is-topmost",
G_CALLBACK (on_hildon_program_is_topmost_notify), self);
- g_signal_connect (G_OBJECT(self), "show",
- G_CALLBACK (modest_main_window_on_show), folder_win);
-
+ /* Connect to "show" action. We delay the creation of some
+ elements until that moment */
+ helper = g_slice_new0 (ShowHelper);
+ helper->folder_win = folder_win;
+ helper->handler_id = g_signal_connect (G_OBJECT(self), "show",
+ G_CALLBACK (modest_main_window_on_show),
+ helper);
+
/* Set window icon */
- window_icon = modest_platform_get_icon (MODEST_APP_ICON);
+ window_icon = modest_platform_get_icon (MODEST_APP_ICON, MODEST_ICON_SIZE_BIG);
if (window_icon) {
gtk_window_set_icon (GTK_WINDOW (self), window_icon);
g_object_unref (window_icon);
}
+ /* Listen for changes in the screen, we don't want to show a
+ led pattern when the display is on for example */
+ osso_hw_set_display_event_cb (modest_maemo_utils_get_osso_context (),
+ osso_display_event_cb,
+ self);
+
/* Dont't restore settings here,
* because it requires a gtk_widget_show(),
* and we don't want to do that until later,
* so that the UI is not visible for non-menu D-Bus activation.
*/
- /* restore_settings (MODEST_MAIN_WINDOW(self), FALSE); */
return MODEST_WINDOW(self);
}
-gboolean
-modest_main_window_close_all (ModestMainWindow *self)
-{
- GtkWidget *note;
- GtkResponseType response;
-
- /* Create the confirmation dialog MSG-NOT308 */
- note = hildon_note_new_confirmation_add_buttons (GTK_WINDOW (self),
- _("emev_nc_close_windows"),
- _("mcen_bd_yes"), GTK_RESPONSE_YES,
- _("mcen_bd_no"), GTK_RESPONSE_NO,
- NULL);
-
- response = gtk_dialog_run (GTK_DIALOG (note));
- gtk_widget_destroy (GTK_WIDGET (note));
-
- if (response == GTK_RESPONSE_YES)
- return TRUE;
- else
- return FALSE;
-}
-
-
void
modest_main_window_set_style (ModestMainWindow *self,
ModestMainWindowStyle style)
ModestWindowPrivate *parent_priv;
GtkAction *action;
gboolean active;
-
+ GtkTreeSelection *sel;
+ GList *rows, *list;
+
g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
g_signal_handlers_unblock_by_func (action, modest_ui_actions_toggle_folders_view, self);
}
+ /* We need to store the selection because it's lost when the
+ widget is reparented */
+ sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->header_view));
+ rows = gtk_tree_selection_get_selected_rows (sel, NULL);
+
priv->style = style;
switch (style) {
case MODEST_MAIN_WINDOW_STYLE_SIMPLE:
+
+ if (!priv->wait_for_settings)
+ modest_widget_memory_save (modest_runtime_get_conf (), G_OBJECT (priv->main_paned),
+ MODEST_CONF_MAIN_PANED_KEY);
/* Remove main paned */
g_object_ref (priv->main_paned);
gtk_container_remove (GTK_CONTAINER (priv->main_vbox), priv->main_paned);
gtk_paned_add2 (GTK_PANED (priv->main_paned), priv->contents_widget);
gtk_container_add (GTK_CONTAINER (priv->main_vbox), priv->main_paned);
+ g_timeout_add (500, (GSourceFunc) restore_paned_timeout_handler, self);
+
break;
default:
+ g_list_foreach (rows, (GFunc) gtk_tree_path_free, NULL);
+ g_list_free (rows);
g_return_if_reached ();
}
+ /* Reselect the previously selected folders. We disable the
+ dimming rules execution during that time because there is
+ no need to work out it again and it could take a lot of
+ time if all the headers are selected */
+ list = rows;
+ modest_window_disable_dimming (MODEST_WINDOW (self));
+ while (list) {
+ gtk_tree_selection_select_path (sel, (GtkTreePath *) list->data);
+ list = g_list_next (list);
+ }
+ modest_window_enable_dimming (MODEST_WINDOW (self));
+
+ /* Free */
+ g_list_foreach (rows, (GFunc) gtk_tree_path_free, NULL);
+ g_list_free (rows);
+
/* Let header view grab the focus if it's being shown */
if (priv->contents_style == MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
gtk_widget_grab_focus (GTK_WIDGET (priv->header_view));
return priv->style;
}
+static void
+toolbar_resize (ModestMainWindow *self)
+{
+ ModestMainWindowPrivate *priv = NULL;
+ ModestWindowPrivate *parent_priv = NULL;
+ GtkWidget *widget;
+ gint static_button_size;
+ ModestWindowMgr *mgr;
+
+ g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
+ priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
+ parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
+
+ mgr = modest_runtime_get_window_mgr ();
+ static_button_size = modest_window_mgr_get_fullscreen_mode (mgr)?118:108;
+
+ if (parent_priv->toolbar) {
+ /* left size buttons */
+ widget = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNew");
+ gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), FALSE);
+ gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), FALSE);
+ gtk_widget_set_size_request (GTK_WIDGET (widget), static_button_size, -1);
+ widget = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarMessageReply");
+ gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), FALSE);
+ gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), FALSE);
+ gtk_widget_set_size_request (GTK_WIDGET (widget), static_button_size, -1);
+ widget = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarDeleteMessage");
+ gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), FALSE);
+ gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), FALSE);
+ gtk_widget_set_size_request (GTK_WIDGET (widget), static_button_size, -1);
+ widget = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToggleFolders");
+ gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), FALSE);
+ gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), FALSE);
+ gtk_widget_set_size_request (GTK_WIDGET (widget), static_button_size, -1);
+
+ gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
+ gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
+ gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE);
+ gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE);
+ gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->refresh_toolitem), TRUE);
+ gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->refresh_toolitem), TRUE);
+ gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->sort_toolitem), TRUE);
+ gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->sort_toolitem), TRUE);
+ }
+
+}
+
static gboolean
if (is_fullscreen != active) {
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (fs_toggle_action), is_fullscreen);
}
+
+ toolbar_resize (MODEST_MAIN_WINDOW (widget));
}
return FALSE;
}
-static void
-set_homogeneous (GtkWidget *widget,
- gpointer data)
-{
- gtk_tool_item_set_expand (GTK_TOOL_ITEM (widget), TRUE);
- gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), TRUE);
-}
-
static void
modest_main_window_show_toolbar (ModestWindow *self,
gboolean show_toolbar)
"/ToolBar");
gtk_widget_set_no_show_all (parent_priv->toolbar, TRUE);
- /* Set homogeneous toolbar */
- gtk_container_foreach (GTK_CONTAINER (parent_priv->toolbar),
- set_homogeneous, NULL);
-
priv->progress_toolitem = GTK_WIDGET (gtk_tool_item_new ());
priv->cancel_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarCancel");
priv->refresh_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarSendReceive");
priv->sort_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarSort");
- gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
- gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
- gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE);
- gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE);
-
+ toolbar_resize (MODEST_MAIN_WINDOW (self));
+
/* Add ProgressBar (Transfer toolbar) */
- priv->progress_bar = modest_progress_bar_widget_new ();
+ priv->progress_bar = modest_progress_bar_new ();
gtk_widget_set_no_show_all (priv->progress_bar, TRUE);
placeholder = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ProgressBarView");
insert_index = gtk_toolbar_get_item_index(GTK_TOOLBAR (parent_priv->toolbar), GTK_TOOL_ITEM(placeholder));
/* Set send & receive button tap and hold menu */
update_menus (MODEST_MAIN_WINDOW (self));
}
-
+
if (show_toolbar) {
/* Quick hack: this prevents toolbar icons "dance" when progress bar show status is changed */
/* TODO: resize mode migth be GTK_RESIZE_QUEUE, in order to avoid unneccesary shows */
gtk_container_set_resize_mode (GTK_CONTAINER(parent_priv->toolbar), GTK_RESIZE_IMMEDIATE);
gtk_widget_show (GTK_WIDGET (parent_priv->toolbar));
- set_toolbar_mode (MODEST_MAIN_WINDOW(self), TOOLBAR_MODE_NORMAL);
- } else
+ if (modest_main_window_transfer_mode_enabled (MODEST_MAIN_WINDOW(self)))
+ set_toolbar_mode (MODEST_MAIN_WINDOW(self), TOOLBAR_MODE_TRANSFER);
+ else
+ set_toolbar_mode (MODEST_MAIN_WINDOW(self), TOOLBAR_MODE_NORMAL);
+ } else {
gtk_widget_hide (GTK_WIDGET (parent_priv->toolbar));
+ }
+
/* Update also the actions (to update the toggles in the
menus), we have to do it manually because some other window
of the same time could have changed it (remember that the
toolbar fullscreen mode is shared by all the windows of the
same type */
if (modest_window_mgr_get_fullscreen_mode (modest_runtime_get_window_mgr ()))
- action_name = "/MenuBar/ViewMenu/ViewShowToolbarMenu/ViewShowToolbarFullScreenMenu";
+ action_name = "/MenuBar/ViewMenu/ViewShowToolbarMainMenu/ViewShowToolbarFullScreenMenu";
else
- action_name = "/MenuBar/ViewMenu/ViewShowToolbarMenu/ViewShowToolbarNormalScreenMenu";
+ action_name = "/MenuBar/ViewMenu/ViewShowToolbarMainMenu/ViewShowToolbarNormalScreenMenu";
action = gtk_ui_manager_get_action (parent_priv->ui_manager, action_name);
- modest_maemo_toggle_action_set_active_block_notify (GTK_TOGGLE_ACTION (action),
+ modest_utils_toggle_action_set_active_block_notify (GTK_TOGGLE_ACTION (action),
show_toolbar);
}
TnyAccount *account,
gpointer user_data)
{
- update_menus (MODEST_MAIN_WINDOW (user_data));
+ /* Transport accounts and local ones (MMC and the Local
+ folders account do now cause menu changes */
+ if (TNY_IS_STORE_ACCOUNT (account) &&
+ modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account))) {
+ /* Update menus */
+ update_menus (MODEST_MAIN_WINDOW (user_data));
+ }
}
static void
-on_account_changed (ModestAccountMgr* mgr,
- const gchar* account,
- gpointer user_data)
+on_default_account_changed (ModestAccountMgr* mgr,
+ gpointer user_data)
{
- gchar *default_account = modest_account_mgr_get_default_account (modest_runtime_get_account_mgr ());
-
- /* Actually, we only want to know when another account has become
- * the default account, but there is no default_account_changed
- * signal in ModestAccountMgr. */
- if(strcmp(account, default_account) == 0)
- update_menus (MODEST_MAIN_WINDOW (user_data));
-
- g_free (default_account);
+ update_menus (MODEST_MAIN_WINDOW (user_data));
}
static void
TnyAccount *account,
gpointer user_data)
{
- update_menus (MODEST_MAIN_WINDOW (user_data));
+ /* Transport accounts and local ones (MMC and the Local
+ folders account do now cause menu changes */
+ if (TNY_IS_STORE_ACCOUNT (account) &&
+ modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account)))
+ update_menus (MODEST_MAIN_WINDOW (user_data));
+}
+
+static void
+on_account_changed (TnyAccountStore *account_store,
+ TnyAccount *account,
+ gpointer user_data)
+{
+ ModestMainWindow *win = MODEST_MAIN_WINDOW (user_data);
+
+ /* Transport accounts and local ones (MMC and the Local
+ folders account do now cause menu changes */
+ if (TNY_IS_STORE_ACCOUNT (account)) {
+ /* We need to refresh the details widget because it could have changed */
+ if (modest_main_window_get_contents_style(win) == MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS)
+ modest_main_window_set_contents_style (win, MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS);
+
+ /* Update the menus as well, name could change */
+ if (modest_tny_folder_store_is_remote (TNY_FOLDER_STORE (account)))
+ update_menus (MODEST_MAIN_WINDOW (user_data));
+ }
}
/*
{
ModestMainWindowPrivate *priv;
+ if (event->type == GDK_KEY_RELEASE)
+ return FALSE;
+
priv = MODEST_MAIN_WINDOW_GET_PRIVATE (user_data);
/* Do nothing if we're in SIMPLE style */
if (priv->style == MODEST_MAIN_WINDOW_STYLE_SIMPLE)
return FALSE;
- if (MODEST_IS_HEADER_VIEW (widget) && event->keyval == GDK_Left)
- gtk_widget_grab_focus (GTK_WIDGET (priv->folder_view));
- else if (MODEST_IS_FOLDER_VIEW (widget) && event->keyval == GDK_Right)
+ if (MODEST_IS_HEADER_VIEW (widget)) {
+ if (event->keyval == GDK_Left)
+ gtk_widget_grab_focus (GTK_WIDGET (priv->folder_view));
+ else if ((event->keyval == GDK_Return)||(event->keyval == GDK_KP_Enter)) {
+ guint selected_headers = modest_header_view_count_selected_headers (MODEST_HEADER_VIEW (widget));
+ if (selected_headers > 1) {
+ hildon_banner_show_information (NULL, NULL, _("mcen_ib_select_one_message"));
+ return TRUE;
+ } else {
+ GtkTreePath * cursor_path;
+ gtk_tree_view_get_cursor (GTK_TREE_VIEW (widget), &cursor_path, NULL);
+ if (cursor_path == NULL) {
+ GtkTreeSelection *selection;
+ GList *list;
+ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
+ list = gtk_tree_selection_get_selected_rows (selection, NULL);
+
+ if (list != NULL)
+ gtk_tree_view_set_cursor (GTK_TREE_VIEW (widget), (GtkTreePath *) list->data, NULL, FALSE);
+ g_list_foreach (list, (GFunc) gtk_tree_path_free, NULL);
+ g_list_free (list);
+ }
+ }
+ }
+ } else if (MODEST_IS_FOLDER_VIEW (widget) && event->keyval == GDK_Right)
gtk_widget_grab_focus (GTK_WIDGET (priv->header_view));
return FALSE;
return GTK_WIDGET(align);
}
+/*
+ * Free the returned string
+ */
+static gchar *
+get_gray_color_markup (GtkWidget *styled_widget)
+{
+ gchar *gray_color_markup = NULL;
+#ifndef MODEST_HAVE_HILDON0_WIDGETS
+ /* Obtain the secondary text color. We need a realized widget, that's why
+ we get styled_widget from outside */
+ GdkColor color;
+ if (gtk_style_lookup_color (styled_widget->style, "SecondaryTextColor", &color))
+ gray_color_markup = modest_text_utils_get_color_string (&color);
+#endif /*MODEST_HAVE_HILDON0_WIDGETS*/
+
+ if (!gray_color_markup)
+ gray_color_markup = g_strdup ("#BBBBBB");
+
+ return gray_color_markup;
+}
+
+/*
+ * Free the returned string
+ */
+static gchar*
+create_device_name_visual_string (const gchar *device_name,
+ const gchar *gray_color_markup)
+{
+ gchar *tmp, *label;
+
+ /* We have to use "" to fill the %s of the translation. We can
+ not just use the device name because the device name is
+ shown in a different color, so it could not be included
+ into the <span> tag */
+ tmp = g_strdup_printf (_("mcen_fi_localroot_description"), "");
+ label = g_markup_printf_escaped ("<span color='%s'>%s</span>%s",
+ gray_color_markup,
+ tmp,
+ device_name);
+ g_free (tmp);
+
+ return label;
+}
+
+typedef struct
+{
+ GtkWidget *count_label;
+ GtkWidget *msg_count_label;
+ GtkWidget *size_label;
+ gchar *color_markup;
+} DetailsWidgets;
+
+static gchar *
+create_uint_label (const gchar *markup,
+ const gchar *name,
+ guint count)
+{
+ return g_markup_printf_escaped ("<span color='%s'>%s:</span> %d", markup, name, count);
+}
+
+static gchar *
+create_gchar_label (const gchar *markup,
+ const gchar *name,
+ gchar *count)
+{
+ return g_markup_printf_escaped ("<span color='%s'>%s:</span> %s", markup, name, count);
+}
+
+static void
+update_folder_stats_status_cb (ModestFolderStats stats,
+ gpointer user_data)
+{
+ DetailsWidgets *widgets = (DetailsWidgets *) user_data;
+ gchar *label, *tmp;
+
+ label = create_uint_label (widgets->color_markup, _("mcen_fi_rootfolder_folders"), stats.folders);
+ gtk_label_set_markup (GTK_LABEL (widgets->count_label), label);
+ g_free (label);
+
+ label = create_uint_label (widgets->color_markup, _("mcen_fi_rootfolder_messages"), stats.msg_count);
+ gtk_label_set_markup (GTK_LABEL (widgets->msg_count_label), label);
+ g_free (label);
+
+ if (widgets->size_label) {
+ tmp = modest_text_utils_get_display_size (stats.local_size);
+ label = create_gchar_label (widgets->color_markup, _("mcen_fi_rootfolder_size"), tmp);
+ gtk_label_set_markup (GTK_LABEL (widgets->size_label), label);
+ g_free (label);
+ g_free (tmp);
+ }
+}
+
+static void
+update_folder_stats_cb (ModestFolderStats stats,
+ gpointer user_data)
+{
+ DetailsWidgets *widgets = (DetailsWidgets *) user_data;
+
+ /* refresh data */
+ update_folder_stats_status_cb (stats, user_data);
+
+ /* frees. Note that the widgets could have been destroyed but
+ we still keep a reference */
+ g_free (widgets->color_markup);
+ if (widgets->count_label)
+ g_object_unref (widgets->count_label);
+ if (widgets->msg_count_label)
+ g_object_unref (widgets->msg_count_label);
+ if (widgets->size_label)
+ g_object_unref (widgets->size_label);
+ g_slice_free (DetailsWidgets, widgets);
+}
+
static GtkWidget *
create_details_widget (GtkWidget *styled_widget, TnyAccount *account)
{
GtkWidget *label_w;
gchar *label;
gchar *gray_color_markup;
+ DetailsWidgets *widgets;
vbox = gtk_vbox_new (FALSE, 0);
+ widgets = g_slice_new0 (DetailsWidgets);
+
+ gray_color_markup = get_gray_color_markup (styled_widget);
+ widgets->color_markup = g_strdup (gray_color_markup);
- /* Obtain the secondary text color. We need a realized widget, that's why
- we get styled_widget from outside */
-#ifndef MODEST_HAVE_HILDON0_WIDGETS
- GdkColor color;
- gtk_style_lookup_color (styled_widget->style, "SecondaryTextColor", &color);
- gray_color_markup = modest_text_utils_get_color_string (&color);
-#else
- // gray_color_markup is freed below
- gray_color_markup = g_strdup ("#BBBBBB");
-#endif
/* Account description: */
-
if (modest_tny_account_is_virtual_local_folders (account)
|| (modest_tny_account_is_memory_card_account (account))) {
- gchar *tmp;
- /* Local folders: */
/* Get device name */
gchar *device_name = NULL;
MODEST_CONF_DEVICE_NAME, NULL);
else
device_name = g_strdup (tny_account_get_name (account));
-
- tmp = g_strdup_printf (_("mcen_fi_localroot_description"), ""); //TODO: Why the ""?
- label = g_markup_printf_escaped ("<span color='%s'>%s</span>%s",
- gray_color_markup, tmp, device_name);
- g_free (tmp);
+
+ label = create_device_name_visual_string ((const gchar *) device_name,
+ (const gchar *) gray_color_markup);
label_w = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label_w), label);
+ gtk_label_set_ellipsize (GTK_LABEL (label_w), PANGO_ELLIPSIZE_END);
gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
g_free (device_name);
g_free (label);
label_w = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label_w), label);
+ gtk_label_set_ellipsize (GTK_LABEL (label_w), PANGO_ELLIPSIZE_END);
gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
g_string_free (proto, TRUE);
g_free (label);
/* Message count */
TnyFolderStore *folder_store = TNY_FOLDER_STORE (account);
- label = g_markup_printf_escaped ("<span color='%s'>%s:</span> %d",
- gray_color_markup, _("mcen_fi_rootfolder_messages"),
- modest_tny_folder_store_get_message_count (folder_store));
+ label = create_uint_label (gray_color_markup, _("mcen_fi_rootfolder_messages"), 0);
label_w = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label_w), label);
+ gtk_label_set_ellipsize (GTK_LABEL (label_w), PANGO_ELLIPSIZE_END);
gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
g_free (label);
+ widgets->msg_count_label = g_object_ref (label_w);
+
/* Folder count */
- label = g_markup_printf_escaped ("<span color='%s'>%s</span>: %d",
- gray_color_markup,
- _("mcen_fi_rootfolder_folders"),
- modest_tny_folder_store_get_folder_count (folder_store));
+ label = create_uint_label (gray_color_markup, _("mcen_fi_rootfolder_folders"), 0);
label_w = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label_w), label);
+ gtk_label_set_ellipsize (GTK_LABEL (label_w), PANGO_ELLIPSIZE_END);
gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
g_free (label);
+ widgets->count_label = g_object_ref (label_w);
+
/* Size / Date */
if (modest_tny_account_is_virtual_local_folders (account)
|| modest_tny_account_is_memory_card_account (account)) {
- gchar *size = modest_text_utils_get_display_size (
- modest_tny_folder_store_get_local_size (folder_store));
-
- label = g_markup_printf_escaped ("<span color='%s'>%s:</span> %s",
- gray_color_markup, _("mcen_fi_rootfolder_size"),
- size);
- g_free (size);
+ label = create_gchar_label (gray_color_markup, _("mcen_fi_rootfolder_size"), "0");
label_w = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label_w), label);
+ gtk_label_set_ellipsize (GTK_LABEL (label_w), PANGO_ELLIPSIZE_END);
gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
g_free (label);
+
+ widgets->size_label = g_object_ref (label_w);
+
} else if (TNY_IS_ACCOUNT(folder_store)) {
TnyAccount *account = TNY_ACCOUNT(folder_store);
time_t last_updated;
- gchar *last_updated_string;
+ const gchar *last_updated_string;
/* Get last updated from configuration */
- last_updated = modest_account_mgr_get_int (modest_runtime_get_account_mgr (),
- tny_account_get_id (account),
- MODEST_ACCOUNT_LAST_UPDATED,
- TRUE);
+ last_updated = modest_account_mgr_get_last_updated (modest_runtime_get_account_mgr (),
+ tny_account_get_id (account));
+
if (last_updated > 0)
last_updated_string = modest_text_utils_get_display_date(last_updated);
else
gray_color_markup, _("mcen_ti_lastupdated"), last_updated_string);
label_w = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label_w), label);
+ gtk_label_set_ellipsize (GTK_LABEL (label_w), PANGO_ELLIPSIZE_END);
gtk_box_pack_start (GTK_BOX (vbox), label_w, FALSE, FALSE, 0);
- g_free (last_updated_string);
g_free (label);
}
g_free (gray_color_markup);
+ /* Refresh folder stats asynchronously */
+ modest_tny_folder_store_get_folder_stats (TNY_FOLDER_STORE (account),
+ update_folder_stats_cb,
+ update_folder_stats_status_cb,
+ widgets);
+
/* Set alignment */
gtk_container_foreach (GTK_CONTAINER (vbox), (GtkCallback) set_alignment, NULL);
static void
-_on_msg_count_changed (ModestHeaderView *header_view,
- TnyFolder *folder,
- TnyFolderChange *change,
- ModestMainWindow *main_window)
+on_msg_count_changed (ModestHeaderView *header_view,
+ TnyFolder *folder,
+ TnyFolderChange *change,
+ ModestMainWindow *main_window)
{
- printf ("DEBUG: %s\n", __FUNCTION__);
+ gboolean refilter = FALSE;
gboolean folder_empty = FALSE;
gboolean all_marked_as_deleted = FALSE;
- TnyFolderChangeChanged changed;
ModestMainWindowPrivate *priv;
-
+
g_return_if_fail (MODEST_IS_MAIN_WINDOW (main_window));
g_return_if_fail (TNY_IS_FOLDER(folder));
- g_return_if_fail (TNY_IS_FOLDER_CHANGE(change));
priv = MODEST_MAIN_WINDOW_GET_PRIVATE (main_window);
-
- changed = tny_folder_change_get_changed (change);
-
- /* If something changes */
- if ((changed) & TNY_FOLDER_CHANGE_CHANGED_ALL_COUNT)
- folder_empty = (tny_folder_change_get_new_all_count (change) == 0);
- else
- folder_empty = (tny_folder_get_all_count (TNY_FOLDER (folder)) == 0);
-
- printf ("DEBUG: %s: folder_empty=%d\n", __FUNCTION__, folder_empty);
-/* Check header removed (hide marked as DELETED headers) */
- if (changed & TNY_FOLDER_CHANGE_CHANGED_EXPUNGED_HEADERS) {
- modest_header_view_refilter (MODEST_HEADER_VIEW(priv->header_view));
+ if (change != NULL) {
+ TnyFolderChangeChanged changed;
+
+ changed = tny_folder_change_get_changed (change);
+ /* If something changes */
+ if ((changed) & TNY_FOLDER_CHANGE_CHANGED_ALL_COUNT)
+ folder_empty = (((guint) tny_folder_change_get_new_all_count (change)) == 0);
+ else
+ folder_empty = (((guint) tny_folder_get_all_count (TNY_FOLDER (folder))) == 0);
+
+ /* Play a sound (if configured) and make the LED blink */
+ if (changed & TNY_FOLDER_CHANGE_CHANGED_ADDED_HEADERS) {
+ modest_platform_push_email_notification ();
+ }
+
+ if ((changed) & TNY_FOLDER_CHANGE_CHANGED_EXPUNGED_HEADERS)
+ refilter = TRUE;
+ } else {
+ folder_empty = (((guint) tny_folder_get_all_count (TNY_FOLDER (folder))) == 0);
}
/* Check if all messages are marked to be deleted */
all_marked_as_deleted = modest_header_view_is_empty (header_view);
- folder_empty = folder_empty || all_marked_as_deleted ;
-
+ folder_empty = folder_empty || all_marked_as_deleted;
+
/* Set contents style of headers view */
if (folder_empty) {
modest_main_window_set_contents_style (main_window,
MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY);
gtk_widget_grab_focus (GTK_WIDGET (priv->folder_view));
- }
- else {
+ } else {
modest_main_window_set_contents_style (main_window,
MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS);
- }
+ }
+
+ if (refilter)
+ modest_header_view_refilter (header_view);
}
details widget */
GtkWidget *content = gtk_bin_get_child (GTK_BIN (priv->contents_widget));
if (content) {
- if (priv->contents_style == MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS)
- g_object_ref (content);
- else if (priv->contents_style == MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY) {
- g_object_ref (priv->empty_view);
+ if (priv->contents_style == MODEST_MAIN_WINDOW_CONTENTS_STYLE_EMPTY) {
gtk_container_remove (GTK_CONTAINER (content), priv->empty_view);
}
ModestMainWindowPrivate *priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
TnyAccount *account = NULL;
- if (!key ||
- priv->notification_id != id ||
- strcmp (key, MODEST_CONF_DEVICE_NAME))
+ if (!key || strcmp (key, MODEST_CONF_DEVICE_NAME))
return;
if (priv->contents_style != MODEST_MAIN_WINDOW_CONTENTS_STYLE_DETAILS)
return;
+
if (priv->folder_view)
account = (TnyAccount *) modest_folder_view_get_selected (priv->folder_view);
+
if (account && TNY_IS_ACCOUNT (account) &&
strcmp (tny_account_get_id (account), MODEST_LOCAL_FOLDERS_ACCOUNT_ID) == 0) {
GList *children;
GtkLabel *label;
const gchar *device_name;
- gchar *new_text;
+ gchar *new_text, *gray_color_markup;
/* Get label */
children = gtk_container_get_children (GTK_CONTAINER (priv->details_widget));
device_name = modest_conf_get_string (modest_runtime_get_conf(),
MODEST_CONF_DEVICE_NAME, NULL);
+
+ gray_color_markup = get_gray_color_markup (GTK_WIDGET (self));
+ new_text = create_device_name_visual_string (device_name, gray_color_markup);
- new_text = g_strdup_printf ("%s: %s",
- _("mcen_fi_localroot_description"),
- device_name);
-
- gtk_label_set_text (label, new_text);
+ gtk_label_set_markup (label, new_text);
gtk_widget_show (GTK_WIDGET (label));
+ g_free (gray_color_markup);
g_free (new_text);
g_list_free (children);
}
/* Checks the dimming rules */
modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (self));
+ modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (self));
/* Show and hide toolbar items */
switch (mode) {
gtk_action_set_visible (refresh_action, FALSE);
if (cancel_action)
gtk_action_set_visible (cancel_action, TRUE);
+ if (priv->progress_bar)
+ gtk_widget_show (priv->progress_bar);
if (priv->progress_toolitem) {
gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
gtk_widget_show (priv->progress_toolitem);
}
- if (priv->progress_bar)
- gtk_widget_show (priv->progress_bar);
/* Show toolbar if it's hiden (optimized view ) */
if (priv->optimized_view)
return is_empty;
}
-static void
-on_queue_changed (ModestMailOperationQueue *queue,
- ModestMailOperation *mail_op,
- ModestMailOperationQueueNotification type,
- ModestMainWindow *self)
+
+/**
+ * Gets the toolbar mode needed for each mail operation. It stores in
+ * @mode_changed if the toolbar mode has changed or not
+ */
+static ModestToolBarModes
+get_toolbar_mode_from_mail_operation (ModestMainWindow *self,
+ ModestMailOperation *mail_op,
+ gboolean *mode_changed)
{
- ModestMainWindowPrivate *priv;
- ModestMailOperationTypeOperation op_type;
ModestToolBarModes mode;
- GSList *tmp;
- gboolean mode_changed = FALSE;
+ ModestMainWindowPrivate *priv;
+
+ *mode_changed = FALSE;
+ priv = MODEST_MAIN_WINDOW_GET_PRIVATE (self);
- g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
- priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
-
/* Get toolbar mode from operation id*/
- op_type = modest_mail_operation_get_type_operation (mail_op);
- switch (op_type) {
+ switch (modest_mail_operation_get_type_operation (mail_op)) {
+ case MODEST_MAIL_OPERATION_TYPE_SEND_AND_RECEIVE:
case MODEST_MAIL_OPERATION_TYPE_RECEIVE:
case MODEST_MAIL_OPERATION_TYPE_OPEN:
mode = TOOLBAR_MODE_TRANSFER;
if (priv->current_toolbar_mode == TOOLBAR_MODE_NORMAL)
- mode_changed = TRUE;
+ *mode_changed = TRUE;
break;
default:
- mode = TOOLBAR_MODE_NORMAL;
-
+ mode = TOOLBAR_MODE_NORMAL;
}
-
-
+ return mode;
+}
+
+static void
+on_mail_operation_started (ModestMailOperation *mail_op,
+ gpointer user_data)
+{
+ ModestMainWindow *self;
+ ModestMailOperationTypeOperation op_type;
+ ModestMainWindowPrivate *priv;
+ ModestToolBarModes mode;
+ GSList *tmp;
+ gboolean mode_changed = FALSE;
+ TnyAccount *account = NULL;
+
+ self = MODEST_MAIN_WINDOW (user_data);
+ priv = MODEST_MAIN_WINDOW_GET_PRIVATE (self);
+
+ /* Do not show progress for receiving operations if the
+ account is the local account or the MMC one */
+ op_type = modest_mail_operation_get_type_operation (mail_op);
+ account = modest_mail_operation_get_account (mail_op);
+ if (account && op_type == MODEST_MAIL_OPERATION_TYPE_RECEIVE) {
+ gboolean is_remote;
+
+ is_remote = !(modest_tny_account_is_virtual_local_folders (account) ||
+ modest_tny_account_is_memory_card_account (account));
+ if (!is_remote) {
+ g_object_unref (account);
+ return;
+ }
+
+ /* Show information banner. Remove old timeout */
+ if (priv->retrieving_banner_timeout > 0) {
+ g_source_remove (priv->retrieving_banner_timeout);
+ priv->retrieving_banner_timeout = 0;
+ }
+ /* Create a new timeout */
+ priv->retrieving_banner_timeout =
+ g_timeout_add (2000, show_retrieving_banner, self);
+ }
+
+ /* Not every mail operation has account, noop does not */
+ if (account)
+ g_object_unref (account);
+
+ /* Get toolbar mode from operation id*/
+ mode = get_toolbar_mode_from_mail_operation (self, mail_op, &mode_changed);
+
/* Add operation observers and change toolbar if neccessary*/
tmp = priv->progress_widgets;
- switch (type) {
- case MODEST_MAIL_OPERATION_QUEUE_OPERATION_ADDED:
- if (mode == TOOLBAR_MODE_TRANSFER) {
- if (mode_changed) {
- set_toolbar_transfer_mode(self);
- }
- while (tmp) {
- modest_progress_object_add_operation (MODEST_PROGRESS_OBJECT (tmp->data),
- mail_op);
- tmp = g_slist_next (tmp);
+ if (mode == TOOLBAR_MODE_TRANSFER) {
+ if (mode_changed) {
+ GObject *source = modest_mail_operation_get_source(mail_op);
+ if (G_OBJECT (self) == source) {
+ set_toolbar_transfer_mode(self);
}
+ g_object_unref (source);
}
- break;
- case MODEST_MAIL_OPERATION_QUEUE_OPERATION_REMOVED:
- /* Change toolbar mode */
- if (mode == TOOLBAR_MODE_TRANSFER) {
- while (tmp) {
- modest_progress_object_remove_operation (MODEST_PROGRESS_OBJECT (tmp->data),
- mail_op);
- tmp = g_slist_next (tmp);
- }
-
- /* If no more operations are being observed, NORMAL mode is enabled again */
- if (observers_empty (self)) {
- set_toolbar_mode (self, TOOLBAR_MODE_NORMAL);
- }
+
+ while (tmp) {
+ modest_progress_object_add_operation (MODEST_PROGRESS_OBJECT (tmp->data),
+ mail_op);
+ tmp = g_slist_next (tmp);
}
+ }
- break;
- }
+ /* Update the main menu as well, we need to explicitely do
+ this in order to enable/disable accelerators */
+ modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (self));
+}
+
+static void
+on_mail_operation_finished (ModestMailOperation *mail_op,
+ gpointer user_data)
+{
+ ModestToolBarModes mode;
+ ModestMailOperationTypeOperation op_type;
+ GSList *tmp = NULL;
+ ModestMainWindow *self;
+ gboolean mode_changed;
+ TnyAccount *account = NULL;
+ ModestMainWindowPrivate *priv;
+
+ self = MODEST_MAIN_WINDOW (user_data);
+ priv = MODEST_MAIN_WINDOW_GET_PRIVATE (self);
+
+ /* The mail operation was not added to the progress objects if
+ the account was the local account or the MMC one */
+ op_type = modest_mail_operation_get_type_operation (mail_op);
+ account = modest_mail_operation_get_account (mail_op);
+ if (account && op_type == MODEST_MAIL_OPERATION_TYPE_RECEIVE) {
+ gboolean is_remote;
+
+ is_remote = !(modest_tny_account_is_virtual_local_folders (account) ||
+ modest_tny_account_is_memory_card_account (account));
+ if (!is_remote) {
+ g_object_unref (account);
+ return;
+ }
+ /* Remove old timeout */
+ if (priv->retrieving_banner_timeout > 0) {
+ g_source_remove (priv->retrieving_banner_timeout);
+ priv->retrieving_banner_timeout = 0;
+ }
+
+ /* Remove the banner if exists */
+ if (priv->retrieving_banner) {
+ gtk_widget_destroy (priv->retrieving_banner);
+ priv->retrieving_banner = NULL;
+ }
+ }
+
+ /* Not every mail operation has account, noop does not */
+ if (account)
+ g_object_unref (account);
+
+ /* Get toolbar mode from operation id*/
+ mode = get_toolbar_mode_from_mail_operation (self, mail_op, &mode_changed);
+
+ /* Change toolbar mode */
+ tmp = priv->progress_widgets;
+ if (mode == TOOLBAR_MODE_TRANSFER) {
+ while (tmp) {
+ modest_progress_object_remove_operation (MODEST_PROGRESS_OBJECT (tmp->data),
+ mail_op);
+ tmp = g_slist_next (tmp);
+ }
+
+ /* If no more operations are being observed, NORMAL mode is enabled again */
+ if (observers_empty (self)) {
+ set_toolbar_mode (self, TOOLBAR_MODE_NORMAL);
+ }
+ }
+}
+
+static void
+on_queue_changed (ModestMailOperationQueue *queue,
+ ModestMailOperation *mail_op,
+ ModestMailOperationQueueNotification type,
+ ModestMainWindow *self)
+{
+ ModestMainWindowPrivate *priv;
+
+ priv = MODEST_MAIN_WINDOW_GET_PRIVATE (self);
+
+ 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");
+ }
}
static void
set_account_visible(ModestMainWindow *self, const gchar *acc_name)
{
ModestMainWindowPrivate *priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
+ GtkAction *action;
+ ModestAccountMgr *mgr;
+ ModestAccountSettings *settings;
+ ModestServerAccountSettings *store_settings = NULL;
/* Get account data */
- ModestAccountMgr *mgr = modest_runtime_get_account_mgr ();
- ModestAccountData *acc_data = modest_account_mgr_get_account_data (mgr, acc_name);
+ mgr = modest_runtime_get_account_mgr ();
+ settings = modest_account_mgr_load_account_settings (mgr, acc_name);
+ if (settings)
+ store_settings = modest_account_settings_get_store_settings (settings);
/* Set the new visible & active account */
- if (acc_data && acc_data->store_account) {
- modest_folder_view_set_account_id_of_visible_server_account (priv->folder_view,
- acc_data->store_account->account_name);
- modest_window_set_active_account (MODEST_WINDOW (self), acc_data->account_name);
+ if (settings && (modest_server_account_settings_get_account_name (store_settings)!= NULL)) {
+ const gchar *account_name;
+
+ account_name = modest_account_settings_get_account_name (settings);
+
+ modest_folder_view_set_account_id_of_visible_server_account
+ (priv->folder_view,
+ modest_server_account_settings_get_account_name (store_settings));
+ modest_folder_view_select_first_inbox_or_local (priv->folder_view);
+ modest_window_set_active_account (MODEST_WINDOW (self), account_name);
+
+ action = gtk_action_group_get_action (priv->view_additions_group, account_name);
+ if (action != NULL) {
+ if (!gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))) {
+ modest_utils_toggle_action_set_active_block_notify (
+ GTK_TOGGLE_ACTION (action),
+ TRUE);
+ }
+ }
}
- modest_folder_view_select_first_inbox_or_local (priv->folder_view);
-
/* Free */
- if (acc_data)
- modest_account_mgr_free_account_data (mgr, acc_data);
+ if (settings) {
+ g_object_unref (store_settings);
+ g_object_unref (settings);
+ }
}
/* Make sure that at least one account is "viewed": */
}
const gchar *active_server_account_name =
- modest_folder_view_get_account_id_of_visible_server_account (priv->folder_view);
+ modest_folder_view_get_account_id_of_visible_server_account (priv->folder_view);
+
if (!active_server_account_name ||
!modest_account_mgr_account_exists (account_mgr, active_server_account_name, TRUE))
{
gchar* first_modest_name = modest_account_mgr_get_first_account_name (account_mgr);
- if (first_modest_name) {
+ gchar* default_modest_name = modest_account_mgr_get_default_account (account_mgr);
+ if (default_modest_name) {
+ set_account_visible (self, default_modest_name);
+ } else if (first_modest_name) {
set_account_visible (self, first_modest_name);
- g_free (first_modest_name);
}
+ g_free (first_modest_name);
+ g_free (default_modest_name);
}
}
static void
-on_show_account_action_activated (GtkAction *action,
+on_show_account_action_toggled (GtkToggleAction *action,
gpointer user_data)
{
ModestMainWindow *self = MODEST_MAIN_WINDOW (user_data);
- const gchar *acc_name = gtk_action_get_name (action);
- set_account_visible (self, acc_name);
+ const gchar *acc_name = gtk_action_get_name (GTK_ACTION (action));
+ if (gtk_toggle_action_get_active (action))
+ set_account_visible (self, acc_name);
}
static void
refresh_account (const gchar *account_name)
{
ModestWindow *win;
-
- win = MODEST_WINDOW (modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ()));
-
+
+ /* win must already exists here, obviously */
+ win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
+ FALSE);
+ if (!win) {
+ g_warning ("%s: BUG: no main window!", __FUNCTION__);
+ return;
+ }
+
/* If account_name == NULL, we must update all (option All) */
if (!account_name)
- modest_ui_actions_do_send_receive_all (win);
+ modest_ui_actions_do_send_receive_all (win, TRUE, TRUE, TRUE);
else
- modest_ui_actions_do_send_receive (account_name, win);
+ modest_ui_actions_do_send_receive (account_name, TRUE, TRUE, TRUE, win);
}
}
static gboolean
-on_folder_view_focus_in (GtkWidget *widget,
- GdkEventFocus *event,
- gpointer userdata)
+on_folder_view_focus_in (GtkWidget *widget, GdkEventFocus *event, gpointer userdata)
{
ModestMainWindow *main_window = NULL;
/* Update toolbar dimming state */
modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
+ modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (main_window));
return FALSE;
}
gpointer userdata)
{
ModestMainWindow *main_window = NULL;
- ModestMainWindowPrivate *priv = NULL;
g_return_val_if_fail (MODEST_IS_MAIN_WINDOW (userdata), FALSE);
+
main_window = MODEST_MAIN_WINDOW (userdata);
- priv = MODEST_MAIN_WINDOW_GET_PRIVATE (main_window);
/* Update toolbar dimming state */
modest_ui_actions_check_toolbar_dimming_rules (MODEST_WINDOW (main_window));
+ modest_ui_actions_check_menu_dimming_rules (MODEST_WINDOW (main_window));
return FALSE;
}
static void
-modest_main_window_on_folder_selection_changed (ModestFolderView *folder_view,
- TnyFolderStore *folder_store,
- gboolean selected,
- ModestMainWindow *main_window)
+on_folder_selection_changed (ModestFolderView *folder_view,
+ TnyFolderStore *folder_store,
+ gboolean selected,
+ ModestMainWindow *main_window)
{
ModestWindowPrivate *parent_priv = MODEST_WINDOW_GET_PRIVATE (main_window);
GtkAction *action = NULL;
show_clipboard = show_delete = show_cancel_send = TRUE;
show_reply = show_forward = FALSE;
break;
+ case TNY_FOLDER_TYPE_INVALID:
+ g_warning ("%s: BUG: TNY_FOLDER_TYPE_INVALID", __FUNCTION__);
+ break;
default:
show_reply = show_forward = show_clipboard = show_delete = TRUE;
show_cancel_send = FALSE;
gtk_action_set_visible (action, show_forward);
action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMCancelSending");
gtk_action_set_visible (action, show_cancel_send);
- action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMCut");
- gtk_action_set_visible (action, show_clipboard);
- action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMCopy");
- gtk_action_set_visible (action, show_clipboard);
- action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMPaste");
- gtk_action_set_visible (action, show_clipboard);
action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/HeaderViewCSM/HeaderViewCSMDelete");
gtk_action_set_visible (action, show_delete);
/* We finally call to the ui actions handler, after updating properly
* the header view CSM */
modest_ui_actions_on_folder_selection_changed (folder_view, folder_store, selected, main_window);
-
}
gboolean
return TRUE;
}
+static gboolean
+show_updating_banner (gpointer user_data)
+{
+ ModestMainWindowPrivate *priv = NULL;
+
+ priv = MODEST_MAIN_WINDOW_GET_PRIVATE (user_data);
+
+ if (priv->updating_banner == NULL) {
+
+ /* We're outside the main lock */
+ gdk_threads_enter ();
+ priv->updating_banner =
+ modest_platform_animation_banner (GTK_WIDGET (user_data), NULL,
+ _CS ("ckdg_pb_updating"));
+ gdk_threads_leave ();
+ }
+
+ /* Remove timeout */
+ priv->updating_banner_timeout = 0;
+ return FALSE;
+}
+
+/**
+ * We use this function to show/hide a progress banner showing
+ * "Updating" while the header view is being filled. We're not showing
+ * it unless the update takes more than 2 seconds
+ *
+ * If starting = TRUE then the refresh is starting, otherwise it means
+ * that is has just finished
+ */
+static void
+on_updating_msg_list (ModestHeaderView *header_view,
+ gboolean starting,
+ gpointer user_data)
+{
+ ModestMainWindowPrivate *priv = NULL;
+
+ priv = MODEST_MAIN_WINDOW_GET_PRIVATE (user_data);
+
+ /* Remove old timeout */
+ if (priv->updating_banner_timeout > 0) {
+ g_source_remove (priv->updating_banner_timeout);
+ priv->updating_banner_timeout = 0;
+ }
+
+ /* Create a new timeout */
+ if (starting) {
+ priv->updating_banner_timeout =
+ g_timeout_add (2000, show_updating_banner, user_data);
+ } else {
+ /* Remove the banner if exists */
+ if (priv->updating_banner) {
+ gtk_widget_destroy (priv->updating_banner);
+ priv->updating_banner = NULL;
+ }
+ }
+}
+
+gboolean
+modest_main_window_screen_is_on (ModestMainWindow *self)
+{
+ ModestMainWindowPrivate *priv = NULL;
+
+ g_return_val_if_fail (MODEST_IS_MAIN_WINDOW(self), FALSE);
+
+ priv = MODEST_MAIN_WINDOW_GET_PRIVATE (self);
+
+ return (priv->display_state == OSSO_DISPLAY_ON) ? TRUE : FALSE;
+}
+
+static void
+remove_banners (ModestMainWindow *window)
+{
+ ModestMainWindowPrivate *priv;
+
+ priv = MODEST_MAIN_WINDOW_GET_PRIVATE (window);
+
+ if (priv->retrieving_banner_timeout > 0) {
+ g_source_remove (priv->retrieving_banner_timeout);
+ priv->retrieving_banner_timeout = 0;
+ }
+
+ if (priv->retrieving_banner != NULL) {
+ gtk_widget_destroy (priv->retrieving_banner);
+ priv->retrieving_banner = NULL;
+ }
+
+ if (priv->updating_banner_timeout > 0) {
+ g_source_remove (priv->updating_banner_timeout);
+ priv->updating_banner_timeout = 0;
+ }
+
+ if (priv->updating_banner != NULL) {
+ gtk_widget_destroy (priv->updating_banner);
+ priv->updating_banner = NULL;
+ }
+}
+
+
+static void
+on_window_hide (GObject *gobject,
+ GParamSpec *arg1,
+ gpointer user_data)
+{
+ g_return_if_fail (MODEST_IS_MAIN_WINDOW (gobject));
+
+ if (!GTK_WIDGET_VISIBLE (gobject)) {
+ TnyFolderStore *folder_store;
+ ModestMainWindowPrivate *priv;
+
+ /* Remove the currently shown banners */
+ remove_banners (MODEST_MAIN_WINDOW (gobject));
+
+ /* Force the folder view to sync the currently selected folder
+ to save the read/unread status and to expunge messages */
+ priv = MODEST_MAIN_WINDOW_GET_PRIVATE (gobject);
+ folder_store = modest_folder_view_get_selected (priv->folder_view);
+ if (TNY_IS_FOLDER (folder_store)) {
+ ModestMailOperation *mail_op;
+
+ mail_op = modest_mail_operation_new (NULL);
+ modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
+ mail_op);
+ modest_mail_operation_sync_folder (mail_op, TNY_FOLDER (folder_store), FALSE);
+ g_object_unref (mail_op);
+ g_object_unref (folder_store);
+ }
+ }
+}
+
+static void
+on_window_destroy (GtkObject *widget,
+ gpointer user_data)
+{
+ g_return_if_fail (MODEST_IS_MAIN_WINDOW (widget));
+
+ remove_banners (MODEST_MAIN_WINDOW (widget));
+}
+
+static gboolean
+show_retrieving_banner (gpointer user_data)
+{
+ ModestMainWindowPrivate *priv = NULL;
+
+ priv = MODEST_MAIN_WINDOW_GET_PRIVATE (user_data);
+
+ if (priv->retrieving_banner == NULL) {
+
+ /* We're outside the main lock */
+ gdk_threads_enter ();
+ priv->retrieving_banner =
+ modest_platform_animation_banner (GTK_WIDGET (user_data), NULL,
+ _("mcen_ib_getting_items"));
+ gdk_threads_leave ();
+ }
+
+ /* Remove timeout */
+ priv->retrieving_banner_timeout = 0;
+ return FALSE;
+}
projects / modest / blobdiff