static void _clear_hidding_filter (ModestHeaderView *header_view);
-static void modest_header_view_notify_observers(
- ModestHeaderView *header_view,
- GtkTreeModel *model,
- const gchar *tny_folder_id);
+static void modest_header_view_notify_observers(ModestHeaderView *header_view,
+ GtkTreeModel *model,
+ const gchar *tny_folder_id);
-static gboolean modest_header_view_on_expose_event(
- GtkTreeView *header_view,
- GdkEventExpose *event,
- gpointer user_data);
+static gboolean modest_header_view_on_expose_event (GtkTreeView *header_view,
+ GdkEventExpose *event,
+ gpointer user_data);
typedef enum {
HEADER_VIEW_NON_EMPTY,
/* Filter tree model */
gchar **hidding_ids;
guint n_selected;
+ GtkTreeRowReference *autoselect_reference;
gint sort_colid[2][TNY_FOLDER_TYPE_NUM];
gint sort_type[2][TNY_FOLDER_TYPE_NUM];
GtkTreeModel *tree_filter, *sortable;
GtkTreeViewColumn *column=NULL;
GtkTreeSelection *selection = NULL;
- GtkCellRenderer *renderer_msgtype,*renderer_header,
+ GtkCellRenderer *renderer_header,
*renderer_attach, *renderer_compact_date_or_status;
GtkCellRenderer *renderer_compact_header, *renderer_recpt_box,
*renderer_subject, *renderer_subject_box, *renderer_recpt,
priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
- /* FIXME: check whether these renderers need to be freed */
- renderer_msgtype = gtk_cell_renderer_pixbuf_new ();
+ /* TODO: check whether these renderers need to be freed */
renderer_attach = gtk_cell_renderer_pixbuf_new ();
renderer_priority = gtk_cell_renderer_pixbuf_new ();
renderer_header = gtk_cell_renderer_text_new ();
g_object_set_data (G_OBJECT (renderer_recpt_box), "date-renderer", renderer_compact_date_or_status);
g_object_set (G_OBJECT (renderer_subject_box), "yalign", 1.0, NULL);
+#ifndef MODEST_TOOLKIT_GTK
gtk_cell_renderer_set_fixed_size (renderer_subject_box, -1, 32);
gtk_cell_renderer_set_fixed_size (renderer_recpt_box, -1, 32);
+#endif
g_object_set (G_OBJECT (renderer_recpt_box), "yalign", 0.0, NULL);
g_object_set(G_OBJECT(renderer_header),
"ellipsize", PANGO_ELLIPSIZE_END,
g_object_set (G_OBJECT (renderer_attach),
"yalign", 0.0, NULL);
+#ifndef MODEST_TOOLKIT_GTK
gtk_cell_renderer_set_fixed_size (renderer_attach, 32, 26);
gtk_cell_renderer_set_fixed_size (renderer_priority, 32, 26);
gtk_cell_renderer_set_fixed_size (renderer_compact_header, -1, 64);
+#else
+ gtk_cell_renderer_set_fixed_size (renderer_attach, 16, 16);
+ gtk_cell_renderer_set_fixed_size (renderer_priority, 16, 16);
+ /* gtk_cell_renderer_set_fixed_size (renderer_compact_header, -1, 64); */
+#endif
remove_all_columns (self);
switch (col) {
- case MODEST_HEADER_VIEW_COLUMN_MSGTYPE:
- column = get_new_column (_("M"), renderer_msgtype, FALSE,
- TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
- FALSE,
- (GtkTreeCellDataFunc)_modest_header_view_msgtype_cell_data,
- NULL);
- gtk_tree_view_column_set_fixed_width (column, 45);
- break;
-
case MODEST_HEADER_VIEW_COLUMN_ATTACH:
column = get_new_column (_("A"), renderer_attach, FALSE,
TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN,
compact_column, NULL);
}
-
return TRUE;
}
priv->monitor = NULL;
priv->observers_lock = g_mutex_new ();
+ priv->autoselect_reference = NULL;
priv->status = HEADER_VIEW_INIT;
priv->status_timeout = 0;
/* Clear hidding array created by cut operation */
_clear_hidding_filter (MODEST_HEADER_VIEW (obj));
+ if (priv->autoselect_reference != NULL) {
+ gtk_tree_row_reference_free (priv->autoselect_reference);
+ priv->autoselect_reference = NULL;
+ }
+
G_OBJECT_CLASS(parent_class)->finalize (obj);
}
static void
scroll_to_selected (ModestHeaderView *self, GtkTreeIter *iter, gboolean up)
{
-#ifdef MODEST_PLATFORM_GNOME
+#ifdef MODEST_TOOLKIT_GTK
GtkTreePath *selected_path;
GtkTreePath *start, *end;
gtk_tree_path_free (start);
gtk_tree_path_free (end);
-#endif /* MODEST_PLATFORM_GNOME */
+#endif /* MODEST_TOOLKIT_GTK */
}
GtkTreeSelection *sel;
GtkTreeModel *model;
GtkTreeIter tree_iter;
+ ModestHeaderViewPrivate *priv;
+ priv = MODEST_HEADER_VIEW_GET_PRIVATE(header_view);
model = gtk_tree_view_get_model(header_view);
if (!model)
return FALSE;
sel = gtk_tree_view_get_selection(header_view);
- if(!gtk_tree_selection_count_selected_rows(sel))
+ if(!gtk_tree_selection_count_selected_rows(sel)) {
if (gtk_tree_model_get_iter_first(model, &tree_iter)) {
+ GtkTreePath *tree_iter_path;
/* Prevent the widget from getting the focus
when selecting the first item */
+ tree_iter_path = gtk_tree_model_get_path (model, &tree_iter);
g_object_set(header_view, "can-focus", FALSE, NULL);
gtk_tree_selection_select_iter(sel, &tree_iter);
+ gtk_tree_view_set_cursor (header_view, tree_iter_path, NULL, FALSE);
g_object_set(header_view, "can-focus", TRUE, NULL);
+ if (priv->autoselect_reference) {
+ gtk_tree_row_reference_free (priv->autoselect_reference);
+ }
+ priv->autoselect_reference = gtk_tree_row_reference_new (model, tree_iter_path);
+ gtk_tree_path_free (tree_iter_path);
+ }
+ } else {
+ if (priv->autoselect_reference != NULL) {
+ gboolean moved_selection = FALSE;
+ GtkTreePath * last_path;
+ if (gtk_tree_selection_count_selected_rows (sel) != 1) {
+ moved_selection = TRUE;
+ } else {
+ GList *rows;
+
+ rows = gtk_tree_selection_get_selected_rows (sel, NULL);
+ last_path = gtk_tree_row_reference_get_path (priv->autoselect_reference);
+ if (gtk_tree_path_compare (last_path, (GtkTreePath *) rows->data) != 0)
+ moved_selection = TRUE;
+ g_list_foreach (rows, (GFunc) gtk_tree_path_free, NULL);
+ g_list_free (rows);
+ gtk_tree_path_free (last_path);
+ }
+ if (moved_selection) {
+ gtk_tree_row_reference_free (priv->autoselect_reference);
+ priv->autoselect_reference = NULL;
+ } else {
+
+ if (gtk_tree_model_get_iter_first (model, &tree_iter)) {
+ GtkTreePath *current_path;
+ current_path = gtk_tree_model_get_path (model, &tree_iter);
+ last_path = gtk_tree_row_reference_get_path (priv->autoselect_reference);
+ if (gtk_tree_path_compare (current_path, last_path) != 0) {
+ g_object_set(header_view, "can-focus", FALSE, NULL);
+ gtk_tree_selection_unselect_all (sel);
+ gtk_tree_selection_select_iter(sel, &tree_iter);
+ gtk_tree_view_set_cursor (header_view, current_path, NULL, FALSE);
+ g_object_set(header_view, "can-focus", TRUE, NULL);
+ gtk_tree_row_reference_free (priv->autoselect_reference);
+ priv->autoselect_reference = gtk_tree_row_reference_new (model, current_path);
+ }
+ gtk_tree_path_free (current_path);
+ gtk_tree_path_free (last_path);
+ }
+ }
}
+ }
return FALSE;
}
-/*
- * This function sets a sortable model in the header view. It's just
- * used for developing purposes, because it only does a
- * gtk_tree_view_set_model
- */
-static void
-modest_header_view_set_model (GtkTreeView *header_view, GtkTreeModel *model)
-{
-/* GtkTreeModel *old_model_sort = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view)); */
-/* if (old_model_sort && GTK_IS_TREE_MODEL_SORT (old_model_sort)) { */
-/* GtkTreeModel *old_model; */
-/* ModestHeaderViewPrivate *priv; */
-/* priv = MODEST_HEADER_VIEW_GET_PRIVATE (header_view); */
-/* old_model = gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (old_model_sort)); */
-
-/* /\* Set new model *\/ */
-/* gtk_tree_view_set_model (header_view, model); */
-/* } else */
- gtk_tree_view_set_model (header_view, model);
-}
-
TnyFolder*
modest_header_view_get_folder (ModestHeaderView *self)
{
}
static void
-modest_header_view_set_folder_intern (ModestHeaderView *self, TnyFolder *folder)
+set_folder_intern_get_headers_async_cb (TnyFolder *folder,
+ gboolean cancelled,
+ TnyList *headers,
+ GError *err,
+ gpointer user_data)
{
- TnyFolderType type;
- TnyList *headers;
+ ModestHeaderView *self;
ModestHeaderViewPrivate *priv;
- GList *cols, *cursor;
- GtkTreeModel *filter_model, *sortable;
- guint sort_colid;
- GtkSortType sort_type;
- priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
+ g_return_if_fail (MODEST_IS_HEADER_VIEW (user_data));
- headers = TNY_LIST (tny_gtk_header_list_model_new ());
+ self = MODEST_HEADER_VIEW (user_data);
+ priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
- tny_gtk_header_list_model_set_folder (TNY_GTK_HEADER_LIST_MODEL(headers),
- folder, FALSE, NULL, NULL, NULL);
+ if (cancelled || err)
+ return;
/* Add IDLE observer (monitor) and another folder observer for
new messages (self) */
tny_folder_monitor_add_list (priv->monitor, TNY_LIST (headers));
tny_folder_monitor_start (priv->monitor);
g_mutex_unlock (priv->observers_lock);
+}
+
+static void
+modest_header_view_set_folder_intern (ModestHeaderView *self, TnyFolder *folder)
+{
+ TnyFolderType type;
+ TnyList *headers;
+ ModestHeaderViewPrivate *priv;
+ GList *cols, *cursor;
+ GtkTreeModel *filter_model, *sortable;
+ guint sort_colid;
+ GtkSortType sort_type;
+
+ priv = MODEST_HEADER_VIEW_GET_PRIVATE(self);
+
+ headers = TNY_LIST (tny_gtk_header_list_model_new ());
+
+ /* Start the monitor in the callback of the
+ tny_gtk_header_list_model_set_folder call. It's crucial to
+ do it there and not just after the call because we want the
+ monitor to observe only the headers returned by the
+ tny_folder_get_headers_async call that it's inside the
+ tny_gtk_header_list_model_set_folder call. This way the
+ monitor infrastructure could successfully cope with
+ duplicates. For example if a tny_folder_add_msg_async is
+ happening while tny_gtk_header_list_model_set_folder is
+ invoked, then the first call could add a header that will
+ be added again by tny_gtk_header_list_model_set_folder, so
+ we'd end up with duplicate headers. sergio */
+ tny_gtk_header_list_model_set_folder (TNY_GTK_HEADER_LIST_MODEL(headers),
+ folder, FALSE,
+ set_folder_intern_get_headers_async_cb,
+ NULL, self);
sortable = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL(headers));
g_object_unref (G_OBJECT (headers));
}
/* Set new model */
- modest_header_view_set_model (GTK_TREE_VIEW (self), filter_model);
+ gtk_tree_view_set_model (GTK_TREE_VIEW (self), filter_model);
modest_header_view_notify_observers(self, GTK_TREE_MODEL(filter_model),
tny_folder_get_id(folder));
g_object_unref (G_OBJECT (filter_model));
-/* modest_header_view_set_model (GTK_TREE_VIEW (self), sortable); */
-/* g_object_unref (G_OBJECT (sortable)); */
/* Free */
g_list_free (cols);
void
modest_header_view_set_folder (ModestHeaderView *self,
TnyFolder *folder,
+ gboolean refresh,
RefreshAsyncUserCallback callback,
gpointer user_data)
{
ModestHeaderViewPrivate *priv;
- SetFolderHelper *info;
ModestWindow *main_win;
g_return_if_fail (self);
}
if (priv->folder) {
- if (priv->status_timeout)
+ if (priv->status_timeout) {
g_source_remove (priv->status_timeout);
+ priv->status_timeout = 0;
+ }
g_mutex_lock (priv->observers_lock);
tny_folder_remove_observer (priv->folder, TNY_FOLDER_OBSERVER (self));
}
if (folder) {
- ModestMailOperation *mail_op = NULL;
GtkTreeSelection *selection;
+ SetFolderHelper *info;
+ ModestMailOperation *mail_op = NULL;
/* Set folder in the model */
modest_header_view_set_folder_intern (self, folder);
0, TRUE, NULL);
/* create the helper */
- info = g_malloc0 (sizeof(SetFolderHelper));
+ info = g_malloc0 (sizeof (SetFolderHelper));
info->header_view = g_object_ref (self);
info->cb = callback;
info->user_data = user_data;
mail_op = modest_mail_operation_new_with_error_handling (G_OBJECT(main_win),
refresh_folder_error_handler,
NULL, NULL);
- modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
- mail_op);
-
- /* Refresh the folder asynchronously */
- modest_mail_operation_refresh_folder (mail_op,
- folder,
- folder_refreshed_cb,
- info);
-
+ if (refresh) {
+ modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
+ mail_op);
+
+ /* Refresh the folder asynchronously */
+ modest_mail_operation_refresh_folder (mail_op,
+ folder,
+ folder_refreshed_cb,
+ info);
+ } else {
+ folder_refreshed_cb (mail_op, folder, info);
+ }
/* Free */
g_object_unref (mail_op);
} else {
g_object_unref (G_OBJECT (priv->monitor));
priv->monitor = NULL;
}
- modest_header_view_set_model (GTK_TREE_VIEW (self), NULL);
+
+ if (priv->autoselect_reference) {
+ gtk_tree_row_reference_free (priv->autoselect_reference);
+ priv->autoselect_reference = NULL;
+ }
+
+ gtk_tree_view_set_model (GTK_TREE_VIEW (self), NULL);
modest_header_view_notify_observers(self, NULL, NULL);
if (selected == NULL) return FALSE;
selected_path = (GtkTreePath *) selected->data;
- /* Check if we need to scroll */
- #if GTK_CHECK_VERSION(2, 8, 0) /* TODO: gtk_tree_view_get_visible_range() is only available in GTK+ 2.8 */
- GtkTreePath *start_path = NULL;
- GtkTreePath *end_path = NULL;
- if (gtk_tree_view_get_visible_range (GTK_TREE_VIEW (self),
- &start_path,
- &end_path)) {
-
- if ((gtk_tree_path_compare (start_path, selected_path) != -1) ||
- (gtk_tree_path_compare (end_path, selected_path) != 1)) {
-
- /* Scroll to first path */
- gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (self),
- selected_path,
- NULL,
- TRUE,
- 0.5,
- 0.0);
- }
- }
- if (start_path)
- gtk_tree_path_free (start_path);
- if (end_path)
- gtk_tree_path_free (end_path);
-
- #endif /* GTK_CHECK_VERSION */
-
/* Frees */
g_list_foreach (selected, (GFunc) gtk_tree_path_free, NULL);
g_list_free (selected);
{
GtkTreeSelection *selection = NULL;
GtkTreePath *path = NULL;
- gboolean already_selected = FALSE;
+ gboolean already_selected = FALSE, already_opened = FALSE;
+ ModestTnySendQueueStatus status = MODEST_TNY_SEND_QUEUE_UNKNOWN;
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(self), event->x, event->y, &path, NULL, NULL, NULL)) {
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(self));
already_selected = gtk_tree_selection_path_is_selected (selection, path);
+
+ /* Get header from model */
+ model = gtk_tree_view_get_model (GTK_TREE_VIEW (self));
+ if (gtk_tree_model_get_iter (model, &iter, path)) {
+ GValue value = {0,};
+ TnyHeader *header;
+
+ gtk_tree_model_get_value (model, &iter,
+ TNY_GTK_HEADER_LIST_MODEL_INSTANCE_COLUMN,
+ &value);
+ header = (TnyHeader *) g_value_get_object (&value);
+ if (TNY_IS_HEADER (header)) {
+ status = modest_tny_all_send_queues_get_msg_status (header);
+ already_opened = modest_window_mgr_find_registered_header (modest_runtime_get_window_mgr (),
+ header, NULL);
+ }
+ g_value_unset (&value);
+ }
}
- /* Enable drag and drop onlly if the user clicks on a row that
+ /* Enable drag and drop only if the user clicks on a row that
it's already selected. If not, let him select items using
- the pointer */
- if (!already_selected) {
+ the pointer. If the message is in an OUTBOX and in sending
+ status disable drag and drop as well */
+ if (!already_selected ||
+ status == MODEST_TNY_SEND_QUEUE_SENDING ||
+ already_opened)
disable_drag_and_drop(self);
- }
- if (path != NULL) {
+ if (path != NULL)
gtk_tree_path_free(path);
- }
+ /* If it's already opened then do not let the button-press
+ event go on because it'll perform a message open because
+ we're clicking on to an already selected header */
return FALSE;
}
{
g_return_if_fail (self && MODEST_IS_HEADER_VIEW(self));
- modest_header_view_set_folder (self, NULL, NULL, NULL);
+ modest_header_view_set_folder (self, NULL, FALSE, NULL, NULL);
}
void
notify_filter_change_destroy (gpointer data)
{
NotifyFilterInfo *info = (NotifyFilterInfo *) data;
+ ModestHeaderViewPrivate *priv;
+
+ priv = MODEST_HEADER_VIEW_GET_PRIVATE (info->self);
+ priv->status_timeout = 0;
g_object_unref (info->self);
g_object_unref (info->folder);
/* Check hiding */
if (priv->hidding_ids != NULL) {
- id = g_strdup(tny_header_get_message_id (header));
+ id = tny_header_dup_message_id (header);
for (i=0; i < priv->n_selected && !found; i++)
if (priv->hidding_ids[i] != NULL && id != NULL)
found = (!strcmp (priv->hidding_ids[i], id));
my_account = tny_folder_get_account (priv->folder);
if (my_account == account)
modest_header_view_clear (MODEST_HEADER_VIEW (user_data));
- g_object_unref (account);
+ g_object_unref (my_account);
}
}
projects / modest / blobdiff