X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fmaemo%2Fmodest-platform.c;h=cac2a48c17aa3679d6f6952caacd37dec21a0b21;hp=f5216393aad59b7968dfd774e194ddc1cea0f550;hb=16d7f8b9f45217e350735e33ee6d0255aa894074;hpb=94a4612a68cf9129d80418e40d177911297b76e7

diff --git a/src/maemo/modest-platform.c b/src/maemo/modest-platform.c
index f521639..cac2a48 100644
--- a/src/maemo/modest-platform.c
+++ b/src/maemo/modest-platform.c
@@ -36,10 +36,8 @@
 #include "maemo/modest-maemo-global-settings-dialog.h"
 #include "modest-widget-memory.h"
 #include <modest-hildon-includes.h>
-#include <osso-helplib.h>
 #include <modest-maemo-utils.h>
 #include <dbus_api/modest-dbus-callbacks.h>
-#include <libosso-abook/osso-abook.h>
 #include <maemo/modest-osso-autosave-callbacks.h>
 #include <libosso.h>
 #include <alarmd/alarm_event.h> /* For alarm_event_add(), etc. */
@@ -56,11 +54,15 @@
 #include <string.h>
 #include <libgnomevfs/gnome-vfs-mime-utils.h>
 
+#ifdef MODEST_HAVE_ABOOK
+#include <libosso-abook/osso-abook.h>
+#endif /*MODEST_HAVE_ABOOK*/
+
 
 #define HILDON_OSSO_URI_ACTION "uri-action"
 #define URI_ACTION_COPY "copy:"
 
-static osso_context_t *osso_context = NULL;
+static osso_context_t *osso_context = NULL; /* urgh global */
 
 static void	
 on_modest_conf_update_interval_changed (ModestConf* self, 
@@ -69,6 +71,8 @@ on_modest_conf_update_interval_changed (ModestConf* self,
 					ModestConfNotificationId id, 
 					gpointer user_data)
 {
+	g_return_if_fail (key);
+	
 	if (strcmp (key, MODEST_CONF_UPDATE_INTERVAL) == 0) {
 		const guint update_interval_minutes = 
 			modest_conf_get_int (self, MODEST_CONF_UPDATE_INTERVAL, NULL);
@@ -103,7 +107,8 @@ modest_platform_init (int argc, char *argv[])
 {
 	osso_hw_state_t hw_state = { 0 };
 	DBusConnection *con;	
-
+	GSList *acc_names;
+	
 	if (!check_required_files ()) {
 		g_printerr ("modest: missing required files\n");
 		return FALSE;
@@ -186,17 +191,27 @@ modest_platform_init (int argc, char *argv[])
 			  "key_changed",
 			  G_CALLBACK (on_modest_conf_update_interval_changed), 
 			  NULL);
-			  
-	/* Get the initial update interval from gconf: */
-	on_modest_conf_update_interval_changed(conf, MODEST_CONF_UPDATE_INTERVAL,
-					       MODEST_CONF_EVENT_KEY_CHANGED, 0, NULL);
 
+	/* only force the setting of the default interval, if there are actually
+	 * any accounts */
+	acc_names = modest_account_mgr_account_names (modest_runtime_get_account_mgr(), TRUE);
+	if (acc_names) {
+		/* Get the initial update interval from gconf: */
+		on_modest_conf_update_interval_changed(conf, MODEST_CONF_UPDATE_INTERVAL,
+						       MODEST_CONF_EVENT_KEY_CHANGED, 0, NULL);
+		modest_account_mgr_free_account_names (acc_names);
+	}
+
+	
+#ifdef MODEST_HAVE_ABOOK
 	/* initialize the addressbook */
 	if (!osso_abook_init (&argc, &argv, osso_context)) {
 		g_printerr ("modest: failed to initialized addressbook\n");
 		return FALSE;
 	}
-		
+#endif /*MODEST_HAVE_ABOOK*/
+
+
 	return TRUE;
 }
 
@@ -599,7 +614,7 @@ launch_sort_headers_dialog (GtkWindow *parent_window,
 
 	sort_key = hildon_sort_dialog_add_sort_key (dialog, _("mcen_li_sort_priority"));
 	sort_model_ids[sort_key] = TNY_GTK_HEADER_LIST_MODEL_FLAGS_COLUMN;
-	sort_ids[sort_key] = TNY_HEADER_FLAG_PRIORITY;
+	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)))));
@@ -613,7 +628,7 @@ launch_sort_headers_dialog (GtkWindow *parent_window,
 		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)
+			if (GPOINTER_TO_INT (flags_sort_type_pointer) == TNY_HEADER_FLAG_PRIORITY_MASK)
 				hildon_sort_dialog_set_sort_key (dialog, priority_sort_id);
 			else
 				hildon_sort_dialog_set_sort_key (dialog, attachments_sort_id);
@@ -921,148 +936,131 @@ modest_platform_run_information_dialog (GtkWindow *parent_window,
 
 
 
-typedef struct
-{
-	GMainLoop* loop;
-} UtilIdleData;
+typedef struct _ConnectAndWaitData {
+	GMutex *mutex;
+	GMainLoop *wait_loop;
+	gboolean has_callback;
+	gulong handler;
+} ConnectAndWaitData;
 
-static gboolean 
-on_idle_connect_and_wait(gpointer user_data)
-{
-	printf ("DEBUG: %s:\n", __FUNCTION__);
-	TnyDevice *device = modest_runtime_get_device();
-	if (!tny_device_is_online (device)) {
 
-		/* This is a GDK lock because we are an idle callback and
-		 * tny_maemo_conic_device_connect can contain Gtk+ code */
-
-		gdk_threads_enter(); /* CHECKED */
-		tny_maemo_conic_device_connect (TNY_MAEMO_CONIC_DEVICE (device), NULL);
-		gdk_threads_leave(); /* CHECKED */
-	}
-	
-	/* Allow the function that requested this idle callback to continue: */
-	UtilIdleData *data = (UtilIdleData*)user_data;
-	if (data->loop)
-		g_main_loop_quit (data->loop);
-	
-	return FALSE; /* Don't call this again. */
+static void
+quit_wait_loop (TnyAccount *account,
+		ConnectAndWaitData *data) 
+{
+	/* Set the has_callback to TRUE (means that the callback was
+	   executed and wake up every code waiting for cond to be
+	   TRUE */
+	g_mutex_lock (data->mutex);
+	data->has_callback = TRUE;
+	if (data->wait_loop)
+		g_main_loop_quit (data->wait_loop);
+	g_mutex_unlock (data->mutex);
 }
 
-static gboolean connect_request_in_progress = FALSE;
-
-/* This callback is used when connect_and_wait() is already queued as an idle callback.
- * This can happen because the gtk_dialog_run() for the connection dialog 
- * (at least in the fake scratchbox version) allows idle handlers to keep running.
- */
-static gboolean 
-on_idle_wait_for_previous_connect_to_finish(gpointer user_data)
+static void
+on_connection_status_changed (TnyAccount *account, 
+			      TnyConnectionStatus status,
+			      gpointer user_data)
 {
-	gboolean result = FALSE;
-	TnyDevice *device = modest_runtime_get_device();
-	if (tny_device_is_online (device))
-		result = FALSE; /* Stop trying. */
-	else {
-		/* Keep trying until connect_request_in_progress is FALSE. */
-		if (connect_request_in_progress)
-			result = TRUE; /* Keep trying */
-		else {
-			printf ("DEBUG: %s: other idle has finished.\n", __FUNCTION__);
-						
-			result = FALSE; /* Stop trying, now that a result should be available. */
-		}
-	}
-	
-	if (result == FALSE) {
-		/* Allow the function that requested this idle callback to continue: */
-		UtilIdleData *data = (UtilIdleData*)user_data;
-		if (data->loop)
-			g_main_loop_quit (data->loop);	
-	}
-		
-	return result;
+	TnyConnectionStatus conn_status;
+	ConnectAndWaitData *data;
+			
+	/* Ignore if reconnecting or disconnected */
+	conn_status = tny_account_get_connection_status (account);
+	if (conn_status == TNY_CONNECTION_STATUS_RECONNECTING ||
+	    conn_status == TNY_CONNECTION_STATUS_DISCONNECTED)
+		return;
+
+	/* Remove the handler */
+	data = (ConnectAndWaitData *) user_data;
+	g_signal_handler_disconnect (account, data->handler);
+
+	/* Quit from wait loop */
+	quit_wait_loop (account, (ConnectAndWaitData *) user_data);
 }
 
-static void 
-set_account_to_online (TnyAccount *account)
+static void
+on_tny_camel_account_set_online_cb (TnyCamelAccount *account, 
+				    gboolean canceled, 
+				    GError *err, 
+				    gpointer user_data)
 {
-	/* TODO: This is necessary to prevent a cancel of the password dialog 
-	 * from making a restart necessary to be asked the password again,
-	 * but it causes a hang:
-	 */
-	#if 0
-	if (account && TNY_IS_CAMEL_STORE_ACCOUNT (account)) {
-		/* Make sure that store accounts are online too, 
-		 * because tinymail sets accounts to offline if 
-		 * a password dialog is ever cancelled.
-		 * We don't do this for transport accounts because 
-		 * a) They fundamentally need network access, so they can't really be offline.
-		 * b) That might cause a transport connection to happen too early.
-		 */
-
-		/* The last argument is user_data, the NULL before that is the callback */
-		tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (account), TRUE, NULL, NULL);
-	}
-	#endif
+	/* Quit from wait loop */
+	quit_wait_loop (TNY_ACCOUNT (account), (ConnectAndWaitData *) user_data);
 }
 
 gboolean 
-modest_platform_connect_and_wait (GtkWindow *parent_window, TnyAccount *account)
+modest_platform_connect_and_wait (GtkWindow *parent_window, 
+				  TnyAccount *account)
 {
-	if (connect_request_in_progress)
-		return FALSE;
-		
-	printf ("DEBUG: %s:\n", __FUNCTION__);
-	TnyDevice *device = modest_runtime_get_device();
+	ConnectAndWaitData *data = NULL;
+	gboolean device_online;
+	TnyDevice *device;
+	TnyConnectionStatus conn_status;
 	
-	if (tny_device_is_online (device)) {
-		printf ("DEBUG: %s: Already online.\n", __FUNCTION__);
-		set_account_to_online (account);
-		return TRUE;
-	} else
-	{
-		printf ("DEBUG: %s: tny_device_is_online() returned FALSE\n", __FUNCTION__);
-	}
-		
-	/* This blocks on the result: */
-	UtilIdleData *data = g_slice_new0 (UtilIdleData);
-	
-	GMainContext *context = NULL; /* g_main_context_new (); */
-	data->loop = g_main_loop_new (context, FALSE /* not running */);
-	
-	/* Cause the function to be run in an idle-handler, which is always 
-	 * in the main thread:
-	 */
-	if (!connect_request_in_progress) {
-		printf ("DEBUG: %s: First request\n", __FUNCTION__);
-		connect_request_in_progress = TRUE;
-		g_idle_add (&on_idle_connect_and_wait, data);
-	}
-	else {
-		printf ("DEBUG: %s: nth request\n", __FUNCTION__);
-		g_idle_add_full (G_PRIORITY_LOW, &on_idle_wait_for_previous_connect_to_finish, data, NULL);
-	}
+	device = modest_runtime_get_device();
+	device_online = tny_device_is_online (device);
 
-	/* This main loop will run until the idle handler has stopped it: */
-	printf ("DEBUG: %s: before g_main_loop_run()\n", __FUNCTION__);
-	GDK_THREADS_LEAVE();
-	g_main_loop_run (data->loop);
-	GDK_THREADS_ENTER();
-	printf ("DEBUG: %s: after g_main_loop_run()\n", __FUNCTION__);
-	connect_request_in_progress = FALSE;
-	printf ("DEBUG: %s: Finished\n", __FUNCTION__);
-	g_main_loop_unref (data->loop);
-	/* g_main_context_unref (context); */
+	/* If there is no account check only the device status */
+	if (!account) {
+		if (device_online)
+			return TRUE;
+		else
+			return tny_maemo_conic_device_connect (TNY_MAEMO_CONIC_DEVICE (device), NULL);
+	}
 
-	g_slice_free (UtilIdleData, data);
+	/* Return if the account is already connected */
+	conn_status = tny_account_get_connection_status (account);
+	if (device_online && conn_status == TNY_CONNECTION_STATUS_CONNECTED)
+		return TRUE;
 
-	const gboolean result = tny_device_is_online (device);
+	/* Create the helper */
+	data = g_slice_new0 (ConnectAndWaitData);
+	data->mutex = g_mutex_new ();
+	data->has_callback = FALSE;
+
+	/* Connect the device */
+	if (!device_online) {
+		/* Track account connection status changes */
+		data->handler = g_signal_connect (account, "connection-status-changed",					    
+						  G_CALLBACK (on_connection_status_changed),
+						  data);
+		/* Try to connect the device */
+		device_online = tny_maemo_conic_device_connect (TNY_MAEMO_CONIC_DEVICE (device), NULL);
+
+		/* If the device connection failed then exit */
+		if (!device_online && data->handler)
+			goto frees;
+	} else {
+		/* Force a reconnection of the account */
+		tny_camel_account_set_online (TNY_CAMEL_ACCOUNT (account), TRUE, 
+					      on_tny_camel_account_set_online_cb, data);
+	}
 
-	if (result) {
-		set_account_to_online (account);
+	/* Wait until the callback is executed */
+	g_mutex_lock (data->mutex);
+	if (!data->has_callback) {
+		data->wait_loop = g_main_loop_new (NULL, FALSE);
+		gdk_threads_leave ();
+		g_mutex_unlock (data->mutex);
+		g_main_loop_run (data->wait_loop);
+		g_mutex_lock (data->mutex);
+		gdk_threads_enter ();
+	}
+	g_mutex_unlock (data->mutex);
+
+ frees:
+	if (data) {
+		if (g_signal_handler_is_connected (account, data->handler))
+			g_signal_handler_disconnect (account, data->handler);
+		g_mutex_free (data->mutex);
+		g_main_loop_unref (data->wait_loop);
+		g_slice_free (ConnectAndWaitData, data);
 	}
 
-	return result;
+	conn_status = tny_account_get_connection_status (account);
+	return (conn_status == TNY_CONNECTION_STATUS_CONNECTED)	? TRUE: FALSE;
 }
 
 gboolean 
@@ -1243,71 +1241,149 @@ modest_platform_set_update_interval (guint minutes)
 	return TRUE;
 }
 
-GtkWidget * 
-modest_platform_get_global_settings_dialog ()
-{
-	return modest_maemo_global_settings_dialog_new ();
-}
-
 void 
-modest_platform_on_new_header_received (TnyHeader *header)
+modest_platform_on_new_headers_received (TnyList *header_list) 
 {
 #ifdef MODEST_HAVE_HILDON_NOTIFY
 	HildonNotification *notification;
-	gchar *url = NULL;
-	TnyFolder *folder = NULL;
-	const gchar *subject;
+	TnyIterator *iter;
+	GSList *notifications_list = NULL;
+
+	/* Get previous notifications ids */
+	notifications_list = modest_conf_get_list (modest_runtime_get_conf (), 
+						   MODEST_CONF_NOTIFICATION_IDS, 
+						   MODEST_CONF_VALUE_INT, NULL);
+
+	iter = tny_list_create_iterator (header_list);
+	while (!tny_iterator_is_done (iter)) {
+		gchar *url = NULL, *display_address = NULL,  *summary = NULL;
+		const gchar *display_date;
+		TnyHeader *header = TNY_HEADER (tny_iterator_get_current (iter));
+		TnyFolder *folder = tny_header_get_folder (header);
+		gboolean first_notification = TRUE;
+		gint notif_id;
+
+		/* constant string, don't free */
+		display_date = modest_text_utils_get_display_date (tny_header_get_date_received (header));
+
+		display_address = g_strdup(tny_header_get_from (header));
+		modest_text_utils_get_display_address (display_address); /* string is changed in-place */
+		
+		summary = g_strdup_printf ("%s - %s", display_date, display_address);
+		notification = hildon_notification_new (summary,
+							tny_header_get_subject (header),
+							"qgn_list_messagin",
+							"email.arrive");
+		/* Create the message URL */
+		url = g_strdup_printf ("%s/%s", tny_folder_get_url_string (folder), 
+				       tny_header_get_uid (header));
+
+		hildon_notification_add_dbus_action(notification,
+						    "default",
+						    "Cancel",
+						    MODEST_DBUS_SERVICE,
+						    MODEST_DBUS_OBJECT,
+						    MODEST_DBUS_IFACE,
+						    MODEST_DBUS_METHOD_OPEN_MESSAGE,
+						    G_TYPE_STRING, url,
+						    -1);
+
+		/* Play sound if the user wants. Show the LED
+		   pattern. Show and play just one */
+		if (G_UNLIKELY (first_notification)) {
+			first_notification = FALSE;
+			if (modest_conf_get_bool (modest_runtime_get_conf (),
+						  MODEST_CONF_PLAY_SOUND_MSG_ARRIVE,
+						  NULL))  {
+				notify_notification_set_hint_string(NOTIFY_NOTIFICATION (notification),
+								    "sound-file", "/usr/share/sounds/ui-new_email.wav");
+			}
 
-	subject = tny_header_get_subject (header);
-	if (!subject || strlen(subject) == 0)
-		subject = _("mail_va_no_subject");
-	
-	notification = hildon_notification_new (tny_header_get_from (header),
-						subject,
-						"qgn_list_messagin",
-						NULL);
-
-	folder = tny_header_get_folder (header);
-	url = g_strdup_printf ("%s/%s", 
-			       tny_folder_get_url_string (folder), 
-			       tny_header_get_uid (header));
-	g_object_unref (folder);
-
-	hildon_notification_add_dbus_action(notification,
-					    "default",
-					    "Cancel",
-					    MODEST_DBUS_SERVICE,
-					    MODEST_DBUS_OBJECT,
-					    MODEST_DBUS_IFACE,
-					    MODEST_DBUS_METHOD_OPEN_MESSAGE,
-					    G_TYPE_STRING, url,
-					    -1);
-	g_free (url);
+			/* Set the led pattern */
+			notify_notification_set_hint_int32 (NOTIFY_NOTIFICATION (notification),
+							    "dialog-type", 4);
+			notify_notification_set_hint_string(NOTIFY_NOTIFICATION (notification),
+							    "led-pattern",
+							    "PatternCommunicationEmail");			
+		}
+
+		/* Notify. We need to do this in an idle because this function
+		   could be called from a thread */
+		notify_notification_show (NOTIFY_NOTIFICATION (notification), NULL);
+
+		/* Save id in the list */
+		g_object_get(G_OBJECT(notification), "id", &notif_id, NULL);
+		notifications_list = g_slist_prepend (notifications_list, GINT_TO_POINTER(notif_id));
+		/* We don't listen for the "closed" signal, because we
+		   don't care about if the notification was removed or
+		   not to store the list in gconf */
 	
-	/* Play sound if the user wants */
-	if (modest_conf_get_bool (modest_runtime_get_conf (), 
-				  MODEST_CONF_PLAY_SOUND_MSG_ARRIVE, 
-				  NULL)) {
-		hildon_notification_set_sound (HILDON_NOTIFICATION(notification),
-					       "/usr/share/sounds/ui-new_email.wav");
+		/* Free & carry on */
+		g_free (display_address);
+		g_free (summary);
+		g_free (url);
+		g_object_unref (folder);
+		g_object_unref (header);
+		tny_iterator_next (iter);
 	}
+	g_object_unref (iter);
+
+	/* Save the ids */
+	modest_conf_set_list (modest_runtime_get_conf (), MODEST_CONF_NOTIFICATION_IDS, 
+			      notifications_list, MODEST_CONF_VALUE_INT, NULL);
+
+	g_slist_free (notifications_list);
 	
-	/* Set the led pattern */
-	notify_notification_set_hint_int32 (NOTIFY_NOTIFICATION(notification),
-					    "dialog-type", 4);
-	notify_notification_set_hint_string(NOTIFY_NOTIFICATION(notification), 
-					    "led-pattern", 
-					    "PatternCommunicationEmail");
-
-	/* Notify. We need to do this in an idle because this function
-	   could be called from a thread */
-	if (!notify_notification_show (NOTIFY_NOTIFICATION(notification), NULL))
-		g_error ("Failed to send notification");
-	
-	g_object_unref (notification);
 #endif /*MODEST_HAVE_HILDON_NOTIFY*/
 }
 
+void
+modest_platform_remove_new_mail_notifications (void) 
+{
+#ifdef MODEST_HAVE_HILDON_NOTIFY
+	GSList *notif_list = NULL;
+
+	/* Get previous notifications ids */
+	notif_list = modest_conf_get_list (modest_runtime_get_conf (), 
+					   MODEST_CONF_NOTIFICATION_IDS, 
+					   MODEST_CONF_VALUE_INT, NULL);
+
+        while (notif_list) {
+		gint notif_id;
+		NotifyNotification *notif;
+
+		/* Nasty HACK to remove the notifications, set the id
+		   of the existing ones and then close them */
+		notif_id = GPOINTER_TO_INT(notif_list->data);
+		notif = notify_notification_new("dummy", NULL, NULL, NULL);
+		g_object_set(G_OBJECT(notif), "id", notif_id, NULL);
+
+		/* Close the notification, note that some ids could be
+		   already invalid, but we don't care because it does
+		   not fail */
+		notify_notification_close(notif, NULL);
+		g_object_unref(notif);
+
+		/* Delete the link, it's like going to the next */
+		notif_list = g_slist_delete_link (notif_list, notif_list);
+        }
+
+	/* Save the ids */
+	modest_conf_set_list (modest_runtime_get_conf (), MODEST_CONF_NOTIFICATION_IDS, 
+			      notif_list, MODEST_CONF_VALUE_INT, NULL);
+
+	g_slist_free (notif_list);
+
+#endif /* MODEST_HAVE_HILDON_NOTIFY */
+}
+
+
+
+GtkWidget * 
+modest_platform_get_global_settings_dialog ()
+{
+	return modest_maemo_global_settings_dialog_new ();
+}
 
 void
 modest_platform_show_help (GtkWindow *parent_window, 
@@ -1318,12 +1394,7 @@ modest_platform_show_help (GtkWindow *parent_window,
 	g_return_if_fail (help_id);
 	g_return_if_fail (osso_context);
 
-	/* Show help */
-#ifdef MODEST_HAVE_OSSO_HELP
-	result = ossohelp_show (osso_context, help_id, OSSO_HELP_SHOW_DIALOG);
-#else
-	result = hildon_help_show (osso_context, help_id, OSSO_HELP_SHOW_DIALOG);
-#endif
+	result = hildon_help_show (osso_context, help_id, HILDON_HELP_SHOW_DIALOG);
 
 	if (result != OSSO_OK) {
 		gchar *error_msg;
@@ -1335,6 +1406,22 @@ modest_platform_show_help (GtkWindow *parent_window,
 	}
 }
 
+void
+modest_platform_set_dialog_help (GtkDialog *parent_window, 
+				 const gchar *help_id)
+{
+	gboolean result;
+	g_return_if_fail (help_id);
+	g_return_if_fail (osso_context);
+	g_return_if_fail (GTK_IS_DIALOG (parent_window));
+
+	result = hildon_help_dialog_help_enable (parent_window, help_id, osso_context);
+
+	if (!result)
+		g_warning ("Help topic %s not found", help_id);
+
+}
+
 void 
 modest_platform_show_search_messages (GtkWindow *parent_window)
 {
@@ -1510,7 +1597,7 @@ modest_platform_check_and_wait_for_account_is_online(TnyAccount *account)
 	GMainContext *context = NULL; /* g_main_context_new (); */
 	data->loop = g_main_loop_new (context, FALSE /* not running */);
 
-	g_timeout_add (1000, &on_timeout_check_account_is_online, data);
+	g_timeout_add (1000, on_timeout_check_account_is_online, data);
 
 	/* This main loop will run until the idle handler has stopped it: */
 	g_main_loop_run (data->loop);
@@ -1545,19 +1632,29 @@ on_cert_dialog_response (GtkDialog *dialog, gint response_id,  const gchar* cert
 
 
 gboolean
-modest_platform_run_certificate_conformation_dialog (const gchar* server_name,
+modest_platform_run_certificate_confirmation_dialog (const gchar* server_name,
 						     const gchar *certificate)
 {
 	GtkWidget *note;
 	gint response;
-	GtkWindow *main_win =
-		(GtkWindow*)modest_window_mgr_get_main_window (modest_runtime_get_window_mgr());
+	ModestWindow *main_win;
+	
+	if (!modest_window_mgr_main_window_exists (modest_runtime_get_window_mgr())) {
+		g_warning ("%s: don't show dialogs if there's no main window; assuming 'Cancel'",
+			   __FUNCTION__);
+		return FALSE;
+	}
 
+	/* don't create it */
+	main_win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr(), FALSE);
+	g_return_val_if_fail (main_win, FALSE); /* should not happen */
+	
+	
 	gchar *question = g_strdup_printf (_("mcen_nc_unknown_certificate"),
 					   server_name);
 	
 	note = hildon_note_new_confirmation_add_buttons  (
-		main_win,
+		GTK_WINDOW(main_win),
 		question,
 		_("mcen_bd_dialog_ok"),     GTK_RESPONSE_OK,
 		_("mcen_bd_view"),          GTK_RESPONSE_HELP,   /* abusing this... */
@@ -1575,7 +1672,7 @@ modest_platform_run_certificate_conformation_dialog (const gchar* server_name,
 	on_destroy_dialog (GTK_DIALOG(note));
 	g_free (question);
 	
-	return response;
+	return response == GTK_RESPONSE_OK;
 }
 	
 
@@ -1584,8 +1681,16 @@ gboolean
 modest_platform_run_alert_dialog (const gchar* prompt, 
 				  gboolean is_question)
 {	
-	ModestWindow *main_window = 
-		modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ());
+	ModestWindow *main_win; 
+
+	if (!modest_window_mgr_main_window_exists (modest_runtime_get_window_mgr())) {
+		g_warning ("%s:\n'%s'\ndon't show dialogs if there's no main window;"
+			   " assuming 'Cancel' for questions, 'Ok' otherwise", prompt, __FUNCTION__);
+		return is_question ? FALSE : TRUE;
+	}
+
+	main_win = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (), FALSE);
+	g_return_val_if_fail (main_win, FALSE); /* should not happen */
 	
 	gboolean retval = TRUE;
 	if (is_question) {
@@ -1593,7 +1698,7 @@ modest_platform_run_alert_dialog (const gchar* prompt,
 		 * when it is a question.
 		 * Obviously, we need tinymail to use more specific error codes instead,
 		 * so we know what buttons to show. */
-		GtkWidget *dialog = GTK_WIDGET (hildon_note_new_confirmation (GTK_WINDOW (main_window), 
+		GtkWidget *dialog = GTK_WIDGET (hildon_note_new_confirmation (GTK_WINDOW (main_win), 
 									      prompt));
 		modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), 
 					     GTK_WINDOW (dialog));
@@ -1604,7 +1709,7 @@ modest_platform_run_alert_dialog (const gchar* prompt,
 		on_destroy_dialog (GTK_DIALOG(dialog));		
 	} else {
 	 	/* Just show the error text and use the default response: */
-	 	modest_platform_run_information_dialog (GTK_WINDOW (main_window), 
+	 	modest_platform_run_information_dialog (GTK_WINDOW (main_win), 
 							prompt);
 	}
 	return retval;