/**
* e_vcard_attribute_add_param_with_value:
* @attr: an #EVCardAttribute
* @param: an #EVCardAttributeParam
* @value: a string value
*
* Adds @value to @param, then adds @param to @attr.
**/
void
e_vcard_attribute_add_param_with_value (EVCardAttribute *attr,
EVCardAttributeParam *param, const char *value)
{
g_return_if_fail (attr != NULL);
g_return_if_fail (param != NULL);
e_vcard_attribute_param_add_value (param, value);
e_vcard_attribute_add_param (attr, param);
}
/*
* Convenience function to set the type parmeter of a vcard attribute
*
* attr: the attribute to modify
* type: semicolan seperated list of values
*
*/
void
hito_vcard_attribute_set_type (EVCardAttribute *attr, const gchar *type)
{
GList *params;
EVCardAttributeParam *p = NULL;
gchar **values;
gint i;
/* look for the TYPE parameter */
for (params = e_vcard_attribute_get_params (attr); params;
params = g_list_next (params))
{
if (!strcmp (e_vcard_attribute_param_get_name (params->data), "TYPE"))
{
p = params->data;
break;
}
}
/* we didn't find the TYPE parameter, so create it now */
if (!p)
{
/* if there isn't an existing TYPE and we are not setting a value, we can
* return straight away */
if (!type)
return;
p = e_vcard_attribute_param_new ("TYPE");
e_vcard_attribute_add_param (attr, p);
}
/* remove the current values */
e_vcard_attribute_param_remove_values (p);
/* if type is null, we don't want to add any type parameters */
if (!type)
return;
values = g_strsplit (type, ";", -1);
for (i = 0; (values[i]); i++)
{
e_vcard_attribute_param_add_value (p, values[i]);
}
g_strfreev (values);
}
/**
* e_vcard_attribute_copy:
* @attr: attribute to copy
*
* Makes a copy of @attr.
*
* Return value: A new #EVCardAttribute identical to @attr.
**/
EVCardAttribute*
e_vcard_attribute_copy (EVCardAttribute *attr)
{
EVCardAttribute *a;
GList *p;
g_return_val_if_fail (attr != NULL, NULL);
a = e_vcard_attribute_new (attr->group, attr->name);
for (p = attr->values; p; p = p->next)
e_vcard_attribute_add_value (a, p->data);
for (p = attr->params; p; p = p->next)
e_vcard_attribute_add_param (a, e_vcard_attribute_param_copy (p->data));
return a;
}
/**
* e_vcard_attribute_add_param_with_values:
* @attr: an #EVCardAttribute
* @param: an #EVCardAttributeParam
* @Varargs: a %NULL-terminated list of strings
*
* Adds the list of values to @param, then adds @param
* to @attr.
**/
void
e_vcard_attribute_add_param_with_values (EVCardAttribute *attr,
EVCardAttributeParam *param, ...)
{
va_list ap;
char *v;
g_return_if_fail (attr != NULL);
g_return_if_fail (param != NULL);
va_start (ap, param);
while ((v = va_arg (ap, char*))) {
e_vcard_attribute_param_add_value (param, v);
}
va_end (ap);
e_vcard_attribute_add_param (attr, param);
}
static void
read_attribute_params (EVCardAttribute *attr, char **p, gboolean *quoted_printable)
{
char *lp;
GString *str;
EVCardAttributeParam *param = NULL;
gboolean in_quote = FALSE;
str = g_string_new ("");
for( lp = skip_newline( *p, *quoted_printable );
*lp != '\n' && *lp != '\r' && *lp != '\0';
lp = skip_newline( lp, *quoted_printable ) ) {
if (*lp == '"') {
in_quote = !in_quote;
lp = g_utf8_next_char (lp);
}
else if (in_quote || g_unichar_isalnum (g_utf8_get_char (lp)) || *lp == '-' || *lp == '_') {
g_string_append_unichar (str, g_utf8_get_char (lp));
lp = g_utf8_next_char (lp);
}
/* accumulate until we hit the '=' or ';'. If we hit
* a '=' the string contains the parameter name. if
* we hit a ';' the string contains the parameter
* value and the name is either ENCODING (if value ==
* QUOTED-PRINTABLE) or TYPE (in any other case.)
*/
else if (*lp == '=') {
if (str->len > 0) {
param = e_vcard_attribute_param_new (str->str);
g_string_assign (str, "");
lp = g_utf8_next_char (lp);
}
else {
skip_until (&lp, ":;");
if (*lp == ';') {
lp = g_utf8_next_char (lp);
} else if (*lp == ':') {
/* do nothing */
} else {
skip_to_next_line( &lp );
break;
}
}
}
else if (*lp == ';' || *lp == ':' || *lp == ',') {
gboolean colon = (*lp == ':');
gboolean comma = (*lp == ',');
if (param) {
if (str->len > 0) {
e_vcard_attribute_param_add_value (param, str->str);
g_string_assign (str, "");
if (!colon)
lp = g_utf8_next_char (lp);
}
else {
/* we've got a parameter of the form:
* PARAM=(.*,)?[:;]
* so what we do depends on if there are already values
* for the parameter. If there are, we just finish
* this parameter and skip past the offending character
* (unless it's the ':'). If there aren't values, we free
* the parameter then skip past the character.
*/
if (!param->values) {
e_vcard_attribute_param_free (param);
param = NULL;
if (!colon)
lp = g_utf8_next_char (lp);
}
}
if (param
&& !g_ascii_strcasecmp (param->name, "encoding")
&& !g_ascii_strcasecmp (param->values->data, "quoted-printable")) {
*quoted_printable = TRUE;
e_vcard_attribute_param_free (param);
param = NULL;
}
}
else {
if (str->len > 0) {
char *param_name;
if (!g_ascii_strcasecmp (str->str,
"quoted-printable")) {
param_name = "ENCODING";
*quoted_printable = TRUE;
}
/* apple's broken addressbook app outputs naked BASE64
parameters, which aren't even vcard 3.0 compliant. */
else if (!g_ascii_strcasecmp (str->str,
"base64")) {
param_name = "ENCODING";
g_string_assign (str, "b");
}
else {
param_name = "TYPE";
}
if (param_name) {
param = e_vcard_attribute_param_new (param_name);
e_vcard_attribute_param_add_value (param, str->str);
}
g_string_assign (str, "");
if (!colon)
lp = g_utf8_next_char (lp);
}
else {
/* we've got an attribute with a truly empty
attribute parameter. So it's of the form:
ATTR;[PARAM=value;]*;[PARAM=value;]*:
(note the extra ';')
the only thing to do here is, well.. nothing.
we skip over the character if it's not a colon,
and the rest is handled for us: We'll either
continue through the loop again if we hit a ';',
or we'll break out correct below if it was a ':' */
if (!colon)
lp = g_utf8_next_char (lp);
}
}
if (param && !comma) {
e_vcard_attribute_add_param (attr, param);
param = NULL;
}
if (colon)
break;
}
else {
g_warning ("invalid character found in parameter spec");
g_string_assign (str, "");
/* skip_until (&lp, ":;"); */
skip_to_next_line( &lp );
}
}
if (str)
g_string_free (str, TRUE);
*p = lp;
}
