X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fmodest-tny-account-store.c;h=5c3385fcf1e2c1ead8c73bfa2138f0672a9135af;hp=8c7191dae0c32b77703d2406ad8e5ec4ad644fef;hb=96d9a8c787c693406a0f26e3d3a00065c7236fe5;hpb=92fc8170d07ed579d31098da356f46757d6aa7f7

diff --git a/src/modest-tny-account-store.c b/src/modest-tny-account-store.c
index 8c7191d..5c3385f 100644
--- a/src/modest-tny-account-store.c
+++ b/src/modest-tny-account-store.c
@@ -73,6 +73,10 @@ static void    modest_tny_account_store_instance_init (ModestTnyAccountStore *ob
 static void    modest_tny_account_store_init          (gpointer g, gpointer iface_data);
 
 
+static void
+get_server_accounts  (TnyAccountStore *self, TnyList *list, TnyAccountType type);
+
+
 /* list my signals */
 enum {
 	ACCOUNT_UPDATE_SIGNAL,
@@ -88,9 +92,17 @@ struct _ModestTnyAccountStorePrivate {
 	TnySessionCamel    *session;
 	TnyDevice          *device;
 	
-	/* we cache them here */
+	/* We cache the lists of accounts here.
+	 * They are created in our get_accounts_func() implementation. */
 	GSList             *store_accounts;
 	GSList             *transport_accounts;
+	
+	/* This is also contained in store_accounts,
+	 * but we cached it temporarily separately, 
+	 * because we create this while creating the transport accounts, 
+	 * but return it when requesting the store accounts: 
+	 */
+	GSList             *store_accounts_outboxes;
 };
 
 #define MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
@@ -218,12 +230,16 @@ on_account_removed (ModestAccountMgr *acc_mgr, const gchar *account, gboolean se
 	 * accounts, and some do not affect tny accounts at all (such as 'last_update')
 	 */
 	
-	
 	account_list_free (priv->store_accounts);
-	priv->store_accounts = NULL;
+	get_server_accounts (TNY_ACCOUNT_STORE(self), NULL, TNY_ACCOUNT_TYPE_STORE);
 	
 	account_list_free (priv->transport_accounts);
-	priv->transport_accounts = NULL;
+	get_server_accounts (TNY_ACCOUNT_STORE(self), NULL,
+							TNY_ACCOUNT_TYPE_TRANSPORT);
+		
+	/* TODO: Ref these when we add them? */
+	g_slist_free (priv->store_accounts_outboxes);
+	priv->store_accounts_outboxes = NULL;
 	
 	g_signal_emit (G_OBJECT(self), signals[ACCOUNT_UPDATE_SIGNAL], 0,
 		       account);
@@ -232,7 +248,7 @@ on_account_removed (ModestAccountMgr *acc_mgr, const gchar *account, gboolean se
 
 static void
 on_account_changed (ModestAccountMgr *acc_mgr, const gchar *account,
-			       const gchar *key, gboolean server_account, gpointer user_data)
+		    const gchar *key, gboolean server_account, gpointer user_data)
 
 {
 	ModestTnyAccountStore *self = MODEST_TNY_ACCOUNT_STORE(user_data);
@@ -241,14 +257,20 @@ on_account_changed (ModestAccountMgr *acc_mgr, const gchar *account,
 	/* FIXME: make this more finegrained; changes do not really affect _all_
 	 * accounts, and some do not affect tny accounts at all (such as 'last_update')
 	 */
-	if (priv->store_accounts) {
-		account_list_free (priv->store_accounts);
-		priv->store_accounts = NULL;
-	}
-	
-	if (priv->transport_accounts) {
-		account_list_free (priv->transport_accounts);
-		priv->transport_accounts = NULL;
+	if (server_account) {
+		if (priv->store_accounts) {
+			account_list_free (priv->store_accounts);
+			priv->store_accounts = NULL;
+			get_server_accounts (TNY_ACCOUNT_STORE(self),
+						     NULL, TNY_ACCOUNT_TYPE_STORE);
+		}
+		
+		if (priv->transport_accounts) {
+			account_list_free (priv->transport_accounts);
+			priv->transport_accounts = NULL;
+			get_server_accounts (TNY_ACCOUNT_STORE(self), NULL,
+						     TNY_ACCOUNT_TYPE_TRANSPORT);
+		}
 	}
 
 	g_signal_emit (G_OBJECT(self), signals[ACCOUNT_UPDATE_SIGNAL], 0,
@@ -269,6 +291,10 @@ get_account_store_for_account (TnyAccount *account)
 static gchar*
 get_password (TnyAccount *account, const gchar *prompt, gboolean *cancel)
 {
+	/* Initialize the output parameter: */
+	if (cancel)
+	  *cancel = FALSE;
+	  
 	const gchar *key;
 	const TnyAccountStore *account_store;
 	ModestTnyAccountStore *self;
@@ -341,10 +367,12 @@ get_password (TnyAccount *account, const gchar *prompt, gboolean *cancel)
 	return pwd;
 }
 
-
+/* tinymail calls this if the connection failed due to an incorrect password.
+ * And it seems to call this for any general connection failure. */
 static void
 forget_password (TnyAccount *account)
 {
+	printf ("DEBUG: %s\n", __FUNCTION__);
 	ModestTnyAccountStore *self;
 	ModestTnyAccountStorePrivate *priv;
 	const TnyAccountStore *account_store;
@@ -449,7 +477,7 @@ modest_tny_account_store_new (ModestAccountMgr *account_mgr, TnyDevice *device)
 	return MODEST_TNY_ACCOUNT_STORE(obj);
 }
 
-
+/** Fill the TnyList from the appropriate cached GSList of accounts. */
 static void
 get_cached_accounts (TnyAccountStore *self, TnyList *list, TnyAccountType type)
 {
@@ -466,29 +494,85 @@ get_cached_accounts (TnyAccountStore *self, TnyList *list, TnyAccountType type)
 	}
 }
 
+static void
+create_per_account_local_outbox_folders (TnyAccountStore *self)
+{
+	g_return_if_fail (self);
+	
+	ModestTnyAccountStorePrivate *priv = 
+		MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+	
+	/* printf("DEBUG: %s: priv->store_accounts_outboxes = %p\n", __FUNCTION__, priv->store_accounts_outboxes); */
+		
+	if (priv->store_accounts_outboxes) {
+			return;
+	}
+	
+	/* Create the transport accounts, if necessary: */
+	if (!(priv->transport_accounts)) {
+		get_server_accounts (self, NULL /* TnyList */, 
+			TNY_ACCOUNT_TYPE_TRANSPORT);
+	}
+	
+	GSList *accounts = NULL;
+	
+	GSList *account_names  = modest_account_mgr_account_names (priv->account_mgr, 
+		TRUE /* including disabled accounts */);
+	
+	GSList *iter = account_names;
+	for (iter = priv->transport_accounts; iter; iter = g_slist_next (iter)) {
+		
+		TnyAccount *transport_account = (TnyAccount*)iter->data;
+		
+		/* Create a per-account local outbox folder (a _store_ account) 
+		 * for each _transport_ account: */
+		TnyAccount *tny_account_outbox =
+			modest_tny_account_new_for_per_account_local_outbox_folder (
+				priv->account_mgr, transport_account, priv->session);
+				
+		accounts = g_slist_append (accounts, tny_account_outbox); /* cache it */
+	};
+	
+	priv->store_accounts_outboxes = accounts;
+}
 
-
-/* this function fills the TnyList, and also returns a GSList of the accounts,
- * for caching purposes
+/* This function fills the TnyList, and also stores a GSList of the accounts,
+ * for caching purposes. It creates the TnyAccount objects if necessary.
+ * The @list parameter may be NULL, if you just want to fill the cache.
  */
-static GSList*
-get_accounts  (TnyAccountStore *self, TnyList *list, TnyAccountType type)
+static void
+get_server_accounts  (TnyAccountStore *self, TnyList *list, TnyAccountType type)
 {
-	ModestTnyAccountStorePrivate *priv = NULL;
-	GSList                       *account_names = NULL, *cursor = NULL;
-	GSList                       *accounts = NULL;
+	g_return_if_fail (self);
 	
-	priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
- 
-	account_names = modest_account_mgr_account_names (priv->account_mgr, 
-		TRUE /* including disabled accounts */);
+	/* printf ("DEBUG: %s: list=%p, type=%d\n", __FUNCTION__, list, type); */
+		
+	ModestTnyAccountStorePrivate *priv = 
+		MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+		
+	/* Do nothing if the accounts are already cached: */
+	if (type == TNY_ACCOUNT_TYPE_STORE) {
+			if (priv->store_accounts)
+				return;
+	} else if (type == TNY_ACCOUNT_TYPE_TRANSPORT) {
+			if (priv->transport_accounts)
+				return;
+	}
 	
+	GSList                       *account_names = NULL, *cursor = NULL;
+	GSList                       *accounts = NULL;
+
+	/* these account names, not server_account names */
+	account_names = modest_account_mgr_account_names (priv->account_mgr,FALSE);
+		
 	for (cursor = account_names; cursor; cursor = cursor->next) {
 		
 		gchar *account_name = (gchar*)cursor->data;
 		
-		/* only return enabled accounts */
+		/* we get the server_accounts for enabled accounts */
 		if (modest_account_mgr_get_enabled(priv->account_mgr, account_name)) {
+				
+			/* Add the account: */
 			TnyAccount *tny_account = 
 				modest_tny_account_new_from_account (priv->account_mgr,
 								     account_name,
@@ -498,24 +582,70 @@ get_accounts  (TnyAccountStore *self, TnyList *list, TnyAccountType type)
 			if (tny_account) {
 				g_object_set_data (G_OBJECT(tny_account), "account_store",
 						   (gpointer)self);
-				tny_list_prepend (list, G_OBJECT(tny_account));
-				accounts = g_slist_append (accounts, tny_account); /* cache it */
+				if (list)
+					tny_list_prepend (list, G_OBJECT(tny_account));
+				
+				accounts = g_slist_append (accounts, tny_account); /* cache it */		
 			} else
 				g_printerr ("modest: failed to create account for %s\n",
 					    account_name);
-		}
+			}
 		g_free (account_name);
 	}
 	g_slist_free (account_names);
-
-	/* also, add the local folder pseudo-account */
+	
 	if (type == TNY_ACCOUNT_TYPE_STORE) {
+		/* Also add the local folder pseudo-account: */
 		TnyAccount *tny_account =
 			modest_tny_account_new_for_local_folders (priv->account_mgr, priv->session);
-		tny_list_prepend (list, G_OBJECT(tny_account));
+		if (list)
+			tny_list_prepend (list, G_OBJECT(tny_account));
 		accounts = g_slist_append (accounts, tny_account); /* cache it */
-	}	
-	return accounts;
+	}
+	
+	/* Do this here, in case create_per_account_local_outbox_folders() needs it. */
+	if (type == TNY_ACCOUNT_TYPE_TRANSPORT) {
+			/* Store the cache: */
+			priv->transport_accounts = accounts;
+	}
+	
+	/* We also create a per-account local outbox folder (a _store_ account) 
+	 * for each _transport_ account. */
+	if (type == TNY_ACCOUNT_TYPE_TRANSPORT) {
+		/* Now would be a good time to create the per-account local outbox folder 
+		 * _store_ accounts corresponding to each transport account: */
+		if (!priv->store_accounts_outboxes) {
+			create_per_account_local_outbox_folders	(self);
+		}
+	}
+	
+	/* But we only return the per-account local outbox folder when 
+	 * _store_ accounts are requested. */
+	if (type == TNY_ACCOUNT_TYPE_STORE) {
+		/* Create them if necessary, 
+		 * (which also requires creating the transport accounts, 
+		 * if necessary.) */
+		if (!priv->store_accounts_outboxes) {
+			create_per_account_local_outbox_folders	(self);
+		}
+	
+		/* Add them to the TnyList: */
+		if (priv->store_accounts_outboxes) {
+			GSList *iter = NULL;
+			for (iter = priv->store_accounts_outboxes; iter; iter = g_slist_next (iter)) {
+				TnyAccount *outbox_account = (TnyAccount*)iter->data;
+				if (list && outbox_account)
+					tny_list_prepend (list,  G_OBJECT(outbox_account));
+					
+				accounts = g_slist_append (accounts, outbox_account);
+			}
+		}
+	}
+		
+	if (type == TNY_ACCOUNT_TYPE_STORE) {
+			/* Store the cache: */
+			priv->store_accounts = accounts;
+	}
 }	
 
 
@@ -539,17 +669,14 @@ modest_tny_account_store_get_accounts  (TnyAccountStore *self, TnyList *list,
 	}
 	
 	if (request_type == TNY_ACCOUNT_STORE_STORE_ACCOUNTS)  {
-		
 		if (!priv->store_accounts)
-			priv->store_accounts = get_accounts (self, list, TNY_ACCOUNT_TYPE_STORE);
+			get_server_accounts (self, list, TNY_ACCOUNT_TYPE_STORE);
 		else
 			get_cached_accounts (self, list, TNY_ACCOUNT_TYPE_STORE);
-
+		
 	} else if (request_type == TNY_ACCOUNT_STORE_TRANSPORT_ACCOUNTS) {
-
 		if (!priv->transport_accounts)
-			priv->transport_accounts =
-				get_accounts (self, list, TNY_ACCOUNT_TYPE_TRANSPORT);
+			get_server_accounts (self, list, TNY_ACCOUNT_TYPE_TRANSPORT);
 		else
 			get_cached_accounts (self, list, TNY_ACCOUNT_TYPE_TRANSPORT);
 	} else
@@ -627,7 +754,7 @@ modest_tny_account_store_find_account_by_url (TnyAccountStore *self, const gchar
 
 static gboolean
 modest_tny_account_store_alert (TnyAccountStore *self, TnyAlertType type,
-				const GError *error)
+				gboolean question, const GError *error)
 {
 	g_return_val_if_fail (error, FALSE);
 
@@ -641,10 +768,9 @@ modest_tny_account_store_alert (TnyAccountStore *self, TnyAlertType type,
 	/* printf("DEBUG: %s: error->message=%s\n", __FUNCTION__, error->message); */
 	
 
-	
-	const gchar *prompt = NULL;
-	switch (error->code)
-	{
+	/* const gchar *prompt = NULL; */
+	gchar *prompt = NULL;
+	switch (error->code) {
 		case TNY_ACCOUNT_ERROR_TRY_CONNECT:
 		/* The tinymail camel implementation just sends us this for almost 
 		 * everything, so we have to guess at the cause.
@@ -653,7 +779,12 @@ modest_tny_account_store_alert (TnyAccountStore *self, TnyAlertType type,
 		case TNY_ACCOUNT_STORE_ERROR_UNKNOWN_ALERT: 
 		    g_debug ("%s: Handling GError domain=%d, code=%d, message=%s", 
 				__FUNCTION__, error->domain, error->code, error->message);
-			prompt = _("Modest account not yet fully configured.");
+			
+			/* TODO: Remove the internal error message for the real release.
+			 * This is just so the testers can give us more information: */
+			/* prompt = _("Modest account not yet fully configured."); */
+			prompt = g_strdup_printf(_("Modest account not yet fully configured. Error=%s"), 
+				error->message);
 			break;
 		default:
 			g_warning ("%s: Unhandled GError code: %d, message=%s", 
@@ -665,11 +796,19 @@ modest_tny_account_store_alert (TnyAccountStore *self, TnyAlertType type,
 	if (!prompt)
 		return FALSE;
 
-	gboolean retval = FALSE;
 #ifdef MODEST_PLATFORM_MAEMO
 	/* The Tinymail documentation says that we should show Yes and No buttons, 
-	 * but these never seem to be questions: */
-	 GtkWidget *dialog = GTK_WIDGET (hildon_note_new_information (NULL, 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 = NULL;
+	 if (question) {
+	 	dialog = GTK_WIDGET (hildon_note_new_confirmation (NULL, 
+	 		prompt));
+	 } else {
+	 	dialog = GTK_WIDGET (hildon_note_new_information (NULL, 
+	 		prompt));
+	 }
 #else
 
 	GtkMessageType gtktype = GTK_MESSAGE_ERROR;
@@ -691,11 +830,20 @@ modest_tny_account_store_alert (TnyAccountStore *self, TnyAlertType type,
 		gtktype, GTK_BUTTONS_YES_NO, prompt);
 #endif /* #ifdef MODEST_PLATFORM_MAEMO */
 
-	if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_YES)
-		retval = TRUE;
+	gboolean retval = TRUE;
+	const int response = gtk_dialog_run (GTK_DIALOG (dialog));
+	if (question) {
+		retval = (response == GTK_RESPONSE_YES) ||
+				 (response == GTK_RESPONSE_OK);	
+	}
 
 	gtk_widget_destroy (dialog);
+	
+	/* TODO: Don't free this when we no longer strdup the message for testers. */
+	g_free (prompt);
 
+
+	printf("DEBUG: %s: returning %d\n", __FUNCTION__, retval);
 	return retval;
 }
 
@@ -730,7 +878,7 @@ modest_tny_account_store_set_get_pass_func (ModestTnyAccountStore *self,
 }
 
 TnySessionCamel*
-tny_account_store_get_session  (TnyAccountStore *self)
+modest_tny_account_store_get_session  (TnyAccountStore *self)
 {
 	g_return_val_if_fail (self, NULL);
 	return MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self)->session;
@@ -749,14 +897,15 @@ modest_tny_account_store_get_tny_account_by_id  (ModestTnyAccountStore *self, co
 	
 	priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
 
+
 	for (cursor = priv->store_accounts; cursor ; cursor = cursor->next) {
 		const gchar *acc_id = tny_account_get_id (TNY_ACCOUNT(cursor->data));
-		if (acc_id && strcmp (acc_id, id) == 0) { 
+		if (acc_id && strcmp (acc_id, id) == 0) {
 			account = TNY_ACCOUNT(cursor->data);
 			break;
 		}
 	}
-
+		
 	/* if we already found something, no need to search the transport accounts */
 	for (cursor = priv->transport_accounts; !account && cursor ; cursor = cursor->next) {
 		const gchar *acc_id = tny_account_get_id (TNY_ACCOUNT(cursor->data));
@@ -778,8 +927,7 @@ modest_tny_account_store_get_tny_account_by_account (ModestTnyAccountStore *self
 						     TnyAccountType type)
 {
 	TnyAccount *account = NULL;
-	ModestAccountData *account_data;
-	const gchar *id = NULL;
+	gchar *id = NULL;
 	ModestTnyAccountStorePrivate *priv;	
 
 	g_return_val_if_fail (self, NULL);
@@ -788,17 +936,26 @@ modest_tny_account_store_get_tny_account_by_account (ModestTnyAccountStore *self
 			      NULL);
 	
 	priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
-	
-	account_data = modest_account_mgr_get_account_data (priv->account_mgr, account_name);
-	if (!account_data) {
-		g_printerr ("modest: cannot get account data for account '%s'\n", account_name);
-		return NULL;
-	}
 
-	if (type == TNY_ACCOUNT_TYPE_STORE && account_data->store_account)
-		id = account_data->store_account->account_name;
-	else if (account_data->transport_account)
-		id = account_data->transport_account->account_name;
+	/* Special case for the local account */
+	if (!strcmp (account_name, MODEST_ACTUAL_LOCAL_FOLDERS_ACCOUNT_ID)) {
+		id = g_strdup (MODEST_ACTUAL_LOCAL_FOLDERS_ACCOUNT_ID);
+	} else {
+		ModestAccountData *account_data;
+
+		account_data = modest_account_mgr_get_account_data (priv->account_mgr, account_name);
+		if (!account_data) {
+			g_printerr ("modest: cannot get account data for account '%s'\n", account_name);
+			return NULL;
+		}
+
+		if (type == TNY_ACCOUNT_TYPE_STORE && account_data->store_account)
+			id = g_strdup (account_data->store_account->account_name);
+		else if (account_data->transport_account)
+			id = g_strdup (account_data->transport_account->account_name);
+
+		modest_account_mgr_free_account_data (priv->account_mgr, account_data);
+	}
 
 	if (!id)
 		g_printerr ("modest: could not get an id for account %s\n",
@@ -811,11 +968,12 @@ modest_tny_account_store_get_tny_account_by_account (ModestTnyAccountStore *self
 			    type == TNY_ACCOUNT_TYPE_STORE? "store" : "transport",
 			    account_name, id ? id : "<none>");
 
-	modest_account_mgr_free_account_data (priv->account_mgr, account_data);
 	return account;	
 }
 
-static TnyAccount* get_smtp_specific_transport_account_for_open_connection (ModestTnyAccountStore *self, const gchar *account_name)
+static TnyAccount*
+get_smtp_specific_transport_account_for_open_connection (ModestTnyAccountStore *self,
+							 const gchar *account_name)
 {
 	/* Get the current connection: */
 	TnyDevice *device = modest_runtime_get_device ();
@@ -859,8 +1017,9 @@ static TnyAccount* get_smtp_specific_transport_account_for_open_connection (Mode
 }
 
 								 
-TnyAccount* modest_tny_account_store_get_transport_account_for_open_connection (ModestTnyAccountStore *self,
-								 const gchar *account_name)
+TnyAccount*
+modest_tny_account_store_get_transport_account_for_open_connection (ModestTnyAccountStore *self,
+								    const gchar *account_name)
 {
 	/*  Get the connection-specific transport acccount, if any: */
 	TnyAccount *account = get_smtp_specific_transport_account_for_open_connection (self, account_name);
@@ -874,3 +1033,10 @@ TnyAccount* modest_tny_account_store_get_transport_account_for_open_connection (
 			     
 	return account;
 }
+
+gboolean modest_tny_folder_store_is_virtual_local_folders (TnyFolderStore *self)
+{
+	/* We should make this more sophisticated if we ever use ModestTnySimpleFolderStore 
+	 * for anything else. */
+	return MODEST_IS_TNY_SIMPLE_FOLDER_STORE (self);
+}