fix coding style
authorPaul Mangan <paul@claws-mail.org>
Sat, 21 Dec 2002 10:57:35 +0000 (10:57 +0000)
committerPaul Mangan <paul@claws-mail.org>
Sat, 21 Dec 2002 10:57:35 +0000 (10:57 +0000)
src/addrbook.c

index 138b9b6..c721955 100644 (file)
@@ -1,6 +1,6 @@
 /*
  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
- * Copyright (C) 2001 Match Grun
+ * Copyright (C) 2001-2002 Match Grun and the Sylpheed-Claws team
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,9 +17,7 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 
-/*
- * General functions for accessing address book files.
- */
+/* General functions for accessing address book files */
 
 #include <glib.h>
 #include <stdio.h>
 #define FILE_NUMDIGITS            6
 
 #define ID_TIME_OFFSET            998000000
-/*
-* Create new address book.
-*/
-AddressBookFile *addrbook_create_book() {
+
+/* Create new address book */
+AddressBookFile *addrbook_create_book()
+{
        AddressBookFile *book;
 
-       book = g_new0( AddressBookFile, 1 );
+       book = g_new0(AddressBookFile, 1);
        book->type = ADBOOKTYPE_BOOK;
        book->addressCache = addrcache_create();
        book->retVal = MGU_SUCCESS;
@@ -66,86 +64,114 @@ AddressBookFile *addrbook_create_book() {
        return book;
 }
 
-/*
-* Specify name to be used.
-*/
-void addrbook_set_name( AddressBookFile *book, const gchar *value ) {
-       g_return_if_fail( book != NULL );
-       addrcache_set_name( book->addressCache, value );
+/* Specify name to be used */
+void addrbook_set_name(AddressBookFile *book, const gchar *value)
+{
+       g_return_if_fail(book != NULL);
+       addrcache_set_name(book->addressCache, value);
 }
-gchar *addrbook_get_name( AddressBookFile *book ) {
-       g_return_val_if_fail( book != NULL, NULL );
-       return addrcache_get_name( book->addressCache );
+
+gchar *addrbook_get_name(AddressBookFile *book)
+{
+       g_return_val_if_fail(book != NULL, NULL);
+       return addrcache_get_name(book->addressCache);
 }
-void addrbook_set_path( AddressBookFile *book, const gchar *value ) {
-       g_return_if_fail( book != NULL );
-       book->path = mgu_replace_string( book->path, value );
-       addrcache_set_dirty( book->addressCache, TRUE );
+
+void addrbook_set_path(AddressBookFile *book, const gchar *value)
+{
+       g_return_if_fail(book != NULL);
+       book->path = mgu_replace_string(book->path, value);
+       addrcache_set_dirty(book->addressCache, TRUE);
 }
-void addrbook_set_file( AddressBookFile *book, const gchar *value ) {
-       g_return_if_fail( book != NULL );
-       book->fileName = mgu_replace_string( book->fileName, value );
-       addrcache_set_dirty( book->addressCache, TRUE );
+
+void addrbook_set_file(AddressBookFile *book, const gchar *value)
+{
+       g_return_if_fail(book != NULL);
+       book->fileName = mgu_replace_string(book->fileName, value);
+       addrcache_set_dirty(book->addressCache, TRUE);
 }
-gboolean addrbook_get_modified( AddressBookFile *book ) {
-       g_return_val_if_fail( book != NULL, FALSE );
+
+gboolean addrbook_get_modified(AddressBookFile *book)
+{
+       g_return_val_if_fail(book != NULL, FALSE);
        return book->addressCache->modified;
 }
-void addrbook_set_modified( AddressBookFile *book, const gboolean value ) {
-       g_return_if_fail( book != NULL );
+
+void addrbook_set_modified(AddressBookFile *book, const gboolean value)
+{
+       g_return_if_fail(book != NULL);
        book->addressCache->modified = value;
 }
-gboolean addrbook_get_accessed( AddressBookFile *book ) {
-       g_return_val_if_fail( book != NULL, FALSE );
+
+gboolean addrbook_get_accessed(AddressBookFile *book)
+{
+       g_return_val_if_fail(book != NULL, FALSE);
        return book->addressCache->accessFlag;
 }
-void addrbook_set_accessed( AddressBookFile *book, const gboolean value ) {
-       g_return_if_fail( book != NULL );
+
+void addrbook_set_accessed(AddressBookFile *book, const gboolean value)
+{
+       g_return_if_fail(book != NULL);
        book->addressCache->accessFlag = value;
 }
-gboolean addrbook_get_read_flag( AddressBookFile *book ) {
-       g_return_val_if_fail( book != NULL, FALSE );
+
+gboolean addrbook_get_read_flag(AddressBookFile *book)
+{
+       g_return_val_if_fail(book != NULL, FALSE);
        return book->addressCache->dataRead;
 }
-void addrbook_set_read_flag( AddressBookFile *book, const gboolean value ) {
-       g_return_if_fail( book != NULL );
+
+void addrbook_set_read_flag(AddressBookFile *book, const gboolean value)
+{
+       g_return_if_fail(book != NULL);
        book->addressCache->dataRead = value;
 }
-gint addrbook_get_status( AddressBookFile *book ) {
-       g_return_val_if_fail( book != NULL, -1 );
+
+gint addrbook_get_status(AddressBookFile *book)
+{
+       g_return_val_if_fail(book != NULL, -1);
        return book->retVal;
 }
-ItemFolder *addrbook_get_root_folder( AddressBookFile *book ) {
-       g_return_val_if_fail( book != NULL, NULL );
-       return addrcache_get_root_folder( book->addressCache );
+
+ItemFolder *addrbook_get_root_folder(AddressBookFile *book)
+{
+       g_return_val_if_fail(book != NULL, NULL);
+       return addrcache_get_root_folder(book->addressCache);
 }
-GList *addrbook_get_list_folder( AddressBookFile *book ) {
-       g_return_val_if_fail( book != NULL, NULL );
-       return addrcache_get_list_folder( book->addressCache );
+
+GList *addrbook_get_list_folder(AddressBookFile *book)
+{
+       g_return_val_if_fail(book != NULL, NULL);
+       return addrcache_get_list_folder(book->addressCache);
 }
-GList *addrbook_get_list_person( AddressBookFile *book ) {
-       g_return_val_if_fail( book != NULL, NULL );
-       return addrcache_get_list_person( book->addressCache );
+
+GList *addrbook_get_list_person(AddressBookFile *book)
+{
+       g_return_val_if_fail(book != NULL, NULL);
+       return addrcache_get_list_person(book->addressCache);
 }
-gboolean addrbook_get_dirty( AddressBookFile *book ) {
-       g_return_val_if_fail( book != NULL, FALSE );
-       return addrcache_get_dirty( book->addressCache );
+
+gboolean addrbook_get_dirty(AddressBookFile *book)
+{
+       g_return_val_if_fail(book != NULL, FALSE);
+       return addrcache_get_dirty(book->addressCache);
 }
-void addrbook_set_dirty( AddressBookFile *book, const gboolean value ) {
-       g_return_if_fail( book != NULL );
-       addrcache_set_dirty( book->addressCache, value );
+
+void addrbook_set_dirty(AddressBookFile *book, const gboolean value)
+{
+       g_return_if_fail(book != NULL);
+       addrcache_set_dirty(book->addressCache, value);
 }
 
-/*
-* Empty address book.
-*/
-void addrbook_empty_book( AddressBookFile *book ) {
-       g_return_if_fail( book != NULL );
+/* Empty address book */
+void addrbook_empty_book(AddressBookFile *book)
+{
+       g_return_if_fail(book != NULL);
 
        /* Free up internal objects */
-       addrcache_clear( book->addressCache );
-       addrcache_set_dirty( book->addressCache, FALSE );
-       g_list_free( book->tempList );
+       addrcache_clear(book->addressCache);
+       addrcache_set_dirty(book->addressCache, FALSE);
+       g_list_free(book->tempList);
 
        /* Reset to initial state */
        book->tempList = NULL;
@@ -156,20 +182,19 @@ void addrbook_empty_book( AddressBookFile *book ) {
        book->retVal = MGU_SUCCESS;
 }
 
-/*
-* Free address book.
-*/
-void addrbook_free_book( AddressBookFile *book ) {
-       g_return_if_fail( book != NULL );
+/* Free address book */
+void addrbook_free_book(AddressBookFile *book)
+{
+       g_return_if_fail(book != NULL);
 
        /* Clear cache */
-       addrcache_clear( book->addressCache );
-       addrcache_free( book->addressCache );
+       addrcache_clear(book->addressCache);
+       addrcache_free(book->addressCache);
 
        /* Free up internal objects */
-       g_free( book->path );
-       g_free( book->fileName );
-       g_list_free( book->tempList );
+       g_free(book->path);
+       g_free(book->fileName);
+       g_list_free(book->tempList);
 
        book->path = NULL;
        book->fileName = NULL;
@@ -181,86 +206,82 @@ void addrbook_free_book( AddressBookFile *book ) {
        book->addressCache = NULL;
        book->retVal = MGU_SUCCESS;
 
-       g_free( book );
+       g_free(book);
 }
 
-/*
-* Print list of items.
-*/
-void addrbook_print_item_list( GList *list, FILE *stream ) {
+/* Print list of items */
+void addrbook_print_item_list(GList *list, FILE *stream)
+{
        GList *node = list;
 
-       while( node ) {
+       while(node) {
                AddrItemObject *obj = node->data;
-               if( ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON ) {
-                       addritem_print_item_person( ( ItemPerson * ) obj, stream );
-               }
-               else if( ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP ) {
-                       addritem_print_item_group( ( ItemGroup * ) obj, stream );
-               }
-               else if( ADDRITEM_TYPE(obj) == ITEMTYPE_FOLDER ) {
-                       addritem_print_item_folder( ( ItemFolder * ) obj, stream );
-               }
-               node = g_list_next( node );
+               if (ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON) 
+                       addritem_print_item_person((ItemPerson *) obj, stream); 
+               else if (ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP)
+                       addritem_print_item_group((ItemGroup *) obj, stream); 
+               else if (ADDRITEM_TYPE(obj) == ITEMTYPE_FOLDER) 
+                       addritem_print_item_folder((ItemFolder *) obj, stream);
+               node = g_list_next(node);
        }
-       fprintf( stream, "\t---\n" );
+       fprintf(stream, "\t---\n");
 }
 
-/*
-* Print address book.
-*/
-void addrbook_print_book( AddressBookFile *book, FILE *stream ) {
-       g_return_if_fail( book != NULL );
+/* Print address book */
+void addrbook_print_book(AddressBookFile *book, FILE *stream)
+{
+       g_return_if_fail(book != NULL);
 
-       fprintf( stream, "AddressBook:\n" );
-       fprintf( stream, "\tpath  : '%s'\n", book->path );
-       fprintf( stream, "\tfile  : '%s'\n", book->fileName );
-       fprintf( stream, "\tstatus: %d : '%s'\n", book->retVal, mgu_error2string( book->retVal ) );
-       addrcache_print( book->addressCache, stream );
+       fprintf(stream, "AddressBook:\n");
+       fprintf(stream, "\tpath : '%s'\n", book->path);
+       fprintf(stream, "\tfile : '%s'\n", book->fileName);
+       fprintf(stream, "\tstatus : %d : '%s'\n", book->retVal,
+               mgu_error2string(book->retVal));
+       addrcache_print(book->addressCache, stream);
 }
 
-/*
-* Dump entire address book traversing folders.
-*/
-void addrbook_dump_book( AddressBookFile *book, FILE *stream ) {
+/* Dump entire address book traversing folders */
+void addrbook_dump_book(AddressBookFile *book, FILE *stream)
+{
        ItemFolder *folder;
 
-       g_return_if_fail( book != NULL );
+       g_return_if_fail(book != NULL);
 
-       addrbook_print_book( book, stream );
+       addrbook_print_book(book, stream);
        folder = book->addressCache->rootFolder;
-       addritem_print_item_folder( folder, stream );
+       addritem_print_item_folder(folder, stream);
 }
 
-/*
-* Remove group from address book.
-* param: group Group to remove.
-* return: Group, or NULL if not found. Note that object should still be freed.
-*/
-ItemGroup *addrbook_remove_group( AddressBookFile *book, ItemGroup *group ) {
-       g_return_val_if_fail( book != NULL, NULL );
-       return addrcache_remove_group( book->addressCache, group );
+/* Remove group from address book.
+   param: group        Group to remove.
+   return: Group, or NULL if not found. 
+   Note that object should still be freed */
+ItemGroup *addrbook_remove_group(AddressBookFile *book, ItemGroup *group)
+{
+       g_return_val_if_fail(book != NULL, NULL);
+       return addrcache_remove_group(book->addressCache, group);
 }
 
-/*
-* Remove specified person from address book.
-* param: person        Person to remove.
-* return: Person, or NULL if not found. Note that object should still be freed.
-*/
-ItemPerson *addrbook_remove_person( AddressBookFile *book, ItemPerson *person ) {
-       g_return_val_if_fail( book != NULL, NULL );
-       return addrcache_remove_person( book->addressCache, person );
+/* Remove specified person from address book.
+   param: person       Person to remove.
+  return: Person, or NULL if not found. 
+  Note that object should still be freed */
+ItemPerson *addrbook_remove_person(AddressBookFile *book, ItemPerson *person)
+{
+       g_return_val_if_fail(book != NULL, NULL);
+       return addrcache_remove_person(book->addressCache, person);
 }
 
-/*
-* Remove email address in address book for specified person.
-* param: person        Person.
-*        email EMail to remove.
-* return: EMail object, or NULL if not found. Note that object should still be freed.
-*/
-ItemEMail *addrbook_person_remove_email( AddressBookFile *book, ItemPerson *person, ItemEMail *email ) {
-       g_return_val_if_fail( book != NULL, NULL );
-       return addrcache_person_remove_email( book->addressCache, person, email );
+/* Remove email address in address book for specified person.
+   param: person       Person.
+          email                EMail to remove.
+  return: EMail object, or NULL if not found. 
+  Note that object should still be freed */
+ItemEMail *addrbook_person_remove_email(AddressBookFile *book,
+                                       ItemPerson *person, ItemEMail *email)
+{
+       g_return_val_if_fail(book != NULL, NULL);
+       return addrcache_person_remove_email(book->addressCache, person, email);
 }
 
 /* **********************************************************************
@@ -328,785 +349,772 @@ ItemEMail *addrbook_person_remove_email( AddressBookFile *book, ItemPerson *pers
 #define AB_ATTAG_VAL_GROUP       "group"
 #define AB_ATTAG_VAL_FOLDER      "folder"
 
-/*
-* Parse address item for person.
-*/
-static void addrbook_parse_address( AddressBookFile *book, XMLFile *file, ItemPerson *person ) {
+/* Parse address item for person */
+static void addrbook_parse_address(AddressBookFile *book, XMLFile *file, 
+                                  ItemPerson *person)
+{
        GList *attr;
        gchar *name, *value;
        ItemEMail *email = NULL;
 
        attr = xml_get_current_tag_attr(file);
-       while( attr ) {
+       while (attr) {
                name = ((XMLAttr *)attr->data)->name;
                value = ((XMLAttr *)attr->data)->value;
-               if( ! email ) email = addritem_create_item_email();
-               if( strcmp( name, AB_ATTAG_UID ) == 0 ) {
-                       ADDRITEM_ID(email) = g_strdup( value );
-               }
-               else if( strcmp( name, AB_ATTAG_ALIAS ) == 0 ) {
-                       ADDRITEM_NAME(email) = g_strdup( value );
-               }
-               else if( strcmp( name, AB_ATTAG_EMAIL ) == 0 ) {
-                       email->address = g_strdup( value );
-               }
-               else if( strcmp( name, AB_ATTAG_REMARKS ) == 0 ) {
-                       email->remarks = g_strdup( value );
-               }
-               attr = g_list_next( attr );
-       }
-       if( email ) {
-               if( person ) {
-                       addrcache_person_add_email( book->addressCache, person, email );
+               if (!email)
+                       email = addritem_create_item_email();
+               if (strcmp(name, AB_ATTAG_UID) == 0)
+                       ADDRITEM_ID(email) = g_strdup(value);
+               else if (strcmp(name, AB_ATTAG_ALIAS) == 0)
+                       ADDRITEM_NAME(email) = g_strdup(value);
+               else if (strcmp(name, AB_ATTAG_EMAIL) == 0)
+                       email->address = g_strdup(value);
+               else if (strcmp(name, AB_ATTAG_REMARKS) == 0)
+                       email->remarks = g_strdup(value);
+               attr = g_list_next(attr);
+       }
+       if (email) {
+               if (person) {
+                       addrcache_person_add_email(book->addressCache, person,
+                                                  email);
                }
                else {
-                       addritem_free_item_email( email );
+                       addritem_free_item_email(email);
                        email = NULL;
                }
        }
 }
 
-/*
-* Parse email address list.
-*/
-static void addrbook_parse_addr_list( AddressBookFile *book, XMLFile *file, ItemPerson *person ){
+/* Parse email address list */
+static void addrbook_parse_addr_list(AddressBookFile *book, XMLFile *file, 
+                                    ItemPerson *person)
+{
        GList *attr;
        guint prev_level;
 
        for (;;) {
                prev_level = file->level;
-               if( xml_parse_next_tag( file ) ) {
-                       longjmp( book->jumper, 1 );
+               if (xml_parse_next_tag(file)) {
+                       longjmp(book->jumper, 1);
                }
                if (file->level < prev_level) return;
-               if( xml_compare_tag( file, AB_ELTAG_ADDRESS ) ) {
+               if (xml_compare_tag(file, AB_ELTAG_ADDRESS)) {
                        attr = xml_get_current_tag_attr(file);
-                       addrbook_parse_address( book, file, person );
-                       addrbook_parse_addr_list( book, file, person );
+                       addrbook_parse_address(book, file, person);
+                       addrbook_parse_addr_list(book, file, person);
                }
        }
 }
 
-/*
-* Parse attibute for person.
-*/
-static void addrbook_parse_attribute( XMLFile *file, ItemPerson *person ) {
+/* Parse attibute for person */
+static void addrbook_parse_attribute(XMLFile *file, ItemPerson *person)
+{
        GList *attr;
        gchar *name, *value;
        gchar *element;
        UserAttribute *uAttr = NULL;
 
        attr = xml_get_current_tag_attr(file);
-       while( attr ) {
+       while (attr) {
                name = ((XMLAttr *)attr->data)->name;
                value = ((XMLAttr *)attr->data)->value;
-               if( ! uAttr ) uAttr = addritem_create_attribute();
-               if( strcmp( name, AB_ATTAG_UID ) == 0 ) {
-                       addritem_attrib_set_id( uAttr, value );
-               }
-               else if( strcmp( name, AB_ATTAG_NAME ) == 0 ) {
-                       addritem_attrib_set_name( uAttr, value );
-               }
-               attr = g_list_next( attr );
+               if (!uAttr) uAttr = addritem_create_attribute();
+               if (strcmp(name, AB_ATTAG_UID) == 0)
+                       addritem_attrib_set_id(uAttr, value);
+               else if (strcmp(name, AB_ATTAG_NAME) == 0) 
+                       addritem_attrib_set_name(uAttr, value);
+               attr = g_list_next(attr);
        }
 
-       element = xml_get_element( file );
-       addritem_attrib_set_value( uAttr, element );
+       element = xml_get_element(file);
+       addritem_attrib_set_value(uAttr, element);
 
-       if( uAttr ) {
-               if( person ) {
-                       addritem_person_add_attribute( person, uAttr );
+       if (uAttr) {
+               if (person) {
+                       addritem_person_add_attribute(person, uAttr);
                }
                else {
-                       addritem_free_attribute( uAttr );
+                       addritem_free_attribute(uAttr);
                        uAttr = NULL;
                }
        }
 }
 
-/*
-* Parse attribute list.
-*/
-static void addrbook_parse_attr_list( AddressBookFile *book, XMLFile *file, ItemPerson *person ){
+/* Parse attribute list */
+static void addrbook_parse_attr_list(AddressBookFile *book, XMLFile *file, 
+                                    ItemPerson *person)
+{
        GList *attr;
        guint prev_level;
 
        for (;;) {
                prev_level = file->level;
-               if( xml_parse_next_tag( file ) ) {
+               if (xml_parse_next_tag(file)) {
                        longjmp( book->jumper, 1 );
                }
                if (file->level < prev_level) return;
-               if( xml_compare_tag( file, AB_ELTAG_ATTRIBUTE ) ) {
+               if (xml_compare_tag(file, AB_ELTAG_ATTRIBUTE)) {
                        attr = xml_get_current_tag_attr(file);
-                       addrbook_parse_attribute( file, person );
-                       addrbook_parse_attr_list( book, file, person );
+                       addrbook_parse_attribute(file, person);
+                       addrbook_parse_attr_list(book, file, person);
                }
        }
 }
 
-/*
-* Parse person.
-*/
-static void addrbook_parse_person( AddressBookFile *book, XMLFile *file ) {
+/* Parse person */
+static void addrbook_parse_person(AddressBookFile *book, XMLFile *file)
+{
        GList *attr;
        gchar *name, *value;
        ItemPerson *person = NULL;
 
        attr = xml_get_current_tag_attr(file);
-       while( attr ) {
+       while (attr) {
                name = ((XMLAttr *)attr->data)->name;
                value = ((XMLAttr *)attr->data)->value;
-               if( ! person ) person = addritem_create_item_person();
-               if( strcmp( name, AB_ATTAG_UID ) == 0 ) {
-                       ADDRITEM_ID(person) = g_strdup( value );
-               }
-               else if( strcmp( name, AB_ATTAG_FIRST_NAME ) == 0 ) {
-                       person->firstName = g_strdup( value );
-               }
-               else if( strcmp( name, AB_ATTAG_LAST_NAME ) == 0 ) {
-                       person->lastName = g_strdup( value );
-               }
-               else if( strcmp( name, AB_ATTAG_NICK_NAME ) == 0 ) {
-                       person->nickName = g_strdup( value );
-               }
-               else if( strcmp( name, AB_ATTAG_COMMON_NAME ) == 0 ) {
-                       ADDRITEM_NAME(person) = g_strdup( value );
-               }
-               attr = g_list_next( attr );
+               if (!person) 
+                       person = addritem_create_item_person();
+               if (strcmp(name, AB_ATTAG_UID) == 0)
+                       ADDRITEM_ID(person) = g_strdup(value);
+               else if (strcmp(name, AB_ATTAG_FIRST_NAME) == 0)
+                       person->firstName = g_strdup(value);
+               else if (strcmp(name, AB_ATTAG_LAST_NAME) == 0)
+                       person->lastName = g_strdup(value);
+               else if (strcmp(name, AB_ATTAG_NICK_NAME) == 0)
+                       person->nickName = g_strdup(value);
+               else if (strcmp(name, AB_ATTAG_COMMON_NAME) == 0)
+                       ADDRITEM_NAME(person) = g_strdup(value);
+               attr = g_list_next(attr);
        }
-       if( xml_parse_next_tag( file ) ) {      /* Consume closing tag */
-               longjmp( book->jumper, 1 );
+       if (xml_parse_next_tag(file)) { /* Consume closing tag */
+               longjmp(book->jumper, 1);
        }
-       if( xml_compare_tag( file, AB_ELTAG_ADDRESS_LIST ) ) {
-               addrbook_parse_addr_list( book, file, person );
-               if( person ) {
-                       addrcache_hash_add_person( book->addressCache, person );
+       if (xml_compare_tag(file, AB_ELTAG_ADDRESS_LIST)) {
+               addrbook_parse_addr_list(book, file, person);
+               if (person) {
+                       addrcache_hash_add_person(book->addressCache, person);
                }
        }
-       if( xml_parse_next_tag( file ) ) {      /* Consume closing tag */
-               longjmp( book->jumper, 1 );
+       if (xml_parse_next_tag(file)) { /* Consume closing tag */
+               longjmp(book->jumper, 1);
        }
-       if( xml_compare_tag( file, AB_ELTAG_ATTRIBUTE_LIST ) ) {
-               addrbook_parse_attr_list( book, file, person );
+       if (xml_compare_tag(file, AB_ELTAG_ATTRIBUTE_LIST)) {
+               addrbook_parse_attr_list(book, file, person);
        }
 }
 
-/*
-* Parse group member.
-*/
-static void addrbook_parse_member( AddressBookFile *book, XMLFile *file, ItemGroup *group ) {
+/* Parse group member */
+static void addrbook_parse_member(AddressBookFile *book, XMLFile *file, 
+                                 ItemGroup *group)
+{
        GList *attr;
        gchar *name, *value;
        gchar *pid = NULL, *eid = NULL;
        ItemEMail *email = NULL;
 
        attr = xml_get_current_tag_attr(file);
-       while( attr ) {
+       while (attr) {
                name = ((XMLAttr *)attr->data)->name;
                value = ((XMLAttr *)attr->data)->value;
-               if( strcmp( name, AB_ATTAG_PID ) == 0 ) {
-                       pid = g_strdup( value );
-               }
-               else if( strcmp( name, AB_ATTAG_EID ) == 0 ) {
-                       eid = g_strdup( value );
-               }
-               attr = g_list_next( attr );
+               if (strcmp(name, AB_ATTAG_PID) == 0)
+                       pid = g_strdup(value);
+               else if (strcmp(name, AB_ATTAG_EID) == 0)
+                       eid = g_strdup(value);
+               attr = g_list_next(attr);
        }
        /* email = addrcache_get_email( book->addressCache, pid, eid ); */
-       email = addrcache_get_email( book->addressCache, eid );
-       if( email ) {
-               if( group ) {
-                       addrcache_group_add_email( book->addressCache, group, email );
+       email = addrcache_get_email(book->addressCache, eid);
+       if (email) {
+               if (group) {
+                       addrcache_group_add_email(book->addressCache, group, 
+                                                 email);
                }
                else {
-                       addritem_free_item_email( email );
+                       addritem_free_item_email(email);
                        email = NULL;
                }
        }
 }
 
-/*
-* Parse group member list.
-*/
-static void addrbook_parse_member_list( AddressBookFile *book, XMLFile *file, ItemGroup *group ){
+/* Parse group member list */
+static void addrbook_parse_member_list(AddressBookFile *book, XMLFile *file, 
+                                      ItemGroup *group)
+{
        GList *attr;
        guint prev_level;
 
        for (;;) {
                prev_level = file->level;
-               if( xml_parse_next_tag( file ) ) {
-                       longjmp( book->jumper, 1 );
+               if (xml_parse_next_tag(file)) {
+                       longjmp(book->jumper, 1);
                }
-               if (file->level < prev_level) return;
-               if( xml_compare_tag( file, AB_ELTAG_MEMBER ) ) {
+               if (file->level < prev_level)
+                       return;
+               if (xml_compare_tag(file, AB_ELTAG_MEMBER)) {
                        attr = xml_get_current_tag_attr(file);
-                       addrbook_parse_member( book, file, group );
-                       addrbook_parse_member_list( book, file, group );
+                       addrbook_parse_member(book, file, group);
+                       addrbook_parse_member_list(book, file, group);
                }
                else {
-                       attr = xml_get_current_tag_attr( file );
+                       attr = xml_get_current_tag_attr(file);
                }
        }
 }
 
-/*
-* Parse group.
-*/
-static void addrbook_parse_group( AddressBookFile *book, XMLFile *file ) {
+/* Parse group */
+static void addrbook_parse_group(AddressBookFile *book, XMLFile *file)
+{
        GList *attr;
        gchar *name, *value;
        ItemGroup *group = NULL;
 
        attr = xml_get_current_tag_attr(file);
-       while( attr ) {
+       while (attr) {
                name = ((XMLAttr *)attr->data)->name;
                value = ((XMLAttr *)attr->data)->value;
-               if( ! group ) group = addritem_create_item_group();
-               if( strcmp( name, AB_ATTAG_UID ) == 0 ) {
-                       ADDRITEM_ID(group) = g_strdup( value );
-               }
-               else if( strcmp( name, AB_ATTAG_NAME ) == 0 ) {
-                       ADDRITEM_NAME(group) = g_strdup( value );
-               }
-               else if( strcmp( name, AB_ATTAG_REMARKS ) == 0 ) {
-                       group->remarks = g_strdup( value );
-               }
-               attr = g_list_next( attr );
+               if (!group) 
+                       group = addritem_create_item_group();
+               if (strcmp(name, AB_ATTAG_UID) == 0) 
+                       ADDRITEM_ID(group) = g_strdup(value);
+               else if (strcmp(name, AB_ATTAG_NAME) == 0)
+                       ADDRITEM_NAME(group) = g_strdup(value);
+               else if (strcmp(name, AB_ATTAG_REMARKS) == 0)
+                       group->remarks = g_strdup(value);
+               attr = g_list_next(attr);
        }
-       if( xml_parse_next_tag( file ) ) {      /* Consume closing tag */
-               longjmp( book->jumper, 1 );
+       if (xml_parse_next_tag(file)) { /* Consume closing tag */
+               longjmp(book->jumper, 1);
        }
-       if( xml_compare_tag( file, AB_ELTAG_MEMBER_LIST ) ) {
-               if( group ) {
-                       addrcache_hash_add_group( book->addressCache, group );
+       if (xml_compare_tag(file, AB_ELTAG_MEMBER_LIST)) {
+               if (group) {
+                       addrcache_hash_add_group(book->addressCache, group);
                }
-               addrbook_parse_member_list( book, file, group );
+               addrbook_parse_member_list(book, file, group);
        }
 }
 
-/*
-* Parse folder item.
-*/
-static void addrbook_parse_folder_item( AddressBookFile *book, XMLFile *file, ItemFolder *folder ) {
+/* Parse folder item */
+static void addrbook_parse_folder_item(AddressBookFile *book, XMLFile *file, 
+                                      ItemFolder *folder)
+{
        GList *attr;
        gchar *name, *value;
        gchar *uid = NULL;
 
        attr = xml_get_current_tag_attr(file);
-       while( attr ) {
+       while (attr) {
                name = ((XMLAttr *)attr->data)->name;
                value = ((XMLAttr *)attr->data)->value;
-               if( strcmp( name, AB_ATTAG_UID ) == 0 ) {
-                       uid = g_strdup( value );
+               if (strcmp(name, AB_ATTAG_UID) == 0) {
+                       uid = g_strdup(value);
                }
-               attr = g_list_next( attr );
+               attr = g_list_next(attr);
        }
-       if( folder ) {
-               if( uid ) {
-                       folder->listItems = g_list_append( folder->listItems, uid );
+       if (folder) {
+               if (uid) {
+                       folder->listItems = g_list_append(folder->listItems, uid);
                }
        }
 }
 
-/*
-* Parse folder item list.
-*/
-static void addrbook_parse_folder_list( AddressBookFile *book, XMLFile *file, ItemFolder *folder ){
+/* Parse folder item list */
+static void addrbook_parse_folder_list(AddressBookFile *book, XMLFile *file,
+                                      ItemFolder *folder)
+{
        GList *attr;
        guint prev_level;
 
        for (;;) {
                prev_level = file->level;
-               if( xml_parse_next_tag( file ) ) {
-                       longjmp( book->jumper, 1 );
+               if (xml_parse_next_tag(file)) {
+                       longjmp(book->jumper, 1);
                }
-               if (file->level < prev_level) return;
-               if( xml_compare_tag( file, AB_ELTAG_ITEM ) ) {
+               if (file->level < prev_level)
+                       return;
+               if (xml_compare_tag(file, AB_ELTAG_ITEM)) {
                        attr = xml_get_current_tag_attr(file);
-                       addrbook_parse_folder_item( book, file, folder );
-                       addrbook_parse_folder_list( book, file, folder );
+                       addrbook_parse_folder_item(book, file, folder);
+                       addrbook_parse_folder_list(book, file, folder);
                }
                else {
-                       attr = xml_get_current_tag_attr( file );
+                       attr = xml_get_current_tag_attr(file);
                }
        }
 }
 
-/*
-* Parse folder.
-*/
-static void addrbook_parse_folder( AddressBookFile *book, XMLFile *file ) {
+/* Parse folder */
+static void addrbook_parse_folder(AddressBookFile *book, XMLFile *file) 
+{
        GList *attr;
        gchar *name, *value;
        ItemFolder *folder = NULL;
 
        attr = xml_get_current_tag_attr(file);
-       while( attr ) {
+       while (attr) {
                name = ((XMLAttr *)attr->data)->name;
                value = ((XMLAttr *)attr->data)->value;
-               if( ! folder ) {
+               if (!folder)
                        folder = addritem_create_item_folder();
-               }
-               if( strcmp( name, AB_ATTAG_UID ) == 0 ) {
-                       ADDRITEM_ID(folder) = g_strdup( value );
-               }
-               else if( strcmp( name, AB_ATTAG_NAME ) == 0 ) {
-                       ADDRITEM_NAME(folder) = g_strdup( value );
-               }
-               else if( strcmp( name, AB_ATTAG_REMARKS ) == 0 ) {
-                       folder->remarks = g_strdup( value );
-               }
-               attr = g_list_next( attr );
-       }
-       if( xml_parse_next_tag( file ) ) {      /* Consume closing tag */
-               longjmp( book->jumper, 1 );
-       }
-       if( xml_compare_tag( file, AB_ELTAG_ITEM_LIST ) ) {
-               if( folder ) {
-                       if( addrcache_hash_add_folder( book->addressCache, folder ) ) {
-                               book->tempList = g_list_append( book->tempList, folder );
-                               ADDRITEM_PARENT(folder) = NULL; /* We will resolve folder later */
+               if (strcmp(name, AB_ATTAG_UID) == 0)
+                       ADDRITEM_ID(folder) = g_strdup(value);
+               else if (strcmp(name, AB_ATTAG_NAME) == 0)
+                       ADDRITEM_NAME(folder) = g_strdup(value);
+               else if (strcmp(name, AB_ATTAG_REMARKS) == 0)
+                       folder->remarks = g_strdup(value);
+               attr = g_list_next(attr);
+       }
+       if (xml_parse_next_tag(file)) { /* Consume closing tag */
+               longjmp(book->jumper, 1);
+       }
+       if (xml_compare_tag(file, AB_ELTAG_ITEM_LIST)) {
+               if (folder) {
+                       if (addrcache_hash_add_folder(book->addressCache, 
+                                                     folder)) {
+                               book->tempList = g_list_append(book->tempList, 
+                                                              folder);
+                               /* We will resolve folder later */
+                               ADDRITEM_PARENT(folder) = NULL;
                        }
                }
-               addrbook_parse_folder_list( book, file, folder );
+               addrbook_parse_folder_list(book, file, folder);
        }
 }
 
-/*
-* Parse address book.
-* Return: TRUE if data read successfully, FALSE if error reading data.
-*/
-static gboolean addrbook_read_tree( AddressBookFile *book, XMLFile *file ) {
+/* Parse address book.
+   Return: TRUE if data read successfully, FALSE if error reading data */
+static gboolean addrbook_read_tree(AddressBookFile *book, XMLFile *file)
+{
        gboolean retVal;
        GList *attr;
        gchar *name, *value;
 
        book->retVal = MGU_BAD_FORMAT;
-       if( xml_get_dtd( file ) ) {
+       if (xml_get_dtd(file))
                return FALSE;
-       }
-       if( xml_parse_next_tag( file ) ) {
-               longjmp( book->jumper, 1 );
-       }
-       if( ! xml_compare_tag( file, AB_ELTAG_ADDRESS_BOOK ) ) {
+       if (xml_parse_next_tag(file))
+               longjmp(book->jumper, 1);
+       if (!xml_compare_tag(file, AB_ELTAG_ADDRESS_BOOK))
                return FALSE;
-       }
 
        attr = xml_get_current_tag_attr(file);
-       while( attr ) {
+       while (attr) {
                name = ((XMLAttr *)attr->data)->name;
                value = ((XMLAttr *)attr->data)->value;
-               if( strcmp( name, AB_ATTAG_NAME ) == 0 ) {
+               if (strcmp( name, AB_ATTAG_NAME) == 0)
                        addrbook_set_name( book, value );
-               }
                attr = g_list_next( attr );
        }
 
        retVal = TRUE;
        for (;;) {
-               if (! file->level ) break;
+               if (!file->level)
+                       break;
                /* Get next item tag (person, group or folder) */
-               if( xml_parse_next_tag( file ) ) {
+               if (xml_parse_next_tag(file))
                        longjmp( book->jumper, 1 );
-               }
-               if( xml_compare_tag( file, AB_ELTAG_PERSON ) ) {
-                       addrbook_parse_person( book, file );
-               }
-               else if( xml_compare_tag( file, AB_ELTAG_GROUP ) ) {
-                       addrbook_parse_group( book, file );
-               }
-               else if( xml_compare_tag( file, AB_ELTAG_FOLDER ) ) {
-                       addrbook_parse_folder( book, file );
-               }
+                       
+               if (xml_compare_tag(file, AB_ELTAG_PERSON))
+                       addrbook_parse_person(book, file);
+               else if (xml_compare_tag(file, AB_ELTAG_GROUP))
+                       addrbook_parse_group(book, file);
+               else if (xml_compare_tag(file, AB_ELTAG_FOLDER))
+                       addrbook_parse_folder(book, file);
        }
-       if( retVal ) book->retVal = MGU_SUCCESS;
-       return retVal;
+       if (retVal) book->retVal = MGU_SUCCESS;
+               return retVal;
 }
 
-/*
-* Resolve folder items visitor function.
-*/
-static void addrbook_res_items_vis( gpointer key, gpointer value, gpointer data ) {
+/* Resolve folder items visitor function */
+static void addrbook_res_items_vis(gpointer key, gpointer value, gpointer data)
+{
        AddressBookFile *book = data;
-       AddrItemObject *obj = ( AddrItemObject * ) value;
+       AddrItemObject *obj = (AddrItemObject *) value;
        ItemFolder *rootFolder = book->addressCache->rootFolder;
-       if( obj->parent == NULL ) {
-               if( ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON ) {
-                       rootFolder->listPerson = g_list_append( rootFolder->listPerson, obj );
+       if (obj->parent == NULL) {
+               if (ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON) {
+                       rootFolder->listPerson = g_list_append(rootFolder->listPerson,
+                                                              obj);
                        ADDRITEM_PARENT(obj) = ADDRITEM_OBJECT(rootFolder);
                }
-               else if( ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP ) {
-                       rootFolder->listGroup = g_list_append( rootFolder->listGroup, obj );
+               else if (ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP) {
+                       rootFolder->listGroup = g_list_append(rootFolder->listGroup,
+                                                             obj);
                        ADDRITEM_PARENT(obj) = ADDRITEM_OBJECT(rootFolder);
                }
        }
 }
 
-/*
-* Resolve folder items. Lists of UID's are replaced with pointers to data items.
-*/
-static void addrbook_resolve_folder_items( AddressBookFile *book ) {
+/* Resolve folder items. Lists of UID's are replaced with pointers to 
+   data items */
+static void addrbook_resolve_folder_items(AddressBookFile *book)
+{
        GList *nodeFolder = NULL;
        GList *listRemove = NULL;
        GList *node = NULL;
        ItemFolder *rootFolder = book->addressCache->rootFolder;
        nodeFolder = book->tempList;
-       while( nodeFolder ) {
+       
+       while (nodeFolder) {
                ItemFolder *folder = nodeFolder->data;
                listRemove = NULL;
                node = folder->listItems;
-               while( node ) {
+               while (node) {
                        gchar *uid = node->data;
-                       AddrItemObject *aio = addrcache_get_object( book->addressCache, uid );
-                       if( aio ) {
-                               if( aio->type == ITEMTYPE_FOLDER ) {
-                                       ItemFolder *item = ( ItemFolder * ) aio;
-                                       folder->listFolder = g_list_append( folder->listFolder, item );
+                       AddrItemObject *aio = addrcache_get_object(book->addressCache, 
+                                                                  uid);
+                       if (aio) {
+                               if (aio->type == ITEMTYPE_FOLDER) {
+                                       ItemFolder *item = (ItemFolder *) aio;
+                                       folder->listFolder = g_list_append(folder->listFolder, item);
                                        ADDRITEM_PARENT(item) = ADDRITEM_OBJECT(folder);
-                                       addrcache_hash_add_folder( book->addressCache, folder );
+                                       addrcache_hash_add_folder(book->addressCache, folder);
                                }
-                               else if( aio->type == ITEMTYPE_PERSON ) {
-                                       ItemPerson *item = ( ItemPerson * ) aio;
-                                       folder->listPerson = g_list_append( folder->listPerson, item );
+                               else if (aio->type == ITEMTYPE_PERSON) {
+                                       ItemPerson *item = (ItemPerson *) aio;
+                                       folder->listPerson = g_list_append(folder->listPerson, item);
                                        ADDRITEM_PARENT(item) = ADDRITEM_OBJECT(folder);
                                }
-                               else if( aio->type == ITEMTYPE_GROUP ) {
-                                       ItemGroup *item = ( ItemGroup * ) aio;
-                                       folder->listGroup = g_list_append( folder->listGroup, item );
+                               else if (aio->type == ITEMTYPE_GROUP) {
+                                       ItemGroup *item = (ItemGroup *) aio;
+                                       folder->listGroup = g_list_append(folder->listGroup, item);
                                        ADDRITEM_PARENT(item) = ADDRITEM_OBJECT(folder);
                                }
                                /* Replace data with pointer to item */
-                               g_free( uid );
+                               g_free(uid);
                                node->data = aio;
                        }
-                       else {
-                               /* Not found, append to remove list. */
-                               listRemove = g_list_append( listRemove, uid );
+                       else { /* Not found, append to remove list. */
+                               listRemove = g_list_append(listRemove, uid);
                        }
-                       node = g_list_next( node );
+                       node = g_list_next(node);
                }
-               rootFolder->listFolder = g_list_append( rootFolder->listFolder, folder );
-
+               rootFolder->listFolder = g_list_append(rootFolder->listFolder, 
+                                                      folder);
                /* Process remove list */
                node = listRemove;
-               while( node ) {
+               while (node) {
                        gchar *uid = node->data;
-                       folder->listItems = g_list_remove( folder->listItems, uid );
-                       g_free( uid );
-                       node = g_list_next( node );
+                       folder->listItems = g_list_remove(folder->listItems,
+                                                         uid);
+                       g_free(uid);
+                       node = g_list_next(node);
                }
-               g_list_free( listRemove );
-               nodeFolder = g_list_next( nodeFolder );
+               g_list_free(listRemove);
+               nodeFolder = g_list_next(nodeFolder);
        }
-
        /* Remove folders with parents. */
        listRemove = NULL;
        node = rootFolder->listFolder;
-       while( node ) {
-               ItemFolder *folder = ( ItemFolder * ) node->data;
-               if( ADDRITEM_PARENT(folder) ) {
+       while (node) {
+               ItemFolder *folder = (ItemFolder *) node->data;
+               if (ADDRITEM_PARENT(folder))
                        /* Remove folders with parents */
-                       listRemove = g_list_append( listRemove, folder );
-               }
-               else {
-                       /* Add to root folder */
+                       listRemove = g_list_append(listRemove, folder);
+               else /* Add to root folder */
                        ADDRITEM_PARENT(folder) = ADDRITEM_OBJECT(book->addressCache->rootFolder);
-               }
+
                node = g_list_next( node );
        }
-
        /* Process remove list */
        node = listRemove;
-       while( node ) {
-               rootFolder->listFolder = g_list_remove( rootFolder->listFolder, node->data );
-               node = g_list_next( node );
+       while (node) {
+               rootFolder->listFolder = g_list_remove(rootFolder->listFolder, 
+                                                      node->data);
+               node = g_list_next(node);
        }
-       g_list_free( listRemove );
+       g_list_free(listRemove);
 
        /* Move all unparented persons and groups into root folder */
-       g_hash_table_foreach( book->addressCache->itemHash, addrbook_res_items_vis, book );
+       g_hash_table_foreach(book->addressCache->itemHash, 
+                            addrbook_res_items_vis, book);
 
        /* Free up some more */
        nodeFolder = book->tempList;
-       while( nodeFolder ) {
+       while (nodeFolder) {
                ItemFolder *folder = nodeFolder->data;
-               g_list_free( folder->listItems );
+               g_list_free(folder->listItems);
                folder->listItems = NULL;
-               nodeFolder = g_list_next( nodeFolder );
+               nodeFolder = g_list_next(nodeFolder);
        }
-       g_list_free( book->tempList );
+       g_list_free(book->tempList);
        book->tempList = NULL;
-
 }
 
-/*
-* Read address book file.
-*/
-gint addrbook_read_data( AddressBookFile *book ) {
+/* Read address book file */
+gint addrbook_read_data(AddressBookFile *book)
+{
        XMLFile *file = NULL;
        gchar *fileSpec = NULL;
 
-       g_return_val_if_fail( book != NULL, -1 );
+       g_return_val_if_fail(book != NULL, -1);
 
        /*
        printf( "...addrbook_read_data :%s:\t:%s:\n", book->fileName,
                addrcache_get_name( book->addressCache ) );
        */
 
-       fileSpec = g_strconcat( book->path, G_DIR_SEPARATOR_S, book->fileName, NULL );
+       fileSpec = g_strconcat(book->path, G_DIR_SEPARATOR_S, 
+                              book->fileName, NULL);
        book->retVal = MGU_OPEN_FILE;
-       addrcache_clear( book->addressCache );
+       addrcache_clear(book->addressCache);
        book->addressCache->modified = FALSE;
        book->addressCache->accessFlag = FALSE;
-       file = xml_open_file( fileSpec );
-       g_free( fileSpec );
-       if( file ) {
+       file = xml_open_file(fileSpec);
+       g_free(fileSpec);
+       if (file) {
                book->tempList = NULL;
-
                /* Trap for parsing errors. */
-               if( setjmp( book->jumper ) ) {
-                       xml_close_file( file );
+               if (setjmp( book->jumper)) {
+                       xml_close_file(file);
                        return book->retVal;
                }
-               addrbook_read_tree( book, file );
-               xml_close_file( file );
-
+               addrbook_read_tree(book, file);
+               xml_close_file(file);
                /* Resolve folder items */
-               addrbook_resolve_folder_items( book );
+               addrbook_resolve_folder_items(book);
                book->tempList = NULL;
                book->addressCache->modified = FALSE;
                book->addressCache->dataRead = TRUE;
-               addrcache_set_dirty( book->addressCache, FALSE );
+               addrcache_set_dirty(book->addressCache, FALSE);
        }
        return book->retVal;
 }
 
-static void addrbook_write_elem_s( FILE *fp, gint lvl, gchar *name ) {
+static void addrbook_write_elem_s(FILE *fp, gint lvl, gchar *name)
+{
        gint i;
-       for( i = 0; i < lvl; i++ ) fputs( "  ", fp );
-       fputs( "<", fp );
-       fputs( name, fp );
+       for (i = 0; i < lvl; i++) 
+               fputs("  ", fp);
+       fputs("<", fp);
+       fputs(name, fp);
 }
 
-static void addrbook_write_elem_e( FILE *fp, gint lvl, gchar *name ) {
+static void addrbook_write_elem_e(FILE *fp, gint lvl, gchar *name)
+{
        gint i;
-       for( i = 0; i < lvl; i++ ) fputs( "  ", fp );
-       fputs( "</", fp );
-       fputs( name, fp );
-       fputs( ">\n", fp );
+       for(i = 0; i < lvl; i++)
+               fputs("  ", fp);
+       fputs("</", fp);
+       fputs(name, fp);
+       fputs(">\n", fp);
 }
 
-static void addrbook_write_attr( FILE *fp, gchar *name, gchar *value ) {
-       fputs( " ", fp );
-       fputs( name, fp );
-       fputs( "=\"", fp );
-       xml_file_put_escape_str( fp, value );
-       fputs( "\"", fp );
+static void addrbook_write_attr(FILE *fp, gchar *name, gchar *value)
+{
+       fputs(" ", fp);
+       fputs(name, fp);
+       fputs("=\"", fp);
+       xml_file_put_escape_str(fp, value);
+       fputs("\"", fp);
 }
 
-/*
-* Write file hash table visitor function.
-*/
-static void addrbook_write_item_person_vis( gpointer key, gpointer value, gpointer data ) {
-       AddrItemObject *obj = ( AddrItemObject * ) value;
-       FILE *fp = ( FILE * ) data;
+/* Write file hash table visitor function */
+static void addrbook_write_item_person_vis(gpointer key, gpointer value, 
+                                          gpointer data)
+{
+       AddrItemObject *obj = (AddrItemObject *) value;
+       FILE *fp = (FILE *) data;
        GList *node;
 
-       if( ! obj ) return;
-       if( ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON ) {
-               ItemPerson *person = ( ItemPerson * ) value;
-               if( person ) {
-                       addrbook_write_elem_s( fp, 1, AB_ELTAG_PERSON );
-                       addrbook_write_attr( fp, AB_ATTAG_UID, ADDRITEM_ID(person) );
-                       addrbook_write_attr( fp, AB_ATTAG_FIRST_NAME, person->firstName );
-                       addrbook_write_attr( fp, AB_ATTAG_LAST_NAME, person->lastName );
-                       addrbook_write_attr( fp, AB_ATTAG_NICK_NAME, person->nickName );
-                       addrbook_write_attr( fp, AB_ATTAG_COMMON_NAME, ADDRITEM_NAME(person) );
-                       fputs( " >\n", fp);
+       if (!obj)
+               return;
+       if (ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON) {
+               ItemPerson *person = (ItemPerson *) value;
+               if (person) {
+                       addrbook_write_elem_s(fp, 1, AB_ELTAG_PERSON);
+                       addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(person));
+                       addrbook_write_attr(fp, AB_ATTAG_FIRST_NAME, person->firstName);
+                       addrbook_write_attr(fp, AB_ATTAG_LAST_NAME, person->lastName);
+                       addrbook_write_attr(fp, AB_ATTAG_NICK_NAME, person->nickName);
+                       addrbook_write_attr(fp, AB_ATTAG_COMMON_NAME, ADDRITEM_NAME(person));
+                       fputs(" >\n", fp);
 
                        /* Output email addresses */
-                       addrbook_write_elem_s( fp, 2, AB_ELTAG_ADDRESS_LIST );
-                       fputs( ">\n", fp );
+                       addrbook_write_elem_s(fp, 2, AB_ELTAG_ADDRESS_LIST);
+                       fputs(">\n", fp);
                        node = person->listEMail;
-                       while ( node ) {
+                       while (node) {
                                ItemEMail *email = node->data;
-                               addrbook_write_elem_s( fp, 3, AB_ELTAG_ADDRESS );
-                               addrbook_write_attr( fp, AB_ATTAG_UID, ADDRITEM_ID(email) );
-                               addrbook_write_attr( fp, AB_ATTAG_ALIAS, ADDRITEM_NAME(email) );
-                               addrbook_write_attr( fp, AB_ATTAG_EMAIL, email->address );
-                               addrbook_write_attr( fp, AB_ATTAG_REMARKS, email->remarks );
-                               fputs( " />\n", fp);
-                               node = g_list_next( node );
+                               addrbook_write_elem_s(fp, 3, AB_ELTAG_ADDRESS);
+                               addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(email));
+                               addrbook_write_attr(fp, AB_ATTAG_ALIAS, ADDRITEM_NAME(email));
+                               addrbook_write_attr(fp, AB_ATTAG_EMAIL, email->address);
+                               addrbook_write_attr(fp, AB_ATTAG_REMARKS, email->remarks);
+                               fputs(" />\n", fp);
+                               node = g_list_next(node);
                        }
-                       addrbook_write_elem_e( fp, 2, AB_ELTAG_ADDRESS_LIST );
+                       addrbook_write_elem_e(fp, 2, AB_ELTAG_ADDRESS_LIST);
 
                        /* Output user attributes */
-                       addrbook_write_elem_s( fp, 2, AB_ELTAG_ATTRIBUTE_LIST );
-                       fputs( ">\n", fp );
+                       addrbook_write_elem_s(fp, 2, AB_ELTAG_ATTRIBUTE_LIST);
+                       fputs(">\n", fp);
                        node = person->listAttrib;
-                       while ( node ) {
+                       while (node) {
                                UserAttribute *attrib = node->data;
-                               addrbook_write_elem_s( fp, 3, AB_ELTAG_ATTRIBUTE );
-                               addrbook_write_attr( fp, AB_ATTAG_UID, attrib->uid );
-                               addrbook_write_attr( fp, AB_ATTAG_NAME, attrib->name );
-                               fputs( " >", fp);
-                               xml_file_put_escape_str( fp, attrib->value );
-                               addrbook_write_elem_e( fp, 0, AB_ELTAG_ATTRIBUTE );
-                               node = g_list_next( node );
+                               addrbook_write_elem_s(fp, 3, AB_ELTAG_ATTRIBUTE);
+                               addrbook_write_attr(fp, AB_ATTAG_UID, attrib->uid);
+                               addrbook_write_attr(fp, AB_ATTAG_NAME, attrib->name);
+                               fputs(" >", fp);
+                               xml_file_put_escape_str(fp, attrib->value);
+                               addrbook_write_elem_e(fp, 0, AB_ELTAG_ATTRIBUTE);
+                               node = g_list_next(node);
                        }
-                       addrbook_write_elem_e( fp, 2, AB_ELTAG_ATTRIBUTE_LIST );
-                       addrbook_write_elem_e( fp, 1, AB_ELTAG_PERSON );
+                       addrbook_write_elem_e(fp, 2, AB_ELTAG_ATTRIBUTE_LIST);
+                       addrbook_write_elem_e(fp, 1, AB_ELTAG_PERSON);
                }
        }
 }
 
-/*
-* Write file hash table visitor function.
-*/
-static void addrbook_write_item_group_vis( gpointer key, gpointer value, gpointer data ) {
-       AddrItemObject *obj = ( AddrItemObject * ) value;
-       FILE *fp = ( FILE * ) data;
+/* Write file hash table visitor function */
+static void addrbook_write_item_group_vis(gpointer key, gpointer value, 
+                                         gpointer data)
+{
+       AddrItemObject *obj = (AddrItemObject *) value;
+       FILE *fp = (FILE *) data;
        GList *node;
 
-       if( ! obj ) return;
-       if( ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP ) {
-               ItemGroup *group = ( ItemGroup * ) value;
-               if( group ) {
-                       addrbook_write_elem_s( fp, 1, AB_ELTAG_GROUP );
-                       addrbook_write_attr( fp, AB_ATTAG_UID, ADDRITEM_ID(group) );
-                       addrbook_write_attr( fp, AB_ATTAG_NAME, ADDRITEM_NAME(group) );
-                       addrbook_write_attr( fp, AB_ATTAG_REMARKS, group->remarks );
-                       fputs( " >\n", fp );
+       if (!obj)
+               return;
+       if (ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP) {
+               ItemGroup *group = (ItemGroup *) value;
+               if (group) {
+                       addrbook_write_elem_s(fp, 1, AB_ELTAG_GROUP);
+                       addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(group));
+                       addrbook_write_attr(fp, AB_ATTAG_NAME, ADDRITEM_NAME(group));
+                       addrbook_write_attr(fp, AB_ATTAG_REMARKS, group->remarks);
+                       fputs(" >\n", fp);
 
                        /* Output email address links */
-                       addrbook_write_elem_s( fp, 2, AB_ELTAG_MEMBER_LIST );
-                       fputs( ">\n", fp );
+                       addrbook_write_elem_s(fp, 2, AB_ELTAG_MEMBER_LIST);
+                       fputs(">\n", fp);
                        node = group->listEMail;
-                       while ( node ) {
+                       while (node) {
                                ItemEMail *email = node->data;
-                               ItemPerson *person = ( ItemPerson * ) ADDRITEM_PARENT(email);
-                               addrbook_write_elem_s( fp, 3, AB_ELTAG_MEMBER );
-                               addrbook_write_attr( fp, AB_ATTAG_PID, ADDRITEM_ID(person) );
-                               addrbook_write_attr( fp, AB_ATTAG_EID, ADDRITEM_ID(email) );
-                               fputs( " />\n", fp );
-                               node = g_list_next( node );
+                               ItemPerson *person = (ItemPerson *) ADDRITEM_PARENT(email);
+                               addrbook_write_elem_s(fp, 3, AB_ELTAG_MEMBER);
+                               addrbook_write_attr(fp, AB_ATTAG_PID, ADDRITEM_ID(person));
+                               addrbook_write_attr(fp, AB_ATTAG_EID, ADDRITEM_ID(email));
+                               fputs(" />\n", fp);
+                               node = g_list_next(node);
                        }
-                       addrbook_write_elem_e( fp, 2, AB_ELTAG_MEMBER_LIST );
-                       addrbook_write_elem_e( fp, 1, AB_ELTAG_GROUP );
+                       addrbook_write_elem_e(fp, 2, AB_ELTAG_MEMBER_LIST);
+                       addrbook_write_elem_e(fp, 1, AB_ELTAG_GROUP);
                }
        }
 }
 
-/*
-* Write file hash table visitor function.
-*/
-static void addrbook_write_item_folder_vis( gpointer key, gpointer value, gpointer data ) {
-       AddrItemObject *obj = ( AddrItemObject * ) value;
-       FILE *fp = ( FILE * ) data;
+/* Write file hash table visitor function */
+static void addrbook_write_item_folder_vis(gpointer key, gpointer value, 
+                                          gpointer data)
+{
+       AddrItemObject *obj = (AddrItemObject *) value;
+       FILE *fp = (FILE *) data;
        GList *node;
 
-       if( ! obj ) return;
-       if( ADDRITEM_TYPE(obj) == ITEMTYPE_FOLDER ) {
-               ItemFolder *folder = ( ItemFolder * ) value;
-               if( folder ) {
-                       addrbook_write_elem_s( fp, 1, AB_ELTAG_FOLDER );
-                       addrbook_write_attr( fp, AB_ATTAG_UID, ADDRITEM_ID(folder) );
-                       addrbook_write_attr( fp, AB_ATTAG_NAME, ADDRITEM_NAME(folder) );
-                       addrbook_write_attr( fp, AB_ATTAG_REMARKS, folder->remarks );
-                       fputs( " >\n", fp );
-                       addrbook_write_elem_s( fp, 2, AB_ELTAG_ITEM_LIST );
-                       fputs( ">\n", fp );
+       if (!obj)
+               return;
+       if (ADDRITEM_TYPE(obj) == ITEMTYPE_FOLDER) {
+               ItemFolder *folder = (ItemFolder *) value;
+               if (folder) {
+                       addrbook_write_elem_s(fp, 1, AB_ELTAG_FOLDER);
+                       addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(folder));
+                       addrbook_write_attr(fp, AB_ATTAG_NAME, ADDRITEM_NAME(folder));
+                       addrbook_write_attr(fp, AB_ATTAG_REMARKS, folder->remarks);
+                       fputs(" >\n", fp);
+                       addrbook_write_elem_s(fp, 2, AB_ELTAG_ITEM_LIST);
+                       fputs(">\n", fp);
 
                        /* Output persons */
                        node = folder->listPerson;
-                       while ( node ) {
+                       while (node) {
                                ItemPerson *item = node->data;
-                               addrbook_write_elem_s( fp, 3, AB_ELTAG_ITEM );
-                               addrbook_write_attr( fp, AB_ATTAG_TYPE,  AB_ATTAG_VAL_PERSON );
-                               addrbook_write_attr( fp, AB_ATTAG_UID, ADDRITEM_ID(item ) );
-                               fputs( " />\n", fp );
-                               node = g_list_next( node );
+                               addrbook_write_elem_s(fp, 3, AB_ELTAG_ITEM);
+                               addrbook_write_attr(fp, AB_ATTAG_TYPE,  AB_ATTAG_VAL_PERSON);
+                               addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(item));
+                               fputs(" />\n", fp);
+                               node = g_list_next(node);
                        }
 
                        /* Output groups */
                        node = folder->listGroup;
-                       while ( node ) {
+                       while (node) {
                                ItemGroup *item = node->data;
-                               addrbook_write_elem_s( fp, 3, AB_ELTAG_ITEM );
-                               addrbook_write_attr( fp, AB_ATTAG_TYPE, AB_ATTAG_VAL_GROUP );
-                               addrbook_write_attr( fp, AB_ATTAG_UID, ADDRITEM_ID(item ) );
-                               fputs( " />\n", fp );
-                               node = g_list_next( node );
+                               addrbook_write_elem_s(fp, 3, AB_ELTAG_ITEM);
+                               addrbook_write_attr(fp, AB_ATTAG_TYPE, AB_ATTAG_VAL_GROUP);
+                               addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(item));
+                               fputs(" />\n", fp);
+                               node = g_list_next(node);
                        }
 
                        /* Output folders */
                        node = folder->listFolder;
-                       while ( node ) {
+                       while (node) {
                                ItemFolder *item = node->data;
-                               addrbook_write_elem_s( fp, 3, AB_ELTAG_ITEM );
-                               addrbook_write_attr( fp, AB_ATTAG_TYPE, AB_ATTAG_VAL_FOLDER );
-                               addrbook_write_attr( fp, AB_ATTAG_UID, ADDRITEM_ID(item ) );
-                               fputs( " />\n", fp );
-                               node = g_list_next( node );
+                               addrbook_write_elem_s(fp, 3, AB_ELTAG_ITEM);
+                               addrbook_write_attr(fp, AB_ATTAG_TYPE, AB_ATTAG_VAL_FOLDER);
+                               addrbook_write_attr(fp, AB_ATTAG_UID, ADDRITEM_ID(item));
+                               fputs(" />\n", fp);
+                               node = g_list_next(node);
                        }
-                       addrbook_write_elem_e( fp, 2, AB_ELTAG_ITEM_LIST );
-                       addrbook_write_elem_e( fp, 1, AB_ELTAG_FOLDER );
+                       addrbook_write_elem_e(fp, 2, AB_ELTAG_ITEM_LIST);
+                       addrbook_write_elem_e(fp, 1, AB_ELTAG_FOLDER);
                }
        }
 }
 
-/*
-* Output address book data to specified file.
-* return: Status code.
-*/
-gint addrbook_write_to( AddressBookFile *book, gchar *newFile ) {
+/* Output address book data to specified file.
+  return: Status code */
+gint addrbook_write_to(AddressBookFile *book, gchar *newFile)
+{
        FILE *fp;
        gchar *fileSpec;
 #ifndef DEV_STANDALONE
        PrefFile *pfile;
 #endif
 
-       g_return_val_if_fail( book != NULL, -1 );
-       g_return_val_if_fail( newFile != NULL, -1 );
+       g_return_val_if_fail(book != NULL, -1);
+       g_return_val_if_fail(newFile != NULL, -1);
 
-       fileSpec = g_strconcat( book->path, G_DIR_SEPARATOR_S, newFile, NULL );
+       fileSpec = g_strconcat(book->path, G_DIR_SEPARATOR_S, newFile, NULL);
 
        book->retVal = MGU_OPEN_FILE;
 #ifdef DEV_STANDALONE
-       fp = fopen( fileSpec, "wb" );
-       g_free( fileSpec );
-       if( fp ) {
-               fputs( "<?xml version=\"1.0\" ?>\n", fp );
+       fp = fopen(fileSpec, "wb");
+       g_free(fileSpec);
+       if (fp) {
+               fputs("<?xml version=\"1.0\" ?>\n", fp);
 #else
-       pfile = prefs_write_open( fileSpec );
-       g_free( fileSpec );
-       if( pfile ) {
+       pfile = prefs_write_open(fileSpec);
+       g_free(fileSpec);
+       if (pfile) {
                fp = pfile->fp;
-               fprintf( fp, "<?xml version=\"1.0\" encoding=\"%s\" ?>\n",
-                               conv_get_current_charset_str() );
+               fprintf(fp, "<?xml version=\"1.0\" encoding=\"%s\" ?>\n",
+                       conv_get_current_charset_str());
 #endif
-               addrbook_write_elem_s( fp, 0, AB_ELTAG_ADDRESS_BOOK );
-               addrbook_write_attr( fp, AB_ATTAG_NAME, addrcache_get_name( book->addressCache ) );
-               fputs( " >\n", fp );
+               addrbook_write_elem_s(fp, 0, AB_ELTAG_ADDRESS_BOOK);
+               addrbook_write_attr(fp, AB_ATTAG_NAME,
+                                   addrcache_get_name(book->addressCache));
+               fputs(" >\n", fp);
 
                /* Output all persons */
-               g_hash_table_foreach( book->addressCache->itemHash, addrbook_write_item_person_vis, fp );
+               g_hash_table_foreach(book->addressCache->itemHash, 
+                                    addrbook_write_item_person_vis, fp);
 
                /* Output all groups */
-               g_hash_table_foreach( book->addressCache->itemHash, addrbook_write_item_group_vis, fp );
+               g_hash_table_foreach(book->addressCache->itemHash, 
+                                    addrbook_write_item_group_vis, fp);
 
                /* Output all folders */
-               g_hash_table_foreach( book->addressCache->itemHash, addrbook_write_item_folder_vis, fp );
+               g_hash_table_foreach(book->addressCache->itemHash, 
+                                    addrbook_write_item_folder_vis, fp);
 
-               addrbook_write_elem_e( fp, 0, AB_ELTAG_ADDRESS_BOOK );
+               addrbook_write_elem_e(fp, 0, AB_ELTAG_ADDRESS_BOOK);
                book->retVal = MGU_SUCCESS;
 #ifdef DEV_STANDALONE
-               fclose( fp );
+               fclose(fp);
 #else
-               if( prefs_write_close( pfile ) < 0 ) {
+               if (prefs_write_close( pfile ) < 0)
                        book->retVal = MGU_ERROR_WRITE;
-               }
 #endif
        }
 
@@ -1114,447 +1122,432 @@ gint addrbook_write_to( AddressBookFile *book, gchar *newFile ) {
        return book->retVal;
 }
 
-/*
-* Output address book data to original file.
-* return: Status code.
-*/
-gint addrbook_save_data( AddressBookFile *book ) {
-       g_return_val_if_fail( book != NULL, -1 );
+/* Output address book data to original file.
+   return: Status code */
+gint addrbook_save_data(AddressBookFile *book)
+{
+       g_return_val_if_fail(book != NULL, -1);
 
        book->retVal = MGU_NO_FILE;
-       if( book->fileName == NULL || *book->fileName == '\0' ) return book->retVal;
-       if( book->path == NULL || *book->path == '\0' ) return book->retVal;
-
-       addrbook_write_to( book, book->fileName );
-       if( book->retVal == MGU_SUCCESS ) {
-               addrcache_set_dirty( book->addressCache, FALSE );
-       }
+       if (book->fileName == NULL || *book->fileName == '\0') 
+               return book->retVal;
+       if (book->path == NULL || *book->path == '\0')
+               return book->retVal;
+
+       addrbook_write_to(book, book->fileName);
+       if (book->retVal == MGU_SUCCESS)
+               addrcache_set_dirty(book->addressCache, FALSE);
        return book->retVal;
 }
 
 /* **********************************************************************
-* Address book edit interface functions...
-* ***********************************************************************
-*/
-
-/*
-* Move person's email item.
-* param: book       Address book.
-*        person     Person.
-*        itemMove   Item to move.
-*        itemTarget Target item before which to move item.
-*/
-ItemEMail *addrbook_move_email_before( AddressBookFile *book, ItemPerson *person,
-                       ItemEMail *itemMove, ItemEMail *itemTarget )
+   Address book edit interface functions...
+   ***********************************************************************
+  Move person's email item.
+  param: book       Address book.
+         person     Person.
+         itemMove   Item to move.
+         itemTarget Target item before which to move item */
+ItemEMail *addrbook_move_email_before(AddressBookFile *book, ItemPerson *person,
+                                     ItemEMail *itemMove, ItemEMail *itemTarget)
 {
        ItemEMail *email = NULL;
 
-       g_return_val_if_fail( book != NULL, NULL );
+       g_return_val_if_fail(book != NULL, NULL);
 
-       email = addritem_move_email_before( person, itemMove, itemTarget );
-       if( email ) {
-               addrcache_set_dirty( book->addressCache, TRUE );
-       }
+       email = addritem_move_email_before(person, itemMove, itemTarget);
+       if (email) 
+               addrcache_set_dirty(book->addressCache, TRUE);
        return email;
 }
 
-/*
-* Move person's email item.
-* param: book       Address book.
-*        person     Person.
-*        itemMove   Item to move.
-*        itemTarget Target item after which to move item.
-*/
-ItemEMail *addrbook_move_email_after( AddressBookFile *book, ItemPerson *person,
-                       ItemEMail *itemMove, ItemEMail *itemTarget )
+/* Move person's email item.
+   param: book       Address book.
+          person     Person.
+         itemMove   Item to move.
+         itemTarget Target item after which to move item */
+ItemEMail *addrbook_move_email_after(AddressBookFile *book, ItemPerson *person,
+                                    ItemEMail *itemMove, ItemEMail *itemTarget)
 {
        ItemEMail *email = NULL;
 
-       g_return_val_if_fail( book != NULL, NULL );
+       g_return_val_if_fail(book != NULL, NULL);
 
-       email = addritem_move_email_after( person, itemMove, itemTarget );
-       if( email ) {
-               addrcache_set_dirty( book->addressCache, TRUE );
-       }
+       email = addritem_move_email_after(person, itemMove, itemTarget);
+       if (email)
+               addrcache_set_dirty(book->addressCache, TRUE);
        return email;
 }
 
-/*
-* Hash table visitor function for deletion of hashtable entries.
-*/
-static gboolean addrbook_free_simple_hash_vis(
-       gpointer *key, gpointer *value, gpointer *data )
+/* Hash table visitor function for deletion of hashtable entries */
+static gboolean addrbook_free_simple_hash_vis(gpointer *key, gpointer *value, 
+                                             gpointer *data)
 {
-       g_free( key );
+       g_free(key);
        key = NULL;
        value = NULL;
        return TRUE;
 }
 
-/*
-* Update address book email list for specified person.
-* Enter: book      Address book.
-*        person    Person to update.
-*        listEMail List of new email addresses.
-* Note: The existing email addresses are replaced with the new addresses. Any references
-* to old addresses in the groups are re-linked to the new addresses. All old addresses
-* linked to the person are removed.
-*/
-void addrbook_update_address_list(
-       AddressBookFile *book, ItemPerson *person, GList *listEMail )
+/* Update address book email list for specified person.
+   Enter: book      Address book.
+          person    Person to update.
+          listEMail List of new email addresses.
+  Note: The existing email addresses are replaced with the new addresses. Any references
+  to old addresses in the groups are re-linked to the new addresses. All old addresses
+  linked to the person are removed */
+void addrbook_update_address_list(AddressBookFile *book, ItemPerson *person, 
+                                 GList *listEMail)
 {
        GList *node;
        GList *listDelete;
        GList *listGroup;
 
-       g_return_if_fail( book != NULL );
-       g_return_if_fail( person != NULL );
+       g_return_if_fail(book != NULL);
+       g_return_if_fail(person != NULL);
 
        /* Get groups where person's existing email addresses are listed */
-       listGroup = addrcache_get_group_for_person( book->addressCache, person );
-       if( listGroup ) {
+       listGroup = addrcache_get_group_for_person(book->addressCache, person);
+       if (listGroup) {
                GHashTable *hashEMail;
                GHashTable *hashEMailAlias;
                GList *nodeGrp;
 
                /* Load hash table with new address entries */
-               hashEMail = g_hash_table_new( g_str_hash, g_str_equal );
-               hashEMailAlias = g_hash_table_new( g_str_hash, g_str_equal );
+               hashEMail = g_hash_table_new(g_str_hash, g_str_equal);
+               hashEMailAlias = g_hash_table_new(g_str_hash, g_str_equal);
                node = listEMail;
-               while( node ) {
+               while (node) {
                        ItemEMail *email = node->data;
-                       gchar *addr = g_strdup( email->address );
+                       gchar *addr = g_strdup(email->address);
                        gchar *alias = email->obj.name ;
-                       g_strdown( addr );
-                       if( ! g_hash_table_lookup( hashEMail, addr ) ) {
-                               g_hash_table_insert( hashEMail, addr, email );
-                       }
-                       if ( *alias != '\0' && ! g_hash_table_lookup( hashEMailAlias, alias ) ) {
-                               g_hash_table_insert( hashEMailAlias, alias, email );
+                       g_strdown(addr);
+                       if (!g_hash_table_lookup(hashEMail, addr)) {
+                               g_hash_table_insert(hashEMail, addr, email);
                        }
-                       node = g_list_next( node );
+                       if (*alias != '\0' && ! g_hash_table_lookup(hashEMailAlias,
+                           alias)) 
+                               g_hash_table_insert(hashEMailAlias, alias, email);
+
+                       node = g_list_next(node);
                }
 
                /* Re-parent new addresses to existing groups, where email address match. */
                nodeGrp = listGroup;
-               while( nodeGrp ) {
-                       ItemGroup *group = ( ItemGroup * ) nodeGrp->data;
+               while (nodeGrp) {
+                       ItemGroup *group = (ItemGroup *) nodeGrp->data;
                        GList *groupEMail = group->listEMail;
                        GList *nodeGrpEM;
                        GList *listRemove = NULL;
 
                        /* Process each email item linked to group */
                        nodeGrpEM = groupEMail;
-                       while( nodeGrpEM ) {
-                               ItemEMail *emailGrp = ( ItemEMail * ) nodeGrpEM->data;
+                       while (nodeGrpEM) {
+                               ItemEMail *emailGrp = (ItemEMail *) nodeGrpEM->data;
 
-                               if( ADDRITEM_PARENT(emailGrp) == ADDRITEM_OBJECT(person) ) {
+                               if (ADDRITEM_PARENT(emailGrp) == ADDRITEM_OBJECT(person)) {
                                        /* Found an email address for this person */
                                        ItemEMail *emailNew = NULL;
-                                       gchar *addr = g_strdup( emailGrp->address );
+                                       gchar *addr = g_strdup(emailGrp->address);
                                        gchar *alias = emailGrp->obj.name;
-                                       g_strdown( addr );
-                                       emailNew = ( ItemEMail * )
-                                               g_hash_table_lookup( hashEMail, addr );
+                                       g_strdown(addr);
+                                       emailNew = (ItemEMail *)
+                                               g_hash_table_lookup(hashEMail, addr);
                                        g_free( addr );
                                        /* If no match by e-mail, try to match by e-mail alias */
-                                       if( ! emailNew && *alias != '\0' ) {
-                                               emailNew = ( ItemEMail * )
-                                                       g_hash_table_lookup( hashEMailAlias, alias);
+                                       if (!emailNew && *alias != '\0') {
+                                               emailNew = (ItemEMail *)
+                                                       g_hash_table_lookup(hashEMailAlias, alias);
                                        }
                                        
-                                       if( emailNew ) {
+                                       if (emailNew)
                                                /* Point to this entry */
                                                nodeGrpEM->data = emailNew;
-                                       }
-                                       else if(g_hash_table_size(hashEMail)==1) {
+                                       else if (g_hash_table_size(hashEMail)==1)
                                                /* If the person has just one e-mail address, then 
                                                   change e-mail address in group list */
                                                nodeGrpEM->data = listEMail->data;
-                                       } 
-                                       else {
+                                       else 
                                                /* Mark for removal */
-                                               listRemove = g_list_append( listRemove, emailGrp );
-                                       }
+                                               listRemove = g_list_append(listRemove, emailGrp);
                                }
                                /* Move on to next email link */
-                               nodeGrpEM = g_list_next( nodeGrpEM );
+                               nodeGrpEM = g_list_next(nodeGrpEM);
                        }
 
                        /* Process all removed links in current group */
                        nodeGrpEM = listRemove;
-                       while( nodeGrpEM ) {
+                       while (nodeGrpEM) {
                                ItemEMail *emailGrp = nodeGrpEM->data;
-                               groupEMail = g_list_remove( groupEMail, emailGrp );
-                               nodeGrpEM = g_list_next( nodeGrpEM );
+                               groupEMail = g_list_remove(groupEMail, emailGrp);
+                               nodeGrpEM = g_list_next(nodeGrpEM);
                        }
 
-                       g_list_free( listRemove );
+                       g_list_free(listRemove);
 
                        /* Move on to next group */
-                       nodeGrp = g_list_next( nodeGrp );
+                       nodeGrp = g_list_next(nodeGrp);
 
                }
-
                /* Clear hash table */
-               g_hash_table_foreach_remove(
-                       hashEMail, ( GHRFunc ) addrbook_free_simple_hash_vis, NULL );
-               g_hash_table_destroy( hashEMail );
+               g_hash_table_foreach_remove(hashEMail, (GHRFunc) 
+                                           addrbook_free_simple_hash_vis, NULL);
+               g_hash_table_destroy(hashEMail);
                hashEMail = NULL;
-               g_hash_table_destroy( hashEMailAlias );
+               g_hash_table_destroy(hashEMailAlias);
                hashEMailAlias = NULL;
-               g_list_free( listGroup );
+               g_list_free(listGroup);
                listGroup = NULL;
        }
-
        /* Remove old addresses from person and cache */
        listDelete = NULL;
        node = person->listEMail;
-       while( node ) {
+       while (node) {
                ItemEMail *email = node->data;
 
-               if( addrcache_person_remove_email( book->addressCache, person, email ) ) {
-                       addrcache_remove_email( book->addressCache, email );
-               }
-               listDelete = g_list_append( listDelete, email );
+               if (addrcache_person_remove_email(book->addressCache, person, email))
+                       addrcache_remove_email(book->addressCache, email);
+
+               listDelete = g_list_append(listDelete, email);
                node = person->listEMail;
        }
-
        /* Add new address entries */
        node = listEMail;
-       while( node ) {
+       while (node) {
                ItemEMail *email = node->data;
 
-               if( ADDRITEM_ID(email) == NULL ) {
+               if (ADDRITEM_ID(email) == NULL)
                        /* Allocate an ID for new address */
-                       addrcache_id_email( book->addressCache, email );
-               }
+                       addrcache_id_email(book->addressCache, email);
+                       
                addrcache_person_add_email( book->addressCache, person, email );
                node = g_list_next( node );
        }
 
-       addrcache_set_dirty( book->addressCache, TRUE );
+       addrcache_set_dirty(book->addressCache, TRUE);
 
        /* Free up memory */
-       g_list_free( listEMail );
+       g_list_free(listEMail);
        listEMail = NULL;
 
        node = listDelete;
-       while( node ) {
+       while (node) {
                ItemEMail *email = node->data;
 
-               addritem_free_item_email( email );
-               node = g_list_next( node );
+               addritem_free_item_email(email);
+               node = g_list_next(node);
        }
-       g_list_free( listDelete );
+       g_list_free(listDelete);
        listDelete = NULL;
 
 }
 
-/*
-* Add person and address data to address book.
-* Enter: book      Address book.
-*        folder    Folder where to add person, or NULL for root folder.
-*        listEMail New list of email addresses.
-* Return: Person added.
-* Note: A new person is created with specified list of email addresses. All objects inserted
-* into address book.
-*/
-ItemPerson *addrbook_add_address_list( AddressBookFile *book, ItemFolder *folder, GList *listEMail ) {
+/* Add person and address data to address book.
+   Enter: book      Address book.
+          folder    Folder where to add person, or NULL for root folder.
+          listEMail New list of email addresses.
+   Return: Person added.
+   Note: A new person is created with specified list of email addresses. All objects inserted
+   into address book */
+ItemPerson *addrbook_add_address_list(AddressBookFile *book, ItemFolder *folder,
+                                     GList *listEMail)
+{
        ItemPerson *person;
        ItemFolder *f = folder;
        GList *node;
 
-       g_return_val_if_fail( book != NULL, NULL );
+       g_return_val_if_fail(book != NULL, NULL);
 
-       if( ! f ) f = book->addressCache->rootFolder;
+       if (!f) 
+               f = book->addressCache->rootFolder;
        person = addritem_create_item_person();
-       addrcache_id_person( book->addressCache, person );
-       addrcache_folder_add_person( book->addressCache, f, person );
+       addrcache_id_person(book->addressCache, person);
+       addrcache_folder_add_person(book->addressCache, f, person);
 
        node = listEMail;
-       while( node ) {
+       while (node) {
                ItemEMail *email = node->data;
-               if( ADDRITEM_ID(email) == NULL ) {
-                       addrcache_id_email( book->addressCache, email );
-               }
-               addrcache_person_add_email( book->addressCache, person, email );
-               node = g_list_next( node );
+               if (ADDRITEM_ID(email) == NULL)
+                       addrcache_id_email(book->addressCache, email);
+
+               addrcache_person_add_email(book->addressCache, person, email);
+               node = g_list_next(node);
        }
        return person;
 }
 
-/*
-* Build available email list visitor function.
-*/
-static void addrbook_build_avail_email_vis( gpointer key, gpointer value, gpointer data ) {
-       AddrItemObject *obj = ( AddrItemObject * ) value;
+/* Build available email list visitor function */
+static void addrbook_build_avail_email_vis(gpointer key, gpointer value, 
+                                          gpointer data)
+{
+       AddrItemObject *obj = (AddrItemObject *) value;
 
-       if( ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON ) {
+       if (ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON) {
                AddressBookFile *book = data;
-               ItemPerson *person = ( ItemPerson * ) obj;
+               ItemPerson *person = (ItemPerson *) obj;
                GList *node = person->listEMail;
-               while( node ) {
+               while (node) {
                        ItemEMail *email = node->data;
                        /* gchar *newKey = g_strdup( ADDRITEM_ID(email) ); */
 
-                       if( ! g_hash_table_lookup( book->tempHash, ADDRITEM_ID(email) ) ) {
-                               book->tempList = g_list_append( book->tempList, email );
-                       }
-                       node = g_list_next( node );
+                       if (!g_hash_table_lookup(book->tempHash,
+                                                ADDRITEM_ID(email)))
+                               book->tempList = g_list_append(book->tempList, email);
+
+                       node = g_list_next(node);
                }
        }
 }
 
-/*
-* Return link list of available email items (which have not already been linked to
-* groups). Note that the list contains references to items and should be g_free()
-* when done. Do *NOT* attempt to used the addrbook_free_xxx() functions... this will
-* destroy the addressbook data!
-* Return: List of items, or NULL if none.
-*/
-GList *addrbook_get_available_email_list( AddressBookFile *book, ItemGroup *group ) {
+/* Return link list of available email items (which have not already been linked to
+   groups). Note that the list contains references to items and should be g_free()
+   when done. Do *NOT* attempt to used the addrbook_free_xxx() functions... this will
+   destroy the addressbook data!
+   Return: List of items, or NULL if none */
+GList *addrbook_get_available_email_list(AddressBookFile *book, ItemGroup *group)
+{
        GList *list = NULL;
        GHashTable *table;
 
-       g_return_val_if_fail( book != NULL, NULL );
+       g_return_val_if_fail(book != NULL, NULL);
 
        /* Load hash table with group email entries */
-       table = g_hash_table_new( g_str_hash, g_str_equal );
-       if( group ) {
+       table = g_hash_table_new(g_str_hash, g_str_equal);
+       if (group) {
                list = group->listEMail;
-               while( list ) {
+               while (list) {
                        ItemEMail *email = list->data;
-                       g_hash_table_insert( table, ADDRITEM_ID(email), email );
-                       list = g_list_next( list );
+                       g_hash_table_insert(table, ADDRITEM_ID(email), email);
+                       list = g_list_next(list);
                }
        }
 
        /* Build list of available email addresses which exclude those already in groups */
        book->tempList = NULL;
        book->tempHash = table;
-       g_hash_table_foreach( book->addressCache->itemHash, addrbook_build_avail_email_vis, book );
+       g_hash_table_foreach(book->addressCache->itemHash, 
+                            addrbook_build_avail_email_vis, book);
        list = book->tempList;
        book->tempList = NULL;
        book->tempHash = NULL;
 
        /* Clear hash table */
-       g_hash_table_destroy( table );
+       g_hash_table_destroy(table);
        table = NULL;
 
        return list;
 }
 
-/*
-* Update address book email list for specified group.
-* Enter: book      Address book.
-*        group     group to update.
-*        listEMail New list of email addresses. This should *NOT* be g_free() when done.
-* Note: The existing email addresses are replaced with the new addresses. Any references
-* to old addresses in the groups are re-linked to the new addresses. All old addresses
-* linked to the person are removed.
-*/
-void addrbook_update_group_list( AddressBookFile *book, ItemGroup *group, GList *listEMail ) {
+/* Update address book email list for specified group.
+   Enter: book      Address book.
+          group     group to update.
+          listEMail New list of email addresses. This should *NOT* be g_free() when done.
+  Note: The existing email addresses are replaced with the new addresses. Any references
+  to old addresses in the groups are re-linked to the new addresses. All old addresses
+  linked to the person are removed */
+void addrbook_update_group_list(AddressBookFile *book, ItemGroup *group, 
+                               GList *listEMail)
+{
        GList *oldData;
 
-       g_return_if_fail( book != NULL );
-       g_return_if_fail( group != NULL );
+       g_return_if_fail(book != NULL);
+       g_return_if_fail(group != NULL);
 
-       addrcache_set_dirty( book->addressCache, TRUE );
+       addrcache_set_dirty(book->addressCache, TRUE);
 
        /* Remember old list */
        oldData = group->listEMail;
        group->listEMail = listEMail;
-       mgu_clear_list( oldData );
+       mgu_clear_list(oldData);
        oldData = NULL;
 }
 
-/*
-* Add group and email list to address book.
-* Enter: book      Address book.
-*        folder    Parent folder, or NULL for root folder.
-*        listEMail New list of email addresses. This should *NOT* be g_free() when done.
-* Return: Group object.
-* Note: The existing email addresses are replaced with the new addresses. Any references
-* to old addresses in the groups are re-linked to the new addresses. All old addresses
-* linked to the person are removed.
-*/
-ItemGroup *addrbook_add_group_list( AddressBookFile *book, ItemFolder *folder, GList *listEMail ) {
+/* Add group and email list to address book.
+   Enter: book      Address book.
+          folder    Parent folder, or NULL for root folder.
+          listEMail New list of email addresses. This should *NOT* be g_free() when done.
+   Return: Group object.
+   Note: The existing email addresses are replaced with the new addresses. Any references
+   to old addresses in the groups are re-linked to the new addresses. All old addresses
+   linked to the person are removed */
+ItemGroup *addrbook_add_group_list(AddressBookFile *book, ItemFolder *folder,
+                                  GList *listEMail)
+{
        ItemGroup *group = NULL;
        ItemFolder *f = folder;
 
-       g_return_val_if_fail( book != NULL, NULL );
+       g_return_val_if_fail(book != NULL, NULL);
 
-       if( ! f ) f = book->addressCache->rootFolder;
+       if (!f)
+               f = book->addressCache->rootFolder;
        group = addritem_create_item_group();
-       addrcache_id_group( book->addressCache, group );
-       addrcache_folder_add_group( book->addressCache, f, group );
+       addrcache_id_group(book->addressCache, group);
+       addrcache_folder_add_group(book->addressCache, f, group);
        group->listEMail = listEMail;
        return group;
 }
 
-/*
-* Add new folder to address book.
-* Enter: book   Address book.
-*        parent        Parent folder.
-* Return: Folder that was added. This should *NOT* be g_free() when done.
-*/
-ItemFolder *addrbook_add_new_folder( AddressBookFile *book, ItemFolder *parent ) {
+/* Add new folder to address book.
+   Enter: book   Address book.
+          parent       Parent folder.
+   Return: Folder that was added. This should *NOT* be g_free() when done */
+ItemFolder *addrbook_add_new_folder(AddressBookFile *book, ItemFolder *parent)
+{
        ItemFolder *folder = NULL;
        ItemFolder *p = parent;
 
-       g_return_val_if_fail( book != NULL, NULL );
+       g_return_val_if_fail(book != NULL, NULL);
 
-       if( ! p ) p = book->addressCache->rootFolder;
+       if (!p)
+               p = book->addressCache->rootFolder;
        folder = addritem_create_item_folder();
-       addrcache_id_folder( book->addressCache, folder );
-       if( addrcache_hash_add_folder( book->addressCache, folder ) ) {
-               p->listFolder = g_list_append( p->listFolder, folder );
+       addrcache_id_folder(book->addressCache, folder);
+       if (addrcache_hash_add_folder(book->addressCache, folder)) {
+               p->listFolder = g_list_append(p->listFolder, folder);
                ADDRITEM_PARENT(folder) = ADDRITEM_OBJECT(p);
-               addrcache_set_dirty( book->addressCache, TRUE );
+               addrcache_set_dirty(book->addressCache, TRUE);
        }
        else {
-               addritem_free_item_folder( folder );
+               addritem_free_item_folder(folder);
                folder = NULL;
        }
        return folder;
 }
 
-/*
-* Update address book attribute list for specified person.
-* Enter: book       Address book.
-*        person     Person to update.
-*        listAttrib New list of attributes.
-* Note: The existing email addresses are replaced with the new addresses. All old attributes
-* linked to the person are removed.
-*/
-void addrbook_update_attrib_list( AddressBookFile *book, ItemPerson *person, GList *listAttrib ) {
+/* Update address book attribute list for specified person.
+   Enter: book       Address book.
+          person     Person to update.
+          listAttrib New list of attributes.
+   Note: The existing email addresses are replaced with the new addresses. All old attributes
+   linked to the person are removed */
+void addrbook_update_attrib_list(AddressBookFile *book, ItemPerson *person,
+                                GList *listAttrib)
+{
        GList *node;
        GList *oldData;
 
-       g_return_if_fail( book != NULL );
-       g_return_if_fail( person != NULL );
+       g_return_if_fail(book != NULL);
+       g_return_if_fail(person != NULL);
 
        /* Remember old list */
        oldData = person->listAttrib;
 
        /* Attach new address list to person. */
        node = listAttrib;
-       while( node ) {
+       while (node) {
                UserAttribute *attrib = node->data;
-               if( attrib->uid == NULL ) {
+               if (attrib->uid == NULL) {
                        /* Allocate an ID */
-                       addrcache_id_attribute( book->addressCache, attrib );
+                       addrcache_id_attribute(book->addressCache, attrib);
                }
-               node = g_list_next( node );
+               node = g_list_next(node);
        }
        person->listAttrib = listAttrib;
-       addrcache_set_dirty( book->addressCache, TRUE );
+       addrcache_set_dirty(book->addressCache, TRUE);
 
        /* Free up old data */
-       addritem_free_list_attribute( oldData );
+       addritem_free_list_attribute(oldData);
        oldData = NULL;
-
 }
 
 /*
@@ -1582,175 +1575,168 @@ void addrbook_add_attrib_list( AddressBookFile *book, ItemPerson *person, GList
        addrcache_set_dirty( book->addressCache, TRUE );
 }
 
-/*
-* Return address book file for specified object.
-* Enter: aio Book item object.
-* Return: Address book, or NULL if not found.
-*/
-AddressBookFile *addrbook_item_get_bookfile( AddrItemObject *aio ) {
+/* Return address book file for specified object.
+   Enter: aio Book item object.
+   Return: Address book, or NULL if not found */
+AddressBookFile *addrbook_item_get_bookfile(AddrItemObject *aio)
+{
        AddressBookFile *book = NULL;
 
-       if( aio ) {
+       if (aio) {
                ItemFolder *parent = NULL;
                ItemFolder *root = NULL;
-               if( aio->type == ITEMTYPE_EMAIL ) {
-                       ItemPerson *person = ( ItemPerson * ) ADDRITEM_PARENT(aio);
-                       if( person ) {
-                               parent = ( ItemFolder * ) ADDRITEM_PARENT(person);
-                       }
+               if (aio->type == ITEMTYPE_EMAIL) {
+                       ItemPerson *person = (ItemPerson *)ADDRITEM_PARENT(aio);
+                       if( person ) 
+                               parent = (ItemFolder *)ADDRITEM_PARENT(person);
                }
                else {
-                       parent = ( ItemFolder * ) ADDRITEM_PARENT(aio);
-               }
-               if( parent ) {
-                       root = addrcache_find_root_folder( parent );
-               }
-               if( root ) {
-                       book = ( AddressBookFile * ) ADDRITEM_PARENT(root);
+                       parent = (ItemFolder *)ADDRITEM_PARENT(aio);
                }
+               if (parent) 
+                       root = addrcache_find_root_folder(parent);
+               if (root)
+                       book = (AddressBookFile *)ADDRITEM_PARENT(root);
        }
        return book;
 }
 
-/*
-* Remove folder from address book. Children are re-parented to parent folder.
-* param: folder Folder to remove.
-* return: Folder, or NULL if not found. Note that object should still be freed.
-*/
-ItemFolder *addrbook_remove_folder( AddressBookFile *book, ItemFolder *folder ) {
+/* Remove folder from address book. Children are re-parented to parent folder.
+   param: folder Folder to remove.
+   return: Folder, or NULL if not found. Note that object should still be freed */
+ItemFolder *addrbook_remove_folder(AddressBookFile *book, ItemFolder *folder)
+{
        ItemFolder *f;
 
-       g_return_val_if_fail( book != NULL, NULL );
+       g_return_val_if_fail(book != NULL, NULL);
 
-       f = addrcache_remove_folder( book->addressCache, folder );
+       f = addrcache_remove_folder(book->addressCache, folder);
        return f;
 }
 
-/*
-* Remove folder from address book. Children are deleted.
-* param: folder Folder to remove.
-* return: Folder, or NULL if not found. Note that object should still be freed.
-*/
-ItemFolder *addrbook_remove_folder_delete( AddressBookFile *book, ItemFolder *folder ) {
+/* Remove folder from address book. Children are deleted.
+   param: folder Folder to remove.
+   return: Folder, or NULL if not found. Note that object should still be freed */
+ItemFolder *addrbook_remove_folder_delete(AddressBookFile *book, 
+                                         ItemFolder *folder)
+{
        ItemFolder *f;
 
-       g_return_val_if_fail( book != NULL, NULL );
+       g_return_val_if_fail(book != NULL, NULL);
 
-       f = addrcache_remove_folder_delete( book->addressCache, folder );
+       f = addrcache_remove_folder_delete(book->addressCache, folder);
        return f;
 }
 
 #define WORK_BUFLEN     1024
 #define ADDRBOOK_DIGITS "0123456789"
 
-/*
-* Return list of existing address book files.
-* Enter: book Address book file.
-* Return: File list.
-*/
-GList *addrbook_get_bookfile_list( AddressBookFile *book ) {
+/* Return list of existing address book files.
+   Enter: book Address book file.
+   Return: File list */
+GList *addrbook_get_bookfile_list(AddressBookFile *book) {
        gchar *adbookdir;
        DIR *dp;
        struct dirent *entry;
        struct stat statbuf;
-       gchar buf[ WORK_BUFLEN ];
-       gchar numbuf[ WORK_BUFLEN ];
+       gchar buf[WORK_BUFLEN];
+       gchar numbuf[WORK_BUFLEN];
        gint len, lenpre, lensuf, lennum;
        long int val, maxval;
        GList *fileList = NULL;
 
-       g_return_val_if_fail( book != NULL, NULL );
+       g_return_val_if_fail(book != NULL, NULL);
 
-       if( book->path == NULL || *book->path == '\0' ) {
+       if (book->path == NULL || *book->path == '\0') {
                book->retVal = MGU_NO_PATH;
                return NULL;
        }
 
-       strcpy( buf, book->path );
-       len = strlen( buf );
-       if( len > 0 ) {
-               if( buf[ len-1 ] != G_DIR_SEPARATOR ) {
-                       buf[ len ] = G_DIR_SEPARATOR;
-                       buf[ ++len ] = '\0';
+       strcpy(buf, book->path);
+       len = strlen(buf);
+       if (len > 0) {
+               if (buf[len-1] != G_DIR_SEPARATOR) {
+                       buf[len] = G_DIR_SEPARATOR;
+                       buf[++len] = '\0';
                }
        }
 
-       adbookdir = g_strdup( buf );
-       strcat( buf, ADDRBOOK_PREFIX );
+       adbookdir = g_strdup(buf);
+       strcat(buf, ADDRBOOK_PREFIX);
 
-       if( ( dp = opendir( adbookdir ) ) == NULL ) {
+       if ((dp = opendir(adbookdir)) == NULL) {
                book->retVal = MGU_OPEN_DIRECTORY;
-               g_free( adbookdir );
+               g_free(adbookdir);
                return NULL;
        }
 
-       lenpre = strlen( ADDRBOOK_PREFIX );
-       lensuf = strlen( ADDRBOOK_SUFFIX );
+       lenpre = strlen(ADDRBOOK_PREFIX);
+       lensuf = strlen(ADDRBOOK_SUFFIX);
        lennum = FILE_NUMDIGITS + lenpre;
        maxval = -1;
 
-       while( ( entry = readdir( dp ) ) != NULL ) {
+       while ((entry = readdir(dp)) != NULL) {
                gchar *endptr = NULL;
                gint i;
                gboolean flg;
 
-               strcpy( buf, adbookdir );
-               strcat( buf, entry->d_name );
-               stat( buf, &statbuf );
-               if( S_IFREG & statbuf.st_mode ) {
-                       if( strncmp( entry->d_name, ADDRBOOK_PREFIX, lenpre ) == 0 ) {
-                               if( strncmp( (entry->d_name) + lennum, ADDRBOOK_SUFFIX, lensuf ) == 0 ) {
-                                       strncpy( numbuf, (entry->d_name) + lenpre, FILE_NUMDIGITS );
-                                       numbuf[ FILE_NUMDIGITS ] = '\0';
+               strcpy(buf, adbookdir);
+               strcat(buf, entry->d_name);
+               stat(buf, &statbuf);
+               if (S_IFREG & statbuf.st_mode) {
+                       if (strncmp(entry->d_name, ADDRBOOK_PREFIX, lenpre) == 0) {
+                               if (strncmp((entry->d_name) + lennum, ADDRBOOK_SUFFIX, lensuf) == 0) {
+                                       strncpy(numbuf, (entry->d_name) + lenpre, FILE_NUMDIGITS);
+                                       numbuf[FILE_NUMDIGITS] = '\0';
                                        flg = TRUE;
-                                       for( i = 0; i < FILE_NUMDIGITS; i++ ) {
-                                               if( ! strchr( ADDRBOOK_DIGITS, numbuf[i] ) ) {
+                                       for(i = 0; i < FILE_NUMDIGITS; i++) {
+                                               if(!strchr(ADDRBOOK_DIGITS, numbuf[i])) {
                                                        flg = FALSE;
                                                        break;
                                                }
                                        }
-                                       if( flg ) {
+                                       if (flg) {
                                                /* Get value */
-                                               val = strtol( numbuf, &endptr, 10 );
-                                               if( endptr  && val > -1 ) {
-                                                       if( val > maxval ) maxval = val;
-                                                       fileList = g_list_append( fileList, g_strdup( entry->d_name ) );
+                                               val = strtol(numbuf, &endptr, 10);
+                                               if (endptr  && val > -1) {
+                                                       if (val > maxval) maxval = val;
+                                                       fileList = g_list_append(fileList, g_strdup(entry->d_name));
                                                }
                                        }
                                }
                        }
                }
        }
-       closedir( dp );
-       g_free( adbookdir );
+       closedir(dp);
+       g_free(adbookdir);
 
        book->maxValue = maxval; 
        book->retVal = MGU_SUCCESS;
        return fileList;
 }
 
-/*
-* Return file name for specified file number.
-* Enter:  fileNum File number.
-* Return: File name, or NULL if file number too large. Should be g_free() when done.
-*/
-gchar *addrbook_gen_new_file_name( gint fileNum ) {
-       gchar fmt[ 30 ];
-       gchar buf[ WORK_BUFLEN ];
+/* Return file name for specified file number.
+   Enter:  fileNum File number.
+   Return: File name, or NULL if file number too large. Should be g_free() when done */
+gchar *addrbook_gen_new_file_name(gint fileNum) {
+       gchar fmt[30];
+       gchar buf[WORK_BUFLEN];
        gint n = fileNum;
        long int nmax;
 
-       if( n < 1 ) n = 1;
-       nmax = -1 + (long int) pow( 10, FILE_NUMDIGITS );
-       if( fileNum > nmax ) return NULL;
-       g_snprintf( fmt, sizeof(fmt), "%%s%%0%dd%%s", FILE_NUMDIGITS );
-       g_snprintf( buf, sizeof(buf), fmt, ADDRBOOK_PREFIX, n, ADDRBOOK_SUFFIX );
-       return g_strdup( buf );
+       if (n < 1) 
+               n = 1;
+       nmax = -1 + (long int) pow(10, FILE_NUMDIGITS);
+       if (fileNum > nmax)
+               return NULL;
+       g_snprintf(fmt, sizeof(fmt), "%%s%%0%dd%%s", FILE_NUMDIGITS);
+       g_snprintf(buf, sizeof(buf), fmt, ADDRBOOK_PREFIX, n, ADDRBOOK_SUFFIX);
+       return g_strdup(buf);
 }
 
 /* **********************************************************************
-* Address book test functions...
-* ***********************************************************************
+   Address book test functions...
+   **********************************************************************
 */
 
 /*
@@ -1762,277 +1748,256 @@ static void addrbook_chkparse_addr_list( AddressBookFile *book, XMLFile *file ){
 
        for (;;) {
                prev_level = file->level;
-               if( xml_parse_next_tag( file ) ) {
-                       longjmp( book->jumper, 1 );
-               }
-               if (file->level < prev_level) return;
+               if (xml_parse_next_tag(file))
+                       longjmp(book->jumper, 1);
+               if (file->level < prev_level)
+                       return;
                attr = xml_get_current_tag_attr(file);
                /* addrbook_show_attribs( attr ); */
-               if( xml_compare_tag( file, AB_ELTAG_ADDRESS ) ) {
-                       addrbook_chkparse_addr_list( book, file );
-               }
+               if (xml_compare_tag(file, AB_ELTAG_ADDRESS))
+                       addrbook_chkparse_addr_list(book, file);
        }
 }
 
-/*
-* Test user attributes for person.
-*/
-static void addrbook_chkparse_attribute( AddressBookFile *book, XMLFile *file ) {
+/* Test user attributes for person */
+static void addrbook_chkparse_attribute(AddressBookFile *book, XMLFile *file)
+{
        GList *attr;
        gchar *element;
 
        attr = xml_get_current_tag_attr(file);
        /* addrbook_show_attribs( attr ); */
-       element = xml_get_element( file );
+       element = xml_get_element(file);
        /* printf( "\t\tattrib value : %s\n", element ); */
 }
 
-/*
-* Test attribute list.
-*/
-static void addrbook_chkparse_attr_list( AddressBookFile *book, XMLFile *file ){
+/* Test attribute list */
+static void addrbook_chkparse_attr_list(AddressBookFile *book, XMLFile *file)
+{
        guint prev_level;
 
        for (;;) {
                prev_level = file->level;
-               if( xml_parse_next_tag( file ) ) {
-                       longjmp( book->jumper, 1 );
-               }
-               if (file->level < prev_level) return;
-               if( xml_compare_tag( file, AB_ELTAG_ATTRIBUTE ) ) {
-                       addrbook_chkparse_attribute( book, file );
-                       addrbook_chkparse_attr_list( book, file );
+               if (xml_parse_next_tag(file))
+                       longjmp(book->jumper, 1);
+               if (file->level < prev_level) 
+                       return;
+               if (xml_compare_tag(file, AB_ELTAG_ATTRIBUTE)) {
+                       addrbook_chkparse_attribute(book, file);
+                       addrbook_chkparse_attr_list(book, file);
                }
        }
 }
 
-/*
-* Test person.
-*/
-static void addrbook_chkparse_person( AddressBookFile *book, XMLFile *file ) {
+/* Test person */
+static void addrbook_chkparse_person(AddressBookFile *book, XMLFile *file)
+{
        GList *attr;
 
        attr = xml_get_current_tag_attr(file);
        /* addrbook_show_attribs( attr ); */
-       if( xml_parse_next_tag( file ) ) {      /* Consume closing tag */
-               longjmp( book->jumper, 1 );
-       }
-       if( xml_compare_tag( file, AB_ELTAG_ADDRESS_LIST ) ) {
-               addrbook_chkparse_addr_list( book, file );
-       }
-       if( xml_parse_next_tag( file ) ) {      /* Consume closing tag */
-               longjmp( book->jumper, 1 );
-       }
-       if( xml_compare_tag( file, AB_ELTAG_ATTRIBUTE_LIST ) ) {
-               addrbook_chkparse_attr_list( book, file );
-       }
+       if (xml_parse_next_tag(file)) /* Consume closing tag */
+               longjmp(book->jumper, 1);
+
+       if (xml_compare_tag(file, AB_ELTAG_ADDRESS_LIST))
+               addrbook_chkparse_addr_list(book, file);
+
+       if (xml_parse_next_tag(file))   /* Consume closing tag */
+               longjmp(book->jumper, 1);
+
+       if (xml_compare_tag(file, AB_ELTAG_ATTRIBUTE_LIST))
+               addrbook_chkparse_attr_list(book, file);
 }
 
-/*
-* Test group member list.
-*/
-static void addrbook_chkparse_member_list( AddressBookFile *book, XMLFile *file ){
+/* Test group member list */
+static void addrbook_chkparse_member_list(AddressBookFile *book, XMLFile *file)
+{
        GList *attr;
        guint prev_level;
 
        for (;;) {
                prev_level = file->level;
-               if( xml_parse_next_tag( file ) ) {
-                       longjmp( book->jumper, 1 );
-               }
-               if (file->level < prev_level) return;
-               if( xml_compare_tag( file, AB_ELTAG_MEMBER ) ) {
+               if (xml_parse_next_tag(file)) 
+                       longjmp(book->jumper, 1);
+
+               if (file->level < prev_level)
+                       return;
+                       
+               if (xml_compare_tag(file, AB_ELTAG_MEMBER)) {
                        attr = xml_get_current_tag_attr(file);
                        /* addrbook_show_attribs( attr ); */
-                       addrbook_chkparse_member_list( book, file );
+                       addrbook_chkparse_member_list(book, file);
                }
                else {
-                       attr = xml_get_current_tag_attr( file );
+                       attr = xml_get_current_tag_attr(file);
                        /* addrbook_show_attribs( attr ); */
                }
        }
 }
 
-/*
-* Test group.
-*/
-static void addrbook_chkparse_group( AddressBookFile *book, XMLFile *file ) {
+/* Test group */
+static void addrbook_chkparse_group(AddressBookFile *book, XMLFile *file)
+{
        GList *attr;
 
        attr = xml_get_current_tag_attr(file);
        /* addrbook_show_attribs( attr ); */
-       if( xml_parse_next_tag( file ) ) {      /* Consume closing tag */
-               longjmp( book->jumper, 1 );
-       }
-       if( xml_compare_tag( file, AB_ELTAG_MEMBER_LIST ) ) {
-               addrbook_chkparse_member_list( book, file );
-       }
+       if (xml_parse_next_tag(file))   /* Consume closing tag */
+               longjmp(book->jumper, 1);
+
+       if (xml_compare_tag(file, AB_ELTAG_MEMBER_LIST))
+               addrbook_chkparse_member_list(book, file);
 }
 
-/*
-* Test folder item list.
-*/
-static void addrbook_chkparse_folder_list( AddressBookFile *book, XMLFile *file ){
+/* Test folder item list */
+static void addrbook_chkparse_folder_list(AddressBookFile *book, XMLFile *file)
+{
        GList *attr;
        guint prev_level;
 
        for (;;) {
                prev_level = file->level;
-               if( xml_parse_next_tag( file ) ) {
-                       longjmp( book->jumper, 1 );
-               }
-               if (file->level < prev_level) return;
-               if( xml_compare_tag( file, AB_ELTAG_ITEM ) ) {
+               if (xml_parse_next_tag(file))
+                       longjmp(book->jumper, 1);
+
+               if (file->level < prev_level)
+                       return;
+                       
+               if (xml_compare_tag(file, AB_ELTAG_ITEM)) {
                        attr = xml_get_current_tag_attr(file);
                        /* addrbook_show_attribs( attr ); */
-                       addrbook_chkparse_folder_list( book, file );
+                       addrbook_chkparse_folder_list(book, file);
                }
                else {
-                       attr = xml_get_current_tag_attr( file );
+                       attr = xml_get_current_tag_attr(file);
                        /* addrbook_show_attribs( attr ); */
                }
        }
 }
 
-/*
-* Test folder.
-*/
-static void addrbook_chkparse_folder( AddressBookFile *book, XMLFile *file ) {
+/* Test folder */
+static void addrbook_chkparse_folder(AddressBookFile *book, XMLFile *file)
+{
        GList *attr;
 
        attr = xml_get_current_tag_attr(file);
        /* addrbook_show_attribs( attr ); */
-       if( xml_parse_next_tag( file ) ) {      /* Consume closing tag */
-               longjmp( book->jumper, 1 );
-       }
-       if( xml_compare_tag( file, AB_ELTAG_ITEM_LIST ) ) {
-               addrbook_chkparse_folder_list( book, file );
-       }
+       if (xml_parse_next_tag(file))   /* Consume closing tag */
+               longjmp(book->jumper, 1);
+
+       if (xml_compare_tag(file, AB_ELTAG_ITEM_LIST))
+               addrbook_chkparse_folder_list(book, file);
 }
 
-/*
-* Test address book.
-*/
-static gboolean addrbook_chkread_tree( AddressBookFile *book, XMLFile *file ) {
+/* Test address book */
+static gboolean addrbook_chkread_tree(AddressBookFile *book, XMLFile *file)
+{
        GList *attr;
        gboolean retVal;
 
-       if( xml_get_dtd( file ) ) {
+       if (xml_get_dtd(file))
                return FALSE;
-       }
-       if( xml_parse_next_tag( file ) ) {
+
+       if (xml_parse_next_tag(file))
                return FALSE;
-       }
 
-       if( ! xml_compare_tag( file, AB_ELTAG_ADDRESS_BOOK ) ) {
+       if (!xml_compare_tag(file, AB_ELTAG_ADDRESS_BOOK))
                return FALSE;
-       }
 
        attr = xml_get_current_tag_attr(file);
        /* addrbook_show_attribs( attr ); */
 
        retVal = TRUE;
        for (;;) {
-               if (! file->level ) break;
+               if (!file->level) 
+                       break;
                /* Get item tag */
-               if( xml_parse_next_tag( file ) ) {
-                       longjmp( book->jumper, 1 );
-               }
+               if (xml_parse_next_tag(file))
+                       longjmp(book->jumper, 1);
+                       
                /* Get next tag (person, group or folder) */
-               if( xml_compare_tag( file, AB_ELTAG_PERSON ) ) {
+               if (xml_compare_tag(file, AB_ELTAG_PERSON))
                        addrbook_chkparse_person( book, file );
-               }
-               else if( xml_compare_tag( file, AB_ELTAG_GROUP ) ) {
-                       addrbook_chkparse_group( book, file );
-               }
-               else if( xml_compare_tag( file, AB_ELTAG_FOLDER ) ) {
-                       addrbook_chkparse_folder( book, file );
-               }
+               else if (xml_compare_tag(file, AB_ELTAG_GROUP))
+                       addrbook_chkparse_group(book, file);
+               else if (xml_compare_tag(file, AB_ELTAG_FOLDER))
+                       addrbook_chkparse_folder(book, file);
        }
        return retVal;
 }
 
-/*
-* Test address book file by parsing contents.
-* Enter: book     Address book file to check.
-*        fileName File name to check.
-* Return: MGU_SUCCESS if file appears to be valid format.
-*/
-gint addrbook_test_read_file( AddressBookFile *book, gchar *fileName ) {
+/* Test address book file by parsing contents.
+   Enter: book     Address book file to check.
+          fileName File name to check.
+   Return: MGU_SUCCESS if file appears to be valid format */
+gint addrbook_test_read_file(AddressBookFile *book, gchar *fileName)
+{
        XMLFile *file = NULL;
        gchar *fileSpec = NULL;
 
-       g_return_val_if_fail( book != NULL, -1 );
+       g_return_val_if_fail(book != NULL, -1);
 
-       fileSpec = g_strconcat( book->path, G_DIR_SEPARATOR_S, fileName, NULL );
+       fileSpec = g_strconcat(book->path, G_DIR_SEPARATOR_S, fileName, NULL);
        book->retVal = MGU_OPEN_FILE;
-       file = xml_open_file( fileSpec );
-       g_free( fileSpec );
-       if( file ) {
+       file = xml_open_file(fileSpec);
+       g_free(fileSpec);
+       if (file) {
                book->retVal = MGU_BAD_FORMAT;
-               if( setjmp( book->jumper ) ) {
+               if (setjmp(book->jumper)) {
                        /* printf( "Caught Ya!!!\n" ); */
-                       xml_close_file( file );
+                       xml_close_file(file);
                        return book->retVal;
                }
-               if( addrbook_chkread_tree( book, file ) ) {
+               if (addrbook_chkread_tree(book, file))
                        book->retVal = MGU_SUCCESS;
-               }
+
                xml_close_file( file );
        }
        return book->retVal;
 }
 
-/*
-* Return link list of all persons in address book.  Note that the list contains
-* references to items. Do *NOT* attempt to use the addrbook_free_xxx() functions...
-* this will destroy the addressbook data!
-* Return: List of items, or NULL if none.
-*/
-GList *addrbook_get_all_persons( AddressBookFile *book ) {
-       g_return_val_if_fail( book != NULL, NULL );
-       return addrcache_get_all_persons( book->addressCache );
-}
-
-/*
-* Add person and address data to address book.
-* Enter: book      Address book.
-*        folder    Folder where to add person, or NULL for root folder.
-*        name      Common name.
-*        address   EMail address.
-*        remarks   Remarks.
-* Return: Person added. Do not *NOT* to use the addrbook_free_xxx() functions...
-* this will destroy the address book data.
-*/
-ItemPerson *addrbook_add_contact( AddressBookFile *book, ItemFolder *folder, const gchar *name,
-               const gchar *address, const gchar *remarks )
+/* Return link list of all persons in address book.  Note that the list contains
+   references to items. Do *NOT* attempt to use the addrbook_free_xxx() functions...
+   this will destroy the addressbook data!
+   Return: List of items, or NULL if none */
+GList *addrbook_get_all_persons(AddressBookFile *book)
+{
+       g_return_val_if_fail(book != NULL, NULL);
+       return addrcache_get_all_persons(book->addressCache);
+}
+
+/* Add person and address data to address book.
+   Enter: book      Address book.
+          folder    Folder where to add person, or NULL for root folder.
+          name      Common name.
+          address   EMail address.
+          remarks   Remarks.
+   Return: Person added. Do not *NOT* to use the addrbook_free_xxx() functions...
+   this will destroy the address book data */
+ItemPerson *addrbook_add_contact(AddressBookFile *book, ItemFolder *folder, 
+                                const gchar *name,const gchar *address, 
+                                const gchar *remarks)
 {
-       g_return_val_if_fail( book != NULL, NULL );
-       return addrcache_add_contact( book->addressCache, folder, name, address, remarks );
+       g_return_val_if_fail(book != NULL, NULL);
+       return addrcache_add_contact(book->addressCache, folder, name, address, 
+                                    remarks);
 }
 
-/*
- * Return file name for next address book file.
- * Enter:  book Address book.
- * Return: File name, or NULL if could not create. This should be g_free()
- *         when done.
- */
-gchar *addrbook_guess_next_file( AddressBookFile *book ) {
+/* Return file name for next address book file.
+   Enter:  book Address book.
+   Return: File name, or NULL if could not create. This should be g_free()
+           when done */
+gchar *addrbook_guess_next_file(AddressBookFile *book)
+{
        gchar *newFile = NULL;
        GList *fileList = NULL;
        gint fileNum = 1;
-       fileList = addrbook_get_bookfile_list( book );
-       if( fileList ) {
+       fileList = addrbook_get_bookfile_list(book);
+       if (fileList)
                fileNum = 1 + book->maxValue;
-       }
-       newFile = addrbook_gen_new_file_name( fileNum );
-       g_list_free( fileList );
+       
+       newFile = addrbook_gen_new_file_name(fileNum);
+       g_list_free(fileList);
        fileList = NULL;
        return newFile;
 }
-
-/*
-* End of Source.
-*/
-
-