/**
* Free address folder. Note: this does not free up the lists of children
* (folders, groups and person). This should be done prior to calling this
* function.
* \param folder Folder to free.
*/
void addritem_free_item_folder( ItemFolder *folder ) {
g_return_if_fail( folder != NULL );
/* Free internal stuff */
g_free( ADDRITEM_ID(folder) );
g_free( ADDRITEM_NAME(folder) );
g_free( folder->remarks );
mgu_clear_list( folder->listItems );
g_list_free( folder->listItems );
ADDRITEM_TYPE(folder) = ITEMTYPE_NONE;
ADDRITEM_ID(folder) = NULL;
ADDRITEM_NAME(folder) = NULL;
ADDRITEM_PARENT(folder) = NULL;
ADDRITEM_SUBTYPE(folder) = 0;
folder->isRoot = FALSE;
folder->remarks = NULL;
folder->listItems = NULL;
folder->listFolder = NULL;
folder->listGroup = NULL;
folder->listPerson = NULL;
folder->folderType = ADDRFOLDER_NONE;
folder->folderData = NULL;
folder->isHidden = FALSE;
g_free( folder );
}
/**
* Format E-Mail address.
* \param email EMail item to format.
* \return Formatted string. Should be freed after use.
*/
gchar *addritem_format_email( ItemEMail *email ) {
gchar *address;
gchar *name;
ItemPerson *person;
address = NULL;
name = NULL;
if( ADDRITEM_NAME( email ) ) {
if( strlen( ADDRITEM_NAME( email ) ) ) {
name = ADDRITEM_NAME( email );
}
}
if( ! name ) {
person = ( ItemPerson * ) ADDRITEM_PARENT( email );
name = ADDRITEM_NAME( person );
}
if( name ) {
if( strchr_with_skip_quote( name, '"', ',' ) ) {
address = g_strdup_printf( "\"%s\" <%s>", name, email->address );
}
else {
address = g_strdup_printf( "%s <%s>", name, email->address );
}
}
else {
address = g_strdup_printf( "%s", email->address );
}
return address;
}
/**
* Print address group item for debug.
* \param group Group to print.
* \param stream Output stream.
*/
void addritem_print_item_group( ItemGroup *group, FILE *stream ) {
GList *node;
ItemPerson *person;
ItemEMail *item;
g_return_if_fail( group != NULL );
fprintf( stream, "Group:\n" );
fprintf( stream, "\tt/u: %d : '%s'\n", ADDRITEM_TYPE(group), ADDRITEM_ID(group) );
fprintf( stream, "\tsub: %d\n", ADDRITEM_SUBTYPE(group) );
fprintf( stream, "\tgrp: '%s'\n", ADDRITEM_NAME(group) );
fprintf( stream, "\trem: '%s'\n", group->remarks );
fprintf( stream, "\t---\n" );
node = group->listEMail;
while( node ) {
item = node->data;
person = ( ItemPerson * ) ADDRITEM_PARENT(item);
if( person ) {
fprintf( stream, "\t\tpid : '%s'\n", ADDRITEM_ID(person) );
fprintf( stream, "\t\tcomn: '%s'\n", ADDRITEM_NAME(person) );
}
else {
fprintf( stream, "\t\tpid : ???\n" );
fprintf( stream, "\t\tcomn: ???\n" );
}
addritem_print_item_email( item, stream );
node = g_list_next( node );
}
fprintf( stream, "\t***\n" );
}
/**
* Free address person object.
* \param person Person object to free.
*/
void addritem_free_item_person( ItemPerson *person ) {
g_return_if_fail( person != NULL );
/* Free internal stuff */
g_free( ADDRITEM_ID(person) );
g_free( ADDRITEM_NAME(person) );
g_free( person->firstName );
g_free( person->lastName );
g_free( person->nickName );
g_free( person->externalID );
g_list_free( person->listEMail );
addritem_free_list_attribute( person->listAttrib );
ADDRITEM_OBJECT(person)->type = ITEMTYPE_NONE;
ADDRITEM_ID(person) = NULL;
ADDRITEM_NAME(person) = NULL;
ADDRITEM_PARENT(person) = NULL;
ADDRITEM_SUBTYPE(person) = 0;
person->firstName = NULL;
person->lastName = NULL;
person->nickName = NULL;
person->externalID = NULL;
person->listEMail = NULL;
person->listAttrib = NULL;
g_free( person );
}
/*
* Remove empty folders (categories).
*/
static void jpilot_remove_empty( JPilotFile *pilotFile ) {
GList *listFolder;
GList *remList;
GList *node;
gint i = 0;
listFolder = addrcache_get_list_folder( pilotFile->addressCache );
node = listFolder;
remList = NULL;
while( node ) {
ItemFolder *folder = node->data;
if( ADDRITEM_NAME(folder) == NULL || *ADDRITEM_NAME(folder) == '\0' ) {
if( folder->listPerson ) {
/* Give name to folder */
gchar name[20];
sprintf( name, "? %d", i );
addritem_folder_set_name( folder, name );
}
else {
/* Mark for removal */
remList = g_list_append( remList, folder );
}
}
node = g_list_next( node );
i++;
}
node = remList;
while( node ) {
ItemFolder *folder = node->data;
addrcache_remove_folder( pilotFile->addressCache, folder );
node = g_list_next( node );
}
g_list_free( remList );
}
/**
* Create a shallow copy of specified email address item.
* \param item E-Mail to copy.
* \return Copy of email, or <i>NULL</i> if null argument supplied.
*/
ItemEMail *addritem_copy_item_email( ItemEMail *item ) {
ItemEMail *itemNew = NULL;
if( item ) {
itemNew = addritem_create_item_email();
ADDRITEM_NAME(itemNew) = g_strdup( ADDRITEM_NAME(item) );
itemNew->address = g_strdup( item->address );
itemNew->remarks = g_strdup( item->remarks );
}
return itemNew;
}
/**
* Copy (deep copy) address book group.
* \param item Group to copy.
* \return Copy of the group object, or <i>NULL</i> if null argument supplied.
*/
ItemGroup *addritem_copy_item_group( ItemGroup *item ) {
ItemGroup *itemNew;
itemNew = g_new0( ItemGroup, 1 );
if( item ) {
itemNew = addritem_create_item_group();
ADDRITEM_NAME(itemNew) = g_strdup( ADDRITEM_NAME(item) );
itemNew->remarks = g_strdup( item->remarks );
}
return itemNew;
}
/**
* Copy address book folder. Note that only the folder and not its contents are
* copied.
* \param item Folder to copy.
* \return A copy of the folder, or <i>NULL</i> if null argument supplied.
*/
ItemFolder *addritem_copy_item_folder( ItemFolder *item ) {
ItemFolder *itemNew;
itemNew = g_new0( ItemFolder, 1 );
if( item ) {
itemNew = addritem_create_item_folder();
ADDRITEM_NAME(itemNew) = g_strdup( ADDRITEM_NAME(item) );
itemNew->folderType = item->folderType;
}
return itemNew;
}
/**
* Specify common name for person object.
* \param person Person object.
* \param value name.
*/
void addritem_person_set_common_name( ItemPerson *person, const gchar *value ) {
if (!value || g_utf8_validate(value, -1, NULL))
ADDRITEM_NAME(person) = mgu_replace_string( ADDRITEM_NAME(person), value );
else {
gchar *out = conv_codeset_strdup(value,
conv_get_locale_charset_str_no_utf8(),
CS_INTERNAL);
if (out)
ADDRITEM_NAME(person) = mgu_replace_string( ADDRITEM_NAME(person), out );
g_free(out);
}
}
/*
* Comparison using linked list elements.
*/
static gint exporthtml_compare_name(
gconstpointer ptr1, gconstpointer ptr2 )
{
const AddrItemObject *item1 = ptr1;
const AddrItemObject *item2 = ptr2;
const gchar *name1 = NULL, *name2 = NULL;
if( item1 ) name1 = ADDRITEM_NAME( item1 );
if( item2 ) name2 = ADDRITEM_NAME( item2 );
if( ! name1 ) return ( name2 != NULL );
if( ! name2 ) return -1;
return g_utf8_collate( name1, name2 );
}
/**
* Create a shallow copy of address book person object.
* \param item Person to copy.
* \return Copy of person, or <i>NULL</i> if null argument supplied.
*/
ItemPerson *addritem_copy_item_person( ItemPerson *item ) {
ItemPerson *itemNew;
itemNew = NULL;
if( item ) {
itemNew = addritem_create_item_person();
ADDRITEM_NAME(itemNew) = g_strdup( ADDRITEM_NAME(item) );
itemNew->firstName = g_strdup( item->firstName );
itemNew->lastName = g_strdup( item->lastName );
itemNew->nickName = g_strdup( item->nickName );
itemNew->externalID = g_strdup( item->externalID );
}
return itemNew;
}
/**
* Replace an incompleted address with a completed one.
* \param entry Address entry field.
* \param newtext New text.
* \param start_pos Insertion point in entry field.
*/
static void replace_address_in_edit(GtkEntry *entry, const gchar *newtext,
gint start_pos, gboolean is_group, GList *grp_emails)
{
if (!newtext) return;
gtk_editable_delete_text(GTK_EDITABLE(entry), start_pos, -1);
if (!is_group) {
gtk_editable_insert_text(GTK_EDITABLE(entry), newtext, strlen(newtext),
&start_pos);
} else {
gchar *addresses = NULL;
GList *cur = grp_emails;
for (; cur; cur = cur->next) {
gchar *tmp;
ItemEMail *email = (ItemEMail *)cur->data;
ItemPerson *person = ( ItemPerson * ) ADDRITEM_PARENT(email);
gchar *addr = get_complete_address_from_name_email(
ADDRITEM_NAME(person), email->address);
if (addresses)
tmp = g_strdup_printf("%s, %s", addresses, addr);
else
tmp = g_strdup_printf("%s", addr);
g_free(addr);
g_free(addresses);
addresses = tmp;
}
gtk_editable_insert_text(GTK_EDITABLE(entry), addresses, strlen(addresses),
&start_pos);
g_free(addresses);
}
gtk_editable_set_position(GTK_EDITABLE(entry), -1);
}
/**
* Print person item for debug.
* \param person Person to print.
* \param stream Output stream.
*/
void addritem_print_item_person( ItemPerson *person, FILE *stream ) {
GList *node;
g_return_if_fail( person != NULL );
fprintf( stream, "Person:\n" );
fprintf( stream, "\tt/uid: %d : '%s'\n", ADDRITEM_TYPE(person), ADDRITEM_ID(person) );
fprintf( stream, "\tsubty: %d\n", ADDRITEM_SUBTYPE(person) );
fprintf( stream, "\tcommn: '%s'\n", ADDRITEM_NAME(person) );
fprintf( stream, "\tfirst: '%s'\n", person->firstName );
fprintf( stream, "\tlast : '%s'\n", person->lastName );
fprintf( stream, "\tnick : '%s'\n", person->nickName );
fprintf( stream, "\textID: '%s'\n", person->externalID );
fprintf( stream, "\teMail:\n" );
fprintf( stream, "\t---\n" );
node = person->listEMail;
while( node ) {
addritem_print_item_email( node->data, stream );
node = g_list_next( node );
}
fprintf( stream, "\tuAttr:\n" );
fprintf( stream, "\t---\n" );
node = person->listAttrib;
while( node ) {
addritem_print_attribute( node->data, stream );
node = g_list_next( node );
}
fprintf( stream, "\t===\n" );
}
static gchar* vcard_get_from_ItemPerson(ItemPerson *item)
{
VFormat *vformat;
gchar *vcard;
VFormatParam *param;
VFormatAttribute *attr;
GList *walk;
vformat = vformat_new();
/* UID */
attr = vformat_attribute_new(NULL,"UID");
vformat_add_attribute_with_value(vformat, attr, ADDRITEM_ID(item));
/* Name */
if(item->lastName || item->firstName) {
attr = vformat_attribute_new(NULL,"N");
vformat_add_attribute_with_values(vformat, attr,
item->lastName ? item->lastName : "",
item->firstName ? item->firstName
: "",
NULL);
}
/* Formatted name */
if(ADDRITEM_NAME(item)) {
attr = vformat_attribute_new(NULL,"FN");
vformat_add_attribute_with_value(vformat, attr, ADDRITEM_NAME(item));
}
/* EMail addresses */
for (walk = item->listEMail; walk; walk = walk->next) {
gchar *email;
email = ((ItemEMail*)walk->data)->address;
attr = vformat_attribute_new(NULL,"EMAIL");
param = vformat_attribute_param_new("INTERNET");
vformat_attribute_add_param(attr, param);
vformat_add_attribute_with_value(vformat, attr, email);
}
vcard = vformat_to_string(vformat, VFORMAT_CARD_21);
vformat_free(vformat);
return vcard;
}
/**
* Print E-Mail address object for debug.
* \param item Item to print.
* \param stream Output stream.
*/
void addritem_print_item_email( ItemEMail *item, FILE *stream ) {
g_return_if_fail( item != NULL );
fprintf( stream, "\t\tt/id: %d : '%s'\n", ADDRITEM_TYPE(item), ADDRITEM_ID(item) );
fprintf( stream, "\t\tsubty: %d\n", ADDRITEM_SUBTYPE(item) );
fprintf( stream, "\t\talis: '%s'\n", ADDRITEM_NAME(item) );
fprintf( stream, "\t\taddr: '%s'\n", item->address );
fprintf( stream, "\t\trems: '%s'\n", item->remarks );
fprintf( stream, "\t\t---\n" );
}
/**
* Retrieve E-Mail address object for update.
* \param item ItemEmail to update.
* \return object, or <i>NULL</i> if none created.
*/
EmailKeyValue *ldapsvr_retrieve_item_email(ItemEMail *item) {
EmailKeyValue *newItem;
cm_return_val_if_fail(item != NULL, NULL);
newItem = emailkeyvalue_create();
newItem->alias = g_strdup(ADDRITEM_NAME(item));
newItem->mail = g_strdup(item->address);
newItem->remarks = g_strdup(item->remarks);
return newItem;
}
/**
* Free address item email object.
* \param item E-Mail item to free.
*/
void addritem_free_item_email( ItemEMail *item ) {
g_return_if_fail( item != NULL );
/* Free internal stuff */
g_free( ADDRITEM_ID(item) );
g_free( ADDRITEM_NAME(item) );
g_free( item->address );
g_free( item->remarks );
ADDRITEM_OBJECT(item)->type = ITEMTYPE_NONE;
ADDRITEM_ID(item) = NULL;
ADDRITEM_NAME(item) = NULL;
ADDRITEM_PARENT(item) = NULL;
ADDRITEM_SUBTYPE(item) = 0;
item->address = NULL;
item->remarks = NULL;
g_free( item );
}
/*
* Insert address into cache.
* Enter: harvester Harvester object.
* entry Header object.
* cache Address cache to load.
* name Name.
* address eMail address.
*/
static void addrharvest_insert_cache(
AddressHarvester *harvester, HeaderEntry *entry,
AddressCache *cache, const gchar *name,
const gchar *address )
{
ItemPerson *person;
ItemFolder *folder;
gchar *folderName;
gboolean newFolder;
gint cnt;
gchar *key, *value;
newFolder = FALSE;
folder = entry->folder;
if( folder == NULL ) {
newFolder = TRUE; /* No folder yet */
}
if( entry->count % harvester->folderSize == 0 ) {
newFolder = TRUE; /* Folder is full */
}
/* Insert address */
key = g_strdup( address );
g_strdown( key );
person = g_hash_table_lookup( harvester->dupTable, key );
if( person ) {
/* Update existing person to use longest name */
value = ADDRITEM_NAME(person);
if( strlen( name ) > strlen( value ) ) {
addritem_person_set_common_name( person, name );
}
g_free( key );
}
else {
/* Folder if required */
if( newFolder ) {
cnt = 1 + ( entry->count / harvester->folderSize );
folderName =g_strdup_printf( "%s (%d)",
entry->header, cnt );
folder = addritem_create_item_folder();
addritem_folder_set_name( folder, folderName );
addritem_folder_set_remarks( folder, "" );
addrcache_id_folder( cache, folder );
addrcache_add_folder( cache, folder );
entry->folder = folder;
g_free( folderName );
}
/* Insert entry */
person = addrcache_add_contact(
cache, folder, name, address, "" );
g_hash_table_insert( harvester->dupTable, key, person );
entry->count++;
}
addritem_parse_first_last( person );
}
/**
* Free address group object.
* \param group Group to free.
*/
void addritem_free_item_group( ItemGroup *group ) {
g_return_if_fail( group != NULL );
/* Free internal stuff */
g_free( ADDRITEM_ID(group) );
g_free( ADDRITEM_NAME(group) );
g_free( group->remarks );
mgu_clear_list( group->listEMail );
g_list_free( group->listEMail );
ADDRITEM_TYPE(group) = ITEMTYPE_NONE;
ADDRITEM_ID(group) = NULL;
ADDRITEM_NAME(group) = NULL;
ADDRITEM_PARENT(group) = NULL;
ADDRITEM_SUBTYPE(group) = 0;
group->remarks = NULL;
group->listEMail = NULL;
g_free( group );
}
static void addressbook_foldersel_load_folder( GtkCMCTreeNode *parentNode, ItemFolder *parentFolder,
FolderInfo *fiParent, FolderPathMatch *match )
{
GtkCMCTree *tree = GTK_CMCTREE( addressbook_foldersel_dlg.tree_folder );
GList *list;
ItemFolder *folder;
gchar *fName;
gchar **name;
GtkCMCTreeNode *node;
FolderInfo *fi;
FolderPathMatch *nextmatch = NULL;
list = parentFolder->listFolder;
while ( list ) {
folder = list->data;
fName = g_strdup( ADDRITEM_NAME(folder) );
name = &fName;
node = gtk_cmctree_insert_node( tree, parentNode, NULL, name, FOLDER_SPACING,
folderXpm, folderXpm,
FALSE, TRUE );
/* match folder name, match pointer will be set to NULL if next recursive call
doesn't need to match subfolder name */
if ( match != NULL &&
match->matched == FALSE ) {
if ( strcmp(match->folder_path[match->index], folder->obj.uid) == 0 ) {
/* folder name matches, prepare next subfolder match */
debug_print("matched folder name '%s'\n", fName);
match->index++;
if ( match->folder_path[match->index] == NULL ) {
/* we've matched all elements */
match->matched = TRUE;
match->node = node;
debug_print("book/folder path matched!\n");
} else {
/* keep on matching */
nextmatch = match;
}
}
}
g_free( fName );
fi = addressbook_foldersel_create_folderinfo( fiParent->book, folder );
gtk_cmctree_node_set_row_data_full( tree, node, fi,
( GDestroyNotify ) addressbook_foldersel_free_folderinfo );
addressbook_foldersel_load_folder( node, folder, fi, nextmatch );
list = g_list_next( list );
}
}
/**
* Create new email address item.
* \return Initialized email item.
*/
ItemEMail *addritem_create_item_email( void ) {
ItemEMail *item;
item = g_new0( ItemEMail, 1 );
ADDRITEM_TYPE(item) = ITEMTYPE_EMAIL;
ADDRITEM_ID(item) = NULL;
ADDRITEM_NAME(item) = NULL;
ADDRITEM_PARENT(item) = NULL;
ADDRITEM_SUBTYPE(item) = 0;
item->address = NULL;
item->remarks = NULL;
return item;
}
/**
* Create new address book group object.
* \return Initialized group object.
*/
ItemGroup *addritem_create_item_group( void ) {
ItemGroup *group;
group = g_new0( ItemGroup, 1 );
ADDRITEM_TYPE(group) = ITEMTYPE_GROUP;
ADDRITEM_ID(group) = NULL;
ADDRITEM_NAME(group) = NULL;
ADDRITEM_PARENT(group) = NULL;
ADDRITEM_SUBTYPE(group) = 0;
group->remarks = NULL;
group->listEMail = NULL;
return group;
}
/**
* Parse first and last names for person from common name.
* \param person Person to process.
*/
void addritem_parse_first_last( ItemPerson *person ) {
gchar *name;
gchar *fName, *lName;
gchar *p;
gint len, i;
g_return_if_fail( person != NULL );
name = ADDRITEM_NAME(person);
if( name == NULL ) return;
fName = NULL;
lName = NULL;
p = strchr( name, ',' );
if( p ) {
len = ( size_t ) ( p - name );
lName = g_strndup( name, len );
fName = g_strdup( p + 1 );
}
else {
/* Other way around */
i = strlen( name );
while( i >= 0 ) {
if( name[i] == ' ' ) {
fName = g_strndup( name, i );
lName = g_strdup( &name[i] );
break;
}
i--;
}
if( fName == NULL ) {
fName = g_strdup( name );
}
}
if( person->firstName ) {
g_free( person->firstName );
}
person->firstName = fName;
if( person->firstName )
g_strstrip( person->firstName );
if( person->lastName ) {
g_free( person->lastName );
}
person->lastName = lName;
if( person->lastName )
g_strstrip( person->lastName );
}
/*
* Format a list of E-Mail addresses.
* Enter: ctl Export control data.
* stream Output stream.
* listEMail List of addresses.
* sortFlag Set to TRUE if address list should be sorted.
*/
static void exporthtml_fmt_email(
ExportHtmlCtl *ctl, FILE *stream, const GList *listEMail,
gboolean sortFlag )
{
const GList *node;
GList *list;
gchar *name;
if( listEMail == NULL ) {
fprintf( stream, SC_HTML_SPACE );
return;
}
list = NULL;
if( sortFlag ) {
node = list = exporthtml_sort_email( listEMail );
}
else {
node = listEMail;
}
while( node ) {
ItemEMail *email = ( ItemEMail * ) node->data;
node = g_list_next( node );
name = ADDRITEM_NAME( email );
if( name ) {
fprintf( stream, "%s ", name );
}
if( ctl->linkEMail ) {
fprintf( stream, "<a href=\"mailto:%s\">",
email->address );
}
fprintf( stream, "<span class=\"tab-email\">" );
fprintf( stream, "%s", email->address );
fprintf( stream, "</span>" );
if( ctl->linkEMail ) {
fprintf( stream, "</a>" );
}
if( email->remarks ) {
if( strlen( email->remarks ) ) {
fprintf( stream, " (%s)", email->remarks );
}
}
fprintf( stream, "<br>\n" );
}
g_list_free( list );
}
/**
* Create new address book person.
* \return Initialized person object.
*/
ItemPerson *addritem_create_item_person( void ) {
ItemPerson *person;
person = g_new0( ItemPerson, 1 );
ADDRITEM_TYPE(person) = ITEMTYPE_PERSON;
ADDRITEM_ID(person) = NULL;
ADDRITEM_NAME(person) = NULL;
ADDRITEM_PARENT(person) = NULL;
ADDRITEM_SUBTYPE(person) = 0;
person->firstName = NULL;
person->lastName = NULL;
person->nickName = NULL;
person->listEMail = NULL;
person->listAttrib = NULL;
person->externalID = NULL;
person->isOpened = FALSE;
return person;
}
/**
* Retrieve person object for update.
* \param person ItemPerson to update.
* \param array GHashTable with user input.
* \return false if update is not needed, or true if update is needed.
*/
gboolean ldapsvr_retrieve_item_person(ItemPerson *person, GHashTable *array) {
GList *node, *attr;
cm_return_val_if_fail(person != NULL, FALSE);
switch (person->status) {
case NONE:
return FALSE;
case ADD_ENTRY:
g_hash_table_insert(array, "status", "new");
break;
case UPDATE_ENTRY:
g_hash_table_insert(array, "status", "update");
break;
case DELETE_ENTRY:
g_hash_table_insert(array, "status", "delete");
break;
default:
g_critical(_("ldapsvr_retrieve_item_person->Unknown status: %d"), person->status);
}
g_hash_table_insert(array, "uid", ADDRITEM_ID(person));
g_hash_table_insert(array, "cn", ADDRITEM_NAME(person));
g_hash_table_insert(array, "givenName", person->firstName);
g_hash_table_insert(array, "sn", person->lastName);
g_hash_table_insert(array, "nickName", person->nickName);
g_hash_table_insert(array, "dn", person->externalID);
g_hash_table_insert(array, "person", person);
node = person->listEMail;
attr = NULL;
while (node) {
EmailKeyValue *newEmail = ldapsvr_retrieve_item_email(node->data);
if (newEmail)
attr = g_list_append(attr, newEmail);
node = g_list_next(node);
}
g_hash_table_insert(array, "mail", attr);
node = person->listAttrib;
attr = NULL;
while (node) {
AttrKeyValue *newAttr = ldapsvr_retrieve_attribute(node->data);
if (newAttr)
attr = g_list_append(attr, newAttr);
node = g_list_next(node);
}
g_hash_table_insert(array, "attribute", attr);
return TRUE;
}
/*
* Create new address folder.
*/
ItemFolder *addritem_create_item_folder( void ) {
ItemFolder *folder;
folder = g_new0( ItemFolder, 1 );
ADDRITEM_TYPE(folder) = ITEMTYPE_FOLDER;
ADDRITEM_ID(folder) = NULL;
ADDRITEM_NAME(folder) = NULL;
ADDRITEM_PARENT(folder) = NULL;
ADDRITEM_SUBTYPE(folder) = 0;
folder->remarks = NULL;
folder->isRoot = FALSE;
folder->listItems = NULL;
folder->listFolder = NULL;
folder->listPerson = NULL;
folder->listGroup = NULL;
folder->userData = NULL;
return folder;
}
/*
* Insert person and address into address cache.
* Enter: muttFile MUTT control data.
* cache Address cache.
* address E-Mail address.
* name Name.
* Return: E-Mail object, either inserted or found in hash table.
*/
static ItemEMail *mutt_insert_table(
MuttFile *muttFile, AddressCache *cache, gchar *address,
gchar *name )
{
ItemPerson *person;
ItemEMail *email;
gchar *key;
/* Test whether address already in hash table */
key = g_strdup( address );
g_strdown( key );
email = g_hash_table_lookup( muttFile->uniqTable, key );
if( email == NULL ) {
/* No - create person */
person = addritem_create_item_person();
addritem_person_set_common_name( person, name );
addrcache_id_person( cache, person );
addrcache_add_person( cache, person );
/* Add email for person */
email = addritem_create_item_email();
addritem_email_set_address( email, address );
addrcache_id_email( cache, email );
addrcache_person_add_email( cache, person, email );
/* Insert entry */
g_hash_table_insert( muttFile->uniqTable, key, email );
}
else {
/* Yes - update person with longest name */
person = ( ItemPerson * ) ADDRITEM_PARENT(email);
if( strlen( name ) > strlen( ADDRITEM_NAME(person) ) ) {
addritem_person_set_common_name( person, name );
}
/* Free up */
g_free( key );
}
return email;
}
/**
* Test whether person's data is empty.
* \param person Person to test.
* \return <i>TRUE</i> if empty.
*/
gboolean addritem_person_empty( ItemPerson *person ) {
gchar *t;
if( person == NULL ) return FALSE;
t = ADDRITEM_NAME(person);
if( t != NULL && strlen( t ) > 0 ) return FALSE;
t = person->firstName;
if( t != NULL && strlen( t ) > 0 ) return FALSE;
t = person->lastName;
if( t != NULL && strlen( t ) > 0 ) return FALSE;
t = person->nickName;
if( t != NULL && strlen( t ) > 0 ) return FALSE;
if( person->listEMail != NULL ) return FALSE;
if( person->listAttrib != NULL ) return FALSE;
return TRUE;
}
/**
* Print person item for debug.
* \param person Person to print.
* \param stream Output stream.
*/
void addritem_print_item_person( ItemPerson *person, FILE *stream ) {
GList *node;
cm_return_if_fail( person != NULL );
fprintf( stream, "Person:\n" );
fprintf( stream, "\tt/uid: %d : '%s'\n", ADDRITEM_TYPE(person), ADDRITEM_ID(person) );
fprintf( stream, "\tsubty: %d\n", ADDRITEM_SUBTYPE(person) );
fprintf( stream, "\tcommn: '%s'\n", ADDRITEM_NAME(person) );
fprintf( stream, "\tphoto: '%s'\n", person->picture );
fprintf( stream, "\tfirst: '%s'\n", person->firstName );
fprintf( stream, "\tlast : '%s'\n", person->lastName );
fprintf( stream, "\tnick : '%s'\n", person->nickName );
fprintf( stream, "\textID: '%s'\n", person->externalID );
fprintf( stream, "\teMail:\n" );
fprintf( stream, "\t---\n" );
node = person->listEMail;
while( node ) {
addritem_print_item_email( node->data, stream );
node = g_list_next( node );
}
fprintf( stream, "\tuAttr:\n" );
fprintf( stream, "\t---\n" );
node = person->listAttrib;
while( node ) {
addritem_print_attribute( node->data, stream );
node = g_list_next( node );
}
gchar *current_status;
switch (person->status) {
case NONE: current_status = g_strdup("Unchanged"); break;
case ADD_ENTRY: current_status = g_strdup("New"); break;
case UPDATE_ENTRY: current_status = g_strdup("Updated"); break;
case DELETE_ENTRY: current_status = g_strdup("Deleted"); break;
default: current_status = g_strdup("Unknown");
}
fprintf( stream, "\t\tStatus: %s\n", current_status );
if ( current_status )
g_free(current_status);
fprintf( stream, "\t===\n" );
}
