source/contacteditor/frmContactEditor-Load.cpp

   1 // frmContactEditor-Load.cpp - frmContactEditor load contact subroutines.
   2 //
   3 // (c) 2012-2015 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 <map>
  20
  21 #include <wx/ffile.h>
  22 #include <wx/tokenzr.h>
  23 #include <wx/datetime.h>
  24 #include <wx/dir.h>
  25
  26 #include "frmContactEditor.h"
  27
  28 #include "../enums.h"
  29 #include "../version.h"
  30 #include "../vcard/vcard.h"
  31 #include "../common/textprocessing.h"
  32 #include "../common/dirs.h"
  33 #include "cdo/ContactDataObject.h"
  34
  35 bool frmContactEditor::LoadContact(wxString Filename){
  36
  37         // Load the contact into the contact editor.
  38
  39         wxFFile ContactFile;
  40         wxString wxSContactString;
  41         wxString ContactLine;
  42         vCard ContactData;
  43         XABViewMode XVMData;
  44         if (StartupEditMode == FALSE){
  45                 XVMData = MainPtr->GetViewMode();
  46         }
  47
  48         wxSContactFilename = Filename;
  49
  50         ContactLoadStatus LoadResult = ContactEditorData.LoadFile(Filename);
  51
  52         switch(LoadResult){
  53
  54                 case CONTACTLOAD_OK:
  55                         break;
  56                 case CONTACTLOAD_FILEMISSING:
  57                         wxMessageBox(_("The file with the filename given does not exist."),
  58                                 _("Contact not found"), wxICON_ERROR);
  59                         this->Close();
  60                         return FALSE;
  61                         break;
  62                 case CONTACTLOAD_FILEERROR:
  63                         wxMessageBox(_("The file with the filename given cannot be opened due to an error while trying open it."),
  64                                 _("Error loading contact"), wxICON_ERROR);
  65                         this->Close();
  66                         return FALSE;
  67                         break;
  68                 case CONTACTLOAD_FILEINVALIDFORMAT:
  69                                 wxMessageBox(_("This file is not a vCard 4.0 contact and is not supported under Xestia Address Book."),
  70                                         _("Contact not supported"), wxICON_ERROR);
  71                         this->Close();
  72                         return FALSE;
  73                         break;
  74                 case CONTACTLOAD_FILEBASESPECFAIL:
  75                         wxMessageBox(_("This file is not a vCard 4.0 contact and is not supported under Xestia Address Book."),
  76                                 _("Contact not supported"), wxICON_ERROR);
  77                         this->Close();
  78                         return FALSE;
  79                         break;
  80
  81         };
  82
  83         // Get the line.
  84
  85         wxString wxSProperty;
  86         wxString wxSPropertySeg1;
  87         wxString wxSPropertySeg2;
  88         wxString wxSPropertyNextLine;
  89         int NicknameCount = 0;
  90         int ADRCount = 0;
  91         int EmailCount = 0;
  92         int IMPPCount = 0;
  93         int TelCount = 0;
  94         int LangCount = 0;
  95         int TZCount = 0;
  96         int GeoCount = 0;
  97         int URLCount = 0;
  98         int RelatedCount = 0;
  99         int TitleCount = 0;
 100         int RoleCount = 0;
 101         int OrgCount = 0;
 102         int NoteCount = 0;
 103         int CategoryCount = 0;
 104         int PhotoCount = 0;
 105         int LogoCount = 0;
 106         int SoundCount = 0;
 107         int CalAdrCount = 0;
 108         int CalReqAdrCount = 0;
 109         int FreeBusyCount = 0;
 110         int KeyCount = 0;
 111         int VendorCount = 0;
 112         int XTokenCount = 0;
 113
 114         // Process the unique ID (UID)
 115
 116         // Do nothing at the moment.
 117
 118         // Process the contact type (KIND) (frmContactEditor-LoadGroup.cpp)
 119
 120         LoadKind(&ContactEditorData.ContactKind);
 121
 122         // Process the Birthday (BDAY) (frmContactEditor-LoadBADays.cpp)
 123
 124         LoadBirthday(&ContactEditorData.Birthday, &ContactEditorData.BirthdayText);
 125
 126         // Process the Anniversary (ANNIVERSARY) (frmContactEditor-LoadBADays.cpp)
 127
 128         LoadAnniversary(&ContactEditorData.Anniversary, &ContactEditorData.AnniversaryText);
 129
 130         // Process the Gender (GENDER) (frmContactEditor-LoadGender.cpp)
 131
 132         LoadGender(&ContactEditorData.Gender, &ContactEditorData.GenderDetails);
 133
 134         // Process the Name (N) (frmContactEditor-LoadName.cpp)
 135
 136         LoadName(&ContactEditorData.NameTitle, &ContactEditorData.NameForename,
 137                 &ContactEditorData.NameSurname, &ContactEditorData.NameOtherNames,
 138                 &ContactEditorData.NameSuffix);
 139
 140         // Process the group members (MEMBER) (frmContactEditor-LoadGroup.cpp)
 141
 142         LoadMember(&ContactEditorData.GroupsList);
 143
 144         // Process the addresses (ADR) (frmContactEditor-LoadAddress.cpp)
 145
 146         LoadAddress(&ContactEditorData.GeneralAddressList,
 147                 &ContactEditorData.GeneralAddressListTown,
 148                 &ContactEditorData.GeneralAddressListCounty,
 149                 &ContactEditorData.GeneralAddressListPostCode,
 150                 &ContactEditorData.GeneralAddressListPref,
 151                 &ContactEditorData.HomeAddressList,
 152                 &ContactEditorData.HomeAddressListTown,
 153                 &ContactEditorData.HomeAddressListCounty,
 154                 &ContactEditorData.HomeAddressListPostCode,
 155                 &ContactEditorData.HomeAddressListPref,
 156                 &ContactEditorData.BusinessAddressList,
 157                 &ContactEditorData.BusinessAddressListTown,
 158                 &ContactEditorData.BusinessAddressListCounty,
 159                 &ContactEditorData.BusinessAddressListPostCode,
 160                 &ContactEditorData.BusinessAddressListPref,
 161                 &ADRCount);
 162
 163         // Process the timezones (TZ).
 164
 165         LoadData(&ContactEditorData.GeneralTZList,
 166                 &ContactEditorData.GeneralTZListPref,
 167                 lboTimezones,
 168                 &ContactEditorData.HomeTZList,
 169                 &ContactEditorData.HomeTZListPref,
 170                 lboHomeTimezones,
 171                 &ContactEditorData.BusinessTZList,
 172                 &ContactEditorData.BusinessTZListPref,
 173                 lboBusinessTimezones,
 174                 &TZCount);
 175
 176         // Process the emails (EMAIL).
 177
 178         LoadData(&ContactEditorData.GeneralEmailList,
 179                 &ContactEditorData.GeneralEmailListPref,
 180                 lboEmails,
 181                 &ContactEditorData.HomeEmailList,
 182                 &ContactEditorData.HomeEmailListPref,
 183                 lboHomeEmails,
 184                 &ContactEditorData.BusinessEmailList,
 185                 &ContactEditorData.BusinessEmailListPref,
 186                 lboBusinessEmail,
 187                 &EmailCount);
 188
 189         // Process the nicknames (NICKNAME).
 190
 191         LoadData(&ContactEditorData.GeneralNicknamesList,
 192                 &ContactEditorData.GeneralNicknamesListPref,
 193                 lboNicknames,
 194                 &ContactEditorData.HomeNicknamesList,
 195                 &ContactEditorData.HomeNicknamesListPref,
 196                 lboHomeNicknames,
 197                 &ContactEditorData.BusinessNicknamesList,
 198                 &ContactEditorData.BusinessNicknamesListPref,
 199                 lboBusinessNicknames,
 200                 &NicknameCount);
 201
 202         // Process the languages (LANG).
 203
 204         LoadData(&ContactEditorData.GeneralLanguageList,
 205                 &ContactEditorData.GeneralLanguageListPref,
 206                 lboLanguages,
 207                 &ContactEditorData.HomeLanguageList,
 208                 &ContactEditorData.HomeLanguageListPref,
 209                 lboHomeLanguages,
 210                 &ContactEditorData.BusinessLanguageList,
 211                 &ContactEditorData.BusinessLanguageListPref,
 212                 lboBusinessLanguages,
 213                 &LangCount);
 214
 215         // Process the geopositiosn (GEO).
 216
 217         LoadData(&ContactEditorData.GeneralGeographyList,
 218                 &ContactEditorData.GeneralGeographyListPref,
 219                 lboGeoposition,
 220                 &ContactEditorData.HomeGeographyList,
 221                 &ContactEditorData.HomeGeographyListPref,
 222                 lboHomeGeoposition,
 223                 &ContactEditorData.BusinessGeographyList,
 224                 &ContactEditorData.BusinessGeographyListPref,
 225                 lboBusinessGeoposition,
 226                 &GeoCount);
 227
 228         // Process the websites (URL).
 229
 230         LoadData(&ContactEditorData.GeneralWebsiteList,
 231                 &ContactEditorData.GeneralWebsiteListPref,
 232                 lboWebsites,
 233                 &ContactEditorData.HomeWebsiteList,
 234                 &ContactEditorData.HomeWebsiteListPref,
 235                 lboHomeWebsites,
 236                 &ContactEditorData.BusinessWebsiteList,
 237                 &ContactEditorData.BusinessWebsiteListPref,
 238                 lboBusinessWebsites,
 239                 &URLCount);
 240
 241         // Process the titles (TITLE).
 242
 243         LoadData(&ContactEditorData.GeneralTitleList,
 244                 &ContactEditorData.GeneralTitleListPref,
 245                 lboTitles,
 246                 &ContactEditorData.HomeTitleList,
 247                 &ContactEditorData.HomeTitleListPref,
 248                 lboHomeTitles,
 249                 &ContactEditorData.BusinessTitleList,
 250                 &ContactEditorData.BusinessTitleListPref,
 251                 lboBusinessTitles,
 252                 &TitleCount);
 253
 254         // Process the roles (ROLE).
 255
 256         LoadData(&ContactEditorData.GeneralRoleList,
 257                 &ContactEditorData.GeneralRoleListPref,
 258                 lboRoles,
 259                 &ContactEditorData.HomeRoleList,
 260                 &ContactEditorData.HomeRoleListPref,
 261                 lboHomeRoles,
 262                 &ContactEditorData.BusinessRoleList,
 263                 &ContactEditorData.BusinessRoleListPref,
 264                 lboBusinessRoles,
 265                 &RoleCount);
 266
 267         // Process the roles (ORG).
 268
 269         LoadData(&ContactEditorData.GeneralOrganisationsList,
 270                 &ContactEditorData.GeneralOrganisationsListPref,
 271                 lboOrganisations,
 272                 &ContactEditorData.HomeOrganisationsList,
 273                 &ContactEditorData.HomeOrganisationsListPref,
 274                 lboHomeOrganisations,
 275                 &ContactEditorData.BusinessOrganisationsList,
 276                 &ContactEditorData.BusinessOrganisationsListPref,
 277                 lboBusinessOrganisations,
 278                 &OrgCount);
 279
 280         // Process the notes (NOTE).
 281
 282         LoadData(&ContactEditorData.GeneralNoteList,
 283                 &ContactEditorData.GeneralNoteListPref,
 284                 lboNotes,
 285                 &ContactEditorData.HomeNoteList,
 286                 &ContactEditorData.HomeNoteListPref,
 287                 lboHomeNotes,
 288                 &ContactEditorData.BusinessNoteList,
 289                 &ContactEditorData.BusinessNoteListPref,
 290                 lboBusinessNotes,
 291                 &NoteCount);
 292
 293         // Process the categories (CATEGORIES).
 294
 295         LoadData(&ContactEditorData.CategoriesList,
 296                 &ContactEditorData.CategoriesListPref,
 297                 lboCategories,
 298                 &CategoryCount);
 299
 300         // Process the telephone numbers (TEL).
 301
 302         LoadData(&ContactEditorData.GeneralTelephoneList,
 303                 &ContactEditorData.GeneralTelephoneListPref,
 304                 &ContactEditorData.GeneralTelephoneListTypeInfo,
 305                 lboTelephone,
 306                 &ContactEditorData.HomeTelephoneList,
 307                 &ContactEditorData.HomeTelephoneListPref,
 308                 &ContactEditorData.HomeTelephoneListTypeInfo,
 309                 lboHomeTelephone,
 310                 &ContactEditorData.BusinessTelephoneList,
 311                 &ContactEditorData.BusinessTelephoneListPref,
 312                 &ContactEditorData.BusinessTelephoneListTypeInfo,
 313                 lboBusinessTelephone,
 314                 &TelCount);
 315
 316         // Process the instant messaging (IMPP).
 317
 318         LoadData(&ContactEditorData.GeneralIMListTypeInfo,
 319                 &ContactEditorData.GeneralIMListPref,
 320                 &ContactEditorData.GeneralIMList,
 321                 lboIM,
 322                 &ContactEditorData.HomeIMListTypeInfo,
 323                 &ContactEditorData.HomeIMListPref,
 324                 &ContactEditorData.HomeIMList,
 325                 lboHomeIM,
 326                 &ContactEditorData.BusinessIMListTypeInfo,
 327                 &ContactEditorData.BusinessIMListPref,
 328                 &ContactEditorData.BusinessIMList,
 329                 lboBusinessIM,
 330                 &IMPPCount);
 331
 332         // Process the photos (PHOTO).
 333
 334         LoadPictureData("PHOTO",
 335                 &ContactEditorData.PicturesList,
 336                 &ContactEditorData.PicturesListPref,
 337                 &ContactEditorData.PicturesListType,
 338                 lboPictures,
 339                 &PhotoCount);
 340
 341         // Process the logos (LOGO).
 342
 343         LoadPictureData("LOGO",
 344                 &ContactEditorData.LogosList,
 345                 &ContactEditorData.LogosListPref,
 346                 &ContactEditorData.LogosListType,
 347                 lboLogos,
 348                 &LogoCount);
 349
 350         // Process the sounds (SOUND).
 351
 352         LoadPictureData("SOUND",
 353                 &ContactEditorData.SoundsList,
 354                 &ContactEditorData.SoundsListPref,
 355                 &ContactEditorData.SoundsListType,
 356                 lboSounds,
 357                 &SoundCount);
 358
 359         // Process the calendar addresses (CALURI).
 360
 361         LoadData("CALURI",
 362                 &ContactEditorData.CalendarList,
 363                 &ContactEditorData.CalendarListPref,
 364                 &ContactEditorData.CalendarListType,
 365                 NULL,
 366                 lboCalendarAddresses,
 367                 &CalAdrCount);
 368
 369         // Process the calendar request addresses (CALADRURI).
 370
 371         LoadData("CALADRURI",
 372                 &ContactEditorData.CalendarRequestList,
 373                 &ContactEditorData.CalendarRequestListPref,
 374                 &ContactEditorData.CalendarRequestListType,
 375                 NULL,
 376                 lboCalendarRequestAddress,
 377                 &CalReqAdrCount);
 378
 379         // Process the free busy addresses (FBURL).
 380
 381         LoadData("FBURL",
 382                 &ContactEditorData.FreeBusyList,
 383                 &ContactEditorData.FreeBusyListPref,
 384                 &ContactEditorData.FreeBusyListType,
 385                 NULL,
 386                 lboFreeBusyAddresses,
 387                 &FreeBusyCount);
 388
 389         // Process the keys. (KEY)
 390
 391         LoadData("KEY",
 392                 &ContactEditorData.KeyList,
 393                 &ContactEditorData.KeyListPref,
 394                 &ContactEditorData.KeyListType,
 395                 &ContactEditorData.KeyListDataType,
 396                 lboKeys,
 397                 &KeyCount);
 398
 399         // Process the vendor specific information (VND-*).
 400
 401         LoadVendorData(&ContactEditorData.VendorListPEN,
 402                 &ContactEditorData.VendorListElement,
 403                 lboVendorNamespace,
 404                 &VendorCount);
 405
 406         // Process the X-Tokens (X-*).
 407
 408         LoadXTokenData(&ContactEditorData.XTokenListTokens,
 409                 lboXToken,
 410                 &XTokenCount);
 411
 412         // Process the related people (RELATED).
 413
 414         LoadRelatedData(&ContactEditorData.GeneralRelatedList,
 415                 &ContactEditorData.GeneralRelatedListPref,
 416                 &ContactEditorData.GeneralRelatedListType,
 417                 lboRelated,
 418                 &RelatedCount);
 419
 420         // Process the full name (FN).
 421
 422         LoadData(&ContactEditorData.FullNamesList,
 423                 cmbDisplayAs);
 424
 425         FMTimer.SetFilename(Filename);
 426         FMTimer.Start(10000, FALSE);
 427
 428         EditMode = TRUE;
 429
 430         return TRUE;
 431 }
 432
 433 void frmContactEditor::SplitValues(wxString *PropertyLine,
 434         std::map<int,int> *SplitPoints,
 435         std::map<int,int> *SplitLength,
 436         int intSize){
 437
 438         // Split the values.
 439
 440         size_t intPropertyLen = PropertyLine->Len();
 441         int intSplitsFound = 0;
 442         int intSplitSize = 0;
 443         int intSplitSeek = 0;
 444
 445         for (int i = intSize; i <= intPropertyLen; i++){
 446
 447                 intSplitSize++;
 448
 449                 if (PropertyLine->Mid(i, 1) == wxT(";") &&
 450                     PropertyLine->Mid((i - 1), 1) != wxT("\\")){
 451
 452                         if (intSplitsFound == 0){
 453
 454                                 SplitLength->insert(std::make_pair(intSplitsFound, (intSplitSize)));
 455
 456                         } else {
 457
 458                                 SplitLength->insert(std::make_pair(intSplitsFound, (intSplitSize - 1)));
 459
 460                         }
 461
 462                         SplitPoints->insert(std::make_pair(intSplitsFound, (i + 1)));
 463
 464                         intSplitsFound++;
 465                         intSplitSeek = i;
 466                         intSplitSize = 0;
 467
 468                 }
 469
 470         }
 471
 472         if (intSplitsFound == 0){
 473
 474                 SplitPoints->insert(std::make_pair(intSplitsFound, (8 + 1)));
 475                 SplitLength->insert(std::make_pair(intSplitsFound, intSplitSize));
 476
 477         } else {
 478
 479                 SplitPoints->insert(std::make_pair(intSplitsFound, (intSplitSeek + 1)));
 480                 SplitLength->insert(std::make_pair(intSplitsFound, intSplitSize));
 481
 482         }
 483
 484 }
 485
 486 void frmContactEditor::LoadData(std::map<int, wxString> *GeneralList,
 487                 std::map<int, int> *GeneralListPref,
 488                 wxListCtrl *GeneralListCtrl,
 489                 std::map<int, wxString> *HomeList,
 490                 std::map<int, int> *HomeListPref,
 491                 wxListCtrl *HomeListCtrl,
 492                 std::map<int, wxString> *BusinessList,
 493                 std::map<int, int> *BusinessListPref,
 494                 wxListCtrl *BusinessListCtrl,
 495                 int *DataCount){
 496
 497         // Load data into the controls (first section of data and preference
 498         // only).
 499
 500         long ListCtrlIndex = -1;
 501
 502         // Deal with the general items.
 503
 504         for (std::map<int,wxString>::iterator Iter = GeneralList->begin();
 505                 Iter != GeneralList->end();
 506                 Iter++){
 507
 508                 wxListItem coldata;
 509
 510                 coldata.SetId(*DataCount);
 511                 coldata.SetData(*DataCount);
 512                 coldata.SetText(Iter->second);
 513
 514                 ListCtrlIndex = GeneralListCtrl->InsertItem(coldata);
 515
 516                 if (MapDataExists(DataCount, GeneralListPref)){
 517
 518                         GeneralListCtrl->SetItem(ListCtrlIndex, 1, wxString::Format("%i", GeneralListPref->find(*DataCount)->second));
 519
 520                 }
 521
 522                 (*DataCount)++;
 523
 524         }
 525
 526         // Deal with the home items.
 527
 528         for (std::map<int,wxString>::iterator Iter = HomeList->begin();
 529                 Iter != HomeList->end();
 530                 Iter++){
 531
 532                 wxListItem coldata;
 533
 534                 coldata.SetId(*DataCount);
 535                 coldata.SetData(*DataCount);
 536                 coldata.SetText(Iter->second);
 537
 538                 ListCtrlIndex = HomeListCtrl->InsertItem(coldata);
 539
 540                 if (MapDataExists(DataCount, HomeListPref)){
 541
 542                         HomeListCtrl->SetItem(ListCtrlIndex, 1, wxString::Format("%i", HomeListPref->find(*DataCount)->second));
 543
 544                 }
 545
 546                 (*DataCount)++;
 547
 548         }
 549
 550         // Deal with the work items.
 551
 552         for (std::map<int,wxString>::iterator Iter = BusinessList->begin();
 553                 Iter != BusinessList->end();
 554                 Iter++){
 555
 556                 wxListItem coldata;
 557
 558                 coldata.SetId(*DataCount);
 559                 coldata.SetData(*DataCount);
 560                 coldata.SetText(Iter->second);
 561
 562                 ListCtrlIndex = BusinessListCtrl->InsertItem(coldata);
 563
 564                 if (MapDataExists(DataCount, BusinessListPref)){
 565
 566                         BusinessListCtrl->SetItem(ListCtrlIndex, 1, wxString::Format("%i", BusinessListPref->find(*DataCount)->second));
 567
 568                 }
 569
 570                 (*DataCount)++;
 571
 572         }
 573
 574 }
 575
 576 void frmContactEditor::LoadData(std::map<int, wxString> *GeneralList,
 577                 std::map<int, int> *GeneralListPref,
 578                 std::map<int, wxString> *GeneralListType,
 579                 wxListCtrl *GeneralListCtrl,
 580                 std::map<int, wxString> *HomeList,
 581                 std::map<int, int> *HomeListPref,
 582                 std::map<int, wxString> *HomeListType,
 583                 wxListCtrl *HomeListCtrl,
 584                 std::map<int, wxString> *BusinessList,
 585                 std::map<int, int> *BusinessListPref,
 586                 std::map<int, wxString> *BusinessListType,
 587                 wxListCtrl *BusinessListCtrl,
 588                 int *DataCount){
 589
 590         // Load data into the controls (first section of data,
 591         // type and preference).
 592
 593         long ListCtrlIndex = -1;
 594
 595         // Deal with the general items.
 596
 597         for (std::map<int,wxString>::iterator Iter = GeneralList->begin();
 598                 Iter != GeneralList->end();
 599                 Iter++){
 600
 601                 wxListItem coldata;
 602
 603                 coldata.SetId(*DataCount);
 604                 coldata.SetData(*DataCount);
 605                 coldata.SetText(Iter->second);
 606
 607                 ListCtrlIndex = GeneralListCtrl->InsertItem(coldata);
 608
 609                 if (MapDataExists(DataCount, GeneralListPref)){
 610
 611                         GeneralListCtrl->SetItem(ListCtrlIndex, 2, wxString::Format("%i", GeneralListPref->find(*DataCount)->second));
 612
 613                 }
 614
 615                 if (MapDataExists(DataCount, GeneralListType)){
 616
 617                         GeneralListCtrl->SetItem(ListCtrlIndex, 1, GeneralListType->find(*DataCount)->second);
 618
 619                 }
 620
 621                 (*DataCount)++;
 622
 623         }
 624
 625         // Deal with the home items.
 626
 627         for (std::map<int,wxString>::iterator Iter = HomeList->begin();
 628                 Iter != HomeList->end();
 629                 Iter++){
 630
 631                 wxListItem coldata;
 632
 633                 coldata.SetId(*DataCount);
 634                 coldata.SetData(*DataCount);
 635                 coldata.SetText(Iter->second);
 636
 637                 ListCtrlIndex = HomeListCtrl->InsertItem(coldata);
 638
 639                 if (MapDataExists(DataCount, HomeListPref)){
 640
 641                         HomeListCtrl->SetItem(ListCtrlIndex, 2, wxString::Format("%i", HomeListPref->find(*DataCount)->second));
 642
 643                 }
 644
 645                 if (MapDataExists(DataCount, HomeListType)){
 646
 647                         HomeListCtrl->SetItem(ListCtrlIndex, 1, HomeListType->find(*DataCount)->second);
 648
 649                 }
 650
 651                 (*DataCount)++;
 652
 653         }
 654
 655         // Deal with the work items.
 656
 657         for (std::map<int,wxString>::iterator Iter = BusinessList->begin();
 658                 Iter != BusinessList->end();
 659                 Iter++){
 660
 661                 wxListItem coldata;
 662
 663                 coldata.SetId(*DataCount);
 664                 coldata.SetData(*DataCount);
 665                 coldata.SetText(Iter->second);
 666
 667                 ListCtrlIndex = BusinessListCtrl->InsertItem(coldata);
 668
 669                 if (MapDataExists(DataCount, BusinessListPref)){
 670
 671                         BusinessListCtrl->SetItem(ListCtrlIndex, 2, wxString::Format("%i", BusinessListPref->find(*DataCount)->second));
 672
 673                 }
 674
 675                 if (MapDataExists(DataCount, BusinessListType)){
 676
 677                         BusinessListCtrl->SetItem(ListCtrlIndex, 1, BusinessListType->find(*DataCount)->second);
 678
 679                 }
 680
 681                 (*DataCount)++;
 682
 683         }
 684
 685 }
 686
 687
 688 void frmContactEditor::LoadData(std::map<int,wxString> *ItemList,
 689                 std::map<int,int> *ItemListPref,
 690                 wxListCtrl *ItemCtrl,
 691                 int *DataCount){
 692
 693         // Load the data (name and preference only).
 694
 695         long ListCtrlIndex = -1;
 696
 697         for (std::map<int,wxString>::iterator Iter = ItemList->begin();
 698                 Iter != ItemList->end();
 699                 Iter++){
 700
 701                 wxListItem coldata;
 702
 703                 coldata.SetId(*DataCount);
 704                 coldata.SetData(*DataCount);
 705                 coldata.SetText(Iter->second);
 706
 707                 ListCtrlIndex = ItemCtrl->InsertItem(coldata);
 708
 709                 if (MapDataExists(DataCount, ItemListPref)){
 710
 711                         ItemCtrl->SetItem(ListCtrlIndex, 1, wxString::Format("%i", ItemListPref->find(*DataCount)->second));
 712
 713                 }
 714
 715                 (*DataCount)++;
 716
 717         }
 718
 719 }
 720
 721 void frmContactEditor::LoadData(std::map<int,wxString> *ItemList,
 722                 std::map<int,int> *ItemListPref,
 723                 std::map<int,wxString> *ItemListType,
 724                 wxListCtrl *ItemCtrl,
 725                 int *DataCount){
 726
 727         // Load the data (name, preference and type).
 728
 729         long ListCtrlIndex = -1;
 730
 731         for (std::map<int,wxString>::iterator Iter = ItemList->begin();
 732                 Iter != ItemList->end();
 733                 Iter++){
 734
 735                 wxListItem coldata;
 736
 737                 coldata.SetId(*DataCount);
 738                 coldata.SetData(*DataCount);
 739                 coldata.SetText(Iter->second);
 740
 741                 ListCtrlIndex = ItemCtrl->InsertItem(coldata);
 742
 743                 if (MapDataExists(DataCount, ItemListType)){
 744
 745                         ItemCtrl->SetItem(ListCtrlIndex, 1, ItemListType->find(*DataCount)->second);
 746
 747                 }
 748
 749                 if (MapDataExists(DataCount, ItemListPref)){
 750
 751                         ItemCtrl->SetItem(ListCtrlIndex, 2, wxString::Format("%i", ItemListPref->find(*DataCount)->second));
 752
 753                 }
 754
 755                 (*DataCount)++;
 756
 757         }
 758
 759 }
 760
 761 void frmContactEditor::LoadData(wxString ItemName,
 762                 std::map<int,wxString> *ItemList,
 763                 std::map<int,int> *ItemListPref,
 764                 std::map<int,wxString> *ItemListType,
 765                 std::map<int,wxString> *ItemListDataType,
 766                 wxListCtrl *ItemCtrl,
 767                 int *DataCount){
 768
 769         // Load data (name, preference, type and data type).
 770
 771         long ListCtrlIndex = -1;
 772
 773         for (std::map<int,wxString>::iterator Iter = ItemList->begin();
 774                 Iter != ItemList->end();
 775                 Iter++){
 776
 777                 wxListItem coldata;
 778
 779                 coldata.SetId(*DataCount);
 780                 coldata.SetData(*DataCount);
 781                 coldata.SetText(Iter->second);
 782
 783                 if (ItemName == "KEY"){
 784
 785                         // Get the key type, if any.
 786
 787                         if (MapDataExists(DataCount, ItemListDataType)){
 788
 789                                 if (ItemListDataType->find(*DataCount)->second == "application/pgp-keys"){
 790
 791                                         coldata.SetText(_("PGP Key"));
 792
 793                                 }
 794
 795                         } else {
 796
 797                                 coldata.SetText(_("Key"));
 798
 799                         }
 800
 801
 802                 }
 803
 804                 ListCtrlIndex = ItemCtrl->InsertItem(coldata);
 805
 806                 if (MapDataExists(DataCount, ItemListType)){
 807
 808                         if (ItemListType->find(*DataCount)->second == "home"){
 809
 810                                 ItemCtrl->SetItem(ListCtrlIndex, 1, _("Home"));
 811
 812                         } else if (ItemListType->find(*DataCount)->second == "work"){
 813
 814                                 ItemCtrl->SetItem(ListCtrlIndex, 1, _("Work"));
 815
 816                         }
 817
 818                 }
 819
 820                 if (MapDataExists(DataCount, ItemListPref)){
 821
 822                         ItemCtrl->SetItem(ListCtrlIndex, 2, wxString::Format("%i", ItemListPref->find(*DataCount)->second));
 823
 824                 }
 825
 826                 (*DataCount)++;
 827
 828         }
 829
 830 }
 831
 832 void frmContactEditor::LoadPictureData(wxString ItemName,
 833                 std::map<int,std::string> *ItemList,
 834                 std::map<int,int> *ItemListPref,
 835                 std::map<int,wxString> *ItemListType,
 836                 wxListCtrl *ItemCtrl,
 837                 int *DataCount){
 838
 839         // Load the picture data.
 840
 841         long ListCtrlIndex = -1;
 842
 843         for (std::map<int,std::string>::iterator Iter = ItemList->begin();
 844                 Iter != ItemList->end();
 845                 Iter++){
 846
 847                 wxListItem coldata;
 848
 849                 coldata.SetId(*DataCount);
 850                 coldata.SetData(*DataCount);
 851
 852                 if (ItemName == "PHOTO"){
 853
 854                         coldata.SetText("Picture");
 855
 856                 } else if (ItemName == "LOGO"){
 857
 858                         coldata.SetText("Logo");
 859
 860                 } else if (ItemName == "SOUND"){
 861
 862                         coldata.SetText("Sound");
 863
 864                 } else {
 865
 866                         coldata.SetText("Object");
 867
 868                 }
 869
 870                 ListCtrlIndex = ItemCtrl->InsertItem(coldata);
 871
 872                 if (MapDataExists(DataCount, ItemListType)){
 873
 874                         if (ItemListType->find(*DataCount)->second == "home"){
 875
 876                                 ItemCtrl->SetItem(ListCtrlIndex, 1, _("Home"));
 877
 878                         } else if (ItemListType->find(*DataCount)->second == "work"){
 879
 880                                 ItemCtrl->SetItem(ListCtrlIndex, 1, _("Work"));
 881
 882                         }
 883
 884                 }
 885
 886                 if (MapDataExists(DataCount, ItemListPref)){
 887
 888                         ItemCtrl->SetItem(ListCtrlIndex, 2, wxString::Format("%i", ItemListPref->find(*DataCount)->second));
 889
 890                 }
 891
 892                 (*DataCount)++;
 893
 894         }
 895
 896 }
 897
 898 void frmContactEditor::LoadVendorData(std::map<int,wxString> *ItemListPEN,
 899                 std::map<int,wxString> *ItemListElement,
 900                 wxListCtrl *ItemCtrl,
 901                 int *DataCount){
 902
 903         // Load the vendor data.
 904
 905         long ListCtrlIndex = -1;
 906         wxString ItemValue;
 907
 908         for (std::map<int,wxString>::iterator Iter = ItemListPEN->begin();
 909                 Iter != ItemListPEN->end();
 910                 Iter++){
 911
 912                 ItemValue.clear();
 913
 914                 wxListItem coldata;
 915
 916                 coldata.SetId(*DataCount);
 917                 coldata.SetData(*DataCount);
 918
 919                 ItemValue.Append(ItemListPEN->find(*DataCount)->second);
 920                 ItemValue.Append("-");
 921                 ItemValue.Append(ItemListElement->find(*DataCount)->second);
 922
 923                 coldata.SetText(ItemValue);
 924
 925                 ListCtrlIndex = ItemCtrl->InsertItem(coldata);
 926
 927                 (*DataCount)++;
 928
 929         }
 930
 931 }
 932
 933 void frmContactEditor::LoadXTokenData(std::map<int,wxString> *ItemListTokens,
 934                 wxListCtrl *ItemCtrl,
 935                 int *DataCount){
 936
 937         // Load the X-Token data.
 938
 939         long ListCtrlIndex = -1;
 940         wxString ItemValue;
 941
 942         for (std::map<int,wxString>::iterator Iter = ItemListTokens->begin();
 943                 Iter != ItemListTokens->end();
 944                 Iter++){
 945
 946                 ItemValue.clear();
 947
 948                 wxListItem coldata;
 949
 950                 coldata.SetId(*DataCount);
 951                 coldata.SetData(*DataCount);
 952
 953                 ItemValue.Append(ItemListTokens->find(*DataCount)->second);
 954
 955                 coldata.SetText(ItemValue);
 956
 957                 ListCtrlIndex = ItemCtrl->InsertItem(coldata);
 958
 959                 (*DataCount)++;
 960
 961         }
 962
 963 }
 964
 965 void frmContactEditor::LoadData(std::map<int,wxString> *ItemList,
 966                 wxComboBox *ItemCtrl){
 967
 968         // Load data into a wxComboBox.
 969
 970         int ItemIndex = 0;
 971
 972         if (MapDataExists(&ItemIndex, ItemList)){
 973
 974                 cmbDisplayAs->SetValue(ItemList->find(0)->second);
 975
 976         }
 977
 978 }
 979
 980 void frmContactEditor::LoadRelatedData(std::map<int,wxString> *ItemList,
 981                 std::map<int,int> *ItemListPref,
 982                 std::map<int,wxString> *ItemListType,
 983                 wxListCtrl *ItemCtrl,
 984                 int *DataCount){
 985
 986         // Load related data (name, preference and type).
 987
 988         long ListCtrlIndex = -1;
 989         wxString RelatedType;
 990
 991         for (std::map<int,wxString>::iterator Iter = ItemList->begin();
 992                 Iter != ItemList->end();
 993                 Iter++){
 994
 995                 RelatedType.clear();
 996
 997                 wxListItem coldata;
 998
 999                 coldata.SetId(*DataCount);
1000                 coldata.SetData(*DataCount);
1001
1002                 if (MapDataExists(DataCount, ItemListType)){
1003
1004                         std::map<int,wxString>::iterator TypeIter = ItemListType->find(*DataCount);
1005
1006                         if (TypeIter->second == wxT("contact")){
1007
1008                                 RelatedType = _("Contact");
1009
1010                         } else if (TypeIter->second == wxT("acquaintance")){
1011
1012                                 RelatedType = _("Acquaintance");
1013
1014                         } else if (TypeIter->second == wxT("friend")){
1015
1016                                 RelatedType = _("Friend");
1017
1018                         } else if (TypeIter->second == wxT("met")){
1019
1020                                 RelatedType = _("Met");
1021
1022                         } else if (TypeIter->second == wxT("co-worker")){
1023
1024                                 RelatedType = _("Co-worker");
1025
1026                         } else if (TypeIter->second == wxT("colleague")){
1027
1028                                 RelatedType = _("Colleague");
1029
1030                         } else if (TypeIter->second == wxT("co-resident")){
1031
1032                                 RelatedType = _("Co-resident");
1033
1034                         } else if (TypeIter->second == wxT("neighbor")){
1035
1036                                 RelatedType = _("Neighbour");
1037
1038                         } else if (TypeIter->second == wxT("child")){
1039
1040                                 RelatedType = _("Child");
1041
1042                         } else if (TypeIter->second == wxT("parent")){
1043
1044                                 RelatedType = _("Parent");
1045
1046                         } else if (TypeIter->second == wxT("sibling")){
1047
1048                                 RelatedType = _("Sibling");
1049
1050                         } else if (TypeIter->second == wxT("spouse")){
1051
1052                                 RelatedType = _("Spouse");
1053
1054                         } else if (TypeIter->second == wxT("kin")){
1055
1056                                 RelatedType = _("Kin");
1057
1058                         } else if (TypeIter->second == wxT("muse")){
1059
1060                                 RelatedType = _("Muse");
1061
1062                         } else if (TypeIter->second == wxT("crush")){
1063
1064                                 RelatedType = _("Crush");
1065
1066                         } else if (TypeIter->second == wxT("date")){
1067
1068                                 RelatedType = _("Date");
1069
1070                         } else if (TypeIter->second == wxT("sweetheart")){
1071
1072                                 RelatedType = _("Sweetheart");
1073
1074                         } else if (TypeIter->second == wxT("me")){
1075
1076                                 RelatedType = _("Me");
1077
1078                         } else if (TypeIter->second == wxT("agent")){
1079
1080                                 RelatedType = _("Agent");
1081
1082                         } else if (TypeIter->second == wxT("emergency")){
1083
1084                                 RelatedType = _("Emergency");
1085
1086                         } else {
1087
1088                                 RelatedType = TypeIter->second;
1089
1090                         }
1091
1092                 }
1093
1094                 coldata.SetText(RelatedType);
1095
1096                 ListCtrlIndex = ItemCtrl->InsertItem(coldata);
1097
1098                 if (MapDataExists(DataCount, ItemList)){
1099
1100                         ItemCtrl->SetItem(ListCtrlIndex, 1, ItemList->find(*DataCount)->second);
1101
1102                 }
1103
1104                 if (MapDataExists(DataCount, ItemListPref)){
1105
1106                         ItemCtrl->SetItem(ListCtrlIndex, 2, wxString::Format("%i", ItemListPref->find(*DataCount)->second));
1107
1108                 }
1109
1110                 (*DataCount)++;
1111
1112         }
1113
1114 }
1115
1116 void frmContactEditor::LoadKind(ContactKindType *KindType){
1117
1118         // Load contact kind.
1119
1120         switch (*KindType){
1121                 case CONTACTKIND_INDIVIDUAL:
1122                         cmbType->SetSelection(1);
1123                         break;
1124                 case CONTACTKIND_GROUP:
1125                         cmbType->SetSelection(2);
1126                         break;
1127                 case CONTACTKIND_ORGANISATION:
1128                         cmbType->SetSelection(3);
1129                         break;
1130                 case CONTACTKIND_LOCATION:
1131                         cmbType->SetSelection(4);
1132                         break;
1133                 case CONTACTKIND_NONE:
1134                         cmbType->SetSelection(0);
1135                         break;
1136         }
1137
1138         wxCommandEvent nullevent;
1139
1140         UpdateMembersTab(nullevent);
1141
1142 }
1143
1144 void frmContactEditor::LoadBirthday(wxString *BirthdayData, bool *BirthdayText){
1145
1146         // Load Birthday.
1147
1148         if (BirthdayData->IsEmpty()){
1149             return;
1150         }
1151
1152         if (*BirthdayText == FALSE){
1153
1154                 int DateYear = 0;
1155                 wxDateTime::Month DateMonth;
1156                 unsigned int DateDay;
1157
1158                 wxString wxSData;
1159
1160                 if (BirthdayData->Mid(0, 2) == wxT("--")){
1161
1162                         // Skip year.
1163
1164                 } else {
1165
1166                         DateYear = wxAtoi(BirthdayData->Mid(0,4));
1167
1168                 }
1169
1170                 DateMonth = (wxDateTime::Month)(wxAtoi(BirthdayData->Mid(4,2)) - 1);
1171                 DateDay = wxAtoi(BirthdayData->Mid(6,2));
1172
1173                 wxDateTime BDayDate(DateDay,DateMonth,DateYear);
1174
1175                 dapBirthday->SetValue(BDayDate);
1176
1177         } else {
1178
1179                 txtBirthday->SetValue(*BirthdayData);
1180
1181         }
1182
1183 }
1184
1185 void frmContactEditor::LoadAnniversary(wxString *AnniversaryData, bool *AnniversaryText){
1186
1187         // Load Anniversary.
1188
1189         if (AnniversaryData->IsEmpty()){
1190             return;
1191         }
1192
1193         if (*AnniversaryText == FALSE){
1194
1195                 int DateYear = 0;
1196                 wxDateTime::Month DateMonth;
1197                 int DateDay;
1198
1199                 wxString wxSData;
1200
1201                 if (AnniversaryData->Mid(0, 2) == wxT("--")){
1202
1203                         // Skip year.
1204
1205                 } else {
1206
1207                         DateYear = wxAtoi(AnniversaryData->Mid(0,4));
1208
1209                 }
1210
1211                 DateMonth = (wxDateTime::Month)(wxAtoi(AnniversaryData->Mid(4,2)) - 1);
1212                 DateDay = wxAtoi(AnniversaryData->Mid(6,2));
1213
1214                 wxDateTime ADayDate(DateDay,DateMonth,DateYear);
1215
1216                 dapAnniversary->SetValue(ADayDate);
1217
1218         } else {
1219
1220                 txtAnniversary->SetValue(*AnniversaryData);
1221
1222         }
1223
1224 }
1225
1226 void frmContactEditor::LoadGender(wxString *GenderComponent, wxString *GenderIdentity){
1227
1228         // Load Gender.
1229
1230         // Deal with the Gender Component.
1231
1232         if (*GenderComponent == wxT("M")){
1233
1234                 // Gender is Male.
1235
1236                 cmbGender->SetSelection(1);
1237
1238         } else if (*GenderComponent == wxT("F")){
1239
1240                 // Gender is Female.
1241
1242                 cmbGender->SetSelection(2);
1243
1244         } else if (*GenderComponent == wxT("O")){
1245
1246                 // Gender is Other.
1247
1248                 cmbGender->SetSelection(3);
1249
1250         } else if (*GenderComponent == wxT("N")){
1251
1252                 // Gender is None/Not Applicable.
1253
1254                 cmbGender->SetSelection(4);
1255
1256         } else if (*GenderComponent == wxT("U")){
1257
1258                 // Gender is Unknown.
1259
1260                 cmbGender->SetSelection(5);
1261
1262         }
1263
1264         // Deal with the Gender Identity.
1265
1266         txtGenderDescription->SetValue(*GenderIdentity);
1267
1268 }
1269
1270 void frmContactEditor::LoadName(wxString *NameTitle, wxString *NameForename,
1271         wxString *NameSurname, wxString *NameOtherNames,
1272         wxString *NameSuffix){
1273
1274         // Load Name.
1275
1276         txtTitle->SetValue(*NameTitle);
1277         txtForename->SetValue(*NameForename);
1278         txtSurname->SetValue(*NameSurname);
1279         txtOtherNames->SetValue(*NameOtherNames);
1280         txtSuffix->SetValue(*NameSuffix);
1281
1282 }
1283
1284 void frmContactEditor::LoadMember(std::map<int,wxString> *GroupList){
1285
1286         // Load group data.
1287
1288         // Go through the list of contacts for the account and find the matching UID.
1289         // If contact with UID doesn't match then say (unknown contact).
1290
1291         XABViewMode XVMData;
1292         if (StartupEditMode == FALSE){
1293                 XVMData = MainPtr->GetViewMode();
1294         }
1295
1296         wxString AccountDirFinal = GetAccountDir(wxSContactAccount, FALSE);
1297
1298         wxString vCardFilename;
1299         wxString vCardFilenameFull;
1300         wxString vCardDataString;
1301         wxString lwxs;
1302         wxString setname, setvalue;
1303         wxString MemberData;
1304         bool FoundContact = FALSE;
1305         std::multimap<wxString, wxString, std::greater<wxString>> vCardNamesAsc;
1306         std::multimap<wxString, wxString, std::less<wxString>> vCardNamesDsc;
1307
1308         wxDir vcardaccdir(AccountDirFinal);
1309
1310         for (std::map<int,wxString>::iterator MemberIter = GroupList->begin();
1311                 MemberIter != GroupList->end();
1312                 MemberIter++){
1313
1314                 MemberData = MemberIter->second;
1315
1316                 bool ProcFiles = vcardaccdir.GetFirst(&vCardFilename, wxEmptyString, wxDIR_FILES);
1317                 while(ProcFiles){
1318
1319                         if (vCardFilename.Right(4) == wxT(".vcf") ||
1320                             vCardFilename.Right(4) == wxT(".VCF") ||
1321                             vCardFilename.Right(5) == wxT(".vcard") ||
1322                             vCardFilename.Right(5) == wxT(".VCARD")){
1323
1324                                 vCard Person;
1325
1326                                 vCardFilenameFull.Append(AccountDirFinal);
1327                                 vCardFilenameFull.Append(wxT("/"));
1328                                 vCardFilenameFull.Append(vCardFilename);
1329
1330                                 Person.LoadFile(vCardFilenameFull);
1331
1332                                 if (MemberData.Left(9) == wxT("urn:uuid:")){
1333
1334                                         wxString NewPropValue;
1335                                         NewPropValue = MemberData.Mid(9, wxString::npos);
1336                                         MemberData = NewPropValue;
1337
1338                                 }
1339
1340                                 if (Person.MeetBaseSpecification()){
1341
1342                                         wxString KindStatus = Person.Get(wxT("KIND"));
1343
1344                                         if (KindStatus == wxT("group")){
1345
1346                                                 vCardFilename.Clear();
1347                                                 vCardFilenameFull.Clear();
1348                                                 vCardDataString.Clear();
1349                                                 ProcFiles = vcardaccdir.GetNext(&vCardFilename);
1350                                                 continue;
1351
1352                                         }
1353
1354                                         wxString PersonName = Person.Get(wxT("N"));
1355                                         wxString PersonUID = Person.Get(wxT("UID"));
1356                                         wxString PersonFilename = vCardFilenameFull;
1357
1358                                         if (PersonUID != MemberData){
1359
1360                                                 vCardFilename.Clear();
1361                                                 vCardFilenameFull.Clear();
1362                                                 vCardDataString.Clear();
1363                                                 ProcFiles = vcardaccdir.GetNext(&vCardFilename);
1364                                                 continue;
1365
1366                                         } else {
1367
1368                                                 FoundContact = TRUE;
1369
1370                                         }
1371
1372                                         //ContactsNames.insert(std::make_pair(PersonName, ContactIndex));
1373                                         //ContactsUIDs.insert(std::make_pair(ContactIndex, PersonUID));
1374
1375                                         if (XVMData.SortMode == 1){
1376
1377                                                 // Split the name into sections.
1378
1379                                                 vCardDataString = Person.Get(wxT("N"));
1380
1381                                                 vCardName NameData = Person.GetName();
1382
1383                                                 vCardDataString = NameData.Forename + wxT(" ") + NameData.Surname;
1384
1385                                         } else if (XVMData.SortMode == 2){
1386
1387                                                 // Split the name into sections.
1388
1389                                                 vCardName NameData = Person.GetName();
1390
1391                                                 vCardDataString = NameData.Surname + wxT(", ") + NameData.Forename;
1392
1393                                         } else if (XVMData.SortMode == 3){
1394
1395                                                 // Check and make sure that the top most nickname is used.
1396
1397                                                 vCardDataString = Person.Get(wxT("NICKNAME"));
1398
1399                                                 if (vCardDataString.IsEmpty()){
1400
1401                                                         vCardDataString = wxT("(no nickname)");
1402
1403                                                 }
1404
1405                                         } else if (XVMData.SortMode == 4){
1406
1407                                                 vCardDataString = Person.Get(wxT("FN"));
1408
1409                                         }
1410
1411                                         if (XVMData.AscendingMode == TRUE){
1412
1413                                                 vCardNamesAsc.insert(std::make_pair(vCardDataString, PersonUID));
1414
1415                                         } else {
1416
1417                                                 vCardNamesDsc.insert(std::make_pair(vCardDataString, PersonUID));
1418
1419                                         }
1420
1421                                 } else {
1422
1423                                 }
1424
1425                         }
1426
1427                         vCardFilename.Clear();
1428                         vCardFilenameFull.Clear();
1429                         vCardDataString.Clear();
1430                         ProcFiles = vcardaccdir.GetNext(&vCardFilename);
1431
1432                 }
1433
1434                 if (FoundContact == FALSE){
1435
1436                         if (XVMData.AscendingMode == TRUE){
1437
1438                                 vCardNamesAsc.insert(std::make_pair(MemberIter->second, MemberIter->second));
1439
1440                         } else {
1441
1442                         vCardNamesDsc.insert(std::make_pair(MemberIter->second, MemberIter->second));
1443
1444                         }
1445
1446                 }
1447
1448                 if (XVMData.AscendingMode == TRUE){
1449
1450                         for (std::map<wxString,wxString>::iterator iter = vCardNamesAsc.begin();
1451                                 iter != vCardNamesAsc.end(); ++iter){
1452
1453                                 wxListItem ItemData;
1454
1455                                 ItemData.SetId(0);
1456                                 ItemData.SetText(iter->first);
1457                                 lboGroups->InsertItem(ItemData);
1458
1459                         }
1460
1461                 } else {
1462
1463                         for (std::map<wxString,wxString>::iterator iter = vCardNamesDsc.begin();
1464                                 iter != vCardNamesDsc.end(); ++iter){
1465
1466                                 wxListItem ItemData;
1467
1468                                 ItemData.SetId(0);
1469                                 ItemData.SetText(iter->first);
1470
1471                                 lboGroups->InsertItem(ItemData);
1472
1473                         }
1474
1475                 }
1476
1477         }
1478
1479 }
1480
1481 void frmContactEditor::LoadAddress(std::map<int, wxString> *GeneralAddressList,
1482         std::map<int, wxString> *GeneralAddressListTown,
1483         std::map<int, wxString> *GeneralAddressListCounty,
1484         std::map<int, wxString> *GeneralAddressListPostCode,
1485         std::map<int, int> *GeneralAddressListPref,
1486         std::map<int, wxString> *HomeAddressList,
1487         std::map<int, wxString> *HomeAddressListTown,
1488         std::map<int, wxString> *HomeAddressListCounty,
1489         std::map<int, wxString> *HomeAddressListPostCode,
1490         std::map<int, int> *HomeAddressListPref,
1491         std::map<int, wxString> *BusinessAddressList,
1492         std::map<int, wxString> *BusinessAddressListTown,
1493         std::map<int, wxString> *BusinessAddressListCounty,
1494         std::map<int, wxString> *BusinessAddressListPostCode,
1495         std::map<int, int> *BusinessAddressListPref,
1496         int *AddressCount){
1497
1498         // Load address.
1499
1500         long ListCtrlIndex = -1;
1501
1502         // Deal with the general addresses.
1503
1504         for (std::map<int,wxString>::iterator Iter = GeneralAddressList->begin();
1505                 Iter != GeneralAddressList->end();
1506                 Iter++){
1507
1508                 wxListItem coldata;
1509
1510                 coldata.SetId(*AddressCount);
1511                 coldata.SetData(*AddressCount);
1512                 coldata.SetText(Iter->second);
1513
1514                 ListCtrlIndex = lboAddresses->InsertItem(coldata);
1515
1516                 if (MapDataExists(AddressCount, GeneralAddressListTown)){
1517
1518                         lboAddresses->SetItem(ListCtrlIndex, 1, GeneralAddressListTown->find(*AddressCount)->second);
1519
1520                 }
1521
1522                 if (MapDataExists(AddressCount, GeneralAddressListCounty)){
1523
1524                         lboAddresses->SetItem(ListCtrlIndex, 2, GeneralAddressListCounty->find(*AddressCount)->second);
1525
1526                 }
1527
1528                 if (MapDataExists(AddressCount, GeneralAddressListPostCode)){
1529
1530                         lboAddresses->SetItem(ListCtrlIndex, 3, GeneralAddressListPostCode->find(*AddressCount)->second);
1531
1532                 }
1533
1534                 if (MapDataExists(AddressCount, GeneralAddressListPref)){
1535
1536                         lboAddresses->SetItem(ListCtrlIndex, 4, wxString::Format("%i", GeneralAddressListPref->find(*AddressCount)->second));
1537
1538                 }
1539
1540                 (*AddressCount)++;
1541
1542         }
1543
1544         // Deal with the home addresses.
1545
1546         for (std::map<int,wxString>::iterator Iter = HomeAddressList->begin();
1547                 Iter != HomeAddressList->end();
1548                 Iter++){
1549
1550                 wxListItem coldata;
1551
1552                 coldata.SetId(*AddressCount);
1553                 coldata.SetData(*AddressCount);
1554                 coldata.SetText(Iter->second);
1555
1556                 ListCtrlIndex = lboHomeAddresses->InsertItem(coldata);
1557
1558                 if (MapDataExists(AddressCount, HomeAddressListTown)){
1559
1560                         lboHomeAddresses->SetItem(ListCtrlIndex, 1, HomeAddressListTown->find(*AddressCount)->second);
1561
1562                 }
1563
1564                 if (MapDataExists(AddressCount, HomeAddressListCounty)){
1565
1566                         lboHomeAddresses->SetItem(ListCtrlIndex, 2, HomeAddressListCounty->find(*AddressCount)->second);
1567
1568                 }
1569
1570                 if (MapDataExists(AddressCount, HomeAddressListPostCode)){
1571
1572                         lboHomeAddresses->SetItem(ListCtrlIndex, 3, HomeAddressListPostCode->find(*AddressCount)->second);
1573
1574                 }
1575
1576                 if (MapDataExists(AddressCount, HomeAddressListPref)){
1577
1578                         lboHomeAddresses->SetItem(ListCtrlIndex, 4, wxString::Format("%i", HomeAddressListPref->find(*AddressCount)->second));
1579
1580                 }
1581
1582                 (*AddressCount)++;
1583
1584         }
1585
1586         // Deal with the work addresses.
1587
1588         for (std::map<int,wxString>::iterator Iter = BusinessAddressList->begin();
1589                 Iter != BusinessAddressList->end();
1590                 Iter++){
1591
1592                 wxListItem coldata;
1593
1594                 coldata.SetId(*AddressCount);
1595                 coldata.SetData(*AddressCount);
1596                 coldata.SetText(Iter->second);
1597
1598                 ListCtrlIndex = lboBusinessAddresses->InsertItem(coldata);
1599
1600                 if (MapDataExists(AddressCount, BusinessAddressListTown)){
1601
1602                         lboBusinessAddresses->SetItem(ListCtrlIndex, 1, BusinessAddressListTown->find(*AddressCount)->second);
1603
1604                 }
1605
1606                 if (MapDataExists(AddressCount, BusinessAddressListCounty)){
1607
1608                         lboBusinessAddresses->SetItem(ListCtrlIndex, 2, BusinessAddressListCounty->find(*AddressCount)->second);
1609
1610                 }
1611
1612                 if (MapDataExists(AddressCount, BusinessAddressListPostCode)){
1613
1614                         lboBusinessAddresses->SetItem(ListCtrlIndex, 3, BusinessAddressListPostCode->find(*AddressCount)->second);
1615
1616                 }
1617
1618                 if (MapDataExists(AddressCount, BusinessAddressListPref)){
1619
1620                         lboBusinessAddresses->SetItem(ListCtrlIndex, 4, wxString::Format("%i", BusinessAddressListPref->find(*AddressCount)->second));
1621
1622                 }
1623
1624                 (*AddressCount)++;
1625
1626         }
1627
1628 }