GtkAdjustment.
* Fix bug on GB potfile in "Sending %d/%d1" message.
* New operation mail_operation_process_msg, to get one or several
messages, applying them an user define function, using a
helper data structure to do this.
* Change tny_get_msg_async calls in modest-ui_actions
by a new mail_operation method called mail_operation_process_msg.
* Add a new method to ModestPropressObject to cancel current
mail operation in progress.
* Connect ModestMainWindow as observer of MailOperatinQueue, to
add and remove mail operations from their observer.
* Connect ModestMsgViewWindow as observer of MailOperatinQueue, to
add and remove mail operations from their observer.
* Manage toolbar of MsgViewWindow, dimming toolbar options
in transfer mode.
pmo-trunk-r1739
"Project-Id-Version: modest-0.0.1\n"
"Report-Msgid-Bugs-To: rami.abbad@nokia.com\n"
"POT-Creation-Date: 2007.04.19 21:28+0200\n"
-"PO-Revision-Date: 2007.04.19 21:28+0200\n"
+"PO-Revision-Date: 2007-04-28 00:31+0200\n"
"Last-Translator:\n"
"Language-Team: Engineering English\n"
"MIME-Version: 1.0\n"
# %d is number of messages / headers downloaded so far for this account and %d1 is number of messages / headers to be downloaded this session
msgid "mcen_me_receiving"
-msgstr "Receiving %d/%d1"
+msgstr "Receiving %d/%d"
# %d is number of messages sent so far for this account and %d1 is number of messages to be sent this session
msgid "mcen_me_sending"
-msgstr "Sending %d/%d1"
+msgstr "Sending %d/%d"
# Indetermined sending
msgid "mail_me_sending"
static void modest_main_window_show_toolbar (ModestWindow *window,
gboolean show_toolbar);
+static void cancel_progressbar (GtkToolButton *toolbutton,
+ ModestMainWindow *self);
+
static void on_queue_changed (ModestMailOperationQueue *queue,
ModestMailOperation *mail_op,
ModestMailOperationQueueNotification type,
GtkWidget *cancel_toolitem;
GtkWidget *sort_toolitem;
GtkWidget *refresh_toolitem;
+ ModestToolBarModes current_toolbar_mode;
/* On-demand widgets */
GtkWidget *accounts_popup;
priv->progress_widgets = NULL;
priv->progress_bar = NULL;
+ priv->current_toolbar_mode = TOOLBAR_MODE_NORMAL;
priv->style = MODEST_MAIN_WINDOW_STYLE_SPLIT;
priv->contents_style = MODEST_MAIN_WINDOW_CONTENTS_STYLE_HEADERS;
return priv->style;
}
+
+
static gboolean
modest_main_window_window_state_event (GtkWidget *widget, GdkEventWindowState *event, gpointer userdata)
{
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_expand (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
+ gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
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_container_add (GTK_CONTAINER (priv->progress_toolitem), priv->progress_bar);
gtk_toolbar_insert(GTK_TOOLBAR(parent_priv->toolbar), GTK_TOOL_ITEM (priv->progress_toolitem), insert_index);
+ /* Connect cancel 'clicked' signal to abort progress mode */
+ g_signal_connect(priv->cancel_toolitem, "clicked",
+ G_CALLBACK(cancel_progressbar),
+ self);
+
/* Add it to the observers list */
priv->progress_widgets = g_slist_prepend(priv->progress_widgets, priv->progress_bar);
set_toolbar_mode (ModestMainWindow *self,
ModestToolBarModes mode)
{
+ ModestWindowPrivate *parent_priv;
ModestMainWindowPrivate *priv;
+ GtkAction *sort_action, *refresh_action, *cancel_action;
g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
+ parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
-
+
+ sort_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarSort");
+ refresh_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarSendReceive");
+ cancel_action = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarCancel");
+
+ /* Sets current toolbar mode */
+ priv->current_toolbar_mode = mode;
+
+ /* Show and hide toolbar items */
switch (mode) {
case TOOLBAR_MODE_NORMAL:
- if (priv->sort_toolitem)
- gtk_widget_show (priv->sort_toolitem);
-
- if (priv->refresh_toolitem)
- gtk_widget_show (priv->refresh_toolitem);
-
- if (priv->progress_toolitem)
+ if (sort_action)
+ gtk_action_set_visible (sort_action, TRUE);
+ if (refresh_action)
+ gtk_action_set_visible (refresh_action, TRUE);
+ if (priv->progress_toolitem) {
gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
+ gtk_widget_hide (priv->progress_toolitem);
+ }
if (priv->progress_bar)
- gtk_widget_hide (priv->progress_bar);
-
- if (priv->cancel_toolitem)
- gtk_widget_hide (priv->cancel_toolitem);
+ gtk_widget_hide (priv->progress_bar);
+
+ if (cancel_action)
+ gtk_action_set_visible (cancel_action, FALSE);
break;
case TOOLBAR_MODE_TRANSFER:
- if (priv->sort_toolitem)
- gtk_widget_hide (priv->sort_toolitem);
-
- if (priv->refresh_toolitem)
- gtk_widget_hide (priv->refresh_toolitem);
-
- if (priv->progress_toolitem)
+ if (sort_action)
+ gtk_action_set_visible (sort_action, FALSE);
+ if (refresh_action)
+ gtk_action_set_visible (refresh_action, FALSE);
+ if (cancel_action)
+ gtk_action_set_visible (cancel_action, TRUE);
+ 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);
-
- if (priv->cancel_toolitem)
- gtk_widget_show (priv->cancel_toolitem);
+ gtk_widget_show (priv->progress_bar);
break;
default:
- if (priv->cancel_toolitem)
- gtk_widget_show (priv->sort_toolitem);
-
- if (priv->refresh_toolitem)
- gtk_widget_show (priv->refresh_toolitem);
-
- if (priv->progress_bar)
- gtk_widget_hide (priv->progress_bar);
-
- if (priv->cancel_toolitem)
- gtk_widget_hide (priv->cancel_toolitem);
+ g_return_if_reached ();
+ }
+
+ gtk_widget_show_all (GTK_WIDGET (self));
+}
+
+static void
+cancel_progressbar (GtkToolButton *toolbutton,
+ ModestMainWindow *self)
+{
+ GSList *tmp;
+ ModestMainWindowPrivate *priv;
+
+ priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
+
+ /* Get operation observers and cancel its current operation */
+ tmp = priv->progress_widgets;
+ while (tmp) {
+ modest_progress_object_cancel_current_operation (MODEST_PROGRESS_OBJECT(tmp->data));
+ tmp=g_slist_next(tmp);
}
}
ModestMailOperationQueueNotification type,
ModestMainWindow *self)
{
- GSList *tmp;
ModestMainWindowPrivate *priv;
ModestMailOperationId op_id;
ModestToolBarModes mode;
-
- priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
+ GSList *tmp;
+ gboolean mode_changed = FALSE;
+ g_return_if_fail (MODEST_IS_MAIN_WINDOW (self));
+ priv = MODEST_MAIN_WINDOW_GET_PRIVATE(self);
+
/* Get toolbar mode from operation id*/
op_id = modest_mail_operation_get_id (mail_op);
switch (op_id) {
case MODEST_MAIL_OPERATION_ID_SEND:
case MODEST_MAIL_OPERATION_ID_RECEIVE:
mode = TOOLBAR_MODE_TRANSFER;
+ if (priv->current_toolbar_mode == TOOLBAR_MODE_NORMAL)
+ mode_changed = TRUE;
break;
default:
mode = TOOLBAR_MODE_NORMAL;
}
+
/* 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_NORMAL)
+ if (mode_changed)
set_toolbar_mode (MODEST_MAIN_WINDOW(self), mode);
- while (tmp) {
- modest_progress_object_add_operation (MODEST_PROGRESS_OBJECT (tmp->data),
- mail_op);
- tmp = g_slist_next (tmp);
+ if (mode == TOOLBAR_MODE_TRANSFER) {
+ while (tmp) {
+ modest_progress_object_add_operation (MODEST_PROGRESS_OBJECT (tmp->data),
+ mail_op);
+ tmp = g_slist_next (tmp);
+ }
}
break;
case MODEST_MAIL_OPERATION_QUEUE_OPERATION_REMOVED:
- if (mode != TOOLBAR_MODE_NORMAL)
+ if (modest_mail_operation_queue_num_elements (queue) == 0)
set_toolbar_mode (MODEST_MAIN_WINDOW(self), TOOLBAR_MODE_NORMAL);
- while (tmp) {
- modest_progress_object_remove_operation (MODEST_PROGRESS_OBJECT (tmp->data),
- mail_op);
- tmp = g_slist_next (tmp);
+ if (mode == TOOLBAR_MODE_TRANSFER) {
+ while (tmp) {
+ modest_progress_object_remove_operation (MODEST_PROGRESS_OBJECT (tmp->data),
+ mail_op);
+ tmp = g_slist_next (tmp);
+ }
}
break;
- }
+ }
}
#include <modest-window-priv.h>
#include <modest-tny-folder.h>
#include <modest-text-utils.h>
+#include "modest-progress-bar-widget.h"
#include "modest-defs.h"
#include "modest-hildon-includes.h"
#include <gtkhtml/gtkhtml-search.h>
GdkEvent *event,
ModestMsgViewWindow *window);
+static void cancel_progressbar (GtkToolButton *toolbutton,
+ ModestMsgViewWindow *self);
+
+static void on_queue_changed (ModestMailOperationQueue *queue,
+ ModestMailOperation *mail_op,
+ ModestMailOperationQueueNotification type,
+ ModestMsgViewWindow *self);
+
+static void set_toolbar_mode (ModestMsgViewWindow *self,
+ ModestToolBarModes mode);
+
/* list my signals */
enum {
GtkWidget *find_toolbar;
gchar *last_search;
+ /* Progress observers */
+ GtkWidget *progress_bar;
+ GSList *progress_widgets;
+
+ /* Tollbar items */
+ GtkWidget *progress_toolitem;
+ GtkWidget *cancel_toolitem;
+ GtkWidget *prev_toolitem;
+ GtkWidget *next_toolitem;
+
GtkTreeModel *header_model;
GtkTreeIter iter;
}
+static void
+set_toolbar_mode (ModestMsgViewWindow *self,
+ ModestToolBarModes mode)
+{
+ ModestWindowPrivate *parent_priv;
+ ModestMsgViewWindowPrivate *priv;
+ GtkAction *widget = NULL;
+
+ g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self));
+
+ parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
+ priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
+
+ switch (mode) {
+ case TOOLBAR_MODE_NORMAL:
+ widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNew");
+ gtk_action_set_sensitive (widget, TRUE);
+ widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageReply");
+ gtk_action_set_sensitive (widget, TRUE);
+ widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarDeleteMessage");
+ gtk_action_set_sensitive (widget, TRUE);
+ widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageMoveTo");
+ gtk_action_set_sensitive (widget, TRUE);
+ widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/FindInMessage");
+ gtk_action_set_sensitive (widget, TRUE);
+
+ if (priv->prev_toolitem)
+ gtk_widget_show (priv->prev_toolitem);
+
+ if (priv->next_toolitem)
+ gtk_widget_show (priv->next_toolitem);
+
+ if (priv->progress_toolitem)
+ gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
+ if (priv->progress_bar)
+ gtk_widget_hide (priv->progress_bar);
+
+ if (priv->cancel_toolitem)
+ gtk_widget_hide (priv->cancel_toolitem);
+ break;
+ case TOOLBAR_MODE_TRANSFER:
+ widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNew");
+ gtk_action_set_sensitive (widget, FALSE);
+ widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageReply");
+ gtk_action_set_sensitive (widget, FALSE);
+ widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarDeleteMessage");
+ gtk_action_set_sensitive (widget, FALSE);
+ widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageMoveTo");
+ gtk_action_set_sensitive (widget, FALSE);
+ widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/FindInMessage");
+ gtk_action_set_sensitive (widget, FALSE);
+
+ if (priv->prev_toolitem)
+ gtk_widget_hide (priv->prev_toolitem);
+
+ if (priv->next_toolitem)
+ gtk_widget_hide (priv->next_toolitem);
+
+ if (priv->progress_toolitem)
+ gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), TRUE);
+ if (priv->progress_bar)
+ gtk_widget_show (priv->progress_bar);
+
+ if (priv->cancel_toolitem)
+ gtk_widget_show (priv->cancel_toolitem);
+ break;
+ default:
+ widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNew");
+ gtk_action_set_sensitive (widget, TRUE);
+ widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageReply");
+ gtk_action_set_sensitive (widget, TRUE);
+ widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarDeleteMessage");
+ gtk_action_set_sensitive (widget, TRUE);
+ widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/ToolbarMessageMoveTo");
+ gtk_action_set_sensitive (widget, TRUE);
+ widget = gtk_ui_manager_get_action (parent_priv->ui_manager, "/ToolBar/FindInMessage");
+ gtk_action_set_sensitive (widget, TRUE);
+
+ if (priv->cancel_toolitem)
+ gtk_widget_show (priv->prev_toolitem);
+
+ if (priv->next_toolitem)
+ gtk_widget_show (priv->next_toolitem);
+
+ if (priv->progress_bar)
+ gtk_widget_hide (priv->progress_bar);
+ if (priv->progress_bar)
+ gtk_widget_hide (priv->progress_bar);
+
+ if (priv->cancel_toolitem)
+ gtk_widget_hide (priv->cancel_toolitem);
+ }
+
+}
+
static GtkWidget *
menubar_to_menu (GtkUIManager *ui_manager)
G_CALLBACK (modest_msg_view_window_window_state_event),
NULL);
+ /* Mail Operation Queue */
+ g_signal_connect (G_OBJECT (modest_runtime_get_mail_operation_queue ()),
+ "queue-changed",
+ G_CALLBACK (on_queue_changed),
+ obj);
+
modest_window_set_active_account (MODEST_WINDOW(obj), account_name);
priv->last_search = NULL;
modest_msg_view_window_show_toolbar (ModestWindow *self,
gboolean show_toolbar)
{
+ ModestMsgViewWindowPrivate *priv = NULL;
ModestWindowPrivate *parent_priv;
GtkWidget *reply_button = NULL, *menu = NULL;
+ GtkWidget *placeholder = NULL;
+ gint insert_index;
parent_priv = MODEST_WINDOW_GET_PRIVATE(self);
+ priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
if (!parent_priv->toolbar && show_toolbar) {
parent_priv->toolbar = gtk_ui_manager_get_widget (parent_priv->ui_manager,
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->next_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarMessageNext");
+ priv->prev_toolitem = gtk_ui_manager_get_widget (parent_priv->ui_manager, "/ToolBar/ToolbarMessageBack");
+ gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
+ gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->progress_toolitem), FALSE);
+ gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE);
+ gtk_tool_item_set_expand (GTK_TOOL_ITEM (priv->cancel_toolitem), FALSE);
+
+ /* Add ProgressBar (Transfer toolbar) */
+ priv->progress_bar = modest_progress_bar_widget_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));
+ gtk_container_add (GTK_CONTAINER (priv->progress_toolitem), priv->progress_bar);
+ gtk_toolbar_insert(GTK_TOOLBAR(parent_priv->toolbar), GTK_TOOL_ITEM (priv->progress_toolitem), insert_index);
+
+ /* Connect cancel 'clicked' signal to abort progress mode */
+ g_signal_connect(priv->cancel_toolitem, "clicked",
+ G_CALLBACK(cancel_progressbar),
+ self);
+
+ /* Add it to the observers list */
+ priv->progress_widgets = g_slist_prepend(priv->progress_widgets, priv->progress_bar);
+
/* Add to window */
hildon_window_add_toolbar (HILDON_WINDOW (self),
GTK_TOOLBAR (parent_priv->toolbar));
/* TODO: Why is this sometimes NULL? murrayc */
if (parent_priv->toolbar) {
- if (show_toolbar)
+ if (show_toolbar) {
gtk_widget_show (GTK_WIDGET (parent_priv->toolbar));
- else
+ set_toolbar_mode (MODEST_MSG_VIEW_WINDOW(self), TOOLBAR_MODE_NORMAL);
+ } else
gtk_widget_hide (GTK_WIDGET (parent_priv->toolbar));
}
}
gtk_action_set_sensitive (action, is_address);
}
+
+static void
+cancel_progressbar (GtkToolButton *toolbutton,
+ ModestMsgViewWindow *self)
+{
+ GSList *tmp;
+ ModestMsgViewWindowPrivate *priv;
+
+ priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
+
+ /* Get operation observers and cancel its current operation */
+ tmp = priv->progress_widgets;
+ while (tmp) {
+ modest_progress_object_cancel_current_operation (MODEST_PROGRESS_OBJECT(tmp->data));
+ tmp=g_slist_next(tmp);
+ }
+}
+
+static void
+on_queue_changed (ModestMailOperationQueue *queue,
+ ModestMailOperation *mail_op,
+ ModestMailOperationQueueNotification type,
+ ModestMsgViewWindow *self)
+{
+ GSList *tmp;
+ ModestMsgViewWindowPrivate *priv;
+ ModestMailOperationId op_id;
+ ModestToolBarModes mode;
+
+ g_return_if_fail (MODEST_IS_MSG_VIEW_WINDOW (self));
+ priv = MODEST_MSG_VIEW_WINDOW_GET_PRIVATE(self);
+
+ /* Get toolbar mode from operation id*/
+ op_id = modest_mail_operation_get_id (mail_op);
+ switch (op_id) {
+ case MODEST_MAIL_OPERATION_ID_SEND:
+ case MODEST_MAIL_OPERATION_ID_RECEIVE:
+ mode = TOOLBAR_MODE_TRANSFER;
+ break;
+ default:
+ mode = TOOLBAR_MODE_NORMAL;
+
+ }
+
+ /* 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_NORMAL)
+ set_toolbar_mode (MODEST_MSG_VIEW_WINDOW(self), mode);
+ while (tmp) {
+ modest_progress_object_add_operation (MODEST_PROGRESS_OBJECT (tmp->data),
+ mail_op);
+ tmp = g_slist_next (tmp);
+ }
+ break;
+ case MODEST_MAIL_OPERATION_QUEUE_OPERATION_REMOVED:
+ if (mode != TOOLBAR_MODE_NORMAL)
+ set_toolbar_mode (MODEST_MSG_VIEW_WINDOW(self), TOOLBAR_MODE_NORMAL);
+ while (tmp) {
+ modest_progress_object_remove_operation (MODEST_PROGRESS_OBJECT (tmp->data),
+ mail_op);
+ tmp = g_slist_next (tmp);
+ }
+ break;
+ }
+}
static void modest_progress_bar_remove_operation (ModestProgressObject *self,
ModestMailOperation *mail_op);
+static void
+modest_progress_bar_cancel_current_operation (ModestProgressObject *self);
+
static void on_progress_changed (ModestMailOperation *mail_op,
ModestProgressBarWidget *self);
static gboolean progressbar_clean (GtkProgressBar *bar);
-#define XALIGN 1
+#define XALIGN 0.5
#define YALIGN 0.5
#define XSPACE 1
#define YSPACE 0
klass->add_operation_func = modest_progress_bar_add_operation;
klass->remove_operation_func = modest_progress_bar_remove_operation;
+ klass->cancel_current_operation_func = modest_progress_bar_cancel_current_operation;
}
priv = MODEST_PROGRESS_BAR_WIDGET_GET_PRIVATE(self);
+ /* Alignment */
+ align = gtk_alignment_new(XALIGN, YALIGN, XSPACE, YSPACE);
+
/* Build GtkProgressBar */
- align = gtk_alignment_new(XALIGN, YALIGN, XSPACE, YSPACE);
adj = (GtkAdjustment *) gtk_adjustment_new (0, LOWER, UPPER, 0, 0, 0);
priv->progress_bar = gtk_progress_bar_new_with_adjustment (adj);
- req.width = 50;
+ req.width = 228;
req.height = 64;
gtk_progress_set_text_alignment (GTK_PROGRESS (priv->progress_bar), 0, 0.5);
gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (priv->progress_bar), PANGO_ELLIPSIZE_END);
gtk_widget_size_request (priv->progress_bar, &req);
gtk_container_add (GTK_CONTAINER (align), priv->progress_bar);
-
- /* Add progress bar widget */
+
+ /* Add progress bar widget */
gtk_box_pack_start (GTK_BOX(self), align, TRUE, TRUE, 0);
- gtk_container_add(GTK_CONTAINER(align), priv->progress_bar);
gtk_widget_show_all (GTK_WIDGET(self));
}
}
static void
+modest_progress_bar_cancel_current_operation (ModestProgressObject *self)
+{
+ ModestProgressBarWidget *me;
+ ModestProgressBarWidgetPrivate *priv;
+
+ me = MODEST_PROGRESS_BAR_WIDGET (self);
+ priv = MODEST_PROGRESS_BAR_WIDGET_GET_PRIVATE (me);
+
+ if (priv->current == NULL) return;
+ modest_mail_operation_cancel (priv->current);
+
+}
+static void
on_progress_changed (ModestMailOperation *mail_op,
ModestProgressBarWidget *self)
{
<toolitem action="FindInMessage"/>
<toolitem action="ToolbarMessageBack"/>
<toolitem action="ToolbarMessageNext"/>
- <placeholder name="ToolbarProgressbar"/>
+ <placeholder name="ProgressbarView">
+ </placeholder>
+ <toolitem action="ToolbarCancel"/>
</toolbar>
<popup name="ToolbarReplyCSM">
g_object_unref (G_OBJECT (mail_op));
}
+guint
+modest_mail_operation_queue_num_elements (ModestMailOperationQueue *self)
+{
+ ModestMailOperationQueuePrivate *priv;
+ guint length = 0;
+
+ g_return_val_if_fail (MODEST_IS_MAIL_OPERATION_QUEUE (self), 0);
+
+ priv = MODEST_MAIL_OPERATION_QUEUE_GET_PRIVATE(self);
+
+ g_mutex_lock (priv->queue_lock);
+ length = g_queue_get_length (priv->op_queue);
+ g_mutex_unlock (priv->queue_lock);
+
+ return length;
+}
+
/* Utility function intended to be used with g_queue_foreach */
static void
void modest_mail_operation_queue_remove (ModestMailOperationQueue *op_queue,
ModestMailOperation *mail_op);
/**
+ * modest_mail_operation_queue_num_elements:
+ * @op_queue: a #ModestMailOperationQueue
+ *
+ * Gets the numeber of elements stored in #ModestMailOperationQueue.
+ **/
+guint
+modest_mail_operation_queue_num_elements (ModestMailOperationQueue *self);
+
+/**
* modest_mail_operation_queue_cancel:
* @op_queue: a #ModestMailOperationQueue
* @mail_op: the #ModestMailOperation that will be canceled
TnyList *list,
GError **err,
gpointer user_data);
+static void update_folders_status_cb (GObject *obj,
+ TnyStatus *status,
+ gpointer user_data);
+
enum _ModestMailOperationSignals
{
}
static void
+update_folders_status_cb (GObject *obj,
+ TnyStatus *status,
+ gpointer user_data)
+{
+}
+
+static void
update_folders_cb (TnyFolderStore *folder_store, TnyList *list, GError **err, gpointer user_data)
{
ModestMailOperation *self;
g_message ("tny_folder_store_get_folders_async");
tny_folder_store_get_folders_async (TNY_FOLDER_STORE (store_account),
- folders, update_folders_cb, NULL, NULL, self);
+ folders, update_folders_cb, NULL, update_folders_status_cb, self);
return TRUE;
}
gboolean
modest_mail_operation_cancel (ModestMailOperation *self)
{
- /* TODO */
+ ModestMailOperationPrivate *priv;
+
+ if (!MODEST_IS_MAIL_OPERATION (self)) {
+ g_warning ("%s: invalid parametter", G_GNUC_FUNCTION);
+ return FALSE;
+ }
+
+ priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
+
+ /* TODO: Tinymail does not support cancel operation */
+
+ /* Set new status */
+ priv->status = MODEST_MAIL_OPERATION_STATUS_CANCELED;
+
+ /* Notify the queue */
+ modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (), self);
+
return TRUE;
}
g_return_val_if_fail (TNY_IS_FOLDER_STORE (parent), NULL);
g_return_val_if_fail (name, NULL);
-
+
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
/* Check parent */
g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
g_return_if_fail (TNY_IS_FOLDER_STORE (folder));
g_return_if_fail (name);
-
+
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
/* Check folder rules */
/* ************************** MSG ACTIONS ************************* */
/* ******************************************************************* */
+void modest_mail_operation_process_msg (ModestMailOperation *self,
+ TnyHeader *header,
+ TnyGetMsgCallback user_callback,
+ gpointer user_data)
+{
+ TnyFolder *folder;
+ ModestMailOperationPrivate *priv;
+
+ g_return_if_fail (MODEST_IS_MAIL_OPERATION (self));
+ g_return_if_fail (TNY_IS_HEADER (header));
+
+ priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
+ folder = tny_header_get_folder (header);
+
+ priv->status = MODEST_MAIL_OPERATION_STATUS_IN_PROGRESS;
+
+ /* Get message from folder */
+ if (folder) {
+ /* The callback will call it per each header */
+ tny_folder_get_msg_async (folder, header, user_callback, NULL, user_data);
+ g_object_unref (G_OBJECT (folder));
+ } else {
+ /* Set status failed and set an error */
+ priv->status = MODEST_MAIL_OPERATION_STATUS_FAILED;
+ g_set_error (&(priv->error), MODEST_MAIL_OPERATION_ERROR,
+ MODEST_MAIL_OPERATION_ERROR_ITEM_NOT_FOUND,
+ _("Error trying to get a message. No folder found for header"));
+ }
+}
+
+
+
void
modest_mail_operation_remove_msg (ModestMailOperation *self,
TnyHeader *header,
}
static void
+transfer_msgs_status_cb (GObject *obj,
+ TnyStatus *status,
+ gpointer user_data)
+{
+}
+
+
+static void
transfer_msgs_cb (TnyFolder *folder, GError **err, gpointer user_data)
{
XFerMsgAsyncHelper *helper;
helper = (XFerMsgAsyncHelper *) user_data;
self = helper->mail_op;
+
priv = MODEST_MAIL_OPERATION_GET_PRIVATE (self);
if (*err) {
folder,
delete_original,
transfer_msgs_cb,
- NULL,
+ transfer_msgs_status_cb,
helper);
}
+
static void
on_refresh_folder (TnyFolder *folder,
gboolean cancelled,
MODEST_MAIL_OPERATION_ID_UNKNOWN,
} ModestMailOperationId;
+
struct _ModestMailOperation {
GObject parent;
/* insert public members, if any */
TnyHeader *header,
gboolean remove_to_trash);
+/**
+ * modest_mail_operation_process_msg:
+ * @self: a #ModestMailOperation
+ * @header: the #TnyHeader of the message to get
+ * permanently
+ *
+ * Gets a message and process it using @callback function
+ * pased as argument. This operation is assynchronous, so the
+ * #ModestMailOperation should be added to
+ * #ModestMailOperationQueue
+ **/
+void modest_mail_operation_process_msg (ModestMailOperation *self,
+ TnyHeader *header,
+ TnyGetMsgCallback user_callback,
+ gpointer user_data);
+
/* Functions to control mail operations */
/**
* modest_mail_operation_get_task_done:
return MODEST_PROGRESS_OBJECT_GET_IFACE (self)->remove_operation_func (self, mail_op);
}
+void
+modest_progress_object_cancel_current_operation (ModestProgressObject *self)
+{
+ return MODEST_PROGRESS_OBJECT_GET_IFACE (self)->cancel_current_operation_func (self);
+}
+
static void
modest_progress_object_base_init (gpointer g_class)
{
return my_type;
}
+
/* the 'vtable': declare function pointers here, eg.: */
void (*add_operation_func) (ModestProgressObject *self, ModestMailOperation *mail_op);
void (*remove_operation_func) (ModestProgressObject *self, ModestMailOperation *mail_op);
+ void (*cancel_current_operation_func) (ModestProgressObject *self);
};
GType modest_progress_object_get_type (void) G_GNUC_CONST;
void modest_progress_object_remove_operation (ModestProgressObject *self,
ModestMailOperation *mail_op);
-
+void modest_progress_object_cancel_current_operation (ModestProgressObject *self);
G_END_DECLS
#include <tny-msg-view.h>
#include <tny-device.h>
-typedef struct _GetMsgAsyncHelper {
+typedef struct _GetMsgAsyncHelper {
ModestWindow *window;
+ ModestMailOperation *mail_op;
TnyIterator *iter;
- GFunc func;
+ GFunc func;
gpointer user_data;
} GetMsgAsyncHelper;
static void reply_forward_func (gpointer data, gpointer user_data);
static void read_msg_func (gpointer data, gpointer user_data);
-static void get_msg_cb (TnyFolder *folder, TnyMsg *msg, GError **err,
+static void get_msg_cb (TnyFolder *folder, TnyMsg *msg, GError **err,
gpointer user_data);
static void reply_forward (ReplyForwardAction action, ModestWindow *win);
TnyList *header_list;
guint reply_forward_type;
TnyHeader *header;
- TnyFolder *folder;
+/* TnyFolder *folder; */
GetMsgAsyncHelper *helper;
ReplyForwardHelper *rf_helper;
reply_forward_func (msg, helper);
} else {
header = TNY_HEADER (tny_iterator_get_current (helper->iter));
- folder = tny_header_get_folder (header);
- if (folder) {
- /* The callback will call it per each header */
- tny_folder_get_msg_async (folder, header, get_msg_cb, NULL, helper);
- g_object_unref (G_OBJECT (folder));
- } else
- g_printerr ("modest: no folder for header\n");
+
+/* folder = tny_header_get_folder (header); */
+/* if (folder) { */
+/* /\* The callback will call it per each header *\/ */
+/* tny_folder_get_msg_async (folder, header, get_msg_cb, NULL, helper); */
+/* g_object_unref (G_OBJECT (folder)); */
+/* } else */
+/* g_printerr ("modest: no folder for header\n"); */
+ helper->mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE);
+ modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), helper->mail_op);
+ modest_mail_operation_process_msg (helper->mail_op, header, get_msg_cb, helper);
+
/* Clean */
g_object_unref (G_OBJECT (header));
}
/* Create the mail operation */
/* TODO: The spec wants us to first do any pending deletions, before receiving. */
- mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO);
+ mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE);
modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_op);
modest_mail_operation_update_account (mail_op, TNY_STORE_ACCOUNT(tny_account));
helper = (GetMsgAsyncHelper *) user_data;
+ /* Check errors */
if ((*err && ((*err)->code == TNY_FOLDER_ERROR_GET_MSG)) || !msg) {
modest_ui_actions_on_item_not_found (NULL,
MODEST_ITEM_TYPE_MESSAGE,
return;
}
+ /* Notify the queue (if neccesary) */
+ if (helper->mail_op != NULL)
+ modest_mail_operation_queue_remove (modest_runtime_get_mail_operation_queue (), helper->mail_op);
+
/* Call user function */
- helper->func (msg, user_data);
+ if (helper->func)
+ helper->func (msg, user_data);
/* Process next element (if exists) */
tny_iterator_next (helper->iter);
g_slice_free (GetMsgAsyncHelper, helper);
} else {
TnyHeader *header;
- header = TNY_HEADER (tny_iterator_get_current (helper->iter));
- tny_folder_get_msg_async (folder, header,
- get_msg_cb, NULL, helper);
+ header = TNY_HEADER (tny_iterator_get_current (helper->iter));
+/* tny_folder_get_msg_async (folder, header, */
+/* get_msg_cb, NULL, helper); */
+ helper->mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE);
+ modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), helper->mail_op);
+ modest_mail_operation_process_msg (helper->mail_op, header, get_msg_cb, helper);
+
g_object_unref (G_OBJECT(header));
}
}
TnyHeader *header,
ModestMainWindow *main_window)
{
- TnyFolder *folder;
+/* TnyFolder *folder; */
GetMsgAsyncHelper *helper;
TnyList *list;
helper->iter = tny_list_create_iterator (list);
helper->func = read_msg_func;
- folder = tny_header_get_folder (TNY_HEADER(header));
+/* folder = tny_header_get_folder (TNY_HEADER(header)); */
+
+/* tny_folder_get_msg_async (TNY_FOLDER(folder), */
+/* header, get_msg_cb, */
+/* NULL, helper); */
- tny_folder_get_msg_async (TNY_FOLDER(folder),
- header, get_msg_cb,
- NULL, helper);
+ helper->mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE);
+ modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), helper->mail_op);
+ modest_mail_operation_process_msg (helper->mail_op, header, get_msg_cb, helper);
/* Frees */
- g_object_unref (G_OBJECT (folder));
+/* g_object_unref (G_OBJECT (folder)); */
}
from = modest_account_mgr_get_from_string (account_mgr, account_name);
/* Create the mail operation */
- mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO);
+ mail_operation = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE);
modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (), mail_operation);
modest_mail_operation_save_to_drafts (mail_operation,
if (result == GTK_RESPONSE_REJECT) {
finished = TRUE;
} else {
- ModestMailOperation *mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO);
+ ModestMailOperation *mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE);
TnyFolder *new_folder = NULL;
modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
if (folder_name != NULL && strlen (folder_name) > 0) {
ModestMailOperation *mail_op;
- mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_INFO);
+ mail_op = modest_mail_operation_new (MODEST_MAIL_OPERATION_ID_RECEIVE);
modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
mail_op);
modest_ui_actions_on_msg_view_window_move_to (action,
MODEST_MSG_VIEW_WINDOW (win));
}
+