/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/* e-contact.c
*
* Copyright (C) 2003 Ximian, Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of version 2 of the GNU General Public
* License as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public
* License along with this program; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*
* Author: Chris Toshok (toshok@ximian.com)
*/
#include <glib.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <libgnome/gnome-i18n.h>
#include <libgnomevfs/gnome-vfs-mime-utils.h>
#include "e-contact.h"
#include "e-book.h"
#include "e-util/ename/e-name-western.h"
struct _EContactPrivate {
};
#define E_CONTACT_FIELD_TYPE_STRING 0x00000001 /* used for simple single valued attributes */
/*E_CONTACT_FIELD_TYPE_FLOAT*/
#define E_CONTACT_FIELD_TYPE_LIST 0x00000002 /* used for multivalued single attributes - the elements are of type char* */
#define E_CONTACT_FIELD_TYPE_MULTI 0x00000004 /* used for multivalued attributes - the elements are of type EVCardAttribute */
#define E_CONTACT_FIELD_TYPE_STRUCT 0x00000008 /* used for structured types (N and ADR properties, in particular) */
#define E_CONTACT_FIELD_TYPE_BOOLEAN 0x00000010 /* used for boolean types (WANTS_HTML) */
#define E_CONTACT_FIELD_TYPE_SYNTHETIC 0x10000000 /* used when there isn't a corresponding vcard field (such as email_1) */
#define E_CONTACT_FIELD_TYPE_LIST_ELEM 0x20000000 /* used when a synthetic attribute is a numbered list element */
#define E_CONTACT_FIELD_TYPE_MULTI_ELEM 0x40000000 /* used when we're looking for the nth attribute where more than 1 can be present in the vcard */
#define E_CONTACT_FIELD_TYPE_ATTR_TYPE 0x80000000 /* used when a synthetic attribute is flagged with a TYPE= that we'll be looking for */
typedef struct {
guint32 t;
EContactField field_id;
const char *vcard_field_name;
const char *field_name; /* non translated */
const char *pretty_name; /* translated */
gboolean read_only;
int list_elem;
const char *attr_type1;
const char *attr_type2;
void* (*struct_getter)(EContact *contact, EVCardAttribute *attribute);
void (*struct_setter)(EContact *contact, EVCardAttribute *attribute, void *data);
} EContactFieldInfo;
static void* photo_getter (EContact *contact, EVCardAttribute *attr);
static void photo_setter (EContact *contact, EVCardAttribute *attr, void *data);
static void* fn_getter (EContact *contact, EVCardAttribute *attr);
static void fn_setter (EContact *contact, EVCardAttribute *attr, void *data);
static void* n_getter (EContact *contact, EVCardAttribute *attr);
static void n_setter (EContact *contact, EVCardAttribute *attr, void *data);
static void* adr_getter (EContact *contact, EVCardAttribute *attr);
static void adr_setter (EContact *contact, EVCardAttribute *attr, void *data);
static void* date_getter (EContact *contact, EVCardAttribute *attr);
static void date_setter (EContact *contact, EVCardAttribute *attr, void *data);
#define STRING_FIELD(id,vc,n,pn,ro) { E_CONTACT_FIELD_TYPE_STRING, (id), (vc), (n), (pn), (ro) }
#define BOOLEAN_FIELD(id,vc,n,pn,ro) { E_CONTACT_FIELD_TYPE_BOOLEAN, (id), (vc), (n), (pn), (ro) }
#define LIST_FIELD(id,vc,n,pn,ro) { E_CONTACT_FIELD_TYPE_LIST, (id), (vc), (n), (pn), (ro) }
#define MULTI_LIST_FIELD(id,vc,n,pn,ro) { E_CONTACT_FIELD_TYPE_MULTI, (id), (vc), (n), (pn), (ro) }
#define STRUCT_FIELD(id,vc,n,pn,ro,get,set) { E_CONTACT_FIELD_TYPE_STRUCT, (id), (vc), (n), (pn), (ro), -1, NULL, NULL, (get), (set) }
#define LIST_ELEM_STR_FIELD(id,vc,n,pn,ro,nm) { E_CONTACT_FIELD_TYPE_LIST_ELEM | E_CONTACT_FIELD_TYPE_SYNTHETIC | E_CONTACT_FIELD_TYPE_STRING, (id), (vc), (n), (pn), (ro), (nm) }
#define MULTI_ELEM_STR_FIELD(id,vc,n,pn,ro,nm) { E_CONTACT_FIELD_TYPE_MULTI_ELEM | E_CONTACT_FIELD_TYPE_SYNTHETIC | E_CONTACT_FIELD_TYPE_STRING, (id), (vc), (n), (pn), (ro), (nm) }
#define ATTR_TYPE_STR_FIELD(id,vc,n,pn,ro,at1,nth) { E_CONTACT_FIELD_TYPE_ATTR_TYPE | E_CONTACT_FIELD_TYPE_SYNTHETIC | E_CONTACT_FIELD_TYPE_STRING, (id), (vc), (n), (pn), (ro), (nth), (at1), NULL }
#define ATTR2_TYPE_STR_FIELD(id,vc,n,pn,ro,at1,at2,nth) { E_CONTACT_FIELD_TYPE_ATTR_TYPE | E_CONTACT_FIELD_TYPE_SYNTHETIC | E_CONTACT_FIELD_TYPE_STRING, (id), (vc), (n), (pn), (ro), (nth), (at1), (at2) }
#define ATTR_TYPE_STRUCT_FIELD(id,vc,n,pn,ro,at,get,set) { E_CONTACT_FIELD_TYPE_ATTR_TYPE | E_CONTACT_FIELD_TYPE_SYNTHETIC | E_CONTACT_FIELD_TYPE_STRUCT, (id), (vc), (n), (pn), (ro), 0, (at), NULL, (get), (set) }
static EContactFieldInfo field_info[] = {
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 As"), FALSE),
/* Name fields */
/* FN isn't really a structured field - we use a getter/setter
so we can set the N property (since evo 1.4 works fine with
vcards that don't even have a N attribute. *sigh*) */
STRUCT_FIELD (E_CONTACT_FULL_NAME, EVC_FN, "full_name", N_("Full Name"), FALSE, fn_getter, fn_setter),
STRUCT_FIELD (E_CONTACT_NAME, EVC_N, "name", N_("Name"), FALSE, n_getter, n_setter),
LIST_ELEM_STR_FIELD (E_CONTACT_GIVEN_NAME, EVC_N, "given_name", N_("Given Name"), FALSE, 1),
LIST_ELEM_STR_FIELD (E_CONTACT_FAMILY_NAME, EVC_N, "family_name", N_("Family Name"), FALSE, 0),
STRING_FIELD (E_CONTACT_NICKNAME, EVC_NICKNAME, "nickname", N_("Nickname"), FALSE),
/* Address fields */
MULTI_LIST_FIELD (E_CONTACT_ADDRESS, EVC_ADR, "address", N_("Address List"), FALSE),
ATTR_TYPE_STRUCT_FIELD (E_CONTACT_ADDRESS_HOME, EVC_ADR, "address_home", N_("Home Address"), FALSE, "HOME", adr_getter, adr_setter),
ATTR_TYPE_STRUCT_FIELD (E_CONTACT_ADDRESS_WORK, EVC_ADR, "address_work", N_("Work Address"), FALSE, "WORK", adr_getter, adr_setter),
ATTR_TYPE_STRUCT_FIELD (E_CONTACT_ADDRESS_OTHER, EVC_ADR, "address_other", N_("Other Address"), FALSE, "OTHER", adr_getter, adr_setter),
ATTR_TYPE_STR_FIELD (E_CONTACT_ADDRESS_LABEL_HOME, EVC_LABEL, "address_label_home", N_("Home Address Label"), FALSE, "HOME", 0),
ATTR_TYPE_STR_FIELD (E_CONTACT_ADDRESS_LABEL_WORK, EVC_LABEL, "address_label_work", N_("Work Address Label"), FALSE, "WORK", 0),
ATTR_TYPE_STR_FIELD (E_CONTACT_ADDRESS_LABEL_OTHER, EVC_LABEL, "address_label_other", N_("Other Address Label"), FALSE, "OTHER", 0),
ATTR_TYPE_STR_FIELD (E_CONTACT_PHONE_ASSISTANT, EVC_TEL, "assistant_phone", N_("Assistant Phone"), FALSE, "X-EVOLUTION-ASSISTANT", 0),
ATTR2_TYPE_STR_FIELD (E_CONTACT_PHONE_BUSINESS, EVC_TEL, "business_phone", N_("Business Phone"), FALSE, "WORK", "VOICE", 0),
ATTR2_TYPE_STR_FIELD (E_CONTACT_PHONE_BUSINESS_2, EVC_TEL, "business_phone_2", N_("Business Phone 2"), FALSE, "WORK", "VOICE", 1),
ATTR2_TYPE_STR_FIELD (E_CONTACT_PHONE_BUSINESS_FAX, EVC_TEL, "business_fax", N_("Business Fax"), FALSE, "WORK", "FAX", 0),
ATTR_TYPE_STR_FIELD (E_CONTACT_PHONE_CALLBACK, EVC_TEL, "callback_phone", N_("Callback Phone"), FALSE, "X-EVOLUTION-CALLBACK", 0),
ATTR_TYPE_STR_FIELD (E_CONTACT_PHONE_CAR, EVC_TEL, "car_phone", N_("Car Phone"), FALSE, "CAR", 0),
ATTR2_TYPE_STR_FIELD (E_CONTACT_PHONE_COMPANY, EVC_TEL, "company_phone", N_("Company Phone"), FALSE, "WORK", "VOICE", 2),
ATTR2_TYPE_STR_FIELD (E_CONTACT_PHONE_HOME, EVC_TEL, "home_phone", N_("Home Phone"), FALSE, "HOME", "VOICE", 0),
ATTR2_TYPE_STR_FIELD (E_CONTACT_PHONE_HOME_2, EVC_TEL, "home_phone_2", N_("Home Phone 2"), FALSE, "HOME", "VOICE", 1),
ATTR2_TYPE_STR_FIELD (E_CONTACT_PHONE_HOME_FAX, EVC_TEL, "home_fax", N_("Home Fax"), FALSE, "HOME", "FAX", 0),
ATTR_TYPE_STR_FIELD (E_CONTACT_PHONE_ISDN, EVC_TEL, "isdn_phone", N_("ISDN"), FALSE, "ISDN", 0),
ATTR_TYPE_STR_FIELD (E_CONTACT_PHONE_MOBILE, EVC_TEL, "mobile_phone", N_("Mobile Phone"), FALSE, "CELL", 0),
ATTR_TYPE_STR_FIELD (E_CONTACT_PHONE_OTHER, EVC_TEL, "other_phone", N_("Other Phone"), FALSE, "VOICE", 0), /* XXX */
ATTR_TYPE_STR_FIELD (E_CONTACT_PHONE_OTHER_FAX, EVC_TEL, "other_fax", N_("Other Fax"), FALSE, "FAX", 0), /* XXX */
ATTR_TYPE_STR_FIELD (E_CONTACT_PHONE_PAGER, EVC_TEL, "pager", N_("Pager"), FALSE, "PAGER", 0),
ATTR_TYPE_STR_FIELD (E_CONTACT_PHONE_PRIMARY, EVC_TEL, "primary_phone", N_("Primary Phone"), FALSE, "PREF", 0),
ATTR_TYPE_STR_FIELD (E_CONTACT_PHONE_RADIO, EVC_TEL, "radio", N_("Radio"), FALSE, "X-EVOLUTION-RADIO", 0),
ATTR_TYPE_STR_FIELD (E_CONTACT_PHONE_TELEX, EVC_TEL, "telex", N_("Telex"), FALSE, "X-EVOLUTION-TELEX", 0),
ATTR_TYPE_STR_FIELD (E_CONTACT_PHONE_TTYTDD, EVC_TEL, "tty", N_("TTY"), FALSE, "X-EVOLUTION-TTYTDD", 0),
/* Email fields */
MULTI_LIST_FIELD (E_CONTACT_EMAIL, EVC_EMAIL, "email", N_("Email List"), FALSE),
MULTI_ELEM_STR_FIELD (E_CONTACT_EMAIL_1, EVC_EMAIL, "email_1", N_("Email 1"), FALSE, 0),
MULTI_ELEM_STR_FIELD (E_CONTACT_EMAIL_2, EVC_EMAIL, "email_2", N_("Email 2"), FALSE, 1),
MULTI_ELEM_STR_FIELD (E_CONTACT_EMAIL_3, EVC_EMAIL, "email_3", N_("Email 3"), FALSE, 2),
STRING_FIELD (E_CONTACT_MAILER, EVC_MAILER, "mailer", N_("Mailer"), FALSE),
BOOLEAN_FIELD (E_CONTACT_WANTS_HTML, EVC_X_WANTS_HTML, "wants_html", N_("Wants HTML Mail"), FALSE),
/* Instant messaging fields */
LIST_FIELD (E_CONTACT_IM_AIM, EVC_X_AIM, "im_aim", N_("AIM Screen Name List"), FALSE),
LIST_FIELD (E_CONTACT_IM_JABBER, EVC_X_JABBER, "im_jabber", N_("Jabber Id List"), FALSE),
LIST_FIELD (E_CONTACT_IM_YAHOO, EVC_X_YAHOO, "im_yahoo", N_("Yahoo! Screen Name List"), FALSE),
LIST_FIELD (E_CONTACT_IM_MSN, EVC_X_MSN, "im_msn", N_("MSN Screen Name List"), FALSE),
LIST_FIELD (E_CONTACT_IM_ICQ, EVC_X_ICQ, "im_icq", N_("ICQ Id List"), FALSE),
/* Organizational fields */
LIST_ELEM_STR_FIELD (E_CONTACT_ORG, EVC_ORG, "org", N_("Organization"), FALSE, 0),
LIST_ELEM_STR_FIELD (E_CONTACT_ORG_UNIT, EVC_ORG, "org_unit", N_("Organizational Unit"), FALSE, 1),
LIST_ELEM_STR_FIELD (E_CONTACT_OFFICE, EVC_ORG, "office", N_("Office"), FALSE, 2),
STRING_FIELD (E_CONTACT_TITLE, EVC_TITLE, "title", N_("Title"), FALSE),
STRING_FIELD (E_CONTACT_ROLE, EVC_ROLE, "role", N_("Role"), FALSE),
STRING_FIELD (E_CONTACT_MANAGER, EVC_X_MANAGER, "manager", N_("Manager"), FALSE),
STRING_FIELD (E_CONTACT_ASSISTANT, EVC_X_ASSISTANT, "assistant", N_("Assistant"), FALSE),
/* Web fields */
STRING_FIELD (E_CONTACT_HOMEPAGE_URL, EVC_URL, "homepage_url", N_("Homepage URL"), FALSE),
STRING_FIELD (E_CONTACT_BLOG_URL, EVC_X_BLOG_URL, "blog_url", N_("Weblog URL"), FALSE),
/* Photo/Logo */
STRUCT_FIELD (E_CONTACT_PHOTO, EVC_PHOTO, "photo", N_("Photo"), FALSE, photo_getter, photo_setter),
STRUCT_FIELD (E_CONTACT_LOGO, EVC_LOGO, "logo", N_("Logo"), FALSE, photo_getter, photo_setter),
/* Contact categories */
#if notyet
LIST_FIELD (E_CONTACT_CATEGORY_LIST, EVC_CATEGORIES, "category_list", N_("Category List"), FALSE),
SYNTH_STR_FIELD (E_CONTACT_CATEGORIES, "categories", N_("Categories"), FALSE),
#else
STRING_FIELD (E_CONTACT_CATEGORIES, EVC_CATEGORIES, "categories", N_("Categories"), FALSE),
#endif
/* Collaboration fields */
STRING_FIELD (E_CONTACT_CALENDAR_URI, EVC_CALURI, "caluri", N_("Calendar URI"), FALSE),
STRING_FIELD (E_CONTACT_FREEBUSY_URL, EVC_FBURL, "fburl", N_("Free/Busy URL"), FALSE),
STRING_FIELD (E_CONTACT_ICS_CALENDAR, EVC_ICSCALENDAR, "icscalendar", N_("ICS Calendar"), FALSE),
/* Misc fields */
STRING_FIELD (E_CONTACT_SPOUSE, EVC_X_SPOUSE, "spouse", N_("Spouse's Name"), FALSE),
STRING_FIELD (E_CONTACT_NOTE, EVC_NOTE, "note", N_("Note"), FALSE),
STRUCT_FIELD (E_CONTACT_BIRTH_DATE, EVC_BDAY, "birth_date", N_("Birth Date"), FALSE, date_getter, date_setter),
STRUCT_FIELD (E_CONTACT_ANNIVERSARY, EVC_BDAY, "anniversary", N_("Anniversary"), FALSE, date_getter, date_setter),
BOOLEAN_FIELD (E_CONTACT_IS_LIST, EVC_X_LIST, "list", N_("List"), FALSE),
BOOLEAN_FIELD (E_CONTACT_LIST_SHOW_ADDRESSES, EVC_X_LIST_SHOW_ADDRESSES, "list_show_addresses", N_("List Show Addresses"), FALSE)
};
#undef LIST_ELEM_STR_FIELD
#undef STRING_FIELD
#undef SYNTH_STR_FIELD
#undef LIST_FIELD
#undef STRUCT_FIELD
static GObjectClass *parent_class;
static void e_contact_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
static void e_contact_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
static void
e_contact_dispose (GObject *object)
{
EContact *ec = E_CONTACT (object);
if (!ec->priv)
return;
/* XXX free instance specific stuff */
g_free (ec->priv);
ec->priv = NULL;
if (G_OBJECT_CLASS (parent_class)->dispose)
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
e_contact_class_init (EContactClass *klass)
{
GObjectClass *object_class;
int i;
object_class = G_OBJECT_CLASS(klass);
parent_class = g_type_class_ref (E_TYPE_VCARD);
object_class->dispose = e_contact_dispose;
object_class->set_property = e_contact_set_property;
object_class->get_property = e_contact_get_property;
for (i = 0; i < G_N_ELEMENTS (field_info); i ++) {
GParamSpec *pspec = NULL;
if (field_info[i].t & E_CONTACT_FIELD_TYPE_STRING)
pspec = g_param_spec_string (field_info[i].field_name,
_(field_info[i].pretty_name),
"" /* XXX blurb */,
NULL,
field_info[i].read_only ? G_PARAM_READABLE : G_PARAM_READWRITE);
else if (field_info[i].t & E_CONTACT_FIELD_TYPE_BOOLEAN)
pspec = g_param_spec_boolean (field_info[i].field_name,
_(field_info[i].pretty_name),
"" /* XXX blurb */,
FALSE,
field_info[i].read_only ? G_PARAM_READABLE : G_PARAM_READWRITE);
else
pspec = g_param_spec_pointer (field_info[i].field_name,
_(field_info[i].pretty_name),
"" /* XXX blurb */,
field_info[i].read_only ? G_PARAM_READABLE : G_PARAM_READWRITE);
g_object_class_install_property (object_class, field_info[i].field_id,
pspec);
}
}
static void
e_contact_init (EContact *ec)
{
ec->priv = g_new0 (EContactPrivate, 1);
}
GType
e_contact_get_type (void)
{
static GType contact_type = 0;
if (!contact_type) {
static const GTypeInfo contact_info = {
sizeof (EContactClass),
NULL, /* base_init */
NULL, /* base_finalize */
(GClassInitFunc) e_contact_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (EContact),
0, /* n_preallocs */
(GInstanceInitFunc) e_contact_init,
};
contact_type = g_type_register_static (E_TYPE_VCARD, "EContact", &contact_info, 0);
}
return contact_type;
}
static EVCardAttribute*
e_contact_get_first_attr (EContact *contact, const char *attr_name)
{
GList *attrs, *l;
attrs = e_vcard_get_attributes (E_VCARD (contact));
for (l = attrs; l; l = l->next) {
EVCardAttribute *attr = l->data;
const char *name, *group;
group = e_vcard_attribute_get_group (attr);
name = e_vcard_attribute_get_name (attr);
/* all the attributes we care about should be in group "" */
if ((!group || !*group) && !strcasecmp (name, attr_name))
return attr;
}
return NULL;
}
static void*
photo_getter (EContact *contact, EVCardAttribute *attr)
{
if (attr) {
GList *values = e_vcard_attribute_get_values_decoded (attr);
if (values && values->data) {
GString *s = values->data;
EContactPhoto *photo = g_new (EContactPhoto, 1);
photo->length = s->len;
photo->data = g_malloc (photo->length);
memcpy (photo->data, s->str, photo->length);
return photo;
}
}
return NULL;
}
static void
photo_setter (EContact *contact, EVCardAttribute *attr, void *data)
{
EContactPhoto *photo = data;
const char *mime_type;
char *image_type = "X-EVOLUTION-UNKNOWN";
e_vcard_attribute_add_param_with_value (attr,
e_vcard_attribute_param_new (EVC_ENCODING),
"b");
mime_type = gnome_vfs_get_mime_type_for_data (photo->data, photo->length);
if (!strcmp (mime_type, "image/gif"))
image_type = "GIF";
else if (!strcmp (mime_type, "image/jpeg"))
image_type = "JPEG";
else if (!strcmp (mime_type, "image/png"))
image_type = "PNG";
else if (!strcmp (mime_type, "image/tiff"))
image_type = "TIFF";
/* i have no idea what these last 2 are.. :) */
else if (!strcmp (mime_type, "image/ief"))
image_type = "IEF";
else if (!strcmp (mime_type, "image/cgm"))
image_type = "CGM";
e_vcard_attribute_add_param_with_value (attr,
e_vcard_attribute_param_new (EVC_TYPE),
image_type);
printf ("adding photo of type `%s' of length %d\n", image_type, photo->length);
e_vcard_attribute_add_value_decoded (attr, photo->data, photo->length);
}
static void*
fn_getter (EContact *contact, EVCardAttribute *attr)
{
if (attr) {
GList *p = e_vcard_attribute_get_values (attr);
return g_strdup (p && p->data ? p->data : "");
}
else
return NULL;
}
static void
fn_setter (EContact *contact, EVCardAttribute *attr, void *data)
{
e_vcard_attribute_add_value (attr, (char*)data);
attr = e_contact_get_first_attr (contact, EVC_N);
if (!attr) {
EContactName *name = e_contact_name_from_string ((char*)data);
attr = e_vcard_attribute_new (NULL, EVC_N);
e_vcard_add_attribute (E_VCARD (contact), attr);
/* call the setter directly */
n_setter (contact, attr, name);
e_contact_name_free (name);
}
}
static void*
n_getter (EContact *contact, EVCardAttribute *attr)
{
EContactName *name = g_new0 (EContactName, 1);
if (attr) {
GList *p = e_vcard_attribute_get_values (attr);
name->family = g_strdup (p && p->data ? p->data : ""); if (p) p = p->next;
name->given = g_strdup (p && p->data ? p->data : ""); if (p) p = p->next;
name->additional = g_strdup (p && p->data ? p->data : ""); if (p) p = p->next;
name->prefixes = g_strdup (p && p->data ? p->data : ""); if (p) p = p->next;
name->suffixes = g_strdup (p && p->data ? p->data : "");
}
return name;
}
static void
n_setter (EContact *contact, EVCardAttribute *attr, void *data)
{
EContactName *name = data;
e_vcard_attribute_add_value (attr, name->family);
e_vcard_attribute_add_value (attr, name->given);
e_vcard_attribute_add_value (attr, name->additional);
e_vcard_attribute_add_value (attr, name->prefixes);
e_vcard_attribute_add_value (attr, name->suffixes);
/* now find the attribute for FileAs. if it's not present, fill it in */
attr = e_contact_get_first_attr (contact, EVC_X_FILE_AS);
if (!attr) {
char *strings[3], **stringptr;
char *string;
attr = e_vcard_attribute_new (NULL, EVC_X_FILE_AS);
e_vcard_add_attribute (E_VCARD (contact), attr);
stringptr = strings;
if (name->family && *name->family)
*(stringptr++) = name->family;
if (name->given && *name->given)
*(stringptr++) = name->given;
*stringptr = NULL;
string = g_strjoinv(", ", strings);
e_vcard_attribute_add_value (attr, string);
g_free (string);
}
}
static void*
adr_getter (EContact *contact, EVCardAttribute *attr)
{
if (attr) {
GList *p = e_vcard_attribute_get_values (attr);
EContactAddress *addr = g_new (EContactAddress, 1);
addr->po = g_strdup (p && p->data ? p->data : ""); if (p) p = p->next;
addr->ext = g_strdup (p && p->data ? p->data : ""); if (p) p = p->next;
addr->street = g_strdup (p && p->data ? p->data : ""); if (p) p = p->next;
addr->locality = g_strdup (p && p->data ? p->data : ""); if (p) p = p->next;
addr->region = g_strdup (p && p->data ? p->data : ""); if (p) p = p->next;
addr->code = g_strdup (p && p->data ? p->data : ""); if (p) p = p->next;
addr->country = g_strdup (p && p->data ? p->data : ""); if (p) p = p->next;
return addr;
}
return NULL;
}
static void
adr_setter (EContact *contact, EVCardAttribute *attr, void *data)
{
/* XXX */
g_assert_not_reached ();
}
static void*
date_getter (EContact *contact, EVCardAttribute *attr)
{
if (attr) {
GList *p = e_vcard_attribute_get_values (attr);
EContactDate *date = e_contact_date_from_string (p && p->data ? (char*)p->data : "");
return date;
}
return NULL;
}
static void
date_setter (EContact *contact, EVCardAttribute *attr, void *data)
{
EContactDate *date = data;
char *str = e_contact_date_to_string (date);
e_vcard_attribute_add_value (attr, str);
g_free (str);
}
/* Set_arg handler for the contact */
static void
e_contact_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
EContact *contact = E_CONTACT (object);
int i;
EContactFieldInfo *info = NULL;
if (prop_id < 1 || prop_id >= E_CONTACT_FIELD_LAST) {
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
return;
}
for (i = 0; i < G_N_ELEMENTS (field_info); i++) {
if (field_info[i].field_id == prop_id) {
info = &field_info[i];
break;
}
}
if (!info) {
g_warning ("unknown field %d", prop_id);
return;
}
if (info->t & E_CONTACT_FIELD_TYPE_MULTI) {
GList *new_values = g_value_get_pointer (value);
GList *l;
/* first we remove all attributes of the type we're
adding, then add new ones based on the values that
are passed in */
e_vcard_remove_attributes (E_VCARD (contact), NULL, info->vcard_field_name);
for (l = new_values; l; l = l->next)
e_vcard_add_attribute_with_value (E_VCARD (contact),
e_vcard_attribute_new (NULL, info->vcard_field_name),
(char*)l->data);
}
else if (info->t & E_CONTACT_FIELD_TYPE_SYNTHETIC) {
if (info->t & E_CONTACT_FIELD_TYPE_MULTI_ELEM) {
/* XXX this is kinda broken - we don't insert
insert padding elements if, e.g. the user
sets email 3 when email 1 and 2 don't
exist. But, if we *did* pad the lists we'd
end up with empty items in the vcard. I
dunno which is worse. */
EVCardAttribute *attr = NULL;
gboolean found = FALSE;
int num_left = info->list_elem;
GList *attrs = e_vcard_get_attributes (E_VCARD (contact));
GList *l;
for (l = attrs; l; l = l->next) {
const char *name, *group;
attr = l->data;
group = e_vcard_attribute_get_group (attr);
name = e_vcard_attribute_get_name (attr);
/* all the attributes we care about should be in group "" */
if ((!group || !*group) && !strcasecmp (name, info->vcard_field_name)) {
if (num_left-- == 0) {
found = TRUE;
break;
}
}
}
if (found) {
/* we found it, overwrite it */
e_vcard_attribute_remove_values (attr);
}
else {
/* we didn't find it - add a new attribute */
attr = e_vcard_attribute_new (NULL, info->vcard_field_name);
e_vcard_add_attribute (E_VCARD (contact), attr);
}
e_vcard_attribute_add_value (attr, g_value_get_string (value));
}
else if (info->t & E_CONTACT_FIELD_TYPE_ATTR_TYPE) {
/* XXX this is kinda broken - we don't insert
insert padding elements if, e.g. the user
sets email 3 when email 1 and 2 don't
exist. But, if we *did* pad the lists we'd
end up with empty items in the vcard. I
dunno which is worse. */
EVCardAttribute *attr = NULL;
gboolean found = FALSE;
int num_left = info->list_elem;
GList *attrs = e_vcard_get_attributes (E_VCARD (contact));
GList *l;
const char *sval = g_value_get_string (value);
for (l = attrs; l && !found; l = l->next) {
const char *name, *group;
gboolean found_needed1, found_needed2;
if (!info->attr_type1)
found_needed1 = TRUE;
else
found_needed1 = FALSE;
if (!info->attr_type2)
found_needed2 = TRUE;
else
found_needed2 = FALSE;
attr = l->data;
group = e_vcard_attribute_get_group (attr);
name = e_vcard_attribute_get_name (attr);
/* all the attributes we care about should be in group "" */
if ((!group || !*group) && !strcasecmp (name, info->vcard_field_name)) {
GList *params;
for (params = e_vcard_attribute_get_params (attr); params; params = params->next) {
EVCardAttributeParam *param = params->data;
const char *name = e_vcard_attribute_param_get_name (param);
if (!strcasecmp (name, EVC_TYPE)) {
GList *values = e_vcard_attribute_param_get_values (param);
if (values && values->data) {
if (!found_needed1 && !strcasecmp ((char*)values->data, info->attr_type1))
found_needed1 = TRUE;
else if (!found_needed2 && !strcasecmp ((char*)values->data, info->attr_type2))
found_needed2 = TRUE;
}
}
if (found_needed1 && found_needed2) {
if (num_left-- == 0) {
found = TRUE;
break;
}
}
}
}
}
if (found) {
/* we found it, overwrite it */
e_vcard_attribute_remove_values (attr);
}
else {
/* we didn't find it - add a new attribute */
attr = e_vcard_attribute_new (NULL, info->vcard_field_name);
e_vcard_add_attribute (E_VCARD (contact), attr);
if (info->attr_type1)
e_vcard_attribute_add_param_with_value (attr, e_vcard_attribute_param_new (EVC_TYPE),
info->attr_type1);
if (info->attr_type2)
e_vcard_attribute_add_param_with_value (attr, e_vcard_attribute_param_new (EVC_TYPE),
info->attr_type2);
}
if (sval && *sval)
e_vcard_attribute_add_value (attr, sval);
else
e_vcard_remove_attribute (E_VCARD (contact), attr);
}
else if (info->t & E_CONTACT_FIELD_TYPE_LIST_ELEM) {
EVCardAttribute *attr = e_contact_get_first_attr (contact, info->vcard_field_name);
GList *values;
GList *p;
const char *sval = g_value_get_string (value);
if (!attr) {
if (!sval || !*sval)
return;
printf ("adding new %s\n", info->vcard_field_name);
attr = e_vcard_attribute_new (NULL, info->vcard_field_name);
e_vcard_add_attribute (E_VCARD (contact), attr);
}
values = e_vcard_attribute_get_values (attr);
p = g_list_nth (values, info->list_elem);
if (p) {
g_free (p->data);
p->data = g_strdup (g_value_get_string (value));
}
else {
/* there weren't enough elements in the list, pad it */
int count = info->list_elem - g_list_length (values);
while (count--)
e_vcard_attribute_add_value (attr, "");
e_vcard_attribute_add_value (attr, g_value_get_string (value));
}
}
}
else if (info->t & E_CONTACT_FIELD_TYPE_BOOLEAN) {
EVCardAttribute *attr;
/* first we search for an attribute we can overwrite */
attr = e_contact_get_first_attr (contact, info->vcard_field_name);
if (attr) {
printf ("setting %s to `%s'\n", info->vcard_field_name, g_value_get_string (value));
e_vcard_attribute_remove_values (attr);
e_vcard_attribute_add_value (attr, g_value_get_boolean (value) ? "TRUE" : "FALSE");
}
else {
/* and if we don't find one we create a new attribute */
e_vcard_add_attribute_with_value (E_VCARD (contact),
e_vcard_attribute_new (NULL, info->vcard_field_name),
g_value_get_boolean (value) ? "TRUE" : "FALSE");
}
}
else if (info->t & E_CONTACT_FIELD_TYPE_STRING) {
EVCardAttribute *attr;
const char *sval = g_value_get_string (value);
/* first we search for an attribute we can overwrite */
attr = e_contact_get_first_attr (contact, info->vcard_field_name);
if (attr) {
printf ("setting %s to `%s'\n", info->vcard_field_name, sval);
e_vcard_attribute_remove_values (attr);
if (sval)
e_vcard_attribute_add_value (attr, sval);
}
else if (sval) {
/* and if we don't find one we create a new attribute */
e_vcard_add_attribute_with_value (E_VCARD (contact),
e_vcard_attribute_new (NULL, info->vcard_field_name),
g_value_get_string (value));
}
}
else if (info->t & E_CONTACT_FIELD_TYPE_STRUCT) {
EVCardAttribute *attr = e_contact_get_first_attr (contact, info->vcard_field_name);
void *data = g_value_get_pointer (value);
if (attr) {
printf ("overwriting existing %s\n", info->vcard_field_name);
/* remove all existing values and parameters.
the setter will add the correct ones */
e_vcard_attribute_remove_values (attr);
e_vcard_attribute_remove_params (attr);
}
else {
printf ("adding new %s\n", info->vcard_field_name);
attr = e_vcard_attribute_new (NULL, info->vcard_field_name);
e_vcard_add_attribute (E_VCARD (contact), attr);
}
info->struct_setter (contact, attr, data);
}
else {
g_warning ("unhandled attribute `%s'", info->vcard_field_name);
}
}
static GList *
e_contact_get_email_list (EContact *contact)
{
GList *rv = NULL;
GList *attrs, *l;
attrs = e_vcard_get_attributes (E_VCARD (contact));
for (l = attrs; l; l = l->next) {
EVCardAttribute *attr = l->data;
const char *name, *group;
group = e_vcard_attribute_get_group (attr);
name = e_vcard_attribute_get_name (attr);
/* all the attributes we care about should be in group "" */
if ((!group || !*group) && !strcasecmp (name, EVC_EMAIL)) {
GList *v = e_vcard_attribute_get_values (attr);
rv = g_list_append (rv, v ? g_strdup (v->data) : NULL);
}
}
return rv;
}
static EVCardAttribute *
e_contact_find_attribute_with_types (EContact *contact, const char *attr_name, const char *type_needed1, const char *type_needed2, int nth)
{
GList *l, *attrs;
gboolean found_needed1, found_needed2;
attrs = e_vcard_get_attributes (E_VCARD (contact));
for (l = attrs; l; l = l->next) {
EVCardAttribute *attr = l->data;
const char *name, *group;
if (!type_needed1)
found_needed1 = TRUE;
else
found_needed1 = FALSE;
if (!type_needed2)
found_needed2 = TRUE;
else
found_needed2 = FALSE;
group = e_vcard_attribute_get_group (attr);
name = e_vcard_attribute_get_name (attr);
/* all the attributes we care about should be in group "" */
if ((!group || !*group) && !strcasecmp (name, attr_name)) {
GList *params;
for (params = e_vcard_attribute_get_params (attr); params; params = params->next) {
EVCardAttributeParam *param = params->data;
const char *name = e_vcard_attribute_param_get_name (param);
if (!strcasecmp (name, EVC_TYPE)) {
GList *values = e_vcard_attribute_param_get_values (param);
if (values && values->data) {
if (!found_needed1 && !strcasecmp ((char*)values->data, type_needed1))
found_needed1 = TRUE;
else if (!found_needed2 && !strcasecmp ((char*)values->data, type_needed2))
found_needed2 = TRUE;
}
}
if (found_needed1 && found_needed2) {
if (nth-- == 0)
return attr;
else
break;
}
}
}
}
return NULL;
}
static void
e_contact_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
EContact *contact = E_CONTACT (object);
int i;
EContactFieldInfo *info = NULL;
if (prop_id < 1 || prop_id >= E_CONTACT_FIELD_LAST) {
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
return;
}
for (i = 0; i < G_N_ELEMENTS (field_info); i++) {
if (field_info[i].field_id == prop_id) {
info = &field_info[i];
break;
}
}
if (!info) {
g_warning ("unknown field %d", prop_id);
return;
}
else if (info->t & E_CONTACT_FIELD_TYPE_BOOLEAN) {
EVCardAttribute *attr = e_contact_get_first_attr (contact, info->vcard_field_name);
gboolean rv = FALSE;
if (attr) {
GList *v = e_vcard_attribute_get_values (attr);
rv = v && v->data && !strcasecmp ((char*)v->data, "true");
}
g_value_set_boolean (value, rv);
}
else if (info->t & E_CONTACT_FIELD_TYPE_LIST) {
EVCardAttribute *attr = e_contact_get_first_attr (contact, info->vcard_field_name);
if (attr)
g_value_set_pointer (value, e_vcard_attribute_get_values (attr));
}
else if (info->t & E_CONTACT_FIELD_TYPE_LIST_ELEM) {
if (info->t & E_CONTACT_FIELD_TYPE_STRING) {
GList *attrs, *l;
attrs = e_vcard_get_attributes (E_VCARD (contact));
for (l = attrs; l; l = l->next) {
EVCardAttribute *attr = l->data;
const char *name, *group;
group = e_vcard_attribute_get_group (attr);
name = e_vcard_attribute_get_name (attr);
/* all the attributes we care about should be in group "" */
if ((!group || !*group) && !strcasecmp (name, info->vcard_field_name)) {
GList *v;
int count;
v = e_vcard_attribute_get_values (attr);
count = info->list_elem;
v = g_list_nth (v, info->list_elem);
g_value_set_string (value, v ? v->data : NULL);
}
}
}
}
else if (info->t & E_CONTACT_FIELD_TYPE_MULTI_ELEM) {
if (info->t & E_CONTACT_FIELD_TYPE_STRING) {
GList *attrs, *l;
attrs = e_vcard_get_attributes (E_VCARD (contact));
for (l = attrs; l; l = l->next) {
EVCardAttribute *attr = l->data;
const char *name, *group;
group = e_vcard_attribute_get_group (attr);
name = e_vcard_attribute_get_name (attr);
/* all the attributes we care about should be in group "" */
if ((!group || !*group) && !strcasecmp (name, info->vcard_field_name)) {
GList *v;
int count;
v = e_vcard_attribute_get_values (attr);
count = info->list_elem;
v = g_list_nth (v, info->list_elem);
g_value_set_string (value, v ? v->data : NULL);
}
}
}
}
else if (info->t & E_CONTACT_FIELD_TYPE_ATTR_TYPE) {
EVCardAttribute *attr = e_contact_find_attribute_with_types (contact, info->vcard_field_name, info->attr_type1, info->attr_type2, info->list_elem);
if (info->t & E_CONTACT_FIELD_TYPE_STRING) {
if (attr) {
GList *p = e_vcard_attribute_get_values (attr);
char *rv = p->data;
g_value_set_string (value, rv);
}
else {
g_value_set_string (value, NULL);
}
}
else { /* struct */
gpointer rv = info->struct_getter (contact, attr);
g_value_set_pointer (value, rv);
}
}
else if (info->t & E_CONTACT_FIELD_TYPE_STRUCT) {
EVCardAttribute *attr = e_contact_get_first_attr (contact, info->vcard_field_name);
void *rv = NULL;
if (attr)
rv = info->struct_getter (contact, attr);
g_value_set_pointer (value, rv);
}
else if (info->t & E_CONTACT_FIELD_TYPE_SYNTHETIC) {
switch (info->field_id) {
default:
g_warning ("unhandled synthetic field 0x%02x", info->field_id);
}
}
else {
GList *attrs, *l;
GList *rv = NULL; /* used for multi attribute lists */
attrs = e_vcard_get_attributes (E_VCARD (contact));
for (l = attrs; l; l = l->next) {
EVCardAttribute *attr = l->data;
const char *name, *group;
group = e_vcard_attribute_get_group (attr);
name = e_vcard_attribute_get_name (attr);
/* all the attributes we care about should be in group "" */
if ((!group || !*group) && !strcasecmp (name, info->vcard_field_name)) {
GList *v;
v = e_vcard_attribute_get_values (attr);
if (info->t & E_CONTACT_FIELD_TYPE_STRING) {
g_value_set_string (value, v ? v->data : NULL);
}
else {
rv = g_list_append (rv, v ? g_strdup (v->data) : NULL);
g_value_set_pointer (value, rv);
}
}
}
}
}
EContact*
e_contact_new (void)
{
return e_contact_new_from_vcard ("");
}
EContact*
e_contact_new_from_vcard (const char *vcard)
{
EContact *contact = g_object_new (E_TYPE_CONTACT, NULL);
e_vcard_construct (E_VCARD (contact), vcard);
return contact;
}
EContact*
e_contact_duplicate (EContact *contact)
{
char *vcard = e_vcard_to_string (E_VCARD (contact), EVC_FORMAT_VCARD_30);
EContact *c = e_contact_new_from_vcard (vcard);
g_free (vcard);
return c;
}
const char *
e_contact_field_name (EContactField field_id)
{
int i;
g_return_val_if_fail (field_id >= 1 && field_id <= E_CONTACT_FIELD_LAST, "");
for (i = 0; i < G_N_ELEMENTS (field_info); i ++) {
if (field_id == field_info[i].field_id)
return field_info[i].field_name;
}
g_warning ("unknown field id %d", field_id);
return "";
}
const char *
e_contact_pretty_name (EContactField field_id)
{
int i;
g_return_val_if_fail (field_id >= 1 && field_id <= E_CONTACT_FIELD_LAST, "");
for (i = 0; i < G_N_ELEMENTS (field_info); i ++) {
if (field_id == field_info[i].field_id)
return _(field_info[i].pretty_name);
}
g_warning ("unknown field id %d", field_id);
return "";
}
EContactField
e_contact_field_id (const char *field_name)
{
int i;
for (i = 0; i < G_N_ELEMENTS (field_info); i ++) {
if (!strcmp (field_info[i].field_name, field_name))
return field_info[i].field_id;
}
g_warning ("unknown field name `%s'", field_name);
return 0;
}
gpointer
e_contact_get (EContact *contact, EContactField field_id)
{
gpointer value;
g_return_val_if_fail (contact && E_IS_CONTACT (contact), NULL);
g_return_val_if_fail (field_id >= 1 && field_id <= E_CONTACT_FIELD_LAST, NULL);
g_object_get (contact,
e_contact_field_name (field_id), &value,
NULL);
return value;
}
/* XXX this won't work for structure/list types... */
static void
free_const_data (gpointer data, GObject *where_object_was)
{
g_free (data);
}
const gpointer
e_contact_get_const (EContact *contact, EContactField field_id)
{
gpointer value;
g_return_val_if_fail (E_IS_CONTACT (contact), NULL);
g_return_val_if_fail (field_id >= 1 && field_id <= E_CONTACT_FIELD_LAST, NULL);
value = e_contact_get (contact, field_id);
g_object_weak_ref (G_OBJECT (contact), free_const_data, value);
return value;
}
void
e_contact_set (EContact *contact, EContactField field_id, gpointer value)
{
printf ("e_contact_set (%p, %d, %p)\n", contact, field_id, value);
g_return_if_fail (contact && E_IS_CONTACT (contact));
g_return_if_fail (field_id >= 1 && field_id <= E_CONTACT_FIELD_LAST);
g_object_set (contact,
e_contact_field_name (field_id), value,
NULL);
}
EContactName*
e_contact_name_new ()
{
return g_new0 (EContactName, 1);
}
char *
e_contact_name_to_string(const EContactName *name)
{
char *strings[6], **stringptr = strings;
g_return_val_if_fail (name != NULL, NULL);
if (name->prefixes && *name->prefixes)
*(stringptr++) = name->prefixes;
if (name->given && *name->given)
*(stringptr++) = name->given;
if (name->additional && *name->additional)
*(stringptr++) = name->additional;
if (name->family && *name->family)
*(stringptr++) = name->family;
if (name->suffixes && *name->suffixes)
*(stringptr++) = name->suffixes;
*stringptr = NULL;
return g_strjoinv(" ", strings);
}
EContactName*
e_contact_name_from_string (const char *name_str)
{
EContactName *name = e_contact_name_new();
ENameWestern *western = e_name_western_parse (name_str);
name->prefixes = g_strdup (western->prefix);
name->given = g_strdup (western->first );
name->additional = g_strdup (western->middle);
name->family = g_strdup (western->last );
name->suffixes = g_strdup (western->suffix);
e_name_western_free(western);
return name;
}
EContactName*
e_contact_name_copy (EContactName *n)
{
EContactName *name = e_contact_name_new();
name->prefixes = g_strdup (n->prefixes);
name->given = g_strdup (n->given);
name->additional = g_strdup (n->additional);
name->family = g_strdup (n->family);
name->suffixes = g_strdup (n->suffixes);
return name;
}
void
e_contact_name_free (EContactName *name)
{
if (!name)
return;
g_free (name->family);
g_free (name->given);
g_free (name->additional);
g_free (name->prefixes);
g_free (name->suffixes);
g_free (name);
}
EContactDate*
e_contact_date_new (void)
{
return g_new0 (EContactDate, 1);
}
EContactDate*
e_contact_date_from_string (const char *str)
{
EContactDate* date = e_contact_date_new();
int length;
length = strlen(str);
if (length == 10 ) {
date->year = str[0] * 1000 + str[1] * 100 + str[2] * 10 + str[3] - '0' * 1111;
date->month = str[5] * 10 + str[6] - '0' * 11;
date->day = str[8] * 10 + str[9] - '0' * 11;
} else if ( length == 8 ) {
date->year = str[0] * 1000 + str[1] * 100 + str[2] * 10 + str[3] - '0' * 1111;
date->month = str[4] * 10 + str[5] - '0' * 11;
date->day = str[6] * 10 + str[7] - '0' * 11;
}
return date;
}
char *
e_contact_date_to_string (EContactDate *dt)
{
if (dt)
return g_strdup_printf ("%04d-%02d-%02d",
CLAMP(dt->year, 1000, 9999),
CLAMP(dt->month, 1, 12),
CLAMP(dt->day, 1, 31));
else
return NULL;
}
void
e_contact_date_free (EContactDate *dt)
{
g_free (dt);
}
void
e_contact_photo_free (EContactPhoto *photo)
{
if (!photo)
return;
g_free (photo->data);
g_free (photo);
}
void
e_contact_address_free (EContactAddress *address)
{
if (!address)
return;
g_free (address->address_format);
g_free (address->po);
g_free (address->ext);
g_free (address->street);
g_free (address->locality);
g_free (address->region);
g_free (address->code);
g_free (address->country);
g_free (address);
}
