src/addritem.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 2001 Match Grun
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * General primitive address item objects.
  22  */
  23
  24 #include <stdio.h>
  25 #include <glib.h>
  26
  27 #include "addritem.h"
  28 #include "mgutils.h"
  29
  30 /*
  31 * Create new email address item.
  32 */
  33 ItemEMail *addritem_create_item_email( void ) {
  34         ItemEMail *item;
  35         item = g_new0( ItemEMail, 1 );
  36         ADDRITEM_TYPE(item) = ITEMTYPE_EMAIL;
  37         ADDRITEM_ID(item) = NULL;
  38         ADDRITEM_NAME(item) = NULL;
  39         ADDRITEM_PARENT(item) = NULL;
  40         ADDRITEM_SUBTYPE(item) = 0;
  41         item->address = NULL;
  42         item->remarks = NULL;
  43         return item;
  44 }
  45
  46 /*
  47 * Create copy of specified email address item.
  48 */
  49 ItemEMail *addritem_copy_item_email( ItemEMail *item ) {
  50         ItemEMail *itemNew = NULL;
  51         if( item ) {
  52                 itemNew = addritem_create_item_email();
  53                 ADDRITEM_TYPE(itemNew) = ADDRITEM_TYPE(item);
  54                 ADDRITEM_ID(itemNew) = g_strdup( ADDRITEM_ID(item) );
  55                 ADDRITEM_NAME(itemNew) = g_strdup( ADDRITEM_NAME(item) );
  56                 ADDRITEM_PARENT(itemNew) = ADDRITEM_PARENT(item);
  57                 itemNew->address = g_strdup( item->address );
  58                 itemNew->remarks = g_strdup( item->remarks );
  59         }
  60         return itemNew;
  61 }
  62
  63 void addritem_email_set_id( ItemEMail *email, const gchar *value ) {
  64         ADDRITEM_ID(email) = mgu_replace_string( ADDRITEM_ID(email), value );
  65 }
  66 void addritem_email_set_alias( ItemEMail *email, const gchar *value ) {
  67         ADDRITEM_NAME(email) = mgu_replace_string( ADDRITEM_NAME(email), value );
  68 }
  69 void addritem_email_set_address( ItemEMail *email, const gchar *value ) {
  70         email->address = mgu_replace_string( email->address, value );
  71 }
  72 void addritem_email_set_remarks( ItemEMail *email, const gchar *value ) {
  73         email->remarks = mgu_replace_string( email->remarks, value );
  74 }
  75
  76 /*
  77 * Free address item email.
  78 */
  79 void addritem_free_item_email( ItemEMail *item ) {
  80         g_return_if_fail( item != NULL );
  81
  82         /* Free internal stuff */
  83         g_free( ADDRITEM_ID(item) );
  84         g_free( ADDRITEM_NAME(item) );
  85         g_free( item->address );
  86         g_free( item->remarks );
  87
  88         ADDRITEM_OBJECT(item)->type = ITEMTYPE_NONE;
  89         ADDRITEM_ID(item) = NULL;
  90         ADDRITEM_NAME(item) = NULL;
  91         ADDRITEM_PARENT(item) = NULL;
  92         ADDRITEM_SUBTYPE(item) = 0;
  93         item->address = NULL;
  94         item->remarks = NULL;
  95         g_free( item );
  96 }
  97
  98 /*
  99 * Create new attribute.
 100 */
 101 UserAttribute *addritem_create_attribute( void ) {
 102         UserAttribute *item;
 103         item = g_new0( UserAttribute, 1 );
 104         item->uid = NULL;
 105         item->name = NULL;
 106         item->value = NULL;
 107         return item;
 108 }
 109
 110 /*
 111 * Create copy of specified attribute.
 112 */
 113 UserAttribute *addritem_copy_attribute( UserAttribute *item ) {
 114         UserAttribute *itemNew = NULL;
 115         if( item ) {
 116                 itemNew = addritem_create_attribute();
 117                 itemNew->uid = g_strdup( item->uid );
 118                 itemNew->name = g_strdup( item->name );
 119                 itemNew->value = g_strdup( item->value );
 120         }
 121         return itemNew;
 122 }
 123
 124 void addritem_attrib_set_id( UserAttribute *item, const gchar *value ) {
 125         g_return_if_fail( item != NULL );
 126         item->uid = mgu_replace_string( item->uid, value );
 127 }
 128 void addritem_attrib_set_name( UserAttribute *item, const gchar *value ) {
 129         g_return_if_fail( item != NULL );
 130         item->name = mgu_replace_string( item->name, value );
 131 }
 132 void addritem_attrib_set_value( UserAttribute *item, const gchar *value ) {
 133         g_return_if_fail( item != NULL );
 134         item->value = mgu_replace_string( item->value, value );
 135 }
 136
 137 /*
 138 * Free user attribute.
 139 */
 140 void addritem_free_attribute( UserAttribute *item ) {
 141         g_return_if_fail( item != NULL );
 142         g_free( item->uid );
 143         g_free( item->name );
 144         g_free( item->value );
 145         item->uid = NULL;
 146         item->name = NULL;
 147         item->value = NULL;
 148         g_free( item );
 149 }
 150
 151 /*
 152 * Create new address book person.
 153 */
 154 ItemPerson *addritem_create_item_person( void ) {
 155         ItemPerson *person;
 156         person = g_new0( ItemPerson, 1 );
 157         ADDRITEM_TYPE(person) = ITEMTYPE_PERSON;
 158         ADDRITEM_ID(person) = NULL;
 159         ADDRITEM_NAME(person) = NULL;
 160         ADDRITEM_PARENT(person) = NULL;
 161         ADDRITEM_SUBTYPE(person) = 0;
 162         person->firstName = NULL;
 163         person->lastName = NULL;
 164         person->nickName = NULL;
 165         person->listEMail = NULL;
 166         person->listAttrib = NULL;
 167         person->externalID = NULL;
 168         person->isOpened = FALSE;
 169         return person;
 170 }
 171
 172 void addritem_person_set_id( ItemPerson *person, const gchar *value ) {
 173         ADDRITEM_ID(person) = mgu_replace_string( ADDRITEM_ID(person), value );
 174 }
 175 void addritem_person_set_first_name( ItemPerson *person, const gchar *value ) {
 176         person->firstName = mgu_replace_string( person->firstName, value );
 177 }
 178 void addritem_person_set_last_name( ItemPerson *person, const gchar *value ) {
 179         person->lastName = mgu_replace_string( person->lastName, value );
 180 }
 181 void addritem_person_set_nick_name( ItemPerson *person, const gchar *value ) {
 182         person->nickName = mgu_replace_string( person->nickName, value );
 183 }
 184 void addritem_person_set_common_name( ItemPerson *person, const gchar *value ) {
 185         ADDRITEM_NAME(person) = mgu_replace_string( ADDRITEM_NAME(person), value );
 186 }
 187 void addritem_person_set_external_id( ItemPerson *person, const gchar *value ) {
 188         person->externalID = mgu_replace_string( person->externalID, value );
 189 }
 190 void addritem_person_set_opened( ItemPerson *person, const gboolean value ) {
 191         person->isOpened = value;
 192 }
 193
 194 /*
 195 * Free linked list of item addresses.
 196 */
 197 void addritem_free_list_email( GList *list ) {
 198         GList *node = list;
 199         while( node ) {
 200                 addritem_free_item_email( node->data );
 201                 node->data = NULL;
 202                 node = g_list_next( node );
 203         }
 204         g_list_free( list );
 205 }
 206
 207 /*
 208 * Free linked list of attributes.
 209 */
 210 void addritem_free_list_attribute( GList *list ) {
 211         GList *node = list;
 212         while( node ) {
 213                 addritem_free_attribute( node->data );
 214                 node->data = NULL;
 215                 node = g_list_next( node );
 216         }
 217         g_list_free( list );
 218 }
 219
 220 /*
 221 * Free address person.
 222 */
 223 void addritem_free_item_person( ItemPerson *person ) {
 224         g_return_if_fail( person != NULL );
 225
 226         /* Free internal stuff */
 227         g_free( ADDRITEM_ID(person) );
 228         g_free( ADDRITEM_NAME(person) );
 229         g_free( person->firstName );
 230         g_free( person->lastName );
 231         g_free( person->nickName );
 232         g_free( person->externalID );
 233         addritem_free_list_email( person->listEMail );
 234         addritem_free_list_attribute( person->listAttrib );
 235
 236         ADDRITEM_OBJECT(person)->type = ITEMTYPE_NONE;
 237         ADDRITEM_ID(person) = NULL;
 238         ADDRITEM_NAME(person) = NULL;
 239         ADDRITEM_PARENT(person) = NULL;
 240         ADDRITEM_SUBTYPE(person) = 0;
 241         person->firstName = NULL;
 242         person->lastName = NULL;
 243         person->nickName = NULL;
 244         person->externalID = NULL;
 245         person->listEMail = NULL;
 246         person->listAttrib = NULL;
 247
 248         g_free( person );
 249 }
 250
 251 /*
 252 * Print address item.
 253 */
 254 void addritem_print_item_email( ItemEMail *item, FILE *stream ) {
 255         g_return_if_fail( item != NULL );
 256         fprintf( stream, "\t\tt/id: %d : '%s'\n", ADDRITEM_TYPE(item), ADDRITEM_ID(item) );
 257         fprintf( stream, "\t\tsubty: %d\n", ADDRITEM_SUBTYPE(item) );
 258         fprintf( stream, "\t\talis: '%s'\n", ADDRITEM_NAME(item) );
 259         fprintf( stream, "\t\taddr: '%s'\n", item->address );
 260         fprintf( stream, "\t\trems: '%s'\n", item->remarks );
 261         fprintf( stream, "\t\t---\n" );
 262 }
 263
 264 /*
 265 * Print user attribute.
 266 */
 267 void addritem_print_attribute( UserAttribute *item, FILE *stream ) {
 268         g_return_if_fail( item != NULL );
 269         fprintf( stream, "\t\tuid  : '%s'\n", item->uid );
 270         fprintf( stream, "\t\tname : '%s'\n", item->name );
 271         fprintf( stream, "\t\tvalue: '%s'\n", item->value );
 272         fprintf( stream, "\t\t---\n" );
 273 }
 274
 275 /*
 276 * Print person item.
 277 */
 278 void addritem_print_item_person( ItemPerson *person, FILE *stream ) {
 279         GList *node;
 280         g_return_if_fail( person != NULL );
 281         fprintf( stream, "Person:\n" );
 282         fprintf( stream, "\tt/uid: %d : '%s'\n", ADDRITEM_TYPE(person), ADDRITEM_ID(person) );
 283         fprintf( stream, "\tsubty: %d\n", ADDRITEM_SUBTYPE(person) );
 284         fprintf( stream, "\tcommn: '%s'\n", ADDRITEM_NAME(person) );
 285         fprintf( stream, "\tfirst: '%s'\n", person->firstName );
 286         fprintf( stream, "\tlast : '%s'\n", person->lastName );
 287         fprintf( stream, "\tnick : '%s'\n", person->nickName );
 288         fprintf( stream, "\textID: '%s'\n", person->externalID );
 289         fprintf( stream, "\teMail:\n" );
 290         fprintf( stream, "\t---\n" );
 291         node = person->listEMail;
 292         while( node ) {
 293                 addritem_print_item_email( node->data, stream );
 294                 node = g_list_next( node );
 295         }
 296         fprintf( stream, "\tuAttr:\n" );
 297         fprintf( stream, "\t---\n" );
 298         node = person->listAttrib;
 299         while( node ) {
 300                 addritem_print_attribute( node->data, stream );
 301                 node = g_list_next( node );
 302         }
 303         fprintf( stream, "\t===\n" );
 304 }
 305
 306 /*
 307 * Add EMail address to person.
 308 * return: TRUE if item added.
 309 */
 310 gboolean addritem_person_add_email( ItemPerson *person, ItemEMail *email ) {
 311         GList *node;
 312
 313         g_return_val_if_fail( person != NULL, FALSE );
 314         g_return_val_if_fail( email != NULL, FALSE );
 315
 316         node = person->listEMail;
 317         while( node ) {
 318                 if( node->data == email ) return FALSE;
 319                 node = g_list_next( node );
 320         }
 321         person->listEMail = g_list_append( person->listEMail, email );
 322         ADDRITEM_PARENT(email) = ADDRITEM_OBJECT(person);
 323         return TRUE;
 324 }
 325
 326 /*
 327 * Return email object with specified ID.
 328 * param: person Person object.
 329 *        eid    EMail ID.
 330 * return: EMail object, or NULL if not found.
 331 */
 332 ItemEMail *addritem_person_get_email( ItemPerson *person, const gchar *eid ) {
 333         ItemEMail *email = NULL;
 334         GList *node;
 335
 336         g_return_val_if_fail( person != NULL, NULL );
 337         if( eid == NULL || *eid == '\0' ) return NULL;
 338
 339         /* Look for email */
 340         node = person->listEMail;
 341         while( node ) {
 342                 AddrItemObject *objE = node->data;
 343                 gchar *ide = ADDRITEM_ID(objE);
 344                 if( ide ) {
 345                         if( strcmp( ide, eid ) == 0 ) {
 346                                 email = ( ItemEMail * ) objE;
 347                         }
 348                 }
 349                 node = g_list_next( node );
 350         }
 351         return email;
 352 }
 353
 354 /*
 355 * Remove email address for specified person.
 356 * param: person Person object.
 357 *        eid    EMail ID.
 358 * return: EMail object, or NULL if not found. Note that object should still be freed.
 359 */
 360 ItemEMail *addritem_person_remove_email_id( ItemPerson *person, const gchar *eid ) {
 361         ItemEMail *email = NULL;
 362         GList *node;
 363
 364         g_return_val_if_fail( person != NULL, NULL );
 365         if( eid == NULL || *eid == '\0' ) return NULL;
 366
 367         /* Look for email */
 368         node = person->listEMail;
 369         while( node ) {
 370                 AddrItemObject *objE = node->data;
 371                 gchar *ide = ADDRITEM_ID(objE);
 372                 if( ide ) {
 373                         if( strcmp( ide, eid ) == 0 ) {
 374                                 email = ( ItemEMail * ) objE;
 375                         }
 376                 }
 377                 node = g_list_next( node );
 378         }
 379
 380         if( email ) {
 381                 /* Remove email from person's address list */
 382                 if( person->listEMail ) {
 383                         person->listEMail = g_list_remove( person->listEMail, email );
 384                 }
 385                 /* Unlink reference to person. */
 386                 ADDRITEM_PARENT(email) = NULL;
 387         }
 388         return email;
 389 }
 390
 391 /*
 392 * Remove email address for specified.
 393 * param: person Person.
 394 *        email  EMail to remove.
 395 * return: EMail object, or NULL if not found. Note that object should still be freed.
 396 */
 397 ItemEMail *addritem_person_remove_email( ItemPerson *person, ItemEMail *email ) {
 398         gboolean found = FALSE;
 399         GList *node;
 400
 401         g_return_val_if_fail( person != NULL, NULL );
 402         if( email == NULL ) return NULL;
 403
 404         /* Look for email */
 405         node = person->listEMail;
 406         while( node ) {
 407                 if( node-> data == email ) {
 408                         found = TRUE;
 409                         break;
 410                 }
 411                 node = g_list_next( node );
 412         }
 413
 414         if( found ) {
 415                 /* Remove email from person's address list */
 416                 if( person->listEMail ) {
 417                         person->listEMail = g_list_remove( person->listEMail, email );
 418                 }
 419                 /* Unlink reference to person. */
 420                 ADDRITEM_PARENT(email) = NULL;
 421                 return email;
 422         }
 423         return NULL;
 424 }
 425
 426 /*
 427 * Add user attribute to person.
 428 * return: TRUE if item added.
 429 */
 430 void addritem_person_add_attribute( ItemPerson *person, UserAttribute *attrib ) {
 431         g_return_if_fail( person != NULL );
 432         person->listAttrib = g_list_append( person->listAttrib, attrib );
 433 }
 434
 435 /*
 436 * Return attribute with specified ID.
 437 * param: person Person object.
 438 *        aid    Attribute ID.
 439 * return: UserAttribute object, or NULL if not found. Note that object should still be freed.
 440 */
 441 UserAttribute *addritem_person_get_attribute( ItemPerson *person, const gchar *aid ) {
 442         UserAttribute *attrib = NULL;
 443         GList *node;
 444
 445         g_return_val_if_fail( person != NULL, NULL );
 446         if( aid == NULL || *aid == '\0' ) return NULL;
 447
 448         /* Look for attribute */
 449         node = person->listAttrib;
 450         while( node ) {
 451                 UserAttribute *attr = node->data;
 452                 gchar *ida = attr->uid;
 453                 if( ida ) {
 454                         if( strcmp( ida, aid ) == 0 ) {
 455                                 attrib = attr;
 456                         }
 457                 }
 458                 node = g_list_next( node );
 459         }
 460         return attrib;
 461 }
 462
 463 /*
 464 * Remove attribute from person.
 465 * param: person Person object.
 466 *        aid    Attribute ID.
 467 * return: UserAttribute object, or NULL if not found. Note that object should still be freed.
 468 */
 469 UserAttribute *addritem_person_remove_attrib_id( ItemPerson *person, const gchar *aid ) {
 470         UserAttribute *attrib = NULL;
 471         GList *node;
 472
 473         g_return_val_if_fail( person != NULL, NULL );
 474         if( aid == NULL || *aid == '\0' ) return NULL;
 475
 476         /* Look for attribute */
 477         node = person->listAttrib;
 478         while( node ) {
 479                 UserAttribute *attr = node->data;
 480                 gchar *ida = attr->uid;
 481                 if( ida ) {
 482                         if( strcmp( ida, aid ) == 0 ) {
 483                                 attrib = attr;
 484                         }
 485                 }
 486                 node = g_list_next( node );
 487         }
 488
 489         /* Remove email from person's address list */
 490         if( person->listAttrib ) {
 491                 person->listAttrib = g_list_remove( person->listAttrib, attrib );
 492         }
 493         return attrib;
 494 }
 495
 496 /*
 497 * Remove attribute from person.
 498 * param: person Person.
 499 *        attrib Attribute to remove.
 500 * return: UserAttribute object. Note that object should still be freed.
 501 */
 502 UserAttribute *addritem_person_remove_attribute( ItemPerson *person, UserAttribute *attrib ) {
 503         gboolean found = FALSE;
 504         GList *node;
 505
 506         g_return_val_if_fail( person != NULL, NULL );
 507         if( attrib == NULL ) return NULL;
 508
 509         /* Look for attribute */
 510         node = person->listAttrib;
 511         while( node ) {
 512                 if( node-> data == attrib ) {
 513                         found = TRUE;
 514                         break;
 515                 }
 516                 node = g_list_next( node );
 517         }
 518
 519         if( found ) {
 520                 /* Remove attribute */
 521                 if( person->listAttrib ) {
 522                         person->listAttrib = g_list_remove( person->listAttrib, attrib );
 523                 }
 524         }
 525         return attrib;
 526 }
 527
 528 /*
 529 * Create new address book group.
 530 */
 531 ItemGroup *addritem_create_item_group( void ) {
 532         ItemGroup *group;
 533
 534         group = g_new0( ItemGroup, 1 );
 535         ADDRITEM_TYPE(group) = ITEMTYPE_GROUP;
 536         ADDRITEM_ID(group) = NULL;
 537         ADDRITEM_NAME(group) = NULL;
 538         ADDRITEM_PARENT(group) = NULL;
 539         ADDRITEM_SUBTYPE(group) = 0;
 540         group->remarks = NULL;
 541         group->listEMail = NULL;
 542         return group;
 543 }
 544
 545 /*
 546 * Specify name to be used.
 547 */
 548 void addritem_group_set_id( ItemGroup *group, const gchar *value ) {
 549         ADDRITEM_ID(group) = mgu_replace_string( ADDRITEM_ID(group), value );
 550 }
 551 void addritem_group_set_name( ItemGroup *group, const gchar *value ) {
 552         ADDRITEM_NAME(group) = mgu_replace_string( ADDRITEM_NAME(group), value );
 553 }
 554 void addritem_group_set_remarks( ItemGroup *group, const gchar *value ) {
 555         group->remarks = mgu_replace_string( group->remarks, value );
 556 }
 557
 558 /*
 559 * Free address group.
 560 */
 561 void addritem_free_item_group( ItemGroup *group ) {
 562         g_return_if_fail( group != NULL );
 563
 564         /* Free internal stuff */
 565         g_free( ADDRITEM_ID(group) );
 566         g_free( ADDRITEM_NAME(group) );
 567         g_free( group->remarks );
 568         mgu_clear_list( group->listEMail );
 569         g_list_free( group->listEMail );
 570
 571         ADDRITEM_TYPE(group) = ITEMTYPE_NONE;
 572         ADDRITEM_ID(group) = NULL;
 573         ADDRITEM_NAME(group) = NULL;
 574         ADDRITEM_PARENT(group) = NULL;
 575         ADDRITEM_SUBTYPE(group) = 0;
 576         group->remarks = NULL;
 577         group->listEMail = NULL;
 578
 579         g_free( group );
 580 }
 581
 582 /*
 583 * Add EMail address to group.
 584 * return: TRUE if item added.
 585 */
 586 gboolean addritem_group_add_email( ItemGroup *group, ItemEMail *email ) {
 587         GList *node;
 588
 589         g_return_val_if_fail( group != NULL, FALSE );
 590         g_return_val_if_fail( email != NULL, FALSE );
 591
 592         node = group->listEMail;
 593         while( node ) {
 594                 if( node->data == email ) return FALSE;
 595                 node = g_list_next( node );
 596         }
 597         group->listEMail = g_list_append( group->listEMail, email );
 598         return TRUE;
 599 }
 600
 601 /*
 602 * Remove email address for specified group.
 603 * param: group  Group from which to remove address.
 604 *        email  EMail to remove
 605 * return: EMail object, or NULL if email not found in group. Note that this object is
 606 * referenced (linked) to a group and should *NOT* be freed. This object should only be
 607 * freed after removing from a person.
 608 */
 609 ItemEMail *addritem_group_remove_email( ItemGroup *group, ItemEMail *email ) {
 610         if( group && email ) {
 611                 GList *node = group->listEMail;
 612                 while( node ) {
 613                         if( node->data == email ) {
 614                                 group->listEMail = g_list_remove( group->listEMail, email );
 615                                 return email;
 616                         }
 617                         node = g_list_next( node );
 618                 }
 619         }
 620         return NULL;
 621 }
 622
 623 /*
 624 * Remove email address for specified group and ID.
 625 * param: group  Group from which to remove address.
 626 *        eid    EMail ID.
 627 * return: EMail object, or NULL if email not found in group. Note that this object is
 628 * referenced (linked) to a group and should *NOT* be freed. This object should only be
 629 * freed after removing from a person.
 630 */
 631 ItemEMail *addritem_group_remove_email_id( ItemGroup *group, const gchar *eid ) {
 632         if( group ) {
 633                 GList *node = group->listEMail;
 634                 while( node ) {
 635                         ItemEMail *email = ( ItemEMail * ) node->data;
 636                         if( strcmp( ADDRITEM_ID( email ), eid ) == 0 ) {
 637                                 group->listEMail = g_list_remove( group->listEMail, email );
 638                                 return email;
 639                         }
 640                         node = g_list_next( node );
 641                 }
 642         }
 643         return NULL;
 644 }
 645
 646 /*
 647 * Print address group item.
 648 */
 649 void addritem_print_item_group( ItemGroup *group, FILE *stream ) {
 650         GList *node;
 651         ItemPerson *person;
 652         ItemEMail *item;
 653         g_return_if_fail( group != NULL );
 654         fprintf( stream, "Group:\n" );
 655         fprintf( stream, "\tt/u: %d : '%s'\n", ADDRITEM_TYPE(group), ADDRITEM_ID(group) );
 656         fprintf( stream, "\tsub: %d\n", ADDRITEM_SUBTYPE(group) );
 657         fprintf( stream, "\tgrp: '%s'\n", ADDRITEM_NAME(group) );
 658         fprintf( stream, "\trem: '%s'\n", group->remarks );
 659         fprintf( stream, "\t---\n" );
 660         node = group->listEMail;
 661         while( node ) {
 662                 item = node->data;
 663                 person = ( ItemPerson * ) ADDRITEM_PARENT(item);
 664                 if( person ) {
 665                         fprintf( stream, "\t\tpid : '%s'\n", ADDRITEM_ID(person) );
 666                         fprintf( stream, "\t\tcomn: '%s'\n", ADDRITEM_NAME(person) );
 667                 }
 668                 else {
 669                         fprintf( stream, "\t\tpid : ???\n" );
 670                         fprintf( stream, "\t\tcomn: ???\n" );
 671                 }
 672                 addritem_print_item_email( item, stream );
 673                 node = g_list_next( node );
 674         }
 675         fprintf( stream, "\t***\n" );
 676 }
 677
 678 /*
 679 * Create new address folder.
 680 */
 681 ItemFolder *addritem_create_item_folder( void ) {
 682         ItemFolder *folder;
 683         folder = g_new0( ItemFolder, 1 );
 684         ADDRITEM_TYPE(folder) = ITEMTYPE_FOLDER;
 685         ADDRITEM_ID(folder) = NULL;
 686         ADDRITEM_NAME(folder) = NULL;
 687         ADDRITEM_PARENT(folder) = NULL;
 688         ADDRITEM_SUBTYPE(folder) = 0;
 689         folder->remarks = NULL;
 690         folder->isRoot = FALSE;
 691         folder->listItems = NULL;
 692         folder->listFolder = NULL;
 693         folder->listPerson = NULL;
 694         folder->listGroup = NULL;
 695         folder->userData = NULL;
 696         return folder;
 697 }
 698
 699 /*
 700 * Specify name to be used.
 701 */
 702 void addritem_folder_set_id( ItemFolder *folder, const gchar *value ) {
 703         ADDRITEM_ID(folder) = mgu_replace_string( ADDRITEM_ID(folder), value );
 704 }
 705 void addritem_folder_set_name( ItemFolder *folder, const gchar *value ) {
 706         ADDRITEM_NAME(folder) = mgu_replace_string( ADDRITEM_NAME(folder), value );
 707 }
 708 void addritem_folder_set_remarks( ItemFolder *folder, const gchar *value ) {
 709         folder->remarks = mgu_replace_string( folder->remarks, value );
 710 }
 711
 712 /*
 713 * Free address folder. Note: this does not free up the lists of children
 714 * (folders, groups and person). This should be done prior to calling this
 715 * function.
 716 */
 717 void addritem_free_item_folder( ItemFolder *folder ) {
 718         g_return_if_fail( folder != NULL );
 719
 720         /* Free internal stuff */
 721         g_free( ADDRITEM_ID(folder) );
 722         g_free( ADDRITEM_NAME(folder) );
 723         g_free( folder->remarks );
 724         mgu_clear_list( folder->listItems );
 725         g_list_free( folder->listItems );
 726
 727         ADDRITEM_TYPE(folder) = ITEMTYPE_NONE;
 728         ADDRITEM_ID(folder) = NULL;
 729         ADDRITEM_NAME(folder) = NULL;
 730         ADDRITEM_PARENT(folder) = NULL;
 731         ADDRITEM_SUBTYPE(folder) = 0;
 732         folder->isRoot = FALSE;
 733         folder->remarks = NULL;
 734         folder->listItems = NULL;
 735         folder->listFolder = NULL;
 736         folder->listGroup = NULL;
 737         folder->listPerson = NULL;
 738
 739         g_free( folder->userData );
 740         folder->userData = NULL;
 741
 742         g_free( folder );
 743 }
 744
 745 /*
 746 * Free up folders recursively. Note: this does not free up the lists of children
 747 * (folders, groups and person). This should be done prior to calling this
 748 * function.
 749 */
 750 void addritem_free_item_folder_recurse( ItemFolder *parent ) {
 751         GList *node = parent->listFolder;
 752
 753         while( node ) {
 754                 ItemFolder *folder = node->data;
 755                 addritem_free_item_folder_recurse( folder );
 756                 node = g_list_next( node );
 757         }
 758         g_list_free( parent->listPerson );
 759         g_list_free( parent->listGroup );
 760         g_list_free( parent->listFolder );
 761         parent->listPerson = NULL;
 762         parent->listGroup = NULL;
 763         parent->listFolder = NULL;
 764 }
 765
 766 /*
 767 * Free up list of person in specified folder.
 768 */
 769 void addritem_folder_free_person( ItemFolder *folder ) {
 770         GList *node;
 771
 772         g_return_if_fail( folder != NULL );
 773
 774         /* Free up folder of persons. */
 775         node = folder->listPerson;
 776         while( node ) {
 777                 ItemPerson *person = node->data;
 778                 addritem_free_item_person( person );
 779                 person = NULL;
 780                 node = g_list_next( node );
 781         }
 782 }
 783
 784 /*
 785 * Add person into folder.
 786 * return: TRUE if person added.
 787 */
 788 gboolean addritem_folder_add_person( ItemFolder *folder, ItemPerson *item ) {
 789         g_return_val_if_fail( folder != NULL, FALSE );
 790         g_return_val_if_fail( item != NULL, FALSE );
 791
 792         folder->listPerson = g_list_append( folder->listPerson, item );
 793         ADDRITEM_PARENT(item) = ADDRITEM_OBJECT(folder);
 794         return TRUE;
 795 }
 796
 797 /*
 798 * Add folder into folder.
 799 * return: TRUE if folder added.
 800 */
 801 gboolean addritem_folder_add_folder( ItemFolder *folder, ItemFolder *item ) {
 802         g_return_val_if_fail( folder != NULL, FALSE );
 803         g_return_val_if_fail( item != NULL, FALSE );
 804
 805         folder->listFolder = g_list_append( folder->listFolder, item );
 806         ADDRITEM_PARENT(item) = ADDRITEM_OBJECT(folder);
 807         return TRUE;
 808 }
 809
 810 /*
 811 * Add group into folder.
 812 * return: TRUE if folder added.
 813 */
 814 gboolean addritem_folder_add_group( ItemFolder *folder, ItemGroup *item ) {
 815         g_return_val_if_fail( folder != NULL, FALSE );
 816         g_return_val_if_fail( item != NULL, FALSE );
 817
 818         folder->listGroup = g_list_append( folder->listGroup, item );
 819         ADDRITEM_PARENT(item) = ADDRITEM_OBJECT(folder);
 820         return TRUE;
 821 }
 822
 823 /*
 824 * Print address folder item.
 825 */
 826 void addritem_print_item_folder( ItemFolder *folder, FILE *stream ) {
 827         GList *node;
 828         /* ItemPerson *person; */
 829         ItemFolder *parent;
 830
 831         g_return_if_fail( folder != NULL );
 832
 833         fprintf( stream, "Folder:\n" );
 834         fprintf( stream, "\tt/u: %d : '%s'\n", ADDRITEM_TYPE(folder), ADDRITEM_ID(folder) );
 835         fprintf( stream, "\tsub: %d\n", ADDRITEM_SUBTYPE(folder) );
 836         fprintf( stream, "\tnam: '%s'\n", ADDRITEM_NAME(folder) );
 837         fprintf( stream, "\trem: '%s'\n", folder->remarks );
 838         fprintf( stream, "\t---\n" );
 839         parent = ( ItemFolder * ) ADDRITEM_PARENT(folder);
 840         if( parent ) {
 841                 fprintf( stream, "\tpar: %s : %s\n", ADDRITEM_ID(parent), ADDRITEM_NAME(parent) );
 842         }
 843         else {
 844                 fprintf( stream, "\tpar: NULL\n" );
 845         }
 846         node = folder->listFolder;
 847         while( node ) {
 848                 AddrItemObject *aio = node->data;
 849                 if( aio ) {
 850                         if( aio->type == ITEMTYPE_FOLDER ) {
 851                                 ItemFolder *item = ( ItemFolder * ) aio;
 852                                 addritem_print_item_folder( item, stream );
 853                         }
 854                 }
 855                 else {
 856                         fprintf( stream, "\t\tpid : ???\n" );
 857                 }
 858
 859                 node = g_list_next( node );
 860         }
 861
 862         node = folder->listPerson;
 863         while( node ) {
 864                 AddrItemObject *aio = node->data;
 865                 if( aio ) {
 866                         if( aio->type == ITEMTYPE_PERSON ) {
 867                                 ItemPerson *item = ( ItemPerson * ) aio;
 868                                 addritem_print_item_person( item, stream );
 869                         }
 870                 }
 871                 else {
 872                         fprintf( stream, "\t\tpid : ???\n" );
 873                 }
 874
 875                 node = g_list_next( node );
 876         }
 877
 878         node = folder->listGroup;
 879         while( node ) {
 880                 AddrItemObject *aio = node->data;
 881                 if( aio ) {
 882                         if( aio->type == ITEMTYPE_GROUP ) {
 883                                 ItemGroup *item = ( ItemGroup * ) aio;
 884                                 addritem_print_item_group( item, stream );
 885                         }
 886                 }
 887                 else {
 888                         fprintf( stream, "\t\tpid : ???\n" );
 889                 }
 890                 node = g_list_next( node );
 891         }
 892         fprintf( stream, "\t###\n" );
 893 }
 894
 895 /*
 896 * Return link list of persons for specified folder. Note that the list contains
 897 * references to items and should be g_free() when done. Do *NOT* attempt to use the
 898 * addritem_free_xxx() functions... this will destroy the addressbook data!
 899 * Return: List of items, or NULL if none.
 900 */
 901 GList *addritem_folder_get_person_list( ItemFolder *folder ) {
 902         GList *list = NULL;
 903         GList *node = NULL;
 904
 905         g_return_val_if_fail( folder != NULL, NULL );
 906
 907         node = folder->listPerson;
 908         while( node ) {
 909                 ItemPerson *person = node->data;
 910                 list = g_list_append( list, person );
 911                 node = g_list_next( node );
 912         }
 913         return list;
 914 }
 915
 916 /*
 917 * Return link list of groups for specified folder. Note that the list contains
 918 * references to items and should be g_free() when done. Do *NOT* attempt to use the
 919 * addritem_free_xxx() functions... this will destroy the addressbook data!
 920 * Return: List of items, or NULL if none.
 921 */
 922 GList *addritem_folder_get_group_list( ItemFolder *folder ) {
 923         GList *list = NULL;
 924         GList *node = NULL;
 925
 926         g_return_val_if_fail( folder != NULL, NULL );
 927
 928         node = folder->listGroup;
 929         while( node ) {
 930                 ItemGroup *group = node->data;
 931                 list = g_list_append( list, group );
 932                 node = g_list_next( node );
 933         }
 934         return list;
 935 }
 936
 937 /*
 938 * Move person's email item.
 939 * param: person     Person.
 940 *        itemMove   Item to move.
 941 *        itemTarget Target item before which to move item.
 942 */
 943
 944 ItemEMail *addritem_move_email_before( ItemPerson *person, ItemEMail *itemMove, ItemEMail *itemTarget ) {
 945         gint posT, posM;
 946
 947         g_return_val_if_fail( person != NULL, NULL );
 948
 949         if( itemTarget == NULL ) return NULL;
 950         if( itemMove == NULL ) return NULL;
 951         if( itemMove == itemTarget ) return itemMove;
 952
 953         posT = g_list_index( person->listEMail, itemTarget );
 954         if( posT < 0 ) return NULL;
 955         posM = g_list_index( person->listEMail, itemMove );
 956         if( posM < 0 ) return NULL;
 957         person->listEMail = g_list_remove( person->listEMail, itemMove );
 958         person->listEMail = g_list_insert( person->listEMail, itemMove, posT );
 959         return itemMove;
 960 }
 961
 962 /*
 963 * Move person's email item.
 964 * param: person     Person.
 965 *        itemMove   Item to move.
 966 *        itemTarget Target item after which to move item.
 967 */
 968 ItemEMail *addritem_move_email_after( ItemPerson *person, ItemEMail *itemMove, ItemEMail *itemTarget ) {
 969         gint posT, posM;
 970
 971         g_return_val_if_fail( person != NULL, NULL );
 972
 973         if( itemTarget == NULL ) return NULL;
 974         if( itemMove == NULL ) return NULL;
 975         if( itemMove == itemTarget ) return itemMove;
 976
 977         posT = g_list_index( person->listEMail, itemTarget );
 978         if( posT < 0 ) return NULL;
 979         posM = g_list_index( person->listEMail, itemMove );
 980         if( posM < 0 ) return NULL;
 981         person->listEMail = g_list_remove( person->listEMail, itemMove );
 982         person->listEMail = g_list_insert( person->listEMail, itemMove, 1+posT );
 983         return itemMove;
 984 }
 985
 986 /*
 987 * End of Source.
 988 */