#include <tny-fs-stream.h>
#include <tny-camel-account.h>
#include <tny-status.h>
-#include <tny-camel-transport-account.h>
-#include <tny-camel-imap-store-account.h>
-#include <tny-camel-pop-store-account.h>
-
+#include <tny-camel-send-queue.h>
+#include <locale.h>
#include <modest-defs.h>
#include "modest-utils.h"
#include "modest-platform.h"
#include "modest-text-utils.h"
#include <modest-local-folder-info.h>
#include "widgets/modest-header-view.h"
-#include "widgets/modest-main-window.h"
#include "modest-widget-memory.h"
#include "widgets/modest-sort-criterium-view.h"
+#include "widgets/modest-header-window.h"
+#ifdef MODEST_TOOLKIT_GTK
+#include <modest-gtk-window-mgr.h>
+#endif
+#include <langinfo.h>
GQuark
modest_utils_get_supported_secure_authentication_error_quark (void)
return g_quark_from_static_string("modest-utils-get-supported-secure-authentication-error-quark");
}
-gboolean
+gboolean
modest_utils_folder_writable (const gchar *filename)
{
g_return_val_if_fail (filename, FALSE);
if (!filename)
return FALSE;
-
- if (g_strncasecmp (filename, "obex", 4) != 0) {
- GnomeVFSFileInfo *folder_info;
- gchar *folder;
- GnomeVFSResult result;
- folder = g_path_get_dirname (filename);
- folder_info = gnome_vfs_file_info_new ();
- result = gnome_vfs_get_file_info (folder, folder_info,
- GNOME_VFS_FILE_INFO_GET_ACCESS_RIGHTS);
- g_free (folder);
+ if (g_ascii_strncasecmp (filename, "obex", 4) != 0) {
+ GnomeVFSFileInfo *folder_info = NULL;
+ GnomeVFSResult result = GNOME_VFS_OK;
+ GnomeVFSURI *uri = NULL;
+ GnomeVFSURI *folder_uri = NULL;
+
+ uri = gnome_vfs_uri_new (filename);
+ folder_uri = gnome_vfs_uri_get_parent (uri);
+
+ if (folder_uri != NULL) {
+ folder_info = gnome_vfs_file_info_new ();
+ result = gnome_vfs_get_file_info_uri (folder_uri, folder_info,
+ GNOME_VFS_FILE_INFO_GET_ACCESS_RIGHTS);
+ gnome_vfs_uri_unref (folder_uri);
+ }
+ gnome_vfs_uri_unref (uri);
+
+ if (folder_uri == NULL)
+ return FALSE;
if ((result != GNOME_VFS_OK) ||
(!((folder_info->permissions & GNOME_VFS_PERM_ACCESS_WRITABLE) ||
return TRUE;
}
-gboolean
+gboolean
modest_utils_file_exists (const gchar *filename)
{
- GnomeVFSURI *uri = NULL;
gboolean result = FALSE;
+ gchar *path;
g_return_val_if_fail (filename, FALSE);
-
- uri = gnome_vfs_uri_new (filename);
- if (uri) {
- result = gnome_vfs_uri_exists (uri);
- gnome_vfs_uri_unref (uri);
- }
+
+ path = strstr (filename, "file://");
+ if (!path)
+ path = (gchar *) filename;
+ else
+ path = (gchar *) filename + strlen ("file://");
+
+ if (g_access (path, F_OK) == 0)
+ result = TRUE;
+
return result;
}
__FUNCTION__, orig_name);
return NULL;
}
-
- if (g_strstr_len (orig_name, strlen(orig_name), "/") != NULL) {
+
+ if (g_strstr_len (orig_name, strlen (orig_name), "/") != NULL) {
g_warning ("%s: filename contains '/' character(s) (%s)",
__FUNCTION__, orig_name);
return NULL;
}
-
+
/* make a random subdir under /tmp or /var/tmp */
if (hash_base != NULL) {
hash_number = g_str_hash (hash_base);
return NULL;
}
- filepath = g_strconcat (tmpdir, "/", orig_name, NULL);
+ filepath = g_build_filename (tmpdir, orig_name, NULL);
+
+ /* if file exists, first we try to remove it */
+ if (g_access (filepath, F_OK) == 0)
+ g_unlink (filepath);
+
/* don't overwrite if it already exists, even if it is writable */
- if (modest_utils_file_exists (filepath)) {
+ if (g_access (filepath, F_OK) == 0) {
if (path!=NULL) {
*path = filepath;
} else {
fd = g_open (filepath, O_CREAT|O_WRONLY|O_TRUNC, 0644);
if (fd == -1) {
g_warning ("%s: failed to create '%s': %s",
- __FUNCTION__, filepath, g_strerror(errno));
+ __FUNCTION__, filepath, g_strerror(errno));
g_free (filepath);
g_free (tmpdir);
return NULL;
if (path)
*path = filepath;
+ else
+ g_free (filepath);
return TNY_FS_STREAM (tny_fs_stream_new (fd));
}
typedef struct
{
- gboolean cancel;
- GList *result;
+ GList **result;
GtkWidget* dialog;
GtkWidget* progress;
- GError* error;
} ModestGetSupportedAuthInfo;
-static void on_camel_account_get_supported_secure_authentication_status (
- GObject *self, TnyStatus *status, gpointer user_data)
-{
- /*ModestGetSupportedAuthInfo* info = (ModestGetSupportedAuthInfo*) user_data;*/
-}
-
static gboolean
on_idle_secure_auth_finished (gpointer user_data)
{
- ModestGetSupportedAuthInfo *info = (ModestGetSupportedAuthInfo*)user_data;
/* Operation has finished, close the dialog. Control continues after
* gtk_dialog_run in modest_utils_get_supported_secure_authentication_methods() */
-
- /* This is a GDK lock because we are an idle callback and
- * the code below is or does Gtk+ code */
-
gdk_threads_enter(); /* CHECKED */
- gtk_dialog_response (GTK_DIALOG (info->dialog), GTK_RESPONSE_ACCEPT);
+ gtk_dialog_response (GTK_DIALOG (user_data), GTK_RESPONSE_ACCEPT);
gdk_threads_leave(); /* CHECKED */
return FALSE;
}
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)
{
ModestPairList *pairs;
GList *result;
g_return_if_fail (user_data);
g_return_if_fail (TNY_IS_CAMEL_ACCOUNT(self));
g_return_if_fail (TNY_IS_LIST(auth_types));
-
+
info = (ModestGetSupportedAuthInfo *) user_data;
/* Free everything if the actual action was canceled */
- if (info->cancel) {
- info->cancel = TRUE;
+ if (cancelled) {
g_debug ("%s: operation canceled\n", __FUNCTION__);
goto close_dialog;
}
if (err) {
- if (info->error) {
- g_error_free (info->error);
- info->error = NULL;
- }
- info->error = g_error_copy (err);
+ g_debug ("%s: error getting the supported auth methods\n", __FUNCTION__);
goto close_dialog;
}
protocol_registry = modest_runtime_get_protocol_registry ();
pairs = modest_protocol_registry_get_pair_list_by_tag (protocol_registry, MODEST_PROTOCOL_REGISTRY_AUTH_PROTOCOLS);
-
+
/* Get the enum value for the strings: */
result = NULL;
iter = tny_list_create_iterator(auth_types);
TnyPair *pair;
const gchar *auth_name;
ModestProtocolType protocol_type;
-
+
pair = TNY_PAIR(tny_iterator_get_current(iter));
auth_name = NULL;
if (pair) {
g_object_unref (pair);
pair = NULL;
}
-
+
g_debug ("%s: auth_name=%s\n", __FUNCTION__, auth_name);
-
+
protocol_type = modest_protocol_get_type_id (modest_protocol_registry_get_protocol_by_name (protocol_registry,
MODEST_PROTOCOL_REGISTRY_AUTH_PROTOCOLS,
auth_name));
-
+
if (modest_protocol_registry_protocol_type_is_secure (protocol_registry, protocol_type))
result = g_list_prepend(result, GINT_TO_POINTER(protocol_type));
-
+
tny_iterator_next(iter);
}
g_object_unref (iter);
modest_pair_list_free (pairs);
- info->result = result;
+ *(info->result) = result;
close_dialog:
/* Close the dialog in a main thread */
- g_idle_add(on_idle_secure_auth_finished, info);
-}
+ g_idle_add(on_idle_secure_auth_finished, info->dialog);
-static void
-on_secure_auth_cancel(GtkWidget* dialog, int response, gpointer user_data)
-{
- 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. */
- info->result = NULL;
- info->cancel = TRUE;
- }
+ /* Free the info */
+ g_slice_free (ModestGetSupportedAuthInfo, info);
}
+
typedef struct {
- GtkProgressBar *progress;
+ GtkWidget *progress;
gboolean not_finished;
} KeepPulsing;
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;
}
-
+
+ gtk_progress_bar_pulse (GTK_PROGRESS_BAR (info->progress));
return TRUE;
}
GList*
-modest_utils_get_supported_secure_authentication_methods (ModestProtocolType protocol_type,
- const gchar* hostname, gint port, const gchar* username, GtkWindow *parent_window, GError** error)
+modest_utils_get_supported_secure_authentication_methods (ModestProtocolType protocol_type,
+ const gchar* hostname,
+ gint port,
+ const gchar* username,
+ GtkWindow *parent_window,
+ GError** error)
{
TnyAccount * tny_account = NULL;
ModestProtocolRegistry *protocol_registry;
- ModestProtocol *protocol;
+ GtkWidget *dialog;
+ gint retval;
+ ModestTnyAccountStore *account_store;
+ TnySessionCamel *session = NULL;
+ ModestProtocol *protocol = NULL;
+ GList *result = NULL;
+ GtkWidget *progress;
g_return_val_if_fail (protocol_type != MODEST_PROTOCOL_REGISTRY_TYPE_INVALID, NULL);
protocol_registry = modest_runtime_get_protocol_registry ();
-
+
/* We need a connection to get the capabilities; */
if (!modest_platform_connect_and_wait (GTK_WINDOW (parent_window), NULL))
return NULL;
-
- /*
- result = g_list_append (result, GINT_TO_POINTER (MODEST_PROTOCOL_AUTH_CRAMMD5));
- */
-
+
/* Create a TnyCamelAccount so we can use
* tny_camel_account_get_supported_secure_authentication(): */
protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, protocol_type);
if (MODEST_IS_ACCOUNT_PROTOCOL (protocol)) {
tny_account = modest_account_protocol_create_account (MODEST_ACCOUNT_PROTOCOL (protocol));
}
-
+
if (!tny_account) {
g_printerr ("%s could not create tny account.", __FUNCTION__);
return NULL;
}
-
- /* Set proto, so that the prepare_func() vfunc will work when we call
- * set_session(): */
- /* TODO: Why isn't this done in account_new()? */
- tny_account_set_proto (tny_account,
- modest_protocol_get_name (modest_protocol_registry_get_protocol_by_type (protocol_registry, protocol_type)));
+ /* Set proto, so that the prepare_func() vfunc will work when
+ * we call set_session(): */
+ protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, protocol_type);
+ tny_account_set_id (tny_account, "temp_account");
+ tny_account_set_proto (tny_account, modest_protocol_get_name (protocol));
tny_account_set_hostname (tny_account, hostname);
- /* Required for POP, at least */
tny_account_set_user (tny_account, username);
-
+
if(port > 0)
tny_account_set_port (tny_account, port);
-
+
/* Set the session for the account, so we can use it: */
- ModestTnyAccountStore *account_store = modest_runtime_get_account_store ();
- TnySessionCamel *session =
- modest_tny_account_store_get_session (TNY_ACCOUNT_STORE (account_store));
+ account_store = modest_runtime_get_account_store ();
+ session = modest_tny_account_store_get_session (TNY_ACCOUNT_STORE (account_store));
g_return_val_if_fail (session, NULL);
tny_camel_account_set_session (TNY_CAMEL_ACCOUNT(tny_account), session);
-
-
+
+ dialog = gtk_dialog_new_with_buttons(" ",
+ parent_window,
+ GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+ _("mcen_bd_dialog_cancel"),
+ GTK_RESPONSE_REJECT,
+ NULL);
+
/* Ask camel to ask the server, asynchronously: */
ModestGetSupportedAuthInfo *info = g_slice_new (ModestGetSupportedAuthInfo);
- info->result = NULL;
- info->cancel = FALSE;
- info->error = NULL;
- info->progress = gtk_progress_bar_new();
-
- info->dialog = gtk_dialog_new_with_buttons(" ",
- parent_window, GTK_DIALOG_MODAL,
- _("mcen_bd_dialog_cancel"),
- GTK_RESPONSE_REJECT,
- NULL);
-
- g_signal_connect(G_OBJECT(info->dialog), "response", G_CALLBACK(on_secure_auth_cancel), info);
-
+ info->result = &result;
+ info->dialog = dialog;
+
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(info->dialog)->vbox),
gtk_label_new(_("emev_ni_checking_supported_auth_methods")));
- gtk_container_add(GTK_CONTAINER(GTK_DIALOG(info->dialog)->vbox), info->progress);
+ progress = gtk_progress_bar_new();
+ gtk_container_add(GTK_CONTAINER(GTK_DIALOG(info->dialog)->vbox), progress);
gtk_widget_show_all(info->dialog);
KeepPulsing *pi = g_slice_new (KeepPulsing);
- pi->progress = (GtkProgressBar *) g_object_ref (info->progress);
+ pi->progress = progress;
pi->not_finished = TRUE;
-
+
/* Starts the pulsing of the progressbar */
g_timeout_add (500, keep_pulsing, pi);
-
- tny_camel_account_get_supported_secure_authentication (
- TNY_CAMEL_ACCOUNT (tny_account),
- on_camel_account_get_supported_secure_authentication,
- on_camel_account_get_supported_secure_authentication_status,
- info);
- gtk_dialog_run (GTK_DIALOG (info->dialog));
-
+ tny_camel_account_get_supported_secure_authentication (TNY_CAMEL_ACCOUNT (tny_account),
+ on_camel_account_get_supported_secure_authentication,
+ NULL,
+ info);
+
+ retval = 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);
- info->dialog = NULL;
-
- GList *result = info->result;
- if (!info->cancel) {
- if (info->error) {
- gchar * debug_url_string = tny_account_get_url_string (tny_account);
- g_warning ("%s:\n error: %s\n account url: %s", __FUNCTION__, info->error->message,
- debug_url_string);
- g_free (debug_url_string);
-
- g_propagate_error(error, info->error);
- info->error = NULL;
- }
- } else {
- // Tell the caller that the operation was canceled so it can
- // make a difference
- g_set_error(error,
- modest_utils_get_supported_secure_authentication_error_quark(),
- MODEST_UTILS_GET_SUPPORTED_SECURE_AUTHENTICATION_ERROR_CANCELED,
- "User has canceled query");
- }
- /* Free the info */
- if (info->error)
- g_free (info->error);
- if (info->result)
- g_list_free (info->result);
- if (info->dialog)
- gtk_widget_destroy (info->dialog);
- if (info->progress)
- gtk_widget_destroy (info->progress);
- g_slice_free (ModestGetSupportedAuthInfo, info);
+ gtk_widget_destroy(dialog);
+
+ /* Frees */
+ tny_account_cancel (tny_account);
+ g_object_unref (tny_account);
return result;
}
-void
-modest_utils_show_dialog_and_forget (GtkWindow *parent_window,
+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));
+ g_return_if_fail (GTK_IS_WINDOW(parent_window));
gtk_window_set_transient_for (GTK_WINDOW (dialog), parent_window);
-
+
/* Destroy the dialog when it is closed: */
- g_signal_connect_swapped (dialog,
- "response",
- G_CALLBACK (gtk_widget_destroy),
+ g_signal_connect_swapped (dialog,
+ "response",
+ G_CALLBACK (gtk_widget_destroy),
dialog);
gtk_widget_show (GTK_WIDGET (dialog));
}
static void
-launch_sort_headers_dialog (GtkWindow *parent_window,
+launch_sort_headers_dialog (ModestWindow *parent_window,
GtkDialog *dialog)
{
ModestHeaderView *header_view = NULL;
gint attachments_sort_id;
gint priority_sort_id;
GtkTreeSortable *sortable;
-
+ GtkTreeModel *filter;
+
/* 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 (MODEST_IS_HEADER_WINDOW (parent_window)) {
+ header_view = MODEST_HEADER_VIEW (modest_header_window_get_header_view (MODEST_HEADER_WINDOW (parent_window)));
}
if (!header_view)
return;
-
+
/* Add sorting keys */
cols = modest_header_view_get_columns (header_view);
if (cols == NULL)
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)))));
+ filter = gtk_tree_view_get_model (GTK_TREE_VIEW (header_view));
+ sortable = GTK_TREE_SORTABLE (gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (filter)));
/* Launch dialogs */
if (!gtk_tree_sortable_get_sort_column_id (sortable,
¤t_sort_colid, ¤t_sort_type)) {
}
void
-modest_utils_run_sort_dialog (GtkWindow *parent_window,
- ModestSortDialogType type)
+modest_utils_run_sort_dialog (ModestWindow *parent_window,
+ ModestSortDialogType type)
{
GtkWidget *dialog = NULL;
+ GtkWindow *toplevel;
/* Build dialog */
- dialog = modest_platform_create_sort_dialog (parent_window);
+ toplevel = (GtkWindow *) gtk_widget_get_toplevel (GTK_WIDGET (parent_window));
+ dialog = modest_platform_create_sort_dialog (toplevel);
if (dialog == NULL)
return;
modest_window_mgr_set_modal (modest_runtime_get_window_mgr (),
- GTK_WINDOW (dialog), parent_window);
+ GTK_WINDOW (dialog), toplevel);
/* Fill sort keys */
switch (type) {
}
gchar *
-modest_utils_get_account_name_from_recipient (const gchar *from_header)
+modest_utils_get_account_name_from_recipient (const gchar *from_header, gchar **mailbox)
{
gchar *account_name = NULL;
ModestAccountMgr *mgr = NULL;
GSList *accounts = NULL, *node = NULL;
+ if (mailbox)
+ *mailbox = NULL;
g_return_val_if_fail (from_header, NULL);
mgr = modest_runtime_get_account_mgr ();
accounts = modest_account_mgr_account_names (mgr, TRUE);
for (node = accounts; node != NULL; node = g_slist_next (node)) {
- gchar *from =
- modest_account_mgr_get_from_string (mgr, node->data);
+ gchar *from;
+ gchar *transport_account;
+
+ if (!strcmp (from_header, node->data)) {
+ account_name = g_strdup (node->data);
+ break;
+ }
+
+ transport_account = modest_account_mgr_get_server_account_name (modest_runtime_get_account_mgr (),
+ (const gchar *) node->data,
+ TNY_ACCOUNT_TYPE_TRANSPORT);
+ if (transport_account) {
+ gchar *proto;
+ proto = modest_account_mgr_get_string (mgr, transport_account, MODEST_ACCOUNT_PROTO, TRUE);
+
+ if (proto != NULL) {
+ ModestProtocol *protocol =
+ modest_protocol_registry_get_protocol_by_name (modest_runtime_get_protocol_registry (),
+ MODEST_PROTOCOL_REGISTRY_TRANSPORT_PROTOCOLS,
+ proto);
+ if (protocol && MODEST_IS_ACCOUNT_PROTOCOL (protocol)) {
+ ModestPairList *pair_list;
+ ModestPair *pair;
+ gchar *from_header_email =
+ modest_text_utils_get_email_address (from_header);
+ pair_list = modest_account_protocol_get_from_list (MODEST_ACCOUNT_PROTOCOL (protocol),
+ node->data);
+
+ pair = modest_pair_list_find_by_first_as_string (pair_list, from_header_email);
+ if (pair != NULL) {
+ account_name = g_strdup (node->data);
+ if (mailbox)
+ *mailbox = g_strdup (from_header_email);
+ }
+
+ modest_pair_list_free (pair_list);
+
+ }
+ g_free (proto);
+ }
+ g_free (transport_account);
+ }
+ if (mailbox && *mailbox)
+ break;
+
+ from =
+ modest_account_mgr_get_from_string (mgr, node->data, NULL);
if (from) {
gchar *from_email =
g_free (from_header_email);
g_free (from);
}
+
+
}
g_slist_foreach (accounts, (GFunc) g_free, NULL);
g_slist_free (accounts);
show_char = "' '";
}
- message = g_strdup_printf (_CS("ckdg_ib_illegal_characters_entered"), show_char);
+ message = g_strdup_printf (_CS_ILLEGAL_CHARACTERS_ENTERED, show_char);
modest_platform_information_banner (GTK_WIDGET (self), NULL, message);
g_free (message);
}
+
+FILE*
+modest_utils_open_mcc_mapping_file (void)
+{
+ FILE* result = NULL;
+ const gchar* path;
+
+ if (access (MODEST_OPERATOR_WIZARD_MCC_MAPPING, R_OK) == 0) {
+ path = MODEST_OPERATOR_WIZARD_MCC_MAPPING;
+ } else if (access (MODEST_MCC_MAPPING, R_OK) == 0) {
+ path = MODEST_MCC_MAPPING;
+ } else {
+ g_warning ("%s: neither '%s' nor '%s' is a readable mapping file",
+ __FUNCTION__, MODEST_OPERATOR_WIZARD_MCC_MAPPING, MODEST_MCC_MAPPING);
+ return NULL;
+ }
+
+ result = fopen (path, "r");
+ if (!result) {
+ g_warning ("%s: error opening mapping file '%s': %s",
+ __FUNCTION__, path, strerror(errno));
+ }
+
+ return result;
+}
+
+/* each line is of the form:
+ xxx logical_id
+
+ NOTE: this function is NOT re-entrant, the out-param country
+ are static strings that should NOT be freed. and will change when
+ calling this function again
+*/
+static int
+parse_mcc_mapping_line (const char* line, char** country)
+{
+ char mcc[4]; /* the mcc code, always 3 bytes*/
+ gchar *iter, *tab, *final;
+
+ if (!line) {
+ *country = NULL;
+ return 0;
+ }
+
+ /* Go to the first tab (Country separator) */
+ tab = g_utf8_strrchr (line, -1, '\t');
+ if (!tab)
+ return 0;
+
+ *country = g_utf8_find_next_char (tab, NULL);
+
+ /* Replace by end of string. We need to use strlen, because
+ g_utf8_strrchr expects bytes and not UTF8 characters. File
+ lines end with \r\n */
+ final = g_utf8_strrchr (tab, strlen (tab) + 1, '\r');
+ if (G_LIKELY (final))
+ *final = '\0';
+ else
+ tab[strlen(tab) - 1] = '\0';
+
+ /* Get MCC code */
+ mcc[0] = g_utf8_get_char (line);
+ iter = g_utf8_find_next_char (line, NULL);
+ mcc[1] = g_utf8_get_char (iter);
+ iter = g_utf8_find_next_char (iter, NULL);
+ mcc[2] = g_utf8_get_char (iter);
+ mcc[3] = '\0';
+
+ return (int) strtol ((const char*)mcc, NULL, 10);
+}
+
+#define MCC_FILE_MAX_LINE_LEN 128 /* max length of a line in MCC file */
+
+/** Note that the mcc_mapping file is installed
+ * by the operator-wizard-settings package.
+ */
+GtkTreeModel *
+modest_utils_create_country_model (void)
+{
+ GtkTreeModel *model;
+
+ model = GTK_TREE_MODEL (gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT));
+
+ return model;
+}
+
+void
+modest_utils_fill_country_model (GtkTreeModel *model, gint *locale_mcc)
+{
+ char line[MCC_FILE_MAX_LINE_LEN];
+ guint previous_mcc = 0;
+ gchar *territory;
+ GHashTable *country_hash;
+ FILE *file;
+
+ /* First we need to know our current region */
+ file = modest_utils_open_mcc_mapping_file ();
+ if (!file) {
+ g_warning ("Could not open mcc_mapping file");
+ return;
+ }
+
+ /* Get the territory specified for the current locale */
+ territory = nl_langinfo (_NL_IDENTIFICATION_TERRITORY);
+
+ setlocale (LC_MESSAGES, "en_GB");
+
+ while (fgets (line, MCC_FILE_MAX_LINE_LEN, file) != NULL) {
+ int mcc;
+ char *country = NULL;
+
+ mcc = parse_mcc_mapping_line (line, &country);
+ if (!country || mcc == 0) {
+ g_warning ("%s: error parsing line: '%s'", __FUNCTION__, line);
+ continue;
+ }
+
+ if (mcc == previous_mcc) {
+ /* g_warning ("already seen: %s", line); */
+ continue;
+ }
+ previous_mcc = mcc;
+
+ if (!(*locale_mcc)) {
+ gchar *translation = dgettext ("osso-countries", country);
+ if (!g_utf8_collate (translation, territory))
+ *locale_mcc = mcc;
+ }
+ }
+
+ setlocale (LC_MESSAGES, "");
+
+ /* Now we fill the model */
+ rewind (file);
+ country_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+ while (fgets (line, MCC_FILE_MAX_LINE_LEN, file) != NULL) {
+
+ int mcc;
+ char *country = NULL;
+ GtkTreeIter iter;
+ const gchar *name_translated;
+
+ mcc = parse_mcc_mapping_line (line, &country);
+ if (!country || mcc == 0) {
+ g_warning ("%s: error parsing line: '%s'", __FUNCTION__, line);
+ continue;
+ }
+
+ if (mcc == previous_mcc ||
+ g_hash_table_lookup (country_hash, country)) {
+ g_debug ("already seen: '%s' %d", country, mcc);
+ continue;
+ }
+ previous_mcc = mcc;
+
+ g_hash_table_insert (country_hash, g_strdup (country), GINT_TO_POINTER (mcc));
+
+ name_translated = dgettext ("osso-countries", country);
+
+ /* Add the row to the model if we have translation for it */
+ if (g_utf8_collate (country, name_translated)) {
+ gtk_list_store_append (GTK_LIST_STORE (model), &iter);
+ gtk_list_store_set(GTK_LIST_STORE (model), &iter,
+ MODEST_UTILS_COUNTRY_MODEL_COLUMN_MCC, mcc,
+ MODEST_UTILS_COUNTRY_MODEL_COLUMN_NAME, name_translated,
+ -1);
+ } else {
+ g_debug ("%s no translation for %s", __FUNCTION__, country);
+ }
+ }
+
+
+ g_hash_table_unref (country_hash);
+ fclose (file);
+
+ /* Fallback to Finland */
+ if (!(*locale_mcc))
+ *locale_mcc = 244;
+
+ /* Sort the items: */
+ gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
+ MODEST_UTILS_COUNTRY_MODEL_COLUMN_NAME, GTK_SORT_ASCENDING);
+}
+
+GList *
+modest_utils_create_notification_list_from_header_list (TnyList *header_list)
+{
+ GList *new_headers_list;
+ TnyIterator *iter;
+
+ g_return_val_if_fail (TNY_IS_LIST (header_list), NULL);
+ g_return_val_if_fail (tny_list_get_length (header_list) > 0, NULL);
+
+ new_headers_list = NULL;
+ iter = tny_list_create_iterator (header_list);
+ while (!tny_iterator_is_done (iter)) {
+ ModestMsgNotificationData *data;
+ TnyHeader *header;
+ TnyFolder *folder;
+
+ header = (TnyHeader *) tny_iterator_get_current (iter);
+ if (header) {
+ folder = tny_header_get_folder (header);
+
+ if (folder) {
+ gchar *uri, *uid;
+
+ uid = tny_header_dup_uid (header);
+ uri = g_strdup_printf ("%s/%s",
+ tny_folder_get_url_string (folder),
+ uid);
+ g_free (uid);
+
+ /* Create data & add to list */
+ data = g_slice_new0 (ModestMsgNotificationData);
+ data->subject = tny_header_dup_subject (header);
+ data->from = tny_header_dup_from (header);
+ data->uri = uri;
+
+ new_headers_list = g_list_append (new_headers_list, data);
+
+ g_object_unref (folder);
+ }
+ g_object_unref (header);
+ }
+ tny_iterator_next (iter);
+ }
+ g_object_unref (iter);
+
+ return new_headers_list;
+}
+
+static void
+free_notification_data (gpointer data,
+ gpointer user_data)
+{
+ ModestMsgNotificationData *notification_data = (ModestMsgNotificationData *) data;
+
+ g_free (notification_data->from);
+ g_free (notification_data->subject);
+ g_free (notification_data->uri);
+
+ g_slice_free (ModestMsgNotificationData, notification_data);
+}
+
+void
+modest_utils_free_notification_list (GList *notification_list)
+{
+ g_return_if_fail (g_list_length (notification_list) > 0);
+
+ g_list_foreach (notification_list, free_notification_data, NULL);
+ g_list_free (notification_list);
+}
+
+void
+modest_utils_flush_send_queue (const gchar *account_id)
+{
+ TnyTransportAccount *account;
+
+ /* Get the transport account */
+ account = (TnyTransportAccount *)
+ modest_tny_account_store_get_server_account (modest_runtime_get_account_store (),
+ account_id,
+ TNY_ACCOUNT_TYPE_TRANSPORT);
+ if (account) {
+ ModestMailOperation *wakeup_op;
+ ModestTnySendQueue *send_queue = modest_runtime_get_send_queue (account, TRUE);
+
+ /* Flush it! */
+ wakeup_op = modest_mail_operation_new (NULL);
+ modest_mail_operation_queue_add (modest_runtime_get_mail_operation_queue (),
+ wakeup_op);
+ modest_mail_operation_queue_wakeup (wakeup_op, send_queue);
+
+ g_object_unref (account);
+ }
+}