/**
* compare_source_names
* Compares sources by name.
**/
static gint
compare_source_names (gconstpointer a, gconstpointer b)
{
g_return_val_if_fail (E_IS_SOURCE (a), -1);
g_return_val_if_fail (E_IS_SOURCE (b), 1);
return g_utf8_collate (e_source_peek_name (E_SOURCE (a)), e_source_peek_name (E_SOURCE (b)));
}
static ESource *
get_source (ESourceList *list)
{
CamelURL *url;
gchar *url_string;
GSList *p, *l;
gchar **temp;
gchar *uri;
/* FIXME Wow... just... wow. If ever one needed proof that
* URL-based accounts were a bad idea, here ya go. */
url = g_malloc0 (sizeof (CamelURL));
camel_settings_save_to_url (settings, url);
url_string = camel_url_to_string (url, 0);
temp = g_strsplit (url_string, ";", -1);
g_free (url_string);
camel_url_free (url);
uri = temp[0];
l = e_source_list_peek_groups (list);
for (p = l; p != NULL; p = p->next) {
gchar *so_uri;
GSList *r, *s;
ESourceGroup *group = E_SOURCE_GROUP (p->data);
s = e_source_group_peek_sources (group);
for (r = s; r != NULL; r = r->next) {
ESource *so = E_SOURCE (r->data);
so_uri = e_source_get_uri (so);
if (so_uri) {
if (!strcmp (so_uri, uri)) {
g_free (so_uri), so_uri = NULL;
g_strfreev (temp);
return E_SOURCE (r->data);
}
g_free (so_uri), so_uri = NULL;
}
}
}
g_strfreev (temp);
return NULL;
}
GList *
evo_environment_list_cal_sources(ECalSourceType type)
{
GList *paths = NULL;
ESourceList *sources = NULL;
ESource *source = NULL;
if (!e_cal_get_sources(&sources, type, NULL)) {
return NULL;
}
GSList *g = NULL;
for (g = e_source_list_peek_groups (sources); g; g = g->next) {
ESourceGroup *group = E_SOURCE_GROUP (g->data);
GSList *s = NULL;
for (s = e_source_group_peek_sources (group); s; s = s->next) {
source = E_SOURCE (s->data);
evo_location_t *path = g_malloc0(sizeof(evo_location_t));
//FIXME: Word around #442187
//if (!first) {
// first = TRUE;
// path->uri = g_strdup("default");
//} else {
path->uri = g_strdup(e_source_get_uri(source));
//}
path->name = g_strdup(e_source_peek_name(source));
paths = g_list_append(paths, path);
}
}
return paths;
}
/**
* em_utils_folder_is_drafts:
* @registry: an #ESourceRegistry
* @folder: a #CamelFolder
*
* Decides if @folder is a Drafts folder.
*
* Returns %TRUE if this is a Drafts folder or %FALSE otherwise.
**/
gboolean
em_utils_folder_is_drafts (ESourceRegistry *registry,
CamelFolder *folder)
{
CamelFolder *local_drafts_folder;
CamelSession *session;
CamelStore *store;
GList *list, *iter;
gchar *folder_uri;
gboolean is_drafts = FALSE;
const gchar *extension_name;
g_return_val_if_fail (CAMEL_IS_FOLDER (folder), FALSE);
store = camel_folder_get_parent_store (folder);
session = camel_service_ref_session (CAMEL_SERVICE (store));
local_drafts_folder =
e_mail_session_get_local_folder (
E_MAIL_SESSION (session), E_MAIL_LOCAL_FOLDER_DRAFTS);
if (folder == local_drafts_folder) {
is_drafts = TRUE;
goto exit;
}
folder_uri = e_mail_folder_uri_from_folder (folder);
store = camel_folder_get_parent_store (folder);
extension_name = E_SOURCE_EXTENSION_MAIL_COMPOSITION;
list = e_source_registry_list_sources (registry, extension_name);
for (iter = list; iter != NULL; iter = g_list_next (iter)) {
ESource *source = E_SOURCE (iter->data);
ESourceExtension *extension;
const gchar *drafts_folder_uri;
extension = e_source_get_extension (source, extension_name);
drafts_folder_uri =
e_source_mail_composition_get_drafts_folder (
E_SOURCE_MAIL_COMPOSITION (extension));
if (drafts_folder_uri != NULL)
is_drafts = e_mail_folder_uri_equal (
session, folder_uri, drafts_folder_uri);
if (is_drafts)
break;
}
g_list_free_full (list, (GDestroyNotify) g_object_unref);
g_free (folder_uri);
exit:
g_object_unref (session);
return is_drafts;
}
static void
process_removal_in_hash (const gchar *uri,
gpointer value,
ProcessRemovalsData *prd)
{
GSList *groups, *sources, *p, *q;
gboolean found = FALSE;
/* search the list of selected calendars */
groups = e_source_list_peek_groups (prd->source_list);
for (p = groups; p != NULL; p = p->next) {
ESourceGroup *group = E_SOURCE_GROUP (p->data);
sources = e_source_group_peek_sources (group);
for (q = sources; q != NULL; q = q->next) {
ESource *source = E_SOURCE (q->data);
gchar *source_uri;
const gchar *completion = e_source_get_property (source, "alarm");
source_uri = e_source_get_uri (source);
if (strcmp (source_uri, uri) == 0)
if (!completion || !g_ascii_strcasecmp (completion, "true"))
found = TRUE;
g_free (source_uri);
if (found)
return;
}
}
/* not found, so list it for removal */
prd->removals = g_list_prepend (prd->removals, (gpointer) uri);
}
static void
e_webdav_discover_content_trust_prompt_done_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
ETrustPromptResponse response = E_TRUST_PROMPT_RESPONSE_UNKNOWN;
ESource *source;
RefreshData *rd = user_data;
GError *local_error = NULL;
g_return_if_fail (E_IS_SOURCE (source_object));
g_return_if_fail (rd != NULL);
source = E_SOURCE (source_object);
if (!e_trust_prompt_run_for_source_finish (source, result, &response, &local_error)) {
g_simple_async_result_take_error (rd->simple, local_error);
local_error = NULL;
g_simple_async_result_complete (rd->simple);
refresh_data_free (rd);
} else if (response == E_TRUST_PROMPT_RESPONSE_ACCEPT || response == E_TRUST_PROMPT_RESPONSE_ACCEPT_TEMPORARILY) {
/* Use NULL credentials to reuse those from the last time. */
e_webdav_discover_sources (source, rd->base_url, E_WEBDAV_DISCOVER_SUPPORTS_NONE, rd->credentials, rd->cancellable,
e_webdav_discover_content_refresh_done_cb, rd);
} else {
g_cancellable_cancel (rd->cancellable);
g_cancellable_set_error_if_cancelled (rd->cancellable, &local_error);
g_simple_async_result_take_error (rd->simple, local_error);
local_error = NULL;
g_simple_async_result_complete (rd->simple);
refresh_data_free (rd);
}
g_clear_error (&local_error);
}
static void
source_group_dispose (GObject *object)
{
ESourceGroupPrivate *priv;
priv = E_SOURCE_GROUP_GET_PRIVATE (object);
if (priv->sources != NULL) {
GSList *p;
for (p = priv->sources; p != NULL; p = p->next) {
ESource *source = E_SOURCE (p->data);
g_signal_handlers_disconnect_by_func (source,
G_CALLBACK (source_changed_callback),
object);
g_object_unref (source);
}
g_slist_free (priv->sources);
priv->sources = NULL;
}
/* Chain up to parent's dispose() method. */
G_OBJECT_CLASS (e_source_group_parent_class)->dispose (object);
}
static void
source_viewer_delete_done_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
ESource *source;
ESourceViewer *viewer;
GError *error = NULL;
source = E_SOURCE (source_object);
viewer = E_SOURCE_VIEWER (user_data);
e_source_remove_finish (source, result, &error);
/* Ignore cancellations. */
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
g_clear_error (&error);
/* FIXME Show an info bar with the error message. */
} else if (error != NULL) {
g_warning ("%s: %s", G_STRFUNC, error->message);
g_clear_error (&error);
}
gtk_notebook_set_current_page (
GTK_NOTEBOOK (viewer->top_panel), PAGE_VIEWING);
gtk_widget_set_sensitive (viewer->tree_view, TRUE);
g_object_unref (viewer->delete_operation);
viewer->delete_operation = NULL;
g_object_unref (viewer);
}
static void
connect_group (ESourceGroup *group)
{
GSList *sources, *p;
g_object_ref (group);
g_signal_connect (group, "changed", G_CALLBACK (group_changed_callback), NULL);
g_signal_connect (group, "source_added", G_CALLBACK (source_added_callback), NULL);
g_signal_connect (group, "source_removed", G_CALLBACK (source_removed_callback), NULL);
sources = e_source_group_peek_sources (group);
for (p = sources; p != NULL; p = p->next)
connect_source (E_SOURCE (p->data));
}
ESource *
evo_environment_find_source(ESourceList *list, const char *uri)
{
GSList *g;
for (g = e_source_list_peek_groups (list); g; g = g->next) {
ESourceGroup *group = E_SOURCE_GROUP (g->data);
GSList *s;
for (s = e_source_group_peek_sources (group); s; s = s->next) {
ESource *source = E_SOURCE (s->data);
if (!strcmp(e_source_get_uri(source), uri))
return source;
}
}
return NULL;
}
static inline void
debug_dump_ecal_list (GHashTable *clients)
{
#ifdef CALENDAR_ENABLE_DEBUG
GList *list, *link;
dprintf ("Loaded clients:\n");
list = g_hash_table_get_keys (clients);
for (link = list; link != NULL; link = g_list_next (link))
{
ESource *source = E_SOURCE (link->data);
dprintf (" %s %s\n",
e_source_get_uid (source),
e_source_get_display_name (source));
}
#endif
}
static void
book_loaded_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
ESource *source = E_SOURCE (source_object);
VCardImporter *gci = user_data;
EClient *client = NULL;
e_client_utils_open_new_finish (source, result, &client, NULL);
if (client == NULL) {
vcard_import_done (gci);
return;
}
gci->book_client = E_BOOK_CLIENT (client);
if (gci->encoding == VCARD_ENCODING_UTF16) {
gchar *tmp;
gunichar2 *contents_utf16 = (gunichar2 *) gci->contents;
tmp = utf16_to_utf8 (contents_utf16);
g_free (gci->contents);
gci->contents = tmp;
} else if (gci->encoding == VCARD_ENCODING_LOCALE) {
gchar *tmp;
tmp = g_locale_to_utf8 (gci->contents, -1, NULL, NULL, NULL);
g_free (gci->contents);
gci->contents = tmp;
}
gci->contactlist = eab_contact_list_from_string (gci->contents);
g_free (gci->contents);
gci->contents = NULL;
gci->iterator = gci->contactlist;
gci->total = g_slist_length (gci->contactlist);
if (gci->iterator)
gci->idle_id = g_idle_add (vcard_import_contacts, gci);
else
vcard_import_done (gci);
}
static void
book_loaded_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
ESource *source = E_SOURCE (source_object);
LDIFImporter *gci = user_data;
EClient *client = NULL;
e_client_utils_open_new_finish (source, result, &client, NULL);
if (client == NULL) {
ldif_import_done (gci);
return;
}
gci->book_client = E_BOOK_CLIENT (client);
gci->idle_id = g_idle_add (ldif_import_contacts, gci);
}
static GSList *traverse_sources(GSList *ebooks, GSList *sources,
char **default_src) {
GError *gerr = NULL;
for (; sources != NULL; sources = g_slist_next(sources)) {
char *uri;
ESource *source = E_SOURCE(sources->data);
EBook *ebook = e_book_new(source, &gerr);
if (ebook == NULL) {
error("Can't create user's address book: %s",
gerr->message);
g_clear_error(&gerr);
continue;
}
uri = e_source_get_uri(source);
if (g_strcmp0(*default_src, uri) == 0) {
g_free(uri);
continue;
}
g_free(uri);
if (e_book_open(ebook, FALSE, &gerr) == FALSE) {
error("Can't open e-book address book: %s",
gerr->message);
g_object_unref(ebook);
g_clear_error(&gerr);
continue;
}
if (*default_src == NULL)
*default_src = e_source_get_uri(source);
DBG("%s address book opened", e_source_peek_name(source));
ebooks = g_slist_append(ebooks, ebook);
}
return ebooks;
}
static void
alarm_notify_load_calendars (AlarmNotify *an,
ECalSourceType source_type)
{
ESourceList *source_list;
GSList *groups, *sources, *p, *q;
if (!e_cal_get_sources (&source_list, source_type, NULL)) {
d (printf("%s:%d (load_calendars) - Cannont get sources\n ", __FILE__, __LINE__));
an->priv->source_lists[source_type] = NULL;
return;
}
groups = e_source_list_peek_groups (source_list);
for (p = groups; p != NULL; p = p->next) {
ESourceGroup *group = E_SOURCE_GROUP (p->data);
sources = e_source_group_peek_sources (group);
for (q = sources; q != NULL; q = q->next) {
ESource *source = E_SOURCE (q->data);
gchar *uri;
const gchar *completion = e_source_get_property (source, "alarm");
if (completion && (!g_ascii_strcasecmp (completion, "false") ||
!g_ascii_strcasecmp (completion, "never")))
continue;
uri = e_source_get_uri (source);
d (printf("%s:%d (load_calendars) - Loading Calendar %s \n", __FILE__, __LINE__, uri));
alarm_notify_add_calendar (an, source_type, source, FALSE);
g_free (uri);
}
}
g_signal_connect_object (
source_list, "changed",
G_CALLBACK (alarm_notify_list_changed_cb), an, 0);
an->priv->source_lists[source_type] = source_list;
}
static void
dump_group (ESourceGroup *group)
{
GSList *sources, *p;
g_print ("Group %s\n", e_source_group_peek_uid (group));
g_print ("\tname: %s\n", e_source_group_peek_name (group));
g_print ("\tbase_uri: %s\n", e_source_group_peek_base_uri (group));
sources = e_source_group_peek_sources (group);
for (p = sources; p != NULL; p = p->next) {
ESource *source = E_SOURCE (p->data);
dump_source (source);
if (e_source_peek_group (source) != group)
g_warning ("\t\t** ERROR ** parent pointer is %p, should be %p",
(gpointer) e_source_peek_group (source),
(gpointer) group);
}
}
static void
calendar_sources_load_esource_list (ESourceRegistry *registry,
CalendarSourceData *source_data)
{
GList *list, *link;
const gchar *extension_name;
switch (source_data->source_type)
{
case E_CAL_SOURCE_TYPE_EVENT:
extension_name = E_SOURCE_EXTENSION_CALENDAR;
break;
case E_CAL_SOURCE_TYPE_TODO:
extension_name = E_SOURCE_EXTENSION_TASK_LIST;
break;
case E_CAL_SOURCE_TYPE_JOURNAL:
case E_CAL_SOURCE_TYPE_LAST:
default:
g_return_if_reached ();
}
list = e_source_registry_list_sources (registry, extension_name);
for (link = list; link != NULL; link = g_list_next (link))
{
ESource *source = E_SOURCE (link->data);
ESourceSelectable *extension;
gboolean show_source;
extension = e_source_get_extension (source, extension_name);
show_source = e_source_get_enabled (source) && e_source_selectable_get_selected (extension);
if (show_source)
create_client_for_source (source, source_data->source_type, source_data);
}
debug_dump_ecal_list (source_data->clients);
g_list_free_full (list, g_object_unref);
}
static void
impl_dispose (GObject *object)
{
ESourceGroupPrivate *priv = E_SOURCE_GROUP (object)->priv;
if (priv->sources != NULL) {
GSList *p;
for (p = priv->sources; p != NULL; p = p->next) {
ESource *source = E_SOURCE (p->data);
g_signal_handlers_disconnect_by_func (source,
G_CALLBACK (source_changed_callback),
object);
g_object_unref (source);
}
g_slist_free (priv->sources);
priv->sources = NULL;
}
(* G_OBJECT_CLASS (e_source_group_parent_class)->dispose) (object);
}
static void
source_util_remove_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
ESource *source;
EActivity *activity;
EAlertSink *alert_sink;
AsyncContext *async_context;
const gchar *display_name;
GError *error = NULL;
source = E_SOURCE (source_object);
async_context = (AsyncContext *) user_data;
activity = async_context->activity;
alert_sink = e_activity_get_alert_sink (activity);
display_name = e_source_get_display_name (source);
e_source_remove_finish (source, result, &error);
if (e_activity_handle_cancellation (activity, error)) {
g_error_free (error);
} else if (error != NULL) {
e_alert_submit (
alert_sink,
"system:remove-source-fail",
display_name, error->message, NULL);
g_error_free (error);
} else {
e_activity_set_state (activity, E_ACTIVITY_COMPLETED);
}
async_context_free (async_context);
}
/**
* e_cal_backend_user_declined:
* @registry: an #ESourceRegistry
* @icalcomp: component where to check
*
* Returns: Whether icalcomp contains attendee with a mail same as any of
* configured enabled mail account and whether this user declined.
*
* Since: 2.26
**/
gboolean
e_cal_backend_user_declined (ESourceRegistry *registry,
icalcomponent *icalcomp)
{
GList *list, *iter;
const gchar *extension_name;
gboolean declined = FALSE;
g_return_val_if_fail (E_IS_SOURCE_REGISTRY (registry), FALSE);
g_return_val_if_fail (icalcomp != NULL, FALSE);
extension_name = E_SOURCE_EXTENSION_MAIL_IDENTITY;
list = e_source_registry_list_enabled (registry, extension_name);
for (iter = list; iter != NULL; iter = g_list_next (iter)) {
ESource *source = E_SOURCE (iter->data);
ESourceMailIdentity *extension;
const gchar *address;
extension = e_source_get_extension (source, extension_name);
address = e_source_mail_identity_get_address (extension);
if (address == NULL)
continue;
if (is_attendee_declined (icalcomp, address)) {
declined = TRUE;
break;
}
}
g_list_free_full (list, (GDestroyNotify) g_object_unref);
return declined;
}
/**
* e_cal_backend_mail_account_is_valid:
* @registry: an #ESourceRegistry
* @user: user name for the account to check
* @name: placeholder for the account name
*
* Checks that a mail account is valid, and returns its name.
*
* Returns: TRUE if the account is valid, FALSE if not.
*/
gboolean
e_cal_backend_mail_account_is_valid (ESourceRegistry *registry,
gchar *user,
gchar **name)
{
GList *list, *iter;
const gchar *extension_name;
gboolean valid = FALSE;
g_return_val_if_fail (E_IS_SOURCE_REGISTRY (registry), FALSE);
g_return_val_if_fail (user != NULL, FALSE);
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
list = e_source_registry_list_enabled (registry, extension_name);
for (iter = list; iter != NULL; iter = g_list_next (iter)) {
ESource *source = E_SOURCE (iter->data);
ESourceMailAccount *mail_account;
ESourceMailIdentity *mail_identity;
const gchar *uid;
gboolean match = FALSE;
gchar *address;
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
mail_account = e_source_get_extension (source, extension_name);
uid = e_source_mail_account_get_identity_uid (mail_account);
if (uid == NULL)
continue;
source = e_source_registry_ref_source (registry, uid);
if (source == NULL)
continue;
extension_name = E_SOURCE_EXTENSION_MAIL_IDENTITY;
if (!e_source_has_extension (source, extension_name)) {
g_object_unref (source);
continue;
}
mail_identity = e_source_get_extension (source, extension_name);
address = e_source_mail_identity_dup_address (mail_identity);
if (address != NULL) {
match = (g_ascii_strcasecmp (address, user) == 0);
g_free (address);
}
if (match && name != NULL)
*name = e_source_dup_display_name (source);
g_object_unref (source);
if (match) {
valid = TRUE;
break;
}
}
g_list_free_full (list, (GDestroyNotify) g_object_unref);
return valid;
}
ESource *
em_utils_guess_mail_account_with_recipients_and_sort (ESourceRegistry *registry,
CamelMimeMessage *message,
CamelFolder *folder,
const gchar *message_uid,
EMailUtilsSourtSourcesFunc sort_func,
gpointer sort_func_data)
{
ESource *source = NULL;
GHashTable *recipients;
CamelInternetAddress *addr;
GList *list, *iter;
const gchar *extension_name;
const gchar *type;
const gchar *key;
/* This policy is subject to debate and tweaking,
* but please also document the rational here. */
g_return_val_if_fail (E_IS_SOURCE_REGISTRY (registry), NULL);
g_return_val_if_fail (CAMEL_IS_MIME_MESSAGE (message), NULL);
/* Build a set of email addresses in which to test for membership.
* Only the keys matter here; the values just need to be non-NULL. */
recipients = g_hash_table_new (g_str_hash, g_str_equal);
type = CAMEL_RECIPIENT_TYPE_TO;
addr = camel_mime_message_get_recipients (message, type);
if (addr != NULL) {
gint index = 0;
while (camel_internet_address_get (addr, index++, NULL, &key))
g_hash_table_add (recipients, (gpointer) key);
}
type = CAMEL_RECIPIENT_TYPE_CC;
addr = camel_mime_message_get_recipients (message, type);
if (addr != NULL) {
gint index = 0;
while (camel_internet_address_get (addr, index++, NULL, &key))
g_hash_table_add (recipients, (gpointer) key);
}
/* First Preference: We were given a folder that maps to an
* enabled mail account, and that account's address appears
* in the list of To: or Cc: recipients. */
if (folder != NULL)
source = guess_mail_account_from_folder (
registry, folder, message_uid);
if (source == NULL)
goto second_preference;
if (mail_account_in_recipients (registry, source, recipients))
goto exit;
second_preference:
/* Second Preference: Choose any enabled mail account whose
* address appears in the list to To: or Cc: recipients. */
if (source != NULL) {
g_object_unref (source);
source = NULL;
}
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
list = e_source_registry_list_sources (registry, extension_name);
if (sort_func)
sort_func (&list, sort_func_data);
for (iter = list; iter != NULL; iter = g_list_next (iter)) {
ESource *temp = E_SOURCE (iter->data);
if (e_source_registry_check_enabled (registry, temp) &&
mail_account_in_recipients (registry, temp, recipients)) {
source = g_object_ref (temp);
break;
}
}
g_list_free_full (list, (GDestroyNotify) g_object_unref);
if (source != NULL)
goto exit;
/* Last Preference: Defer to em_utils_guess_mail_account(). */
source = em_utils_guess_mail_account (
registry, message, folder, message_uid);
exit:
g_hash_table_destroy (recipients);
return source;
}
/*
* Search for a buddy in the Evolution contacts.
*
* @param buddy The buddy to search for.
* @param query An optional query. This function takes ownership of @a query,
* so callers must e_book_query_ref() it in advance (to obtain a
* second reference) if they want to reuse @a query.
*/
EContact *
gevo_search_buddy_in_contacts(PurpleBuddy *buddy, EBookQuery *query)
{
ESourceList *addressbooks;
GError *err = NULL;
EBookQuery *full_query;
GSList *groups, *g;
EContact *result;
EContactField protocol_field = gevo_prpl_get_field(buddy->account, buddy);
if (protocol_field == 0)
return NULL;
if (query != NULL)
{
EBookQuery *queries[2];
queries[0] = query;
queries[1] = e_book_query_field_test(protocol_field, E_BOOK_QUERY_IS, buddy->name);
if (queries[1] == NULL)
{
purple_debug_error("evolution", "Error in creating protocol query\n");
e_book_query_unref(query);
return NULL;
}
full_query = e_book_query_and(2, queries, TRUE);
}
else
{
full_query = e_book_query_field_test(protocol_field, E_BOOK_QUERY_IS, buddy->name);
if (full_query == NULL)
{
purple_debug_error("evolution", "Error in creating protocol query\n");
return NULL;
}
}
if (!e_book_get_addressbooks(&addressbooks, &err))
{
purple_debug_error("evolution",
"Unable to fetch list of address books.\n");
e_book_query_unref(full_query);
if (err != NULL)
g_error_free(err);
return NULL;
}
groups = e_source_list_peek_groups(addressbooks);
if (groups == NULL)
{
g_object_unref(addressbooks);
e_book_query_unref(full_query);
return NULL;
}
for (g = groups; g != NULL; g = g->next)
{
GSList *sources, *s;
sources = e_source_group_peek_sources(g->data);
for (s = sources; s != NULL; s = s->next)
{
result = gevo_run_query_in_uri(e_source_get_uri(E_SOURCE(s->data)), full_query);
if (result != NULL) {
g_object_unref(addressbooks);
e_book_query_unref(full_query);
return result;
}
}
}
g_object_unref(addressbooks);
e_book_query_unref(full_query);
return NULL;
}
void
gevo_addrbooks_model_populate(GtkTreeModel *model)
{
ESourceList *addressbooks;
GError *err = NULL;
GSList *groups, *g;
GtkTreeIter iter;
GtkListStore *list;
g_return_if_fail(model != NULL);
g_return_if_fail(GTK_IS_LIST_STORE(model));
list = GTK_LIST_STORE(model);
if (!e_book_get_addressbooks(&addressbooks, &err))
{
purple_debug_error("evolution",
"Unable to fetch list of address books.\n");
gtk_list_store_append(list, &iter);
gtk_list_store_set(list, &iter,
ADDRBOOK_COLUMN_NAME, _("None"),
ADDRBOOK_COLUMN_URI, NULL,
-1);
return;
}
groups = e_source_list_peek_groups(addressbooks);
if (groups == NULL)
{
gtk_list_store_append(list, &iter);
gtk_list_store_set(list, &iter,
ADDRBOOK_COLUMN_NAME, _("None"),
ADDRBOOK_COLUMN_URI, NULL,
-1);
return;
}
for (g = groups; g != NULL; g = g->next)
{
GSList *sources, *s;
sources = e_source_group_peek_sources(g->data);
for (s = sources; s != NULL; s = s->next)
{
ESource *source = E_SOURCE(s->data);
g_object_ref(source);
gtk_list_store_append(list, &iter);
gtk_list_store_set(list, &iter,
ADDRBOOK_COLUMN_NAME, e_source_peek_name(source),
ADDRBOOK_COLUMN_URI, e_source_get_uri(source),
-1);
}
}
g_object_unref(addressbooks);
}
static void
e_webdav_discover_content_refresh_done_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
RefreshData *rd = user_data;
ESource *source;
gchar *certificate_pem = NULL;
GTlsCertificateFlags certificate_errors = 0;
GSList *discovered_sources = NULL;
GSList *calendar_user_addresses = NULL;
GError *local_error = NULL;
g_return_if_fail (E_IS_SOURCE (source_object));
g_return_if_fail (rd != NULL);
source = E_SOURCE (source_object);
if (!e_webdav_discover_sources_finish (source, result,
&certificate_pem, &certificate_errors, &discovered_sources,
&calendar_user_addresses, &local_error)) {
if (!g_cancellable_is_cancelled (rd->cancellable) && certificate_pem &&
g_error_matches (local_error, SOUP_HTTP_ERROR, SOUP_STATUS_SSL_FAILED)) {
GtkWindow *parent;
GtkWidget *widget;
widget = gtk_widget_get_toplevel (rd->content);
parent = widget ? GTK_WINDOW (widget) : NULL;
e_trust_prompt_run_for_source (parent, source, certificate_pem, certificate_errors,
NULL, FALSE, rd->cancellable, e_webdav_discover_content_trust_prompt_done_cb, rd);
rd = NULL;
} else if (g_cancellable_is_cancelled (rd->cancellable) ||
(!g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED) &&
!g_error_matches (local_error, SOUP_HTTP_ERROR, SOUP_STATUS_UNAUTHORIZED) &&
!g_error_matches (local_error, SOUP_HTTP_ERROR, SOUP_STATUS_FORBIDDEN))) {
g_simple_async_result_take_error (rd->simple, local_error);
local_error = NULL;
g_simple_async_result_complete (rd->simple);
} else {
EWebDAVDiscoverContentData *data;
data = g_object_get_data (G_OBJECT (rd->content), WEBDAV_DISCOVER_CONTENT_DATA_KEY);
g_return_if_fail (data != NULL);
e_credentials_prompter_prompt (data->credentials_prompter, source,
local_error ? local_error->message : NULL,
rd->credentials ? E_CREDENTIALS_PROMPTER_PROMPT_FLAG_NONE:
E_CREDENTIALS_PROMPTER_PROMPT_FLAG_ALLOW_STORED_CREDENTIALS,
e_webdav_discover_content_credentials_prompt_done_cb, rd);
rd = NULL;
}
} else {
EWebDAVDiscoverContentData *data;
data = g_object_get_data (G_OBJECT (rd->content), WEBDAV_DISCOVER_CONTENT_DATA_KEY);
g_warn_if_fail (data != NULL);
if (data) {
e_webdav_discover_content_fill_discovered_sources (data->sources_tree_view,
data->supports_filter, discovered_sources);
e_webdav_discover_content_fill_calendar_emails (data->email_addresses_combo,
calendar_user_addresses);
}
g_simple_async_result_set_op_res_gboolean (rd->simple, TRUE);
g_simple_async_result_complete (rd->simple);
}
g_free (certificate_pem);
e_webdav_discover_free_discovered_sources (discovered_sources);
g_slist_free_full (calendar_user_addresses, g_free);
refresh_data_free (rd);
g_clear_error (&local_error);
}
void
dates_update_calendars (ESourceList *cal_list, DatesData *d)
{
GSList *groups, *g;
/* TODO: Don't reload *all* calendars on update */
d->dcal = NULL;
gtk_list_store_clear (d->cal_list_store);
dates_view_remove_all_calendars (d->view);
groups = e_source_list_peek_groups (cal_list);
#ifdef DEBUG
if (d->debug & DATES_DEBUG_CALENDAR)
g_debug ("Updating Calendars");
#endif
/* Disable creating of calendars until we know there's a valid
* calendar to add events to.
*/
d->cal_loaded = FALSE;
if (d->TBNew)
{
#ifdef DEBUG
if (d->debug & DATES_DEBUG_CALENDAR)
g_debug ("*** Setting TBNew button insensitive ***");
#endif
gtk_widget_set_sensitive (d->TBNew, FALSE);
}
for (g = groups; g; g = g->next) {
GSList *sources, *s;
#ifdef DEBUG
if (d->debug & DATES_DEBUG_CALENDAR)
g_debug ("Group %s (%s)",
e_source_group_peek_name (
E_SOURCE_GROUP (g->data)),
e_source_group_peek_base_uri (
E_SOURCE_GROUP (g->data)));
#endif
sources = e_source_group_peek_sources (
E_SOURCE_GROUP (g->data));
for (s = sources; s; s = s->next) {
ESource *source = E_SOURCE (s->data);
ECal *ecal;
ecal = dates_load_esource (source,
E_CAL_SOURCE_TYPE_EVENT, NULL, d);
if (!ecal) {
#ifdef DEBUG
if (d->debug & DATES_DEBUG_CALENDAR)
g_debug ("No EVENTS in this source");
#endif
continue;
}
#ifdef DEBUG
if (d->debug & DATES_DEBUG_CALENDAR)
g_debug ("Found EVENTS in this source");
#endif
g_signal_connect (G_OBJECT (ecal), "cal_opened",
G_CALLBACK (dates_cal_open_cb), d);
e_cal_open_async (ecal, FALSE);
/*
* Set the calendar mode to CAL_MODE_REMOTE. This is necessary to get the
* remote (webcal) calendars to work. It doesn't seem to have any effect
* on the file backend.
*/
e_cal_set_mode (ecal, CAL_MODE_REMOTE);
}
}
}
void
dates_autoselect_calendars (DatesData *d, ESourceList * cal_list)
{
GSList *selected_list;
if (!cal_list)
return;
selected_list = gconf_client_get_list (gconf_client_get_default (),
CALENDAR_GCONF_SELECTED,
GCONF_VALUE_STRING, NULL);
if (!selected_list) {
/* select all available calendars */
GSList *list = NULL, *groups, *g;
groups = e_source_list_peek_groups (cal_list);
#ifdef DEBUG
if (d->debug & DATES_DEBUG_CALENDAR)
g_debug ("Attempting to autoselect");
#endif
for (g = groups; g; g = g->next) {
GSList *sources, *s;
sources =
e_source_group_peek_sources (E_SOURCE_GROUP (g->data));
for (s = sources; s; s = s->next) {
ESource *source = E_SOURCE (s->data);
ECal *ecal;
gchar * uid;
ecal = dates_load_esource (source,
E_CAL_SOURCE_TYPE_EVENT,
NULL, d);
if (!ecal)
{
#ifdef DEBUG
if (d->debug & DATES_DEBUG_CALENDAR)
g_debug ("No ecal");
#endif
continue;
}
uid = (gchar *)e_source_peek_uid (e_cal_get_source (ecal));
list = g_slist_prepend (list, uid);
}
}
if (list)
{
#ifdef DEBUG
if (d->debug & DATES_DEBUG_CALENDAR)
g_debug ("Setting new list");
#endif
gconf_client_set_list (gconf_client_get_default (),
CALENDAR_GCONF_SELECTED,
GCONF_VALUE_STRING,
list, NULL);
}
}
else
#ifdef DEBUG
if (d->debug & DATES_DEBUG_CALENDAR)
g_debug ("Have selected list");
#endif
}
static void
import_contacts (void)
{
EShell *shell;
ESourceRegistry *registry;
EClient *client = NULL;
GList *list;
gchar *name;
GString *line;
FILE *fp;
gsize offset;
const gchar *extension_name;
GError *error = NULL;
printf ("importing pine addressbook\n");
shell = e_shell_get_default ();
registry = e_shell_get_registry (shell);
extension_name = E_SOURCE_EXTENSION_ADDRESS_BOOK;
name = g_build_filename (g_get_home_dir (), ".addressbook", NULL);
fp = fopen (name, "r");
g_free (name);
if (fp == NULL)
return;
list = e_source_registry_list_sources (registry, extension_name);
if (list != NULL) {
ESource *source;
source = E_SOURCE (list->data);
client = e_book_client_connect_sync (source, 30, NULL, &error);
} else {
/* No address books exist. */
g_warning ("%s: No address books exist.", G_STRFUNC);
fclose (fp);
return;
}
g_list_free_full (list, (GDestroyNotify) g_object_unref);
if (error != NULL) {
g_warning (
"%s: Failed to open book client: %s",
G_STRFUNC, error ? error->message : "Unknown error");
g_clear_error (&error);
fclose (fp);
return;
}
line = g_string_new ("");
g_string_set_size (line, 256);
offset = 0;
while (fgets (line->str + offset, 256, fp)) {
gsize len;
len = strlen (line->str + offset) + offset;
if (line->str[len - 1] == '\n')
g_string_truncate (line, len - 1);
else if (!feof (fp)) {
offset = len;
g_string_set_size (line, len + 256);
continue;
} else {
g_string_truncate (line, len);
}
import_contact (E_BOOK_CLIENT (client), line->str);
offset = 0;
}
g_string_free (line, TRUE);
fclose (fp);
g_object_unref (client);
}
static void
mail_to_event (ECalClientSourceType source_type,
gboolean with_attendees,
EMailReader *reader)
{
EShell *shell;
EMailBackend *backend;
ESourceRegistry *registry;
GPtrArray *uids;
ESource *source = NULL;
ESource *default_source;
GList *list, *iter;
GtkWindow *parent;
const gchar *extension_name;
parent = e_mail_reader_get_window (reader);
uids = e_mail_reader_get_selected_uids (reader);
/* Ask before converting 10 or more mails to events. */
if (uids->len > 10) {
gchar *question;
gint response;
question = g_strdup_printf (
get_question_add_all_mails (source_type, uids->len), uids->len);
response = do_ask (question, FALSE);
g_free (question);
if (response == GTK_RESPONSE_NO) {
g_ptr_array_unref (uids);
return;
}
}
backend = e_mail_reader_get_backend (reader);
shell = e_shell_backend_get_shell (E_SHELL_BACKEND (backend));
registry = e_shell_get_registry (shell);
switch (source_type) {
case E_CAL_CLIENT_SOURCE_TYPE_EVENTS:
extension_name = E_SOURCE_EXTENSION_CALENDAR;
default_source = e_source_registry_ref_default_calendar (registry);
break;
case E_CAL_CLIENT_SOURCE_TYPE_MEMOS:
extension_name = E_SOURCE_EXTENSION_MEMO_LIST;
default_source = e_source_registry_ref_default_memo_list (registry);
break;
case E_CAL_CLIENT_SOURCE_TYPE_TASKS:
extension_name = E_SOURCE_EXTENSION_TASK_LIST;
default_source = e_source_registry_ref_default_task_list (registry);
break;
default:
g_return_if_reached ();
}
list = e_source_registry_list_sources (registry, extension_name);
/* If there is only one writable source, no need to prompt the user. */
for (iter = list; iter != NULL; iter = g_list_next (iter)) {
ESource *candidate = E_SOURCE (iter->data);
if (e_source_get_writable (candidate)) {
if (source == NULL)
source = candidate;
else {
source = NULL;
break;
}
}
}
g_list_free_full (list, (GDestroyNotify) g_object_unref);
if (source == NULL) {
GtkWidget *dialog;
ESourceSelector *selector;
/* ask the user which tasks list to save to */
dialog = e_source_selector_dialog_new (
parent, registry, extension_name);
selector = e_source_selector_dialog_get_selector (
E_SOURCE_SELECTOR_DIALOG (dialog));
e_source_selector_set_primary_selection (
selector, default_source);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
source = e_source_selector_dialog_peek_primary_selection (
E_SOURCE_SELECTOR_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
if (source) {
/* if a source has been selected, perform the mail2event operation */
AsyncData *data = NULL;
GThread *thread = NULL;
GError *error = NULL;
/* Fill the elements in AsynData */
data = g_new0 (AsyncData, 1);
data->client_cache = g_object_ref (e_shell_get_client_cache (shell));
data->source = g_object_ref (source);
data->extension_name = extension_name;
data->source_type = source_type;
data->folder = e_mail_reader_ref_folder (reader);
data->uids = g_ptr_array_ref (uids);
data->with_attendees = with_attendees;
if (uids->len == 1)
data->selected_text = get_selected_text (reader);
else
data->selected_text = NULL;
thread = g_thread_try_new (
NULL, (GThreadFunc) do_mail_to_event, data, &error);
if (error != NULL) {
g_warning (G_STRLOC ": %s", error->message);
g_error_free (error);
} else {
g_thread_unref (thread);
}
}
g_object_unref (default_source);
g_ptr_array_unref (uids);
}
static void
alarm_notify_list_changed_cb (ESourceList *source_list,
AlarmNotify *an)
{
GSList *groups, *sources, *p, *q;
ECalSourceType source_type = E_CAL_SOURCE_TYPE_LAST;
ProcessRemovalsData prd;
GList *l;
gint i;
g_signal_handlers_block_by_func (
source_list, alarm_notify_list_changed_cb, an);
/* Figure out the source type */
for (i = 0; i < E_CAL_SOURCE_TYPE_LAST; i++) {
if (source_list == an->priv->source_lists[i]) {
source_type = i;
break;
}
}
if (source_type == E_CAL_SOURCE_TYPE_LAST)
return;
/* process the additions */
groups = e_source_list_peek_groups (source_list);
for (p = groups; p != NULL; p = p->next) {
ESourceGroup *group = E_SOURCE_GROUP (p->data);
sources = e_source_group_peek_sources (group);
for (q = sources; q != NULL; q = q->next) {
ESource *source = E_SOURCE (q->data);
gchar *uri;
const gchar *completion = e_source_get_property (source, "alarm");
if (completion && (!g_ascii_strcasecmp (completion, "false") ||
!g_ascii_strcasecmp (completion, "never")))
continue;
uri = e_source_get_uri (source);
if (!g_hash_table_lookup (an->priv->uri_client_hash[source_type], uri)) {
d (printf("%s:%d (list_changed_cb) - Adding Calendar %s\n", __FILE__, __LINE__, uri));
alarm_notify_add_calendar (an, source_type, source, FALSE);
}
g_free (uri);
}
}
/* process the removals */
prd.an = an;
prd.source_list = an->priv->source_lists[source_type];
prd.removals = NULL;
g_hash_table_foreach (an->priv->uri_client_hash[source_type], (GHFunc) process_removal_in_hash, &prd);
for (l = prd.removals; l; l = l->next) {
d (printf("%s:%d (list_changed_cb) - Removing Calendar %s\n", __FILE__, __LINE__, (gchar *)l->data));
alarm_notify_remove_calendar (an, source_type, l->data);
}
g_list_free (prd.removals);
g_signal_handlers_unblock_by_func (
source_list, alarm_notify_list_changed_cb, an);
}
