X-Git-Url: http://git.maemo.org/git/?p=modest;a=blobdiff_plain;f=src%2Fmodest-tny-folder.c;h=f654a4015af3b97e2eabcb20c86f3f4027c7db36;hp=1dfeefda86920ed71340a9382a6614b5ab7cb012;hb=4d39841513a3a7f7aa9d38ab97cb9fcc9171e80b;hpb=8aa037a33d83d2c05799e83182f09ac95e7fa618 diff --git a/src/modest-tny-folder.c b/src/modest-tny-folder.c index 1dfeefd..f654a40 100644 --- a/src/modest-tny-folder.c +++ b/src/modest-tny-folder.c @@ -30,81 +30,111 @@ #include #include #include +#include #include +#include #include #include #include #include -#include -#include #include #include +#include -TnyFolderType -modest_tny_folder_guess_folder_type_from_name (const gchar* name) -{ - gint type; - gchar *folder; - g_return_val_if_fail (name, TNY_FOLDER_TYPE_UNKNOWN); - - type = TNY_FOLDER_TYPE_UNKNOWN; - folder = g_utf8_strdown (name, strlen(name)); - -// if (strcmp (folder, "inbox") == 0 || -// strcmp (folder, _("inbox")) == 0 || -// strcmp (folder, _("mcen_me_folder_inbox")) == 0) -// type = TNY_FOLDER_TYPE_INBOX; - if (strcmp (folder, _("mcen_me_folder_outbox")) == 0) - type = TNY_FOLDER_TYPE_OUTBOX; -// else if (g_str_has_prefix(folder, "junk") || -// g_str_has_prefix(folder, _("junk"))) -// type = TNY_FOLDER_TYPE_JUNK; -// else if (g_str_has_prefix(folder, "trash") || -// g_str_has_prefix(folder, _("trash"))) -// type = TNY_FOLDER_TYPE_TRASH; - else if (strcmp (folder, _("mcen_me_folder_sent")) == 0) - type = TNY_FOLDER_TYPE_SENT; - else if (strcmp (folder, _("mcen_me_folder_drafts")) == 0) - type = TNY_FOLDER_TYPE_DRAFTS; -// else if (g_str_has_prefix(folder, "notes") || -// g_str_has_prefix(folder, _("notes"))) -// type = TNY_FOLDER_TYPE_NOTES; -// else if (g_str_has_prefix(folder, "contacts") || -// g_str_has_prefix(folder, _("contacts"))) -// type = TNY_FOLDER_TYPE_CONTACTS; -// else if (g_str_has_prefix(folder, "calendar") || -// g_str_has_prefix(folder, _("calendar"))) -// type = TNY_FOLDER_TYPE_CALENDAR; +/* make sure you use the *full* name, because foo/drafts is not the same as drafts */ +static TnyFolderType +modest_tny_folder_guess_folder_type_from_name (const gchar* full_name) +{ + g_return_val_if_fail (full_name, TNY_FOLDER_TYPE_INVALID); - g_free (folder); - return type; + if (strcmp (full_name, modest_local_folder_info_get_type_name(TNY_FOLDER_TYPE_OUTBOX)) == 0) + return TNY_FOLDER_TYPE_OUTBOX; + else if (strcmp (full_name, modest_local_folder_info_get_type_name(TNY_FOLDER_TYPE_DRAFTS)) == 0) + return TNY_FOLDER_TYPE_DRAFTS; + return + TNY_FOLDER_TYPE_NORMAL; } TnyFolderType -modest_tny_folder_guess_folder_type (const TnyFolder *folder) +modest_tny_folder_guess_folder_type (TnyFolder *folder) { TnyFolderType type; - g_return_val_if_fail (TNY_IS_FOLDER(folder), TNY_FOLDER_TYPE_UNKNOWN); + g_return_val_if_fail (TNY_IS_FOLDER(folder), TNY_FOLDER_TYPE_INVALID); - if (modest_tny_folder_is_local_folder ((TnyFolder*)folder)) - type = modest_tny_folder_get_local_or_mmc_folder_type ((TnyFolder*)folder); + if (modest_tny_folder_is_local_folder (folder) || + modest_tny_folder_is_memory_card_folder (folder)) + type = modest_tny_folder_get_local_or_mmc_folder_type (folder); else type = tny_folder_get_folder_type (TNY_FOLDER (folder)); + + /* Fallback code, some servers (Dovecot in some versions) + report incorrectly that the INBOX folder is a normal + folder. Really ugly code but... */ + if (type == TNY_FOLDER_TYPE_NORMAL) { + TnyFolderStore *parent = tny_folder_get_folder_store (folder); + if (parent) { + if (TNY_IS_ACCOUNT (parent)) { + gchar *downcase = + g_ascii_strdown (tny_camel_folder_get_full_name (TNY_CAMEL_FOLDER (folder)), + -1); + + if ((strlen (downcase) == 5) && + !strncmp (downcase, "inbox", 5)) + type = TNY_FOLDER_TYPE_INBOX; + if ((strlen (downcase) == 7) && + !strncmp (downcase, "archive", 7)) + type = TNY_FOLDER_TYPE_ARCHIVE; + g_free (downcase); + } + g_object_unref (parent); + } + } if (type == TNY_FOLDER_TYPE_UNKNOWN) { - const gchar *folder_name; - folder_name = tny_folder_get_name (TNY_FOLDER (folder)); + const gchar *folder_name = + tny_camel_folder_get_full_name (TNY_CAMEL_FOLDER (folder)); type = modest_tny_folder_guess_folder_type_from_name (folder_name); } + if (type == TNY_FOLDER_TYPE_INVALID) + g_warning ("%s: BUG: TNY_FOLDER_TYPE_INVALID", __FUNCTION__); + return type; } +const gchar* +modest_tny_folder_get_help_id (TnyFolder *folder) +{ + TnyFolderType type; + const gchar* help_id = NULL; + + g_return_val_if_fail (folder, NULL); + g_return_val_if_fail (TNY_IS_FOLDER(folder), NULL); + + type = modest_tny_folder_guess_folder_type (TNY_FOLDER (folder)); + + switch (type) { + case TNY_FOLDER_TYPE_NORMAL: help_id = "applications_email_managefolders"; break; + case TNY_FOLDER_TYPE_INBOX: help_id = "applications_email_inbox";break; + case TNY_FOLDER_TYPE_OUTBOX: help_id = "applications_email_outbox";break; + case TNY_FOLDER_TYPE_SENT: help_id = "applications_email_sent"; break; + case TNY_FOLDER_TYPE_DRAFTS: help_id = "applications_email_drafts";break; + case TNY_FOLDER_TYPE_ARCHIVE: help_id = "applications_email_managefolders";break; + + case TNY_FOLDER_TYPE_INVALID: g_warning ("%s: BUG: TNY_FOLDER_TYPE_INVALID", __FUNCTION__);break; + default: g_warning ("%s: BUG: unexpected folder type (%d)", __FUNCTION__, type); + } + + return help_id; +} + + + /* FIXME: encode all folder rules here */ ModestTnyFolderRules modest_tny_folder_get_rules (TnyFolder *folder) @@ -113,11 +143,12 @@ modest_tny_folder_get_rules (TnyFolder *folder) TnyFolderType type; g_return_val_if_fail (TNY_IS_FOLDER(folder), -1); - + if (modest_tny_folder_is_local_folder (folder) || modest_tny_folder_is_memory_card_folder (folder)) { type = modest_tny_folder_get_local_or_mmc_folder_type (folder); + g_return_val_if_fail (type != TNY_FOLDER_TYPE_INVALID, -1); switch (type) { case TNY_FOLDER_TYPE_OUTBOX: @@ -141,17 +172,20 @@ modest_tny_folder_get_rules (TnyFolder *folder) break; } } else { - ModestTransportStoreProtocol proto; + ModestProtocolRegistry *protocol_registry; + ModestProtocolType protocol_type; TnyFolderType folder_type; TnyAccount *account; + protocol_registry = modest_runtime_get_protocol_registry (); + account = modest_tny_folder_get_account ((TnyFolder*)folder); if (!account) return -1; /* no account: nothing is allowed */ - proto = modest_protocol_info_get_transport_store_protocol (tny_account_get_proto (account)); + protocol_type = modest_tny_account_get_protocol_type (account); - if (proto == MODEST_PROTOCOL_STORE_IMAP) { + if (modest_protocol_registry_protocol_type_has_tag (protocol_registry, protocol_type, MODEST_PROTOCOL_REGISTRY_STORE_HAS_FOLDERS)) { rules = 0; } else { /* pop, nntp, ... */ @@ -166,6 +200,8 @@ modest_tny_folder_get_rules (TnyFolder *folder) /* Neither INBOX nor ROOT, nor ARCHIVE folders should me moveable */ folder_type = modest_tny_folder_guess_folder_type (folder); + g_return_val_if_fail (folder_type != TNY_FOLDER_TYPE_INVALID, -1); + if ((folder_type == TNY_FOLDER_TYPE_INBOX) || (folder_type == TNY_FOLDER_TYPE_ROOT) || (folder_type == TNY_FOLDER_TYPE_ARCHIVE)) { @@ -223,9 +259,9 @@ gboolean modest_tny_folder_is_memory_card_folder (TnyFolder *folder) { g_return_val_if_fail (folder, FALSE); - - /* The merge folder is a special case, - * used to merge the per-account local outbox folders. + + /* The merge folder is a special case, + * used to merge the per-account local outbox folders. * and can have no get_account() implementation. */ if (TNY_IS_MERGE_FOLDER (folder)) @@ -236,20 +272,22 @@ modest_tny_folder_is_memory_card_folder (TnyFolder *folder) return FALSE; const gchar* account_id = tny_account_get_id (account); - if (!account_id) + if (!account_id) { + g_object_unref (account); return FALSE; + } + + g_object_unref (account); - g_object_unref (G_OBJECT(account)); - return (strcmp (account_id, MODEST_MMC_ACCOUNT_ID) == 0); -} +} gboolean modest_tny_folder_is_remote_folder (TnyFolder *folder) { gboolean is_local = TRUE; - g_return_val_if_fail (folder, FALSE); + g_return_val_if_fail (TNY_IS_FOLDER(folder), FALSE); is_local = ((modest_tny_folder_is_local_folder(folder)) || (modest_tny_folder_is_memory_card_folder(folder))); @@ -258,13 +296,14 @@ modest_tny_folder_is_remote_folder (TnyFolder *folder) return !is_local; } + TnyFolderType modest_tny_folder_get_local_or_mmc_folder_type (TnyFolder *folder) { - g_return_val_if_fail (folder, TNY_FOLDER_TYPE_UNKNOWN); + g_return_val_if_fail (folder, TNY_FOLDER_TYPE_INVALID); g_return_val_if_fail (modest_tny_folder_is_local_folder(folder)|| modest_tny_folder_is_memory_card_folder(folder), - TNY_FOLDER_TYPE_UNKNOWN); + TNY_FOLDER_TYPE_INVALID); /* The merge folder is a special case, * used to merge the per-account local outbox folders. @@ -291,13 +330,9 @@ modest_tny_folder_get_local_or_mmc_folder_type (TnyFolder *folder) * _full name_, that is, the full path name of the folder, * to distinguish between 'Outbox' and 'myfunkyfolder/Outbox' */ - CamelFolder *camel_folder = tny_camel_folder_get_folder (TNY_CAMEL_FOLDER(folder)); - if (!camel_folder) - return TNY_FOLDER_TYPE_UNKNOWN; - const gchar *full_name = camel_folder_get_full_name (camel_folder); + const gchar *full_name = tny_camel_folder_get_full_name (TNY_CAMEL_FOLDER (folder)); /* printf ("DEBUG: %s: full_name=%s\n", __FUNCTION__, full_name); */ - camel_object_unref (CAMEL_OBJECT(camel_folder)); if (!full_name) return TNY_FOLDER_TYPE_UNKNOWN; @@ -315,25 +350,6 @@ modest_tny_folder_is_outbox_for_account (TnyFolder *folder, TnyAccount *account) return FALSE; return TRUE; -#if 0 - /* we need to use the camel functions, because we want the - * _full name_, that is, the full path name of the folder, - * to distinguis between 'Outbox' and 'myfunkyfolder/Outbox' - */ - CamelFolder *camel_folder = tny_camel_folder_get_folder (TNY_CAMEL_FOLDER(folder)); - if (!camel_folder) - return FALSE; - - const gchar *full_name = camel_folder_get_full_name (camel_folder); - camel_object_unref (CAMEL_OBJECT(camel_folder)); - - if (!full_name) - return TNY_FOLDER_TYPE_UNKNOWN; - else - return modest_local_folder_info_get_type (full_name); - - return FALSE; -#endif } gchar* @@ -341,7 +357,7 @@ modest_tny_folder_get_header_unique_id (TnyHeader *header) { TnyFolder *folder; gchar *url, *retval; - const gchar *uid; + gchar *uid; g_return_val_if_fail (TNY_IS_HEADER (header), NULL); @@ -350,9 +366,10 @@ modest_tny_folder_get_header_unique_id (TnyHeader *header) return NULL; url = tny_folder_get_url_string (folder); - uid = tny_header_get_uid (header); + uid = tny_header_dup_uid (header); retval = g_strjoin ("/", url, uid, NULL); + g_free (uid); g_free (url); g_object_unref (folder); @@ -364,6 +381,8 @@ TnyAccount * modest_tny_folder_get_account (TnyFolder *folder) { TnyAccount *account = NULL; + + g_return_val_if_fail (TNY_IS_FOLDER(folder), NULL); if (TNY_IS_MERGE_FOLDER (folder)) { /* TnyMergeFolder does not support get_account(), @@ -378,40 +397,174 @@ modest_tny_folder_get_account (TnyFolder *folder) return account; } -gboolean -modest_tny_folder_same_subfolder (TnyFolderStore *parent, - const gchar *new_name) +/* + * It's probably better to use a query to get the folders that match + * new_name but currently tinymail only provides a match by name using + * regular expressions and we want an exact matching. We're not using + * a regular expression for the exact name because we'd need first to + * escape @new_name and it's not easy sometimes. + * + * The code that uses the query is available in revision 3152. + */ +gboolean +modest_tny_folder_has_subfolder_with_name (TnyFolderStore *parent, + const gchar *new_name, + gboolean non_strict) { TnyList *subfolders = NULL; TnyIterator *iter = NULL; TnyFolder *folder = NULL; GError *err = NULL; - const gchar *name = NULL; - gboolean same_subfolder = FALSE; + gboolean has_name = FALSE; g_return_val_if_fail (TNY_IS_FOLDER_STORE (parent), FALSE); + g_return_val_if_fail (new_name, FALSE); /* Get direct subfolders */ subfolders = tny_simple_list_new (); - tny_folder_store_get_folders (parent, subfolders, NULL, &err); + tny_folder_store_get_folders (parent, subfolders, NULL, FALSE, &err); /* Check names */ iter = tny_list_create_iterator (subfolders); - while (!tny_iterator_is_done (iter) && !same_subfolder) { - folder = TNY_FOLDER(tny_iterator_get_current (iter)); + while (!tny_iterator_is_done (iter) && !has_name) { + + const gchar *name; + + folder = (TnyFolder*)tny_iterator_get_current (iter); + if (!folder || ! TNY_IS_FOLDER(folder)) { + g_warning ("%s: invalid folder", __FUNCTION__); + tny_iterator_next (iter); + continue; + } + name = tny_folder_get_name (folder); - - same_subfolder = !strcmp(name, new_name); + if (!name) { + g_warning ("%s: folder name == NULL", __FUNCTION__); + g_object_unref (folder); + tny_iterator_next (iter); + continue; + } + + /* is it simply the same folder name? */ + if (strcmp (name, new_name) == 0) + has_name = TRUE; + /* or is it the same when ignoring case (non-strict mode)? */ + else if (non_strict && modest_text_utils_utf8_strcmp (name, new_name, TRUE) == 0) + has_name = TRUE; + /* or is the name equal to the display name of some folder, in the current locale? */ + else if (non_strict) { + TnyFolderType type = modest_tny_folder_guess_folder_type (folder); + if (type != TNY_FOLDER_TYPE_INVALID && type != TNY_FOLDER_TYPE_NORMAL) + has_name = !(modest_text_utils_utf8_strcmp (modest_local_folder_info_get_type_display_name (type), + new_name, + TRUE)); + } else { + has_name = FALSE; + } g_object_unref (folder); tny_iterator_next(iter); } - + /* free */ - if (iter != NULL) - g_object_unref (iter); - if (subfolders != NULL) - g_object_unref (subfolders); - - return same_subfolder; + g_object_unref (iter); + g_object_unref (subfolders); + + return has_name; +} + +gboolean +modest_tny_folder_is_ancestor (TnyFolder *folder, + TnyFolderStore *ancestor) +{ + TnyFolderStore *tmp = NULL; + gboolean found = FALSE; + + tmp = TNY_FOLDER_STORE (folder); + while (!found && tmp && !TNY_IS_ACCOUNT (tmp)) { + TnyFolderStore *folder_store; + + folder_store = tny_folder_get_folder_store (TNY_FOLDER (tmp)); + if (ancestor == folder_store) + found = TRUE; + else + tmp = folder_store; + g_object_unref (folder_store); + } + return found; +} + +gchar * +modest_tny_folder_get_display_name (TnyFolder *folder) +{ + TnyFolderType type = TNY_FOLDER_TYPE_UNKNOWN; + gchar *fname; + + g_return_val_if_fail (TNY_IS_FOLDER (folder), NULL); + + fname = g_strdup (tny_folder_get_name (folder)); + type = tny_folder_get_folder_type (folder); + + if (modest_tny_folder_is_local_folder (TNY_FOLDER (folder)) || + modest_tny_folder_is_memory_card_folder (TNY_FOLDER (folder))) { + type = modest_tny_folder_get_local_or_mmc_folder_type (TNY_FOLDER (folder)); + if (type != TNY_FOLDER_TYPE_UNKNOWN) { + g_free (fname); + fname = g_strdup (modest_local_folder_info_get_type_display_name (type)); + } + } else { + /* Sometimes an special folder is reported by the server as + NORMAL, like some versions of Dovecot */ + if (type == TNY_FOLDER_TYPE_NORMAL || + type == TNY_FOLDER_TYPE_UNKNOWN) { + type = modest_tny_folder_guess_folder_type (TNY_FOLDER (folder)); + } + } + + if (type == TNY_FOLDER_TYPE_INBOX) { + g_free (fname); + fname = g_strdup (_("mcen_me_folder_inbox")); + } + + return fname; +} + +TnyFolder * +modest_tny_folder_store_find_folder_from_uri (TnyFolderStore *folder_store, const gchar *uri) +{ + TnyList *children; + TnyIterator *iterator; + TnyFolder *result; + + result = NULL; + children = TNY_LIST (tny_simple_list_new ()); + tny_folder_store_get_folders (folder_store, children, NULL, FALSE, NULL); + + for (iterator = tny_list_create_iterator (children); + !tny_iterator_is_done (iterator) && (result == NULL); + tny_iterator_next (iterator)) { + TnyFolderStore *child; + + child = TNY_FOLDER_STORE (tny_iterator_get_current (iterator)); + + if (TNY_IS_FOLDER (child)) { + gchar *folder_url; + + folder_url = tny_folder_get_url_string (TNY_FOLDER (child)); + if (g_str_has_prefix (uri, folder_url)) + result = g_object_ref (child); + g_free (folder_url); + } + + if ((child == NULL) && TNY_IS_FOLDER_STORE (child)) { + result = modest_tny_folder_store_find_folder_from_uri (child, uri); + } + + g_object_unref (child); + } + + g_object_unref (iterator); + g_object_unref (children); + + return result; }