dbc->c_close (dbc);
}
- e_dbhash_foreach_key (ehash, (EDbHashFunc)e_book_backend_file_changes_foreach_key, &ctx);
+ e_dbhash_foreach_key (ehash, (EDbHashFunc)e_book_backend_file_changes_foreach_key, &ctx);
/* Send the changes */
if (db_error != DB_NOTFOUND) {
writable = TRUE;
} else {
db->close (db, 0);
- db_error = db_create (&db, env, 0);
- if (db_error != 0) {
- g_warning ("db_create failed with %s", db_strerror (db_error));
- g_free (dirname);
- g_free (filename);
- return db_error_to_status (db_error);
- }
+ db_error = db_create (&db, env, 0);
+ if (db_error != 0) {
+ g_warning ("db_create failed with %s", db_strerror (db_error));
+ g_free (dirname);
+ g_free (filename);
+ return db_error_to_status (db_error);
+ }
db_error = (*db->open) (db, NULL, filename, NULL, DB_HASH, DB_RDONLY | DB_THREAD, 0666);
db_error = db_create (&db, env, 0);
if (db_error != 0) {
- g_warning ("db_create failed with %s", db_strerror (db_error));
+ g_warning ("db_create failed with %s", db_strerror (db_error));
g_free (dirname);
g_free (filename);
return db_error_to_status (db_error);
static EBookBackendSyncStatus e_book_backend_status_from_google_book_error (GoogleBookError error_code);
static EBookBackendSyncStatus
-e_book_backend_google_create_contact (EBookBackendSync *backend,
+e_book_backend_google_create_contact (EBookBackendSync *backend,
EDataBook *book,
- guint32 opid,
- const char *vcard_str,
- EContact **out_contact)
+ guint32 opid,
+ const char *vcard_str,
+ EContact **out_contact)
{
EBookBackendGooglePrivate *priv;
EBookBackendSyncStatus status = GNOME_Evolution_Addressbook_OtherError;
static EBookBackendSyncStatus
e_book_backend_google_remove_contacts (EBookBackendSync *backend,
- EDataBook *book,
- guint32 opid,
- GList *id_list,
- GList **ids)
+ EDataBook *book,
+ guint32 opid,
+ GList *id_list,
+ GList **ids)
{
EBookBackendGooglePrivate *priv;
EBookBackendSyncStatus status = GNOME_Evolution_Addressbook_OtherError;
}
static EBookBackendSyncStatus
-e_book_backend_google_modify_contact (EBookBackendSync *backend,
+e_book_backend_google_modify_contact (EBookBackendSync *backend,
EDataBook *book,
- guint32 opid,
- const char *vcard_str,
- EContact **out_contact)
+ guint32 opid,
+ const char *vcard_str,
+ EContact **out_contact)
{
EBookBackendGooglePrivate *priv;
EBookBackendSyncStatus status = GNOME_Evolution_Addressbook_OtherError;
}
static EBookBackendSyncStatus
-e_book_backend_google_get_contact (EBookBackendSync *backend,
- EDataBook *book,
- guint32 opid,
- const char *uid,
- char **vcard_str)
+e_book_backend_google_get_contact (EBookBackendSync *backend,
+ EDataBook *book,
+ guint32 opid,
+ const char *uid,
+ char **vcard_str)
{
EBookBackendGooglePrivate *priv;
EBookBackendSyncStatus status = GNOME_Evolution_Addressbook_OtherError;
static EBookBackendSyncStatus
e_book_backend_google_get_contact_list (EBookBackendSync *backend,
- EDataBook *book,
- guint32 opid,
- const char *query,
- GList **contacts)
+ EDataBook *book,
+ guint32 opid,
+ const char *query,
+ GList **contacts)
{
EBookBackendGooglePrivate *priv;
EBookBackendSyncStatus status = GNOME_Evolution_Addressbook_OtherError;
static EBookBackendSyncStatus
e_book_backend_google_authenticate_user (EBookBackendSync *backend,
- EDataBook *book,
- guint32 opid,
- const char *username,
- const char *password,
- const char *auth_method)
+ EDataBook *book,
+ guint32 opid,
+ const char *username,
+ const char *password,
+ const char *auth_method)
{
EBookBackendGooglePrivate *priv;
EBookBackendSyncStatus status = GNOME_Evolution_Addressbook_Success;
}
static EBookBackendSyncStatus
-e_book_backend_google_get_supported_auth_methods (EBookBackendSync *backend,
- EDataBook *book,
- guint32 opid,
- GList **methods)
+e_book_backend_google_get_supported_auth_methods (EBookBackendSync *backend,
+ EDataBook *book,
+ guint32 opid,
+ GList **methods)
{
char *auth_method;
}
static EBookBackendSyncStatus
-e_book_backend_google_get_required_fields (EBookBackendSync *backend,
- EDataBook *book,
- guint32 opid,
- GList **fields_out)
+e_book_backend_google_get_required_fields (EBookBackendSync *backend,
+ EDataBook *book,
+ guint32 opid,
+ GList **fields_out)
{
__debug__ (G_STRFUNC);
}
static EBookBackendSyncStatus
-e_book_backend_google_get_supported_fields (EBookBackendSync *backend,
- EDataBook *book,
- guint32 opid,
- GList **fields_out)
+e_book_backend_google_get_supported_fields (EBookBackendSync *backend,
+ EDataBook *book,
+ guint32 opid,
+ GList **fields_out)
{
const int supported_fields[] =
{
}
static EBookBackendSyncStatus
-e_book_backend_google_get_changes (EBookBackendSync *backend,
- EDataBook *book,
- guint32 opid,
- const char *change_id,
- GList **changes_out)
+e_book_backend_google_get_changes (EBookBackendSync *backend,
+ EDataBook *book,
+ guint32 opid,
+ const char *change_id,
+ GList **changes_out)
{
__debug__ (G_STRFUNC);
return GNOME_Evolution_Addressbook_OtherError;
}
static EBookBackendSyncStatus
-e_book_backend_google_remove (EBookBackendSync *backend,
+e_book_backend_google_remove (EBookBackendSync *backend,
EDataBook *book,
- guint32 opid)
+ guint32 opid)
{
__debug__ (G_STRFUNC);
return GNOME_Evolution_Addressbook_Success;
static GNOME_Evolution_Addressbook_CallStatus
e_book_backend_google_load_source (EBookBackend *backend,
- ESource *source,
- gboolean only_if_exists)
+ ESource *source,
+ gboolean only_if_exists)
{
EBookBackendGooglePrivate *priv = GET_PRIVATE (backend);
const char *refresh_interval_str, *use_ssl_str, *use_cache_str;
static const struct field_element_mapping {
EContactField field_id;
- int element_type;
+ int element_type;
char *element_name;
void (*populate_contact_func)(EContact *contact, gpointer data);
void (*set_value_in_gw_item) (EGwItem *item, gpointer data);
new_postal_address = e_gw_item_get_address (new_item, address_type);
old_postal_address = e_gw_item_get_address (old_item, address_type);
- if (new_postal_address && old_postal_address) {
+ if (new_postal_address && old_postal_address) {
s1 = new_postal_address->street_address;
s2 = old_postal_address->street_address;
if (!s1 && s2)
item = E_GW_ITEM (data);
value = e_gw_item_get_field_value (item, "birthday");
- if (value) {
+ if (value) {
date = e_contact_date_from_string (value);
e_contact_set (contact, E_CONTACT_BIRTH_DATE, date);
e_contact_date_free (date);
if (old_full_name && new_full_name) {
s1 = new_full_name->name_prefix;
s2 = old_full_name->name_prefix;
- if(!s1 && s2)
+ if(!s1 && s2)
delete_full_name->name_prefix = g_strdup(s2);
else if (s1)
update_full_name->name_prefix = g_strdup(s1);
static void
set_members_in_gw_item (EGwItem *item, EContact *contact, EBookBackendGroupwise *egwb)
{
- GList *members, *temp, *dtemp, *items, *p, *emails_without_ids, *dest_without_ids;
+ GList *members, *temp, *dtemp, *items, *p, *emails_without_ids, *dest_without_ids;
GList *group_members;
char *email;
EGwFilter *filter;
g_list_free (dest_without_ids);
g_list_free (items);
- e_gw_item_set_member_list (item, group_members);
+ e_gw_item_set_member_list (item, group_members);
}
static void
GList *old_members, *new_members ;
GList *old_ids, *new_ids, *additions, *deletions;
- old_ids = new_ids = additions = deletions = NULL;
+ old_ids = new_ids = additions = deletions = NULL;
old_members = e_gw_item_get_member_list (old_item);
new_members = e_gw_item_get_member_list (new_item);
new_value = e_gw_item_get_field_value (new_item, "organization");
old_org_id = e_gw_item_get_field_value (old_item, "organization_id");
new_org_id = e_gw_item_get_field_value (new_item, "organization_id");
- if (new_value && old_value) {
+ if (new_value && old_value) {
if (!g_str_equal (new_value, old_value)) {
e_gw_item_set_change (new_item, E_GW_ITEM_CHANGE_TYPE_UPDATE, "organization", new_value);
e_gw_item_set_change (new_item, E_GW_ITEM_CHANGE_TYPE_UPDATE, "organization_id", new_org_id);
if (g_str_equal (propname, "x-evolution-any-field")) {
if (!sexp_data->is_personal_book && str && strlen(str) == 0) {
/* ignore the NULL query */
- sexp_data->is_filter_valid = FALSE;
+ sexp_data->is_filter_valid = FALSE;
r = e_sexp_result_new(f, ESEXP_RES_BOOL);
r->value.bool = FALSE;
return r;
if (!sexp_data->is_personal_book && str && strlen(str) == 0) {
/* ignore the NULL query */
- sexp_data->is_filter_valid = FALSE;
+ sexp_data->is_filter_valid = FALSE;
r = e_sexp_result_new(f, ESEXP_RES_BOOL);
r->value.bool = FALSE;
return r;
if (!e_flag_is_set (closure->running))
break;
- uid = g_ptr_array_index (ids, i);
+ uid = g_ptr_array_index (ids, i);
contact = e_book_backend_db_cache_get_contact (ebgw->priv->file_db, uid);
if (contact) {
e_data_book_view_notify_update (book_view, contact);
}
if (gwb->priv->is_summary_ready &&
- e_book_backend_summary_is_summary_query (gwb->priv->summary, query)) {
+ e_book_backend_summary_is_summary_query (gwb->priv->summary, query)) {
if (enable_debug)
printf ("reading the uids from summary \n");
ids = e_book_backend_summary_search (gwb->priv->summary, query);
if (gwb->priv->cnc == NULL) {
e_data_book_view_notify_complete (book_view,
- GNOME_Evolution_Addressbook_AuthenticationRequired);
+ GNOME_Evolution_Addressbook_AuthenticationRequired);
e_data_book_view_unref (book_view);
return NULL;
}
if (filter)
g_object_unref (filter);
return NULL;
- }
- else
- status = E_GW_CONNECTION_STATUS_OK;
+ }
+ else
+ status = E_GW_CONNECTION_STATUS_OK;
/* Check if the data is found on summary */
if (gwb->priv->is_summary_ready &&
- e_book_backend_summary_is_summary_query (gwb->priv->summary, query)) {
+ e_book_backend_summary_is_summary_query (gwb->priv->summary, query)) {
if (enable_debug)
printf("reading the uids from summary file\n");
ids = e_book_backend_summary_search (gwb->priv->summary, query);
}
if (status != E_GW_CONNECTION_STATUS_OK)
- break;
+ break;
for (l = gw_items; l != NULL; l = g_list_next (l)) {
contact_num++;
ebgw->priv->categories_by_id);
/* When a distribution list is modified the server sends me a delete and add response.
- But it doesnt send me the members, so i have to explicitly request the server for the members of the distribution list */
+ But it doesnt send me the members, so i have to explicitly request the server for the members of the distribution list */
if (e_contact_get (contact, E_CONTACT_IS_LIST)) {
if(enable_debug)
} else {
if (enable_debug)
printf("contact not there\n");
- e_book_backend_db_cache_add_contact (ebgw->priv->file_db, contact);
+ e_book_backend_db_cache_add_contact (ebgw->priv->file_db, contact);
e_book_backend_summary_add_contact (ebgw->priv->summary, contact);
}
if (enable_debug) {
printf ("authenticate user ............\n");
- if(priv->book_name)
+ if(priv->book_name)
printf("book_name:%s\n", priv->book_name);
}
t = g_thread_create ((GThreadFunc) update_address_book_deltas, ebgw, TRUE, NULL);
/* spawn a thread to update the system address book cache
- * at given intervals
- */
+ * at given intervals
+ */
cache_refresh_interval_set = g_getenv ("BOOK_CACHE_REFRESH_INTERVAL");
if (cache_refresh_interval_set) {
cache_refresh_interval = g_ascii_strtod (cache_refresh_interval_set,
char *book_name;
char *uri;
char **tokens;
- const char *port;
+ const char *port;
int db_error;
DB *db;
DB_ENV *env;
priv->cache_timeout = 0;
priv->update_mutex = g_mutex_new();
priv->update_cache_mutex = g_mutex_new();
- backend->priv = priv;
+ backend->priv = priv;
if (!priv->dlock) {
priv->dlock = g_new0 (SyncUpdate, 1);
char *schema_dn; /* the base dn for schema information */
gchar *ldap_rootdn; /* the base dn of our searches */
int ldap_scope; /* the scope used for searches */
- gchar *ldap_search_filter;
+ gchar *ldap_search_filter;
int ldap_limit; /* the search limit */
int ldap_timeout; /* the search timeout */
{
#define FIND_INSERT(oc) \
if (!g_list_find_custom (existing_objectclasses, (oc), (GCompareFunc)g_ascii_strcasecmp)) \
- g_ptr_array_add (objectclasses, g_strdup ((oc)))
+ g_ptr_array_add (objectclasses, g_strdup ((oc)))
#define INSERT(oc) \
g_ptr_array_add (objectclasses, g_strdup ((oc)))
address_populate(EContact * card, char **values, EContactField field, EContactField other_field)
{
if (values[0]) {
- EContactAddress *contact_addr;
+ EContactAddress *contact_addr;
char *temp = g_strdup(values[0]);
char *i;
for (i = temp; *i != '\0'; i++) {
}
e_contact_set(card, field, temp);
- contact_addr = getormakeEContactAddress(card, other_field);
- contact_addr->street = g_strdup (temp);
- e_contact_set (card, other_field, contact_addr);
- e_contact_address_free (contact_addr);
+ contact_addr = getormakeEContactAddress(card, other_field);
+ contact_addr->street = g_strdup (temp);
+ e_contact_set (card, other_field, contact_addr);
+ e_contact_address_free (contact_addr);
g_free(temp);
}
do {
g_static_rec_mutex_lock (&eds_ldap_handler_lock);
if ((ldap_error = ldap_search_ext_s (bl->priv->ldap,
- values[j],
- LDAP_SCOPE_BASE,
- NULL,
- grpattrs, 0,
- NULL,
- NULL,
- NULL,
- view_limit,
- &result)) == LDAP_SUCCESS) {
+ values[j],
+ LDAP_SCOPE_BASE,
+ NULL,
+ grpattrs, 0,
+ NULL,
+ NULL,
+ NULL,
+ view_limit,
+ &result)) == LDAP_SUCCESS) {
/* find the e-mail ids of members */
cn_values = ldap_get_values (bl->priv->ldap, result, "cn");
email_values = ldap_get_values (bl->priv->ldap, result, "mail");
info->populate_contact_func (contact, member_info);
for (j = 0; j < count; j++) {
- g_free (*(member_info + j));
- }
- g_free (member_info);
+ g_free (*(member_info + j));
+ }
+ g_free (member_info);
}
ldap_value_free (values);
priv->supported_fields = NULL;
priv->supported_auth_methods = NULL;
- priv->ldap_limit = 100;
- priv->id_to_op = g_hash_table_new (g_int_hash, g_int_equal);
- priv->poll_timeout = -1;
+ priv->ldap_limit = 100;
+ priv->id_to_op = g_hash_table_new (g_int_hash, g_int_equal);
+ priv->poll_timeout = -1;
priv->marked_for_offline = FALSE;
priv->mode = GNOME_Evolution_Addressbook_MODE_REMOTE;
- priv->is_summary_ready = FALSE;
- priv->reserved1 = NULL;
- priv->reserved2 = NULL;
- priv->reserved3 = NULL;
- priv->reserved4 = NULL;
+ priv->is_summary_ready = FALSE;
+ priv->reserved1 = NULL;
+ priv->reserved2 = NULL;
+ priv->reserved3 = NULL;
+ priv->reserved4 = NULL;
g_static_rec_mutex_init (&priv->op_hash_mutex);
backend->priv = priv;
*token_val = res;
}
break;
-/* kind = TK_UNEXPCHAR; */
-/* break; */
+/* kind = TK_UNEXPCHAR; */
+/* break; */
}
return kind;
const char **scheme )
{
/*
- * return non-zero if this looks like a LDAP URL; zero if not
- * if non-zero returned, *urlp will be moved past "ldap://" part of URL
- */
+ * return non-zero if this looks like a LDAP URL; zero if not
+ * if non-zero returned, *urlp will be moved past "ldap://" part of URL
+ */
const char *p;
if ( url == NULL ) {
GList *fields = NULL;
fields = g_list_append (fields , g_strdup(e_contact_field_name (E_CONTACT_FILE_AS)));
- *fields_out = fields;
+ *fields_out = fields;
return GNOME_Evolution_Addressbook_Success;
}
message = soup_message_new(SOUP_METHOD_GET, uri);
soup_message_headers_append(message->request_headers,
- "User-Agent", USERAGENT);
+ "User-Agent", USERAGENT);
status = soup_session_send_message(webdav->priv->session, message);
if (status != 200) {
* DECIDE: should we also accept text/plain for webdav servers that
* don't know about text/x-vcard?*/
content_type = soup_message_headers_get(message->response_headers,
- "Content-Type");
+ "Content-Type");
if (content_type != NULL && strstr(content_type, "text/x-vcard") == NULL) {
g_message("'%s' doesn't have mime-type text/x-vcard but '%s'", uri,
- content_type);
+ content_type);
g_object_unref(message);
return NULL;
}
message = soup_message_new(SOUP_METHOD_PUT, uri);
soup_message_headers_append(message->request_headers,
- "User-Agent", USERAGENT);
+ "User-Agent", USERAGENT);
property = e_source_get_property(source, "avoid_ifmatch");
if (property != NULL && strcmp(property, "1") == 0) {
etag = e_contact_get(contact, E_CONTACT_REV);
if (etag == NULL) {
soup_message_headers_append(message->request_headers,
- "If-None-Match", "*");
+ "If-None-Match", "*");
} else if (etag[0] == 'W' && etag[1] == '/') {
g_warning("we only have a weak ETag, don't use If-Match synchronisation");
} else {
soup_message_headers_append(message->request_headers,
- "If-Match", etag);
+ "If-Match", etag);
g_free(etag);
}
}
e_contact_set(contact, E_CONTACT_REV, NULL);
request = e_vcard_to_string(E_VCARD(contact), EVC_FORMAT_VCARD_30);
soup_message_set_request(message, "text/x-vcard", SOUP_MEMORY_TEMPORARY,
- request, strlen(request));
+ request, strlen(request));
status = soup_session_send_message(webdav->priv->session, message);
new_etag = soup_message_headers_get(message->response_headers, "ETag");
static void
e_book_backend_webdav_create_contact(EBookBackend *backend,
- EDataBook *book, guint32 opid, const char *vcard)
+ EDataBook *book, guint32 opid, const char *vcard)
{
EBookBackendWebdav *webdav = E_BOOK_BACKEND_WEBDAV (backend);
EBookBackendWebdavPrivate *priv = webdav->priv;
/* do 3 rand() calls to construct a unique ID... poor way but should be
* good enough for us */
uid = g_strdup_printf("%s%08X-%08X-%08X.vcf", priv->uri, rand(), rand(),
- rand());
+ rand());
e_contact_set(contact, E_CONTACT_UID, uid);
/* kill revision field (might have been set by some other backend) */
e_data_book_respond_create(book, opid, res, NULL);
} else {
g_warning("create resource '%s' failed with http status: %d",
- uid, status);
+ uid, status);
e_data_book_respond_create(book, opid,
GNOME_Evolution_Addressbook_OtherError, NULL);
}
message = soup_message_new(SOUP_METHOD_DELETE, uri);
soup_message_headers_append(message->request_headers,
- "User-Agent", USERAGENT);
+ "User-Agent", USERAGENT);
status = soup_session_send_message(webdav->priv->session, message);
g_object_unref(message);
GNOME_Evolution_Addressbook_CallStatus res
= e_book_backend_handle_auth_request(webdav);
e_data_book_respond_remove_contacts(book, opid, res,
- deleted_ids);
+ deleted_ids);
} else {
g_warning("DELETE failed with http status %d", status);
}
static void
e_book_backend_webdav_modify_contact(EBookBackend *backend,
- EDataBook *book, guint32 opid, const char *vcard)
+ EDataBook *book, guint32 opid, const char *vcard)
{
EBookBackendWebdav *webdav = E_BOOK_BACKEND_WEBDAV(backend);
EBookBackendWebdavPrivate *priv = webdav->priv;
/* get internalized versions of some strings to avoid strcmp while
* parsing */
strings.multistatus
- = xmlTextReaderConstString(reader, BAD_CAST "multistatus");
+ = xmlTextReaderConstString(reader, BAD_CAST "multistatus");
strings.dav = xmlTextReaderConstString(reader, BAD_CAST "DAV:");
strings.href = xmlTextReaderConstString(reader, BAD_CAST "href");
strings.response = xmlTextReaderConstString(reader, BAD_CAST "response");
message = soup_message_new(SOUP_METHOD_PROPFIND, priv->uri);
soup_message_headers_append(message->request_headers,
- "User-Agent", USERAGENT);
+ "User-Agent", USERAGENT);
soup_message_headers_append(message->request_headers, "Depth", "1");
soup_message_set_request(message, "text/xml", SOUP_MEMORY_TEMPORARY,
(gchar*) request, strlen(request));
/* parse response */
reader = xmlReaderForMemory(message->response_body->data,
- message->response_body->length, NULL, NULL,
- XML_PARSE_NOWARNING);
+ message->response_body->length, NULL, NULL,
+ XML_PARSE_NOWARNING);
elements = parse_propfind_response(reader);
if (priv->username != NULL) {
soup_auth_authenticate(auth, g_strdup(priv->username),
- g_strdup(priv->password));
+ g_strdup(priv->password));
}
}
session = soup_session_sync_new();
g_signal_connect(session, "authenticate", G_CALLBACK(soup_authenticate),
- webdav);
+ webdav);
priv->session = session;
priv->proxy = e_proxy_new ();
e_book_backend_set_is_loaded(backend, TRUE);
e_book_backend_notify_connection_status(backend, TRUE);
e_book_backend_set_is_writable(backend, TRUE);
- e_book_backend_notify_writable(backend, TRUE);
+ e_book_backend_notify_writable(backend, TRUE);
return GNOME_Evolution_Addressbook_Success;
}
found_po_box = FALSE;
found_postal = FALSE;
- for (cntr = 0; cntr < linecntr; cntr++) {
+ for (cntr = 0; cntr < linecntr; cntr++) {
if (e_address_western_is_po_box (lines[cntr])) {
if (eaw->po_box == NULL)
eaw->po_box = e_address_western_extract_po_box (lines[cntr]);
/* This *must* be kept in the same order as the EContactField enum */
static const EContactFieldInfo field_info[] = {
{0,}, /* Dummy row as EContactField starts from 1 */
- STRING_FIELD (E_CONTACT_UID, EVC_UID, "id", N_("Unique ID"), FALSE),
+ STRING_FIELD (E_CONTACT_UID, EVC_UID, "id", N_("Unique ID"), FALSE),
STRING_FIELD (E_CONTACT_FILE_AS, EVC_X_FILE_AS, "file_as", N_("File Under"), FALSE),
/* URI of the book to which the contact belongs to */
STRING_FIELD (E_CONTACT_BOOK_URI, EVC_X_BOOK_URI, "book_uri", N_("Book URI"), FALSE),
/* Instant messaging fields */
MULTI_LIST_FIELD (E_CONTACT_IM_AIM, EVC_X_AIM, "im_aim", N_("AIM Screen Name List"), FALSE),
MULTI_LIST_FIELD (E_CONTACT_IM_GROUPWISE, EVC_X_GROUPWISE, "im_groupwise", N_("GroupWise Id List"), FALSE),
- MULTI_LIST_FIELD (E_CONTACT_IM_JABBER, EVC_X_JABBER, "im_jabber", N_("Jabber Id List"), FALSE),
- MULTI_LIST_FIELD (E_CONTACT_IM_YAHOO, EVC_X_YAHOO, "im_yahoo", N_("Yahoo! Screen Name List"), FALSE),
- MULTI_LIST_FIELD (E_CONTACT_IM_MSN, EVC_X_MSN, "im_msn", N_("MSN Screen Name List"), FALSE),
- MULTI_LIST_FIELD (E_CONTACT_IM_ICQ, EVC_X_ICQ, "im_icq", N_("ICQ Id List"), FALSE),
+ MULTI_LIST_FIELD (E_CONTACT_IM_JABBER, EVC_X_JABBER, "im_jabber", N_("Jabber Id List"), FALSE),
+ MULTI_LIST_FIELD (E_CONTACT_IM_YAHOO, EVC_X_YAHOO, "im_yahoo", N_("Yahoo! Screen Name List"), FALSE),
+ MULTI_LIST_FIELD (E_CONTACT_IM_MSN, EVC_X_MSN, "im_msn", N_("MSN Screen Name List"), FALSE),
+ MULTI_LIST_FIELD (E_CONTACT_IM_ICQ, EVC_X_ICQ, "im_icq", N_("ICQ Id List"), FALSE),
BOOLEAN_FIELD (E_CONTACT_WANTS_HTML, EVC_X_WANTS_HTML, "wants_html", N_("Wants HTML Mail"), FALSE),
ATTR_TYPE_STR_FIELD (E_CONTACT_IM_SKYPE_WORK_1, EVC_X_SKYPE, "im_skype_work_1", N_("Skype Work Name 1"), FALSE, "WORK", 0),
ATTR_TYPE_STR_FIELD (E_CONTACT_IM_SKYPE_WORK_2, EVC_X_SKYPE, "im_skype_work_2", N_("Skype Work Name 2"), FALSE, "WORK", 1),
ATTR_TYPE_STR_FIELD (E_CONTACT_IM_SKYPE_WORK_3, EVC_X_SKYPE, "im_skype_work_3", N_("Skype Work Name 3"), FALSE, "WORK", 2),
- MULTI_LIST_FIELD (E_CONTACT_IM_SKYPE, EVC_X_SKYPE, "im_skype", N_("Skype Name List"), FALSE),
+ MULTI_LIST_FIELD (E_CONTACT_IM_SKYPE, EVC_X_SKYPE, "im_skype", N_("Skype Name List"), FALSE),
- MULTI_LIST_FIELD (E_CONTACT_SIP, EVC_X_SIP, "sip", N_("SIP address"), FALSE),
+ MULTI_LIST_FIELD (E_CONTACT_SIP, EVC_X_SIP, "sip", N_("SIP address"), FALSE),
};
#undef LIST_ELEM_STR_FIELD
g_value_set_boxed (value, data);
} else {
g_value_set_string (value, data);
- }
+ }
} else if (info->t & E_CONTACT_FIELD_TYPE_STRING) {
g_value_set_string (value, data);
} else {
g_value_set_pointer (value, data);
- }
+ }
}
\f
typedef enum {
- E_CONTACT_UID = 1, /* string field */
- E_CONTACT_FILE_AS, /* string field */
+ E_CONTACT_UID = 1, /* string field */
+ E_CONTACT_FILE_AS, /* string field */
E_CONTACT_BOOK_URI, /* string field */
/* Name fields */
- E_CONTACT_FULL_NAME, /* string field */
- E_CONTACT_GIVEN_NAME, /* synthetic string field */
- E_CONTACT_FAMILY_NAME, /* synthetic string field */
- E_CONTACT_NICKNAME, /* string field */
+ E_CONTACT_FULL_NAME, /* string field */
+ E_CONTACT_GIVEN_NAME, /* synthetic string field */
+ E_CONTACT_FAMILY_NAME, /* synthetic string field */
+ E_CONTACT_NICKNAME, /* string field */
/* Email fields */
- E_CONTACT_EMAIL_1, /* synthetic string field */
- E_CONTACT_EMAIL_2, /* synthetic string field */
- E_CONTACT_EMAIL_3, /* synthetic string field */
+ E_CONTACT_EMAIL_1, /* synthetic string field */
+ E_CONTACT_EMAIL_2, /* synthetic string field */
+ E_CONTACT_EMAIL_3, /* synthetic string field */
E_CONTACT_EMAIL_4, /* synthetic string field */
E_CONTACT_MAILER, /* string field */
E_CONTACT_PHONE_TTYTDD,
/* Organizational fields */
- E_CONTACT_ORG, /* string field */
- E_CONTACT_ORG_UNIT, /* string field */
- E_CONTACT_OFFICE, /* string field */
- E_CONTACT_TITLE, /* string field */
- E_CONTACT_ROLE, /* string field */
- E_CONTACT_MANAGER, /* string field */
- E_CONTACT_ASSISTANT, /* string field */
+ E_CONTACT_ORG, /* string field */
+ E_CONTACT_ORG_UNIT, /* string field */
+ E_CONTACT_OFFICE, /* string field */
+ E_CONTACT_TITLE, /* string field */
+ E_CONTACT_ROLE, /* string field */
+ E_CONTACT_MANAGER, /* string field */
+ E_CONTACT_ASSISTANT, /* string field */
/* Web fields */
E_CONTACT_HOMEPAGE_URL, /* string field */
E_CONTACT_CATEGORY_LIST, /* multi-valued */
/* Photo/Logo */
- E_CONTACT_PHOTO, /* structured field (EContactPhoto) */
- E_CONTACT_LOGO, /* structured field (EContactPhoto) */
+ E_CONTACT_PHOTO, /* structured field (EContactPhoto) */
+ E_CONTACT_LOGO, /* structured field (EContactPhoto) */
- E_CONTACT_NAME, /* structured field (EContactName) */
- E_CONTACT_EMAIL, /* Multi-valued */
+ E_CONTACT_NAME, /* structured field (EContactName) */
+ E_CONTACT_EMAIL, /* Multi-valued */
/* Instant Messaging fields */
- E_CONTACT_IM_AIM, /* Multi-valued */
+ E_CONTACT_IM_AIM, /* Multi-valued */
E_CONTACT_IM_GROUPWISE, /* Multi-valued */
- E_CONTACT_IM_JABBER, /* Multi-valued */
- E_CONTACT_IM_YAHOO, /* Multi-valued */
- E_CONTACT_IM_MSN, /* Multi-valued */
- E_CONTACT_IM_ICQ, /* Multi-valued */
+ E_CONTACT_IM_JABBER, /* Multi-valued */
+ E_CONTACT_IM_YAHOO, /* Multi-valued */
+ E_CONTACT_IM_MSN, /* Multi-valued */
+ E_CONTACT_IM_ICQ, /* Multi-valued */
E_CONTACT_WANTS_HTML, /* boolean field */
E_CONTACT_IM_SKYPE_WORK_1, /* Synthetic string field */
E_CONTACT_IM_SKYPE_WORK_2, /* Synthetic string field */
E_CONTACT_IM_SKYPE_WORK_3, /* Synthetic string field */
- E_CONTACT_IM_SKYPE, /* Multi-valued */
+ E_CONTACT_IM_SKYPE, /* Multi-valued */
E_CONTACT_SIP,
char *family;
char *given;
char *additional;
- char *prefixes;
+ char *prefixes;
char *suffixes;
} EContactName;
gboolean e_destination_is_evolution_list (const EDestination *dest);
gboolean e_destination_list_show_addresses (const EDestination *dest);
const GList *e_destination_list_get_dests (const EDestination *dest);
-gboolean e_destination_is_ignored (const EDestination *dest);
-void e_destination_set_ignored (EDestination *dest, gboolean ignored);
+gboolean e_destination_is_ignored (const EDestination *dest);
+void e_destination_set_ignored (EDestination *dest, gboolean ignored);
/* If true, they want HTML mail. */
void e_destination_set_html_mail_pref (EDestination *dest, gboolean flag);
gint remaining_bytes, valid_bytes;
string = NULL;
- remainder = name;
+ remainder = name;
remaining_bytes = strlen (name);
- while (remaining_bytes != 0) {
+ while (remaining_bytes != 0) {
if (g_utf8_validate (remainder, remaining_bytes, &invalid))
break;
valid_bytes = invalid - remainder;
string = g_string_sized_new (remaining_bytes);
g_string_append_len (string, remainder, valid_bytes);
- /* append U+FFFD REPLACEMENT CHARACTER */
- g_string_append (string, "\357\277\275");
+ /* append U+FFFD REPLACEMENT CHARACTER */
+ g_string_append (string, "\357\277\275");
- remaining_bytes -= valid_bytes + 1;
- remainder = invalid + 1;
+ remaining_bytes -= valid_bytes + 1;
+ remainder = invalid + 1;
}
- if (string == NULL)
- return g_strdup (name);
+ if (string == NULL)
+ return g_strdup (name);
g_string_append (string, remainder);
#define EVC_X_ICQ "X-ICQ"
#define EVC_X_JABBER "X-JABBER"
#define EVC_X_LIST_SHOW_ADDRESSES "X-EVOLUTION-LIST-SHOW_ADDRESSES"
-#define EVC_X_LIST "X-EVOLUTION-LIST"
-#define EVC_X_MANAGER "X-EVOLUTION-MANAGER"
-#define EVC_X_MSN "X-MSN"
-#define EVC_X_SKYPE "X-SKYPE"
-#define EVC_X_RADIO "X-EVOLUTION-RADIO"
-#define EVC_X_SIP "X-SIP"
-#define EVC_X_SPOUSE "X-EVOLUTION-SPOUSE"
-#define EVC_X_TELEX "X-EVOLUTION-TELEX"
-#define EVC_X_TTYTDD "X-EVOLUTION-TTYTDD"
-#define EVC_X_VIDEO_URL "X-EVOLUTION-VIDEO-URL"
-#define EVC_X_WANTS_HTML "X-MOZILLA-HTML"
-#define EVC_X_YAHOO "X-YAHOO"
+#define EVC_X_LIST "X-EVOLUTION-LIST"
+#define EVC_X_MANAGER "X-EVOLUTION-MANAGER"
+#define EVC_X_MSN "X-MSN"
+#define EVC_X_SKYPE "X-SKYPE"
+#define EVC_X_RADIO "X-EVOLUTION-RADIO"
+#define EVC_X_SIP "X-SIP"
+#define EVC_X_SPOUSE "X-EVOLUTION-SPOUSE"
+#define EVC_X_TELEX "X-EVOLUTION-TELEX"
+#define EVC_X_TTYTDD "X-EVOLUTION-TTYTDD"
+#define EVC_X_VIDEO_URL "X-EVOLUTION-VIDEO-URL"
+#define EVC_X_WANTS_HTML "X-MOZILLA-HTML"
+#define EVC_X_YAHOO "X-YAHOO"
#define EVC_X_GADUGADU "X-GADUGADU"
-#define EVC_X_GROUPWISE "X-GROUPWISE"
-#define EVC_X_BOOK_URI "X-EVOLUTION-BOOK-URI"
+#define EVC_X_GROUPWISE "X-GROUPWISE"
+#define EVC_X_BOOK_URI "X-EVOLUTION-BOOK-URI"
typedef enum {
EVC_FORMAT_VCARD_21,
{
EBookBackendCache *cache;
- cache = g_object_new (E_TYPE_BOOK_BACKEND_CACHE, "uri", uri, NULL);
+ cache = g_object_new (E_TYPE_BOOK_BACKEND_CACHE, "uri", uri, NULL);
return cache;
}
void
e_book_backend_cache_set_populated (EBookBackendCache *cache)
{
- g_return_if_fail (E_IS_BOOK_BACKEND_CACHE (cache));
+ g_return_if_fail (E_IS_BOOK_BACKEND_CACHE (cache));
e_file_cache_add_object (E_FILE_CACHE (cache), "populated", "TRUE");
}
gboolean
e_book_backend_cache_is_populated (EBookBackendCache *cache)
{
- g_return_val_if_fail (E_IS_BOOK_BACKEND_CACHE (cache), FALSE);
+ g_return_val_if_fail (E_IS_BOOK_BACKEND_CACHE (cache), FALSE);
if (e_file_cache_get_object (E_FILE_CACHE (cache), "populated"))
return TRUE;
return FALSE;
db_error = db->get (db, NULL, &uid_dbt, &vcard_dbt,0);
if (db_error != 0)
return FALSE;
- else {
+ else {
free (vcard_dbt.data);
return TRUE;
}
(GInstanceInitFunc) ecb_caldav_factory_instance_init \
}; \
\
- if (!type) { \
+ if (!type) { \
type = g_type_module_register_type (module, \
E_TYPE_CAL_BACKEND_FACTORY, \
_name, \
*online = TRUE;
}
- return GNOME_Evolution_Calendar_Success;
+ return GNOME_Evolution_Calendar_Success;
}
/* ************************************************************************* */
static void
soup_authenticate (SoupSession *session,
- SoupMessage *msg,
+ SoupMessage *msg,
SoupAuth *auth,
gboolean retrying,
gpointer data)
check_calendar_changed_on_server (ECalBackendCalDAV *cbdav)
{
ECalBackendCalDAVPrivate *priv;
- xmlOutputBufferPtr buf;
+ xmlOutputBufferPtr buf;
SoupMessage *message;
xmlDocPtr doc;
- xmlNodePtr root, node;
+ xmlNodePtr root, node;
xmlNsPtr ns, nsdav;
- gboolean result = TRUE;
+ gboolean result = TRUE;
g_return_val_if_fail (cbdav != NULL, TRUE);
}
soup_message_set_request (message,
- "text/calendar; charset=utf-8",
+ "text/calendar; charset=utf-8",
SOUP_MEMORY_COPY,
object->cdata,
strlen (object->cdata));
ECalBackendCalDAVPrivate *priv;
ECalBackendSyncStatus result;
ECalBackend *bkend;
- icalcomponent *icomp, *subcomp;
+ icalcomponent *icomp, *subcomp;
icalcomponent_kind kind;
gboolean res;
#define etags_match(_tag1, _tag2) ((_tag1 == _tag2) ? TRUE : \
g_str_equal (_tag1 != NULL ? _tag1 : "", \
- _tag2 != NULL ? _tag2 : ""))
+ _tag2 != NULL ? _tag2 : ""))
static void
synchronize_cache (ECalBackendCalDAV *cbdav)
{
ECalComponent *comp;
- comp = e_cal_component_new ();
-
- switch (e_cal_backend_get_kind (E_CAL_BACKEND (backend))) {
- case ICAL_VEVENT_COMPONENT:
- e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_EVENT);
- break;
- case ICAL_VTODO_COMPONENT:
- e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_TODO);
- break;
- case ICAL_VJOURNAL_COMPONENT:
- e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_JOURNAL);
- break;
- default:
- g_object_unref (comp);
+ comp = e_cal_component_new ();
+
+ switch (e_cal_backend_get_kind (E_CAL_BACKEND (backend))) {
+ case ICAL_VEVENT_COMPONENT:
+ e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_EVENT);
+ break;
+ case ICAL_VTODO_COMPONENT:
+ e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_TODO);
+ break;
+ case ICAL_VJOURNAL_COMPONENT:
+ e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_JOURNAL);
+ break;
+ default:
+ g_object_unref (comp);
return GNOME_Evolution_Calendar_ObjectNotFound;
- }
+ }
- *object = e_cal_component_get_as_string (comp);
- g_object_unref (comp);
+ *object = e_cal_component_get_as_string (comp);
+ g_object_unref (comp);
return GNOME_Evolution_Calendar_Success;
}
{
ECalBackendCalDAV *cbdav;
ECalBackendCalDAVPrivate *priv;
- ECalBackendSExp *sexp;
+ ECalBackendSExp *sexp;
ECalBackendCache *bcache;
ECalBackend *bkend;
gboolean do_search;
{
ECalBackendCalDAV *cbdav;
ECalBackendCalDAVPrivate *priv;
- ECalBackendSExp *sexp;
+ ECalBackendSExp *sexp;
ECalBackend *bkend;
gboolean do_search;
GList *list, *iter;
sync_class->is_read_only_sync = caldav_is_read_only;
sync_class->get_cal_address_sync = caldav_get_cal_address;
- sync_class->get_alarm_email_address_sync = caldav_get_alarm_email_address;
- sync_class->get_ldap_attribute_sync = caldav_get_ldap_attribute;
- sync_class->get_static_capabilities_sync = caldav_get_static_capabilities;
+ sync_class->get_alarm_email_address_sync = caldav_get_alarm_email_address;
+ sync_class->get_ldap_attribute_sync = caldav_get_ldap_attribute;
+ sync_class->get_static_capabilities_sync = caldav_get_static_capabilities;
sync_class->open_sync = caldav_do_open;
sync_class->remove_sync = caldav_remove;
sync_class->discard_alarm_sync = caldav_discard_alarm;
sync_class->receive_objects_sync = caldav_receive_objects;
sync_class->send_objects_sync = caldav_send_objects;
- sync_class->get_default_object_sync = caldav_get_default_object;
+ sync_class->get_default_object_sync = caldav_get_default_object;
sync_class->get_object_sync = caldav_get_object;
sync_class->get_object_list_sync = caldav_get_object_list;
sync_class->get_timezone_sync = caldav_get_timezone;
e_cal_backend_contacts_get_static_capabilities (ECalBackendSync *backend, EDataCal *cal,
char **capabilities)
{
- *capabilities = NULL;
+ *capabilities = NULL;
return GNOME_Evolution_Calendar_Success;
}
sync_class->is_read_only_sync = e_cal_backend_contacts_is_read_only;
sync_class->get_cal_address_sync = e_cal_backend_contacts_get_cal_address;
- sync_class->get_alarm_email_address_sync = e_cal_backend_contacts_get_alarm_email_address;
- sync_class->get_ldap_attribute_sync = e_cal_backend_contacts_get_ldap_attribute;
- sync_class->get_static_capabilities_sync = e_cal_backend_contacts_get_static_capabilities;
+ sync_class->get_alarm_email_address_sync = e_cal_backend_contacts_get_alarm_email_address;
+ sync_class->get_ldap_attribute_sync = e_cal_backend_contacts_get_ldap_attribute;
+ sync_class->get_static_capabilities_sync = e_cal_backend_contacts_get_static_capabilities;
sync_class->open_sync = e_cal_backend_contacts_open;
sync_class->remove_sync = e_cal_backend_contacts_remove;
sync_class->create_object_sync = e_cal_backend_contacts_create_object;
sync_class->discard_alarm_sync = e_cal_backend_contacts_discard_alarm;
sync_class->receive_objects_sync = e_cal_backend_contacts_receive_objects;
sync_class->send_objects_sync = e_cal_backend_contacts_send_objects;
- sync_class->get_default_object_sync = e_cal_backend_contacts_get_default_object;
+ sync_class->get_default_object_sync = e_cal_backend_contacts_get_default_object;
sync_class->get_object_sync = e_cal_backend_contacts_get_object;
sync_class->get_object_list_sync = e_cal_backend_contacts_get_object_list;
sync_class->get_timezone_sync = e_cal_backend_contacts_get_timezone;
g_static_rec_mutex_free (&priv->idle_save_rmutex);
if (priv->path) {
- g_free (priv->path);
+ g_free (priv->path);
priv->path = NULL;
}
static ECalBackendSyncStatus
e_cal_backend_file_get_alarm_email_address (ECalBackendSync *backend, EDataCal *cal, char **address)
{
- /* A file backend has no particular email address associated
- * with it (although that would be a useful feature some day).
- */
+ /* A file backend has no particular email address associated
+ * with it (although that would be a useful feature some day).
+ */
*address = NULL;
return GNOME_Evolution_Calendar_Success;
/* Claim a succesful open if we are already open */
if (priv->path && priv->comp_uid_hash) {
- status = GNOME_Evolution_Calendar_Success;
+ status = GNOME_Evolution_Calendar_Success;
goto done;
}
static ECalBackendSyncStatus
e_cal_backend_file_get_default_object (ECalBackendSync *backend, EDataCal *cal, char **object)
{
- ECalComponent *comp;
-
- comp = e_cal_component_new ();
-
- switch (e_cal_backend_get_kind (E_CAL_BACKEND (backend))) {
- case ICAL_VEVENT_COMPONENT:
- e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_EVENT);
- break;
- case ICAL_VTODO_COMPONENT:
- e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_TODO);
- break;
- case ICAL_VJOURNAL_COMPONENT:
- e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_JOURNAL);
- break;
- default:
- g_object_unref (comp);
+ ECalComponent *comp;
+
+ comp = e_cal_component_new ();
+
+ switch (e_cal_backend_get_kind (E_CAL_BACKEND (backend))) {
+ case ICAL_VEVENT_COMPONENT:
+ e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_EVENT);
+ break;
+ case ICAL_VTODO_COMPONENT:
+ e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_TODO);
+ break;
+ case ICAL_VJOURNAL_COMPONENT:
+ e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_JOURNAL);
+ break;
+ default:
+ g_object_unref (comp);
return GNOME_Evolution_Calendar_ObjectNotFound;
- }
+ }
- *object = e_cal_component_get_as_string (comp);
- g_object_unref (comp);
+ *object = e_cal_component_get_as_string (comp);
+ g_object_unref (comp);
return GNOME_Evolution_Calendar_Success;
}
g_object_unref (comp);
return TRUE;
- }
+ }
return FALSE;
}
*deletes = be_data.deletes;
e_xmlhash_write (ehash);
- e_xmlhash_destroy (ehash);
+ e_xmlhash_destroy (ehash);
g_static_rec_mutex_unlock (&priv->idle_save_rmutex);
return GNOME_Evolution_Calendar_Success;
g_static_rec_mutex_lock (&priv->idle_save_rmutex);
if (!strcmp (tzid, "UTC"))
- zone = icaltimezone_get_utc_timezone ();
+ zone = icaltimezone_get_utc_timezone ();
else {
zone = icalcomponent_get_timezone (priv->icalcomp, tzid);
if (!zone)
sync_class->is_read_only_sync = e_cal_backend_file_is_read_only;
sync_class->get_cal_address_sync = e_cal_backend_file_get_cal_address;
- sync_class->get_alarm_email_address_sync = e_cal_backend_file_get_alarm_email_address;
- sync_class->get_ldap_attribute_sync = e_cal_backend_file_get_ldap_attribute;
- sync_class->get_static_capabilities_sync = e_cal_backend_file_get_static_capabilities;
+ sync_class->get_alarm_email_address_sync = e_cal_backend_file_get_alarm_email_address;
+ sync_class->get_ldap_attribute_sync = e_cal_backend_file_get_ldap_attribute;
+ sync_class->get_static_capabilities_sync = e_cal_backend_file_get_static_capabilities;
sync_class->open_sync = e_cal_backend_file_open;
sync_class->remove_sync = e_cal_backend_file_remove;
sync_class->create_object_sync = e_cal_backend_file_create_object;
sync_class->discard_alarm_sync = e_cal_backend_file_discard_alarm;
sync_class->receive_objects_sync = e_cal_backend_file_receive_objects;
sync_class->send_objects_sync = e_cal_backend_file_send_objects;
- sync_class->get_default_object_sync = e_cal_backend_file_get_default_object;
+ sync_class->get_default_object_sync = e_cal_backend_file_get_default_object;
sync_class->get_object_sync = e_cal_backend_file_get_object;
sync_class->get_object_list_sync = e_cal_backend_file_get_object_list;
sync_class->get_attachment_list_sync = e_cal_backend_file_get_attachment_list;
kind = e_cal_backend_get_kind (E_CAL_BACKEND(cbgo));
temp = icaltime_current_time_with_zone (icaltimezone_get_utc_timezone ());
- item = e_cal_backend_google_get_item (cbgo);
+ item = e_cal_backend_google_get_item (cbgo);
entries = gdata_feed_get_entries (item->feed);
priv = cbgo->priv;
comp = e_cal_component_new ();
switch (e_cal_backend_get_kind (E_CAL_BACKEND (backend))) {
case ICAL_VEVENT_COMPONENT:
- e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_EVENT);
+ e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_EVENT);
break;
case ICAL_VTODO_COMPONENT:
e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_TODO);
if (!priv->mode && priv->mode == mode) {
e_cal_backend_notify_mode (backend, GNOME_Evolution_Calendar_CalListener_MODE_SET,
- cal_mode_to_corba (mode));
+ cal_mode_to_corba (mode));
return;
}
return GNOME_Evolution_Calendar_InvalidObject;
}
- gdata_service_delete_entry (GDATA_SERVICE(priv->service), entry, NULL);
+ gdata_service_delete_entry (GDATA_SERVICE(priv->service), entry, NULL);
*object = NULL;
*old_object = strdup (calobj);
}
filename = g_build_filename (g_get_home_dir (),
".evolution/cache", source,
mangled_uri,
- NULL);
+ NULL);
g_free (mangled_uri);
priv->local_attachments_store = g_filename_to_uri (filename, NULL, NULL);
G_BEGIN_DECLS
-#define E_TYPE_CAL_BACKEND_GOOGLE (e_cal_backend_google_get_type ())
-#define E_CAL_BACKEND_GOOGLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), E_TYPE_CAL_BACKEND_GOOGLE, ECalBackendGoogle))
-#define E_CAL_BACKEND_GOOGLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), E_TYPE_CAL_BACKEND_GOOGLE, ECalBackendGoogleClass))
+#define E_TYPE_CAL_BACKEND_GOOGLE (e_cal_backend_google_get_type ())
+#define E_CAL_BACKEND_GOOGLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), E_TYPE_CAL_BACKEND_GOOGLE, ECalBackendGoogle))
+#define E_CAL_BACKEND_GOOGLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), E_TYPE_CAL_BACKEND_GOOGLE, ECalBackendGoogleClass))
#define E_IS_CAL_BACKEND_GOOGLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_TYPE_CAL_BACKEND_GOOGLE))
-#define E_IS_CAL_BACKEND_GOOGLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), E_TYPE_CAL_BACKEND_GOOGLE))
+#define E_IS_CAL_BACKEND_GOOGLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), E_TYPE_CAL_BACKEND_GOOGLE))
typedef struct _ECalBackendGoogle ECalBackendGoogle;
typedef struct _ECalBackendGoogleClass ECalBackendGoogleClass;
icaltimezone *default_zone;
const char *user_email;
- g_return_val_if_fail (E_IS_CAL_COMPONENT (comp), NULL);
+ g_return_val_if_fail (E_IS_CAL_COMPONENT (comp), NULL);
default_zone = e_cal_backend_groupwise_get_default_zone (cbgw);
item = e_gw_item_new_empty ();
e_gw_item_set_id (item, e_cal_component_get_gw_id (comp));
return status;
}
- /* if status is OK - parse result, return the list */
+ /* if status is OK - parse result, return the list */
param = soup_soap_response_get_first_parameter_by_name (response, "freeBusySessionId");
if (!param) {
g_object_unref (response);
msg = e_gw_message_new_with_header (e_gw_connection_get_uri (cnc),
e_gw_connection_get_session_id (cnc),
"closeFreeBusySessionRequest");
- e_gw_message_write_string_parameter (msg, "freeBusySessionId", NULL, session);
+ e_gw_message_write_string_parameter (msg, "freeBusySessionId", NULL, session);
e_gw_message_write_footer (msg);
/* send message to server */
msg = e_gw_message_new_with_header (e_gw_connection_get_uri (cnc),
e_gw_connection_get_session_id (cnc),
"getFreeBusyRequest");
- e_gw_message_write_string_parameter (msg, "freeBusySessionId", NULL, session);
+ e_gw_message_write_string_parameter (msg, "freeBusySessionId", NULL, session);
e_gw_message_write_footer (msg);
/* send message to server */
prop = icalcomponent_get_next_property (e_cal_component_get_icalcomponent (comp),
ICAL_X_PROPERTY);
- }
+ }
- return FALSE;
+ return FALSE;
}
char *formed_uri;
const char *use_ssl;
- EUri *parsed_uri;
+ EUri *parsed_uri;
uri = e_source_get_uri (source);
if (uri == NULL)
if (parsed_uri == NULL)
return NULL;
- port = e_source_get_property (source, "port");
+ port = e_source_get_property (source, "port");
if (port == NULL)
port = "7191";
use_ssl = e_source_get_property (source, "use_ssl");
*capabilities = g_strdup (CAL_STATIC_CAPABILITY_NO_EMAIL_ALARMS ","
CAL_STATIC_CAPABILITY_ONE_ALARM_ONLY ","
CAL_STATIC_CAPABILITY_REMOVE_ALARMS ","
- CAL_STATIC_CAPABILITY_NO_THISANDPRIOR ","
+ CAL_STATIC_CAPABILITY_NO_THISANDPRIOR ","
CAL_STATIC_CAPABILITY_NO_THISANDFUTURE ","
CAL_STATIC_CAPABILITY_NO_CONV_TO_ASSIGN_TASK ","
CAL_STATIC_CAPABILITY_NO_CONV_TO_RECUR ","
GNOME_Evolution_Calendar_MODE_REMOTE);
e_cal_backend_notify_readonly (backend, priv->read_only);
if(e_cal_backend_groupwise_is_loaded (backend))
- e_cal_backend_notify_auth_required(backend);
+ e_cal_backend_notify_auth_required(backend);
break;
case CAL_MODE_LOCAL : /* go offline */
switch (e_cal_backend_get_kind (E_CAL_BACKEND (backend))) {
case ICAL_VEVENT_COMPONENT:
- e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_EVENT);
+ e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_EVENT);
break;
case ICAL_VTODO_COMPONENT:
e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_TODO);
return;
}
- /* notify listeners of all objects */
+ /* notify listeners of all objects */
if (objects) {
e_data_cal_view_notify_objects_added (query, (const GList *) objects);
e_xmlhash_remove (be_data->ehash, key);
g_object_unref (comp);
- }
+ }
}
static ECalBackendSyncStatus
be_data.kind = e_cal_backend_get_kind (E_CAL_BACKEND (cbgw));
be_data.deletes = NULL;
be_data.ehash = ehash;
- e_xmlhash_foreach_key (ehash, (EXmlHashFunc)e_cal_backend_groupwise_compute_changes_foreach_key, &be_data);
+ e_xmlhash_foreach_key (ehash, (EXmlHashFunc)e_cal_backend_groupwise_compute_changes_foreach_key, &be_data);
*deletes = be_data.deletes;
e_xmlhash_write (ehash);
- e_xmlhash_destroy (ehash);
+ e_xmlhash_destroy (ehash);
return GNOME_Evolution_Calendar_Success;
}
else {
comps = g_slist_append (comps, component);
found = TRUE;
- }
+ }
e_cal_component_free_id (id);
}
g_free (comp_str);
}
- }
+ }
g_slist_foreach (comps, (GFunc) g_object_unref, NULL);
g_slist_free (comps);
g_object_unref (comp);
g_object_unref (modif_comp);
- return GNOME_Evolution_Calendar_Success;
+ return GNOME_Evolution_Calendar_Success;
}
sync_class->is_read_only_sync = e_cal_backend_groupwise_is_read_only;
sync_class->get_cal_address_sync = e_cal_backend_groupwise_get_cal_address;
- sync_class->get_alarm_email_address_sync = e_cal_backend_groupwise_get_alarm_email_address;
- sync_class->get_ldap_attribute_sync = e_cal_backend_groupwise_get_ldap_attribute;
- sync_class->get_static_capabilities_sync = e_cal_backend_groupwise_get_static_capabilities;
+ sync_class->get_alarm_email_address_sync = e_cal_backend_groupwise_get_alarm_email_address;
+ sync_class->get_ldap_attribute_sync = e_cal_backend_groupwise_get_ldap_attribute;
+ sync_class->get_static_capabilities_sync = e_cal_backend_groupwise_get_static_capabilities;
sync_class->open_sync = e_cal_backend_groupwise_open;
sync_class->remove_sync = e_cal_backend_groupwise_remove;
sync_class->create_object_sync = e_cal_backend_groupwise_create_object;
sync_class->discard_alarm_sync = e_cal_backend_groupwise_discard_alarm;
sync_class->receive_objects_sync = e_cal_backend_groupwise_receive_objects;
sync_class->send_objects_sync = e_cal_backend_groupwise_send_objects;
- sync_class->get_default_object_sync = e_cal_backend_groupwise_get_default_object;
+ sync_class->get_default_object_sync = e_cal_backend_groupwise_get_default_object;
sync_class->get_object_sync = e_cal_backend_groupwise_get_object;
sync_class->get_object_list_sync = e_cal_backend_groupwise_get_object_list;
sync_class->get_attachment_list_sync = e_cal_backend_groupwise_get_attachment_list;
}
if (priv->uri) {
- g_free (priv->uri);
+ g_free (priv->uri);
priv->uri = NULL;
}
static ECalBackendSyncStatus
e_cal_backend_http_get_alarm_email_address (ECalBackendSync *backend, EDataCal *cal, char **address)
{
- /* A HTTP backend has no particular email address associated
- * with it (although that would be a useful feature some day).
- */
+ /* A HTTP backend has no particular email address associated
+ * with it (although that would be a useful feature some day).
+ */
*address = NULL;
return GNOME_Evolution_Calendar_Success;
static void
soup_authenticate (SoupSession *session,
- SoupMessage *msg,
+ SoupMessage *msg,
SoupAuth *auth,
gboolean retrying,
gpointer data)
const char *secure_prop = e_source_get_property (source, "use_ssl");
priv->uri = webcal_to_http_method (e_cal_backend_get_uri (E_CAL_BACKEND (cbhttp)),
- (secure_prop && g_str_equal(secure_prop, "1")));
+ (secure_prop && g_str_equal(secure_prop, "1")));
}
/* create the Soup session if not already created */
priv = cbhttp->priv;
if (!strcmp (tzid, "UTC"))
- zone = icaltimezone_get_utc_timezone ();
+ zone = icaltimezone_get_utc_timezone ();
else {
zone = icaltimezone_get_builtin_timezone_from_tzid (tzid);
sync_class->is_read_only_sync = e_cal_backend_http_is_read_only;
sync_class->get_cal_address_sync = e_cal_backend_http_get_cal_address;
- sync_class->get_alarm_email_address_sync = e_cal_backend_http_get_alarm_email_address;
- sync_class->get_ldap_attribute_sync = e_cal_backend_http_get_ldap_attribute;
- sync_class->get_static_capabilities_sync = e_cal_backend_http_get_static_capabilities;
+ sync_class->get_alarm_email_address_sync = e_cal_backend_http_get_alarm_email_address;
+ sync_class->get_ldap_attribute_sync = e_cal_backend_http_get_ldap_attribute;
+ sync_class->get_static_capabilities_sync = e_cal_backend_http_get_static_capabilities;
sync_class->open_sync = e_cal_backend_http_open;
sync_class->remove_sync = e_cal_backend_http_remove;
sync_class->create_object_sync = e_cal_backend_http_create_object;
sync_class->discard_alarm_sync = e_cal_backend_http_discard_alarm;
sync_class->receive_objects_sync = e_cal_backend_http_receive_objects;
sync_class->send_objects_sync = e_cal_backend_http_send_objects;
- sync_class->get_default_object_sync = e_cal_backend_http_get_default_object;
+ sync_class->get_default_object_sync = e_cal_backend_http_get_default_object;
sync_class->get_object_sync = e_cal_backend_http_get_object;
sync_class->get_object_list_sync = e_cal_backend_http_get_object_list;
sync_class->get_timezone_sync = e_cal_backend_http_get_timezone;
_events_new_backend (ECalBackendFactory *factory, ESource *source)
{
return g_object_new (e_cal_backend_weather_get_type (),
- "source", source,
+ "source", source,
"kind", ICAL_VEVENT_COMPONENT,
NULL);
}
(GInstanceInitFunc) e_cal_backend_weather_factory_instance_init
};
type = g_type_module_register_type (module,
- E_TYPE_CAL_BACKEND_FACTORY,
+ E_TYPE_CAL_BACKEND_FACTORY,
"ECalBackendWeatherEventsFactory",
&info, 0);
if (priv->source_changed_id == 0)
priv->source_changed_id = g_signal_connect (G_OBJECT (source),
- "changed",
+ "changed",
G_CALLBACK (source_changed),
cbw);
* serious bandwidth, they would appreciate it if we didn't hammer their servers
*/
priv->reload_timeout_id = g_timeout_add ((refresh_str ? atoi (refresh_str) : 240) * 60000,
- (GSourceFunc) reload_cb, cbw);
+ (GSourceFunc) reload_cb, cbw);
}
const char *description;
const char *icon_name;
} categories[] = {
- { N_("Weather: Fog"), "weather-fog" },
- { N_("Weather: Cloudy"), "weather-few-clouds" },
+ { N_("Weather: Fog"), "weather-fog" },
+ { N_("Weather: Cloudy"), "weather-few-clouds" },
{ N_("Weather: Cloudy Night"), "weather-few-clouds-night" },
{ N_("Weather: Overcast"), "weather-overcast" },
- { N_("Weather: Showers"), "weather-showers" },
- { N_("Weather: Snow"), "weather-snow" },
- { N_("Weather: Sunny"), "weather-clear" },
- { N_("Weather: Clear Night"), "weather-clear-night" },
+ { N_("Weather: Showers"), "weather-showers" },
+ { N_("Weather: Snow"), "weather-snow" },
+ { N_("Weather: Sunny"), "weather-clear" },
+ { N_("Weather: Clear Night"), "weather-clear-night" },
{ N_("Weather: Thunderstorms"), "weather-storm" },
{ NULL, NULL }
};
icalcomponent *ical_comp;
struct icaltimetype itt;
ECalComponentDateTime dt;
- char *uid;
+ char *uid;
GSList *text_list = NULL;
ECalComponentText *description;
ESource *source;
/* Evolution calendar - weather backend source class for parsing
- * CCF (coded cities forecast) formatted NWS reports
+ * CCF (coded cities forecast) formatted NWS reports
*
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*
/* Evolution calendar - weather backend source class for parsing
- * CCF (coded cities forecast) formatted NWS reports
+ * CCF (coded cities forecast) formatted NWS reports
*
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*
priv->summary.altrep_param);
}
} else if (priv->summary.altrep_param) {
- icalproperty_remove_parameter (priv->summary.prop, ICAL_ALTREP_PARAMETER);
- priv->summary.altrep_param = NULL;
+ icalproperty_remove_parameter (priv->summary.prop, ICAL_ALTREP_PARAMETER);
+ priv->summary.altrep_param = NULL;
}
/* look for alarms that need a description */
G_STRUCT_OFFSET (ECalListenerClass, object_list),
NULL, NULL,
e_cal_marshal_VOID__INT_POINTER,
- G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_POINTER);
+ G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_POINTER);
signals[ATTACHMENT_LIST] =
g_signal_new ("attachment_list",
G_TYPE_FROM_CLASS (klass),
g_return_val_if_fail (listener != NULL, NULL);
g_return_val_if_fail (E_IS_CAL_LISTENER (listener), NULL);
- g_return_val_if_fail (cal_set_mode_fn != NULL, NULL);
+ g_return_val_if_fail (cal_set_mode_fn != NULL, NULL);
priv = listener->priv;
void (*discard_alarm) (ECalListener *listener, ECalendarStatus status);
- void (*receive_objects) (ECalListener *listener, ECalendarStatus status);
- void (*send_objects) (ECalListener *listener, ECalendarStatus status, GList *users, const char *object);
+ void (*receive_objects) (ECalListener *listener, ECalendarStatus status);
+ void (*send_objects) (ECalListener *listener, ECalendarStatus status, GList *users, const char *object);
void (*default_object) (ECalListener *listener, ECalendarStatus status, const char *object);
void (*object) (ECalListener *listener, ECalendarStatus status, const char *object);
ECalRecurInstanceFn cb,
gpointer cb_data,
ECalRecurResolveTimezoneFn tz_cb,
- gpointer tz_cb_data,
+ gpointer tz_cb_data,
icaltimezone *default_timezone)
{
ECalComponentDateTime dtstart, dtend;
if (len >= 0)
g_array_append_vals (all_occs, occs->data, len + 1);
- g_array_free (occs, TRUE);
+ g_array_free (occs, TRUE);
/* Skip to the next period, or exit the loop if finished. */
if ((*vtable->find_next_position) (&occ, event_end,
case E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START:
case E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_END:
dur = &trigger.u.rel_duration;
- dur_time = icaldurationtype_as_int (*dur);
+ dur_time = icaldurationtype_as_int (*dur);
if (repeat.repetitions != 0) {
int rdur;
continue;
dur = &trigger.u.rel_duration;
- dur_time = icaldurationtype_as_int (*dur);
+ dur_time = icaldurationtype_as_int (*dur);
if (trigger.type == E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START)
occur_time = start;
struct _ECal;
struct _ECalView {
- GObject object;
+ GObject object;
/*< private >*/
ECalViewPrivate *priv;
{
ECalBackendCache *cache;
- cache = g_object_new (E_TYPE_CAL_BACKEND_CACHE, "source_type", source_type, "uri", uri, NULL);
+ cache = g_object_new (E_TYPE_CAL_BACKEND_CACHE, "source_type", source_type, "uri", uri, NULL);
return cache;
}
g_return_val_if_fail (E_IS_CAL_BACKEND_CACHE (cache), NULL);
- return e_file_cache_get_object (E_FILE_CACHE (cache), "server_utc_time");
+ return e_file_cache_get_object (E_FILE_CACHE (cache), "server_utc_time");
}
static char *
typedef struct {
ECalBackendFactoryClass parent_class;
- GSList* (*get_protocol_list) (ECalBackendLoaderFactory *factory);
- ECalBackend* (*new_backend_with_protocol) (ECalBackendLoaderFactory *factory, ESource *source, const char *protocol);
+ GSList* (*get_protocol_list) (ECalBackendLoaderFactory *factory);
+ ECalBackend* (*new_backend_with_protocol) (ECalBackendLoaderFactory *factory, ESource *source, const char *protocol);
} ECalBackendLoaderFactoryClass;
GType e_cal_backend_loader_factory_get_type (void);
ECalBackendSyncStatus
e_cal_backend_sync_remove (ECalBackendSync *backend, EDataCal *cal)
{
- ECalBackendSyncStatus status;
+ ECalBackendSyncStatus status;
- g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
- LOCK_WRAPPER (remove_sync, (backend, cal));
+ LOCK_WRAPPER (remove_sync, (backend, cal));
- return status;
+ return status;
}
/**
ECalBackendSyncStatus
e_cal_backend_sync_create_object (ECalBackendSync *backend, EDataCal *cal, char **calobj, char **uid)
{
- ECalBackendSyncStatus status;
+ ECalBackendSyncStatus status;
- g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
- g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->create_object_sync != NULL,
- GNOME_Evolution_Calendar_UnsupportedMethod);
+ g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->create_object_sync != NULL,
+ GNOME_Evolution_Calendar_UnsupportedMethod);
- LOCK_WRAPPER (create_object_sync, (backend, cal, calobj, uid));
+ LOCK_WRAPPER (create_object_sync, (backend, cal, calobj, uid));
- return status;
+ return status;
}
/**
e_cal_backend_sync_modify_object (ECalBackendSync *backend, EDataCal *cal, const char *calobj,
CalObjModType mod, char **old_object, char **new_object)
{
- ECalBackendSyncStatus status;
+ ECalBackendSyncStatus status;
- g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
- g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->modify_object_sync != NULL,
- GNOME_Evolution_Calendar_UnsupportedMethod);
+ g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->modify_object_sync != NULL,
+ GNOME_Evolution_Calendar_UnsupportedMethod);
- LOCK_WRAPPER (modify_object_sync, (backend, cal, calobj, mod, old_object, new_object));
+ LOCK_WRAPPER (modify_object_sync, (backend, cal, calobj, mod, old_object, new_object));
- return status;
+ return status;
}
/**
e_cal_backend_sync_remove_object (ECalBackendSync *backend, EDataCal *cal, const char *uid, const char *rid,
CalObjModType mod, char **old_object, char **object)
{
- ECalBackendSyncStatus status;
+ ECalBackendSyncStatus status;
- g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
- g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->remove_object_sync != NULL,
- GNOME_Evolution_Calendar_UnsupportedMethod);
+ g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->remove_object_sync != NULL,
+ GNOME_Evolution_Calendar_UnsupportedMethod);
- LOCK_WRAPPER (remove_object_sync, (backend, cal, uid, rid, mod, old_object, object));
+ LOCK_WRAPPER (remove_object_sync, (backend, cal, uid, rid, mod, old_object, object));
- return status;
+ return status;
}
/**
ECalBackendSyncStatus
e_cal_backend_sync_discard_alarm (ECalBackendSync *backend, EDataCal *cal, const char *uid, const char *auid)
{
- ECalBackendSyncStatus status;
+ ECalBackendSyncStatus status;
- g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
- g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->discard_alarm_sync != NULL,
- GNOME_Evolution_Calendar_UnsupportedMethod);
+ g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->discard_alarm_sync != NULL,
+ GNOME_Evolution_Calendar_UnsupportedMethod);
- LOCK_WRAPPER (discard_alarm_sync, (backend, cal, uid, auid));
+ LOCK_WRAPPER (discard_alarm_sync, (backend, cal, uid, auid));
- return status;
+ return status;
}
/**
ECalBackendSyncStatus
e_cal_backend_sync_receive_objects (ECalBackendSync *backend, EDataCal *cal, const char *calobj)
{
- ECalBackendSyncStatus status;
+ ECalBackendSyncStatus status;
- g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
- g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->receive_objects_sync != NULL,
- GNOME_Evolution_Calendar_UnsupportedMethod);
+ g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->receive_objects_sync != NULL,
+ GNOME_Evolution_Calendar_UnsupportedMethod);
- LOCK_WRAPPER (receive_objects_sync, (backend, cal, calobj));
+ LOCK_WRAPPER (receive_objects_sync, (backend, cal, calobj));
- return status;
+ return status;
}
/**
e_cal_backend_sync_send_objects (ECalBackendSync *backend, EDataCal *cal, const char *calobj, GList **users,
char **modified_calobj)
{
- ECalBackendSyncStatus status;
+ ECalBackendSyncStatus status;
- g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
- g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->send_objects_sync != NULL,
- GNOME_Evolution_Calendar_UnsupportedMethod);
+ g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->send_objects_sync != NULL,
+ GNOME_Evolution_Calendar_UnsupportedMethod);
- LOCK_WRAPPER (send_objects_sync, (backend, cal, calobj, users, modified_calobj));
+ LOCK_WRAPPER (send_objects_sync, (backend, cal, calobj, users, modified_calobj));
- return status;
+ return status;
}
/**
ECalBackendSyncStatus
e_cal_backend_sync_get_default_object (ECalBackendSync *backend, EDataCal *cal, char **object)
{
- ECalBackendSyncStatus status;
+ ECalBackendSyncStatus status;
- g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
- g_return_val_if_fail (object, GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (object, GNOME_Evolution_Calendar_OtherError);
- LOCK_WRAPPER (get_default_object_sync, (backend, cal, object));
+ LOCK_WRAPPER (get_default_object_sync, (backend, cal, object));
- return status;
+ return status;
}
/**
ECalBackendSyncStatus
e_cal_backend_sync_get_object (ECalBackendSync *backend, EDataCal *cal, const char *uid, const char *rid, char **object)
{
- ECalBackendSyncStatus status;
+ ECalBackendSyncStatus status;
- g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
- g_return_val_if_fail (object, GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (object, GNOME_Evolution_Calendar_OtherError);
- LOCK_WRAPPER (get_object_sync, (backend, cal, uid, rid, object));
+ LOCK_WRAPPER (get_object_sync, (backend, cal, uid, rid, object));
- return status;
+ return status;
}
/**
ECalBackendSyncStatus
e_cal_backend_sync_get_object_list (ECalBackendSync *backend, EDataCal *cal, const char *sexp, GList **objects)
{
- ECalBackendSyncStatus status;
+ ECalBackendSyncStatus status;
- g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
- g_return_val_if_fail (objects, GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (objects, GNOME_Evolution_Calendar_OtherError);
- LOCK_WRAPPER (get_object_list_sync, (backend, cal, sexp, objects));
+ LOCK_WRAPPER (get_object_list_sync, (backend, cal, sexp, objects));
- return status;
+ return status;
}
/**
ECalBackendSyncStatus
e_cal_backend_sync_get_attachment_list (ECalBackendSync *backend, EDataCal *cal, const char *uid, const char *rid, GSList **attachments)
{
- ECalBackendSyncStatus status;
+ ECalBackendSyncStatus status;
- g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
- g_return_val_if_fail (attachments, GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (attachments, GNOME_Evolution_Calendar_OtherError);
- LOCK_WRAPPER (get_attachment_list_sync, (backend, cal, uid, rid, attachments));
+ LOCK_WRAPPER (get_attachment_list_sync, (backend, cal, uid, rid, attachments));
- return status;
+ return status;
}
/**
ECalBackendSyncStatus
e_cal_backend_sync_get_timezone (ECalBackendSync *backend, EDataCal *cal, const char *tzid, char **object)
{
- ECalBackendSyncStatus status;
+ ECalBackendSyncStatus status;
- g_return_val_if_fail (E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
- LOCK_WRAPPER (get_timezone_sync, (backend, cal, tzid, object));
+ LOCK_WRAPPER (get_timezone_sync, (backend, cal, tzid, object));
- return status;
+ return status;
}
/**
ECalBackendSyncStatus
e_cal_backend_sync_add_timezone (ECalBackendSync *backend, EDataCal *cal, const char *tzobj)
{
- ECalBackendSyncStatus status;
+ ECalBackendSyncStatus status;
- g_return_val_if_fail (E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
- LOCK_WRAPPER (add_timezone_sync, (backend, cal, tzobj));
+ LOCK_WRAPPER (add_timezone_sync, (backend, cal, tzobj));
- return status;
+ return status;
}
/**
ECalBackendSyncStatus
e_cal_backend_sync_set_default_zone (ECalBackendSync *backend, EDataCal *cal, const char *tz)
{
- ECalBackendSyncStatus status;
+ ECalBackendSyncStatus status;
- g_return_val_if_fail (E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
/* Old backends might be using the set_default_timezone */
if (!E_CAL_BACKEND_SYNC_GET_CLASS (backend)->set_default_zone_sync) {
tzid = icaltimezone_get_tzid (zone);
}
- LOCK_WRAPPER (set_default_timezone_sync, (backend, cal, tzid));
+ LOCK_WRAPPER (set_default_timezone_sync, (backend, cal, tzid));
icaltimezone_free (zone, 1);
return status;
}
- LOCK_WRAPPER (set_default_zone_sync, (backend, cal, tz));
+ LOCK_WRAPPER (set_default_zone_sync, (backend, cal, tz));
- return status;
+ return status;
}
/**
ECalBackendSyncStatus
e_cal_backend_sync_set_default_timezone (ECalBackendSync *backend, EDataCal *cal, const char *tzid)
{
- ECalBackendSyncStatus status;
+ ECalBackendSyncStatus status;
- g_return_val_if_fail (E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+ g_return_val_if_fail (E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
- LOCK_WRAPPER (set_default_timezone_sync, (backend, cal, tzid));
+ LOCK_WRAPPER (set_default_timezone_sync, (backend, cal, tzid));
- return status;
+ return status;
}
/**
backend_class->add_timezone = _e_cal_backend_add_timezone;
backend_class->set_default_timezone = _e_cal_backend_set_default_timezone;
backend_class->set_default_zone = _e_cal_backend_set_default_zone;
- backend_class->get_changes = _e_cal_backend_get_changes;
- backend_class->get_free_busy = _e_cal_backend_get_free_busy;
- backend_class->internal_get_timezone = _e_cal_backend_internal_get_timezone;
+ backend_class->get_changes = _e_cal_backend_get_changes;
+ backend_class->get_free_busy = _e_cal_backend_get_free_busy;
+ backend_class->internal_get_timezone = _e_cal_backend_internal_get_timezone;
object_class->dispose = e_cal_backend_sync_dispose;
}
static void
e_cal_backend_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
{
- ECalBackend *backend;
+ ECalBackend *backend;
ECalBackendPrivate *priv;
backend = E_CAL_BACKEND (object);
impl_Cal_getDefaultObject (PortableServer_Servant servant,
CORBA_Environment *ev)
{
- EDataCal *cal;
- EDataCalPrivate *priv;
+ EDataCal *cal;
+ EDataCalPrivate *priv;
- cal = E_DATA_CAL (bonobo_object_from_servant (servant));
- priv = cal->priv;
+ cal = E_DATA_CAL (bonobo_object_from_servant (servant));
+ priv = cal->priv;
- e_cal_backend_get_default_object (priv->backend, cal);
+ e_cal_backend_get_default_object (priv->backend, cal);
}
/* Cal::getObject method */
epv->remove = impl_Cal_remove;
epv->isReadOnly = impl_Cal_isReadOnly;
epv->getCalAddress = impl_Cal_getCalAddress;
- epv->getAlarmEmailAddress = impl_Cal_getAlarmEmailAddress;
- epv->getLdapAttribute = impl_Cal_getLdapAttribute;
- epv->getStaticCapabilities = impl_Cal_getStaticCapabilities;
+ epv->getAlarmEmailAddress = impl_Cal_getAlarmEmailAddress;
+ epv->getLdapAttribute = impl_Cal_getLdapAttribute;
+ epv->getStaticCapabilities = impl_Cal_getStaticCapabilities;
epv->setMode = impl_Cal_setMode;
epv->getDefaultObject = impl_Cal_getDefaultObject;
epv->getObject = impl_Cal_getObject;
CamelAddress *camel_address_new_clone (const CamelAddress *addr);
int camel_address_length (CamelAddress *addr);
-int camel_address_decode (CamelAddress *addr, const char *raw);
+int camel_address_decode (CamelAddress *addr, const char *raw);
char *camel_address_encode (CamelAddress *addr);
-int camel_address_unformat (CamelAddress *addr, const char *raw);
+int camel_address_unformat (CamelAddress *addr, const char *raw);
char *camel_address_format (CamelAddress *addr);
int camel_address_cat (CamelAddress *dest, const CamelAddress *source);
}
#define d(x) if (camel_debug("sqlite")) x
-#define START(stmt) if (camel_debug("dbtime")) { g_print ("\n===========\nDB SQL operation [%s] started\n", stmt); if (!cdb->priv->timer) { cdb->priv->timer = g_timer_new (); } else { g_timer_reset(cdb->priv->timer);} }
-#define END if (camel_debug("dbtime")) { g_timer_stop (cdb->priv->timer); g_print ("DB Operation ended. Time Taken : %f\n###########\n", g_timer_elapsed (cdb->priv->timer, NULL)); }
-#define STARTTS(stmt) if (camel_debug("dbtimets")) { g_print ("\n===========\nDB SQL operation [%s] started\n", stmt); if (!cdb->priv->timer) { cdb->priv->timer = g_timer_new (); } else { g_timer_reset(cdb->priv->timer);} }
-#define ENDTS if (camel_debug("dbtimets")) { g_timer_stop (cdb->priv->timer); g_print ("DB Operation ended. Time Taken : %f\n###########\n", g_timer_elapsed (cdb->priv->timer, NULL)); }
+#define START(stmt) if (camel_debug("dbtime")) { g_print ("\n===========\nDB SQL operation [%s] started\n", stmt); if (!cdb->priv->timer) { cdb->priv->timer = g_timer_new (); } else { g_timer_reset(cdb->priv->timer);} }
+#define END if (camel_debug("dbtime")) { g_timer_stop (cdb->priv->timer); g_print ("DB Operation ended. Time Taken : %f\n###########\n", g_timer_elapsed (cdb->priv->timer, NULL)); }
+#define STARTTS(stmt) if (camel_debug("dbtimets")) { g_print ("\n===========\nDB SQL operation [%s] started\n", stmt); if (!cdb->priv->timer) { cdb->priv->timer = g_timer_new (); } else { g_timer_reset(cdb->priv->timer);} }
+#define ENDTS if (camel_debug("dbtimets")) { g_timer_stop (cdb->priv->timer); g_print ("DB Operation ended. Time Taken : %f\n###########\n", g_timer_elapsed (cdb->priv->timer, NULL)); }
struct _CamelDBPrivate {
static int
count_cb (void *data, int argc, char **argv, char **azColName)
{
- int i;
+ int i;
- for(i=0; i<argc; i++) {
+ for(i=0; i<argc; i++) {
if (strstr(azColName[i], "COUNT")) {
*(guint32 *)data = argv [i] ? strtoul (argv [i], NULL, 10) : 0;
}
- }
+ }
- return 0;
+ return 0;
}
int
g_mutex_unlock (cdb->lock);
CAMEL_DB_RELEASE_SQLITE_MEMORY;
- if (ret != SQLITE_OK) {
- d(g_warning ("Error in select statement '%s' [%s].\n", stmt, errmsg));
+ if (ret != SQLITE_OK) {
+ d(g_warning ("Error in select statement '%s' [%s].\n", stmt, errmsg));
if (ex)
camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, errmsg);
sqlite3_free (errmsg);
errmsg = NULL;
- }
+ }
if (errmsg) {
sqlite3_free (errmsg);
/* Note that the linux man page says:
a+ Open for reading and appending (writing at end of file). The
- file is created if it does not exist. The stream is positioned
+ file is created if it does not exist. The stream is positioned
at the end of the file.
However, c99 (which glibc uses?) says:
a+ append; open or create text file for update, writing at
- end-of-file
+ end-of-file
So we must seek ourselves.
*/
static CamelMessageContentInfo * content_info_new_from_parser(CamelFolderSummary *, CamelMimeParser *);
static CamelMessageContentInfo * content_info_new_from_message(CamelFolderSummary *s, CamelMimePart *mp);
static CamelMessageContentInfo * content_info_load(CamelFolderSummary *, FILE *);
-static int content_info_save(CamelFolderSummary *, FILE *, CamelMessageContentInfo *);
-static void content_info_free(CamelFolderSummary *, CamelMessageContentInfo *);
+static int content_info_save(CamelFolderSummary *, FILE *, CamelMessageContentInfo *);
+static void content_info_free(CamelFolderSummary *, CamelMessageContentInfo *);
static int save_message_infos_to_db (CamelFolderSummary *s, gboolean fresh_mir, CamelException *ex);
static int camel_read_mir_callback (void * ref, int ncol, char ** cols, char ** name);
record->followup_flag = (char *) camel_pstring_strdup(camel_message_info_user_tag(info, "follow-up"));
record->followup_completed_on = (char *) camel_pstring_strdup(camel_message_info_user_tag(info, "completed-on"));
- record->followup_due_by = (char *) camel_pstring_strdup(camel_message_info_user_tag(info, "due-by"));
+ record->followup_due_by = (char *) camel_pstring_strdup(camel_message_info_user_tag(info, "due-by"));
tmp = g_string_new (NULL);
if (mi->references) {
#ifndef USE_GSLICE
g_free(mi);
#else
- g_slice_free1 (s->message_info_size, mi);
+ g_slice_free1 (s->message_info_size, mi);
#endif
#endif
else
CamelMessageInfo * (*message_info_new_from_parser)(CamelFolderSummary *, CamelMimeParser *);
CamelMessageInfo * (*message_info_new_from_message)(CamelFolderSummary *, CamelMimeMessage *);
CamelMessageInfo * (*message_info_load)(CamelFolderSummary *, FILE *);
- int (*message_info_save)(CamelFolderSummary *, FILE *, CamelMessageInfo *);
+ int (*message_info_save)(CamelFolderSummary *, FILE *, CamelMessageInfo *);
int (*meta_message_info_save)(CamelFolderSummary *, FILE *, FILE *, CamelMessageInfo *);
void (*message_info_free)(CamelFolderSummary *, CamelMessageInfo *);
CamelMessageContentInfo * (*content_info_new_from_parser)(CamelFolderSummary *, CamelMimeParser *);
CamelMessageContentInfo * (*content_info_new_from_message)(CamelFolderSummary *, CamelMimePart *);
CamelMessageContentInfo * (*content_info_load)(CamelFolderSummary *, FILE *);
- int (*content_info_save)(CamelFolderSummary *, FILE *, CamelMessageContentInfo *);
- void (*content_info_free)(CamelFolderSummary *, CamelMessageContentInfo *);
+ int (*content_info_save)(CamelFolderSummary *, FILE *, CamelMessageContentInfo *);
+ void (*content_info_free)(CamelFolderSummary *, CamelMessageContentInfo *);
CamelMessageInfo * (*message_info_from_uid) (CamelFolderSummary *, const char *);
/* get the next uid */
char *(*next_uid_string)(CamelFolderSummary *);
guint32 camel_folder_summary_next_uid (CamelFolderSummary *summary);
char *camel_folder_summary_next_uid_string (CamelFolderSummary *summary);
-void camel_folder_summary_set_uid (CamelFolderSummary *summary, guint32 uid);
+void camel_folder_summary_set_uid (CamelFolderSummary *summary, guint32 uid);
/* load/save the summary in its entirety */
int camel_folder_summary_load(CamelFolderSummary *summary);
d(printf("scanning children:\n"));
while (c->next) {
d(printf(" %p\n", c));
- if (c->next==child) {
+ if (c->next==child) {
d(printf("found node %p\n", child));
c->next = c->next->next;
child->parent = NULL;
CamelException *ex);
static GPtrArray *get_uids (CamelFolder *folder);
-static GPtrArray *get_uncached_uids (CamelFolder *, GPtrArray * uids, CamelException *);
+static GPtrArray *get_uncached_uids (CamelFolder *, GPtrArray * uids, CamelException *);
static void free_uids (CamelFolder *folder,
GPtrArray *array);
static gint cmp_uids (CamelFolder *folder, const char *uid1, const char *uid2);
msg->driver = driver;
camel_exception_init(&msg->ex);
camel_session_thread_queue(session, &msg->msg, 0);
- return FALSE;
+ return FALSE;
}
return TRUE;
GPtrArray * camel_folder_get_uncached_uids (CamelFolder *,
GPtrArray * uids,
CamelException *);
-gint camel_folder_cmp_uids (CamelFolder *folder, const char *uid1, const char *uid2);
+gint camel_folder_cmp_uids (CamelFolder *folder, const char *uid1, const char *uid2);
void camel_folder_sort_uids (CamelFolder *folder,
GPtrArray *uids);
#define status_backup(gpg, start, len) G_STMT_START { \
if (gpg->statusleft <= len) { \
unsigned int slen, soff; \
- \
+ \
slen = soff = gpg->statusptr - gpg->statusbuf; \
slen = slen ? slen : 1; \
- \
+ \
while (slen < soff + len) \
slen <<= 1; \
- \
+ \
gpg->statusbuf = g_realloc (gpg->statusbuf, slen + 1); \
gpg->statusptr = gpg->statusbuf + soff; \
gpg->statusleft = slen - soff; \
} \
- \
+ \
memcpy (gpg->statusptr, start, len); \
gpg->statusptr += len; \
gpg->statusleft -= len; \
{ "gb18030-0", "gb18030" },
{ "gbk-0", "GBK" },
- { "eucjp-0", "eucJP" },
- { "ujis-0", "ujis" },
+ { "eucjp-0", "eucJP" },
+ { "ujis-0", "ujis" },
{ "jisx0208.1983-0","SJIS" },
{ "jisx0212.1990-0","SJIS" },
{ "pck", "SJIS" },
void (*reset) (CamelIndexCursor *idc);
};
-CamelType camel_index_cursor_get_type(void);
+CamelType camel_index_cursor_get_type(void);
CamelIndexCursor *camel_index_cursor_new(CamelIndex *idx, const char *name);
size_t (*add_buffer)(CamelIndexName *name, const char *buffer, size_t len);
};
-CamelType camel_index_name_get_type (void);
+CamelType camel_index_name_get_type (void);
CamelIndexName *camel_index_name_new(CamelIndex *idx, const char *name);
int (*rename)(CamelIndex *idx, const char *path);
- int (*has_name)(CamelIndex *idx, const char *name);
+ int (*has_name)(CamelIndex *idx, const char *name);
CamelIndexName * (*add_name)(CamelIndex *idx, const char *name);
int (*write_name)(CamelIndex *idx, CamelIndexName *idn);
CamelIndexCursor * (*find_name)(CamelIndex *idx, const char *name);
- void (*delete_name)(CamelIndex *idx, const char *name);
- CamelIndexCursor * (*find)(CamelIndex *idx, const char *word);
+ void (*delete_name)(CamelIndex *idx, const char *name);
+ CamelIndexCursor * (*find)(CamelIndex *idx, const char *word);
CamelIndexCursor * (*words)(CamelIndex *idx);
CamelIndexCursor * (*names)(CamelIndex *idx);
/* flags, stored in 'state', set with set_state */
#define CAMEL_INDEX_DELETED (1<<0)
-CamelType camel_index_get_type (void);
+CamelType camel_index_get_type (void);
CamelIndex *camel_index_new(const char *path, int flags);
void camel_index_construct(CamelIndex *, const char *path, int flags);
/* camelMedium.c : Abstract class for a medium
*
* Authors: Bertrand Guiheneuf <bertrand@helixcode.com>
- * Michael Zucchi <notzed@ximian.com>
+ * Michael Zucchi <notzed@ximian.com>
*
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*
break;
case CAMEL_MIME_FILTER_BASIC_BASE64_DEC:
/* output can't possibly exceed the input size */
- camel_mime_filter_set_size(mf, len, FALSE);
+ camel_mime_filter_set_size(mf, len, FALSE);
newlen = g_base64_decode_step(in, len, (guchar *) mf->outbuf, &f->state, (guint *) &f->save);
g_assert(newlen <= len);
break;
CamelTransferEncoding camel_mime_filter_bestenc_get_best_encoding(CamelMimeFilterBestenc *filter, CamelBestencEncoding required);
const char * camel_mime_filter_bestenc_get_best_charset(CamelMimeFilterBestenc *filter);
-void camel_mime_filter_bestenc_set_flags(CamelMimeFilterBestenc *filter, unsigned int flags);
+void camel_mime_filter_bestenc_set_flags(CamelMimeFilterBestenc *filter, unsigned int flags);
G_END_DECLS
/* public methods */
CamelMimePart * camel_mime_part_new (void);
-void camel_mime_part_set_description (CamelMimePart *mime_part, const char *description);
+void camel_mime_part_set_description (CamelMimePart *mime_part, const char *description);
const char *camel_mime_part_get_description (CamelMimePart *mime_part);
-void camel_mime_part_set_disposition (CamelMimePart *mime_part, const char *disposition);
+void camel_mime_part_set_disposition (CamelMimePart *mime_part, const char *disposition);
const char *camel_mime_part_get_disposition (CamelMimePart *mime_part);
-void camel_mime_part_set_filename (CamelMimePart *mime_part, const char *filename);
+void camel_mime_part_set_filename (CamelMimePart *mime_part, const char *filename);
const char *camel_mime_part_get_filename (CamelMimePart *mime_part);
void camel_mime_part_set_content_id (CamelMimePart *mime_part, const char *contentid);
void camel_mime_part_set_content_location (CamelMimePart *mime_part, const char *location);
const char *camel_mime_part_get_content_location (CamelMimePart *mime_part);
-void camel_mime_part_set_encoding (CamelMimePart *mime_part, CamelTransferEncoding encoding);
+void camel_mime_part_set_encoding (CamelMimePart *mime_part, CamelTransferEncoding encoding);
CamelTransferEncoding camel_mime_part_get_encoding (CamelMimePart *mime_part);
-void camel_mime_part_set_content_languages (CamelMimePart *mime_part, GList *content_languages);
+void camel_mime_part_set_content_languages (CamelMimePart *mime_part, GList *content_languages);
const GList *camel_mime_part_get_content_languages (CamelMimePart *mime_part);
/* FIXME: what about content-type parameters? what about major/minor parts? */
-void camel_mime_part_set_content_type (CamelMimePart *mime_part, const char *content_type);
+void camel_mime_part_set_content_type (CamelMimePart *mime_part, const char *content_type);
CamelContentType *camel_mime_part_get_content_type (CamelMimePart *mime_part);
/* construction */
int camel_mime_part_construct_from_parser (CamelMimePart *mime_part, CamelMimeParser *parser);
/* utility functions */
-void camel_mime_part_set_content (CamelMimePart *mime_part,
+void camel_mime_part_set_content (CamelMimePart *mime_part,
const char *data, int length, const char *type);
size_t camel_mime_part_get_content_size (CamelMimePart *mime_part);
if (uulen >= 3) {
*outptr++ = CAMEL_UUDECODE_CHAR (b0) << 2 | CAMEL_UUDECODE_CHAR (b1) >> 4;
*outptr++ = CAMEL_UUDECODE_CHAR (b1) << 4 | CAMEL_UUDECODE_CHAR (b2) >> 2;
- *outptr++ = CAMEL_UUDECODE_CHAR (b2) << 6 | CAMEL_UUDECODE_CHAR (b3);
+ *outptr++ = CAMEL_UUDECODE_CHAR (b2) << 6 | CAMEL_UUDECODE_CHAR (b3);
} else {
if (uulen >= 1) {
*outptr++ = CAMEL_UUDECODE_CHAR (b0) << 2 | CAMEL_UUDECODE_CHAR (b1) >> 4;
case 8:
case 10:
case 12:
- return 31;
+ return 31;
case 4:
case 6:
case 9:
case 11:
- return 30;
+ return 30;
case 2:
- if (g_date_is_leap_year (year))
- return 29;
+ if (g_date_is_leap_year (year))
+ return 29;
else
- return 28;
+ return 28;
default:
- return 0;
+ return 0;
}
}
#endif
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
*
* Authors: Michael Zucchi <notzed@ximian.com>
- * Jeffrey Stedfast <fejj@ximian.com>
+ * Jeffrey Stedfast <fejj@ximian.com>
* Chris Toshok <toshok@ximian.com>
*
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
int req_length; \
char *p; \
int i; \
- \
+ \
/* check to make sure we have enough room in our buffer */ \
req_length = 0; \
if (h->h_aliases) { \
req_length += strlen (h->h_aliases[i]) + 1; \
num_aliases = i; \
} \
- \
+ \
if (h->h_addr_list) { \
for (i = 0; h->h_addr_list[i]; i++) \
req_length += h->h_length; \
num_addrs = i; \
} \
- \
+ \
req_length += sizeof (char *) * (num_aliases + 1); \
req_length += sizeof (char *) * (num_addrs + 1); \
req_length += strlen (h->h_name) + 1; \
- \
+ \
if (buflen < req_length) { \
*herr = ERANGE; \
G_UNLOCK (gethost_mutex); \
return ERANGE; \
} \
- \
+ \
/* we store the alias/addr pointers in the buffer */ \
/* their addresses here. */ \
p = buf; \
p += sizeof (char *) * (num_addrs + 1); \
} else \
host->h_addr_list = NULL; \
- \
+ \
/* copy the host name into the buffer */ \
host->h_name = p; \
strcpy (p, h->h_name); \
p += strlen (h->h_name) + 1; \
host->h_addrtype = h->h_addrtype; \
host->h_length = h->h_length; \
- \
+ \
/* copy the aliases/addresses into the buffer */ \
/* and assign pointers into the hostent */ \
*p = 0; \
} \
host->h_aliases[num_aliases] = NULL; \
} \
- \
+ \
if (num_addrs) { \
for (i = 0; i < num_addrs; i++) { \
memcpy (p, h->h_addr_list[i], h->h_length); \
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
*
* Authors: Michael Zucchi <notzed@ximian.com>
- * Jeffrey Stedfast <fejj@ximian.com>
+ * Jeffrey Stedfast <fejj@ximian.com>
*
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*
#include "camel-object.h"
#define d(x)
-#define b(x) /* object bag */
-#define h(x) /* hooks */
+#define b(x) /* object bag */
+#define h(x) /* hooks */
/* I just mashed the keyboard for these... */
-#define CAMEL_OBJECT_MAGIC 0x77A344ED
-#define CAMEL_OBJECT_CLASS_MAGIC 0xEE26A997
-#define CAMEL_INTERFACE_MAGIC 0xBCE137A7
+#define CAMEL_OBJECT_MAGIC 0x77A344ED
+#define CAMEL_OBJECT_CLASS_MAGIC 0xEE26A997
+#define CAMEL_INTERFACE_MAGIC 0xBCE137A7
#define CAMEL_OBJECT_FINALISED_MAGIC 0x84AC365F
#define CAMEL_OBJECT_CLASS_FINALISED_MAGIC 0x7621ABCD
#define CAMEL_INTERFACE_FINALISED_MAGIC 0x7CB2FE71
Version 0 of the file:
version:uint32 = 0
- count:uint32 -- count of meta-data items
+ count:uint32 -- count of meta-data items
( name:string value:string ) *count -- meta-data items
Version 1 of the file adds:
uids = camel_folder_get_uids (folder);
if (!uids)
- goto done;
+ goto done;
uncached_uids = camel_folder_get_uncached_uids(folder, uids, ex);
if (uids) {
if (expression)
{ "match-all", (ESExpFunc *)match_all, 1 },
{ "match-threads", (ESExpFunc *)match_threads, 1 },
-/* { "body-contains", body_contains}, */ /* We don't store body on the db. */
+/* { "body-contains", body_contains}, */ /* We don't store body on the db. */
{ "header-contains", header_contains, 0},
{ "header-matches", header_matches, 0},
{ "header-starts-with", header_starts_with, 0},
char *str = g_strdup_printf("NOT ( %s )", n->exact_token);
g_free (n->exact_token);
n->exact_token = str;
- all = g_list_prepend (all, n);
+ all = g_list_prepend (all, n);
if (preserve) {
GList *foo;
foo = preserve;
}
if (!lastoper)
- free_node (n1);
+ free_node (n1);
g_list_free (res);
res = NULL;
tmp = all;
/* public methods */
off_t camel_seekable_stream_seek (CamelSeekableStream *stream, off_t offset,
CamelStreamSeekPolicy policy);
-off_t camel_seekable_stream_tell (CamelSeekableStream *stream);
+off_t camel_seekable_stream_tell (CamelSeekableStream *stream);
int camel_seekable_stream_set_bounds (CamelSeekableStream *stream, off_t start, off_t end);
G_END_DECLS
void camel_session_forward_to (CamelSession *session,
struct _CamelFolder *folder,
- struct _CamelMimeMessage *message,
+ struct _CamelMimeMessage *message,
const char *address,
CamelException *ex);
cs (SEC_ERROR_EXPIRED_ISSUER_CERTIFICATE, "The certificate issuer's certificate has expired. Check your system date and time.")
cs (SEC_ERROR_CRL_EXPIRED, "The CRL for the certificate's issuer has expired. Update it or check your system date and time.")
cs (SEC_ERROR_CRL_BAD_SIGNATURE, "The CRL for the certificate's issuer has an invalid signature.")
- cs (SEC_ERROR_CRL_INVALID, "New CRL has an invalid format.")
+ cs (SEC_ERROR_CRL_INVALID, "New CRL has an invalid format.")
cs (SEC_ERROR_EXTENSION_VALUE_INVALID, "Certificate extension value is invalid.")
cs (SEC_ERROR_EXTENSION_NOT_FOUND, "Certificate extension not found.")
cs (SEC_ERROR_CA_CERT_INVALID, "Issuer certificate is invalid.")
dec = NSS_CMSDecoder_Start(NULL,
NULL, NULL, /* content callback */
- NULL, NULL, /* password callback */
+ NULL, NULL, /* password callback */
NULL, NULL); /* decrypt key callback */
camel_data_wrapper_decode_to_stream(camel_medium_get_content_object((CamelMedium *)sigpart), (CamelStream *)mem);
PLArenaPool *poolp;
NSSCMSMessage *cmsg = NULL;
NSSCMSEnvelopedData *envd;
- NSSCMSEncoderContext *enc = NULL;
+ NSSCMSEncoderContext *enc = NULL;
CamelStreamMem *mem;
CamelStream *ostream = NULL;
CamelDataWrapper *dw;
/* public methods */
CamelFolder * camel_store_get_folder (CamelStore *store,
- const char *folder_name,
+ const char *folder_name,
guint32 flags,
- CamelException *ex);
+ CamelException *ex);
CamelFolder * camel_store_get_inbox (CamelStore *store,
CamelException *ex);
CamelFolder * camel_store_get_trash (CamelStore *store,
CamelIndexClass parent_class;
};
-CamelType camel_text_index_get_type (void);
+CamelType camel_text_index_get_type (void);
CamelTextIndex *camel_text_index_new(const char *path, int flags);
/* static utility functions */
/* auto update vfolders shouldn't need a rebuild */
-/* if ((vf->flags & CAMEL_STORE_VEE_FOLDER_AUTO) == 0 */
-/* && camel_vee_folder_rebuild_folder(vf, f, ex) == -1) */
-/* break; */
+/* if ((vf->flags & CAMEL_STORE_VEE_FOLDER_AUTO) == 0 */
+/* && camel_vee_folder_rebuild_folder(vf, f, ex) == -1) */
+/* break; */
node = node->next;
}
gboolean ret;
HANDLE_NULL_INFO(FALSE);
- ret = camel_message_info_user_flag (rmi, id);
+ ret = camel_message_info_user_flag (rmi, id);
camel_message_info_free (rmi);
return ret;
static int
callback (void *data, int argc, char **argv, char **azColName)
{
- int i;
- for(i=0; i<argc; i++) {
- printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
- }
- printf("--DONE \n");
+ int i;
+ for(i=0; i<argc; i++) {
+ printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
+ }
+ printf("--DONE \n");
- return 0;
+ return 0;
}
static int
select_stmt (const char* stmt) {
- char *errmsg;
- int ret;
- int nrecs = 0;
+ char *errmsg;
+ int ret;
+ int nrecs = 0;
- ret = sqlite3_exec(db, stmt, callback, &nrecs, &errmsg);
+ ret = sqlite3_exec(db, stmt, callback, &nrecs, &errmsg);
- if(ret!=SQLITE_OK) {
- printf("Error in select statement %s [%s].\n", stmt, errmsg);
- } else {
- printf("\n %d records returned.\n", nrecs);
- }
+ if(ret!=SQLITE_OK) {
+ printf("Error in select statement %s [%s].\n", stmt, errmsg);
+ } else {
+ printf("\n %d records returned.\n", nrecs);
+ }
return ret;
}
static int
sql_stmt(const char* stmt) {
- char *errmsg;
- int ret;
+ char *errmsg;
+ int ret;
- ret = sqlite3_exec(db, stmt, 0, 0, &errmsg);
+ ret = sqlite3_exec(db, stmt, 0, 0, &errmsg);
- if(ret != SQLITE_OK) {
- printf("Error in statement: %s [%s].\n", stmt, errmsg);
+ if(ret != SQLITE_OK) {
+ printf("Error in statement: %s [%s].\n", stmt, errmsg);
exit (1);
- }
+ }
return ret;
}
char *zErrMsg = 0;
int rc;
-// rc = sqlite3_open_v2("test.db", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE , NULL);
+// rc = sqlite3_open_v2("test.db", &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE , NULL);
rc = sqlite3_open("test.db", &db);
- if( rc ) {
- fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
- sqlite3_close(db);
- exit(1);
- }
+ if( rc ) {
+ fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
+ sqlite3_close(db);
+ exit(1);
+ }
sqlite3_create_collation(db, "uidcmp", SQLITE_UTF8, NULL, sort_cmp);
sqlite3_create_collation(db, "uidsort", SQLITE_UTF8, NULL, sort_uid);
printf("------\n");
select_stmt ("select count(isize) from table1");
- sqlite3_close(db);
+ sqlite3_close(db);
- return 0;
+ return 0;
}
CAMEL_GROUPWISE_FOLDER_REC_LOCK (folder, cache_lock);
if ((cache_stream = camel_data_cache_add (gw_folder->cache, "cache", id, NULL))) {
- if (camel_data_wrapper_write_to_stream ((CamelDataWrapper *) mail_msg, cache_stream) == -1 || camel_stream_flush (cache_stream) == -1)
+ if (camel_data_wrapper_write_to_stream ((CamelDataWrapper *) mail_msg, cache_stream) == -1 || camel_stream_flush (cache_stream) == -1)
camel_data_cache_remove (gw_folder->cache, "cache", id, NULL);
camel_object_unref (cache_stream);
}
if (use_imap)
groupwise_provider.object_types[CAMEL_PROVIDER_STORE] = imap_provider->object_types [CAMEL_PROVIDER_STORE];
- else {
+ else {
groupwise_provider.object_types[CAMEL_PROVIDER_STORE] = camel_groupwise_store_get_type();
groupwise_provider.object_types[CAMEL_PROVIDER_TRANSPORT] = camel_groupwise_transport_get_type();
}
}
}
- container_id = g_strdup (g_hash_table_lookup (priv->name_hash, folder_name));
+ container_id = g_strdup (g_hash_table_lookup (priv->name_hash, folder_name));
storage_path = g_strdup_printf("%s/folders", priv->storage_path);
}
}
- container_id = g_strdup (g_hash_table_lookup (priv->name_hash, folder->full_name));
+ container_id = g_strdup (g_hash_table_lookup (priv->name_hash, folder->full_name));
si = camel_store_summary_path ((CamelStoreSummary *)gw_store->summary, folder->name);
if (si) {
static void
groupwise_rename_folder(CamelStore *store,
- const char *old_name,
+ const char *old_name,
const char *new_name,
CamelException *ex)
{
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*
* Authors:
- * parthasrathi susarla <sparthasrathi@novell.com>
+ * parthasrathi susarla <sparthasrathi@novell.com>
* Based on the IMAP summary class implementation by:
* Michael Zucchi <notzed@ximian.com>
* Dan Winship <danw@ximian.com>
service = CAMEL_SERVICE(transport);
url = camel_url_to_string (service->url,
- (CAMEL_URL_HIDE_PASSWORD |
+ (CAMEL_URL_HIDE_PASSWORD |
CAMEL_URL_HIDE_PARAMS |
CAMEL_URL_HIDE_AUTH) );
/* Copy the mangled path. */
p = vpath;
- while (1) {
+ while (1) {
newp = strchr (p, '/');
if (newp == NULL) {
strcpy (dp, p);
gboolean ok;
CamelFolderChangeInfo *changes = NULL;
- if (camel_application_is_exiting)
- return;
+ if (camel_application_is_exiting)
+ return;
imap_folder->need_rescan = FALSE;
static CamelImapMessageInfo *
imap_folder_summary_uid_or_error(CamelFolderSummary *summary, const char * uid, CamelException *ex)
{
- CamelImapMessageInfo *mi;
+ CamelImapMessageInfo *mi;
mi = (CamelImapMessageInfo *)camel_folder_summary_uid (summary, uid);
if (mi == NULL) {
camel_exception_setv (
- ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID,
+ ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID,
_("Cannot get message with message ID %s: %s"),
uid, _("No such message available."));
}
/* FIXME: If it enters if(info) it will always match the exception. So stupid */
/* FIXME[disk-summary] Use a db query to see if the DB exists */
-/* info = (CamelImapMessageInfo *)camel_folder_summary_uid(folder->summary, uid); */
-/* if (info) { */
-/* for (seq = 0; seq < camel_folder_summary_count (folder->summary); seq++) { */
-/* if (folder->summary->messages->pdata[seq] == info) */
-/* break; */
-/* } */
-
-/* g_warning("Message already present? %s", camel_message_info_uid(mi)); */
-/* camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, */
-/* _("Unexpected server response: Identical UIDs provided for messages %d and %d"), */
-/* seq + 1, i + first); */
-
-/* camel_message_info_free(&info->info); */
-/* break; */
-/* } */
+/* info = (CamelImapMessageInfo *)camel_folder_summary_uid(folder->summary, uid); */
+/* if (info) { */
+/* for (seq = 0; seq < camel_folder_summary_count (folder->summary); seq++) { */
+/* if (folder->summary->messages->pdata[seq] == info) */
+/* break; */
+/* } */
+
+/* g_warning("Message already present? %s", camel_message_info_uid(mi)); */
+/* camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, */
+/* _("Unexpected server response: Identical UIDs provided for messages %d and %d"), */
+/* seq + 1, i + first); */
+
+/* camel_message_info_free(&info->info); */
+/* break; */
+/* } */
((CamelMessageInfoBase *)mi)->dirty = TRUE;
if (((CamelMessageInfoBase *)mi)->summary)
case CAMEL_IMAP_JOURNAL_ENTRY_EXPUNGE:
uids = imap_entry->uids;
- if (encode_uids (out, uids))
+ if (encode_uids (out, uids))
return -1;
case CAMEL_IMAP_JOURNAL_ENTRY_APPEND:
if (camel_file_util_encode_string (out, imap_entry->append_uid))
fprintf (stderr, "NIL");
break;
case CAMEL_IMAP4_TOKEN_ATOM:
- fprintf (stderr, "%s", token->v.atom);
+ fprintf (stderr, "%s", token->v.atom);
break;
case CAMEL_IMAP4_TOKEN_QSTRING:
- fprintf (stderr, "\"%s\"", token->v.qstring);
+ fprintf (stderr, "\"%s\"", token->v.qstring);
break;
case CAMEL_IMAP4_TOKEN_LITERAL:
fprintf (stderr, "{%u}", token->v.literal);
#define token_save(imap4, start, len) G_STMT_START { \
if (imap4->tokenleft <= len) { \
unsigned int tlen, toff; \
- \
+ \
tlen = toff = imap4->tokenptr - imap4->tokenbuf; \
tlen = tlen ? tlen : 1; \
- \
+ \
while (tlen < toff + len) \
tlen <<= 1; \
- \
+ \
imap4->tokenbuf = g_realloc (imap4->tokenbuf, tlen + 1); \
imap4->tokenptr = imap4->tokenbuf + toff; \
imap4->tokenleft = tlen - toff; \
} \
- \
+ \
memcpy (imap4->tokenptr, start, len); \
imap4->tokenptr += len; \
imap4->tokenleft -= len; \
CamelObjectClass parent_class;
};
-CamelType camel_imapp_driver_get_type (void);
+CamelType camel_imapp_driver_get_type (void);
CamelIMAPPDriver * camel_imapp_driver_new(CamelIMAPPStream *stream);
CamelIMAPPEngine *camel_imapp_engine_new(CamelIMAPPStream *stream);
void camel_imapp_engine_add_handler(CamelIMAPPEngine *imap, const char *response, CamelIMAPPEngineFunc func, void *data);
-int camel_imapp_engine_iterate(CamelIMAPPEngine *imap, CamelIMAPPCommand *wait); /* throws PARSE,IO exception */
+int camel_imapp_engine_iterate(CamelIMAPPEngine *imap, CamelIMAPPCommand *wait); /* throws PARSE,IO exception */
int camel_imapp_engine_skip(CamelIMAPPEngine *imap);
int camel_imapp_engine_capabilities(CamelIMAPPEngine *imap);
void camel_imapp_engine_command_complete(CamelIMAPPEngine *imap, struct _CamelIMAPPCommand *, CamelIMAPPCommandFunc func, void *data);
void camel_imapp_engine_command_add (CamelIMAPPEngine *imap, CamelIMAPPCommand *ic, const char *fmt, ...);
void camel_imapp_engine_command_free (CamelIMAPPEngine *imap, CamelIMAPPCommand *ic);
-void camel_imapp_engine_command_queue(CamelIMAPPEngine *imap, CamelIMAPPCommand *ic); /* throws IO exception */
+void camel_imapp_engine_command_queue(CamelIMAPPEngine *imap, CamelIMAPPCommand *ic); /* throws IO exception */
CamelIMAPPCommand *camel_imapp_engine_command_find (CamelIMAPPEngine *imap, const char *name);
CamelIMAPPCommand *camel_imapp_engine_command_find_tag(CamelIMAPPEngine *imap, unsigned int tag);
void camel_imapp_stream_ungettoken (CamelIMAPPStream *is, camel_imapp_token_t tok, unsigned char *token, unsigned int len);
void camel_imapp_stream_set_literal (CamelIMAPPStream *is, unsigned int literal);
-int camel_imapp_stream_gets (CamelIMAPPStream *is, unsigned char **start, unsigned int *len);
-int camel_imapp_stream_getl (CamelIMAPPStream *is, unsigned char **start, unsigned int *len);
+int camel_imapp_stream_gets (CamelIMAPPStream *is, unsigned char **start, unsigned int *len);
+int camel_imapp_stream_getl (CamelIMAPPStream *is, unsigned char **start, unsigned int *len);
/* all throw IO,PARSE exceptions */
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
*
* Authors:
- * Michael Zucchi <notzed@ximian.com>
+ * Michael Zucchi <notzed@ximian.com>
*
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*
static CamelMessageInfo * message_info_new_from_parser(CamelFolderSummary *, CamelMimeParser *);
static CamelMessageInfo * message_info_load (CamelFolderSummary *, FILE *);
static int message_info_save (CamelFolderSummary *, FILE *, CamelMessageInfo *);
-static int meta_message_info_save(CamelFolderSummary *s, FILE *out_meta, FILE *out, CamelMessageInfo *mi);
+static int meta_message_info_save(CamelFolderSummary *s, FILE *out_meta, FILE *out, CamelMessageInfo *mi);
/*static void message_info_free (CamelFolderSummary *, CamelMessageInfo *);*/
static char *mbox_summary_encode_x_evolution (CamelLocalSummary *cls, const CamelLocalMessageInfo *mi);
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
*
* Authors:
- * Michael Zucchi <notzed@ximian.com>
+ * Michael Zucchi <notzed@ximian.com>
*
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*
CamelException *ex)
{
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
- _("You cannot post NNTP messages while working offline!"));
+ _("You cannot post NNTP messages while working offline!"));
}
/* I do not know what to do this exactly. Looking at the IMAP implementation for this, it
GPtrArray **transferred_uids, gboolean delete_orig, CamelException *ex)
{
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
- _("You cannot copy messages from a NNTP folder!"));
+ _("You cannot copy messages from a NNTP folder!"));
}
static void
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*
* Authors: Christopher Toshok <toshok@ximian.com>
- * Michael Zucchi <notzed@ximian.com>
+ * Michael Zucchi <notzed@ximian.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of version 2 of the GNU Lesser General Public
static int camel_nntp_try_authenticate (CamelNNTPStore *store, CamelException *ex);
static void nntp_construct (CamelService *service, CamelSession *session,
- CamelProvider *provider, CamelURL *url,
- CamelException *ex);
+ CamelProvider *provider, CamelURL *url,
+ CamelException *ex);
static gboolean
&& camel_nntp_try_authenticate(store, ex) != NNTP_AUTH_ACCEPTED)
goto fail;
- /* set 'reader' mode & ignore return code, also ping the server, inn goes offline very quickly otherwise */
+ /* set 'reader' mode & ignore return code, also ping the server, inn goes offline very quickly otherwise */
if (camel_nntp_raw_command_auth (store, ex, (char **) &buf, "mode reader") == -1
|| camel_nntp_raw_command_auth (store, ex, (char **) &buf, "date") == -1)
- goto fail;
+ goto fail;
if (xover_setup(store, ex) == -1)
goto fail;
if (!si) {
camel_exception_setv (ex, CAMEL_EXCEPTION_FOLDER_INVALID,
_("You cannot subscribe to this newsgroup:\n\n"
- "No such newsgroup. The selected item is a probably a parent folder."));
+ "No such newsgroup. The selected item is a probably a parent folder."));
} else {
if (!(si->flags & CAMEL_STORE_INFO_FOLDER_SUBSCRIBED)) {
si->flags |= CAMEL_STORE_INFO_FOLDER_SUBSCRIBED;
if (!fitem) {
camel_exception_setv (ex, CAMEL_EXCEPTION_FOLDER_INVALID,
_("You cannot unsubscribe to this newsgroup:\n\n"
- "newsgroup does not exist!"));
+ "newsgroup does not exist!"));
} else {
if (fitem->flags & CAMEL_STORE_INFO_FOLDER_SUBSCRIBED) {
fitem->flags &= ~CAMEL_STORE_INFO_FOLDER_SUBSCRIBED;
const char *folder_name, CamelException *ex)
{
camel_exception_setv (ex, CAMEL_EXCEPTION_FOLDER_INVALID,
- _("You cannot create a folder in a News store: subscribe instead."));
+ _("You cannot create a folder in a News store: subscribe instead."));
return NULL;
}
nntp_rename_folder (CamelStore *store, const char *old_name, const char *new_name_in, CamelException *ex)
{
camel_exception_setv (ex, CAMEL_EXCEPTION_FOLDER_INVALID,
- _("You cannot rename a folder in a News store."));
+ _("You cannot rename a folder in a News store."));
}
static void
{
nntp_store_unsubscribe_folder (store, folder_name, ex);
camel_exception_setv (ex, CAMEL_EXCEPTION_FOLDER_INVALID,
- _("You cannot remove a folder in a News store: unsubscribe instead."));
+ _("You cannot remove a folder in a News store: unsubscribe instead."));
return;
}
void camel_nntp_stream_set_mode (CamelNNTPStream *is, camel_nntp_stream_mode_t mode);
int camel_nntp_stream_line (CamelNNTPStream *is, unsigned char **data, unsigned int *len);
-int camel_nntp_stream_gets (CamelNNTPStream *is, unsigned char **start, unsigned int *len);
-int camel_nntp_stream_getd (CamelNNTPStream *is, unsigned char **start, unsigned int *len);
+int camel_nntp_stream_gets (CamelNNTPStream *is, unsigned char **start, unsigned int *len);
+int camel_nntp_stream_getd (CamelNNTPStream *is, unsigned char **start, unsigned int *len);
G_END_DECLS
void camel_pop3_engine_command_free(CamelPOP3Engine *pe, CamelPOP3Command *pc);
-int camel_pop3_engine_iterate (CamelPOP3Engine *pe, CamelPOP3Command *pc);
+int camel_pop3_engine_iterate (CamelPOP3Engine *pe, CamelPOP3Command *pc);
CamelPOP3Command *camel_pop3_engine_command_new (CamelPOP3Engine *pe, guint32 flags, CamelPOP3CommandFunc func, void *data, const char *fmt, ...);
void camel_pop3_stream_set_mode (CamelPOP3Stream *is, camel_pop3_stream_mode_t mode);
int camel_pop3_stream_line (CamelPOP3Stream *is, unsigned char **data, unsigned int *len);
-int camel_pop3_stream_gets (CamelPOP3Stream *is, unsigned char **start, unsigned int *len);
-int camel_pop3_stream_getd (CamelPOP3Stream *is, unsigned char **start, unsigned int *len);
+int camel_pop3_stream_gets (CamelPOP3Stream *is, unsigned char **start, unsigned int *len);
+int camel_pop3_stream_getd (CamelPOP3Stream *is, unsigned char **start, unsigned int *len);
G_END_DECLS
{ { 1, 0, 0 }, "(= 72000 (get-sent-date))" },
{ { 0, 0, 0 }, "(= 72001 (get-sent-date))" },
- { { (100/2-1)/17+1, (50/2-1)/17+1, 0 }, "(and (user-flag \"every17\") (< 72000 (get-sent-date)))" },
+ { { (100/2-1)/17+1, (50/2-1)/17+1, 0 }, "(and (user-flag \"every17\") (< 72000 (get-sent-date)))" },
{ { (100/2-1)/17+1, (50/2-1)/17, 0 }, "(and (user-flag \"every17\") (> 72000 (get-sent-date)))" },
{ { (100/2-1)/13+1, (50/2-1)/13+1, 0 }, "(and (user-flag \"every13\") (< 72000 (get-sent-date)))" },
{ { (100/2-1)/13+1, (50/2-1)/13+1, 0 }, "(and (user-flag \"every13\") (> 72000 (get-sent-date)))" },
reading/writing different charsets
Just testing streams:
- different stream types
+ different stream types
different file ops
seek, eof, etc.
*/
guint32 unicode[200];
} tests[] = {
/* the escape char */
- { "&", "&-",
+ { "&", "&-",
{ 0x0026, } },
/* part of set D */
{ "+", "+",
}
if (!progname) {
if ((progname = __db_rpath(*nargv)) == NULL)
- progname = *nargv;
- else
- ++progname;
+ progname = *nargv;
+ else
+ ++progname;
}
if (optreset || !*place) { /* update scanning pointer */
progname, optopt);
return (BADCH);
}
- else /* white space */
+ else /* white space */
optarg = nargv[optind];
place = EMSG;
++optind;
if (txn == NULL) /* case 3 */
snprintf(retp, len,
"%.*s%s%s.", plen, name, BACKUP_PREFIX, p);
- else /* case 4 */
+ else /* case 4 */
snprintf(retp, len,
"%.*s%x.%x.", plen, name, lsn.file, lsn.offset);
}
#define MUTEX_SET(tsl) ({ \
int __r; \
asm volatile("swpb %0, %1, [%2]" \
- : "=r" (__r) \
+ : "=r" (__r) \
: "0" (1), "r" (tsl) \
: "memory" \
); \
__db_mutex_tas_dummy()
{
__asm__ __volatile__(" \n\
- .globl ___db_mutex_set \n\
+ .globl ___db_mutex_set \n\
___db_mutex_set: \n\
lwarx r5,0,r3 \n\
- cmpwi r5,0 \n\
- bne fail \n\
- addi r5,r5,1 \n\
- stwcx. r5,0,r3 \n\
- beq success \n\
+ cmpwi r5,0 \n\
+ bne fail \n\
+ addi r5,r5,1 \n\
+ stwcx. r5,0,r3 \n\
+ beq success \n\
fail: \n\
- li r3,0 \n\
- blr \n\
+ li r3,0 \n\
+ blr \n\
success: \n\
- li r3,1 \n\
+ li r3,1 \n\
blr");
}
#define MUTEX_SET(tsl) __db_mutex_set(tsl)
block = (CHAR64LONG16*)buffer;
#endif
if (is_bigendian == -1)
- is_bigendian = __db_isbigendian();
+ is_bigendian = __db_isbigendian();
/* Copy context->state[] to working vars */
a = state[0];
b = state[1];
#else
# if (PERL_VERSION == 3) && (PERL_SUBVERSION == 22)
/* 5.003_22 */
- start_subparse(0),
+ start_subparse(0),
# else
/* 5.003_23 onwards */
- start_subparse(FALSE, 0),
+ start_subparse(FALSE, 0),
# endif
#endif
#define DBM_setFilter(db_type,code) \
{ \
if (db_type) \
- RETVAL = sv_mortalcopy(db_type) ; \
+ RETVAL = sv_mortalcopy(db_type) ; \
ST(0) = RETVAL ; \
if (db_type && (code == &PL_sv_undef)) { \
SvREFCNT_dec(db_type) ; \
- db_type = NULL ; \
+ db_type = NULL ; \
} \
else if (code) { \
- if (db_type) \
- sv_setsv(db_type, code) ; \
- else \
- db_type = newSVsv(code) ; \
- } \
+ if (db_type) \
+ sv_setsv(db_type, code) ; \
+ else \
+ db_type = newSVsv(code) ; \
+ } \
}
#define DBM_ckFilter(arg,type,name) \
if (db->type) { \
if (db->filtering) { \
- croak("recursion detected in %s", name) ; \
- } \
+ croak("recursion detected in %s", name) ; \
+ } \
ENTER ; \
SAVETMPS ; \
SAVEINT(db->filtering) ; \
SvTEMP_off(arg) ; \
PUSHMARK(SP) ; \
PUTBACK ; \
- (void) perl_call_sv(db->type, G_DISCARD); \
+ (void) perl_call_sv(db->type, G_DISCARD); \
SPAGAIN ; \
PUTBACK ; \
FREETMPS ; \
#else
# if (PERL_VERSION == 3) && (PERL_SUBVERSION == 22)
/* 5.003_22 */
- start_subparse(0),
+ start_subparse(0),
# else
/* 5.003_23 onwards */
- start_subparse(FALSE, 0),
+ start_subparse(FALSE, 0),
# endif
#endif
#define DBM_setFilter(db_type,code) \
{ \
if (db_type) \
- RETVAL = sv_mortalcopy(db_type) ; \
+ RETVAL = sv_mortalcopy(db_type) ; \
ST(0) = RETVAL ; \
if (db_type && (code == &PL_sv_undef)) { \
SvREFCNT_dec(db_type) ; \
- db_type = NULL ; \
+ db_type = NULL ; \
} \
else if (code) { \
- if (db_type) \
- sv_setsv(db_type, code) ; \
- else \
- db_type = newSVsv(code) ; \
- } \
+ if (db_type) \
+ sv_setsv(db_type, code) ; \
+ else \
+ db_type = newSVsv(code) ; \
+ } \
}
#define DBM_ckFilter(arg,type,name) \
if (db->type) { \
if (db->filtering) { \
- croak("recursion detected in %s", name) ; \
- } \
+ croak("recursion detected in %s", name) ; \
+ } \
ENTER ; \
SAVETMPS ; \
SAVEINT(db->filtering) ; \
SvTEMP_off(arg) ; \
PUSHMARK(SP) ; \
PUTBACK ; \
- (void) perl_call_sv(db->type, G_DISCARD); \
+ (void) perl_call_sv(db->type, G_DISCARD); \
SPAGAIN ; \
PUTBACK ; \
FREETMPS ; \
* There are three different cases here.
* 1. We asked for a particular LSN and got it.
* 2. We asked for an LSN of X,0 which is invalid and got the
- * first log record in a particular file.
+ * first log record in a particular file.
* 3. We asked for an LSN and it's not found because it is
* beyond the end of a log file and we need a NEWFILE msg.
*/
#include "libedataserver/libedataserver-private.h"
-#define E_DATA_SERVER_TYPE_MODULE (e_data_server_module_get_type ())
+#define E_DATA_SERVER_TYPE_MODULE (e_data_server_module_get_type ())
#define E_DATA_SERVER_MODULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), E_DATA_SERVER_TYPE_MODULE, EDataServerModule))
#define E_DATA_SERVER_MODULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), E_DATA_SERVER_TYPE_MODULE, EDataServerModule))
#define E_DATA_SERVER_IS_MODULE(obj) (G_TYPE_INSTANCE_CHECK_TYPE ((obj), E_DATA_SERVER_TYPE_MODULE))
{ "gbk-0", "GBK" },
/* Japanese charsets */
- { "eucjp-0", "eucJP" }, /* should this map to "EUC-JP" instead? */
- { "ujis-0", "ujis" }, /* we might want to map this to EUC-JP */
+ { "eucjp-0", "eucJP" }, /* should this map to "EUC-JP" instead? */
+ { "ujis-0", "ujis" }, /* we might want to map this to EUC-JP */
{ "jisx0208.1983-0", "SJIS" },
{ "jisx0212.1990-0", "SJIS" },
{ "pck", "SJIS" },
void (*remove) (EIterator *iterator);
void (*insert) (EIterator *iterator,
const void *object,
- gboolean before);
+ gboolean before);
void (*set) (EIterator *iterator,
const void *object);
gboolean (*is_valid) (EIterator *iterator);
static void e_list_iterator_invalidate (EIterator *iterator);
static gboolean e_list_iterator_is_valid (EIterator *iterator);
static void e_list_iterator_set (EIterator *iterator,
- const void *object);
+ const void *object);
static void e_list_iterator_remove (EIterator *iterator);
static void e_list_iterator_insert (EIterator *iterator,
- const void *object,
- gboolean before);
+ const void *object,
+ gboolean before);
static gboolean e_list_iterator_prev (EIterator *iterator);
static gboolean e_list_iterator_next (EIterator *iterator);
static void e_list_iterator_reset (EIterator *iterator);
/* Forward declarations. */
-static void ep_setting_changed (GConfClient *client, guint32 cnxn_id,
+static void ep_setting_changed (GConfClient *client, guint32 cnxn_id,
GConfEntry *entry, gpointer user_data);
-static void e_proxy_dispose (GObject* object);
+static void e_proxy_dispose (GObject* object);
-static void ipv6_network_addr (const struct in6_addr *addr,
+static void ipv6_network_addr (const struct in6_addr *addr,
const struct in6_addr *mask,
struct in6_addr *res);
type = (if bool function)
type = (if bool function function)
- Choose a flow path based on a boolean value
+ Choose a flow path based on a boolean value
type = (begin func func func)
Execute a sequence. The last function return is the return type.
a1 = (char **)r1->value.ptrarray->pdata;
l1 = r1->value.ptrarray->len;
for (j=0;j<l1;j++) {
- gpointer ptr;
+ gpointer ptr;
int n;
ptr = g_hash_table_lookup(ht, a1[j]);
n = GPOINTER_TO_INT(ptr);
#ifdef E_SEXP_IS_G_OBJECT
GType e_sexp_get_type (void);
#endif
-ESExp *e_sexp_new (void);
+ESExp *e_sexp_new (void);
#ifdef E_SEXP_IS_G_OBJECT
#define e_sexp_ref(f) g_object_ref (f)
#define e_sexp_unref(f) g_object_unref (f)
void e_sexp_ref (ESExp *f);
void e_sexp_unref (ESExp *f);
#endif
-void e_sexp_add_function (ESExp *f, int scope, char *name, ESExpFunc *func, void *data);
-void e_sexp_add_ifunction (ESExp *f, int scope, char *name, ESExpIFunc *func, void *data);
-void e_sexp_add_variable (ESExp *f, int scope, char *name, ESExpTerm *value);
+void e_sexp_add_function (ESExp *f, int scope, char *name, ESExpFunc *func, void *data);
+void e_sexp_add_ifunction (ESExp *f, int scope, char *name, ESExpIFunc *func, void *data);
+void e_sexp_add_variable (ESExp *f, int scope, char *name, ESExpTerm *value);
void e_sexp_remove_symbol (ESExp *f, int scope, char *name);
int e_sexp_set_scope (ESExp *f, int scope);
gchar *
e_source_group_get_property (ESourceGroup *source_group,
- const gchar *property)
+ const gchar *property)
{
ESourceGroupPrivate *priv;
void
e_source_group_set_property (ESourceGroup *source_group,
- const gchar *property,
- const gchar *value)
+ const gchar *property,
+ const gchar *value)
{
ESourceGroupPrivate *priv;
**/
void
e_source_set_color_spec (ESource *source,
- const gchar *color_spec)
+ const gchar *color_spec)
{
g_return_if_fail (E_IS_SOURCE (source));
g_return_val_if_fail (E_IS_SOURCE (source), NULL);
priv = source->priv;
- return g_strdup (g_hash_table_lookup (priv->properties, property));
+ return g_strdup (g_hash_table_lookup (priv->properties, property));
}
void
if (!match_string (HERE_AM_STR, rp))
{
if (match_string (HERE_PM_STR, rp))
- is_pm = 1;
+ is_pm = 1;
else
- return NULL;
+ return NULL;
}
break;
case 'r':
/* The C locale has no era information, so use the
normal representation. */
goto match_century;
- case 'y':
+ case 'y':
if (*decided != raw)
{
get_number(0, 9999, 4);
EDestinationStore *destination_store = E_DESTINATION_STORE (tree_model);
EDestination *destination;
const gchar *string;
- GString *string_new;
+ GString *string_new;
gint row;
EContact *contact;
Section section;
GtkTreeViewColumn *column;
GtkCellRenderer *cell_renderer;
- GtkWidget *vbox, *hbox, *chbox;
- GtkWidget *widget, *image, *label;
+ GtkWidget *vbox, *hbox, *chbox;
+ GtkWidget *widget, *image, *label;
SelData *data;
GtkTreeSelection *selection;
- gchar *text;
+ gchar *text;
g_assert (name != NULL);
g_assert (pretty_name != NULL);
EDestination *destination;
GString *buffer;
- destination = e_destination_store_get_destination (destination_store, iter);
+ destination = e_destination_store_get_destination (destination_store, iter);
g_assert (destination);
buffer = g_string_new (e_destination_get_name (destination));
/* 1/3 of the second to wait until invoking autocomplete lookup */
#define AUTOCOMPLETE_TIMEOUT 333
-#define re_set_timeout(id,func,ptr) \
+#define re_set_timeout(id,func,ptr) \
if (id) \
g_source_remove (id); \
id = g_timeout_add (AUTOCOMPLETE_TIMEOUT, \
/* If we are at the beginning or removing junk space, let us ignore it */
del_space = TRUE;
}
- } else if (end_pos == start_pos +1 && index_end == index_start+1) {
+ } else if (end_pos == start_pos +1 && index_end == index_start+1) {
/* We could be just deleting the empty text */
char *c;
EDestination *destination = name_selector_entry->popup_destination;
int position, start, end;
- position = GPOINTER_TO_INT(g_object_get_data ((GObject *)name_selector_entry, "index"));
+ position = GPOINTER_TO_INT(g_object_get_data ((GObject *)name_selector_entry, "index"));
email_list = e_destination_get_address(destination);
- text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
- get_range_at_position (text, position, &start, &end);
+ text = gtk_entry_get_text (GTK_ENTRY (name_selector_entry));
+ get_range_at_position (text, position, &start, &end);
g_signal_handlers_block_by_func (name_selector_entry, user_delete_text, name_selector_entry);
int email_num;
EContact *contact;
- if (!gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (item)))
+ if (!gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (item)))
return;
contact = e_destination_get_contact (destination);
if (!contact)
GList *email_list=NULL;
GList *l;
gint i;
- char *edit_label;
- char *cut_label;
+ char *edit_label;
+ char *cut_label;
char *copy_label;
- int email_num, len;
- GSList *group = NULL;
+ int email_num, len;
+ GSList *group = NULL;
gboolean is_list;
gboolean show_menu = FALSE;
gtk_grab_add (GTK_WIDGET (list->popup));
gdk_pointer_grab (window, TRUE,
- GDK_BUTTON_PRESS_MASK |
- GDK_BUTTON_RELEASE_MASK |
- GDK_POINTER_MOTION_MASK,
- NULL, NULL, GDK_CURRENT_TIME);
+ GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK |
+ GDK_POINTER_MOTION_MASK,
+ NULL, NULL, GDK_CURRENT_TIME);
- gdk_keyboard_grab (window, TRUE, GDK_CURRENT_TIME);
+ gdk_keyboard_grab (window, TRUE, GDK_CURRENT_TIME);
gtk_widget_grab_focus ((GtkWidget *)list);
/* Build the listview from the model */
ENameSelectorList *list)
{
if (event->type == GDK_ENTER_NOTIFY && !GTK_WIDGET_HAS_GRAB (list->popup))
- enl_popup_grab (list);
+ enl_popup_grab (list);
return TRUE;
}
GtkTreeSelection *selection;
if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (E_NAME_SELECTOR_ENTRY (list)->destination_store), &iter, path))
- return;
+ return;
selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW (list->tree_view));
len = e_destination_store_get_destination_count (E_NAME_SELECTOR_ENTRY (list)->destination_store);
if(list->menu)
gtk_menu_popdown(GTK_MENU (list->menu));
gtk_widget_hide ( GTK_WIDGET (list->popup));
- return;
+ return;
}
iter.stamp = ((ENameSelectorEntry *) list)->destination_store->stamp;
int email_num;
EContact *contact;
- if (!gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (item)))
+ if (!gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (item)))
return;
contact = e_destination_get_contact (destination);
if (!contact)
GtkWidget *menu_item;
GList *email_list = NULL, *l;
gint i;
- int email_num, len;
+ int email_num, len;
char *delete_label;
- GSList *group = NULL;
+ GSList *group = NULL;
gboolean is_list;
gboolean show_menu = FALSE;
GtkTreeSelection *selection;
PopupDeleteRowInfo *row_info;
GtkTreeIter iter;
- if ( !GTK_WIDGET_HAS_GRAB (list->popup))
- enl_popup_grab (list);
+ if ( !GTK_WIDGET_HAS_GRAB (list->popup))
+ enl_popup_grab (list);
gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW (list->tree_view), event->x, event->y, &path, NULL);
selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW (list->tree_view));
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
- GTK_POLICY_NEVER,
+ GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll),
- GTK_SHADOW_NONE);
+ GTK_SHADOW_NONE);
gtk_widget_set_size_request (
gtk_scrolled_window_get_vscrollbar (
GTK_SCROLLED_WINDOW (scroll)), -1, 0);
list->popup = GTK_WINDOW (gtk_window_new (GTK_WINDOW_POPUP));
- gtk_window_set_resizable (GTK_WINDOW (list->popup), FALSE);
+ gtk_window_set_resizable (GTK_WINDOW (list->popup), FALSE);
popup_frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (popup_frame),
- GTK_SHADOW_ETCHED_IN);
+ GTK_SHADOW_ETCHED_IN);
gtk_container_add (GTK_CONTAINER (list->popup), popup_frame);
gtk_container_add (GTK_CONTAINER (scroll), list->tree_view);
gtk_box_pack_start (GTK_BOX (vbox), scroll,
- TRUE, TRUE, 0);
+ TRUE, TRUE, 0);
g_signal_connect_after (GTK_WIDGET (list), "focus-in-event", G_CALLBACK(enl_entry_focus_in), NULL);
g_signal_connect (GTK_WIDGET (list), "focus-out-event", G_CALLBACK(enl_entry_focus_out), NULL);
int rows;
};
-GType e_name_selector_list_get_type (void);
-ENameSelectorList *e_name_selector_list_new (void);
+GType e_name_selector_list_get_type (void);
+ENameSelectorList *e_name_selector_list_new (void);
void e_name_selector_list_expand_clicked (ENameSelectorList *list);
G_END_DECLS
/* The space acts as a vertical placeholder. */
markup = g_markup_printf_escaped (
"<small>%s</small>", (mask & GDK_LOCK_MASK) ?
- _("You have the Caps Lock key on.") : " ");
+ _("You have the Caps Lock key on.") : " ");
gtk_label_set_markup (GTK_LABEL (label), markup);
g_free (markup);
(ESourceComboBox *source_combo_box);
void e_source_combo_box_set_source_list
(ESourceComboBox *source_combo_box,
- ESourceList *source_list);
+ ESourceList *source_list);
ESource * e_source_combo_box_get_active
(ESourceComboBox *source_combo_box);
void e_source_combo_box_set_active
GtkTreeIter *child);
static GArray *build_node_map (ETreeModelGenerator *tree_model_generator, GtkTreeIter *parent_iter,
- GArray *parent_group, gint parent_index);
+ GArray *parent_group, gint parent_index);
static void release_node_map (GArray *group);
static void child_row_changed (ETreeModelGenerator *tree_model_generator, GtkTreePath *path, GtkTreeIter *iter);
name_selector_entry = e_name_selector_entry_new ();
e_name_selector_entry_set_destination_store (name_selector_entry, destination_store);
- g_signal_connect (name_selector_dialog, "response", G_CALLBACK (close_dialog), name_selector_dialog);
+ g_signal_connect (name_selector_dialog, "response", G_CALLBACK (close_dialog), name_selector_dialog);
gtk_widget_show (GTK_WIDGET (name_selector_dialog));
container = gtk_window_new (GTK_WINDOW_TOPLEVEL);
#pragma }
#endif /* __cplusplus */
-gboolean e2k_actions_extract (guint8 **data,
- int *len,
- GPtrArray **actions);
-void e2k_actions_append (GByteArray *ba,
- GPtrArray *actions);
-
-E2kAction *e2k_action_move (GByteArray *store_entryid,
- GByteArray *folder_source_key);
-E2kAction *e2k_action_copy (GByteArray *store_entryid,
- GByteArray *folder_source_key);
-E2kAction *e2k_action_reply (GByteArray *template_entryid,
- guint8 template_guid[16]);
-E2kAction *e2k_action_oof_reply (GByteArray *template_entryid,
- guint8 template_guid[16]);
+gboolean e2k_actions_extract (guint8 **data,
+ int *len,
+ GPtrArray **actions);
+void e2k_actions_append (GByteArray *ba,
+ GPtrArray *actions);
+
+E2kAction *e2k_action_move (GByteArray *store_entryid,
+ GByteArray *folder_source_key);
+E2kAction *e2k_action_copy (GByteArray *store_entryid,
+ GByteArray *folder_source_key);
+E2kAction *e2k_action_reply (GByteArray *template_entryid,
+ guint8 template_guid[16]);
+E2kAction *e2k_action_oof_reply (GByteArray *template_entryid,
+ guint8 template_guid[16]);
E2kAction *e2k_action_defer (GByteArray *data);
E2kAction *e2k_action_bounce (E2kActionBounceCode bounce_code);
-E2kAction *e2k_action_forward (E2kAddrList *list);
-E2kAction *e2k_action_delegate (E2kAddrList *list);
-E2kAction *e2k_action_tag (const char *propname,
- E2kPropType type,
- gpointer value);
+E2kAction *e2k_action_forward (E2kAddrList *list);
+E2kAction *e2k_action_delegate (E2kAddrList *list);
+E2kAction *e2k_action_tag (const char *propname,
+ E2kPropType type,
+ gpointer value);
E2kAction *e2k_action_delete (void);
-void e2k_actions_free (GPtrArray *actions);
+void e2k_actions_free (GPtrArray *actions);
void e2k_action_free (E2kAction *act);
-E2kAddrList *e2k_addr_list_new (int nentries);
-void e2k_addr_list_set_local (E2kAddrList *list,
- int entry_num,
- const char *display_name,
- const char *exchange_dn,
- const char *email);
-void e2k_addr_list_set_oneoff (E2kAddrList *list,
- int entry_num,
- const char *display_name,
- const char *email);
-void e2k_addr_list_free (E2kAddrList *list);
+E2kAddrList *e2k_addr_list_new (int nentries);
+void e2k_addr_list_set_local (E2kAddrList *list,
+ int entry_num,
+ const char *display_name,
+ const char *exchange_dn,
+ const char *email);
+void e2k_addr_list_set_oneoff (E2kAddrList *list,
+ int entry_num,
+ const char *display_name,
+ const char *email);
+void e2k_addr_list_free (E2kAddrList *list);
#ifdef __cplusplus
}
/* SURF : e_notice (NULL, GTK_MESSAGE_ERROR,
_("Could not connect to the Exchange "
- "server.\nMake sure the URL is correct "
- "(try \"%s\" instead of \"%s\"?) "
- "and try again."), new, old);
+ "server.\nMake sure the URL is correct "
+ "(try \"%s\" instead of \"%s\"?) "
+ "and try again."), new, old);
*/
valid = FALSE;
break;
case E2K_AUTOCONFIG_CANT_RESOLVE:
/* SURF : e_notice (NULL, GTK_MESSAGE_ERROR,
- _("Could not locate Exchange server.\n"
- "Make sure the server name is spelled correctly "
- "and try again."));
+ _("Could not locate Exchange server.\n"
+ "Make sure the server name is spelled correctly "
+ "and try again."));
*/
valid = FALSE;
break;
case E2K_AUTOCONFIG_AUTH_ERROR_TRY_NTLM:
case E2K_AUTOCONFIG_AUTH_ERROR_TRY_BASIC:
/* SURF : e_notice (NULL, GTK_MESSAGE_ERROR,
- _("Could not authenticate to the Exchange "
- "server.\nMake sure the username and "
- "password are correct and try again."));
+ _("Could not authenticate to the Exchange "
+ "server.\nMake sure the username and "
+ "password are correct and try again."));
*/
valid = FALSE;
break;
case E2K_AUTOCONFIG_AUTH_ERROR_TRY_DOMAIN:
- /* SURF : e_notice (NULL, GTK_MESSAGE_ERROR,
- _("Could not authenticate to the Exchange "
- "server.\nMake sure the username and "
- "password are correct and try again.\n\n"
- "You may need to specify the Windows "
- "domain name as part of your username "
- "(eg, \"MY-DOMAIN\\%s\")."),
- ac->username);
+ /* SURF : e_notice (NULL, GTK_MESSAGE_ERROR,
+ _("Could not authenticate to the Exchange "
+ "server.\nMake sure the username and "
+ "password are correct and try again.\n\n"
+ "You may need to specify the Windows "
+ "domain name as part of your username "
+ "(eg, \"MY-DOMAIN\\%s\")."),
+ ac->username);
*/
valid = FALSE;
break;
case E2K_AUTOCONFIG_NO_OWA:
case E2K_AUTOCONFIG_NOT_EXCHANGE:
/* SURF : e_notice (NULL, GTK_MESSAGE_ERROR,
- _("Could not find OWA data at the indicated URL.\n"
- "Make sure the URL is correct and try again."));
+ _("Could not find OWA data at the indicated URL.\n"
+ "Make sure the URL is correct and try again."));
*/
valid = FALSE;
break;
/* SURF : e_notice (
NULL, GTK_MESSAGE_ERROR,
_("Ximian Connector requires access to certain "
- "functionality on the Exchange Server that appears "
- "to be disabled or blocked. (This is usually "
- "unintentional.) Your Exchange Administrator will "
- "need to enable this functionality in order for "
- "you to be able to use Ximian Connector.\n\n"
- "For information to provide to your Exchange "
- "administrator, please follow the link below:\n"
+ "functionality on the Exchange Server that appears "
+ "to be disabled or blocked. (This is usually "
+ "unintentional.) Your Exchange Administrator will "
+ "need to enable this functionality in order for "
+ "you to be able to use Ximian Connector.\n\n"
+ "For information to provide to your Exchange "
+ "administrator, please follow the link below:\n"
"http://support.novell.com/cgi-bin/search/searchtid.cgi?/ximian/ximian328.html "));
*/
valid = FALSE;
/* SURF : e_notice (
NULL, GTK_MESSAGE_ERROR,
_("The Exchange server URL you provided is for an "
- "Exchange 5.5 Server. Ximian Connector supports "
- "Microsoft Exchange 2000 and 2003 only."));
+ "Exchange 5.5 Server. Ximian Connector supports "
+ "Microsoft Exchange 2000 and 2003 only."));
*/
valid = FALSE;
break;
default:
/* SURF : e_notice (NULL, GTK_MESSAGE_ERROR,
- _("Could not configure Exchange account because "
- "an unknown error occurred. Check the URL, "
- "username, and password, and try again."));
+ _("Could not configure Exchange account because "
+ "an unknown error occurred. Check the URL, "
+ "username, and password, and try again."));
*/
valid = FALSE; /* FIXME return valid */
break;
const char *location;
location = soup_message_headers_get (failed_msg->response_headers,
- "Location");
+ "Location");
if (location != NULL) {/*Make sure we can get absolute path*/
suri = soup_uri_new (location);
if (suri != NULL) {/*Valid URI*/
path_end = strrchr (suri->path, '/') + 1;
*path_end = '\0';
suri->path = g_realloc (suri->path,
- path_end - suri->path + strlen (value) + 1);
+ path_end - suri->path + strlen (value) + 1);
strcat (suri->path, value);
g_free (suri->query);
suri->query = NULL;
/* Copy the mangled path. */
p = vpath;
- while (1) {
+ while (1) {
newp = strchr (p, '/');
if (newp == NULL) {
strcpy (dp, p);
printf (" ebrowse -s URI (subscribe and listen)\n");
printf (" ebrowse [ -m | -c ] SRC DEST (move/copy)\n");
printf (" ebrowse -n ALIAS URI (lookup name)\n");
- printf (" ebrowse -f URI (lookup favorite folder props)\n");
+ printf (" ebrowse -f URI (lookup favorite folder props)\n");
exit (1);
}
if ((strcmp (type, "calendar") == 0) ||
(strcmp (type, "calendar/public") == 0)) {
add_folder_esource (hier->account,
- EXCHANGE_CALENDAR_FOLDER,
- name,
- physical_uri);
+ EXCHANGE_CALENDAR_FOLDER,
+ name,
+ physical_uri);
}
else if ((strcmp (type, "tasks") == 0) ||
(strcmp (type, "tasks/public") == 0)) {
add_folder_esource (hier->account,
- EXCHANGE_TASKS_FOLDER,
- name,
- physical_uri);
+ EXCHANGE_TASKS_FOLDER,
+ name,
+ physical_uri);
}
else if ((strcmp (type, "contacts") == 0) ||
(strcmp (type, "contacts/public") == 0)) {
add_folder_esource (hier->account,
- EXCHANGE_CONTACTS_FOLDER,
- name,
- physical_uri);
+ EXCHANGE_CONTACTS_FOLDER,
+ name,
+ physical_uri);
}
}
return ef;
void e_folder_exchange_set_permanent_uri (EFolder *folder,
const char *permanent_uri);
-long long int e_folder_exchange_get_folder_size (EFolder *folder);
-void e_folder_exchange_set_folder_size (EFolder *folder, long long int folder_size);
+long long int e_folder_exchange_get_folder_size (EFolder *folder);
+void e_folder_exchange_set_folder_size (EFolder *folder, long long int folder_size);
gboolean e_folder_exchange_get_has_subfolders (EFolder *folder);
void e_folder_exchange_set_has_subfolders (EFolder *folder,
const char *type,
const char *description);
-const char *e_folder_get_name (EFolder *folder);
-const char *e_folder_get_type_string (EFolder *folder);
-const char *e_folder_get_description (EFolder *folder);
-const char *e_folder_get_physical_uri (EFolder *folder);
-int e_folder_get_unread_count (EFolder *folder);
-gboolean e_folder_get_highlighted (EFolder *folder);
-gboolean e_folder_get_is_stock (EFolder *folder);
+const char *e_folder_get_name (EFolder *folder);
+const char *e_folder_get_type_string (EFolder *folder);
+const char *e_folder_get_description (EFolder *folder);
+const char *e_folder_get_physical_uri (EFolder *folder);
+int e_folder_get_unread_count (EFolder *folder);
+gboolean e_folder_get_highlighted (EFolder *folder);
+gboolean e_folder_get_is_stock (EFolder *folder);
gboolean e_folder_get_can_sync_offline (EFolder *folder);
gboolean e_folder_get_has_subfolders (EFolder *folder);
const char *e_folder_get_custom_icon_name (EFolder *folder);
GList * (* get_subfolder_paths) (EStorage *storage,
const char *path);
- EFolder * (* get_folder) (EStorage *storage,
+ EFolder * (* get_folder) (EStorage *storage,
const char *path);
- const char * (* get_name) (EStorage *storage);
+ const char * (* get_name) (EStorage *storage);
void (* async_create_folder) (EStorage *storage,
const char *path,
EFolder *source);
void (* async_discover_shared_folder) (EStorage *storage,
- const char *owner,
- const char *folder_name,
- EStorageDiscoveryCallback callback,
- void *data);
+ const char *owner,
+ const char *folder_name,
+ EStorageDiscoveryCallback callback,
+ void *data);
void (* cancel_discover_shared_folder) (EStorage *storage,
const char *owner,
const char *folder_name);
void (* async_remove_shared_folder) (EStorage *storage,
- const char *path,
- EStorageResultCallback callback,
- void *data);
+ const char *path,
+ EStorageResultCallback callback,
+ void *data);
};
GType e_storage_get_type (void);
}
else if (!account->priv->account->source->save_passwd) {
/* get_password returns the password cached but user has not
- * selected remember password option, forget this password
- * whis is stored temporarily by e2k_validate_user()
- */
+ * selected remember password option, forget this password
+ * whis is stored temporarily by e2k_validate_user()
+ */
e_passwords_forget_password ("Exchange", account->priv->password_key);
}
}
}
else if (!account->priv->account->source->save_passwd) {
/* get_password returns the password cached but user has not
- * selected remember password option, forget this password
- * whis is stored temporarily by e2k_validate_user()
- */
+ * selected remember password option, forget this password
+ * whis is stored temporarily by e2k_validate_user()
+ */
e_passwords_forget_password ("Exchange", account->priv->password_key);
}
qsort (folders->pdata, folders->len,
sizeof (EFolder *), folder_comparator);
- g_free (fld_tree);
+ g_free (fld_tree);
return folders;
}
E2kContext *exchange_account_get_context (ExchangeAccount *acct);
E2kGlobalCatalog *exchange_account_get_global_catalog (ExchangeAccount *acct);
-EAccount *exchange_account_fetch (ExchangeAccount *acct);
+EAccount *exchange_account_fetch (ExchangeAccount *acct);
char *exchange_account_get_account_uri_param (ExchangeAccount *acct, const char *param);
const char *exchange_account_get_standard_uri (ExchangeAccount *acct,
const char *std_uri_prop);
ExchangeHierarchy *exchange_account_get_hierarchy_by_email (ExchangeAccount *account, const char *email);
-char *exchange_account_get_authtype (ExchangeAccount *account);
+char *exchange_account_get_authtype (ExchangeAccount *account);
E2kContext *exchange_account_connect (ExchangeAccount *acct,
const char *pword,
const char *path_or_uri);
GPtrArray *exchange_account_get_folders (ExchangeAccount *acct);
-GPtrArray *exchange_account_get_folder_tree (ExchangeAccount *account, char* path);
+GPtrArray *exchange_account_get_folder_tree (ExchangeAccount *account, char* path);
ExchangeHierarchy *exchange_account_get_hierarchy_by_type (ExchangeAccount *acct,
ExchangeHierarchyType type);
void exchange_account_rescan_tree (ExchangeAccount *acct);
-char *exchange_account_get_password (ExchangeAccount *acct);
+char *exchange_account_get_password (ExchangeAccount *acct);
-ExchangeAccountResult exchange_account_set_password (ExchangeAccount *acct,
+ExchangeAccountResult exchange_account_set_password (ExchangeAccount *acct,
char *old_password,
char *new_password);
-void exchange_account_forget_password (ExchangeAccount *acct);
+void exchange_account_forget_password (ExchangeAccount *acct);
void exchange_account_set_save_password (ExchangeAccount *account,
gboolean save_password);
EFolder *folder);
gboolean exchange_account_is_favorite_folder (ExchangeAccount *account,
- EFolder *folder);
+ EFolder *folder);
-char * exchange_account_get_username (ExchangeAccount *account);
+char * exchange_account_get_username (ExchangeAccount *account);
-char * exchange_account_get_windows_domain (ExchangeAccount *account);
+char * exchange_account_get_windows_domain (ExchangeAccount *account);
-char * exchange_account_get_email_id (ExchangeAccount *account);
+char * exchange_account_get_email_id (ExchangeAccount *account);
int exchange_account_get_quota_limit (ExchangeAccount *account);
int exchange_account_check_password_expiry (ExchangeAccount *account);
/* Folder Size methods */
-void exchange_account_folder_size_add (ExchangeAccount *account,
- const char *folder_name,
- gdouble size);
-void exchange_account_folder_size_remove (ExchangeAccount *account,
- const char *folder_name);
-void exchange_account_folder_size_rename (ExchangeAccount *account,
- const char *old_name,
- const char *new_name);
-GtkListStore *exchange_account_folder_size_get_model (ExchangeAccount *account);
-void exchange_account_scan_foreign_hierarchy (ExchangeAccount *account,
+void exchange_account_folder_size_add (ExchangeAccount *account,
+ const char *folder_name,
+ gdouble size);
+void exchange_account_folder_size_remove (ExchangeAccount *account,
+ const char *folder_name);
+void exchange_account_folder_size_rename (ExchangeAccount *account,
+ const char *old_name,
+ const char *new_name);
+GtkListStore *exchange_account_folder_size_get_model (ExchangeAccount *account);
+void exchange_account_scan_foreign_hierarchy (ExchangeAccount *account,
const char *user_email);
void
add_folder_esource (ExchangeAccount *account,
- FolderType folder_type,
- const char *folder_name,
- const char *physical_uri)
+ FolderType folder_type,
+ const char *folder_name,
+ const char *physical_uri)
{
ESource *source = NULL;
ESourceGroup *source_group = NULL;
g_object_unref (source_list);
g_object_unref (source_group);
g_object_unref (client);
- g_free (relative_uri);
+ g_free (relative_uri);
g_free (username);
if (authtype)
g_free (authtype);
g_free (browse);
}
else {
- source = e_source_new (folder_name, relative_uri);
+ source = e_source_new (folder_name, relative_uri);
}
if (mode == OFFLINE_MODE)
#define CONF_KEY_CONTACTS "/apps/evolution/addressbook/sources"
#define EXCHANGE_URI_PREFIX "exchange://"
-void add_folder_esource (ExchangeAccount *account, FolderType folder_type, const char *folder_name, const char *physical_uri);
-void remove_folder_esource (ExchangeAccount *account, FolderType folder_type, const char *physical_uri);
+void add_folder_esource (ExchangeAccount *account, FolderType folder_type, const char *folder_name, const char *physical_uri);
+void remove_folder_esource (ExchangeAccount *account, FolderType folder_type, const char *physical_uri);
/* Remove this ugly hack by moving this to exchange-account.h */
char * exchange_account_get_authtype (ExchangeAccount *account);
!(strcmp (folder_type, "calendar/public"))) {
folder_mask = EXCHANGE_CALENDAR_FOLDER | FORIEGN_FOLDER_FLAG;
add_folder_esource (hier->account,
- folder_mask,
- new_folder_name,
- physical_uri);
+ folder_mask,
+ new_folder_name,
+ physical_uri);
}
else if (!(strcmp (folder_type, "tasks")) ||
!(strcmp (folder_type, "tasks/public"))) {
folder_mask = EXCHANGE_TASKS_FOLDER | FORIEGN_FOLDER_FLAG;
add_folder_esource (hier->account,
- folder_mask,
- new_folder_name,
- physical_uri);
+ folder_mask,
+ new_folder_name,
+ physical_uri);
}
else if (!(strcmp (folder_type, "contacts")) ||
!(strcmp (folder_type, "contacts/public")) ||
!(strcmp (folder_type, "contacts/ldap"))) {
folder_mask = EXCHANGE_CONTACTS_FOLDER | FORIEGN_FOLDER_FLAG;
add_folder_esource (hier->account,
- folder_mask,
- new_folder_name,
- physical_uri);
+ folder_mask,
+ new_folder_name,
+ physical_uri);
}
g_free (new_folder_name);
}
NULL, NULL, NULL);
/* Add ESource */
add_folder_esource (hier->account, EXCHANGE_CONTACTS_FOLDER,
- hierarchy_name, physical_uri_prefix);
+ hierarchy_name, physical_uri_prefix);
g_object_unref (toplevel);
typedef struct XCBackendComponentPrivate XCBackendComponentPrivate;
typedef struct XCBackendComponentClass XCBackendComponentClass;
-typedef struct XCBackendView XCBackendView;
-typedef struct XCBackendViewPrivate XCBackendViewPrivate;
-typedef struct XCBackendViewClass XCBackendViewClass;
+typedef struct XCBackendView XCBackendView;
+typedef struct XCBackendViewPrivate XCBackendViewPrivate;
+typedef struct XCBackendViewClass XCBackendViewClass;
typedef enum {
EXCHANGE_HIERARCHY_PERSONAL,
entry_edit_url = gdata_entry_get_edit_link (entry);
priv = GDATA_GOOGLE_SERVICE_GET_PRIVATE (GDATA_GOOGLE_SERVICE (service));
auth = (GDataGoogleServiceAuth *) priv->auth;
- soup_session = (SoupSession *)priv->soup_session;
+ soup_session = (SoupSession *)priv->soup_session;
msg = soup_message_new (SOUP_METHOD_DELETE, entry_edit_url);
soup_message_headers_append (msg->request_headers,
/* Handle redirects ourself */
send_and_handle_google_redirection (soup_session, msg);
- if (msg->status_code != 200) {
+ if (msg->status_code != 200) {
g_set_error (error, SOUP_HTTP_ERROR,
msg->status_code, "%s", msg->reason_phrase);
} else {
/* Handle redirects ourself */
send_and_handle_google_redirection (soup_session, msg);
- if (msg->status_code != 200) {
+ if (msg->status_code != 200) {
g_set_error (error, SOUP_HTTP_ERROR,
msg->status_code, "%s", msg->reason_phrase);
g_object_unref (msg);
soup_session_send_message (priv->soup_session, msg);
- if (msg->status_code != 200) {
+ if (msg->status_code != 200) {
g_set_error (error, SOUP_HTTP_ERROR,
msg->status_code, "%s", msg->reason_phrase);
g_object_unref(msg);
GSList *attendees;
gchar *location;
gchar *content;
- gchar *title;
+ gchar *title;
gchar *reminder;
gchar *status;
gchar *visibility;
status = e_gw_connection_get_container_list (cnc, "folders", &container_list);
if (status == E_GW_CONNECTION_STATUS_INVALID_CONNECTION)
- status = e_gw_connection_get_container_list (cnc, "folders", &container_list);
+ status = e_gw_connection_get_container_list (cnc, "folders", &container_list);
if (status != E_GW_CONNECTION_STATUS_OK) {
e_gw_connection_free_container_list (container_list);
return NULL;
if (view)
e_gw_message_write_string_parameter (msg, "view", NULL, view);
- soup_soap_message_start_element (msg, "deltaInfo", NULL, NULL);
+ soup_soap_message_start_element (msg, "deltaInfo", NULL, NULL);
e_gw_message_write_string_parameter (msg, "firstSequence", NULL, start_sequence);
e_gw_message_write_string_parameter (msg, "count", NULL, count);
soup_soap_message_end_element(msg);
e_gw_message_write_string_parameter (msg, "container", NULL, container);
if (view)
e_gw_message_write_string_parameter (msg, "view", NULL, view);
- soup_soap_message_start_element (msg, "items", NULL, NULL);
+ soup_soap_message_start_element (msg, "items", NULL, NULL);
for (i = 0; i < item_ids->len; i ++) {
char *id = g_ptr_array_index (item_ids, i);
e_gw_message_write_string_parameter (msg, "item", NULL, id);
EGwConnectionStatus
e_gw_connection_get_deltas ( EGwConnection *cnc, GSList **adds, GSList **deletes, GSList **updates)
{
- SoupSoapMessage *msg;
+ SoupSoapMessage *msg;
SoupSoapResponse *response;
EGwConnectionStatus status;
SoupSoapParameter *param, *subparam;
char *tmp;
- g_return_val_if_fail (E_IS_GW_CONNECTION (cnc), E_GW_CONNECTION_STATUS_INVALID_OBJECT);
+ g_return_val_if_fail (E_IS_GW_CONNECTION (cnc), E_GW_CONNECTION_STATUS_INVALID_OBJECT);
- /* build the SOAP message */
+ /* build the SOAP message */
msg = e_gw_message_new_with_header (cnc->priv->uri, cnc->priv->session_id, "getDeltaRequest");
if (!msg) {
g_warning (G_STRLOC ": Could not build SOAP message");
status = e_gw_connection_parse_response_status (response);
if (status != E_GW_CONNECTION_STATUS_OK) {
- g_object_unref (response);
+ g_object_unref (response);
g_object_unref (msg);
/* g_object_unref (cnc); */
- return status;
- }
+ return status;
+ }
- /* if status is OK - parse result. return the list */
- param = soup_soap_response_get_first_parameter_by_name (response, "changed");
+ /* if status is OK - parse result. return the list */
+ param = soup_soap_response_get_first_parameter_by_name (response, "changed");
if (!param) {
g_object_unref (response);
g_object_unref (msg);
g_object_unref (response);
g_object_unref (msg);
/* g_object_unref (cnc); */
- return E_GW_CONNECTION_STATUS_INVALID_RESPONSE;
+ return E_GW_CONNECTION_STATUS_INVALID_RESPONSE;
}
/*if (!e_cal_backend_cache_put_component (cache, comp))
g_message ("Could not add the component"); */
param = soup_soap_parameter_get_first_child_by_name (param, "update");
if (param) {
for (subparam = soup_soap_parameter_get_first_child_by_name(param, "item");
- subparam != NULL;
- subparam = soup_soap_parameter_get_next_child (subparam)) {
+ subparam != NULL;
+ subparam = soup_soap_parameter_get_next_child (subparam)) {
EGwItem *item;
/*process each item */
/*item = get_item_from_updates (subparam);*/
return E_GW_CONNECTION_STATUS_INVALID_RESPONSE;
}
- *item = e_gw_item_new_from_soap_parameter (cnc->priv->user_email, container, param);
+ *item = e_gw_item_new_from_soap_parameter (cnc->priv->user_email, container, param);
/* free memory */
g_object_unref (response);
return E_GW_CONNECTION_STATUS_UNKNOWN;
}
- e_gw_message_write_footer (msg);
+ e_gw_message_write_footer (msg);
/* send message to server */
response = e_gw_connection_send_message (cnc, msg);
e_gw_container_set_is_writable (container, FALSE);
g_free (value);
value = NULL;
- type_param = soup_soap_parameter_get_first_child_by_name (subparam, "isFrequentContacts");
+ type_param = soup_soap_parameter_get_first_child_by_name (subparam, "isFrequentContacts");
if (type_param)
value = soup_soap_parameter_get_string_value (type_param);
if (value && g_str_equal(value , "1"))
return E_GW_CONNECTION_STATUS_INVALID_OBJECT;
}
- e_gw_message_write_footer (msg);
+ e_gw_message_write_footer (msg);
/* send message to server */
response = e_gw_connection_send_message (cnc, msg);
}
status = e_gw_connection_parse_response_status (response);
- if (status != E_GW_CONNECTION_STATUS_OK) {
+ if (status != E_GW_CONNECTION_STATUS_OK) {
if (status == E_GW_CONNECTION_STATUS_INVALID_CONNECTION)
reauthenticate (cnc);
g_object_unref (response);
g_static_mutex_unlock (&connecting);
return E_GW_CONNECTION_STATUS_UNKNOWN;
}
- e_gw_message_write_footer (msg);
+ e_gw_message_write_footer (msg);
/* send message to server */
response = e_gw_connection_send_message (cnc, msg);
g_static_mutex_unlock (&connecting);
return E_GW_CONNECTION_STATUS_UNKNOWN;
}
- e_gw_message_write_footer (msg);
+ e_gw_message_write_footer (msg);
/* send message to server */
response = e_gw_connection_send_message (cnc, msg);
view_is_id = TRUE;
/* We are interested only in getting the ids */
for (subparam = soup_soap_parameter_get_first_child_by_name (param, "item");
- subparam != NULL;
- subparam = soup_soap_parameter_get_next_child_by_name (subparam, "item")) {
+ subparam != NULL;
+ subparam = soup_soap_parameter_get_next_child_by_name (subparam, "item")) {
SoupSoapParameter *param_id;
- char *id;
+ char *id;
if (view_is_id) {
param_id = soup_soap_parameter_get_first_child_by_name (subparam, "id");
if (!param) {
g_object_unref (response);
return status;
- } else {
+ } else {
e_gw_proxy_construct_proxy_access_list (param, proxy_list);
}
/* free memory */
const char *e_gw_connection_get_user_name (EGwConnection *cnc);
const char *e_gw_connection_get_user_email (EGwConnection *cnc);
const char *e_gw_connection_get_user_uuid (EGwConnection *cnc);
-const char *e_gw_connection_get_version (EGwConnection *cnc);
+const char *e_gw_connection_get_version (EGwConnection *cnc);
const char *e_gw_connection_get_server_time (EGwConnection *cnc) ;
soup_soap_message_end_element (msg);
soup_soap_message_end_element (msg);
- } else if (flag == 1) {
+ } else if (flag == 1) {
soup_soap_message_start_element (msg, "delete", NULL, NULL);
soup_soap_message_start_element (msg, "acl", NULL, NULL);
const char *e_gw_container_get_id (EGwContainer *container);
void e_gw_container_set_id (EGwContainer *container, const char *new_id);
const char *e_gw_container_get_parent_id (EGwContainer *container) ;
-void e_gw_container_set_parent_id (EGwContainer *container, const char *parent_id) ;
+void e_gw_container_set_parent_id (EGwContainer *container, const char *parent_id) ;
guint32 e_gw_container_get_total_count (EGwContainer *container) ;
guint32 e_gw_container_get_unread_count (EGwContainer *container) ;
gboolean e_gw_container_get_is_writable (EGwContainer *container);
int e_gw_container_get_sequence(EGwContainer *container);
gboolean e_gw_container_get_is_shared_by_me(EGwContainer *container);
gboolean e_gw_container_get_is_shared_to_me(EGwContainer *container);
-int e_gw_container_get_rights(EGwContainer *container, gchar *email);
+int e_gw_container_get_rights(EGwContainer *container, gchar *email);
EGwContainerType e_gw_container_get_container_type (EGwContainer *container) ;
-void e_gw_container_get_user_list(EGwContainer *container, GList **user_list);
+void e_gw_container_get_user_list(EGwContainer *container, GList **user_list);
void e_gw_container_form_message (SoupSoapMessage *msg, gchar *id, GList *new_list, const char *sub, const char *mesg, int flag);
gboolean e_gw_container_get_is_system_folder (EGwContainer *container);
void e_gw_container_set_is_system_folder (EGwContainer *container, gboolean is_system_folder);
switch (filter_component->operation) {
- case E_GW_FILTER_OP_EQUAL :
+ case E_GW_FILTER_OP_EQUAL :
operation_name = "eq";
break;
case E_GW_FILTER_OP_NOTEQUAL :
to none. */
subparam = soup_soap_parameter_get_first_child_by_name (param_recipient, "recipientStatus");
if (subparam) {
- char *formatted_date, *value;
+ char *formatted_date, *value;
SoupSoapParameter *temp_param ;
recipient->status_enabled = TRUE;
- if ( (temp_param = soup_soap_parameter_get_first_child_by_name (subparam, "deleted")) ) {
+ if ( (temp_param = soup_soap_parameter_get_first_child_by_name (subparam, "deleted")) ) {
recipient->status = E_GW_ITEM_STAT_DELETED;
value = soup_soap_parameter_get_string_value (temp_param);
formatted_date = e_gw_connection_format_date_string (value);
value = soup_soap_parameter_get_string_value (subparam);
if (value && !g_ascii_strcasecmp (value, "1")) {
g_free (value), value = NULL;
- return E_GW_ITEM_NOTIFY_MAIL;
+ return E_GW_ITEM_NOTIFY_MAIL;
}
g_free (value), value = NULL;
}
value = soup_soap_parameter_get_property (subparam, "autoDelete");
if (value && !g_ascii_strcasecmp (value, "1"))
- priv->autodelete = TRUE;
+ priv->autodelete = TRUE;
g_free (value), value = NULL;
}
}
}
- subparam = soup_soap_parameter_get_first_child_by_name (param, "website");
+ subparam = soup_soap_parameter_get_first_child_by_name (param, "website");
if(subparam) {
value = soup_soap_parameter_get_string_value (subparam);
if(value)
e_gw_message_write_string_parameter (msg, "namePrefix", NULL, full_name->name_prefix);
if (full_name->first_name)
e_gw_message_write_string_parameter (msg, "firstName", NULL, full_name->first_name);
- if (full_name->middle_name)
+ if (full_name->middle_name)
e_gw_message_write_string_parameter (msg, "middleName", NULL, full_name->middle_name);
if (full_name->last_name)
e_gw_message_write_string_parameter (msg, "lastName", NULL, full_name->last_name) ;
void e_gw_item_set_im_list (EGwItem *item, GList *im_list);
void e_gw_item_set_categories (EGwItem *item, GList *category_list);
GList* e_gw_item_get_categories (EGwItem *item);
-void e_gw_item_set_to (EGwItem *item, const char *to) ;
+void e_gw_item_set_to (EGwItem *item, const char *to) ;
const char* e_gw_item_get_to (EGwItem *item) ;
const char *e_gw_item_get_msg_content_type (EGwItem *item) ;
guint32 e_gw_item_get_item_status (EGwItem *item);
if (val_param)
val = soup_soap_parameter_get_string_value (val_param);
- if (val) {
+ if (val) {
if (!g_ascii_strcasecmp (val, "None"))
gopts->reply_enabled = FALSE;
else if (!g_ascii_strcasecmp (val, "WhenConvenient")) {
temp = soup_soap_parameter_get_property (group_param, "type");
- if (!temp)
+ if (!temp)
continue;
if (!g_ascii_strcasecmp (temp, "MailMessageSettings")) {
parse_general_options (group_param, priv->gopts);
}
- if (!g_ascii_strcasecmp (temp, "AppointmentMessageSettings")) {
+ if (!g_ascii_strcasecmp (temp, "AppointmentMessageSettings")) {
parse_status_tracking_options (group_param, 11, priv->copts);
}
- if (!g_ascii_strcasecmp (temp, "TaskMessageSettings"))
+ if (!g_ascii_strcasecmp (temp, "TaskMessageSettings"))
parse_status_tracking_options (group_param, 4, priv->topts);
- if (!g_ascii_strcasecmp (temp, "AdvancedSettings"))
+ if (!g_ascii_strcasecmp (temp, "AdvancedSettings"))
parse_advanced_settings (group_param, priv->gopts);
g_free (temp);
G_BEGIN_DECLS
-#define OFFLINE_TYPE_LISTENER (offline_listener_get_type ())
-#define OFFLINE_LISTENER(obj) ((G_TYPE_CHECK_INSTANCE_CAST((obj), OFFLINE_TYPE_LISTENER, OfflineListener)))
-#define OFFLINE_LISTENER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), OFFLINE_TYPE_LISTENER, OfflineListenerClass))
+#define OFFLINE_TYPE_LISTENER (offline_listener_get_type ())
+#define OFFLINE_LISTENER(obj) ((G_TYPE_CHECK_INSTANCE_CAST((obj), OFFLINE_TYPE_LISTENER, OfflineListener)))
+#define OFFLINE_LISTENER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), OFFLINE_TYPE_LISTENER, OfflineListenerClass))
#define OFFLINE_IS_LISTENER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), OFFLINE_TYPE_LISTENER))
#define OFFLINE_IS_LISTENER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), OFFLINE_TYPE_LISTENER))
projects / platform / upstream / evolution-data-server.git / commitdiff