source/contacteditor/frmContactEditor-Save.cpp

   1 // frmContactEditor-Save.cpp - frmContactEditor save contact subroutines.
   2 //
   3 // (c) 2012-2016 Xestia Software Development.
   4 //
   5 // This file is part of Xestia Address Book.
   6 //
   7 // Xestia Address Book is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU General Public License as published by the
   9 // Free Software Foundation, version 3 of the license.
  10 //
  11 // Xestia Address Book is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with Xestia Address Book. If not, see <http://www.gnu.org/licenses/>
  18
  19 #include "frmContactEditor.h"
  20 #include "../enums.h"
  21 #include "../version.h"
  22 #include "../vcard/vcard.h"
  23 #include "../vcard/vcard34conv.h"
  24 #include "../common/textprocessing.h"
  25 #include "../common/preferences.h"
  26 #include "../common/uuid.h"
  27 #include "../common/dirs.h"
  28
  29 void frmContactEditor::SaveContact( wxCommandEvent& event )
  30 {
  31
  32         // Check if Display As combo box has a value in it.
  33         // Do not go any further if there is no value.
  34
  35         wxString cmbDisplayAsValue = cmbDisplayAs->GetValue();
  36
  37         if (cmbDisplayAsValue.IsEmpty()){
  38
  39                 wxMessageBox(_("Display As value cannot be left blank."), _("Display As value empty"), wxICON_ERROR);
  40                 return;
  41
  42         }
  43
  44         // Save the updated contact data.
  45
  46         //vCard ContactData;
  47         wxString FilenameFinal;
  48         bool ReplaceContact = FALSE;
  49
  50         if (StartupEditMode == TRUE){
  51
  52                 if (cmbType->GetCurrentSelection() == 1 ||
  53                     cmbType->GetCurrentSelection() == 3 ||
  54                     cmbType->GetCurrentSelection() == 4){
  55
  56                         if (IsGroup == TRUE){
  57
  58                                 // Mark contact for replacing.
  59
  60                                 ReplaceContact = TRUE;
  61                                 IsGroup = FALSE;
  62
  63                         }
  64
  65                 } else if (cmbType->GetCurrentSelection() == 2){
  66
  67                         if (IsGroup == FALSE){
  68
  69                                 // Mark contact for replacing.
  70
  71                                 ReplaceContact = TRUE;
  72                                 IsGroup = TRUE;
  73
  74                         }
  75
  76                 }
  77
  78                 if (ReplaceContact == TRUE){
  79
  80                         wxString wxDelSplitFilename;
  81                         wxString wxDelFinalFilename;
  82                         wxString wxSDelDataURL;
  83                         wxStringTokenizer wSTDelFilename(wxSContactFilename, wxT("/"));
  84
  85                         while(wSTDelFilename.HasMoreTokens()){
  86
  87                                 wxDelSplitFilename = wSTDelFilename.GetNextToken();
  88
  89                         }
  90
  91                         wxSDelDataURL = wxDelSplitFilename;
  92
  93                         // Delete the contact from the server as it will be useless in certain
  94                         // address book clients.
  95
  96                         ActMgrPtr->AddTask(2, cmbDisplayAs->GetValue(), wxSContactAccount, wxSDelDataURL, wxDelSplitFilename, wxSContactFilename, wxT(""));
  97
  98                         // Clear the filename so the trigger to recreate the UID is done.
  99
 100                         wxSContactFilename.Clear();
 101                         EditMode = FALSE;
 102
 103                 }
 104
 105         }
 106
 107         if (wxSContactFilename.IsEmpty()){
 108
 109                 // Generate a random UUID.
 110
 111                 ContactEditorData.UIDToken = GenerateUUID();
 112                 ContactEditorData.UIDToken = ContactEditorData.UIDToken.MakeUpper();
 113
 114                 // Setup the filename.
 115
 116                 FilenameFinal = GetAccountDir(wxSContactAccount, FALSE);
 117
 118 #if defined(__HAIKU__)
 119
 120 #elif defined(__WIN32__)
 121
 122                 FilenameFinal = GetAccountDir(wxSContactAccount, FALSE);
 123                 FilenameFinal.Append(ContactEditorData.UIDToken);
 124                 FilenameFinal.Append(wxT(".vcf"));
 125                 wxSContactFilename = FilenameFinal;
 126
 127 #else
 128
 129                 FilenameFinal = GetAccountDir(wxSContactAccount, FALSE);
 130                 FilenameFinal.Append(ContactEditorData.UIDToken);
 131                 FilenameFinal.Append(wxT(".vcf"));
 132                 wxSContactFilename = FilenameFinal;
 133
 134 #endif
 135
 136         } else {
 137
 138                 if (ContactEditorData.UIDToken.IsEmpty()){
 139
 140                         // UID Token is empty. (Shouldn't be).
 141                         // Generate a new UID Token.
 142
 143                         ContactEditorData.UIDToken = GenerateUUID();
 144                         ContactEditorData.UIDToken = ContactEditorData.UIDToken.MakeUpper();
 145
 146                 }
 147
 148                 FilenameFinal = wxSContactFilename;
 149
 150         }
 151
 152         // Setup the data and write it into the account folder.
 153
 154         // Begin preperations to write the contact to a file.
 155
 156         bool FNFirst = TRUE;
 157         std::map<int,int>::iterator intiter;
 158         std::map<int,wxString>::iterator striter;
 159
 160         // Set some values for saving.
 161
 162         ContactEditorData.NameForename = txtForename->GetValue();
 163         ContactEditorData.NameSurname = txtSurname->GetValue();
 164         ContactEditorData.NameOtherNames = txtOtherNames->GetValue();
 165         ContactEditorData.NameTitle = txtTitle->GetValue();
 166         ContactEditorData.NameSuffix = txtSuffix->GetValue();
 167
 168         ContactEditorData.GenderDetails = txtGenderDescription->GetValue();
 169
 170         // Process Birthday: Get Day, Month & Year.
 171
 172         wxDateTime BirthdayDate;
 173         wxDateTime::Month BirthdayMonth;
 174         int BirthdayDay;
 175         int BirthdayYear;
 176         wxString DataBeforeT;
 177         wxString DataAfterT;
 178         wxString FinalBirthdayString;
 179         bool ProcessDataAfterT = FALSE;
 180
 181         BirthdayDate = dapBirthday->GetValue();
 182
 183         if (!txtBirthday->IsEmpty()){
 184
 185                 // Birthday value is text so use this.
 186
 187                 ContactEditorData.Birthday = txtBirthday->GetValue();
 188
 189         } else if (BirthdayDate.IsValid()){
 190
 191                 BirthdayDay = BirthdayDate.GetDay();
 192                 BirthdayMonth = BirthdayDate.GetMonth();
 193                 BirthdayYear = BirthdayDate.GetYear();
 194
 195                 // Look for T and replace data before this.
 196
 197                 wxStringTokenizer wSTDate(ContactEditorData.Birthday, wxT("T"));
 198
 199                 while (wSTDate.HasMoreTokens()){
 200
 201                         if (ProcessDataAfterT == FALSE){
 202
 203                                 DataBeforeT = wSTDate.GetNextToken();
 204                                 ProcessDataAfterT = TRUE;
 205
 206                         } else {
 207
 208                                 DataAfterT = wSTDate.GetNextToken();
 209                                 break;
 210
 211                         }
 212
 213                 }
 214
 215                 // If there is not T then replace altogether.
 216
 217                 wxString FinalBirthdayDay;
 218                 wxString FinalBirthdayMonth;
 219                 wxString FinalBirthdayYear;
 220
 221                 if (BirthdayDay < 10){
 222
 223                         FinalBirthdayDay = wxT("0") + wxString::Format(wxT("%i"), BirthdayDay);
 224
 225                 } else {
 226
 227                         FinalBirthdayDay = wxString::Format(wxT("%i"), BirthdayDay);
 228
 229                 }
 230
 231                 if (((int)BirthdayMonth + 1) < 10){
 232
 233                         FinalBirthdayMonth = wxT("0") + wxString::Format(wxT("%i"), ((int)BirthdayMonth + 1));
 234
 235                 } else {
 236
 237                         FinalBirthdayMonth = wxString::Format(wxT("%i"), ((int)BirthdayMonth + 1));
 238
 239                 }
 240
 241                 if (BirthdayYear == 0){
 242
 243                         FinalBirthdayYear = wxT("--");
 244
 245                 } else {
 246
 247                         FinalBirthdayYear = wxString::Format(wxT("%i"), BirthdayYear);
 248
 249                 }
 250
 251                 if (!DataAfterT.IsEmpty()){
 252
 253                         FinalBirthdayString = FinalBirthdayYear + FinalBirthdayMonth + FinalBirthdayDay + wxT("T") + DataAfterT;
 254
 255                 } else {
 256
 257                         FinalBirthdayString = FinalBirthdayYear + FinalBirthdayMonth + FinalBirthdayDay;
 258
 259                 }
 260
 261                 if(!FinalBirthdayString.IsEmpty()){
 262
 263                         ContactEditorData.Birthday = FinalBirthdayString;
 264
 265                 }
 266
 267         }
 268
 269         // Process Anniversary: Get Day, Month & Year.
 270
 271         wxDateTime AnniversaryDate;
 272         wxDateTime::Month AnniversaryMonth;
 273         int AnniversaryDay;
 274         int AnniversaryYear;
 275         DataBeforeT = "";
 276         DataAfterT = "";
 277         wxString FinalAnniversaryString;
 278         ProcessDataAfterT = FALSE;
 279
 280         AnniversaryDate = dapAnniversary->GetValue();
 281
 282         if (!txtAnniversary->IsEmpty()){
 283
 284                 // Birthday value is text so use this.
 285
 286                 ContactEditorData.Anniversary = txtAnniversary->GetValue();
 287
 288         } else if (AnniversaryDate.IsValid()){
 289
 290                 AnniversaryDay = AnniversaryDate.GetDay();
 291                 AnniversaryMonth = AnniversaryDate.GetMonth();
 292                 AnniversaryYear = AnniversaryDate.GetYear();
 293
 294                 // Look for T and replace data before this.
 295
 296                 wxStringTokenizer wSTDate(ContactEditorData.Anniversary, wxT("T"));
 297
 298                 while (wSTDate.HasMoreTokens()){
 299
 300                         if (ProcessDataAfterT == FALSE){
 301
 302                                 DataBeforeT = wSTDate.GetNextToken();
 303                                 ProcessDataAfterT = TRUE;
 304
 305                         } else {
 306
 307                                 DataAfterT = wSTDate.GetNextToken();
 308                                 break;
 309
 310                         }
 311
 312                 }
 313
 314                 // If there is not T then replace altogether.
 315
 316                 wxString FinalAnniversaryDay;
 317                 wxString FinalAnniversaryMonth;
 318                 wxString FinalAnniversaryYear;
 319
 320                 if (AnniversaryDay < 10){
 321
 322                         FinalAnniversaryDay = wxT("0") + wxString::Format(wxT("%i"), AnniversaryDay);
 323
 324                 } else {
 325
 326                         FinalAnniversaryDay = wxString::Format(wxT("%i"), AnniversaryDay);
 327
 328                 }
 329
 330                 if (((int)AnniversaryMonth + 1) < 10){
 331
 332                         FinalAnniversaryMonth = wxT("0") + wxString::Format(wxT("%i"), ((int)AnniversaryMonth + 1));
 333
 334                 } else {
 335
 336                         FinalAnniversaryMonth = wxString::Format(wxT("%i"), ((int)AnniversaryMonth + 1));
 337
 338                 }
 339
 340                 if (AnniversaryYear == 0){
 341
 342                         FinalAnniversaryYear = wxT("--");
 343
 344                 } else {
 345
 346                         FinalAnniversaryYear = wxString::Format(wxT("%i"), AnniversaryYear);
 347
 348                 }
 349
 350                 if (!DataAfterT.IsEmpty()){
 351
 352                         FinalAnniversaryString = FinalAnniversaryYear + FinalAnniversaryMonth + FinalAnniversaryDay + wxT("T") + DataAfterT;
 353
 354                 } else {
 355
 356                         FinalAnniversaryString = FinalAnniversaryYear + FinalAnniversaryMonth + FinalAnniversaryDay;
 357
 358                 }
 359
 360                 if(!FinalAnniversaryString.IsEmpty()){
 361
 362                         ContactEditorData.Birthday = FinalAnniversaryString;
 363
 364                 }
 365
 366         }
 367
 368         // Process full name.
 369
 370         if (ContactEditorData.FullNamesList.size() > 0){
 371
 372                 ContactEditorData.FullNamesList[0] = cmbDisplayAs->GetValue();
 373
 374         } else {
 375
 376                 ContactEditorData.FullNamesList.insert(std::make_pair(0, cmbDisplayAs->GetValue()));
 377                 ContactEditorData.FullNamesListAltID.insert(std::make_pair(0, wxT("")));
 378                 ContactEditorData.FullNamesListPID.insert(std::make_pair(0, wxT("")));
 379                 ContactEditorData.FullNamesListType.insert(std::make_pair(0, wxT("")));
 380                 ContactEditorData.FullNamesListLanguage.insert(std::make_pair(0, wxT("")));
 381                 ContactEditorData.FullNamesListPref.insert(std::make_pair(0, 0));
 382                 ContactEditorData.FullNamesListTokens.insert(std::make_pair(0, wxT("")));
 383
 384         }
 385
 386         /*ContactData.Add(wxT("BEGIN"), wxT("VCARD"), FALSE);
 387         ContactData.Add(wxT("VERSION"), wxT("4.0"), FALSE);
 388
 389         // Setup the version string.
 390
 391         strValue.Append(wxT("-//Xestia//Address Book Version "));
 392         strValue.Append(wxT(XSDAB_VERSION));
 393         strValue.Append(wxT("//KW"));
 394
 395         ContactData.Add(wxT("PRODID"), strValue, FALSE);
 396
 397         // Process the REV property.
 398
 399         wxDateTime DateTimeSave;
 400         DateTimeSave = DateTimeSave.SetToCurrent();
 401         wxString DateTimeSaveValue;
 402
 403         DateTimeSaveValue += wxString::Format("%04i", DateTimeSave.GetYear());
 404         DateTimeSaveValue += wxString::Format("%02i", (DateTimeSave.GetMonth() + 1));
 405         DateTimeSaveValue += wxString::Format("%02i", DateTimeSave.GetDay());
 406         DateTimeSaveValue += "T";
 407         DateTimeSaveValue += wxString::Format("%02i", DateTimeSave.GetHour());
 408         DateTimeSaveValue += wxString::Format("%02i", DateTimeSave.GetMinute());
 409         DateTimeSaveValue += wxString::Format("%02i", DateTimeSave.GetSecond());
 410
 411         if (!ContactEditorData.RevisionTokens.IsEmpty()){
 412
 413                 ContactData.AddRaw("REV;" + ContactEditorData.RevisionTokens, DateTimeSaveValue);
 414
 415         } else {
 416
 417                 ContactData.AddRaw("REV", DateTimeSaveValue);
 418
 419         }
 420
 421         // Process the XML properties.
 422
 423         for (std::map<int,wxString>::iterator iter = ContactEditorData.XMLList.begin();
 424                 iter != ContactEditorData.XMLList.end(); ++iter){
 425
 426                 wxString strOrigValue;
 427
 428                 strOrigValue = ContactEditorData.XMLList.find(iter->first)->second;
 429
 430                 ResetUnusedString(&strOrigValue);
 431
 432                 ProcessSaveData(wxT("XML"), &strValue2, &boolValue2, &boolValue,
 433                         &iter, &strOrigValue, &ContactData,
 434                         wxT("ALTID"), &ContactEditorData.XMLListAltID );
 435
 436                 ResetSaveProcessData();
 437
 438         }
 439
 440         // Process the CLIENTPIDMAP properties.
 441
 442         for (std::map<int,wxString>::iterator iter = ContactEditorData.ClientPIDList.begin();
 443                 iter != ContactEditorData.ClientPIDList.end(); ++iter){
 444
 445                 wxString strOrigValue;
 446
 447                 strOrigValue = ContactEditorData.ClientPIDList.find(iter->first)->second;
 448
 449                 ResetUnusedString(&strOrigValue);
 450
 451                 ProcessSaveData(wxT("CLIENTPIDMAP"), &strValue2, &boolValue2, &boolValue,
 452                         &iter, &strOrigValue, &ContactData,
 453                         wxT(""), &ContactEditorData.ClientPIDListTokens );
 454
 455                 ResetSaveProcessData();
 456
 457         }
 458
 459         // Process the SOURCE properties.
 460
 461         for (std::map<int,wxString>::iterator iter = ContactEditorData.SourceList.begin();
 462                 iter != ContactEditorData.SourceList.end(); ++iter){
 463
 464                 wxString strOrigValue;
 465
 466                 strOrigValue = ContactEditorData.SourceList.find(iter->first)->second;
 467
 468                 ResetUnusedString(&strOrigValue);
 469
 470                 ProcessSaveData(wxT("SOURCE"), &strValue2, &boolValue2, &boolValue,
 471                         &iter, &strOrigValue, &ContactData,
 472                         wxT("ALTID"), &ContactEditorData.SourceListAltID,
 473                         wxT("PID"), &ContactEditorData.SourceListPID,
 474                         wxT("TYPE"), &ContactEditorData.SourceListType,
 475                         wxT("PREF"), &ContactEditorData.SourceListPref,
 476                         wxT("MEDIATYPE"), &ContactEditorData.SourceListMediatype,
 477                         wxT(""), &ContactEditorData.SourceListTokens );
 478
 479                 ResetSaveProcessData();
 480
 481         }
 482
 483         // Setup the name.
 484
 485         strValue.Clear();
 486
 487         // Setup the name field.
 488
 489         strValue = txtSurname->GetValue() + wxT(";") +
 490         txtForename->GetValue() + wxT(";") +
 491         txtOtherNames->GetValue() + wxT(";") +
 492         txtTitle->GetValue() + wxT(";") +
 493         txtSuffix->GetValue();
 494
 495         strValue2 = ContactData.Convert(cmbDisplayAs->GetValue(), FALSE);
 496         strValue2.Trim();
 497
 498         if (ContactEditorData.NameTokens.IsEmpty()){
 499
 500                 ContactData.Add(wxT("N;SORT-AS=\"") + strValue2 + wxT("\""), strValue, FALSE);
 501
 502         } else {
 503
 504                 ContactData.Add(wxT("N;SORT-AS=\"") + strValue2 + wxT("\";") + ContactEditorData.NameTokens, strValue, FALSE);
 505
 506         }
 507
 508         if (cmbType->GetCurrentSelection() == 1){
 509
 510                 ContactData.AddRaw(wxT("KIND"), wxT("individual"));
 511
 512         } else if (cmbType->GetCurrentSelection() == 2){
 513
 514                 ContactData.AddRaw(wxT("KIND"), wxT("group"));
 515
 516                 // Go through each of the members and write them out.
 517
 518                 for (std::map<int, wxString>::iterator itemiter = ContactEditorData.GroupsList.begin();
 519                         itemiter != ContactEditorData.GroupsList.end(); ++itemiter){
 520
 521                         ContactData.Add(wxT("MEMBER:urn:uuid"), itemiter->second, FALSE);
 522
 523                 }
 524
 525         } else if (cmbType->GetCurrentSelection() == 3){
 526
 527                 ContactData.AddRaw(wxT("KIND"), wxT("org"));
 528
 529         } else if (cmbType->GetCurrentSelection() == 4){
 530
 531                 ContactData.AddRaw(wxT("KIND"), wxT("location"));
 532
 533         }
 534
 535
 536         // Setup the nicknames (General, Home & Business).
 537
 538         strValue.Clear();
 539         strValue2.Clear();
 540         strValue3.Clear();
 541
 542         boolValue = FALSE;
 543         boolValue2 = FALSE;
 544         intValue2 = 0;
 545         intValue  = 0;
 546
 547         // Setup the gender.
 548
 549         if (cmbGender->GetCurrentSelection() != 0){
 550
 551                 switch(cmbGender->GetCurrentSelection()){
 552
 553                         case 1:
 554
 555                                 strValue = wxT("M");
 556                                 break;
 557
 558                         case 2:
 559
 560                                 strValue = wxT("F");
 561                                 break;
 562
 563                         case 3:
 564
 565                                 strValue = wxT("O");
 566                                 break;
 567
 568                         case 4:
 569
 570                                 strValue = wxT("N");
 571                                 break;
 572
 573                         case 5:
 574
 575                                 strValue = wxT("U");
 576                                 break;
 577
 578                 }
 579
 580         }
 581
 582         if (!txtGenderDescription->IsEmpty()){
 583
 584                 strValue2 = txtGenderDescription->GetValue();
 585
 586         }
 587
 588         if (!strValue.IsEmpty() || !strValue2.IsEmpty()){
 589
 590                 EscapeString(&strValue2, FALSE);
 591
 592                 if (!ContactEditorData.GenderTokens.IsEmpty()){
 593
 594                         if (!strValue2.IsEmpty()){
 595
 596                                 ContactData.AddRaw(wxT("GENDER;") + ContactEditorData.GenderTokens, strValue + wxT(";") + strValue2);
 597
 598                         } else {
 599
 600                                 ContactData.AddRaw(wxT("GENDER;") + ContactEditorData.GenderTokens, strValue);
 601
 602                         }
 603
 604                 } else {
 605
 606                         if (!strValue2.IsEmpty()){
 607
 608                                 ContactData.AddRaw(wxT("GENDER"), strValue + wxT(";") + strValue2);
 609
 610                         } else {
 611
 612                                 ContactData.AddRaw(wxT("GENDER"), strValue);
 613
 614                         }
 615
 616                 }
 617
 618         }
 619
 620         ResetSaveProcessData();
 621
 622         // Build the values for the BDAY property.
 623
 624         // ALTID
 625
 626         if (!ContactEditorData.BirthdayAltID.IsEmpty()){
 627
 628                 wxString DataValue;
 629                 DataValue = ContactEditorData.BirthdayAltID;
 630
 631                 EscapeString(&DataValue, FALSE);
 632
 633                 strValue3.Append("ALTID=");
 634                 strValue3.Append(DataValue);
 635
 636                 boolValue2 = TRUE;
 637
 638         }
 639
 640         // CALSCALE.
 641
 642         if (!ContactEditorData.BirthdayCalScale.IsEmpty()){
 643
 644                 wxString DataValue;
 645                 DataValue = ContactEditorData.BirthdayCalScale;
 646
 647                 EscapeString(&DataValue, FALSE);
 648
 649                 if (boolValue2 == TRUE){
 650
 651                         strValue3.Append(";");
 652
 653                 }
 654
 655                 strValue3.Append("CALSCALE=");
 656                 strValue3.Append(DataValue);
 657
 658                 boolValue2 = TRUE;
 659
 660         }
 661
 662         // Extra tokens.
 663
 664         if (!ContactEditorData.BirthdayTokens.IsEmpty()){
 665
 666                 wxString DataValue;
 667                 DataValue = ContactEditorData.BirthdayTokens;
 668
 669                 EscapeString(&DataValue, FALSE);
 670
 671                 if (boolValue2 == TRUE){
 672
 673                         strValue3.Append(";");
 674
 675                 }
 676
 677                 strValue3.Append(DataValue);
 678
 679         }
 680
 681         // Write the BDAY property.
 682
 683         if (!txtBirthday->IsEmpty()){
 684
 685                 if (!txtBirthday->GetValue().IsEmpty()){
 686
 687                         strValue = txtBirthday->GetValue();
 688
 689                         if (!strValue3.IsEmpty()){
 690
 691                                 ContactData.AddRaw("BDAY;VALUE=text;" + strValue3, strValue);
 692
 693                         } else {
 694
 695                                 ContactData.AddRaw("BDAY;VALUE=text", strValue);
 696
 697                         }
 698
 699                 }
 700
 701         } else {
 702
 703                 // Deal with date.
 704
 705                 // Get Day, Month & Year.
 706
 707                 wxDateTime BirthdayDate;
 708                 wxDateTime::Month BirthdayMonth;
 709                 int BirthdayDay;
 710                 int BirthdayYear;
 711                 wxString DataBeforeT;
 712                 wxString DataAfterT;
 713                 wxString FinalBirthdayString;
 714                 bool ProcessDataAfterT = FALSE;
 715
 716                 BirthdayDate = dapBirthday->GetValue();
 717
 718                 if (BirthdayDate.IsValid()){
 719
 720                         BirthdayDay = BirthdayDate.GetDay();
 721                         BirthdayMonth = BirthdayDate.GetMonth();
 722                         BirthdayYear = BirthdayDate.GetYear();
 723
 724                         // Look for T and replace data before this.
 725
 726                         wxStringTokenizer wSTDate(ContactEditorData.Birthday, wxT("T"));
 727
 728                         while (wSTDate.HasMoreTokens()){
 729
 730                                 if (ProcessDataAfterT == FALSE){
 731
 732                                         DataBeforeT = wSTDate.GetNextToken();
 733                                         ProcessDataAfterT = TRUE;
 734
 735                                 } else {
 736
 737                                         DataAfterT = wSTDate.GetNextToken();
 738                                         break;
 739
 740                                 }
 741
 742                         }
 743
 744                         // If there is not T then replace altogether.
 745
 746                         wxString FinalBirthdayDay;
 747                         wxString FinalBirthdayMonth;
 748                         wxString FinalBirthdayYear;
 749
 750                         if (BirthdayDay < 10){
 751
 752                                 FinalBirthdayDay = wxT("0") + wxString::Format(wxT("%i"), BirthdayDay);
 753
 754                         } else {
 755
 756                                 FinalBirthdayDay = wxString::Format(wxT("%i"), BirthdayDay);
 757
 758                         }
 759
 760                         if (((int)BirthdayMonth + 1) < 10){
 761
 762                                 FinalBirthdayMonth = wxT("0") + wxString::Format(wxT("%i"), ((int)BirthdayMonth + 1));
 763
 764                         } else {
 765
 766                                 FinalBirthdayMonth = wxString::Format(wxT("%i"), ((int)BirthdayMonth + 1));
 767
 768                         }
 769
 770                         if (BirthdayYear == 0){
 771
 772                                 FinalBirthdayYear = wxT("--");
 773
 774                         } else {
 775
 776                                 FinalBirthdayYear = wxString::Format(wxT("%i"), BirthdayYear);
 777
 778                         }
 779
 780                         if (!DataAfterT.IsEmpty()){
 781
 782                                 FinalBirthdayString = FinalBirthdayYear + FinalBirthdayMonth + FinalBirthdayDay + wxT("T") + DataAfterT;
 783
 784                         } else {
 785
 786                                 FinalBirthdayString = FinalBirthdayYear + FinalBirthdayMonth + FinalBirthdayDay;
 787
 788                         }
 789
 790                         if (!FinalBirthdayString.IsEmpty() || !strValue3.IsEmpty()){
 791
 792                                 if (!strValue3.IsEmpty()){
 793
 794                                         EscapeString(&strValue2, FALSE);
 795                                         EscapeString(&strValue, FALSE);
 796
 797                                         ContactData.AddRaw(wxT("BDAY;") + strValue3, FinalBirthdayString);
 798
 799                                 } else {
 800
 801                                         EscapeString(&strValue, FALSE);
 802
 803                                         ContactData.AddRaw(wxT("BDAY"), FinalBirthdayString);
 804
 805                                 }
 806
 807                         }
 808
 809                 }
 810
 811         }
 812
 813         ResetSaveProcessData();
 814
 815         // Build the values for the ANNIVERSARY property.
 816
 817         // ALTID
 818
 819         if (!ContactEditorData.AnniversaryAltID.IsEmpty()){
 820
 821                 wxString DataValue;
 822                 DataValue = ContactEditorData.AnniversaryAltID;
 823
 824                 EscapeString(&DataValue, FALSE);
 825
 826                 strValue3.Append("ALTID=");
 827                 strValue3.Append(DataValue);
 828
 829                 boolValue2 = TRUE;
 830
 831         }
 832
 833         // CALSCALE.
 834
 835         if (!ContactEditorData.AnniversaryCalScale.IsEmpty()){
 836
 837                 wxString DataValue;
 838                 DataValue = ContactEditorData.AnniversaryCalScale;
 839
 840                 EscapeString(&DataValue, FALSE);
 841
 842                 if (boolValue2 == TRUE){
 843
 844                         strValue3.Append(";");
 845
 846                 }
 847
 848                 strValue3.Append("CALSCALE=");
 849                 strValue3.Append(DataValue);
 850
 851                 boolValue2 = TRUE;
 852
 853         }
 854
 855         // Extra tokens.
 856
 857         if (!ContactEditorData.AnniversaryTokens.IsEmpty()){
 858
 859                 wxString DataValue;
 860                 DataValue = ContactEditorData.AnniversaryTokens;
 861
 862                 EscapeString(&DataValue, FALSE);
 863
 864                 if (boolValue2 == TRUE){
 865
 866                         strValue3.Append(";");
 867
 868                 }
 869
 870                 strValue3.Append(DataValue);
 871
 872         }
 873
 874         // Write the ANNIVERSARY property.
 875
 876         if (!txtAnniversary->IsEmpty()){
 877
 878                 if (!txtAnniversary->GetValue().IsEmpty()){
 879
 880                         strValue = txtAnniversary->GetValue();
 881
 882                         if (!strValue3.IsEmpty()){
 883
 884                                 ContactData.AddRaw("ANNIVERSARY;VALUE=text;" + strValue3, strValue);
 885
 886                         } else {
 887
 888                                 ContactData.AddRaw("ANNIVERSARY;VALUE=text", strValue);
 889
 890                         }
 891
 892                 }
 893
 894         } else {
 895
 896                 // Look for T and replace data before this.
 897
 898                 // Get Day, Month & Year.
 899
 900                 wxDateTime AnniversaryDate;
 901                 wxDateTime::Month AnniversaryMonth;
 902                 int AnniversaryDay;
 903                 int AnniversaryYear;
 904                 wxString DataBeforeT;
 905                 wxString DataAfterT;
 906                 wxString FinalAnniversaryString;
 907                 bool ProcessDataAfterT = FALSE;
 908
 909                 AnniversaryDate = dapAnniversary->GetValue();
 910
 911                 if (AnniversaryDate.IsValid()){
 912
 913                         AnniversaryDay = AnniversaryDate.GetDay();
 914                         AnniversaryMonth = AnniversaryDate.GetMonth();
 915                         AnniversaryYear = AnniversaryDate.GetYear();
 916
 917                         // Look for T and replace data before this.
 918
 919                         wxStringTokenizer wSTDate(ContactEditorData.Anniversary, wxT("T"));
 920
 921                         while (wSTDate.HasMoreTokens()){
 922
 923                                 if (ProcessDataAfterT == FALSE){
 924
 925                                         DataBeforeT = wSTDate.GetNextToken();
 926                                         ProcessDataAfterT = TRUE;
 927
 928                                 } else {
 929
 930                                         DataAfterT = wSTDate.GetNextToken();
 931                                         break;
 932
 933                                 }
 934
 935                         }
 936
 937                         // If there is not T then replace altogether.
 938
 939                         wxString FinalAnniversaryDay;
 940                         wxString FinalAnniversaryMonth;
 941                         wxString FinalAnniversaryYear;
 942
 943                         if (AnniversaryDay < 10){
 944
 945                                 FinalAnniversaryDay = wxT("0") + wxString::Format(wxT("%i"), AnniversaryDay);
 946
 947                         } else {
 948
 949                                 FinalAnniversaryDay = wxString::Format(wxT("%i"), AnniversaryDay);
 950
 951                         }
 952
 953                         if (((int)AnniversaryMonth + 1) < 10){
 954
 955                                 FinalAnniversaryMonth = wxT("0") + wxString::Format(wxT("%i"), ((int)AnniversaryMonth + 1));
 956
 957                         } else {
 958
 959                                 FinalAnniversaryMonth = wxString::Format(wxT("%i"), ((int)AnniversaryMonth + 1));
 960
 961                         }
 962
 963                         if (AnniversaryYear == 0){
 964
 965                                 FinalAnniversaryYear = wxT("--");
 966
 967                         } else {
 968
 969                                 FinalAnniversaryYear = wxString::Format(wxT("%i"), AnniversaryYear);
 970
 971                         }
 972
 973                         if (!DataAfterT.IsEmpty()){
 974
 975                                 FinalAnniversaryString = FinalAnniversaryYear + FinalAnniversaryMonth + FinalAnniversaryDay + wxT("T") + DataAfterT;
 976
 977                         } else {
 978
 979                                 FinalAnniversaryString = FinalAnniversaryYear + FinalAnniversaryMonth + FinalAnniversaryDay;
 980
 981                         }
 982
 983                         if (!FinalAnniversaryString.IsEmpty() || !strValue3.IsEmpty()){
 984
 985                                 if (!strValue3.IsEmpty()){
 986
 987                                         EscapeString(&strValue2, FALSE);
 988                                         EscapeString(&strValue, FALSE);
 989
 990                                         ContactData.AddRaw(wxT("ANNIVERSARY;") + strValue3, FinalAnniversaryString);
 991
 992                                 } else {
 993
 994                                         EscapeString(&strValue, FALSE);
 995
 996                                         ContactData.AddRaw(wxT("ANNIVERSARY"), FinalAnniversaryString);
 997
 998                                 }
 999
1000                         }
1001
1002                 }
1003
1004         }
1005
1006         // Setup the addresses (General, Home, Business).
1007
1008         ResetSaveProcessData();
1009
1010         for (std::map<int,wxString>::iterator iter = ContactEditorData.GeneralAddressList.begin();
1011                 iter != ContactEditorData.GeneralAddressList.end(); ++iter){
1012
1013                 int intSeekValue = iter->first;
1014
1015                 wxString strAddressString;
1016                 wxString strAddressFinalValue;
1017                 std::map<int, wxString>::iterator iterValue;
1018
1019                 strAddressString.Append(wxT(";;"));
1020
1021                 // Get Address
1022
1023                 iterValue = ContactEditorData.GeneralAddressList.find(intSeekValue);
1024                 strAddressFinalValue = iterValue->second;
1025                 ProcessCaptureStrings(&strAddressFinalValue);
1026                 strAddressString.Append(strAddressFinalValue + wxT(";"));
1027                 strAddressFinalValue.Clear();
1028
1029                 // Get Town
1030
1031                 iterValue = ContactEditorData.GeneralAddressListTown.find(intSeekValue);
1032                 strAddressFinalValue = iterValue->second;
1033                 ProcessCaptureStrings(&strAddressFinalValue);
1034                 strAddressString.Append(strAddressFinalValue + wxT(";"));
1035                 strAddressFinalValue.Clear();
1036
1037                 // Get County
1038
1039                 iterValue = ContactEditorData.GeneralAddressListCounty.find(intSeekValue);
1040                 strAddressFinalValue = iterValue->second;
1041                 ProcessCaptureStrings(&strAddressFinalValue);
1042                 strAddressString.Append(strAddressFinalValue + wxT(";"));
1043                 strAddressFinalValue.Clear();
1044
1045                 // Get Post Code
1046
1047                 iterValue = ContactEditorData.GeneralAddressListPostCode.find(intSeekValue);
1048                 strAddressFinalValue = iterValue->second;
1049                 ProcessCaptureStrings(&strAddressFinalValue);
1050                 strAddressString.Append(strAddressFinalValue + wxT(";"));
1051                 strAddressFinalValue.Clear();
1052
1053                 // Get Country
1054
1055                 iterValue = ContactEditorData.GeneralAddressListCountry.find(intSeekValue);
1056                 strAddressFinalValue = iterValue->second;
1057                 ProcessCaptureStrings(&strAddressFinalValue);
1058                 strAddressString.Append(strAddressFinalValue);
1059                 strAddressFinalValue.Clear();
1060
1061                 ProcessSaveData(wxT("ADR"), &strValue2, &boolValue2, &boolValue,
1062                         &iter, &strAddressString, &ContactData,
1063                         wxT("LABEL"), &ContactEditorData.GeneralAddressListLabel,
1064                         wxT("LANGUAGE"), &ContactEditorData.GeneralAddressListLang,
1065                         wxT("ALTID"), &ContactEditorData.GeneralAddressListAltID,
1066                         wxT("PID"), &ContactEditorData.GeneralAddressListPID,
1067                         wxT("GEO"), &ContactEditorData.GeneralAddressListGeo,
1068                         wxT("TZ"), &ContactEditorData.GeneralAddressListTimezone,
1069                         wxT("MEDIATYPE"), &ContactEditorData.GeneralAddressListMediatype,
1070                         wxT("PREF"), &ContactEditorData.GeneralAddressListPref,
1071                         wxT(""), &ContactEditorData.GeneralAddressListTokens );
1072
1073                 ResetSaveProcessData();
1074
1075         }
1076
1077         ResetSaveProcessData();
1078
1079         for (std::map<int,wxString>::iterator iter = ContactEditorData.HomeAddressList.begin();
1080                 iter != ContactEditorData.HomeAddressList.end(); ++iter){
1081
1082                 int intSeekValue = iter->first;
1083
1084                 wxString strAddressString;
1085                 wxString strAddressFinalValue;
1086                 std::map<int, wxString>::iterator iterValue;
1087
1088                 strAddressString.Append(wxT(";;"));
1089
1090                 // Get Address
1091
1092                 iterValue = ContactEditorData.HomeAddressList.find(intSeekValue);
1093                 strAddressFinalValue = iterValue->second;
1094                 ProcessCaptureStrings(&strAddressFinalValue);
1095                 strAddressString.Append(strAddressFinalValue + wxT(";"));
1096
1097                 // Get Town
1098
1099                 iterValue = ContactEditorData.HomeAddressListTown.find(intSeekValue);
1100                 strAddressFinalValue = iterValue->second;
1101                 ProcessCaptureStrings(&strAddressFinalValue);
1102                 strAddressString.Append(strAddressFinalValue + wxT(";"));
1103
1104                 // Get County
1105
1106                 iterValue = ContactEditorData.HomeAddressListCounty.find(intSeekValue);
1107                 strAddressFinalValue = iterValue->second;
1108                 ProcessCaptureStrings(&strAddressFinalValue);
1109                 strAddressString.Append(strAddressFinalValue + wxT(";"));
1110
1111                 // Get Post Code
1112
1113                 iterValue = ContactEditorData.HomeAddressListPostCode.find(intSeekValue);
1114                 strAddressFinalValue = iterValue->second;
1115                 ProcessCaptureStrings(&strAddressFinalValue);
1116                 strAddressString.Append(strAddressFinalValue + wxT(";"));
1117
1118                 // Get Country
1119
1120                 iterValue = ContactEditorData.HomeAddressListCountry.find(intSeekValue);
1121                 strAddressFinalValue = iterValue->second;
1122                 ProcessCaptureStrings(&strAddressFinalValue);
1123                 strAddressString.Append(strAddressFinalValue);
1124
1125                 ProcessSaveData(wxT("ADR;TYPE=home"), &strValue2, &boolValue2, &boolValue,
1126                         &iter, &strAddressString, &ContactData,
1127                         wxT("LABEL"), &ContactEditorData.HomeAddressListLabel,
1128                         wxT("LANGUAGE"), &ContactEditorData.HomeAddressListLang,
1129                         wxT("ALTID"), &ContactEditorData.HomeAddressListAltID,
1130                         wxT("PID"), &ContactEditorData.HomeAddressListPID,
1131                         wxT("GEO"), &ContactEditorData.HomeAddressListGeo,
1132                         wxT("TZ"), &ContactEditorData.HomeAddressListTimezone,
1133                         wxT("MEDIATYPE"), &ContactEditorData.HomeAddressListMediatype,
1134                         wxT("PREF"), &ContactEditorData.HomeAddressListPref,
1135                         wxT(""), &ContactEditorData.HomeAddressListTokens );
1136
1137                 ResetSaveProcessData();
1138
1139         }
1140
1141         ResetSaveProcessData();
1142
1143         for (std::map<int,wxString>::iterator iter = ContactEditorData.BusinessAddressList.begin();
1144                 iter != ContactEditorData.BusinessAddressList.end(); ++iter){
1145
1146                 int intSeekValue = iter->first;
1147
1148                 wxString strAddressString;
1149                 wxString strAddressFinalValue;
1150                 std::map<int, wxString>::iterator iterValue;
1151
1152                 strAddressString.Append(wxT(";;"));
1153
1154                 // Get Address
1155
1156                 iterValue = ContactEditorData.BusinessAddressList.find(intSeekValue);
1157                 strAddressFinalValue = iterValue->second;
1158                 ProcessCaptureStrings(&strAddressFinalValue);
1159
1160                 strAddressString.Append(strAddressFinalValue + wxT(";"));
1161
1162                 // Get Town
1163
1164                 iterValue = ContactEditorData.BusinessAddressListTown.find(intSeekValue);
1165                 strAddressFinalValue = iterValue->second;
1166                 ProcessCaptureStrings(&strAddressFinalValue);
1167
1168                 strAddressString.Append(strAddressFinalValue + wxT(";"));
1169
1170                 // Get County
1171
1172                 iterValue = ContactEditorData.BusinessAddressListCounty.find(intSeekValue);
1173                 strAddressFinalValue = iterValue->second;
1174                 ProcessCaptureStrings(&strAddressFinalValue);
1175
1176                 strAddressString.Append(strAddressFinalValue + wxT(";"));
1177
1178                 // Get Post Code
1179
1180                 iterValue = ContactEditorData.BusinessAddressListPostCode.find(intSeekValue);
1181                 strAddressFinalValue = iterValue->second;
1182                 ProcessCaptureStrings(&strAddressFinalValue);
1183
1184                 strAddressString.Append(strAddressFinalValue + wxT(";"));
1185
1186                 // Get Country
1187
1188                 iterValue = ContactEditorData.BusinessAddressListCountry.find(intSeekValue);
1189                 strAddressFinalValue = iterValue->second;
1190                 ProcessCaptureStrings(&strAddressFinalValue);
1191
1192                 strAddressString.Append(strAddressFinalValue);
1193
1194                 ProcessSaveData(wxT("ADR;TYPE=work"), &strValue2, &boolValue2, &boolValue,
1195                         &iter, &strAddressString, &ContactData,
1196                         wxT("LABEL"), &ContactEditorData.BusinessAddressListLabel,
1197                         wxT("LANGUAGE"), &ContactEditorData.BusinessAddressListLang,
1198                         wxT("ALTID"), &ContactEditorData.BusinessAddressListAltID,
1199                         wxT("PID"), &ContactEditorData.BusinessAddressListPID,
1200                         wxT("GEO"), &ContactEditorData.BusinessAddressListGeo,
1201                         wxT("TZ"), &ContactEditorData.BusinessAddressListTimezone,
1202                         wxT("MEDIATYPE"), &ContactEditorData.BusinessAddressListMediatype,
1203                         wxT("PREF"), &ContactEditorData.BusinessAddressListPref,
1204                         wxT(""), &ContactEditorData.BusinessAddressListTokens );
1205
1206                 ResetSaveProcessData();
1207
1208         }
1209
1210         // Sort out nicknames (if any).
1211
1212         for (std::map<int,wxString>::iterator iter = ContactEditorData.GeneralNicknamesList.begin();
1213                 iter != ContactEditorData.GeneralNicknamesList.end(); ++iter){
1214
1215                 intValue2 = iter->first;
1216
1217                 // Process Alternative ID.
1218
1219                 ProcessSaveData(wxT("NICKNAME"), &strValue2, &boolValue2, &boolValue,
1220                         &iter, &ContactEditorData.GeneralNicknamesList, &ContactData,
1221                         wxT("LANGUAGE"), &ContactEditorData.GeneralNicknamesListLanguage,
1222                         wxT("ALTID"), &ContactEditorData.GeneralNicknamesListAltID,
1223                         wxT("PID"), &ContactEditorData.GeneralNicknamesListPID,
1224                         wxT("PREF"), &ContactEditorData.GeneralNicknamesListPref,
1225                         wxT(""), &ContactEditorData.GeneralNicknamesListTokens );
1226
1227                 ResetSaveProcessData();
1228
1229         }
1230
1231         ResetSaveProcessData();
1232
1233         for (std::map<int,wxString>::iterator iter = ContactEditorData.HomeNicknamesList.begin();
1234                 iter != ContactEditorData.HomeNicknamesList.end(); ++iter){
1235
1236                 ProcessSaveData(wxT("NICKNAME;TYPE=home"), &strValue2, &boolValue2, &boolValue,
1237                         &iter, &ContactEditorData.HomeNicknamesList, &ContactData,
1238                         wxT("LANGUAGE"), &ContactEditorData.HomeNicknamesListLanguage,
1239                         wxT("ALTID"), &ContactEditorData.HomeNicknamesListAltID,
1240                         wxT("PID"), &ContactEditorData.HomeNicknamesListPID,
1241                         wxT("PREF"), &ContactEditorData.HomeNicknamesListPref,
1242                         wxT(""), &ContactEditorData.HomeNicknamesListTokens );
1243
1244                 ResetSaveProcessData();
1245
1246         }
1247
1248         ResetSaveProcessData();
1249
1250         for (std::map<int,wxString>::iterator iter = ContactEditorData.BusinessNicknamesList.begin();
1251                 iter != ContactEditorData.BusinessNicknamesList.end(); ++iter){
1252
1253                 ProcessSaveData(wxT("NICKNAME;TYPE=work"), &strValue2, &boolValue2, &boolValue,
1254                         &iter, &ContactEditorData.BusinessNicknamesList, &ContactData,
1255                         wxT("LANGUAGE"), &ContactEditorData.BusinessNicknamesListLanguage,
1256                         wxT("ALTID"), &ContactEditorData.BusinessNicknamesListAltID,
1257                         wxT("PID"), &ContactEditorData.BusinessNicknamesListPID,
1258                         wxT("PREF"), &ContactEditorData.BusinessNicknamesListPref,
1259                         wxT(""), &ContactEditorData.BusinessNicknamesListTokens );
1260
1261                 ResetSaveProcessData();
1262
1263         }
1264
1265         ResetSaveProcessData();
1266
1267         // Sort out email (general, home and business).
1268
1269         for (std::map<int,wxString>::iterator iter = ContactEditorData.GeneralEmailList.begin();
1270                 iter != ContactEditorData.GeneralEmailList.end(); ++iter){
1271
1272                 wxString strAddressFinalValue;
1273                 std::map<int, wxString>::iterator iterValue;
1274
1275                 ProcessSaveData(wxT("EMAIL"), &strValue2, &boolValue2, &boolValue,
1276                         &iter, &ContactEditorData.GeneralEmailList, &ContactData,
1277                         wxT("ALTID"), &ContactEditorData.GeneralEmailListAltID,
1278                         wxT("PID"), &ContactEditorData.GeneralEmailListPID,
1279                         wxT("PREF"), &ContactEditorData.GeneralEmailListPref,
1280                         wxT(""), &ContactEditorData.GeneralEmailListTokens );
1281
1282                 ResetSaveProcessData();
1283
1284         }
1285
1286         ResetSaveProcessData();
1287
1288         for (std::map<int,wxString>::iterator iter = ContactEditorData.HomeEmailList.begin();
1289                 iter != ContactEditorData.HomeEmailList.end(); ++iter){
1290
1291                 ProcessSaveData(wxT("EMAIL;TYPE=home"), &strValue2, &boolValue2, &boolValue,
1292                         &iter, &ContactEditorData.HomeEmailList, &ContactData,
1293                         wxT("ALTID"), &ContactEditorData.HomeEmailListAltID,
1294                         wxT("PID"), &ContactEditorData.HomeEmailListPID,
1295                         wxT("PREF"), &ContactEditorData.HomeEmailListPref,
1296                         wxT(""), &ContactEditorData.HomeEmailListTokens );
1297
1298                 ResetSaveProcessData();
1299
1300         }
1301
1302         ResetSaveProcessData();
1303
1304         for (std::map<int,wxString>::iterator iter = ContactEditorData.BusinessEmailList.begin();
1305                 iter != ContactEditorData.BusinessEmailList.end(); ++iter){
1306
1307                 ProcessSaveData(wxT("EMAIL;TYPE=work"), &strValue2, &boolValue2, &boolValue,
1308                         &iter, &ContactEditorData.BusinessEmailList, &ContactData,
1309                         wxT("ALTID"), &ContactEditorData.BusinessEmailListAltID,
1310                         wxT("PID"), &ContactEditorData.BusinessEmailListPID,
1311                         wxT("PREF"), &ContactEditorData.BusinessEmailListPref,
1312                         wxT(""), &ContactEditorData.BusinessEmailListTokens );
1313
1314                 ResetSaveProcessData();
1315
1316         }
1317
1318         ResetSaveProcessData();
1319
1320         for (std::map<int,wxString>::iterator iter = ContactEditorData.GeneralIMList.begin();
1321                 iter != ContactEditorData.GeneralIMList.end(); ++iter){
1322
1323                 intValue2 = iter->first;
1324
1325                 wxString strIMFinalValue = iter->second;
1326
1327                 ProcessCaptureStrings(&strIMFinalValue);
1328
1329                 if (ContactEditorData.GeneralIMListTypeInfo.find(iter->first) !=
1330                         ContactEditorData.GeneralIMListTypeInfo.end()){
1331
1332                         std::map<int,wxString>::iterator DataTypeIter = ContactEditorData.GeneralIMListTypeInfo.find(iter->first);
1333
1334                         strIMFinalValue.insert(0, ":");
1335                         strIMFinalValue.insert(0, DataTypeIter->second);
1336
1337                 } else {
1338
1339                         strIMFinalValue.insert(0, "none:");
1340
1341                 }
1342
1343                 // Process Alternative ID.
1344
1345                 ProcessSaveData(wxT("IMPP"), &strValue2, &boolValue2, &boolValue,
1346                         &iter, &strIMFinalValue, &ContactData,
1347                         wxT("ALTID"), &ContactEditorData.GeneralIMListAltID,
1348                         wxT("PID"), &ContactEditorData.GeneralIMListPID,
1349                         wxT("MEDIATYPE"), &ContactEditorData.GeneralIMListMediatype,
1350                         wxT("PREF"), &ContactEditorData.GeneralIMListPref,
1351                         wxT(""), &ContactEditorData.GeneralIMListTokens );
1352
1353                 ResetSaveProcessData();
1354
1355         }
1356
1357         ResetSaveProcessData();
1358
1359         for (std::map<int,wxString>::iterator iter = ContactEditorData.HomeIMList.begin();
1360                 iter != ContactEditorData.HomeIMList.end(); ++iter){
1361
1362                 wxString strIMFinalValue = iter->second;
1363
1364                 ProcessCaptureStrings(&strIMFinalValue);
1365
1366                 if (ContactEditorData.HomeIMListTypeInfo.find(iter->first) !=
1367                         ContactEditorData.HomeIMListTypeInfo.end()){
1368
1369                         std::map<int,wxString>::iterator DataTypeIter = ContactEditorData.HomeIMListTypeInfo.find(iter->first);
1370
1371                         strIMFinalValue.insert(0, ":");
1372                         strIMFinalValue.insert(0, DataTypeIter->second);
1373
1374                 } else {
1375
1376                         strIMFinalValue.insert(0, "none:");
1377
1378                 }
1379
1380                 ProcessSaveData(wxT("IMPP;TYPE=home"), &strValue2, &boolValue2, &boolValue,
1381                         &iter, &ContactEditorData.HomeIMList, &ContactData,
1382                         wxT("ALTID"), &ContactEditorData.HomeIMListAltID,
1383                         wxT("PID"), &ContactEditorData.HomeIMListPID,
1384                         wxT("MEDIATYPE"), &ContactEditorData.HomeIMListMediatype,
1385                         wxT("PREF"), &ContactEditorData.HomeIMListPref,
1386                         wxT(""), &ContactEditorData.HomeIMListTokens );
1387
1388                 ResetSaveProcessData();
1389
1390         }
1391
1392         ResetSaveProcessData();
1393
1394         for (std::map<int,wxString>::iterator iter = ContactEditorData.BusinessIMList.begin();
1395                 iter != ContactEditorData.BusinessIMList.end(); ++iter){
1396
1397                 wxString strIMFinalValue = iter->second;
1398
1399                 ProcessCaptureStrings(&strIMFinalValue);
1400
1401                 if (ContactEditorData.BusinessIMListTypeInfo.find(iter->first) !=
1402                         ContactEditorData.BusinessIMListTypeInfo.end()){
1403
1404                         std::map<int,wxString>::iterator DataTypeIter = ContactEditorData.BusinessIMListTypeInfo.find(iter->first);
1405
1406                         strIMFinalValue.insert(0, ":");
1407                         strIMFinalValue.insert(0, DataTypeIter->second);
1408
1409                 } else {
1410
1411                         strIMFinalValue.insert(0, "none:");
1412
1413                 }
1414
1415                 ProcessSaveData(wxT("IMPP;TYPE=work"), &strValue2, &boolValue2, &boolValue,
1416                         &iter, &ContactEditorData.BusinessIMList, &ContactData,
1417                         wxT("ALTID"), &ContactEditorData.BusinessIMListAltID,
1418                         wxT("PID"), &ContactEditorData.BusinessIMListPID,
1419                         wxT("MEDIATYPE"), &ContactEditorData.BusinessIMListMediatype,
1420                         wxT("PREF"), &ContactEditorData.BusinessIMListPref,
1421                         wxT(""), &ContactEditorData.BusinessIMListTokens );
1422
1423                 ResetSaveProcessData();
1424
1425         }
1426
1427         ResetSaveProcessData();
1428
1429         for (std::map<int,wxString>::iterator iter = ContactEditorData.GeneralTelephoneList.begin();
1430                 iter != ContactEditorData.GeneralTelephoneList.end(); ++iter){
1431
1432                 wxString strAddressFinalValue = iter->second;
1433                 int DataID = iter->first;
1434
1435                 ProcessCaptureStrings(&strAddressFinalValue);
1436
1437                 if (MapDataExists(&DataID, &ContactEditorData.GeneralTelephoneListDataType)){
1438
1439                         std::map<int,wxString>::iterator DataTypeIter = ContactEditorData.GeneralTelephoneListDataType.find(iter->first);
1440
1441                         strAddressFinalValue.insert(0, ":");
1442                         strAddressFinalValue.insert(0, DataTypeIter->second);
1443
1444                 } else {
1445
1446                         strAddressFinalValue.insert(0, "tel:");
1447
1448                 }
1449
1450                 wxString strAddressTypeInfo;
1451
1452                 if (MapDataExists(&DataID, &ContactEditorData.GeneralTelephoneListTypeInfo)){
1453
1454                         strAddressTypeInfo = ContactEditorData.GeneralTelephoneListTypeInfo.find(iter->first)->second;
1455
1456                 }
1457
1458                 ProcessSaveData(wxT("TEL"), &strValue2, &boolValue2, &boolValue,
1459                         &iter, &strAddressFinalValue, &ContactData,
1460                         wxT("ALTID"), &ContactEditorData.GeneralTelephoneListAltID,
1461                         wxT("PID"), &ContactEditorData.GeneralTelephoneListPID,
1462                         wxT("TYPE"), &ContactEditorData.GeneralTelephoneListTypeInfo,
1463                         wxT("PREF"), &ContactEditorData.GeneralTelephoneListPref,
1464                         wxT(""), &ContactEditorData.GeneralTelephoneListTokens );
1465
1466                 ResetSaveProcessData();
1467
1468         }
1469
1470         ResetSaveProcessData();
1471
1472         for (std::map<int,wxString>::iterator iter = ContactEditorData.HomeTelephoneList.begin();
1473                 iter != ContactEditorData.HomeTelephoneList.end(); ++iter){
1474
1475                 wxString strAddressFinalValue = iter->second;
1476
1477                 ProcessCaptureStrings(&strAddressFinalValue);
1478
1479                 if (ContactEditorData.HomeTelephoneListDataType.find(iter->first) !=
1480                         ContactEditorData.HomeTelephoneListDataType.end()){
1481
1482                         std::map<int,wxString>::iterator DataTypeIter = ContactEditorData.HomeTelephoneListDataType.find(iter->first);
1483
1484                         strAddressFinalValue.insert(0, ":");
1485                         strAddressFinalValue.insert(0, DataTypeIter->second);
1486
1487                 } else {
1488
1489                         strAddressFinalValue.insert(0, "tel:");
1490
1491                 }
1492
1493                 ProcessSaveData(wxT("TEL"), &strValue2, &boolValue2, &boolValue,
1494                         &iter, &strAddressFinalValue, &ContactData,
1495                         wxT("ALTID"), &ContactEditorData.HomeTelephoneListAltID,
1496                         wxT("PID"), &ContactEditorData.HomeTelephoneListPID,
1497                         wxT("TYPE"), &ContactEditorData.HomeTelephoneListTypeInfo,
1498                         wxT("PREF"), &ContactEditorData.HomeTelephoneListPref,
1499                         wxT(""), &ContactEditorData.HomeTelephoneListTokens );
1500
1501                 ResetSaveProcessData();
1502
1503         }
1504
1505         ResetSaveProcessData();
1506
1507         for (std::map<int,wxString>::iterator iter = ContactEditorData.BusinessTelephoneList.begin();
1508                 iter != ContactEditorData.BusinessTelephoneList.end(); ++iter){
1509
1510                 wxString strAddressFinalValue = iter->second;
1511
1512                 ProcessCaptureStrings(&strAddressFinalValue);
1513
1514                 if (ContactEditorData.BusinessTelephoneListDataType.find(iter->first) !=
1515                         ContactEditorData.BusinessTelephoneListDataType.end()){
1516
1517                         std::map<int,wxString>::iterator DataTypeIter = ContactEditorData.BusinessTelephoneListDataType.find(iter->first);
1518
1519                         strAddressFinalValue.insert(0, ":");
1520                         strAddressFinalValue.insert(0, DataTypeIter->second);
1521
1522                 } else {
1523
1524                         strAddressFinalValue.insert(0, "tel:");
1525
1526                 }
1527
1528                 ProcessSaveData(wxT("TEL"), &strValue2, &boolValue2, &boolValue,
1529                         &iter, &strAddressFinalValue, &ContactData,
1530                         wxT("ALTID"), &ContactEditorData.BusinessTelephoneListAltID,
1531                         wxT("PID"), &ContactEditorData.BusinessTelephoneListPID,
1532                         wxT("TYPE"), &ContactEditorData.BusinessTelephoneListTypeInfo,
1533                         wxT("PREF"), &ContactEditorData.BusinessTelephoneListPref,
1534                         wxT(""), &ContactEditorData.BusinessTelephoneListTokens );
1535
1536                 ResetSaveProcessData();
1537
1538         }
1539
1540         ResetSaveProcessData();
1541
1542         for (std::map<int,wxString>::iterator iter = ContactEditorData.GeneralLanguageList.begin();
1543                 iter != ContactEditorData.GeneralLanguageList.end(); ++iter){
1544
1545                 intValue2 = iter->first;
1546
1547                 ProcessSaveData(wxT("LANG"), &strValue2, &boolValue2, &boolValue,
1548                         &iter, &ContactEditorData.GeneralLanguageList, &ContactData,
1549                         wxT("ALTID"), &ContactEditorData.GeneralLanguageListAltID,
1550                         wxT("PID"), &ContactEditorData.GeneralLanguageListPID,
1551                         wxT("PREF"), &ContactEditorData.GeneralLanguageListPref,
1552                         wxT(""), &ContactEditorData.GeneralLanguageListTokens );
1553
1554                 ResetSaveProcessData();
1555
1556         }
1557
1558         ResetSaveProcessData();
1559
1560         for (std::map<int,wxString>::iterator iter = ContactEditorData.HomeLanguageList.begin();
1561                 iter != ContactEditorData.HomeLanguageList.end(); ++iter){
1562
1563                 ProcessSaveData(wxT("LANG;TYPE=home"), &strValue2, &boolValue2, &boolValue,
1564                         &iter, &ContactEditorData.HomeLanguageList, &ContactData,
1565                         wxT("ALTID"), &ContactEditorData.HomeLanguageListAltID,
1566                         wxT("PID"), &ContactEditorData.HomeLanguageListPID,
1567                         wxT("PREF"), &ContactEditorData.HomeLanguageListPref,
1568                         wxT(""), &ContactEditorData.HomeLanguageListTokens );
1569
1570                 ResetSaveProcessData();
1571
1572         }
1573
1574         ResetSaveProcessData();
1575
1576         for (std::map<int,wxString>::iterator iter = ContactEditorData.BusinessLanguageList.begin();
1577                 iter != ContactEditorData.BusinessLanguageList.end(); ++iter){
1578
1579                 ProcessSaveData(wxT("LANG;TYPE=work"), &strValue2, &boolValue2, &boolValue,
1580                         &iter, &ContactEditorData.BusinessLanguageList, &ContactData,
1581                         wxT("ALTID"), &ContactEditorData.BusinessLanguageListAltID,
1582                         wxT("PID"), &ContactEditorData.BusinessLanguageListPID,
1583                         wxT("PREF"), &ContactEditorData.BusinessLanguageListPref,
1584                         wxT(""), &ContactEditorData.BusinessLanguageListTokens );
1585
1586                 ResetSaveProcessData();
1587
1588         }
1589
1590         ResetSaveProcessData();
1591
1592         for (std::map<int,wxString>::iterator iter = ContactEditorData.GeneralTZList.begin();
1593                 iter != ContactEditorData.GeneralTZList.end(); ++iter){
1594
1595                 ProcessSaveData(wxT("TZ"), &strValue2, &boolValue2, &boolValue,
1596                         &iter, &ContactEditorData.GeneralTZList, &ContactData,
1597                         wxT("ALTID"), &ContactEditorData.GeneralTZListAltID,
1598                         wxT("PID"), &ContactEditorData.GeneralTZListPID,
1599                         wxT("MEDIATYPE"), &ContactEditorData.GeneralTZListMediatype,
1600                         wxT("PREF"), &ContactEditorData.GeneralTZListPref,
1601                         wxT(""), &ContactEditorData.GeneralTZListTokens );
1602
1603                 ResetSaveProcessData();
1604
1605         }
1606
1607         ResetSaveProcessData();
1608
1609         for (std::map<int,wxString>::iterator iter = ContactEditorData.HomeTZList.begin();
1610                 iter != ContactEditorData.HomeTZList.end(); ++iter){
1611
1612                 ProcessSaveData(wxT("TZ;TYPE=home"), &strValue2, &boolValue2, &boolValue,
1613                         &iter, &ContactEditorData.HomeTZList, &ContactData,
1614                         wxT("ALTID"), &ContactEditorData.HomeTZListAltID,
1615                         wxT("PID"), &ContactEditorData.HomeTZListPID,
1616                         wxT("MEDIATYPE"), &ContactEditorData.HomeTZListMediatype,
1617                         wxT("PREF"), &ContactEditorData.HomeTZListPref,
1618                         wxT(""), &ContactEditorData.HomeTZListTokens );
1619
1620                 ResetSaveProcessData();
1621
1622         }
1623
1624         ResetSaveProcessData();
1625
1626         for (std::map<int,wxString>::iterator iter = ContactEditorData.BusinessTZList.begin();
1627                 iter != ContactEditorData.BusinessTZList.end(); ++iter){
1628
1629                 ProcessSaveData(wxT("TZ;TYPE=work"), &strValue2, &boolValue2, &boolValue,
1630                         &iter, &ContactEditorData.BusinessTZList, &ContactData,
1631                         wxT("ALTID"), &ContactEditorData.BusinessTZListAltID,
1632                         wxT("PID"), &ContactEditorData.BusinessTZListPID,
1633                         wxT("MEDIATYPE"), &ContactEditorData.BusinessTZListMediatype,
1634                         wxT("PREF"), &ContactEditorData.BusinessTZListPref,
1635                         wxT(""), &ContactEditorData.BusinessTZListTokens );
1636
1637                 ResetSaveProcessData();
1638
1639         }
1640
1641         ResetSaveProcessData();
1642
1643         for (std::map<int,wxString>::iterator iter = ContactEditorData.GeneralGeographyList.begin();
1644                 iter != ContactEditorData.GeneralGeographyList.end(); ++iter){
1645
1646                 wxString strGeoFinalValue = iter->second;
1647
1648                 ProcessCaptureStrings(&strGeoFinalValue);
1649
1650                 if (ContactEditorData.GeneralGeographyListDataType.find(iter->first) !=
1651                         ContactEditorData.GeneralGeographyListDataType.end()){
1652
1653                         std::map<int,wxString>::iterator DataTypeIter = ContactEditorData.GeneralGeographyListDataType.find(iter->first);
1654
1655                         strGeoFinalValue.insert(0, ":");
1656                         strGeoFinalValue.insert(0, DataTypeIter->second);
1657
1658                 } else {
1659
1660                         strGeoFinalValue.insert(0, "geo:");
1661
1662                 }
1663
1664                 ProcessSaveData(wxT("GEO"), &strValue2, &boolValue2, &boolValue,
1665                         &iter, &strGeoFinalValue, &ContactData,
1666                         wxT("ALTID"), &ContactEditorData.GeneralGeographyListAltID,
1667                         wxT("PID"), &ContactEditorData.GeneralGeographyListPID,
1668                         wxT("MEDIATYPE"), &ContactEditorData.GeneralGeographyListMediatype,
1669                         wxT("PREF"), &ContactEditorData.GeneralGeographyListPref,
1670                         wxT(""), &ContactEditorData.GeneralGeographyListTokens );
1671
1672                 ResetSaveProcessData();
1673
1674         }
1675
1676         ResetSaveProcessData();
1677
1678         for (std::map<int,wxString>::iterator iter = ContactEditorData.HomeGeographyList.begin();
1679                 iter != ContactEditorData.HomeGeographyList.end(); ++iter){
1680
1681                 wxString strGeoFinalValue = iter->second;
1682
1683                 ProcessCaptureStrings(&strGeoFinalValue);
1684
1685                 if (ContactEditorData.HomeGeographyListDataType.find(iter->first) !=
1686                         ContactEditorData.HomeGeographyListDataType.end()){
1687
1688                         std::map<int,wxString>::iterator DataTypeIter = ContactEditorData.HomeGeographyListDataType.find(iter->first);
1689
1690                         strGeoFinalValue.insert(0, ":");
1691                         strGeoFinalValue.insert(0, DataTypeIter->second);
1692
1693                 } else {
1694
1695                         strGeoFinalValue.insert(0, "geo:");
1696
1697                 }
1698
1699                 ProcessSaveData(wxT("GEO;TYPE=home"), &strValue2, &boolValue2, &boolValue,
1700                         &iter, &strGeoFinalValue, &ContactData,
1701                         wxT("ALTID"), &ContactEditorData.HomeGeographyListAltID,
1702                         wxT("PID"), &ContactEditorData.HomeGeographyListPID,
1703                         wxT("MEDIATYPE"), &ContactEditorData.HomeGeographyListMediatype,
1704                         wxT("PREF"), &ContactEditorData.HomeGeographyListPref,
1705                         wxT(""), &ContactEditorData.HomeGeographyListTokens );
1706
1707                 ResetSaveProcessData();
1708
1709         }
1710
1711         ResetSaveProcessData();
1712
1713         for (std::map<int,wxString>::iterator iter = ContactEditorData.BusinessGeographyList.begin();
1714                 iter != ContactEditorData.BusinessGeographyList.end(); ++iter){
1715
1716                 wxString strGeoFinalValue = iter->second;
1717
1718                 ProcessCaptureStrings(&strGeoFinalValue);
1719
1720                 if (ContactEditorData.BusinessGeographyListDataType.find(iter->first) !=
1721                         ContactEditorData.BusinessGeographyListDataType.end()){
1722
1723                         std::map<int,wxString>::iterator DataTypeIter = ContactEditorData.BusinessGeographyListDataType.find(iter->first);
1724
1725                         strGeoFinalValue.insert(0, ":");
1726                         strGeoFinalValue.insert(0, DataTypeIter->second);
1727
1728                 } else {
1729
1730                         strGeoFinalValue.insert(0, "geo:");
1731
1732                 }
1733
1734                 ProcessSaveData(wxT("GEO;TYPE=work"), &strValue2, &boolValue2, &boolValue,
1735                         &iter, &strGeoFinalValue, &ContactData,
1736                         wxT("ALTID"), &ContactEditorData.BusinessGeographyListAltID,
1737                         wxT("PID"), &ContactEditorData.BusinessGeographyListPID,
1738                         wxT("MEDIATYPE"), &ContactEditorData.BusinessGeographyListMediatype,
1739                         wxT("PREF"), &ContactEditorData.BusinessGeographyListPref,
1740                         wxT(""), &ContactEditorData.BusinessGeographyListTokens );
1741
1742                 ResetSaveProcessData();
1743
1744         }
1745
1746         ResetSaveProcessData();
1747
1748         for (std::map<int,wxString>::iterator iter = ContactEditorData.GeneralRelatedList.begin();
1749                 iter != ContactEditorData.GeneralRelatedList.end(); ++iter){
1750
1751                 ProcessSaveData(wxT("RELATED"), &strValue2, &boolValue2, &boolValue,
1752                         &iter, &ContactEditorData.GeneralRelatedList, &ContactData,
1753                         wxT("ALTID"), &ContactEditorData.GeneralRelatedListAltID,
1754                         wxT("PID"), &ContactEditorData.GeneralRelatedListPID,
1755                         wxT("LANGUAGE"), &ContactEditorData.GeneralRelatedListLanguage,
1756                         wxT("TYPE"), &ContactEditorData.GeneralRelatedListRelType,
1757                         wxT("PREF"), &ContactEditorData.GeneralRelatedListPref,
1758                         wxT(""), &ContactEditorData.GeneralRelatedListTokens );
1759
1760                 ResetSaveProcessData();
1761
1762         }
1763
1764         ResetSaveProcessData();
1765
1766         for (std::map<int,wxString>::iterator iter = ContactEditorData.GeneralWebsiteList.begin();
1767                 iter != ContactEditorData.GeneralWebsiteList.end(); ++iter){
1768
1769                 ProcessSaveData(wxT("URL"), &strValue2, &boolValue2, &boolValue,
1770                         &iter, &ContactEditorData.GeneralWebsiteList, &ContactData,
1771                         wxT("ALTID"), &ContactEditorData.GeneralWebsiteListAltID,
1772                         wxT("PID"), &ContactEditorData.GeneralWebsiteListPID,
1773                         wxT("MEDIATYPE"), &ContactEditorData.GeneralWebsiteListMediatype,
1774                         wxT("PREF"), &ContactEditorData.GeneralWebsiteListPref,
1775                         wxT(""), &ContactEditorData.GeneralWebsiteListTokens );
1776
1777                 ResetSaveProcessData();
1778
1779         }
1780
1781         ResetSaveProcessData();
1782
1783         for (std::map<int,wxString>::iterator iter = ContactEditorData.HomeWebsiteList.begin();
1784                 iter != ContactEditorData.HomeWebsiteList.end(); ++iter){
1785
1786                 ProcessSaveData(wxT("URL;TYPE=home"), &strValue2, &boolValue2, &boolValue,
1787                         &iter, &ContactEditorData.HomeWebsiteList, &ContactData,
1788                         wxT("ALTID"), &ContactEditorData.HomeWebsiteListAltID,
1789                         wxT("PID"), &ContactEditorData.HomeWebsiteListPID,
1790                         wxT("MEDIATYPE"), &ContactEditorData.HomeWebsiteListMediatype,
1791                         wxT("PREF"), &ContactEditorData.HomeWebsiteListPref,
1792                         wxT(""), &ContactEditorData.HomeWebsiteListTokens );
1793
1794                 ResetSaveProcessData();
1795
1796         }
1797
1798         ResetSaveProcessData();
1799
1800         for (std::map<int,wxString>::iterator iter = ContactEditorData.BusinessWebsiteList.begin();
1801                 iter != ContactEditorData.BusinessWebsiteList.end(); ++iter){
1802
1803                 ProcessSaveData(wxT("URL;TYPE=work"), &strValue2, &boolValue2, &boolValue,
1804                         &iter, &ContactEditorData.BusinessWebsiteList, &ContactData,
1805                         wxT("ALTID"), &ContactEditorData.BusinessWebsiteListAltID,
1806                         wxT("PID"), &ContactEditorData.BusinessWebsiteListPID,
1807                         wxT("MEDIATYPE"), &ContactEditorData.BusinessWebsiteListMediatype,
1808                         wxT("PREF"), &ContactEditorData.BusinessWebsiteListPref,
1809                         wxT(""), &ContactEditorData.BusinessWebsiteListTokens );
1810
1811                 ResetSaveProcessData();
1812
1813         }
1814
1815         ResetSaveProcessData();
1816
1817         for (std::map<int,wxString>::iterator iter = ContactEditorData.GeneralTitleList.begin();
1818                 iter != ContactEditorData.GeneralTitleList.end(); ++iter){
1819
1820                 ProcessSaveData(wxT("TITLE"), &strValue2, &boolValue2, &boolValue,
1821                         &iter, &ContactEditorData.GeneralTitleList, &ContactData,
1822                         wxT("ALTID"), &ContactEditorData.GeneralTitleListAltID,
1823                         wxT("PID"), &ContactEditorData.GeneralTitleListPID,
1824                         wxT("LANGUAGE"), &ContactEditorData.GeneralTitleListLanguage,
1825                         wxT("PREF"), &ContactEditorData.GeneralTitleListPref,
1826                         wxT(""), &ContactEditorData.GeneralTitleListTokens );
1827
1828                 ResetSaveProcessData();
1829
1830         }
1831
1832         ResetSaveProcessData();
1833
1834         for (std::map<int,wxString>::iterator iter = ContactEditorData.HomeTitleList.begin();
1835                 iter != ContactEditorData.HomeTitleList.end(); ++iter){
1836
1837                 ProcessSaveData(wxT("TITLE;TYPE=home"), &strValue2, &boolValue2, &boolValue,
1838                         &iter, &ContactEditorData.HomeTitleList, &ContactData,
1839                         wxT("ALTID"), &ContactEditorData.HomeTitleListAltID,
1840                         wxT("PID"), &ContactEditorData.HomeTitleListPID,
1841                         wxT("LANGUAGE"), &ContactEditorData.HomeTitleListLanguage,
1842                         wxT("PREF"), &ContactEditorData.HomeTitleListPref,
1843                         wxT(""), &ContactEditorData.HomeTitleListTokens );
1844
1845                 ResetSaveProcessData();
1846
1847         }
1848
1849         ResetSaveProcessData();
1850
1851         for (std::map<int,wxString>::iterator iter = ContactEditorData.BusinessTitleList.begin();
1852                 iter != ContactEditorData.BusinessTitleList.end(); ++iter){
1853
1854                 ProcessSaveData(wxT("TITLE;TYPE=work"), &strValue2, &boolValue2, &boolValue,
1855                         &iter, &ContactEditorData.BusinessTitleList, &ContactData,
1856                         wxT("ALTID"), &ContactEditorData.BusinessTitleListAltID,
1857                         wxT("PID"), &ContactEditorData.BusinessTitleListPID,
1858                         wxT("LANGUAGE"), &ContactEditorData.BusinessTitleListLanguage,
1859                         wxT("PREF"), &ContactEditorData.BusinessTitleListPref,
1860                         wxT(""), &ContactEditorData.BusinessTitleListTokens );
1861
1862                 ResetSaveProcessData();
1863
1864         }
1865
1866         ResetSaveProcessData();
1867
1868         for (std::map<int,wxString>::iterator iter = ContactEditorData.GeneralRoleList.begin();
1869                 iter != ContactEditorData.GeneralRoleList.end(); ++iter){
1870
1871                 ProcessSaveData(wxT("ROLE"), &strValue2, &boolValue2, &boolValue,
1872                         &iter, &ContactEditorData.GeneralRoleList, &ContactData,
1873                         wxT("ALTID"), &ContactEditorData.GeneralRoleListAltID,
1874                         wxT("PID"), &ContactEditorData.GeneralRoleListPID,
1875                         wxT("LANGUAGE"), &ContactEditorData.GeneralRoleListLanguage,
1876                         wxT("PREF"), &ContactEditorData.GeneralRoleListPref,
1877                         wxT(""), &ContactEditorData.GeneralRoleListTokens );
1878
1879                 ResetSaveProcessData();
1880
1881         }
1882
1883         ResetSaveProcessData();
1884
1885         for (std::map<int,wxString>::iterator iter = ContactEditorData.HomeRoleList.begin();
1886                 iter != ContactEditorData.HomeRoleList.end(); ++iter){
1887
1888                 ProcessSaveData(wxT("ROLE;TYPE=home"), &strValue2, &boolValue2, &boolValue,
1889                         &iter, &ContactEditorData.HomeRoleList, &ContactData,
1890                         wxT("ALTID"), &ContactEditorData.HomeRoleListAltID,
1891                         wxT("PID"), &ContactEditorData.HomeRoleListPID,
1892                         wxT("LANGUAGE"), &ContactEditorData.HomeRoleListLanguage,
1893                         wxT("PREF"), &ContactEditorData.HomeRoleListPref,
1894                         wxT(""), &ContactEditorData.HomeRoleListTokens );
1895
1896                 ResetSaveProcessData();
1897
1898         }
1899
1900         ResetSaveProcessData();
1901
1902         for (std::map<int,wxString>::iterator iter = ContactEditorData.BusinessRoleList.begin();
1903                 iter != ContactEditorData.BusinessRoleList.end(); ++iter){
1904
1905                 ProcessSaveData(wxT("ROLE;TYPE=work"), &strValue2, &boolValue2, &boolValue,
1906                         &iter, &ContactEditorData.BusinessRoleList, &ContactData,
1907                         wxT("ALTID"), &ContactEditorData.BusinessRoleListAltID,
1908                         wxT("PID"), &ContactEditorData.BusinessRoleListPID,
1909                         wxT("LANGUAGE"), &ContactEditorData.BusinessRoleListLanguage,
1910                         wxT("PREF"), &ContactEditorData.BusinessRoleListPref,
1911                         wxT(""), &ContactEditorData.BusinessRoleListTokens );
1912
1913                 ResetSaveProcessData();
1914
1915         }
1916
1917         ResetSaveProcessData();
1918
1919         for (std::map<int,wxString>::iterator iter = ContactEditorData.GeneralOrganisationsList.begin();
1920                 iter != ContactEditorData.GeneralOrganisationsList.end(); ++iter){
1921
1922                 ProcessSaveData(wxT("ORG"), &strValue2, &boolValue2, &boolValue,
1923                         &iter, &ContactEditorData.GeneralOrganisationsList, &ContactData,
1924                         wxT("ALTID"), &ContactEditorData.GeneralOrganisationsListAltID,
1925                         wxT("PID"), &ContactEditorData.GeneralOrganisationsListPID,
1926                         wxT("LANGUAGE"), &ContactEditorData.GeneralOrganisationsListLanguage,
1927                         wxT("SORT-AS"), &ContactEditorData.GeneralOrganisationsListSortAs,
1928                         wxT("PREF"), &ContactEditorData.GeneralOrganisationsListPref,
1929                         wxT(""), &ContactEditorData.GeneralOrganisationsListTokens );
1930
1931                 ResetSaveProcessData();
1932
1933         }
1934
1935         ResetSaveProcessData();
1936
1937         for (std::map<int,wxString>::iterator iter = ContactEditorData.HomeOrganisationsList.begin();
1938                 iter != ContactEditorData.HomeOrganisationsList.end(); ++iter){
1939
1940                 ProcessSaveData(wxT("ORG;TYPE=home"), &strValue2, &boolValue2, &boolValue,
1941                         &iter, &ContactEditorData.HomeOrganisationsList, &ContactData,
1942                         wxT("ALTID"), &ContactEditorData.HomeOrganisationsListAltID,
1943                         wxT("PID"), &ContactEditorData.HomeOrganisationsListPID,
1944                         wxT("LANGUAGE"), &ContactEditorData.HomeOrganisationsListLanguage,
1945                         wxT("SORT-AS"), &ContactEditorData.HomeOrganisationsListSortAs,
1946                         wxT("PREF"), &ContactEditorData.HomeOrganisationsListPref,
1947                         wxT(""), &ContactEditorData.HomeOrganisationsListTokens );
1948
1949                 ResetSaveProcessData();
1950
1951         }
1952
1953         ResetSaveProcessData();
1954
1955         for (std::map<int,wxString>::iterator iter = ContactEditorData.BusinessOrganisationsList.begin();
1956                 iter != ContactEditorData.BusinessOrganisationsList.end(); ++iter){
1957
1958                 ProcessSaveData(wxT("ORG;TYPE=work"), &strValue2, &boolValue2, &boolValue,
1959                         &iter, &ContactEditorData.BusinessOrganisationsList, &ContactData,
1960                         wxT("ALTID"), &ContactEditorData.BusinessOrganisationsListAltID,
1961                         wxT("PID"), &ContactEditorData.BusinessOrganisationsListPID,
1962                         wxT("LANGUAGE"), &ContactEditorData.BusinessOrganisationsListLanguage,
1963                         wxT("SORT-AS"), &ContactEditorData.BusinessOrganisationsListSortAs,
1964                         wxT("PREF"), &ContactEditorData.BusinessOrganisationsListPref,
1965                         wxT(""), &ContactEditorData.BusinessOrganisationsListTokens );
1966
1967                 ResetSaveProcessData();
1968
1969         }
1970
1971         ResetSaveProcessData();
1972
1973         for (std::map<int,wxString>::iterator iter = ContactEditorData.GeneralNoteList.begin();
1974                 iter != ContactEditorData.GeneralNoteList.end(); ++iter){
1975
1976                 ProcessSaveData(wxT("NOTE"), &strValue2, &boolValue2, &boolValue,
1977                         &iter, &ContactEditorData.GeneralNoteList, &ContactData,
1978                         wxT("ALTID"), &ContactEditorData.GeneralNoteListAltID,
1979                         wxT("PID"), &ContactEditorData.GeneralNoteListPID,
1980                         wxT("LANGUAGE"), &ContactEditorData.GeneralNoteListLanguage,
1981                         wxT("PREF"), &ContactEditorData.GeneralNoteListPref,
1982                         wxT(""), &ContactEditorData.GeneralNoteListTokens );
1983
1984                 ResetSaveProcessData();
1985
1986         }
1987
1988         ResetSaveProcessData();
1989
1990         for (std::map<int,wxString>::iterator iter = ContactEditorData.HomeNoteList.begin();
1991                 iter != ContactEditorData.HomeNoteList.end(); ++iter){
1992
1993                 ProcessSaveData(wxT("NOTE;TYPE=home"), &strValue2, &boolValue2, &boolValue,
1994                         &iter, &ContactEditorData.HomeNoteList, &ContactData,
1995                         wxT("ALTID"), &ContactEditorData.HomeNoteListAltID,
1996                         wxT("PID"), &ContactEditorData.HomeNoteListPID,
1997                         wxT("LANGUAGE"), &ContactEditorData.HomeNoteListLanguage,
1998                         wxT("PREF"), &ContactEditorData.HomeNoteListPref,
1999                         wxT(""), &ContactEditorData.HomeNoteListTokens );
2000
2001                 ResetSaveProcessData();
2002
2003         }
2004
2005         ResetSaveProcessData();
2006
2007         for (std::map<int,wxString>::iterator iter = ContactEditorData.BusinessNoteList.begin();
2008                 iter != ContactEditorData.BusinessNoteList.end(); ++iter){
2009
2010                 ProcessSaveData(wxT("NOTE;TYPE=work"), &strValue2, &boolValue2, &boolValue,
2011                         &iter, &ContactEditorData.BusinessNoteList, &ContactData,
2012                         wxT("ALTID"), &ContactEditorData.BusinessNoteListAltID,
2013                         wxT("PID"), &ContactEditorData.BusinessNoteListPID,
2014                         wxT("LANGUAGE"), &ContactEditorData.BusinessNoteListLanguage,
2015                         wxT("PREF"), &ContactEditorData.BusinessNoteListPref,
2016                         wxT(""), &ContactEditorData.BusinessNoteListTokens );
2017
2018                 ResetSaveProcessData();
2019
2020         }
2021
2022         ResetSaveProcessData();
2023
2024         for (std::map<int,wxString>::iterator iter = ContactEditorData.CategoriesList.begin();
2025                 iter != ContactEditorData.CategoriesList.end(); ++iter){
2026
2027                 ProcessSaveData(wxT("CATEGORIES"), &strValue2, &boolValue2, &boolValue,
2028                         &iter, &ContactEditorData.CategoriesList, &ContactData,
2029                         wxT("ALTID"), &ContactEditorData.CategoriesListAltID,
2030                         wxT("PID"), &ContactEditorData.CategoriesListPID,
2031                         wxT("TYPE"), &ContactEditorData.CategoriesListType,
2032                         wxT("PREF"), &ContactEditorData.CategoriesListPref,
2033                         wxT(""), &ContactEditorData.CategoriesListTokens );
2034
2035                 ResetSaveProcessData();
2036
2037         }
2038
2039         // Pictures.
2040
2041         for (std::map<int, std::string>::iterator iter = ContactEditorData.PicturesList.begin();
2042                 iter != ContactEditorData.PicturesList.end(); ++iter){
2043
2044                 int intValueIndex = iter->first;
2045
2046                 std::map<int, std::string>::iterator stdstriter;
2047                 std::map<int, wxString>::iterator enciter;
2048
2049                 striter = ContactEditorData.PicturesListPictureType.find(intValueIndex);
2050                 enciter = ContactEditorData.PicturesListPicEncType.find(intValueIndex);
2051
2052                 ProcessSaveData(wxT("PHOTO"), &strValue2, &boolValue2, &boolValue,
2053                         &iter, &ContactEditorData.PicturesList, &striter,
2054                         &enciter, &ContactData,
2055                         wxT("ALTID"), &ContactEditorData.PicturesListAltID,
2056                         wxT("PID"), &ContactEditorData.PicturesListPID,
2057                         wxT("TYPE"), &ContactEditorData.PicturesListType,
2058                         wxT("PREF"), &ContactEditorData.PicturesListPref,
2059                         wxT(""), &ContactEditorData.PicturesListTokens);
2060
2061                 ResetSaveProcessData();
2062
2063         }
2064
2065         ResetSaveProcessData();
2066
2067         // Logos.
2068
2069         for (std::map<int, std::string>::iterator iter = ContactEditorData.LogosList.begin();
2070                 iter != ContactEditorData.LogosList.end(); ++iter){
2071
2072                 int intValueIndex = iter->first;
2073
2074                 std::map<int, std::string>::iterator stdstriter;
2075                 std::map<int, wxString>::iterator enciter;
2076
2077                 striter = ContactEditorData.LogosListPictureType.find(intValueIndex);
2078                 enciter = ContactEditorData.LogosListPicEncType.find(intValueIndex);
2079
2080                 ProcessSaveData(wxT("LOGO"), &strValue2, &boolValue2, &boolValue,
2081                         &iter, &ContactEditorData.LogosList, &striter,
2082                         &enciter, &ContactData,
2083                         wxT("ALTID"), &ContactEditorData.LogosListAltID,
2084                         wxT("PID"), &ContactEditorData.LogosListPID,
2085                         wxT("TYPE"), &ContactEditorData.LogosListType,
2086                         wxT("PREF"), &ContactEditorData.LogosListPref,
2087                         wxT(""), &ContactEditorData.LogosListTokens );
2088
2089                 ResetSaveProcessData();
2090
2091         }
2092
2093         ResetSaveProcessData();
2094
2095         // Sounds.
2096
2097         for (std::map<int, std::string>::iterator iter = ContactEditorData.SoundsList.begin();
2098                 iter != ContactEditorData.SoundsList.end(); ++iter){
2099
2100                 int intValueIndex = iter->first;
2101
2102                 std::map<int, std::string>::iterator stdstriter;
2103                 std::map<int, wxString>::iterator enciter;
2104
2105                 striter = ContactEditorData.SoundsListAudioType.find(intValueIndex);
2106                 enciter = ContactEditorData.SoundsListAudioEncType.find(intValueIndex);
2107
2108                 ProcessSaveData(wxT("SOUND"), &strValue2, &boolValue2, &boolValue,
2109                         &iter, &ContactEditorData.SoundsList, &striter,
2110                         &enciter, &ContactData,
2111                         wxT("ALTID"), &ContactEditorData.SoundsListAltID,
2112                         wxT("PID"), &ContactEditorData.SoundsListPID,
2113                         wxT("TYPE"), &ContactEditorData.SoundsListType,
2114                         wxT("PREF"), &ContactEditorData.SoundsListPref,
2115                         wxT(""), &ContactEditorData.SoundsListTokens );
2116
2117                 ResetSaveProcessData();
2118
2119         }
2120
2121         ResetSaveProcessData();
2122
2123         for (std::map<int,wxString>::iterator iter = ContactEditorData.CalendarList.begin();
2124                 iter != ContactEditorData.CalendarList.end(); ++iter){
2125
2126                 ProcessSaveData(wxT("CALURI"), &strValue2, &boolValue2, &boolValue,
2127                         &iter, &ContactEditorData.CalendarList, &ContactData,
2128                         wxT("ALTID"), &ContactEditorData.CalendarListAltID,
2129                         wxT("PID"), &ContactEditorData.CalendarListPID,
2130                         wxT("MEDIATYPE"), &ContactEditorData.CalendarListMediatype,
2131                         wxT("TYPE"), &ContactEditorData.CalendarListType,
2132                         wxT("PREF"), &ContactEditorData.CalendarListPref,
2133                         wxT(""), &ContactEditorData.CalendarListTokens );
2134
2135                 ResetSaveProcessData();
2136
2137         }
2138
2139         ResetSaveProcessData();
2140
2141         for (std::map<int,wxString>::iterator iter = ContactEditorData.CalendarRequestList.begin();
2142                 iter != ContactEditorData.CalendarRequestList.end(); ++iter){
2143
2144                 ProcessSaveData(wxT("CALADRURI"), &strValue2, &boolValue2, &boolValue,
2145                         &iter, &ContactEditorData.CalendarRequestList, &ContactData,
2146                         wxT("ALTID"), &ContactEditorData.CalendarRequestListAltID,
2147                         wxT("PID"), &ContactEditorData.CalendarRequestListPID,
2148                         wxT("MEDIATYPE"), &ContactEditorData.CalendarRequestListMediatype,
2149                         wxT("TYPE"), &ContactEditorData.CalendarRequestListType,
2150                         wxT("PREF"), &ContactEditorData.CalendarRequestListPref,
2151                         wxT(""), &ContactEditorData.CalendarRequestListTokens );
2152
2153                 ResetSaveProcessData();
2154
2155         }
2156
2157         ResetSaveProcessData();
2158
2159         for (std::map<int,wxString>::iterator iter = ContactEditorData.FreeBusyList.begin();
2160                 iter != ContactEditorData.FreeBusyList.end(); ++iter){
2161
2162                 ProcessSaveData(wxT("FBURL"), &strValue2, &boolValue2, &boolValue,
2163                         &iter, &ContactEditorData.FreeBusyList, &ContactData,
2164                         wxT("ALTID"), &ContactEditorData.FreeBusyListAltID,
2165                         wxT("PID"), &ContactEditorData.FreeBusyListPID,
2166                         wxT("MEDIATYPE"), &ContactEditorData.FreeBusyListMediatype,
2167                         wxT("TYPE"), &ContactEditorData.FreeBusyListType,
2168                         wxT("PREF"), &ContactEditorData.FreeBusyListPref,
2169                         wxT(""), &ContactEditorData.FreeBusyListTokens );
2170
2171                 ResetSaveProcessData();
2172
2173         }
2174
2175         for (std::map<int, wxString>::iterator iter = ContactEditorData.KeyList.begin();
2176                 iter != ContactEditorData.KeyList.end(); ++iter){
2177
2178                 intValue2 = iter->first;
2179
2180                 // Get the key information.
2181
2182                 std::map<int, wxString>::iterator enciter;
2183
2184                 striter = ContactEditorData.KeyListDataType.find(intValue2);
2185
2186                 wxString strValueData;
2187
2188                 strValueData = iter->second;
2189                 strValueData.insert(0, wxT("data:") + striter->second + wxT(";base64,"));
2190
2191                 ProcessSaveData(wxT("KEY"), &strValue2, &boolValue2, &boolValue,
2192                         &iter, &strValueData, &ContactData,
2193                         wxT("ALTID"), &ContactEditorData.KeyListAltID,
2194                         wxT("PID"), &ContactEditorData.KeyListPID,
2195                         wxT("TYPE"), &ContactEditorData.KeyListType,
2196                         wxT("PREF"), &ContactEditorData.KeyListPref,
2197                         wxT(""), &ContactEditorData.KeyListTokens );
2198
2199                 ResetSaveProcessData();
2200
2201         }
2202
2203         // Vendor specific items.
2204
2205         ResetSaveProcessData();
2206
2207         for (std::map<int,wxString>::iterator iter = ContactEditorData.VendorList.begin();
2208                 iter != ContactEditorData.VendorList.end(); ++iter){
2209
2210                 intValue2 = iter->first;
2211
2212                 // Get the IANA PEN number.
2213
2214                 striter = ContactEditorData.VendorListPEN.find(intValue2);
2215
2216                 if (striter->first == intValue2){
2217
2218                         strValue2 = striter->second;
2219
2220                 }
2221
2222                 // Get the element name.
2223
2224                 striter = ContactEditorData.VendorListElement.find(intValue2);
2225
2226                 if (striter->first == intValue2){
2227
2228                         strValue3 = striter->second;
2229
2230                 }
2231
2232                 // Get the address.
2233
2234                 striter = ContactEditorData.VendorList.find(intValue2);
2235
2236                 if (striter->first == intValue2){
2237
2238                         strValue = striter->second;
2239
2240                 }
2241
2242                 // Add to the vCard.
2243
2244                 if (boolValue == TRUE){
2245
2246                         ContactData.AddRaw(wxT("VND-") + strValue2 + wxT("-") + strValue3, strValue);
2247
2248                 } else {
2249
2250                         ContactData.Add(wxT("VND-") + strValue2 + wxT("-") + strValue3, strValue, FALSE);
2251
2252                 }
2253
2254                 ResetSaveProcessData();
2255
2256         }
2257
2258         ResetSaveProcessData();
2259
2260         // X-Tokens.
2261
2262         for (std::map<int,wxString>::iterator iter = ContactEditorData.XTokenList.begin();
2263                 iter != ContactEditorData.XTokenList.end(); ++iter){
2264
2265                 intValue2 = iter->first;
2266
2267                 // Get the element name.
2268
2269                 striter = ContactEditorData.XTokenListTokens.find(intValue2);
2270
2271                 if (striter->first == intValue2){
2272
2273                         strValue2 = striter->second;
2274
2275                 }
2276
2277                 // Get the address.
2278
2279                 striter = ContactEditorData.XTokenList.find(intValue2);
2280
2281                 if (striter->first == intValue2){
2282
2283                         strValue = striter->second;
2284
2285                 }
2286
2287                 // Add to the vCard.
2288
2289                 if (boolValue == TRUE){
2290
2291                         ContactData.AddRaw(wxT("X-") + strValue2, strValue);
2292
2293                 } else {
2294
2295                         ContactData.Add(wxT("X-") + strValue2, strValue, FALSE);
2296
2297                 }
2298
2299                 ResetSaveProcessData();
2300
2301         }
2302
2303         ResetSaveProcessData();
2304
2305         if (ContactEditorData.FullNamesList.size() == 0){
2306
2307                 wxString FullName = cmbDisplayAs->GetValue();
2308                 ContactEditorData.FullNamesList.insert(std::make_pair(0, FullName));
2309                 ContactEditorData.FullNamesListAltID.insert(std::make_pair(0, wxT("")));
2310                 ContactEditorData.FullNamesListPID.insert(std::make_pair(0, wxT("")));
2311                 ContactEditorData.FullNamesListType.insert(std::make_pair(0, wxT("")));
2312                 ContactEditorData.FullNamesListLanguage.insert(std::make_pair(0, wxT("")));
2313                 ContactEditorData.FullNamesListPref.insert(std::make_pair(0, 0));
2314                 ContactEditorData.FullNamesListTokens.insert(std::make_pair(0, wxT("")));
2315                 FNFirst = FALSE;
2316
2317         }
2318
2319         for (std::map<int, wxString>::iterator iter = ContactEditorData.FullNamesList.begin();
2320                 iter != ContactEditorData.FullNamesList.end(); ++iter){
2321
2322                 if (FNFirst == TRUE){
2323
2324                         iter->second = cmbDisplayAs->GetValue();
2325                         FNFirst = FALSE;
2326
2327                 }
2328
2329                 std::map<int,wxString>::iterator mapS;
2330
2331                 mapS = ContactEditorData.FullNamesListTokens.find(iter->first);
2332
2333                 ProcessSaveData(wxT("FN"), &strValue2, &boolValue2, &boolValue,
2334                         &iter, &ContactEditorData.FullNamesList, &ContactData,
2335                         wxT("ALTID"), &ContactEditorData.FullNamesListAltID,
2336                         wxT("PID"), &ContactEditorData.FullNamesListPID,
2337                         wxT("TYPE"), &ContactEditorData.FullNamesListType,
2338                         wxT("LANGUAGE"), &ContactEditorData.FullNamesListLanguage,
2339                         wxT("PREF"), &ContactEditorData.FullNamesListPref,
2340                         wxT(""), &ContactEditorData.FullNamesListTokens );
2341
2342                 // Get the address.
2343
2344                 ResetSaveProcessData();
2345
2346         }
2347
2348         // Insert revision (REV) date.
2349
2350         // Get today's date and time.
2351
2352         wxDateTime DateTimeNow = wxDateTime::Now();
2353
2354         wxString DateRev;
2355
2356         // Set year, month and date.
2357
2358         int intYear = DateTimeNow.GetYear();
2359         int intMonth = DateTimeNow.GetMonth();
2360         int intDay = DateTimeNow.GetDay();
2361
2362         DateRev.Append(wxT("0") + wxString::Format(wxT("%i"), intYear));
2363
2364         if (intMonth < 10){
2365
2366                 DateRev.Append(wxT("0") + wxString::Format(wxT("%i"), intMonth));
2367
2368         } else {
2369
2370                 DateRev.Append(wxString::Format(wxT("%i"), intMonth));
2371
2372         }
2373
2374         if (intDay < 10){
2375
2376                 DateRev.Append(wxT("0") + wxString::Format(wxT("%i"), intDay));
2377
2378         } else {
2379
2380                 DateRev.Append(wxString::Format(wxT("%i"), intDay));
2381
2382         }
2383
2384         DateRev.Append(wxT("T"));
2385
2386         // Set hour, minute and second.
2387
2388         int intHour = DateTimeNow.GetHour();
2389         int intMinute = DateTimeNow.GetMinute();
2390         int intSecond = DateTimeNow.GetSecond();
2391
2392         if (intHour < 10){
2393
2394                 DateRev.Append(wxT("0") + wxString::Format(wxT("%i"), intHour));
2395
2396         } else {
2397
2398                 DateRev.Append(wxString::Format(wxT("%i"), intHour));
2399
2400         }
2401
2402         if (intMinute < 10){
2403
2404                 DateRev.Append(wxT("0") + wxString::Format(wxT("%i"), intMinute));
2405
2406         } else {
2407
2408                 DateRev.Append(wxString::Format(wxT("%i"), intMinute));
2409
2410         }
2411
2412         if (intSecond < 10){
2413
2414                 DateRev.Append(wxT("0") + wxString::Format(wxT("%i"), intSecond));
2415
2416         } else {
2417
2418                 DateRev.Append(wxString::Format(wxT("%i"), intSecond));
2419
2420         }
2421
2422         DateRev.Append(wxT("Z"));
2423
2424         ContactData.Add(wxT("UID"), ContactEditorData.UIDToken, FALSE);
2425
2426         // End the vCard File.
2427
2428         ContactData.Add(wxT("END"), wxT("VCARD"), FALSE);*/
2429
2430         FMTimer.Stop();
2431         ContactEditorData.SaveFile(FilenameFinal);
2432         //ContactData.WriteFile(FilenameFinal);
2433
2434         vCard34Conv ConvFileFun;
2435
2436         wxString wxSData;
2437
2438         ConvFileFun.ConvertToV3(FilenameFinal, &wxSData);
2439
2440         wxString AccountDirPrefix;
2441         wxString AccountDir;
2442         wxString PrefDir;
2443
2444 #if defined(__HAIKU__)
2445
2446 #elif defined(__APPLE__)
2447
2448         PrefDir = GetUserPrefDir();
2449
2450         wxStringTokenizer wSTFilename(wxSContactFilename, wxT("/"));
2451
2452 #elif defined(__WIN32__)
2453
2454         PrefDir = GetUserPrefDir();
2455
2456         wxStringTokenizer wSTFilename(wxSContactFilename, wxT("\\"));
2457
2458 #else
2459
2460         PrefDir = GetUserPrefDir();
2461
2462         wxStringTokenizer wSTFilename(wxSContactFilename, wxT("/"));
2463
2464 #endif
2465
2466         XABPreferences PrefData(PrefDir);
2467
2468         wxString AccountType;
2469
2470         for (int i = 0; i < PrefData.accounts.GetCount(); i++){
2471
2472                 AccountDir = PrefData.accounts.GetAccountDirectory(i) + wxT(".carddav");
2473
2474                 if (AccountDir == wxSContactAccount){
2475
2476                         AccountDirPrefix = PrefData.accounts.GetAccountDirPrefix(i);
2477                         AccountDirPrefix.Trim();
2478                         AccountType = PrefData.accounts.GetAccountType(i);
2479                         break;
2480
2481                 }
2482
2483         }
2484
2485         wxString wxSplitFilename;
2486         wxString wxSDataURL;
2487
2488         while(wSTFilename.HasMoreTokens()){
2489
2490                 wxSplitFilename = wSTFilename.GetNextToken();
2491
2492         }
2493
2494         wxSDataURL = wxSplitFilename;
2495
2496         // Find out if the filename exists in the table.
2497
2498         if (AccountType == wxT("CardDAV") || AccountType == wxT("carddav")){
2499
2500                 wxString ETagResult;
2501                 wxString ETagOriginal;
2502
2503                 ETagDB *ETagDBPtr = NULL;
2504
2505                 ETagDBPtr = ETagTmrPtr->GetPointer(wxSContactAccount);
2506
2507                 wxString wxSETag = ETagDBPtr->GetETag(wxSplitFilename);
2508                 wxString wxSETagOrig = ETagDBPtr->GetETagOriginal(wxSplitFilename);
2509
2510                 if (wxSETagOrig.IsEmpty()){
2511
2512                         // Generate the ETag.
2513
2514                         wxSETagOrig = wxString::Format(wxT("%X%X%X%X"), rand() % 1024, rand() % 1024, rand() % 1024, rand() % 1024);
2515
2516                 }
2517
2518                 if (wxSETag.IsEmpty()){
2519
2520                         // Update empty ETag.
2521
2522                         wxSETag = wxSETagOrig;
2523                         ETagDBPtr->UpdateETag(wxSplitFilename, wxSETag, wxSETagOrig);
2524
2525                 } else {
2526
2527                         // Don't change original ETag.
2528
2529                         wxSETag = wxString::Format(wxT("%X%X%X%X"), rand() % 1024, rand() % 1024, rand() % 1024, rand() % 1024);
2530                         ETagDBPtr->UpdateETag(wxSplitFilename, wxSETag);
2531
2532                 }
2533
2534                 if (EditMode == FALSE){
2535
2536                         ActMgrPtr->AddTask(0, cmbDisplayAs->GetValue(), wxSContactAccount, wxSDataURL, wxSplitFilename, FilenameFinal, wxSData);
2537                         EditMode = TRUE;
2538                         FMTimer.SetFilename(FilenameFinal);
2539                         FMTimer.UpdateTimestamp();
2540                         FMTimer.Start(10000, FALSE);
2541
2542                         wxCommandEvent reloadevent(RELOADCONTACTLIST);
2543                         reloadevent.SetString(wxSContactAccount);
2544                         wxPostEvent(this->GetParent(), reloadevent);
2545
2546                 } else {
2547
2548                         ActMgrPtr->AddTask(1, cmbDisplayAs->GetValue(), wxSContactAccount, wxSDataURL, wxSplitFilename, FilenameFinal, wxSData);
2549                         FMTimer.UpdateTimestamp();
2550                         FMTimer.Start(10000, FALSE);
2551
2552                 }
2553
2554         }
2555
2556         // Send a notification to update the main window
2557         // with the new details.
2558
2559         UCNotif *ucd;
2560         ucd = new UCNotif;
2561
2562         // TODO: Workout nickname settings by priority and
2563         // type.
2564
2565         vCardName NameData;
2566
2567         NameData.Forename = txtForename->GetValue();
2568         NameData.Surname = txtSurname->GetValue();
2569         NameData.OtherNames = txtOtherNames->GetValue();
2570         NameData.Title = txtTitle->GetValue();
2571         NameData.Suffix = txtSuffix->GetValue();
2572
2573         ucd->ContactAccount = wxSContactAccount;
2574         ucd->ContactFilename = FilenameFinal;
2575         ucd->ContactName = cmbDisplayAs->GetValue();
2576         ucd->ContactNameArray = NameData;
2577
2578         for (std::map<int,wxString>::iterator gniter = ContactEditorData.GeneralNicknamesList.begin();
2579                 gniter != ContactEditorData.GeneralNicknamesList.end(); gniter++){
2580
2581                 ucd->ContactNickname = gniter->second;
2582                 break;
2583
2584         }
2585
2586         wxCommandEvent event2(CE_UPDATECONTACTLIST);
2587         event2.SetClientData(ucd);
2588         wxPostEvent(MainPtr, event2);
2589
2590 }
2591
2592 void frmContactEditor::SaveCloseContact( wxCommandEvent& event )
2593 {
2594
2595         // Save the updated contact data and close the form.
2596
2597         wxCommandEvent NullEvent;
2598         this->SaveContact(NullEvent);
2599         this->Close();
2600
2601 }