X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fmodest-utils.c;h=d598b050bdea8a7ff187bdd27d9c1ee053b57c94;hp=2a5981c89b9411652147cb5afe0403dea715b1cb;hb=85dbfb5b2586e248ed9cef94d0e43f8e24865caf;hpb=7929406e046ed92142ff337bd9161e6a16e1d04e diff --git a/src/modest-utils.c b/src/modest-utils.c index 2a5981c..d598b05 100644 --- a/src/modest-utils.c +++ b/src/modest-utils.c @@ -43,6 +43,11 @@ #include #include "modest-utils.h" #include "modest-platform.h" +#include +#include "widgets/modest-header-view.h" +#include "widgets/modest-main-window.h" +#include "modest-widget-memory.h" +#include "widgets/modest-sort-criterium-view.h" GQuark modest_utils_get_supported_secure_authentication_error_quark (void) @@ -59,16 +64,18 @@ modest_utils_folder_writable (const gchar *filename) return FALSE; if (g_strncasecmp (filename, "obex", 4) != 0) { - GnomeVFSFileInfo folder_info; + GnomeVFSFileInfo *folder_info; gchar *folder; folder = g_path_get_dirname (filename); - gnome_vfs_get_file_info (folder, &folder_info, + folder_info = gnome_vfs_file_info_new (); + gnome_vfs_get_file_info (folder, folder_info, GNOME_VFS_FILE_INFO_GET_ACCESS_RIGHTS); g_free (folder); - if (!((folder_info.permissions & GNOME_VFS_PERM_ACCESS_WRITABLE) || - (folder_info.permissions & GNOME_VFS_PERM_USER_WRITE))) { + if (!((folder_info->permissions & GNOME_VFS_PERM_ACCESS_WRITABLE) || + (folder_info->permissions & GNOME_VFS_PERM_USER_WRITE))) { return FALSE; } + gnome_vfs_file_info_unref (folder_info); } return TRUE; } @@ -79,6 +86,8 @@ modest_utils_file_exists (const gchar *filename) GnomeVFSURI *uri = NULL; gboolean result = FALSE; + g_return_val_if_fail (filename, FALSE); + uri = gnome_vfs_uri_new (filename); if (uri) { result = gnome_vfs_uri_exists (uri); @@ -96,7 +105,8 @@ modest_utils_create_temp_stream (const gchar *orig_name, const gchar *hash_base, guint hash_number; /* hmmm... maybe we need a modest_text_utils_validate_file_name? */ - g_return_val_if_fail (orig_name || strlen(orig_name) == 0, NULL); + g_return_val_if_fail (orig_name && strlen(orig_name) != 0, NULL); + if (strlen(orig_name) > 200) { g_warning ("%s: filename too long ('%s')", __FUNCTION__, orig_name); @@ -186,18 +196,18 @@ on_idle_secure_auth_finished (gpointer user_data) } static void -on_camel_account_get_supported_secure_authentication ( - TnyCamelAccount *self, gboolean cancelled, - TnyList *auth_types, GError *err, - gpointer user_data) +on_camel_account_get_supported_secure_authentication (TnyCamelAccount *self, gboolean cancelled, + TnyList *auth_types, GError *err, gpointer user_data) { + g_return_if_fail (TNY_IS_CAMEL_ACCOUNT(self)); + g_return_if_fail (TNY_IS_LIST(auth_types)); + ModestGetSupportedAuthInfo *info = (ModestGetSupportedAuthInfo*)user_data; g_return_if_fail (info); /* Free everything if the actual action was canceled */ - if (info->cancel) - { + if (info->cancel) { /* The operation was canceled and the ownership of the info given to us * so that we could still check the cancel flag. */ g_slice_free (ModestGetSupportedAuthInfo, info); @@ -205,8 +215,7 @@ on_camel_account_get_supported_secure_authentication ( } else { - if (err) - { + if (err) { if (info->error) { g_error_free (info->error); info->error = NULL; @@ -218,10 +227,9 @@ on_camel_account_get_supported_secure_authentication ( if (!auth_types) { g_warning ("DEBUG: %s: auth_types is NULL.\n", __FUNCTION__); } - else if (tny_list_get_length(auth_types) == 0) { + else if (tny_list_get_length(auth_types) == 0) g_warning ("DEBUG: %s: auth_types is an empty TnyList.\n", __FUNCTION__); - } else - { + else { ModestPairList* pairs = modest_protocol_info_get_auth_protocol_pair_list (); /* Get the enum value for the strings: */ @@ -261,8 +269,9 @@ on_camel_account_get_supported_secure_authentication ( static void on_secure_auth_cancel(GtkWidget* dialog, int response, gpointer user_data) { - if(response == GTK_RESPONSE_REJECT || response == GTK_RESPONSE_DELETE_EVENT) - { + g_return_if_fail (GTK_IS_WIDGET(dialog)); + + if(response == GTK_RESPONSE_REJECT || response == GTK_RESPONSE_DELETE_EVENT) { ModestGetSupportedAuthInfo *info = (ModestGetSupportedAuthInfo*)user_data; g_return_if_fail(info); /* This gives the ownership of the info to the worker thread. */ @@ -270,6 +279,26 @@ on_secure_auth_cancel(GtkWidget* dialog, int response, gpointer user_data) info->cancel = TRUE; } } +typedef struct { + GtkProgressBar *progress; + gboolean not_finished; +} KeepPulsing; + +static gboolean +keep_pulsing (gpointer user_data) +{ + KeepPulsing *info = (KeepPulsing *) user_data; + + gtk_progress_bar_pulse (info->progress); + + if (!info->not_finished) { + g_object_unref (info->progress); + g_slice_free (KeepPulsing, info); + return FALSE; + } + + return TRUE; +} GList* modest_utils_get_supported_secure_authentication_methods (ModestTransportStoreProtocol proto, @@ -336,8 +365,11 @@ modest_utils_get_supported_secure_authentication_methods (ModestTransportStorePr info->cancel = FALSE; info->error = NULL; info->progress = gtk_progress_bar_new(); - /* TODO: Need logical_ID for the title: */ - info->dialog = gtk_dialog_new_with_buttons(_("Authentication"), + + /* FIXME: the title (first arg) here is empty; there should be 'accountwizard_fi_authentication', + * but that does not exist yet; see bug #82487. so, for now, we simply leave it empty + */ + info->dialog = gtk_dialog_new_with_buttons(" ", parent_window, GTK_DIALOG_MODAL, _("mcen_bd_dialog_cancel"), GTK_RESPONSE_REJECT, @@ -347,12 +379,19 @@ modest_utils_get_supported_secure_authentication_methods (ModestTransportStorePr g_signal_connect(G_OBJECT(info->dialog), "response", G_CALLBACK(on_secure_auth_cancel), info); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(info->dialog)->vbox), - gtk_label_new("Checking for supported authentication types...")); + gtk_label_new(_("emev_ni_checking_supported_auth_methods"))); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(info->dialog)->vbox), info->progress); gtk_widget_show_all(info->dialog); - gtk_progress_bar_pulse(GTK_PROGRESS_BAR(info->progress)); + + KeepPulsing *pi = g_slice_new (KeepPulsing); + pi->progress = (GtkProgressBar *) g_object_ref (info->progress); + pi->not_finished = TRUE; + + /* Starts the pulsing of the progressbar */ + g_timeout_add (500, keep_pulsing, pi); printf ("DEBUG: %s: STARTING.\n", __FUNCTION__); + tny_camel_account_get_supported_secure_authentication ( TNY_CAMEL_ACCOUNT (tny_account), on_camel_account_get_supported_secure_authentication, @@ -361,6 +400,9 @@ modest_utils_get_supported_secure_authentication_methods (ModestTransportStorePr gtk_dialog_run (GTK_DIALOG (info->dialog)); + pi->not_finished = FALSE; + /* pi is freed in the timeout itself to avoid a GCond here */ + gtk_widget_destroy(info->dialog); GList *result = info->result; @@ -396,6 +438,9 @@ void modest_utils_show_dialog_and_forget (GtkWindow *parent_window, GtkDialog *dialog) { + g_return_if_fail (GTK_IS_WINDOW(parent_window)); + g_return_if_fail (GTK_IS_DIALOG(dialog)); + gtk_window_set_transient_for (GTK_WINDOW (dialog), parent_window); /* Destroy the dialog when it is closed: */ @@ -430,3 +475,263 @@ modest_utils_toggle_action_set_active_block_notify (GtkToggleAction *action, gbo } + +gint +modest_list_index (TnyList *list, GObject *object) +{ + TnyIterator *iter; + gint index = 0; + + g_return_val_if_fail (TNY_IS_LIST(list), -1); + g_return_val_if_fail (G_IS_OBJECT(object), -1); + + iter = tny_list_create_iterator (list); + while (!tny_iterator_is_done (iter)) { + GObject *current = tny_iterator_get_current (iter); + + g_object_unref (current); + if (current == object) + break; + + tny_iterator_next (iter); + index++; + } + + if (tny_iterator_is_done (iter)) + index = -1; + g_object_unref (iter); + return index; +} + +guint64 +modest_folder_available_space (const gchar *maildir_path) +{ + gchar *folder; + gchar *uri_string; + GnomeVFSURI *uri; + GnomeVFSFileSize size; + + folder = modest_local_folder_info_get_maildir_path (maildir_path); + uri_string = gnome_vfs_get_uri_from_local_path (folder); + uri = gnome_vfs_uri_new (uri_string); + g_free (folder); + g_free (uri_string); + + if (uri) { + if (gnome_vfs_get_volume_free_space (uri, &size) != GNOME_VFS_OK) + size = -1; + gnome_vfs_uri_unref (uri); + } else { + size = -1; + } + + return (guint64) size; +} + +static void +on_destroy_dialog (GtkDialog *dialog) +{ + gtk_widget_destroy (GTK_WIDGET(dialog)); + if (gtk_events_pending ()) + gtk_main_iteration (); +} + +static guint +checked_modest_sort_criterium_view_add_sort_key (ModestSortCriteriumView *view, const gchar* key, guint max) +{ + gint sort_key; + + g_return_val_if_fail (view && MODEST_IS_SORT_CRITERIUM_VIEW(view), 0); + g_return_val_if_fail (key, 0); + + sort_key = modest_sort_criterium_view_add_sort_key (view, key); + if (sort_key < 0 || sort_key >= max) { + g_warning ("%s: out of range (%d) for %s", __FUNCTION__, sort_key, key); + return 0; + } else + return (guint)sort_key; +} + +static void +launch_sort_headers_dialog (GtkWindow *parent_window, + GtkDialog *dialog) +{ + ModestHeaderView *header_view = NULL; + GList *cols = NULL; + GtkSortType sort_type; + gint sort_key; + gint default_key = 0; + gint result; + gboolean outgoing = FALSE; + gint current_sort_colid = -1; + GtkSortType current_sort_type; + gint attachments_sort_id; + gint priority_sort_id; + GtkTreeSortable *sortable; + + /* Get header window */ + if (MODEST_IS_MAIN_WINDOW (parent_window)) { + header_view = MODEST_HEADER_VIEW(modest_main_window_get_child_widget (MODEST_MAIN_WINDOW(parent_window), + MODEST_MAIN_WINDOW_WIDGET_TYPE_HEADER_VIEW)); + } + if (!header_view) + return; + + /* Add sorting keys */ + cols = modest_header_view_get_columns (header_view); + if (cols == NULL) + return; +#define SORT_ID_NUM 6 + int sort_model_ids[SORT_ID_NUM]; + int sort_ids[SORT_ID_NUM]; + + outgoing = (GPOINTER_TO_INT (g_object_get_data(G_OBJECT(cols->data), MODEST_HEADER_VIEW_COLUMN))== + MODEST_HEADER_VIEW_COLUMN_COMPACT_HEADER_OUT); + + sort_key = checked_modest_sort_criterium_view_add_sort_key (MODEST_SORT_CRITERIUM_VIEW (dialog), _("mcen_li_sort_sender_recipient"), + SORT_ID_NUM); + if (outgoing) { + sort_model_ids[sort_key] = TNY_GTK_HEADER_LIST_MODEL_TO_COLUMN; + sort_ids[sort_key] = MODEST_HEADER_VIEW_COLUMN_COMPACT_HEADER_OUT; + } else { + sort_model_ids[sort_key] = TNY_GTK_HEADER_LIST_MODEL_FROM_COLUMN; + sort_ids[sort_key] = MODEST_HEADER_VIEW_COLUMN_COMPACT_HEADER_IN; + } + + sort_key = checked_modest_sort_criterium_view_add_sort_key (MODEST_SORT_CRITERIUM_VIEW (dialog), _("mcen_li_sort_date"), + SORT_ID_NUM); + if (outgoing) { + sort_model_ids[sort_key] = TNY_GTK_HEADER_LIST_MODEL_DATE_SENT_TIME_T_COLUMN; + sort_ids[sort_key] = MODEST_HEADER_VIEW_COLUMN_COMPACT_SENT_DATE; + } else { + sort_model_ids[sort_key] = TNY_GTK_HEADER_LIST_MODEL_DATE_RECEIVED_TIME_T_COLUMN; + sort_ids[sort_key] = MODEST_HEADER_VIEW_COLUMN_COMPACT_RECEIVED_DATE; + } + default_key = sort_key; + + sort_key = checked_modest_sort_criterium_view_add_sort_key (MODEST_SORT_CRITERIUM_VIEW (dialog), _("mcen_li_sort_subject"), + SORT_ID_NUM); + sort_model_ids[sort_key] = TNY_GTK_HEADER_LIST_MODEL_SUBJECT_COLUMN; + if (outgoing) + sort_ids[sort_key] = MODEST_HEADER_VIEW_COLUMN_COMPACT_HEADER_OUT; + else + sort_ids[sort_key] = MODEST_HEADER_VIEW_COLUMN_COMPACT_HEADER_IN; + + sort_key = checked_modest_sort_criterium_view_add_sort_key (MODEST_SORT_CRITERIUM_VIEW (dialog), _("mcen_li_sort_attachment"), + SORT_ID_NUM); + sort_model_ids[sort_key] = TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN; + sort_ids[sort_key] = TNY_HEADER_FLAG_ATTACHMENTS; + attachments_sort_id = sort_key; + + sort_key = checked_modest_sort_criterium_view_add_sort_key (MODEST_SORT_CRITERIUM_VIEW (dialog), _("mcen_li_sort_size"), + SORT_ID_NUM); + sort_model_ids[sort_key] = TNY_GTK_HEADER_LIST_MODEL_MESSAGE_SIZE_COLUMN; + sort_ids[sort_key] = 0; + + sort_key = checked_modest_sort_criterium_view_add_sort_key (MODEST_SORT_CRITERIUM_VIEW (dialog), _("mcen_li_sort_priority"), + SORT_ID_NUM); + sort_model_ids[sort_key] = TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN; + sort_ids[sort_key] = TNY_HEADER_FLAG_PRIORITY_MASK; + priority_sort_id = sort_key; + + sortable = GTK_TREE_SORTABLE (gtk_tree_model_filter_get_model + (GTK_TREE_MODEL_FILTER (gtk_tree_view_get_model (GTK_TREE_VIEW (header_view))))); + /* Launch dialogs */ + if (!gtk_tree_sortable_get_sort_column_id (sortable, + ¤t_sort_colid, ¤t_sort_type)) { + modest_sort_criterium_view_set_sort_key (MODEST_SORT_CRITERIUM_VIEW (dialog), default_key); + modest_sort_criterium_view_set_sort_order (MODEST_SORT_CRITERIUM_VIEW (dialog), GTK_SORT_DESCENDING); + } else { + modest_sort_criterium_view_set_sort_order (MODEST_SORT_CRITERIUM_VIEW (dialog), current_sort_type); + if (current_sort_colid == TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN) { + gpointer flags_sort_type_pointer; + flags_sort_type_pointer = g_object_get_data (G_OBJECT (cols->data), MODEST_HEADER_VIEW_FLAG_SORT); + if (GPOINTER_TO_INT (flags_sort_type_pointer) == TNY_HEADER_FLAG_PRIORITY_MASK) + modest_sort_criterium_view_set_sort_key (MODEST_SORT_CRITERIUM_VIEW (dialog), priority_sort_id); + else + modest_sort_criterium_view_set_sort_key (MODEST_SORT_CRITERIUM_VIEW (dialog), attachments_sort_id); + } else { + gint current_sort_keyid = 0; + while (current_sort_keyid < 6) { + if (sort_model_ids[current_sort_keyid] == current_sort_colid) + break; + else + current_sort_keyid++; + } + modest_sort_criterium_view_set_sort_key (MODEST_SORT_CRITERIUM_VIEW (dialog), current_sort_keyid); + } + } + + result = gtk_dialog_run (GTK_DIALOG (dialog)); + if (result == GTK_RESPONSE_OK) { + sort_key = modest_sort_criterium_view_get_sort_key (MODEST_SORT_CRITERIUM_VIEW (dialog)); + if (sort_key < 0 || sort_key > SORT_ID_NUM -1) { + g_warning ("%s: out of range (%d)", __FUNCTION__, sort_key); + sort_key = 0; + } + + sort_type = modest_sort_criterium_view_get_sort_order (MODEST_SORT_CRITERIUM_VIEW (dialog)); + if (sort_model_ids[sort_key] == TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN) { + g_object_set_data (G_OBJECT(cols->data), MODEST_HEADER_VIEW_FLAG_SORT, + GINT_TO_POINTER (sort_ids[sort_key])); + /* This is a hack to make it resort rows always when flag fields are + * selected. If we do not do this, changing sort field from priority to + * attachments does not work */ + modest_header_view_sort_by_column_id (header_view, 0, sort_type); + } else { + gtk_tree_view_column_set_sort_column_id (GTK_TREE_VIEW_COLUMN (cols->data), + sort_model_ids[sort_key]); + } + + modest_header_view_sort_by_column_id (header_view, sort_model_ids[sort_key], sort_type); + gtk_tree_sortable_sort_column_changed (sortable); + } + + modest_widget_memory_save (modest_runtime_get_conf (), + G_OBJECT (header_view), MODEST_CONF_HEADER_VIEW_KEY); + + /* free */ + g_list_free(cols); +} + +void +modest_utils_run_sort_dialog (GtkWindow *parent_window, + ModestSortDialogType type) +{ + GtkWidget *dialog = NULL; + + /* Build dialog */ + dialog = modest_platform_create_sort_dialog (parent_window); + if (dialog == NULL) + return; + modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), + GTK_WINDOW (dialog)); + + /* Fill sort keys */ + switch (type) { + case MODEST_SORT_HEADERS: + launch_sort_headers_dialog (parent_window, + GTK_DIALOG(dialog)); + break; + } + + /* Free */ + on_destroy_dialog (GTK_DIALOG(dialog)); +} + + +gchar * +modest_images_cache_get_id (const gchar *account, const gchar *uri) +{ + GnomeVFSURI *vfs_uri; + gchar *result; + + vfs_uri = gnome_vfs_uri_new (uri); + if (vfs_uri == NULL) + return NULL; + + result = g_strdup_printf ("%s__%x", account, gnome_vfs_uri_hash (vfs_uri)); + gnome_vfs_uri_unref (vfs_uri); + + return result; +}