Home | News | Projects | Releases
Bugs | RFE | Repositories | Help
e9784dc661df6b09a1cbf8f694c42d0766816bc6
[xestiaab/.git] / source / contacteditor / ContactDataObject.cpp
1 // ContactDataObject.cpp - Client Data Object.
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/>
19 #include "ContactDataObject.h"
21 ContactLoadStatus ContactDataObject::LoadFile(wxString Filename){
22         
23         if (!wxFileExists(Filename)){
24         
25                 return CONTACTLOAD_FILEMISSING;
26         
27         }
28         
29         wxFile ContactFile;
30         
31         if (!ContactFile.Open(Filename, wxFile::read, wxS_DEFAULT)){
32         
33                 return CONTACTLOAD_FILEERROR;
34         
35         }
36         
37         // Check that the vCard is a valid vCard 4.0 file.
39         vCard vCard4FormatCheck;
40         
41         vCard4FormatCheck.LoadFile(Filename);
42         
43         if (vCard4FormatCheck.Get("VERSION") != wxT("4.0")){
44         
45                 return CONTACTLOAD_FILEINVALIDFORMAT;
46         
47         }
49         // Check that the vCard meets the base specification.
50         
51         if (!vCard4FormatCheck.MeetBaseSpecification()){
52         
53                 return CONTACTLOAD_FILEBASESPECFAIL;
54         
55         }
56         
57         wxStringTokenizer wSTContactFileLines(vCard4FormatCheck.WriteString(), wxT("\r\n"));
58         
59         std::map<int, wxString> ContactFileLines;
61         int ContactLineSeek = 0;
63         while (wSTContactFileLines.HasMoreTokens() == TRUE){
65                 wxString ContactLine = wSTContactFileLines.GetNextToken();
66                 ContactFileLines.insert(std::make_pair(ContactLineSeek, ContactLine));
67                 ContactLineSeek++;              
68         
69         }
70         
71         wxString wxSPropertyNextLine;
72         
73         bool ExtraLineSeek = TRUE;
74         bool QuoteMode = FALSE;
75         bool PropertyFind = TRUE;
76         bool KindProcessed = FALSE;
77         bool NameProcessed = FALSE;
78         bool GenderProcessed = FALSE;
79         bool BirthdayProcessed = FALSE;
80         bool AnniversaryProcessed = FALSE;
81         bool UIDProcessed = FALSE;
82         bool RevisionProcessed = FALSE;
83         int ContactLineLen = 0;
84         int QuoteBreakPoint = 0;
85         int SourceCount = 0;
86         int GroupCount = 0;
87         int FNCount = 0;
88         int NicknameCount = 0;
89         int TimeZoneCount = 0;
90         int AddressCount = 0;
91         int EmailCount = 0;
92         int IMCount = 0;
93         int TelephoneCount = 0;
94         int LanguageCount = 0;
95         int GeographicCount = 0;
96         int RelatedCount = 0;
97         int URLCount = 0;
98         int TitleCount = 0;
99         int RoleCount = 0;
100         int OrganisationCount = 0;
101         int NoteCount = 0;
102         int CategoryCount = 0;
103         int PhotoCount = 0;
104         int LogoCount = 0;
105         int SoundCount = 0;
106         int CalendarCount = 0;
107         int CalendarAddressCount = 0;
108         int FreeBusyAddressCount = 0;
109         int KeyCount = 0;
110         int VendorCount = 0;
111         int XTokenCount = 0;
112         int XMLCount = 0;
113         int ClientPIDCount = 0;
114         wxString ContactLine;
115         wxString PropertyLine;
116         wxString PropertySeg1;
117         wxString PropertySeg2;
118         wxString PropertyNextLine;
119         wxString Property;
120         
121         for (std::map<int,wxString>::iterator iter = ContactFileLines.begin(); 
122          iter != ContactFileLines.end(); ++iter){
124                 ExtraLineSeek = TRUE;
125                 QuoteMode = FALSE;
126                 PropertyFind = TRUE;
127                 ContactLineLen = 0;
128                 QuoteBreakPoint = 0;
129                 ContactLine.Clear();
130                 PropertyLine.Clear();
131                 PropertySeg1.Clear();
132                 PropertySeg2.Clear();
133                 Property.Clear();
134          
135                 ContactLine = iter->second;
136                 
137                 while (ExtraLineSeek == TRUE){
138                 
139                         // Check if there is extra data on the next line 
140                         // (indicated by space or tab at the start) and add data.
141                 
142                         iter++;
143                         
144                         if (iter == ContactFileLines.end()){
145                         
146                                 iter--;
147                                 break;
148                         
149                         }                       
150                 
151                         PropertyNextLine = iter->second;
152                 
153                         if (PropertyNextLine.Mid(0, 1) == wxT(" ") || PropertyNextLine.Mid(0, 1) == wxT("\t")){
154                 
155                                 PropertyNextLine.Remove(0, 1);
156                                 ContactLine.Append(PropertyNextLine);
157                 
158                         } else {
159                         
160                                 iter--;
161                                 ExtraLineSeek = FALSE;
162                         
163                         }
164                 
165                 }
167                 ContactLineLen = ContactLine.Len();
168                 
169                 // Make sure we are not in quotation mode.
170                 // Make sure colon does not have \ or \\ before it.
171                 
172                 for (int i = 0; i <= ContactLineLen; i++){
173                 
174                         if ((ContactLine.Mid(i, 1) == wxT(";") || ContactLine.Mid(i, 1) == wxT(":")) && PropertyFind == TRUE){
175                         
176                                 PropertyFind = FALSE;
177                         
178                         } else if (PropertyFind == TRUE){
179                         
180                                 Property.Append(ContactLine.Mid(i, 1));
181                         
182                         }               
183                 
184                         if (ContactLine.Mid(i, 1) == wxT("\"")){
185                         
186                                 if (QuoteMode == TRUE){
187                                 
188                                         QuoteMode = FALSE;
189                                 
190                                 } else {
191                         
192                                         QuoteMode = TRUE;
193                                         
194                                 }
195                         
196                         }
197                         
198                         if (ContactLine.Mid(i, 1) == wxT(":") && ContactLine.Mid((i - 1), 1) != wxT("\\") && QuoteMode == FALSE){
199                         
200                                 QuoteBreakPoint = i;
201                                 break;
202                         
203                         }
204                 
205                 }
206                 
207                 // Split that line at the point into two variables (ignore the colon).
208                 
209                 PropertySeg1 = ContactLine.Mid(0, QuoteBreakPoint);
210                 PropertySeg2 = ContactLine.Mid((QuoteBreakPoint + 1));
211                 
212                  if (Property == wxT("KIND") && KindProcessed == FALSE){
213                                 
214                         ProcessKind(PropertySeg2);
215                 
216                 } else if (Property == wxT("UID") && UIDProcessed == FALSE){
217                 
218                         UIDToken = PropertySeg2;
219                         UIDProcessed = TRUE;
220                 
221                 } else if (Property == wxT("SOURCE")){
222                 
223                         ProcessSource(PropertySeg1, PropertySeg2, &SourceCount);
224                         SourceCount++;
225                 
226                 } else if (Property == wxT("XML")){
227                 
228                         ProcessXML(PropertySeg1, PropertySeg2, &XMLCount);
229                         XMLCount++;
230                 
231                 } else if (Property == wxT("REV") && RevisionProcessed == FALSE){
232                 
233                         ProcessRevision(PropertySeg1, PropertySeg2);
234                         RevisionProcessed = TRUE;
235                 
236                 } else if (Property == wxT("MEMBER")){
238                         ProcessMember(PropertySeg1, PropertySeg2, &GroupCount);
239                         GroupCount++;   
240                 
241                 } else if (Property == wxT("FN")){
242                 
243                         ProcessFN(PropertySeg1, PropertySeg2, &FNCount);
244                         FNCount++;
245                 
246                 } else if (Property == wxT("N") && NameProcessed == FALSE){
247                 
248                         ProcessN(PropertySeg1, PropertySeg2);
249                         NameProcessed = TRUE;
250                 
251                 } else if (Property == wxT("CLIENTPIDMAP")){
252                 
253                         ProcessClientPIDMap(PropertySeg1, PropertySeg2, &ClientPIDCount);
254                         ClientPIDCount++;
255                 
256                 } else if (Property == wxT("NICKNAME")){
257                                                 
258                         ProcessNickname(PropertySeg1, PropertySeg2, &NicknameCount);
259                         NicknameCount++;
260                         
261                 } else if (Property == wxT("GENDER") && GenderProcessed == FALSE){
262                 
263                         ProcessGender(PropertySeg1, PropertySeg2);
264                         GenderProcessed = TRUE;
265                 
266                 } else if (Property == wxT("BDAY") && BirthdayProcessed == FALSE){
267                 
268                         ProcessBirthday(PropertySeg1, PropertySeg2);
269                         BirthdayProcessed = TRUE;
270                 
271                 } else if (Property == wxT("ANNIVERSARY") && AnniversaryProcessed == FALSE){
272                 
273                         ProcessAnniversary(PropertySeg1, PropertySeg2);
274                         AnniversaryProcessed = TRUE;
275                 
276                 } else if (Property == wxT("TZ")){
277                 
278                         ProcessTimeZone(PropertySeg1, PropertySeg2, &TimeZoneCount);
279                         TimeZoneCount++;
280                 
281                 } else if (Property == wxT("ADR")){
282                 
283                         ProcessAddress(PropertySeg1, PropertySeg2, &AddressCount);
284                         AddressCount++;
285                 
286                 } else if (Property == wxT("EMAIL")){
287                                         
288                         ProcessEmail(PropertySeg1, PropertySeg2, &EmailCount);  
289                         EmailCount++;
290                 
291                 } else if (Property == wxT("IMPP")){
292                 
293                         ProcessIM(PropertySeg1, PropertySeg2, &IMCount);
294                         IMCount++;
295                         
296                 } else if (Property == wxT("TEL")){
297                                 
298                         ProcessTelephone(PropertySeg1, PropertySeg2, &TelephoneCount);
299                         TelephoneCount++;
300                 
301                 } else if (Property == wxT("LANG")){
302                 
303                         // See frmContactEditor-LoadLanguage.cpp
304                         
305                         ProcessLanguage(PropertySeg1, PropertySeg2, &LanguageCount);
306                         LanguageCount++;
307                 
308                 } else if (Property == wxT("GEO")){
309                 
310                         // See frmContactEditor-LoadGeo.cpp
311                         
312                         ProcessGeographic(PropertySeg1, PropertySeg2, &GeographicCount);        
313                         GeographicCount++;
314                 
315                 } else if (Property == wxT("RELATED")){
316                         
317                         // See fromContactEditor-LoadRelated.cpp
318                         
319                         ProcessRelated(PropertySeg1, PropertySeg2, &RelatedCount);              
320                         RelatedCount++;
321                         
322                 } else if (Property == wxT("URL")){
324                         // See frmContactEditor-LoadURL.cpp
325                 
326                         ProcessURL(PropertySeg1, PropertySeg2, &URLCount);
327                         URLCount++;
328                 
329                 } else if (Property == wxT("TITLE")) {
330                 
331                         // See frmContactEditor-LoadTitle.cpp
332                         
333                         ProcessTitle(PropertySeg1, PropertySeg2, &TitleCount);
334                         TitleCount++;
335                         
336                 } else if (Property == wxT("ROLE")) {
337                 
338                         // See frmContactEditor-LoadTitle.cpp
339                         
340                         ProcessRole(PropertySeg1, PropertySeg2, &RoleCount);
341                         RoleCount++;
342                         
343                 } else if (Property == wxT("ORG")) {
344                 
345                         // See frmContactEditor-LoadOrg.cpp
346                         
347                         ProcessOrganisation(PropertySeg1, PropertySeg2, &OrganisationCount);
348                         OrganisationCount++;
349                         
350                 } else if (Property == wxT("NOTE")) {
352                         // See frmContactEditor-LoadNote.cpp
354                         ProcessNote(PropertySeg1, PropertySeg2, &NoteCount);
355                         NoteCount++;    
356                         
357                 } else if (Property == wxT("CATEGORIES")) {
358                 
359                         // See frmContactEditor-LoadCategory.cpp
360                 
361                         ProcessCategory(PropertySeg1, PropertySeg2, &CategoryCount);    
362                         CategoryCount++;
363                         
364                 } else if (Property == wxT("PHOTO")) {
365                 
366                         // See frmContactEditor-LoadPhoto.cpp
367                         
368                         ProcessPhoto(PropertySeg1, PropertySeg2, &PhotoCount);
369                         PhotoCount++;
371                 } else if (Property == wxT("LOGO")) {
372                 
373                         // See frmContactEditor-LoadPhoto.cpp
374                         
375                         ProcessLogo(PropertySeg1, PropertySeg2, &LogoCount);
376                         LogoCount++;
378                 } else if (Property == wxT("LOGO")) {
379                 
380                         // See frmContactEditor-LoadPhoto.cpp
381                         
382                         ProcessLogo(PropertySeg1, PropertySeg2, &LogoCount);
383                         LogoCount++;
385                 } else if (Property == wxT("SOUND")) {
386                 
387                         // See frmContactEditor-LoadSound.cpp
388                         
389                         ProcessSound(PropertySeg1, PropertySeg2, &SoundCount);
390                         SoundCount++;
391                         
392                 } else if (Property == wxT("CALURI")){
394                         // See frmContactEditor-LoadCalendar.cpp
395                         
396                         ProcessCalendarURI(PropertySeg1, PropertySeg2, &CalendarCount);
397                         CalendarCount++;
398                 
399                 } else if (Property == wxT("CALADRURI")){
400                 
401                         ProcessCalendarAddressURI(PropertySeg1, PropertySeg2, &CalendarAddressCount);
402                         CalendarAddressCount++;
403                 
404                 } else if (Property == wxT("FBURL")){
406                         // See frmContactEditor-LoadCalendar.cpp
408                         ProcessCalendarFreeBusy(PropertySeg1, PropertySeg2, &FreeBusyAddressCount);
409                         FreeBusyAddressCount++;
411                 } else if (Property == wxT("KEY")){
412                 
413                         // See frmContactEditor-LoadKey.cpp
414                         
415                         ProcessKey(PropertySeg1, PropertySeg2, &KeyCount);
416                         KeyCount++;
417                 
418                 } else if (Property.Mid(0, 3) == wxT("VND")){
419                 
420                         ProcessVendor(PropertySeg1, PropertySeg2, &VendorCount);
421                         VendorCount++;
422                 
423                 } else if (Property.Mid(0, 2) == wxT("X-")){
424                         
425                         XTokenList.insert(std::make_pair(XTokenCount, PropertySeg2));
426                         XTokenListTokens.insert(std::make_pair(XTokenCount, PropertySeg1.Mid(2)));
427                         XTokenCount++;
428                 
429                 }
430                 
431         }
432         
433         return CONTACTLOAD_OK;
437 void ContactDataObject::ProcessKind(wxString KindType){
439         if (KindType == wxT("individual")){
440                         
441                 ContactKind = CONTACTKIND_INDIVIDUAL;
442                         
443         } else if (KindType == wxT("group")){
444                         
445                 ContactKind = CONTACTKIND_GROUP;
446                         
447         } else if (KindType == wxT("org")){
448                         
449                 ContactKind = CONTACTKIND_ORGANISATION;
450                         
451         } else if (KindType == wxT("location")){
452                         
453                 ContactKind = CONTACTKIND_LOCATION;
454                         
455         } else {
456                         
457                 ContactKind = CONTACTKIND_NONE;                 
458         }
462 void ContactDataObject::ProcessRevision(wxString PropertySeg1, wxString PropertySeg2){
464         size_t intPropertyLen = PropertySeg1.Len();
465         std::map<int, int> SplitPoints;
466         std::map<int, int> SplitLength;
467         std::map<int, int>::iterator SLiter;                    
468         wxString PropertyData;
469         wxString PropertyName;
470         wxString PropertyValue;
471         wxString PropertyTokens;
472         bool FirstToken = TRUE;
473         int intSplitsFound = 0;
474         int intSplitSize = 0;
475         int intPrevValue = 5;
476         int intPref = 0;                        
477         int intType = 0;
478         
479         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
480         
481         intPrevValue = 4;
483         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
484         intiter != SplitPoints.end(); ++intiter){
485         
486                 SLiter = SplitLength.find(intiter->first);
487         
488                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
489                 
490                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
491                 PropertyName = PropertyElement.GetNextToken();                          
492                 PropertyValue = PropertyElement.GetNextToken();
493                 
494                 intPrevValue = intiter->second;
495                 
496                 // Process properties.
497                 
498                 size_t intPropertyValueLen = PropertyValue.Len();
499                 
500                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
501                         
502                         PropertyValue.Trim();
503                         PropertyValue.RemoveLast();
504                         
505                 }                               
506                 
507                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
508                         
509                         PropertyValue.Remove(0, 1);
510                         
511                 }                       
512                 
513                 CaptureString(&PropertyValue, FALSE);
514                                                                 
515                 if (FirstToken == TRUE){
516                                 
517                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
518                         FirstToken = FALSE;
519                                 
520                 } else {
521                                 
522                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
523                                 
524                 }
525         
526         }       
527         
528         CaptureString(&PropertySeg2, FALSE);
529         
530         Revision = PropertySeg2;
531         
532         if (!PropertyTokens.IsEmpty()){
533         
534                 RevisionTokens = PropertyTokens;
535         
536         }
541 void ContactDataObject::ProcessSource(wxString PropertySeg1, wxString PropertySeg2, int *SourceCount){
543         size_t intPropertyLen = PropertySeg1.Len();
544         std::map<int, int> SplitPoints;
545         std::map<int, int> SplitLength;
546         std::map<int, int>::iterator SLiter;                    
547         wxString PropertyData;
548         wxString PropertyName;
549         wxString PropertyValue;
550         wxString PropertyTokens;
551         bool FirstToken = TRUE;
552         int intSplitsFound = 0;
553         int intSplitSize = 0;
554         int intPrevValue = 8;
555         int intPref = 0;                        
556         int intType = 0;
557         
558         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
559         
560         intPrevValue = 7;
561         
562         PropertyType PropType = PROPERTY_NONE;
563         
564         // Look for type before continuing.                     
566         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
568         intPrevValue = 7;
570         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
571         intiter != SplitPoints.end(); ++intiter){
572         
573                 SLiter = SplitLength.find(intiter->first);
574         
575                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
576                 
577                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
578                 PropertyName = PropertyElement.GetNextToken();                          
579                 PropertyValue = PropertyElement.GetNextToken();
580                 
581                 intPrevValue = intiter->second;
582                 
583                 // Process properties.
584                 
585                 size_t intPropertyValueLen = PropertyValue.Len();
586                 
587                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
588                         
589                         PropertyValue.Trim();
590                         PropertyValue.RemoveLast();
591                         
592                 }                               
593                 
594                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
595                         
596                         PropertyValue.Remove(0, 1);
597                         
598                 }                       
599                 
600                 CaptureString(&PropertyValue, FALSE);
601                 
602                 if (PropertyName == wxT("ALTID")){
604                         SourceListAltID.erase(*SourceCount);
605                         SourceListAltID.insert(std::make_pair(*SourceCount, PropertyValue));
606                 
607                 } else if (PropertyName == wxT("PID")){
609                         SourceListPID.erase(*SourceCount);
610                         SourceListPID.insert(std::make_pair(*SourceCount, PropertyValue));
611                 
612                 } else if (PropertyName == wxT("PREF")){
613                         
614                         ProcessIntegerValue(this, &SourceListPref, &PropertyValue, SourceCount);
616                 } else if (PropertyName == wxT("MEDIATYPE")){
617                 
618                         SourceListMediatype.erase(*SourceCount);
619                         SourceListMediatype.insert(std::make_pair(*SourceCount, PropertyValue));
621                 } else {
622                 
623                         // Something else we don't know about so append
624                         // to the tokens variable.
625                         
626                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
627                         
628                                 if (FirstToken == TRUE){
629                                 
630                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
631                                         FirstToken = FALSE;
632                                 
633                                 } else {
634                                 
635                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
636                                 
637                                 }
638                         
639                         }
640                 
641                 }
642         
643         }       
644         
645         intPropertyLen = PropertySeg2.Len();
646         SplitPoints.clear();
647         SplitLength.clear();
648         intSplitsFound = 0;
649         intSplitSize = 0;
650         intPrevValue = 0;
651         
652         CaptureString(&PropertySeg2, FALSE);
653         
654         // Add the data to the General/Home/Work address variables.
655                 
656         switch(PropType){
657                 case PROPERTY_NONE:
658                         break;
659                 case PROPERTY_HOME:
660                         SourceListType.insert(std::make_pair(*SourceCount, "home"));
661                         break;
662                 case PROPERTY_WORK:
663                         SourceListType.insert(std::make_pair(*SourceCount, "work"));
664                         break;
665         }
666         
667         SourceList.insert(std::make_pair(*SourceCount, PropertySeg2));
668         
669         if (!PropertyTokens.IsEmpty()){
670         
671                 SourceListTokens.insert(std::make_pair(*SourceCount, PropertyTokens));
672         
673         }
677 void ContactDataObject::ProcessXML(wxString PropertySeg1, wxString PropertySeg2, int *XMLCount){
679         std::map<int, int> SplitPoints;
680         std::map<int, int> SplitLength;
682         int intPrevValue = 5;
683         int intPref = 0;                        
684         int intType = 0;
685         
686         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
688         intPrevValue = 4;
689         
690         wxString PropertyName;
691         wxString PropertyValue;
692         wxString PropertyData;
693         wxString PropertyTokens;
694         std::map<int,int>::iterator SLiter;
695         bool FirstToken = TRUE;
696         
697         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
698         intiter != SplitPoints.end(); ++intiter){
699         
700                 SLiter = SplitLength.find(intiter->first);
701         
702                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
703                 
704                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
705                 PropertyName = PropertyElement.GetNextToken();                          
706                 PropertyValue = PropertyElement.GetNextToken();
707                 
708                 intPrevValue = intiter->second;
709                 
710                 CaptureString(&PropertyValue, FALSE);
711         
712                 if (PropertyName == wxT("ALTID")){
714                         XMLListAltID.erase(*XMLCount);
715                         XMLListAltID.insert(std::make_pair(*XMLCount, PropertyValue));
716                 
717                 }
718                 
719         }
721         XMLList.insert(std::make_pair(*XMLCount, PropertySeg2));
725 void ContactDataObject::ProcessMember(wxString PropertySeg1, wxString PropertySeg2, int *GroupCount){
727         std::map<int, int> SplitPoints;
728         std::map<int, int> SplitLength;
730         int intPrevValue = 8;
731         int intPref = 0;                        
732         int intType = 0;
733         
734         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
736         intPrevValue = 7;
737         
738         wxString PropertyName;
739         wxString PropertyValue;
740         wxString PropertyData;
741         wxString PropertyTokens;
742         std::map<int,int>::iterator SLiter;
743         bool FirstToken = TRUE;
744         
745         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
746         intiter != SplitPoints.end(); ++intiter){
747         
748                 SLiter = SplitLength.find(intiter->first);
749         
750                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
751                 
752                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
753                 PropertyName = PropertyElement.GetNextToken();                          
754                 PropertyValue = PropertyElement.GetNextToken();
755                 
756                 intPrevValue = intiter->second;
757                 
758                 CaptureString(&PropertyValue, FALSE);
759         
760                 if (PropertyName == wxT("ALTID")){
762                         GroupsListAltID.erase(*GroupCount);
763                         GroupsListAltID.insert(std::make_pair(*GroupCount, PropertyValue));
764                 
765                 } else if (PropertyName == wxT("PID")){
767                         GroupsListPID.erase(*GroupCount);
768                         GroupsListPID.insert(std::make_pair(*GroupCount, PropertyValue));
769                 
770                 } else if (PropertyName == wxT("PREF")){
772                         ProcessIntegerValue(this, &GroupsListPref, &PropertyValue, GroupCount);
773                 
774                 } else if (PropertyName == wxT("MEDIATYPE")){
776                         GroupsListMediaType.erase(*GroupCount);
777                         GroupsListMediaType.insert(std::make_pair(*GroupCount, PropertyValue));
778                 
779                 } else if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty()){
780                         
781                         if (FirstToken == TRUE){
782                                 
783                                 PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
784                                 FirstToken = FALSE;
785                                 
786                         } else {
787                         
788                                 PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
789                                 
790                         }
791                         
792                 }
793                 
794         }
796         GroupsList.insert(std::make_pair(*GroupCount, PropertySeg2));
798         if (!PropertyTokens.IsEmpty()){
799         
800                 GroupsListTokens.insert(std::make_pair(*GroupCount, PropertyTokens));
801         
802         }
807 void ContactDataObject::ProcessFN(wxString PropertySeg1, wxString PropertySeg2, int *FNCount){
809         std::map<int, int> SplitPoints;
810         std::map<int, int> SplitLength;
812         int intPrevValue = 4;
813         int intPref = 0;                        
814         int intType = 0;
815         
816         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
818         intPrevValue = 3;
819         
820         wxString PropertyName;
821         wxString PropertyValue;
822         wxString PropertyData;
823         wxString PropertyTokens;
824         std::map<int,int>::iterator SLiter;
825         bool FirstToken = TRUE;
826         
827         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
828         intiter != SplitPoints.end(); ++intiter){
829         
830                 SLiter = SplitLength.find(intiter->first);
831         
832                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
833                 
834                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
835                 PropertyName = PropertyElement.GetNextToken();                          
836                 PropertyValue = PropertyElement.GetNextToken();
837                 
838                 intPrevValue = intiter->second;
839                 
840                 CaptureString(&PropertyValue, FALSE);
841                 
842                 if (PropertyName == wxT("TYPE")){
844                         if (!PropertyValue.IsEmpty() || PropertyValue == wxT("home") ||
845                                 PropertyValue == wxT("work") ){
847                                 FullNamesListType.erase(*FNCount);
848                                 FullNamesListType.insert(std::make_pair(*FNCount, PropertyValue));
849                 
850                         }
851                 
852                 } else if (PropertyName == wxT("LANGUAGE")){
854                         FullNamesListLanguage.erase(*FNCount);
855                         FullNamesListLanguage.insert(std::make_pair(*FNCount, PropertyValue));
856                 
857                 } else if (PropertyName == wxT("ALTID")){
858                 
859                         FullNamesListAltID.erase(*FNCount);
860                         FullNamesListAltID.insert(std::make_pair(*FNCount, PropertyValue));
861                 
862                 } else if (PropertyName == wxT("PID")){
864                         FullNamesListPID.erase(*FNCount);
865                         FullNamesListPID.insert(std::make_pair(*FNCount, PropertyValue));
866                 
867                 } else if (PropertyName == wxT("PREF")){
869                         ProcessIntegerValue(this, &FullNamesListPref, &PropertyValue, FNCount);
870                 
871                 } else if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty()){
872                         
873                         if (FirstToken == TRUE){
874                                 
875                                 PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
876                                 FirstToken = FALSE;
877                                 
878                         } else {
879                         
880                                 PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
881                                 
882                         }
883                         
884                 } 
885         
886         }
888         FullNamesList.insert(std::make_pair(*FNCount, PropertySeg2));
890         if (!PropertyTokens.IsEmpty()){
891         
892                 FullNamesListTokens.insert(std::make_pair(*FNCount, PropertyTokens));
893         
894         }
898 void ContactDataObject::ProcessN(wxString PropertySeg1, wxString PropertySeg2){
900         std::map<int, int> SplitPoints;
901         std::map<int, int> SplitLength;
903         int intPrevValue = 3;
904         int intPref = 0;                        
905         int intType = 0;
906         
907         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
908         
909         intPrevValue = 2;
910         
911         wxString PropertyName;
912         wxString PropertyValue;
913         wxString PropertyData;
914         wxString PropertyTokens;
915         std::map<int,int>::iterator SLiter;
916         bool FirstToken = TRUE;
917         
918         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
919         intiter != SplitPoints.end(); ++intiter){
920         
921                 SLiter = SplitLength.find(intiter->first);
922         
923                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
924                 
925                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
926                 PropertyName = PropertyElement.GetNextToken();                          
927                 PropertyValue = PropertyElement.GetNextToken();
928                 
929                 intPrevValue = intiter->second;
930                 
931                 CaptureString(&PropertyValue, FALSE);
932                 
933                 if (PropertyName == wxT("ALTID")){
935                         NameAltID = PropertyValue;
936                 
937                 } else if (PropertyName == wxT("LANGUAGE")){
938                 
939                         NameLanguage = PropertyValue;
940                 
941                 } else if (PropertyName == wxT("SORT-AS")){
942                 
943                         if (PropertyValue.Left(1) == wxT("\"") && PropertyValue.Right(1) == wxT("\"") &&
944                                 PropertyValue.Len() >= 3){
945                                 NameDisplayAs = PropertyValue.Mid(1, (PropertyValue.Len() - 2));
946                         }
947                 
948                 } else if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty()){
949                         
950                         if (FirstToken == TRUE){
951                                 
952                                 PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
953                                 FirstToken = FALSE;
954                                 
955                         } else {
956                         
957                                 PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
958                                 
959                         }
960                         
961                 }
962         
963         }
964         
965         // Split the name data.
966         
967         int intSplitSeek = 0;           
968         int intSplitsFound = 0;
969         int intSplitSize = 0;
970         int intPropertyLen = PropertySeg2.Len();
971         
972         std::map<int,wxString> NameValues;
973         intPrevValue = 0;                                       
974         
975         for (int i = 0; i <= intPropertyLen; i++){
976         
977                 if (PropertySeg2.Mid(i, 1) == wxT(";") && PropertySeg2.Mid((i - 1), 1) != wxT("\\")){
978                         
979                         NameValues.insert(std::make_pair(++intSplitsFound, PropertySeg2.Mid(intSplitSeek, intSplitSize)));
980                         
981                         intSplitSeek = i;
982                         intSplitSeek++;
983                         
984                         if (intSplitsFound == 4){
985                         
986                                 NameValues.insert(std::make_pair(++intSplitsFound, PropertySeg2.Mid(intSplitSeek, wxString::npos)));
987                                 break;
988                         
989                         }
990                         
991                         intSplitSize = 0;
992                         continue;
993         
994                 }
995                 
996                 intSplitSize++;
998         }
999         
1000         // Split the data into several parts.
1001                         
1002         for (std::map<int, wxString>::iterator iter = NameValues.begin(); 
1003         iter != NameValues.end(); ++iter){
1004         
1005                 if (iter->first == 1){
1006                 
1007                         // Deal with family name.
1008                         
1009                         NameSurname = iter->second;
1010                 
1011                 } else if (iter->first == 2){
1012                 
1013                         // Deal with given names.
1014                         
1015                         NameForename = iter->second;
1016                 
1017                 } else if (iter->first == 3){
1018                 
1019                         // Deal with additional names.
1020                         
1021                         NameOtherNames = iter->second;
1022                 
1023                 } else if (iter->first == 4){
1024                 
1025                         // Deal with honorifix prefixes and suffixes.
1027                         NameTitle = iter->second;
1028                 
1029                         iter++;
1030                         
1031                         if (iter == NameValues.end()){
1032                         
1033                                 break;
1034                         
1035                         }
1036                 
1037                         NameSuffix = iter->second;
1038                 
1039                 }
1040         
1041         }
1042         
1043         // Add the name token data.
1044         
1045         if (!PropertyTokens.IsEmpty()){
1046         
1047                 NameTokens = PropertyTokens;
1048         
1049         }
1053 void ContactDataObject::ProcessClientPIDMap(wxString PropertySeg1, wxString PropertySeg2, int *ClientPIDCount){
1055         size_t intPropertyLen = PropertySeg1.Len();
1056         std::map<int, int> SplitPoints;
1057         std::map<int, int> SplitLength;
1058         std::map<int, int>::iterator SLiter;                    
1059         wxString PropertyData;
1060         wxString PropertyName;
1061         wxString PropertyValue;
1062         wxString PropertyTokens;
1063         bool FirstToken = TRUE;
1064         int intSplitsFound = 0;
1065         int intSplitSize = 0;
1066         int intPrevValue = 14;
1067         int intPref = 0;                        
1068         int intType = 0;
1069         
1070         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
1071         
1072         intPrevValue = 13;
1074         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
1075         intiter != SplitPoints.end(); ++intiter){
1076         
1077                 SLiter = SplitLength.find(intiter->first);
1078         
1079                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
1080                 
1081                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
1082                 PropertyName = PropertyElement.GetNextToken();                          
1083                 PropertyValue = PropertyElement.GetNextToken();
1084                 
1085                 intPrevValue = intiter->second;
1086                 
1087                 // Process properties.
1088                 
1089                 size_t intPropertyValueLen = PropertyValue.Len();
1090                 
1091                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
1092                         
1093                         PropertyValue.Trim();
1094                         PropertyValue.RemoveLast();
1095                         
1096                 }                               
1097                 
1098                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
1099                         
1100                         PropertyValue.Remove(0, 1);
1101                         
1102                 }                       
1103                 
1104                 CaptureString(&PropertyValue, FALSE);
1105                 
1106                 if (PropertyName.IsEmpty() || PropertyName.IsEmpty()){
1107                 
1108                         continue;
1109                 
1110                 }
1111                                                         
1112                 if (FirstToken == TRUE){
1113                                 
1114                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
1115                         FirstToken = FALSE;
1116                                 
1117                 } else {
1118                                 
1119                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
1120                                 
1121                 }
1122         
1123         }       
1124         
1125         CaptureString(&PropertySeg2, FALSE);
1126         
1127         ClientPIDList.insert(std::make_pair(*ClientPIDCount, PropertySeg2));
1128         
1129         if (!PropertyTokens.IsEmpty()){
1130         
1131                 ClientPIDListTokens.insert(std::make_pair(*ClientPIDCount, PropertyTokens));
1132         
1133         }
1137 void ContactDataObject::ProcessNickname(wxString PropertySeg1, wxString PropertySeg2, int *NicknameCount){
1139         std::map<int, int> SplitPoints;
1140         std::map<int, int> SplitLength;
1142         int intPrevValue = 10;
1143         int intPref = 0;                        
1144         
1145         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
1146         
1147         intPrevValue = 9;
1148         
1149         PropertyType PropType = PROPERTY_NONE;
1150         
1151         // Look for type before continuing.
1152         
1153         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
1154         
1155         intPrevValue = 9;
1156         
1157         std::map<int, wxString> *NicknamesList = NULL;
1158         std::map<int, wxString> *NicknamesListType = NULL;
1159         std::map<int, wxString> *NicknamesListLanguage = NULL;
1160         std::map<int, wxString> *NicknamesListAltID = NULL;
1161         std::map<int, wxString> *NicknamesListPID = NULL;
1162         std::map<int, wxString> *NicknamesListTokens = NULL;            
1163         std::map<int, int> *NicknamesListPref = NULL;
1164         
1165         switch(PropType){
1166                 case PROPERTY_NONE:
1167                         NicknamesList = &GeneralNicknamesList;
1168                         NicknamesListType = &GeneralNicknamesListType;
1169                         NicknamesListLanguage = &GeneralNicknamesListLanguage;
1170                         NicknamesListAltID = &GeneralNicknamesListAltID;
1171                         NicknamesListPID = &GeneralNicknamesListPID;
1172                         NicknamesListTokens = &GeneralNicknamesListTokens;
1173                         NicknamesListPref = &GeneralNicknamesListPref;
1174                         break;
1175                 case PROPERTY_HOME:
1176                         NicknamesList = &HomeNicknamesList;
1177                         NicknamesListType = &HomeNicknamesListType;
1178                         NicknamesListLanguage = &HomeNicknamesListLanguage;
1179                         NicknamesListAltID = &HomeNicknamesListAltID;
1180                         NicknamesListPID = &HomeNicknamesListPID;
1181                         NicknamesListTokens = &HomeNicknamesListTokens;
1182                         NicknamesListPref = &HomeNicknamesListPref;
1183                         break;
1184                 case PROPERTY_WORK:
1185                         NicknamesList = &BusinessNicknamesList;
1186                         NicknamesListType = &BusinessNicknamesListType;
1187                         NicknamesListLanguage = &BusinessNicknamesListLanguage;
1188                         NicknamesListAltID = &BusinessNicknamesListAltID;
1189                         NicknamesListPID = &BusinessNicknamesListPID;
1190                         NicknamesListTokens = &BusinessNicknamesListTokens;
1191                         NicknamesListPref = &BusinessNicknamesListPref;
1192                         break;
1193         }
1194         
1195         std::map<int, int>::iterator SLiter;    
1196         wxString PropertyData;
1197         wxString PropertyName;
1198         wxString PropertyValue;
1199         wxString PropertyTokens;
1200         bool FirstToken = TRUE;
1201         
1202         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
1203         intiter != SplitPoints.end(); ++intiter){
1204         
1205                 SLiter = SplitLength.find(intiter->first);
1206         
1207                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
1208                 
1209                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
1210                 PropertyName = PropertyElement.GetNextToken();                          
1211                 PropertyValue = PropertyElement.GetNextToken();
1212                 
1213                 intPrevValue = intiter->second;
1214                 
1215                 CaptureString(&PropertyValue, FALSE);
1216                 
1217                 if (PropertyName == wxT("ALTID")){
1219                         NicknamesListAltID->erase(*NicknameCount);
1220                         NicknamesListAltID->insert(std::make_pair(*NicknameCount, PropertyValue));
1221                 
1222                 } else if (PropertyName == wxT("PID")){
1224                         NicknamesListPID->erase(*NicknameCount);
1225                         NicknamesListPID->insert(std::make_pair(*NicknameCount, PropertyValue));        
1227                 } else if (PropertyName == wxT("PREF")){
1229                         ProcessIntegerValue(this, NicknamesListPref, &PropertyValue, NicknameCount);
1230                 
1231                 } else if (PropertyName == wxT("LANGUAGE")){
1233                         NicknamesListLanguage->erase(*NicknameCount);
1234                         NicknamesListLanguage->insert(std::make_pair(*NicknameCount, PropertyValue));   
1236                 } else {
1237                 
1238                         // Something else we don't know about so append
1239                         // to the tokens variable.
1240                 
1241                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
1242                 
1243                                 if (FirstToken == TRUE){
1244                         
1245                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
1246                                         FirstToken = FALSE;
1247                         
1248                                 } else {
1249                         
1250                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
1251                         
1252                                 }
1253                 
1254                         }
1255                 
1256                 }
1257                 
1258         }
1259         
1260         NicknamesList->insert(std::make_pair(*NicknameCount, PropertySeg2));
1261         
1262         // Add the name token data.
1263         
1264         if (!PropertyTokens.IsEmpty()){
1265         
1266                 NicknamesListTokens->insert(std::make_pair(*NicknameCount, PropertyTokens));
1267         
1268         }
1272 void ContactDataObject::ProcessGender(wxString PropertySeg1, wxString PropertySeg2){
1274         std::map<int, int> SplitPoints;
1275         std::map<int, int> SplitLength;
1276         std::map<int, int>::iterator SLiter;                    
1277         wxString PropertyData;
1278         wxString PropertyName;
1279         wxString PropertyValue;
1280         wxString PropertyTokens;
1281         bool FirstToken = TRUE;
1282         int intPrevValue = 8;
1284         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
1286         intPrevValue = 7;                       
1287         
1288         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
1289         intiter != SplitPoints.end(); ++intiter){
1290         
1291                 SLiter = SplitLength.find(intiter->first);
1292         
1293                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
1294                 
1295                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
1296                 PropertyName = PropertyElement.GetNextToken();                          
1297                 PropertyValue = PropertyElement.GetNextToken();
1298                 
1299                 intPrevValue = intiter->second;
1300                 
1301                 // Process properties.
1302                 
1303                 size_t intPropertyValueLen = PropertyValue.Len();
1304                 
1305                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
1306                         
1307                         PropertyValue.Trim();
1308                         PropertyValue.RemoveLast();
1309                         
1310                 }                               
1311                 
1312                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
1313                         
1314                         PropertyValue.Remove(0, 1);
1315                         
1316                 }                               
1317                 
1318                 if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty()){
1320                         if (FirstToken == TRUE){
1321         
1322                                 PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
1323                                 FirstToken = FALSE;
1324         
1325                         } else {
1326         
1327                                 PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
1328         
1329                         }
1331                 }
1332         
1333         }       
1335         wxStringTokenizer GenderData (PropertySeg2, wxT(";"));
1336         
1337         wxString GenderComponent;
1338         
1339         if (GenderData.CountTokens() >= 2){
1340         
1341                 Gender = GenderData.GetNextToken();
1342                 GenderDetails = GenderData.GetString();
1343         
1344                 CaptureString(&GenderDetails, FALSE);
1345                                                 
1346         } else {
1347         
1348                 Gender = GenderData.GetNextToken();
1349         
1350         }
1351         
1352         if (!PropertyTokens.IsEmpty()){
1353         
1354                 GenderTokens = PropertyTokens;
1355         
1356         }
1360 void ContactDataObject::ProcessBirthday(wxString PropertySeg1, wxString PropertySeg2){
1362         // Process date. Preserve the remainder in the string.
1364         std::map<int, int> SplitPoints;
1365         std::map<int, int> SplitLength;
1366         std::map<int, int>::iterator SLiter;                    
1367         wxString PropertyData;
1368         wxString PropertyName;
1369         wxString PropertyValue;
1370         wxString PropertyTokens;
1371         bool BirthdayText = FALSE;
1372         int intPrevValue = 6;
1374         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
1376         intPrevValue = 5;
1378         // Look for type before continuing.
1380         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
1381         intiter != SplitPoints.end(); ++intiter){
1383                 SLiter = SplitLength.find(intiter->first);
1385                 PropertyData = PropertySeg1.Mid(intPrevValue, SLiter->second);
1386         
1387                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
1388                 PropertyName = PropertyElement.GetNextToken();                          
1389                 PropertyValue = PropertyElement.GetNextToken();
1390         
1391                 intPrevValue = intiter->second;
1392         
1393                 if (PropertyName == wxT("VALUE") && PropertyValue == wxT("text") && BirthdayText == FALSE){
1394         
1395                         CaptureString(&PropertySeg2, FALSE);
1396                         Birthday = PropertySeg2;
1397                         BirthdayText = TRUE;
1398         
1399                 }
1401         }
1403         // Setup blank lines for later on.
1404         
1405         intPrevValue = 5;
1406         bool FirstToken = TRUE;
1408         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
1409         intiter != SplitPoints.end(); ++intiter){
1411                 SLiter = SplitLength.find(intiter->first);
1413                 PropertyData = PropertySeg1.Mid(intPrevValue, SLiter->second);
1414         
1415                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
1416                 PropertyName = PropertyElement.GetNextToken();                          
1417                 PropertyValue = PropertyElement.GetNextToken();
1418         
1419                 intPrevValue = intiter->second;
1420         
1421                 // Process properties.
1422         
1423                 CaptureString(&PropertyValue, FALSE);
1424         
1425                 if (PropertyValue.Mid((PropertyValue.Len() - 1), 1) == wxT("\"")){
1426                 
1427                         PropertyValue.Trim();
1428                         PropertyValue.RemoveLast();
1429                 
1430                 }                               
1431         
1432                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
1433                 
1434                         PropertyValue.Remove(0, 1);
1435                 
1436                 }                               
1437         
1438                 if (PropertyName == wxT("ALTID")){
1440                         BirthdayAltID = PropertyValue;
1441         
1442                 } else if (PropertyName == wxT("CALSCALE")){
1443         
1444                         BirthdayCalScale = PropertyValue;
1445         
1446                 } else if (PropertyName != wxT("VALUE")) {
1447         
1448                         // Something else we don't know about so append
1449                         // to the tokens variable.
1450                 
1451                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty()){
1452                 
1453                                 if (FirstToken == TRUE){
1454         
1455                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
1456                                         FirstToken = FALSE;
1457         
1458                                 } else {
1459         
1460                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
1461         
1462                                 }
1463                                 
1464                         }
1465                         
1466                 }
1468         }       
1470         // Add the data to the variables and form.
1471         
1472         if (BirthdayText == FALSE){
1473         
1474                 Birthday = PropertySeg2;
1476         }
1477         
1478         if (!PropertyTokens.IsEmpty()){
1479         
1480                 BirthdayTokens = PropertyTokens;
1482         }
1486 void ContactDataObject::ProcessAnniversary(wxString PropertySeg1, wxString PropertySeg2){
1488         // Process date. Preserve the remainder in the string.
1490         std::map<int, int> SplitPoints;
1491         std::map<int, int> SplitLength;
1492         std::map<int, int>::iterator SLiter;                    
1493         wxString PropertyData;
1494         wxString PropertyName;
1495         wxString PropertyValue;
1496         wxString PropertyTokens;
1497         bool AnniversaryText = FALSE;
1498         int intPrevValue = 13;
1500         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
1502         intPrevValue = 12;
1504         // Look for type before continuing.
1506         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
1507         intiter != SplitPoints.end(); ++intiter){
1509                 SLiter = SplitLength.find(intiter->first);
1511                 PropertyData = PropertySeg1.Mid(intPrevValue, SLiter->second);
1512         
1513                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
1514                 PropertyName = PropertyElement.GetNextToken();                          
1515                 PropertyValue = PropertyElement.GetNextToken();
1516         
1517                 intPrevValue = intiter->second;
1518         
1519                 if (PropertyName == wxT("VALUE") && PropertyValue == wxT("text") && AnniversaryText == FALSE){
1520         
1521                         CaptureString(&PropertySeg2, FALSE);
1522                         Anniversary = PropertySeg2;
1523                         AnniversaryText = TRUE;
1524         
1525                 }
1527         }
1529         // Setup blank lines for later on.
1530         
1531         intPrevValue = 12;
1532         bool FirstToken = TRUE;
1534         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
1535         intiter != SplitPoints.end(); ++intiter){
1537                 SLiter = SplitLength.find(intiter->first);
1539                 PropertyData = PropertySeg1.Mid(intPrevValue, SLiter->second);
1540         
1541                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
1542                 PropertyName = PropertyElement.GetNextToken();                          
1543                 PropertyValue = PropertyElement.GetNextToken();
1544         
1545                 intPrevValue = intiter->second;
1546         
1547                 // Process properties.
1548         
1549                 CaptureString(&PropertyValue, FALSE);
1550         
1551                 if (PropertyValue.Mid((PropertyValue.Len() - 1), 1) == wxT("\"")){
1552                 
1553                         PropertyValue.Trim();
1554                         PropertyValue.RemoveLast();
1555                 
1556                 }                               
1557         
1558                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
1559                 
1560                         PropertyValue.Remove(0, 1);
1561                 
1562                 }                               
1563         
1564                 if (PropertyName == wxT("ALTID")){
1566                         AnniversaryAltID = PropertyValue;
1567         
1568                 } else if (PropertyName == wxT("CALSCALE")){
1569         
1570                         AnniversaryCalScale = PropertyValue;
1571         
1572                 } else if (PropertyName != wxT("VALUE")) {
1573         
1574                         // Something else we don't know about so append
1575                         // to the tokens variable.
1576                 
1577                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty()){
1578                 
1579                                 if (FirstToken == TRUE){
1580         
1581                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
1582                                         FirstToken = FALSE;
1583         
1584                                 } else {
1585         
1586                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
1587         
1588                                 }
1589                                 
1590                         }
1591                         
1592                 }
1594         }       
1596         // Add the data to the variables and form.
1597         
1598         if (AnniversaryText == FALSE){
1599         
1600                 Anniversary = PropertySeg2;
1602         }
1603         
1604         if (!PropertyTokens.IsEmpty()){
1605         
1606                 AnniversaryTokens = PropertyTokens;
1608         }
1612 void ContactDataObject::ProcessTimeZone(wxString PropertySeg1, wxString PropertySeg2, int *TimeZoneCount){
1614         std::map<int, int> SplitPoints;
1615         std::map<int, int> SplitLength;
1617         int intPrevValue = 4;
1618         int intPref = 0;                        
1619         
1620         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
1621         
1622         intPrevValue = 3;
1623         
1624         PropertyType PropType = PROPERTY_NONE;
1625         
1626         // Look for type before continuing.
1627         
1628         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
1629         
1630         intPrevValue = 3;
1631         
1632         std::map<int, wxString> *TZList = NULL;
1633         std::map<int, wxString> *TZListType = NULL;
1634         std::map<int, wxString> *TZListMediatype = NULL;
1635         std::map<int, wxString> *TZListAltID = NULL;
1636         std::map<int, wxString> *TZListPID = NULL;
1637         std::map<int, wxString> *TZListTokens = NULL;           
1638         std::map<int, int> *TZListPref = NULL;
1639         
1640         switch(PropType){
1641                 case PROPERTY_NONE:
1642                         TZList = &GeneralTZList;
1643                         TZListType = &GeneralTZListType;
1644                         TZListMediatype = &GeneralTZListMediatype;
1645                         TZListAltID = &GeneralTZListAltID;
1646                         TZListPID = &GeneralTZListPID;
1647                         TZListTokens = &GeneralTZListTokens;
1648                         TZListPref = &GeneralTZListPref;
1649                         break;
1650                 case PROPERTY_HOME:
1651                         TZList = &HomeTZList;
1652                         TZListType = &HomeTZListType;
1653                         TZListMediatype = &HomeTZListMediatype;
1654                         TZListAltID = &HomeTZListAltID;
1655                         TZListPID = &HomeTZListPID;
1656                         TZListTokens = &HomeTZListTokens;
1657                         TZListPref = &HomeTZListPref;
1658                         break;
1659                 case PROPERTY_WORK:
1660                         TZList = &BusinessTZList;
1661                         TZListType = &BusinessTZListType;
1662                         TZListMediatype = &BusinessTZListMediatype;
1663                         TZListAltID = &BusinessTZListAltID;
1664                         TZListPID = &BusinessTZListPID;
1665                         TZListTokens = &BusinessTZListTokens;
1666                         TZListPref = &BusinessTZListPref;
1667                         break;
1668         }
1669         
1670         std::map<int, int>::iterator SLiter;    
1671         wxString PropertyData;
1672         wxString PropertyName;
1673         wxString PropertyValue;
1674         wxString PropertyTokens;
1675         bool FirstToken = TRUE;
1676         
1677         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
1678         intiter != SplitPoints.end(); ++intiter){
1679         
1680                 SLiter = SplitLength.find(intiter->first);
1681         
1682                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
1683                 
1684                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
1685                 PropertyName = PropertyElement.GetNextToken();                          
1686                 PropertyValue = PropertyElement.GetNextToken();
1687                 
1688                 intPrevValue = intiter->second;
1689                 
1690                 CaptureString(&PropertyValue, FALSE);
1692                 if (PropertyName == wxT("ALTID")){
1694                         TZListAltID->erase(*TimeZoneCount);
1695                         TZListAltID->insert(std::make_pair(*TimeZoneCount, PropertyValue));
1696                 
1697                 } else if (PropertyName == wxT("PID")){
1699                         TZListPID->erase(*TimeZoneCount);
1700                         TZListPID->insert(std::make_pair(*TimeZoneCount, PropertyValue));       
1702                 } else if (PropertyName == wxT("PREF")){
1704                         ProcessIntegerValue(this, TZListPref, &PropertyValue, TimeZoneCount);
1705                 
1706                 } else if (PropertyName == wxT("MEDIATYPE")){
1708                         TZListMediatype->erase(*TimeZoneCount);
1709                         TZListMediatype->insert(std::make_pair(*TimeZoneCount, PropertyValue)); 
1711                 } else {
1712                 
1713                         // Something else we don't know about so append
1714                         // to the tokens variable.
1715                 
1716                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
1717                 
1718                                 if (FirstToken == TRUE){
1719                         
1720                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
1721                                         FirstToken = FALSE;
1722                         
1723                                 } else {
1724                         
1725                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
1726                         
1727                                 }
1728                 
1729                         }
1730                 
1731                 }
1732                 
1733         }
1734         
1735         TZList->insert(std::make_pair(*TimeZoneCount, PropertySeg2));
1736         
1737         // Add the name token data.
1738         
1739         if (!PropertyTokens.IsEmpty()){
1740         
1741                 TZListTokens->insert(std::make_pair(*TimeZoneCount, PropertyTokens));
1742         
1743         }
1748 void ContactDataObject::ProcessAddress(wxString PropertySeg1, wxString PropertySeg2, int *AddressCount){
1750         size_t intPropertyLen = PropertySeg1.Len();
1751         std::map<int, int> SplitPoints;
1752         std::map<int, int> SplitLength;
1753         std::map<int, int>::iterator SLiter;                    
1754         wxString PropertyData;
1755         wxString PropertyName;
1756         wxString PropertyValue;
1757         wxString PropertyTokens;
1758         wxString AddressLabel;
1759         wxString AddressLang;
1760         wxString AddressAltID;
1761         wxString AddressPID;
1762         wxString AddressTokens;
1763         wxString AddressGeo;
1764         wxString AddressTimezone;
1765         wxString AddressType;
1766         wxString AddressMediatype;
1767         wxString AddressPOBox;
1768         wxString AddressExtended;
1769         wxString AddressStreet;
1770         wxString AddressLocality;
1771         wxString AddressCity;
1772         wxString AddressRegion;
1773         wxString AddressPostalCode;
1774         wxString AddressCountry;
1775         bool FirstToken = TRUE;                 
1776         int intSplitsFound = 0;
1777         int intSplitSize = 0;
1778         int intPrevValue = 5;
1779         int intPref = 0;                        
1780         int intType = 0;
1781         long ListCtrlIndex;
1782         
1783         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
1784         
1785         intPrevValue = 4;
1786         
1787         PropertyType PropType = PROPERTY_NONE;
1788                 
1789         // Look for type before continuing.
1790         
1791         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
1792         
1793         intPrevValue = 4;
1794         
1795         std::map<int, wxString> *AddressList = NULL;
1796         std::map<int, wxString> *AddressListTown = NULL;
1797         std::map<int, wxString> *AddressListCounty = NULL;
1798         std::map<int, wxString> *AddressListPostCode = NULL;
1799         std::map<int, wxString> *AddressListCountry = NULL;
1800         std::map<int, wxString> *AddressListLabel = NULL;
1801         std::map<int, wxString> *AddressListLang = NULL;                
1802         std::map<int, wxString> *AddressListAltID = NULL;
1803         std::map<int, wxString> *AddressListPID = NULL;
1804         std::map<int, wxString> *AddressListTokens = NULL;
1805         std::map<int, wxString> *AddressListGeo = NULL;
1806         std::map<int, wxString> *AddressListTimezone = NULL;            
1807         std::map<int, wxString> *AddressListType = NULL;
1808         std::map<int, wxString> *AddressListMediatype = NULL;
1809         std::map<int, int> *AddressListPref = NULL;
1811         switch(PropType){
1812                 case PROPERTY_NONE:
1813                         AddressList = &GeneralAddressList;
1814                         AddressListTown = &GeneralAddressListTown;
1815                         AddressListCounty = &GeneralAddressListCounty;
1816                         AddressListPostCode = &GeneralAddressListPostCode;
1817                         AddressListCountry = &GeneralAddressListCountry;
1818                         AddressListLabel = &GeneralAddressListLabel;
1819                         AddressListLang = &GeneralAddressListLang;              
1820                         AddressListAltID = &GeneralAddressListAltID;
1821                         AddressListPID = &GeneralAddressListPID;
1822                         AddressListTokens = &GeneralAddressListTokens;
1823                         AddressListGeo = &GeneralAddressListGeo;
1824                         AddressListTimezone = &GeneralAddressListTimezone;
1825                         AddressListType = &GeneralAddressListType;
1826                         AddressListMediatype = &GeneralAddressListMediatype;
1827                         AddressListPref = &GeneralAddressListPref;              
1828                         break;
1829                 case PROPERTY_HOME:
1830                         AddressList = &HomeAddressList;
1831                         AddressListTown = &HomeAddressListTown;
1832                         AddressListCounty = &HomeAddressListCounty;
1833                         AddressListPostCode = &HomeAddressListPostCode;
1834                         AddressListCountry = &HomeAddressListCountry;
1835                         AddressListLabel = &HomeAddressListLabel;
1836                         AddressListLang = &HomeAddressListLang;         
1837                         AddressListAltID = &HomeAddressListAltID;
1838                         AddressListPID = &HomeAddressListPID;
1839                         AddressListTokens = &HomeAddressListTokens;
1840                         AddressListGeo = &HomeAddressListGeo;
1841                         AddressListTimezone = &HomeAddressListTimezone;
1842                         AddressListType = &HomeAddressListType;
1843                         AddressListMediatype = &HomeAddressListMediatype;
1844                         AddressListPref = &HomeAddressListPref;
1845                         break;
1846                 case PROPERTY_WORK:
1847                         AddressList = &BusinessAddressList;
1848                         AddressListTown = &BusinessAddressListTown;
1849                         AddressListCounty = &BusinessAddressListCounty;
1850                         AddressListPostCode = &BusinessAddressListPostCode;
1851                         AddressListCountry = &BusinessAddressListCountry;
1852                         AddressListLabel = &BusinessAddressListLabel;
1853                         AddressListLang = &BusinessAddressListLang;             
1854                         AddressListAltID = &BusinessAddressListAltID;
1855                         AddressListPID = &BusinessAddressListPID;
1856                         AddressListTokens = &BusinessAddressListTokens;
1857                         AddressListGeo = &BusinessAddressListGeo;
1858                         AddressListTimezone = &BusinessAddressListTimezone;
1859                         AddressListType = &BusinessAddressListType;
1860                         AddressListMediatype = &BusinessAddressListMediatype;
1861                         AddressListPref = &BusinessAddressListPref;
1862                         break;
1863         }
1864         
1865         intPrevValue = 4;
1866         
1867         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
1868         intiter != SplitPoints.end(); ++intiter){
1869         
1870                 SLiter = SplitLength.find(intiter->first);
1871         
1872                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
1873                 
1874                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
1875                 PropertyName = PropertyElement.GetNextToken();                          
1876                 PropertyValue = PropertyElement.GetNextToken();
1877                 
1878                 intPrevValue = intiter->second;
1879                 
1880                 CaptureString(&PropertyValue, FALSE);
1881                 
1882                 // Process properties.
1883                 
1884                 if (PropertyName == wxT("LABEL")){
1885                 
1886                         AddressListLabel->erase(*AddressCount);
1887                         AddressListLabel->insert(std::make_pair(*AddressCount, PropertyValue));
1888                                 
1889                 } else if (PropertyName == wxT("LANGUAGE")){
1890                 
1891                         AddressListLang->erase(*AddressCount);
1892                         AddressListLang->insert(std::make_pair(*AddressCount, PropertyValue));                  
1893                 
1894                 } else if (PropertyName == wxT("ALTID")){
1896                         AddressListAltID->erase(*AddressCount);
1897                         AddressListAltID->insert(std::make_pair(*AddressCount, PropertyValue));
1898                 
1899                 } else if (PropertyName == wxT("PID")){
1901                         AddressListPID->erase(*AddressCount);
1902                         AddressListPID->insert(std::make_pair(*AddressCount, PropertyValue));
1903                 
1904                 } else if (PropertyName == wxT("GEO")){
1905                 
1906                         AddressListGeo->erase(*AddressCount);
1907                         AddressListGeo->insert(std::make_pair(*AddressCount, PropertyValue));
1908                 
1909                 } else if (PropertyName == wxT("TZ")){
1911                         AddressListTimezone->erase(*AddressCount);
1912                         AddressListTimezone->insert(std::make_pair(*AddressCount, PropertyValue));
1913                 
1914                 } else if (PropertyName == wxT("MEDIATYPE")){
1916                         AddressListMediatype->erase(*AddressCount);
1917                         AddressListMediatype->insert(std::make_pair(*AddressCount, PropertyValue));
1918                 
1919                 } else if (PropertyName == wxT("PREF")){
1921                         ProcessIntegerValue(this, AddressListPref, &PropertyValue, AddressCount);
1922                 
1923                 } else {
1924                 
1925                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
1926                         
1927                                 if (FirstToken == TRUE){
1928                                 
1929                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
1930                                         FirstToken = FALSE;
1931                                 
1932                                 } else {
1933                                 
1934                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
1935                                 
1936                                 }
1937                         
1938                         }
1939                 
1940                 }
1941         
1942         }                       
1943         
1944         // Split the address. 
1946         //std::map<int, int>::iterator SLiter;
1947         intPropertyLen = PropertySeg2.Len();
1948         SplitPoints.clear();
1949         SplitLength.clear();
1950         intSplitsFound = 0;
1951         intSplitSize = 0;
1952         intPrevValue = 0;
1953         
1954         for (int i = 0; i <= intPropertyLen; i++){
1956                 intSplitSize++;
1957         
1958                 if (PropertySeg2.Mid(i, 1) == wxT(";") && PropertySeg2.Mid((i - 1), 1) != wxT("\\")){
1959         
1960                         intSplitsFound++;
1961                         SplitPoints.insert(std::make_pair(intSplitsFound, (i + 1)));
1962                         
1963                         if (intSplitsFound == 6){ 
1964                         
1965                                 SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1)));
1966                                 break; 
1967                                 
1968                         } else {
1969                         
1970                                 SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1)));
1971                         
1972                         }
1973                         
1974                         intSplitSize = 0;                                       
1975         
1976                 }
1978         }
1979         
1980         // Split the data into several parts.                   
1981         
1982         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
1983         intiter != SplitPoints.end(); ++intiter){
1984                         
1985                 if (intiter->first == 1){
1986                 
1987                         // Deal with PO Box.
1988                         
1989                         SLiter = SplitLength.find(1);
1990                                                                 
1991                         //txtSurname->SetValue(ContactData.Convert(wxSPropertySeg2.Mid(0, SLiter->second), TRUE));
1992                         AddressPOBox = PropertySeg2.Mid(0, SLiter->second);
1993                         intPrevValue = intiter->second;
1994                 
1995                 } else if (intiter->first == 2){
1996                 
1997                         // Deal with extended address.
1998                         
1999                         SLiter = SplitLength.find(2);
2000                         
2001                         AddressExtended = PropertySeg2.Mid(intPrevValue, SLiter->second);
2002                         //txtForename->SetValue(ContactData.Convert(wxSPropertySeg2.Mid(intPrevValue, SLiter->second), TRUE));
2003                         intPrevValue = intiter->second;
2004                 
2005                 } else if (intiter->first == 3){
2006                 
2007                         // Deal with street address.
2008                         
2009                         SLiter = SplitLength.find(3);
2010                                                                 
2011                         AddressStreet = PropertySeg2.Mid(intPrevValue, SLiter->second);
2012                         //txtOtherNames->SetValue(ContactData.Convert(wxSPropertySeg2.Mid(intPrevValue, SLiter->second), TRUE));
2013                         intPrevValue = intiter->second;
2014                 
2015                 } else if (intiter->first == 4){
2016                 
2017                         // Deal with locality
2019                         SLiter = SplitLength.find(4);
2020                         
2021                         AddressLocality = PropertySeg2.Mid(intPrevValue, SLiter->second);
2022                         //txtTitle->SetValue(ContactData.Convert(wxSPropertySeg2.Mid(intPrevValue, SLiter->second), TRUE));
2023                         intPrevValue = intiter->second;
2024                         
2025                         //txtSuffix->SetValue(ContactData.Convert(wxSPropertySeg2.Mid(intPrevValue), TRUE));
2026                 
2027                 } else if (intiter->first == 5){
2028                 
2029                         // Deal with region.
2031                         SLiter = SplitLength.find(5);
2032                         
2033                         AddressRegion = PropertySeg2.Mid(intPrevValue, SLiter->second);
2034                         //txtTitle->SetValue(ContactData.Convert(wxSPropertySeg2.Mid(intPrevValue, SLiter->second), TRUE));
2035                         intPrevValue = intiter->second;
2036                         
2037                         //txtSuffix->SetValue(ContactData.Convert(wxSPropertySeg2.Mid(intPrevValue), TRUE));
2038                 
2039                 } else if (intiter->first == 6){
2040                 
2041                         // Deal with post code.
2043                         SLiter = SplitLength.find(6);
2044                         
2045                         AddressPostalCode = PropertySeg2.Mid(intPrevValue, SLiter->second);
2046                         //txtTitle->SetValue(ContactData.Convert(wxSPropertySeg2.Mid(intPrevValue, SLiter->second), TRUE));
2047                         intPrevValue = intiter->second;
2048                         
2049                         // Deal with country.
2050                                                 
2051                         AddressCountry = PropertySeg2.Mid(intPrevValue, wxString::npos);
2052                         //txtSuffix->SetValue(ContactData.Convert(wxSPropertySeg2.Mid(intPrevValue), TRUE));
2053                         
2054                         break;
2055                 
2056                 }
2057         
2058         }       
2059         
2060         // Add the data to the General/Home/Work address variables.
2061         
2062         CaptureString(&AddressStreet, FALSE); 
2063         CaptureString(&AddressLocality, FALSE);
2064         CaptureString(&AddressRegion, FALSE);
2065         CaptureString(&AddressPostalCode, FALSE);
2066         CaptureString(&AddressCountry, FALSE);
2067                 
2068         if (!PropertyTokens.IsEmpty()){
2069         
2070                 AddressListTokens->insert(std::make_pair(*AddressCount, PropertyTokens));
2071         
2072         }
2074         AddressListCountry->insert(std::make_pair(*AddressCount, AddressCountry));      
2075         AddressList->insert(std::make_pair(*AddressCount, AddressStreet));
2076         AddressListTown->insert(std::make_pair(*AddressCount, AddressLocality));
2077         AddressListCounty->insert(std::make_pair(*AddressCount, AddressRegion));
2078         AddressListPostCode->insert(std::make_pair(*AddressCount, AddressPostalCode));
2080         switch(PropType){
2081                 case PROPERTY_NONE:
2082                         AddressListType->insert(std::make_pair(*AddressCount, wxT("")));
2083                         break;
2084                 case PROPERTY_HOME:
2085                         AddressListType->insert(std::make_pair(*AddressCount, wxT("home")));
2086                         break;
2087                 case PROPERTY_WORK:
2088                         AddressListType->insert(std::make_pair(*AddressCount, wxT("work")));    
2089                         break;
2090         }
2091         
2092         AddressListTokens->insert(std::make_pair(*AddressCount, PropertyTokens));
2096 void ContactDataObject::ProcessEmail(wxString PropertySeg1, wxString PropertySeg2, int *EmailCount){
2098         std::map<int, int> SplitPoints;
2099         std::map<int, int> SplitLength;
2101         int intPrevValue = 7;
2102         int intPref = 0;                        
2103         
2104         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
2105         
2106         intPrevValue = 6;
2107         
2108         PropertyType PropType = PROPERTY_NONE;
2109                 
2110         // Look for type before continuing.
2111         
2112         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
2113         
2114         std::map<int, wxString> *EmailList = NULL;
2115         std::map<int, wxString> *EmailListType = NULL;
2116         std::map<int, wxString> *EmailListAltID = NULL;
2117         std::map<int, wxString> *EmailListPID = NULL;
2118         std::map<int, wxString> *EmailListTokens = NULL;                
2119         std::map<int, int> *EmailListPref = NULL;
2121         switch(PropType){
2122                 case PROPERTY_NONE:
2123                         EmailList = &GeneralEmailList;
2124                         EmailListType = &GeneralEmailListType;
2125                         EmailListAltID = &GeneralEmailListAltID;
2126                         EmailListPID = &GeneralEmailListPID;
2127                         EmailListTokens = &GeneralEmailListTokens;              
2128                         EmailListPref = &GeneralEmailListPref;  
2129                         break;
2130                 case PROPERTY_HOME:
2131                         EmailList = &HomeEmailList;
2132                         EmailListType = &HomeEmailListType;
2133                         EmailListAltID = &HomeEmailListAltID;
2134                         EmailListPID = &HomeEmailListPID;
2135                         EmailListTokens = &HomeEmailListTokens;         
2136                         EmailListPref = &HomeEmailListPref;     
2137                         break;
2138                 case PROPERTY_WORK:
2139                         EmailList = &BusinessEmailList;
2140                         EmailListType = &BusinessEmailListType;
2141                         EmailListAltID = &BusinessEmailListAltID;
2142                         EmailListPID = &BusinessEmailListPID;
2143                         EmailListTokens = &BusinessEmailListTokens;             
2144                         EmailListPref = &BusinessEmailListPref; 
2145                         break;
2146         }
2147         
2148         intPrevValue = 6;
2149         
2150         std::map<int,int>::iterator SLiter;
2151         wxString PropertyData;
2152         wxString PropertyName;
2153         wxString PropertyValue;
2154         wxString PropertyTokens;
2155         bool FirstToken = TRUE;
2156         
2157         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
2158         intiter != SplitPoints.end(); ++intiter){
2159         
2160                 SLiter = SplitLength.find(intiter->first);
2161         
2162                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
2163                 
2164                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
2165                 PropertyName = PropertyElement.GetNextToken();                          
2166                 PropertyValue = PropertyElement.GetNextToken();
2167                 
2168                 intPrevValue = intiter->second;
2169                 
2170                 CaptureString(&PropertyValue, FALSE);
2171                 
2172                 // Process properties.
2173                 
2174                 if (PropertyName == wxT("ALTID")){
2176                         EmailListAltID->erase(*EmailCount);
2177                         EmailListAltID->insert(std::make_pair(*EmailCount, PropertyValue));
2178                 
2179                 } else if (PropertyName == wxT("PID")){
2181                         EmailListPID->erase(*EmailCount);
2182                         EmailListPID->insert(std::make_pair(*EmailCount, PropertyValue));
2183                 
2184                 } else if (PropertyName == wxT("PREF")){
2185                         
2186                         ProcessIntegerValue(this, EmailListPref, &PropertyValue, EmailCount);
2187                 
2188                 } else {
2189                 
2190                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
2191                         
2192                                 if (FirstToken == TRUE){
2193                                 
2194                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
2195                                         FirstToken = FALSE;
2196                                 
2197                                 } else {
2198                                 
2199                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
2200                                 
2201                                 }
2202                         
2203                         }
2204                 
2205                 }
2206         
2207         }
2208         
2209         EmailList->insert(std::make_pair(*EmailCount, PropertySeg2));
2210         
2211         // Add the name token data.
2212         
2213         if (!PropertyTokens.IsEmpty()){
2214         
2215                 EmailListTokens->insert(std::make_pair(*EmailCount, PropertyTokens));
2216         
2217         }       
2222 void ContactDataObject::ProcessIM(wxString PropertySeg1, wxString PropertySeg2, int *IMCount){
2224         std::map<int, int> SplitPoints;
2225         std::map<int, int> SplitLength;
2227         int intPrevValue = 6;
2228         int intPref = 0;                        
2229         
2230         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
2231         
2232         intPrevValue = 5;
2233         
2234         PropertyType PropType = PROPERTY_NONE;
2235                 
2236         // Look for type before continuing.
2237         
2238         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
2239         
2240         std::map<int, wxString> *IMList = NULL;
2241         std::map<int, wxString> *IMListType = NULL;
2242         std::map<int, wxString> *IMListAltID = NULL;
2243         std::map<int, wxString> *IMListPID = NULL;
2244         std::map<int, wxString> *IMListTokens = NULL;
2245         std::map<int, wxString> *IMListMediatype = NULL;        
2246         std::map<int, int> *IMListPref = NULL;
2248         switch(PropType){
2249                 case PROPERTY_NONE:
2250                         IMList = &GeneralIMList;
2251                         IMListType = &GeneralIMListType;
2252                         IMListAltID = &GeneralIMListAltID;
2253                         IMListPID = &GeneralIMListPID;
2254                         IMListTokens = &GeneralIMListTokens;
2255                         IMListMediatype = &GeneralIMListMediatype;
2256                         IMListPref = &GeneralIMListPref;        
2257                         break;
2258                 case PROPERTY_HOME:
2259                         IMList = &HomeIMList;
2260                         IMListType = &HomeIMListType;
2261                         IMListAltID = &HomeIMListAltID;
2262                         IMListPID = &HomeIMListPID;
2263                         IMListTokens = &HomeIMListTokens;
2264                         IMListMediatype = &HomeIMListMediatype;         
2265                         IMListPref = &HomeIMListPref;   
2266                         break;
2267                 case PROPERTY_WORK:
2268                         IMList = &BusinessIMList;
2269                         IMListType = &BusinessIMListType;
2270                         IMListAltID = &BusinessIMListAltID;
2271                         IMListPID = &BusinessIMListPID;
2272                         IMListTokens = &BusinessIMListTokens;   
2273                         IMListMediatype = &BusinessIMListMediatype;     
2274                         IMListPref = &BusinessIMListPref;       
2275                         break;
2276         }
2277         
2278         intPrevValue = 5;
2279         
2280         std::map<int,int>::iterator SLiter;
2281         wxString PropertyData;
2282         wxString PropertyName;
2283         wxString PropertyValue;
2284         wxString PropertyTokens;
2285         bool FirstToken = TRUE;
2286         
2287         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
2288         intiter != SplitPoints.end(); ++intiter){
2289         
2290                 SLiter = SplitLength.find(intiter->first);
2291         
2292                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
2293                 
2294                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
2295                 PropertyName = PropertyElement.GetNextToken();                          
2296                 PropertyValue = PropertyElement.GetNextToken();
2297                 
2298                 intPrevValue = intiter->second;
2299                 
2300                 CaptureString(&PropertyValue, FALSE);
2301                 
2302                 // Process properties.
2303                 
2304                 if (PropertyName == wxT("ALTID")){
2306                         IMListAltID->erase(*IMCount);
2307                         IMListAltID->insert(std::make_pair(*IMCount, PropertyValue));
2308                 
2309                 } else if (PropertyName == wxT("PID")){
2311                         IMListPID->erase(*IMCount);
2312                         IMListPID->insert(std::make_pair(*IMCount, PropertyValue));
2313                 
2314                 } else if (PropertyName == wxT("MEDIATYPE")){
2316                         IMListMediatype->erase(*IMCount);
2317                         IMListMediatype->insert(std::make_pair(*IMCount, PropertyValue));
2318                 
2319                 } else if (PropertyName == wxT("PREF")){
2320                         
2321                         ProcessIntegerValue(this, IMListPref, &PropertyValue, IMCount);
2322                 
2323                 } else {
2324                 
2325                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
2326                         
2327                                 if (FirstToken == TRUE){
2328                                 
2329                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
2330                                         FirstToken = FALSE;
2331                                 
2332                                 } else {
2333                                 
2334                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
2335                                 
2336                                 }
2337                         
2338                         }
2339                 
2340                 }
2341         
2342         }
2343                 
2344         IMList->insert(std::make_pair(*IMCount, PropertySeg2));
2345         
2346         // Add the name token data.
2347         
2348         if (!PropertyTokens.IsEmpty()){
2349         
2350                 IMListTokens->insert(std::make_pair(*IMCount, PropertyTokens));
2351         
2352         }
2356 void ContactDataObject::ProcessTelephone(wxString PropertySeg1, wxString PropertySeg2, int *TelephoneCount){
2358         std::map<int, int> SplitPoints;
2359         std::map<int, int> SplitLength;
2360         std::map<int, int>::iterator SLiter;
2361         
2362         int intPref = 0;
2363         
2364         PropertyType PropType = PROPERTY_NONE;
2365                 
2366         // Look for type before continuing.
2367         
2368         wxString TelTypeUI;
2369         wxString TelTypeDetail;
2370         wxString PropertyData;
2371         wxString PropertyName;
2372         wxString PropertyValue;
2373         wxString PropertyTokens;
2374         
2375         std::map<int,int> TypeSplitPoints;
2376         std::map<int,int> TypeSplitLength;
2377         std::map<int,int>::iterator TSLiter;
2378         
2379         int intSplitSize = 0;
2380         int intSplitsFound = 0;
2381         int intSplitPoint = 0;
2382         int intType = 0;
2383         int intPrevValue = 5;
2384                 
2385         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
2386         
2387         intPrevValue = 4;
2388         
2389         // Look for type before continuing.
2390         
2391         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
2392         intiter != SplitPoints.end(); ++intiter){
2393         
2394                 SLiter = SplitLength.find(intiter->first);
2395         
2396                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
2397                 
2398                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
2399                 PropertyName = PropertyElement.GetNextToken();                          
2400                 PropertyValue = PropertyElement.GetNextToken();
2401                 
2402                 intPrevValue = intiter->second;
2404                 if (PropertyName == wxT("TYPE")){
2405                 
2406                         // Process each value in type and translate each
2407                         // part.
2408                 
2409                         // Strip out the quotes if they are there.
2410                 
2411                         size_t intPropertyValueLen = PropertyValue.Len();
2412                 
2413                         if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
2414                         
2415                                 PropertyValue.Trim();
2416                                 PropertyValue.RemoveLast();
2417                         
2418                         }                               
2419                 
2420                         if (PropertyValue.Mid(0, 1) == wxT("\"")){
2421                         
2422                                 PropertyValue.Remove(0, 1);
2423                         
2424                         }
2425                         
2426                         TelTypeDetail = PropertyValue;
2427                         
2428                         intSplitSize = 0;
2429                         intSplitsFound = 0;
2430                         intSplitPoint = 0;
2431                         
2432                         for (int i = 0; i <= intPropertyValueLen; i++){
2433         
2434                                 intSplitSize++;
2435         
2436                                 if (PropertyValue.Mid(i, 1) == wxT(",") && PropertyValue.Mid((i - 1), 1) != wxT("\\")){
2437         
2438                                         if (intSplitsFound == 0){
2440                                                 TypeSplitPoints.insert(std::make_pair(intSplitsFound, intSplitPoint));
2441                                                 TypeSplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1)));
2442                         
2443                                         } else {
2444                         
2445                                                 TypeSplitPoints.insert(std::make_pair(intSplitsFound, intSplitPoint));
2446                                                 TypeSplitLength.insert(std::make_pair(intSplitsFound, intSplitSize));
2447                         
2448                                         }                       
2450                                         intSplitsFound++;
2451                                         i++;
2452                                         intSplitPoint = i;
2453                                         intSplitSize = 0;
2454         
2455                                 }
2456         
2457                         }
2458                         
2459                         TypeSplitPoints.insert(std::make_pair(intSplitsFound, intSplitPoint));
2460                         TypeSplitLength.insert(std::make_pair(intSplitsFound, intSplitSize));                                                           
2461                 
2462                         int intTypeSeek = 0;
2463                 
2464                         for (std::map<int, int>::iterator typeiter = TypeSplitPoints.begin(); 
2465                         typeiter != TypeSplitPoints.end(); ++typeiter){
2466                         
2467                                 wxString TypePropertyName;
2468                                 
2469                                 TSLiter = TypeSplitLength.find(typeiter->first);
2470                                 
2471                                 TypePropertyName = PropertyValue.Mid(typeiter->second, TSLiter->second);
2472                                 
2473                                 if (intTypeSeek == 0){
2474                                 
2475                                 
2476                                 } else {
2477                                                                                 
2478                                         TelTypeUI.Append(wxT(","));                                                     
2479                                 
2480                                 }
2481                         
2482                                 if (TypePropertyName == wxT("home")){
2483                                 
2484                                         PropType = PROPERTY_HOME;
2485                                 
2486                                 } else if (TypePropertyName == wxT("work")){
2487                                 
2488                                         PropType = PROPERTY_WORK;
2489                                                                         
2490                                 }
2491                                 
2492                                 
2493                                 if (TypePropertyName == wxT("text")){
2494                                 
2495                                         TelTypeUI.Append(_("text"));
2496                                         intTypeSeek++;
2497                                 
2498                                 } else if (TypePropertyName == wxT("voice")){
2499                                 
2500                                         TelTypeUI.Append(_("voice"));
2501                                         intTypeSeek++;
2502                                 
2503                                 } else if (TypePropertyName == wxT("fax")){
2504                                 
2505                                         TelTypeUI.Append(_("fax"));
2506                                         intTypeSeek++;
2507                                 
2508                                 } else if (TypePropertyName == wxT("cell")){
2509                                 
2510                                         TelTypeUI.Append(_("mobile"));
2511                                         intTypeSeek++;
2512                                 
2513                                 } else if (TypePropertyName == wxT("video")){
2514                                 
2515                                         TelTypeUI.Append(_("video"));
2516                                         intTypeSeek++;
2517                                 
2518                                 } else if (TypePropertyName == wxT("pager")){
2519                                 
2520                                         TelTypeUI.Append(_("pager"));
2521                                         intTypeSeek++;
2522                                 
2523                                 } else if (TypePropertyName == wxT("textphone")){
2524                                 
2525                                         TelTypeUI.Append(_("textphone"));
2526                                         intTypeSeek++;
2527                                 
2528                                 }
2529                         
2530                         }
2531                 
2532                 }
2533                 
2534         }
2535         
2536         std::map<int, wxString> *TelephoneList = NULL;
2537         std::map<int, wxString> *TelephoneListType = NULL;
2538         std::map<int, wxString> *TelephoneListAltID = NULL;
2539         std::map<int, wxString> *TelephoneListPID = NULL;
2540         std::map<int, wxString> *TelephoneListTokens = NULL;
2541         std::map<int, wxString> *TelephoneListTypeInfo = NULL;  
2542         std::map<int, int> *TelephoneListPref = NULL;
2544         switch(PropType){
2545                 case PROPERTY_NONE:
2546                         TelephoneList = &GeneralTelephoneList;
2547                         TelephoneListType = &GeneralTelephoneListType;
2548                         TelephoneListAltID = &GeneralTelephoneListAltID;
2549                         TelephoneListPID = &GeneralTelephoneListPID;
2550                         TelephoneListTokens = &GeneralTelephoneListTokens;
2551                         TelephoneListTypeInfo = &GeneralTelephoneListTypeInfo;
2552                         TelephoneListPref = &GeneralTelephoneListPref;  
2553                         break;
2554                 case PROPERTY_HOME:
2555                         TelephoneList = &HomeTelephoneList;
2556                         TelephoneListType = &HomeTelephoneListType;
2557                         TelephoneListAltID = &HomeTelephoneListAltID;
2558                         TelephoneListPID = &HomeTelephoneListPID;
2559                         TelephoneListTokens = &HomeTelephoneListTokens;
2560                         TelephoneListTypeInfo = &HomeTelephoneListTypeInfo;     
2561                         TelephoneListPref = &HomeTelephoneListPref;     
2562                         break;
2563                 case PROPERTY_WORK:
2564                         TelephoneList = &BusinessTelephoneList;
2565                         TelephoneListType = &BusinessTelephoneListType;
2566                         TelephoneListAltID = &BusinessTelephoneListAltID;
2567                         TelephoneListPID = &BusinessTelephoneListPID;
2568                         TelephoneListTokens = &BusinessTelephoneListTokens;     
2569                         TelephoneListTypeInfo = &BusinessTelephoneListTypeInfo; 
2570                         TelephoneListPref = &BusinessTelephoneListPref; 
2571                         break;
2572         }
2573                 
2574         // Process the properties.
2575         
2576         bool FirstToken = TRUE;
2577         
2578         intPrevValue = 5;
2579         SplitPoints.clear();
2580         SplitLength.clear();
2582         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
2584         intPrevValue = 4;
2585         
2586         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
2587         intiter != SplitPoints.end(); ++intiter){
2588         
2589                 SLiter = SplitLength.find(intiter->first);
2590         
2591                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
2592                 
2593                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
2594                 PropertyName = PropertyElement.GetNextToken();                          
2595                 PropertyValue = PropertyElement.GetNextToken();
2596                 
2597                 intPrevValue = intiter->second;
2598                 
2599                 CaptureString(&PropertyValue, FALSE);
2600                 
2601                 // Process properties.
2602                 
2603                 if (PropertyName == wxT("ALTID")){
2605                         TelephoneListAltID->erase(*TelephoneCount);
2606                         TelephoneListAltID->insert(std::make_pair(*TelephoneCount, PropertyValue));
2607                 
2608                 } else if (PropertyName == wxT("PID")){
2610                         TelephoneListPID->erase(*TelephoneCount);
2611                         TelephoneListPID->insert(std::make_pair(*TelephoneCount, PropertyValue));
2612                 
2613                 } else if (PropertyName == wxT("PREF")){
2615                         ProcessIntegerValue(this, TelephoneListPref, &PropertyValue, TelephoneCount);
2616                 
2617                 } else {
2618                 
2619                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
2620                         
2621                                 if (FirstToken == TRUE){
2622                                 
2623                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
2624                                         FirstToken = FALSE;
2625                                 
2626                                 } else {
2627                                 
2628                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
2629                                 
2630                                 }
2631                         
2632                         }
2633                 
2634                 }
2635         
2636         }
2637                 
2638         TelephoneList->insert(std::make_pair(*TelephoneCount, PropertySeg2));
2639         TelephoneListTypeInfo->insert(std::make_pair(*TelephoneCount, TelTypeUI));
2640         
2641         // Add the name token data.
2642         
2643         if (!PropertyTokens.IsEmpty()){
2644         
2645                 TelephoneListTokens->insert(std::make_pair(*TelephoneCount, PropertyTokens));
2646         
2647         }
2651 void ContactDataObject::ProcessLanguage(wxString PropertySeg1, wxString PropertySeg2, int *LanguageCount){
2653         std::map<int, int> SplitPoints;
2654         std::map<int, int> SplitLength;
2656         int intPrevValue = 6;
2657         int intPref = 0;                        
2658         
2659         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
2660         
2661         intPrevValue = 5;
2662         
2663         PropertyType PropType = PROPERTY_NONE;
2664                 
2665         // Look for type before continuing.
2666         
2667         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
2668         
2669         std::map<int, wxString> *LanguageList = NULL;
2670         std::map<int, wxString> *LanguageListType = NULL;
2671         std::map<int, wxString> *LanguageListAltID = NULL;
2672         std::map<int, wxString> *LanguageListPID = NULL;
2673         std::map<int, wxString> *LanguageListTokens = NULL;
2674         std::map<int, int> *LanguageListPref = NULL;
2676         switch(PropType){
2677                 case PROPERTY_NONE:
2678                         LanguageList = &GeneralLanguageList;
2679                         LanguageListType = &GeneralLanguageListType;
2680                         LanguageListAltID = &GeneralLanguageListAltID;
2681                         LanguageListPID = &GeneralLanguageListPID;
2682                         LanguageListTokens = &GeneralLanguageListTokens;
2683                         LanguageListPref = &GeneralLanguageListPref;    
2684                         break;
2685                 case PROPERTY_HOME:
2686                         LanguageList = &HomeLanguageList;
2687                         LanguageListType = &HomeLanguageListType;
2688                         LanguageListAltID = &HomeLanguageListAltID;
2689                         LanguageListPID = &HomeLanguageListPID;
2690                         LanguageListTokens = &HomeLanguageListTokens;   
2691                         LanguageListPref = &HomeLanguageListPref;       
2692                         break;
2693                 case PROPERTY_WORK:
2694                         LanguageList = &BusinessLanguageList;
2695                         LanguageListType = &BusinessLanguageListType;
2696                         LanguageListAltID = &BusinessLanguageListAltID;
2697                         LanguageListPID = &BusinessLanguageListPID;
2698                         LanguageListTokens = &BusinessLanguageListTokens;       
2699                         LanguageListPref = &BusinessLanguageListPref;
2700                         break;
2701         }
2702         
2703         intPrevValue = 5;
2704         
2705         std::map<int,int>::iterator SLiter;
2706         wxString PropertyData;
2707         wxString PropertyName;
2708         wxString PropertyValue;
2709         wxString PropertyTokens;
2710         bool FirstToken = TRUE;
2711         
2712         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
2713         intiter != SplitPoints.end(); ++intiter){
2714         
2715                 SLiter = SplitLength.find(intiter->first);
2716         
2717                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
2718                 
2719                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
2720                 PropertyName = PropertyElement.GetNextToken();                          
2721                 PropertyValue = PropertyElement.GetNextToken();
2722                 
2723                 intPrevValue = intiter->second;
2724                 
2725                 CaptureString(&PropertyValue, FALSE);
2726                 
2727                 // Process properties.
2728                 
2729                 if (PropertyName == wxT("ALTID")){
2731                         LanguageListAltID->erase(*LanguageCount);
2732                         LanguageListAltID->insert(std::make_pair(*LanguageCount, PropertyValue));
2733                 
2734                 } else if (PropertyName == wxT("PID")){
2736                         LanguageListPID->erase(*LanguageCount);
2737                         LanguageListPID->insert(std::make_pair(*LanguageCount, PropertyValue));
2738                 
2739                 } else if (PropertyName == wxT("PREF")){
2740                         
2741                         ProcessIntegerValue(this, LanguageListPref, &PropertyValue, LanguageCount);
2742                 
2743                 } else {
2744                 
2745                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
2746                         
2747                                 if (FirstToken == TRUE){
2748                                 
2749                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
2750                                         FirstToken = FALSE;
2751                                 
2752                                 } else {
2753                                 
2754                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
2755                                 
2756                                 }
2757                         
2758                         }
2759                 
2760                 }
2761         
2762         }
2763                 
2764         LanguageList->insert(std::make_pair(*LanguageCount, PropertySeg2));
2765         
2766         // Add the name token data.
2767         
2768         if (!PropertyTokens.IsEmpty()){
2769         
2770                 LanguageListTokens->insert(std::make_pair(*LanguageCount, PropertyTokens));
2771         
2772         }
2776 void ContactDataObject::ProcessGeographic(wxString PropertySeg1, wxString PropertySeg2, int *GeographicCount){
2778         std::map<int, int> SplitPoints;
2779         std::map<int, int> SplitLength;
2781         int intPrevValue = 5;
2782         int intPref = 0;                        
2783         
2784         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
2785         
2786         intPrevValue = 4;
2787         
2788         PropertyType PropType = PROPERTY_NONE;
2789                 
2790         // Look for type before continuing.
2791         
2792         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
2793         
2794         std::map<int, wxString> *GeopositionList = NULL;
2795         std::map<int, wxString> *GeopositionListType = NULL;
2796         std::map<int, wxString> *GeopositionListAltID = NULL;
2797         std::map<int, wxString> *GeopositionListPID = NULL;
2798         std::map<int, wxString> *GeopositionListTokens = NULL;
2799         std::map<int, wxString> *GeopositionListMediatype = NULL;
2800         std::map<int, int> *GeopositionListPref = NULL;
2802         switch(PropType){
2803                 case PROPERTY_NONE:
2804                         GeopositionList = &GeneralGeographyList;
2805                         GeopositionListType = &GeneralGeographyListType;
2806                         GeopositionListAltID = &GeneralGeographyListAltID;
2807                         GeopositionListPID = &GeneralGeographyListPID;
2808                         GeopositionListTokens = &GeneralGeographyListTokens;
2809                         GeopositionListMediatype = &GeneralGeographyListMediatype;
2810                         GeopositionListPref = &GeneralGeographyListPref;        
2811                         break;
2812                 case PROPERTY_HOME:
2813                         GeopositionList = &HomeGeographyList;
2814                         GeopositionListType = &HomeGeographyListType;
2815                         GeopositionListAltID = &HomeGeographyListAltID;
2816                         GeopositionListPID = &HomeGeographyListPID;
2817                         GeopositionListTokens = &HomeGeographyListTokens;
2818                         GeopositionListMediatype = &HomeGeographyListMediatype;
2819                         GeopositionListPref = &HomeGeographyListPref;   
2820                         break;
2821                 case PROPERTY_WORK:
2822                         GeopositionList = &BusinessGeographyList;
2823                         GeopositionListType = &BusinessGeographyListType;
2824                         GeopositionListAltID = &BusinessGeographyListAltID;
2825                         GeopositionListPID = &BusinessGeographyListPID;
2826                         GeopositionListTokens = &BusinessGeographyListTokens;
2827                         GeopositionListMediatype = &BusinessGeographyListMediatype;     
2828                         GeopositionListPref = &BusinessGeographyListPref;
2829                         break;
2830         }
2831         
2832         intPrevValue = 4;
2833         
2834         std::map<int,int>::iterator SLiter;
2835         wxString PropertyData;
2836         wxString PropertyName;
2837         wxString PropertyValue;
2838         wxString PropertyTokens;
2839         bool FirstToken = TRUE;
2840         
2841         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
2842         intiter != SplitPoints.end(); ++intiter){
2843         
2844                 SLiter = SplitLength.find(intiter->first);
2845         
2846                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
2847                 
2848                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
2849                 PropertyName = PropertyElement.GetNextToken();                          
2850                 PropertyValue = PropertyElement.GetNextToken();
2851                 
2852                 intPrevValue = intiter->second;
2853                 
2854                 CaptureString(&PropertyValue, FALSE);
2855                 
2856                 // Process properties.
2857                 
2858                 if (PropertyName == wxT("ALTID")){
2860                         GeopositionListAltID->erase(*GeographicCount);
2861                         GeopositionListAltID->insert(std::make_pair(*GeographicCount, PropertyValue));
2862                 
2863                 } else if (PropertyName == wxT("PID")){
2865                         GeopositionListPID->erase(*GeographicCount);
2866                         GeopositionListPID->insert(std::make_pair(*GeographicCount, PropertyValue));
2867                 
2868                 } else if (PropertyName == wxT("MEDIATYPE")){
2870                         GeopositionListMediatype->erase(*GeographicCount);
2871                         GeopositionListMediatype->insert(std::make_pair(*GeographicCount, PropertyValue));
2872                 
2873                 } else if (PropertyName == wxT("PREF")){
2874                         
2875                         int PriorityNumber = 0;
2876                         bool ValidNumber = TRUE;
2877                         
2878                         try{
2879                                 PriorityNumber = std::stoi(PropertyValue.ToStdString());
2880                         }
2881                         
2882                         catch(std::invalid_argument &e){
2883                                 ValidNumber = FALSE;
2884                         }
2886                         if (ValidNumber == TRUE){
2888                                 GeopositionListPref->erase(*GeographicCount);
2889                                 GeopositionListPref->insert(std::make_pair(*GeographicCount, PriorityNumber));
2891                         }
2892                 
2893                 } else {
2894                 
2895                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
2896                         
2897                                 if (FirstToken == TRUE){
2898                                 
2899                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
2900                                         FirstToken = FALSE;
2901                                 
2902                                 } else {
2903                                 
2904                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
2905                                 
2906                                 }
2907                         
2908                         }
2909                 
2910                 }
2911         
2912         }
2913                 
2914         GeopositionList->insert(std::make_pair(*GeographicCount, PropertySeg2));
2915         
2916         // Add the name token data.
2917         
2918         if (!PropertyTokens.IsEmpty()){
2919         
2920                 GeopositionListTokens->insert(std::make_pair(*GeographicCount, PropertyTokens));
2921         
2922         }
2926 void ContactDataObject::ProcessRelated(wxString PropertySeg1, wxString PropertySeg2, int *RelatedCount){
2928         size_t intPropertyLen = PropertySeg1.Len();
2929         std::map<int, int> SplitPoints;
2930         std::map<int, int> SplitLength;
2931         std::map<int, int>::iterator SLiter;                    
2932         wxString PropertyData;
2933         wxString PropertyName;
2934         wxString PropertyValue;
2935         wxString PropertyTokens;
2936         wxString RelatedType;
2937         wxString RelatedTypeOriginal;                   
2938         wxString RelatedName;
2939         bool FirstToken = TRUE;                 
2940         int intSplitsFound = 0;
2941         int intSplitSize = 0;
2942         int intPrevValue = 9;
2943         int intPref = 0;
2944         long ListCtrlIndex;
2945         
2946         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
2947         
2948         intPrevValue = 8;
2949         
2950         // Look for type before continuing.
2951         
2952         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
2953         intiter != SplitPoints.end(); ++intiter){
2954         
2955                 SLiter = SplitLength.find(intiter->first);
2956         
2957                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
2958                 
2959                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
2960                 PropertyName = PropertyElement.GetNextToken();                          
2961                 PropertyValue = PropertyElement.GetNextToken();
2962                 
2963                 intPrevValue = intiter->second;
2964                 
2965                 // Process these.
2966                 
2967                 RelatedTypeOriginal = PropertyValue;
2968                 
2969                 if (PropertyName == wxT("TYPE")){
2970                 
2971                         if (PropertyValue == wxT("contact")){
2973                                 RelatedType = _("Contact");
2975                         } else if (PropertyValue == wxT("acquaintance")){
2977                                 RelatedType = _("Acquaintance");
2979                         } else if (PropertyValue == wxT("friend")){
2981                                 RelatedType = _("Friend");
2983                         } else if (PropertyValue == wxT("met")){
2985                                 RelatedType = _("Met");
2987                         } else if (PropertyValue == wxT("co-worker")){
2989                                 RelatedType = _("Co-worker");
2991                         } else if (PropertyValue == wxT("colleague")){
2993                                 RelatedType = _("Colleague");
2995                         } else if (PropertyValue == wxT("co-resident")){
2997                                 RelatedType = _("Co-resident");
2999                         } else if (PropertyValue == wxT("neighbor")){
3001                                 RelatedType = _("Neighbour");
3003                         } else if (PropertyValue == wxT("child")){
3005                                 RelatedType = _("Child");
3007                         } else if (PropertyValue == wxT("parent")){
3009                                 RelatedType = _("Parent");
3011                         } else if (PropertyValue == wxT("sibling")){
3013                                 RelatedType = _("Sibling");
3015                         } else if (PropertyValue == wxT("spouse")){
3017                                 RelatedType = _("Spouse");
3019                         } else if (PropertyValue == wxT("kin")){
3021                                 RelatedType = _("Kin");
3023                         } else if (PropertyValue == wxT("muse")){
3025                                 RelatedType = _("Muse");
3027                         } else if (PropertyValue == wxT("crush")){
3029                                 RelatedType = _("Crush");
3031                         } else if (PropertyValue == wxT("date")){
3033                                 RelatedType = _("Date");
3035                         } else if (PropertyValue == wxT("sweetheart")){
3037                                 RelatedType = _("Sweetheart");
3039                         } else if (PropertyValue == wxT("me")){
3041                                 RelatedType = _("Me");
3043                         } else if (PropertyValue == wxT("agent")){
3045                                 RelatedType = _("Agent");
3047                         } else if (PropertyValue == wxT("emergency")){
3049                                 RelatedType = _("Emergency");
3051                         } else {
3053                                 RelatedType = PropertyValue;
3055                         }
3056                 
3057                 }
3058         
3059         }
3060         
3061         intPrevValue = 8;                       
3062         
3063         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
3064         intiter != SplitPoints.end(); ++intiter){
3065         
3066                 SLiter = SplitLength.find(intiter->first);
3067         
3068                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
3069                 
3070                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
3071                 PropertyName = PropertyElement.GetNextToken();                          
3072                 PropertyValue = PropertyElement.GetNextToken();
3073                 
3074                 intPrevValue = intiter->second;
3075                 
3076                 // Process properties.
3077                 
3078                 size_t intPropertyValueLen = PropertyValue.Len();
3079                 
3080                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
3081                         
3082                         PropertyValue.Trim();
3083                         PropertyValue.RemoveLast();
3084                         
3085                 }                               
3086                 
3087                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
3088                         
3089                         PropertyValue.Remove(0, 1);
3090                         
3091                 }
3092                 
3093                 CaptureString(&PropertyValue, FALSE);
3094                         
3095                 if (PropertyName == wxT("ALTID")){
3097                         GeneralRelatedListAltID.erase(*RelatedCount);
3098                         GeneralRelatedListAltID.insert(std::make_pair(*RelatedCount, PropertyValue));
3099                 
3100                 } else if (PropertyName == wxT("PID")){
3102                         GeneralRelatedListPID.erase(*RelatedCount);
3103                         GeneralRelatedListPID.insert(std::make_pair(*RelatedCount, PropertyValue));
3104                 
3105                 } else if (PropertyName == wxT("PREF")){
3106                         
3107                         int PriorityNumber = 0;
3108                         bool ValidNumber = TRUE;
3109                         
3110                         try{
3111                                 PriorityNumber = std::stoi(PropertyValue.ToStdString());
3112                         }
3113                         
3114                         catch(std::invalid_argument &e){
3115                                 ValidNumber = FALSE;
3116                         }
3118                         if (ValidNumber == TRUE){
3120                                 GeneralRelatedListPref.erase(*RelatedCount);
3121                                 GeneralRelatedListPref.insert(std::make_pair(*RelatedCount, PriorityNumber));
3123                         }
3124                 
3125                 } else if (PropertyName == wxT("LANGUAGE")){
3126                 
3127                         GeneralRelatedListLanguage.erase(*RelatedCount);
3128                         GeneralRelatedListLanguage.insert(std::make_pair(*RelatedCount, PropertyValue));
3129                 
3130                 } else if (PropertyName != wxT("TYPE")) {
3131                 
3132                         // Something else we don't know about so append
3133                         // to the tokens variable.
3134                 
3135                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
3136                 
3137                                 if (FirstToken == TRUE){
3138                         
3139                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
3140                                         FirstToken = FALSE;
3141                         
3142                                 } else {
3143                         
3144                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
3145                         
3146                                 }
3147                 
3148                         }
3149                 
3150                 }
3151         
3152         }                                       
3153         
3154         // Add the data to the General/Home/Work address variables.
3155                                 
3156         GeneralRelatedList.erase(*RelatedCount);
3157         GeneralRelatedListRelType.erase(*RelatedCount);
3158         GeneralRelatedListType.erase(*RelatedCount);
3159         GeneralRelatedListTokens.erase(*RelatedCount);
3160         GeneralRelatedList.insert(std::make_pair(*RelatedCount, PropertySeg2));
3161         GeneralRelatedListRelType.insert(std::make_pair(*RelatedCount, RelatedType));                   
3162         GeneralRelatedListType.insert(std::make_pair(*RelatedCount, RelatedType));
3163         GeneralRelatedListTokens.insert(std::make_pair(*RelatedCount, PropertyTokens));
3167 void ContactDataObject::ProcessURL(wxString PropertySeg1, wxString PropertySeg2, int *URLCount){
3169         std::map<int, int> SplitPoints;
3170         std::map<int, int> SplitLength;
3171         std::map<int, int>::iterator SLiter;                    
3172         wxString PropertyData;
3173         wxString PropertyName;
3174         wxString PropertyValue;
3175         wxString PropertyTokens;
3176         bool FirstToken = TRUE;
3177         int intPrevValue = 5;
3178         int intPref = 0;                        
3179         int intType = 0;
3180         long ListCtrlIndex;
3181         
3182         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
3183         
3184         intPrevValue = 4;
3185         
3186         PropertyType PropType = PROPERTY_NONE;
3187                 
3188         // Look for type before continuing.
3189         
3190         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
3191         
3192         // Setup the pointers.
3193         
3194         std::map<int, wxString> *WebsiteList = NULL;
3195         std::map<int, wxString> *WebsiteListAltID = NULL;
3196         std::map<int, wxString> *WebsiteListPID = NULL;
3197         std::map<int, wxString> *WebsiteListType = NULL;
3198         std::map<int, wxString> *WebsiteListTokens = NULL;
3199         std::map<int, wxString> *WebsiteListMediatype = NULL;
3200         std::map<int, int> *WebsiteListPref = NULL;
3201         
3202         // Setup blank lines for later on.
3203         
3204         switch(PropType){
3205                 case PROPERTY_NONE:
3206                         WebsiteList = &GeneralWebsiteList;
3207                         WebsiteListType = &GeneralWebsiteListType;
3208                         WebsiteListAltID = &GeneralWebsiteListAltID;
3209                         WebsiteListPID = &GeneralWebsiteListPID;
3210                         WebsiteListTokens = &GeneralWebsiteListTokens;
3211                         WebsiteListMediatype = &GeneralWebsiteListMediatype;
3212                         WebsiteListPref = &GeneralWebsiteListPref;      
3213                         break;
3214                 case PROPERTY_HOME:
3215                         WebsiteList = &HomeWebsiteList;
3216                         WebsiteListType = &HomeWebsiteListType;
3217                         WebsiteListAltID = &HomeWebsiteListAltID;
3218                         WebsiteListPID = &HomeWebsiteListPID;
3219                         WebsiteListTokens = &HomeWebsiteListTokens;
3220                         WebsiteListMediatype = &HomeWebsiteListMediatype;
3221                         WebsiteListPref = &HomeWebsiteListPref; 
3222                         break;
3223                 case PROPERTY_WORK:
3224                         WebsiteList = &BusinessWebsiteList;
3225                         WebsiteListType = &BusinessWebsiteListType;
3226                         WebsiteListAltID = &BusinessWebsiteListAltID;
3227                         WebsiteListPID = &BusinessWebsiteListPID;
3228                         WebsiteListTokens = &BusinessWebsiteListTokens;
3229                         WebsiteListMediatype = &BusinessWebsiteListMediatype;   
3230                         WebsiteListPref = &BusinessWebsiteListPref;
3231                         break;
3232         }
3233         
3234         intPrevValue = 4;
3235         
3236         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
3237         intiter != SplitPoints.end(); ++intiter){
3238         
3239                 SLiter = SplitLength.find(intiter->first);
3240         
3241                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
3242                 
3243                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
3244                 PropertyName = PropertyElement.GetNextToken();                          
3245                 PropertyValue = PropertyElement.GetNextToken();
3246                 
3247                 intPrevValue = intiter->second;
3248                 
3249                 // Process properties.
3250                 
3251                 size_t intPropertyValueLen = PropertyValue.Len();
3252                 
3253                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
3254                         
3255                         PropertyValue.Trim();
3256                         PropertyValue.RemoveLast();
3257                         
3258                 }                               
3259                 
3260                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
3261                         
3262                         PropertyValue.Remove(0, 1);
3263                         
3264                 }
3265                 
3266                 CaptureString(&PropertyValue, FALSE);
3267                 
3268                 if (PropertyName == wxT("ALTID")){
3270                         WebsiteListAltID->erase(*URLCount);
3271                         WebsiteListAltID->insert(std::make_pair(*URLCount, PropertyValue));
3272                 
3273                 } else if (PropertyName == wxT("PID")){
3275                         WebsiteListPID->erase(*URLCount);
3276                         WebsiteListPID->insert(std::make_pair(*URLCount, PropertyValue));
3277                         
3278                 } else if (PropertyName == wxT("PREF")){
3279                         
3280                         int PriorityNumber = 0;
3281                         bool ValidNumber = TRUE;
3282                         
3283                         try{
3284                                 PriorityNumber = std::stoi(PropertyValue.ToStdString());
3285                         }
3286                         
3287                         catch(std::invalid_argument &e){
3288                                 ValidNumber = FALSE;
3289                         }
3291                         if (ValidNumber == TRUE){
3293                                 WebsiteListPref->erase(*URLCount);
3294                                 WebsiteListPref->insert(std::make_pair(*URLCount, PriorityNumber));
3296                         }
3297                                         
3298                 } else if (PropertyName == wxT("MEDIATYPE")){
3299                 
3300                         WebsiteListMediatype->erase(*URLCount);
3301                         WebsiteListMediatype->insert(std::make_pair(*URLCount, PropertyValue));
3302                 
3303                 } else {
3304                 
3305                         // Something else we don't know about so append
3306                         // to the tokens variable.
3307                 
3308                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
3309                 
3310                                 if (FirstToken == TRUE){
3311                         
3312                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
3313                                         FirstToken = FALSE;
3314                         
3315                                 } else {
3316                         
3317                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
3318                         
3319                                 }
3320                 
3321                         }
3322                 
3323                 }
3324         
3325         }
3326         
3327         // Add the data to the General/Home/Work address variables.
3328         
3329         CaptureString(&PropertySeg2, FALSE);
3330                         
3331         WebsiteList->insert(std::make_pair(*URLCount, PropertySeg2));
3332         
3333         if (!PropertyTokens.IsEmpty()){
3334         
3335                 WebsiteListTokens->insert(std::make_pair(*URLCount, PropertyTokens));
3336                         
3337         }
3338         
3341 void ContactDataObject::ProcessTitle(wxString PropertySeg1, wxString PropertySeg2, int *TitleCount){
3343         std::map<int, int> SplitPoints;
3344         std::map<int, int> SplitLength;
3345         std::map<int, int>::iterator SLiter;                    
3346         wxString PropertyData;
3347         wxString PropertyName;
3348         wxString PropertyValue;
3349         wxString PropertyTokens;
3350         bool FirstToken = TRUE;
3351         int intPrevValue = 7;
3352         int intPref = 0;                        
3353         int intType = 0;
3354         long ListCtrlIndex;
3355         
3356         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
3357         
3358         intPrevValue = 6;
3359         
3360         PropertyType PropType = PROPERTY_NONE;
3361                 
3362         // Look for type before continuing.
3363         
3364         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
3365         
3366         // Setup the pointers.
3367         
3368         std::map<int, wxString> *TitleList = NULL;
3369         std::map<int, wxString> *TitleListAltID = NULL;
3370         std::map<int, wxString> *TitleListPID = NULL;
3371         std::map<int, wxString> *TitleListType = NULL;
3372         std::map<int, wxString> *TitleListTokens = NULL;
3373         std::map<int, wxString> *TitleListLanguage = NULL;
3374         std::map<int, int> *TitleListPref = NULL;
3375         
3376         // Setup blank lines for later on.
3377         
3378         switch(PropType){
3379                 case PROPERTY_NONE:
3380                         TitleList = &GeneralTitleList;
3381                         TitleListType = &GeneralTitleListType;
3382                         TitleListAltID = &GeneralTitleListAltID;
3383                         TitleListPID = &GeneralTitleListPID;
3384                         TitleListTokens = &GeneralTitleListTokens;
3385                         TitleListLanguage = &GeneralTitleListLanguage;
3386                         TitleListPref = &GeneralTitleListPref;  
3387                         break;
3388                 case PROPERTY_HOME:
3389                         TitleList = &HomeTitleList;
3390                         TitleListType = &HomeTitleListType;
3391                         TitleListAltID = &HomeTitleListAltID;
3392                         TitleListPID = &HomeTitleListPID;
3393                         TitleListTokens = &HomeTitleListTokens;
3394                         TitleListLanguage = &HomeTitleListLanguage;
3395                         TitleListPref = &HomeTitleListPref;     
3396                         break;
3397                 case PROPERTY_WORK:
3398                         TitleList = &BusinessTitleList;
3399                         TitleListType = &BusinessTitleListType;
3400                         TitleListAltID = &BusinessTitleListAltID;
3401                         TitleListPID = &BusinessTitleListPID;
3402                         TitleListTokens = &BusinessTitleListTokens;
3403                         TitleListLanguage = &BusinessTitleListLanguage; 
3404                         TitleListPref = &BusinessTitleListPref;
3405                         break;
3406         }
3408         intPrevValue = 6;
3409                 
3410         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
3411         intiter != SplitPoints.end(); ++intiter){
3412         
3413                 SLiter = SplitLength.find(intiter->first);
3414         
3415                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
3416                 
3417                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
3418                 PropertyName = PropertyElement.GetNextToken();                          
3419                 PropertyValue = PropertyElement.GetNextToken();
3420                 
3421                 intPrevValue = intiter->second;
3422                 
3423                 // Process properties.
3424                 
3425                 size_t intPropertyValueLen = PropertyValue.Len();
3426                 
3427                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
3428                         
3429                         PropertyValue.Trim();
3430                         PropertyValue.RemoveLast();
3431                         
3432                 }                               
3433                 
3434                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
3435                         
3436                         PropertyValue.Remove(0, 1);
3437                         
3438                 }                               
3439                 
3440                 CaptureString(&PropertyValue, FALSE);
3441                 
3442                 if (PropertyName == wxT("ALTID")){
3443                 
3444                         TitleListAltID->erase(*TitleCount);
3445                         TitleListAltID->insert(std::make_pair(*TitleCount, PropertyValue));
3446                 
3447                 } else if (PropertyName == wxT("PID")){
3449                         TitleListPID->erase(*TitleCount);
3450                         TitleListPID->insert(std::make_pair(*TitleCount, PropertyValue));
3451                 
3452                 } else if (PropertyName == wxT("PREF")){
3453                                 
3454                         int PriorityNumber = 0;
3455                         bool ValidNumber = TRUE;
3456                         
3457                         try{
3458                                 PriorityNumber = std::stoi(PropertyValue.ToStdString());
3459                         }
3460                         
3461                         catch(std::invalid_argument &e){
3462                                 ValidNumber = FALSE;
3463                         }
3465                         if (ValidNumber == TRUE){
3467                                 TitleListPref->erase(*TitleCount);
3468                                 TitleListPref->insert(std::make_pair(*TitleCount, PriorityNumber));
3470                         }
3471                                         
3472                 } else if (PropertyName == wxT("LANGUAGE")){
3473                 
3474                         TitleListLanguage->erase(*TitleCount);
3475                         TitleListLanguage->insert(std::make_pair(*TitleCount, PropertyValue));
3476                 
3477                 } else {
3478                 
3479                         // Something else we don't know about so append
3480                         // to the tokens variable.
3481                 
3482                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
3483                 
3484                                 if (FirstToken == TRUE){
3485                         
3486                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
3487                                         FirstToken = FALSE;
3488                         
3489                                 } else {
3490                         
3491                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
3492                         
3493                                 }
3494                 
3495                         }
3496                 
3497                 }
3498         
3499         }
3500         
3501         // Add the data to the General/Home/Work address variables.
3502         
3503         CaptureString(&PropertySeg2, FALSE);
3505         TitleList->insert(std::make_pair(*TitleCount, PropertySeg2));
3506         
3507         if (!PropertyTokens.IsEmpty()){
3508         
3509                 TitleListTokens->insert(std::make_pair(*TitleCount, PropertyTokens));
3510                         
3511         }
3515 void ContactDataObject::ProcessRole(wxString PropertySeg1, wxString PropertySeg2, int *RoleCount){
3517         std::map<int, int> SplitPoints;
3518         std::map<int, int> SplitLength;
3519         std::map<int, int>::iterator SLiter;                    
3520         wxString PropertyData;
3521         wxString PropertyName;
3522         wxString PropertyValue;
3523         wxString PropertyTokens;
3524         bool FirstToken = TRUE;
3525         int intPrevValue = 6;
3526         int intPref = 0;                        
3527         int intType = 0;
3528         long ListCtrlIndex;
3529         
3530         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
3531         
3532         intPrevValue = 5;
3533         
3534         PropertyType PropType = PROPERTY_NONE;
3535                 
3536         // Look for type before continuing.
3537         
3538         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
3539         
3540         // Setup the pointers.
3541         
3542         std::map<int, wxString> *RoleList = NULL;
3543         std::map<int, wxString> *RoleListAltID = NULL;
3544         std::map<int, wxString> *RoleListPID = NULL;
3545         std::map<int, wxString> *RoleListType = NULL;
3546         std::map<int, wxString> *RoleListTokens = NULL;
3547         std::map<int, wxString> *RoleListLanguage = NULL;
3548         std::map<int, int> *RoleListPref = NULL;
3549         
3550         // Setup blank lines for later on.
3551         
3552         switch(PropType){
3553                 case PROPERTY_NONE:
3554                         RoleList = &GeneralRoleList;
3555                         RoleListType = &GeneralRoleListType;
3556                         RoleListAltID = &GeneralRoleListAltID;
3557                         RoleListPID = &GeneralRoleListPID;
3558                         RoleListTokens = &GeneralRoleListTokens;
3559                         RoleListLanguage = &GeneralRoleListLanguage;
3560                         RoleListPref = &GeneralRoleListPref;    
3561                         break;
3562                 case PROPERTY_HOME:
3563                         RoleList = &HomeRoleList;
3564                         RoleListType = &HomeRoleListType;
3565                         RoleListAltID = &HomeRoleListAltID;
3566                         RoleListPID = &HomeRoleListPID;
3567                         RoleListTokens = &HomeRoleListTokens;
3568                         RoleListLanguage = &HomeRoleListLanguage;
3569                         RoleListPref = &HomeRoleListPref;       
3570                         break;
3571                 case PROPERTY_WORK:
3572                         RoleList = &BusinessRoleList;
3573                         RoleListType = &BusinessRoleListType;
3574                         RoleListAltID = &BusinessRoleListAltID;
3575                         RoleListPID = &BusinessRoleListPID;
3576                         RoleListTokens = &BusinessRoleListTokens;
3577                         RoleListLanguage = &BusinessRoleListLanguage;   
3578                         RoleListPref = &BusinessRoleListPref;
3579                         break;
3580         }
3582         intPrevValue = 5;
3583                 
3584         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
3585         intiter != SplitPoints.end(); ++intiter){
3586         
3587                 SLiter = SplitLength.find(intiter->first);
3588         
3589                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
3590                 
3591                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
3592                 PropertyName = PropertyElement.GetNextToken();                          
3593                 PropertyValue = PropertyElement.GetNextToken();
3594                 
3595                 intPrevValue = intiter->second;
3596                 
3597                 // Process properties.
3598                 
3599                 size_t intPropertyValueLen = PropertyValue.Len();
3600                 
3601                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
3602                         
3603                         PropertyValue.Trim();
3604                         PropertyValue.RemoveLast();
3605                         
3606                 }                               
3607                 
3608                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
3609                         
3610                         PropertyValue.Remove(0, 1);
3611                         
3612                 }                               
3613                 
3614                 CaptureString(&PropertyValue, FALSE);
3615                 
3616                 if (PropertyName == wxT("ALTID")){
3617                 
3618                         RoleListAltID->erase(*RoleCount);
3619                         RoleListAltID->insert(std::make_pair(*RoleCount, PropertyValue));
3620                 
3621                 } else if (PropertyName == wxT("PID")){
3623                         RoleListPID->erase(*RoleCount);
3624                         RoleListPID->insert(std::make_pair(*RoleCount, PropertyValue));
3625                 
3626                 } else if (PropertyName == wxT("PREF")){
3627                                 
3628                         int PriorityNumber = 0;
3629                         bool ValidNumber = TRUE;
3630                         
3631                         try{
3632                                 PriorityNumber = std::stoi(PropertyValue.ToStdString());
3633                         }
3634                         
3635                         catch(std::invalid_argument &e){
3636                                 ValidNumber = FALSE;
3637                         }
3639                         if (ValidNumber == TRUE){
3641                                 RoleListPref->erase(*RoleCount);
3642                                 RoleListPref->insert(std::make_pair(*RoleCount, PriorityNumber));
3644                         }
3645                                         
3646                 } else if (PropertyName == wxT("LANGUAGE")){
3647                 
3648                         RoleListLanguage->erase(*RoleCount);
3649                         RoleListLanguage->insert(std::make_pair(*RoleCount, PropertyValue));
3650                 
3651                 } else {
3652                 
3653                         // Something else we don't know about so append
3654                         // to the tokens variable.
3655                 
3656                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
3657                 
3658                                 if (FirstToken == TRUE){
3659                         
3660                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
3661                                         FirstToken = FALSE;
3662                         
3663                                 } else {
3664                         
3665                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
3666                         
3667                                 }
3668                 
3669                         }
3670                 
3671                 }
3672         
3673         }
3674         
3675         // Add the data to the General/Home/Work address variables.
3676         
3677         CaptureString(&PropertySeg2, FALSE);
3679         RoleList->insert(std::make_pair(*RoleCount, PropertySeg2));
3680         
3681         if (!PropertyTokens.IsEmpty()){
3682         
3683                 RoleListTokens->insert(std::make_pair(*RoleCount, PropertyTokens));
3684                         
3685         }
3689 void ContactDataObject::ProcessOrganisation(wxString PropertySeg1, wxString PropertySeg2, int *OrganisationCount){
3691         std::map<int, int> SplitPoints;
3692         std::map<int, int> SplitLength;
3693         std::map<int, int>::iterator SLiter;                    
3694         wxString PropertyData;
3695         wxString PropertyName;
3696         wxString PropertyValue;
3697         wxString PropertyTokens;
3698         bool FirstToken = TRUE;
3699         int intPrevValue = 5;
3700         int intPref = 0;                        
3701         int intType = 0;
3702         long ListCtrlIndex;
3703         
3704         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
3705         
3706         intPrevValue = 4;
3707         
3708         PropertyType PropType = PROPERTY_NONE;
3709                 
3710         // Look for type before continuing.
3711         
3712         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
3713         
3714         // Setup the pointers.
3715         
3716         std::map<int, wxString> *OrganisationsList = NULL;
3717         std::map<int, wxString> *OrganisationsListAltID = NULL;
3718         std::map<int, wxString> *OrganisationsListPID = NULL;
3719         std::map<int, wxString> *OrganisationsListType = NULL;
3720         std::map<int, wxString> *OrganisationsListTokens = NULL;
3721         std::map<int, wxString> *OrganisationsListLanguage = NULL;
3722         std::map<int, wxString> *OrganisationsListSortAs = NULL;
3723         std::map<int, int> *OrganisationsListPref = NULL;
3724         
3725         // Setup blank lines for later on.
3726         
3727         switch(PropType){
3728                 case PROPERTY_NONE:
3729                         OrganisationsList = &GeneralOrganisationsList;
3730                         OrganisationsListType = &GeneralOrganisationsListType;
3731                         OrganisationsListAltID = &GeneralOrganisationsListAltID;
3732                         OrganisationsListPID = &GeneralOrganisationsListPID;
3733                         OrganisationsListTokens = &GeneralOrganisationsListTokens;
3734                         OrganisationsListLanguage = &GeneralOrganisationsListLanguage;
3735                         OrganisationsListSortAs = &GeneralOrganisationsListSortAs;
3736                         OrganisationsListPref = &GeneralOrganisationsListPref;  
3737                         break;
3738                 case PROPERTY_HOME:
3739                         OrganisationsList = &HomeOrganisationsList;
3740                         OrganisationsListType = &HomeOrganisationsListType;
3741                         OrganisationsListAltID = &HomeOrganisationsListAltID;
3742                         OrganisationsListPID = &HomeOrganisationsListPID;
3743                         OrganisationsListTokens = &HomeOrganisationsListTokens;
3744                         OrganisationsListLanguage = &HomeOrganisationsListLanguage;
3745                         OrganisationsListSortAs = &HomeOrganisationsListSortAs;
3746                         OrganisationsListPref = &HomeOrganisationsListPref;     
3747                         break;
3748                 case PROPERTY_WORK:
3749                         OrganisationsList = &BusinessOrganisationsList;
3750                         OrganisationsListType = &BusinessOrganisationsListType;
3751                         OrganisationsListAltID = &BusinessOrganisationsListAltID;
3752                         OrganisationsListPID = &BusinessOrganisationsListPID;
3753                         OrganisationsListTokens = &BusinessOrganisationsListTokens;
3754                         OrganisationsListLanguage = &BusinessOrganisationsListLanguage;
3755                         OrganisationsListSortAs = &BusinessOrganisationsListSortAs;     
3756                         OrganisationsListPref = &BusinessOrganisationsListPref;
3757                         break;
3758         }
3760         intPrevValue = 4;
3761                 
3762         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
3763         intiter != SplitPoints.end(); ++intiter){
3764         
3765                 SLiter = SplitLength.find(intiter->first);
3766         
3767                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
3768                 
3769                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
3770                 PropertyName = PropertyElement.GetNextToken();                          
3771                 PropertyValue = PropertyElement.GetNextToken();
3772                 
3773                 intPrevValue = intiter->second;
3774                 
3775                 // Process properties.
3776                 
3777                 size_t intPropertyValueLen = PropertyValue.Len();
3778                 
3779                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
3780                         
3781                         PropertyValue.Trim();
3782                         PropertyValue.RemoveLast();
3783                         
3784                 }                               
3785                 
3786                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
3787                         
3788                         PropertyValue.Remove(0, 1);
3789                         
3790                 }                               
3791                 
3792                 CaptureString(&PropertyValue, FALSE);
3793                 
3794                 if (PropertyName == wxT("ALTID")){
3795                 
3796                         OrganisationsListAltID->erase(*OrganisationCount);
3797                         OrganisationsListAltID->insert(std::make_pair(*OrganisationCount, PropertyValue));
3798                 
3799                 } else if (PropertyName == wxT("PID")){
3801                         OrganisationsListPID->erase(*OrganisationCount);
3802                         OrganisationsListPID->insert(std::make_pair(*OrganisationCount, PropertyValue));
3803                 
3804                 } else if (PropertyName == wxT("SORT-AS")){
3806                         OrganisationsListSortAs->erase(*OrganisationCount);
3807                         OrganisationsListSortAs->insert(std::make_pair(*OrganisationCount, PropertyValue));
3808                 
3809                 } else if (PropertyName == wxT("PREF")){
3810                                 
3811                         int PriorityNumber = 0;
3812                         bool ValidNumber = TRUE;
3813                         
3814                         try{
3815                                 PriorityNumber = std::stoi(PropertyValue.ToStdString());
3816                         }
3817                         
3818                         catch(std::invalid_argument &e){
3819                                 ValidNumber = FALSE;
3820                         }
3822                         if (ValidNumber == TRUE){
3824                                 OrganisationsListPref->erase(*OrganisationCount);
3825                                 OrganisationsListPref->insert(std::make_pair(*OrganisationCount, PriorityNumber));
3827                         }
3828                                         
3829                 } else if (PropertyName == wxT("LANGUAGE")){
3830                 
3831                         OrganisationsListLanguage->erase(*OrganisationCount);
3832                         OrganisationsListLanguage->insert(std::make_pair(*OrganisationCount, PropertyValue));
3833                 
3834                 } else {
3835                 
3836                         // Something else we don't know about so append
3837                         // to the tokens variable.
3838                 
3839                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
3840                 
3841                                 if (FirstToken == TRUE){
3842                         
3843                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
3844                                         FirstToken = FALSE;
3845                         
3846                                 } else {
3847                         
3848                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
3849                         
3850                                 }
3851                 
3852                         }
3853                 
3854                 }
3855         
3856         }
3857         
3858         // Add the data to the General/Home/Work address variables.
3859         
3860         CaptureString(&PropertySeg2, FALSE);
3862         OrganisationsList->insert(std::make_pair(*OrganisationCount, PropertySeg2));
3863         
3864         if (!PropertyTokens.IsEmpty()){
3865         
3866                 OrganisationsListTokens->insert(std::make_pair(*OrganisationCount, PropertyTokens));
3867                         
3868         }
3872 void ContactDataObject::ProcessNote(wxString PropertySeg1, wxString PropertySeg2, int *NoteCount){
3874         std::map<int, int> SplitPoints;
3875         std::map<int, int> SplitLength;
3876         std::map<int, int>::iterator SLiter;                    
3877         wxString PropertyData;
3878         wxString PropertyName;
3879         wxString PropertyValue;
3880         wxString PropertyTokens;
3881         bool FirstToken = TRUE;
3882         int intPrevValue = 6;
3883         int intPref = 0;                        
3884         int intType = 0;
3885         long ListCtrlIndex;
3886         
3887         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
3888         
3889         intPrevValue = 5;
3890         
3891         PropertyType PropType = PROPERTY_NONE;
3892                 
3893         // Look for type before continuing.
3894         
3895         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
3896         
3897         // Setup the pointers.
3898         
3899         std::map<int, wxString> *NoteList = NULL;
3900         std::map<int, wxString> *NoteListAltID = NULL;
3901         std::map<int, wxString> *NoteListPID = NULL;
3902         std::map<int, wxString> *NoteListType = NULL;
3903         std::map<int, wxString> *NoteListTokens = NULL;
3904         std::map<int, wxString> *NoteListLanguage = NULL;
3905         std::map<int, int> *NoteListPref = NULL;
3906         
3907         // Setup blank lines for later on.
3908         
3909         switch(PropType){
3910                 case PROPERTY_NONE:
3911                         NoteList = &GeneralNoteList;
3912                         NoteListType = &GeneralNoteListType;
3913                         NoteListAltID = &GeneralNoteListAltID;
3914                         NoteListPID = &GeneralNoteListPID;
3915                         NoteListTokens = &GeneralNoteListTokens;
3916                         NoteListLanguage = &GeneralNoteListLanguage;
3917                         NoteListPref = &GeneralNoteListPref;    
3918                         break;
3919                 case PROPERTY_HOME:
3920                         NoteList = &HomeNoteList;
3921                         NoteListType = &HomeNoteListType;
3922                         NoteListAltID = &HomeNoteListAltID;
3923                         NoteListPID = &HomeNoteListPID;
3924                         NoteListTokens = &HomeNoteListTokens;
3925                         NoteListLanguage = &HomeNoteListLanguage;
3926                         NoteListPref = &HomeNoteListPref;       
3927                         break;
3928                 case PROPERTY_WORK:
3929                         NoteList = &BusinessNoteList;
3930                         NoteListType = &BusinessNoteListType;
3931                         NoteListAltID = &BusinessNoteListAltID;
3932                         NoteListPID = &BusinessNoteListPID;
3933                         NoteListTokens = &BusinessNoteListTokens;
3934                         NoteListLanguage = &BusinessNoteListLanguage;   
3935                         NoteListPref = &BusinessNoteListPref;
3936                         break;
3937         }
3939         intPrevValue = 5;
3940                 
3941         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
3942         intiter != SplitPoints.end(); ++intiter){
3943         
3944                 SLiter = SplitLength.find(intiter->first);
3945         
3946                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
3947                 
3948                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
3949                 PropertyName = PropertyElement.GetNextToken();                          
3950                 PropertyValue = PropertyElement.GetNextToken();
3951                 
3952                 intPrevValue = intiter->second;
3953                 
3954                 // Process properties.
3955                 
3956                 size_t intPropertyValueLen = PropertyValue.Len();
3957                 
3958                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
3959                         
3960                         PropertyValue.Trim();
3961                         PropertyValue.RemoveLast();
3962                         
3963                 }                               
3964                 
3965                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
3966                         
3967                         PropertyValue.Remove(0, 1);
3968                         
3969                 }                               
3970                 
3971                 CaptureString(&PropertyValue, FALSE);
3972                 
3973                 if (PropertyName == wxT("ALTID")){
3974                 
3975                         NoteListAltID->erase(*NoteCount);
3976                         NoteListAltID->insert(std::make_pair(*NoteCount, PropertyValue));
3977                 
3978                 } else if (PropertyName == wxT("PID")){
3980                         NoteListPID->erase(*NoteCount);
3981                         NoteListPID->insert(std::make_pair(*NoteCount, PropertyValue));
3982                 
3983                 } else if (PropertyName == wxT("PREF")){
3984                                 
3985                         int PriorityNumber = 0;
3986                         bool ValidNumber = TRUE;
3987                         
3988                         try{
3989                                 PriorityNumber = std::stoi(PropertyValue.ToStdString());
3990                         }
3991                         
3992                         catch(std::invalid_argument &e){
3993                                 ValidNumber = FALSE;
3994                         }
3996                         if (ValidNumber == TRUE){
3998                                 NoteListPref->erase(*NoteCount);
3999                                 NoteListPref->insert(std::make_pair(*NoteCount, PriorityNumber));
4001                         }
4002                                         
4003                 } else if (PropertyName == wxT("LANGUAGE")){
4004                 
4005                         NoteListLanguage->erase(*NoteCount);
4006                         NoteListLanguage->insert(std::make_pair(*NoteCount, PropertyValue));
4007                 
4008                 } else {
4009                 
4010                         // Something else we don't know about so append
4011                         // to the tokens variable.
4012                 
4013                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
4014                 
4015                                 if (FirstToken == TRUE){
4016                         
4017                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
4018                                         FirstToken = FALSE;
4019                         
4020                                 } else {
4021                         
4022                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
4023                         
4024                                 }
4025                 
4026                         }
4027                 
4028                 }
4029         
4030         }
4031         
4032         // Add the data to the General/Home/Work address variables.
4033         
4034         CaptureString(&PropertySeg2, FALSE);
4036         NoteList->insert(std::make_pair(*NoteCount, PropertySeg2));
4037         
4038         if (!PropertyTokens.IsEmpty()){
4039         
4040                 NoteListTokens->insert(std::make_pair(*NoteCount, PropertyTokens));
4041                         
4042         }
4046 void ContactDataObject::ProcessCategory(wxString PropertySeg1, wxString PropertySeg2, int *CategoryCount){
4048         std::map<int, int> SplitPoints;
4049         std::map<int, int> SplitLength;
4050         std::map<int, int>::iterator SLiter;                    
4051         wxString PropertyData;
4052         wxString PropertyName;
4053         wxString PropertyValue;
4054         wxString PropertyTokens;
4055         bool FirstToken = TRUE;
4056         int intPrevValue = 12;
4057         int intPref = 0;                        
4058         int intType = 0;
4059         long ListCtrlIndex;
4060         
4061         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
4062         
4063         intPrevValue = 11;
4064         
4065         PropertyType PropType = PROPERTY_NONE;
4066                 
4067         // Look for type before continuing.
4068         
4069         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
4070         
4071         // Setup blank lines for later on.
4072         
4073         switch(PropType){
4074                 case PROPERTY_NONE:
4075                         break;
4076                 case PROPERTY_HOME:
4077                         CategoriesListType.insert(std::make_pair(*CategoryCount, "home"));
4078                         break;
4079                 case PROPERTY_WORK:
4080                         CategoriesListType.insert(std::make_pair(*CategoryCount, "work"));
4081                         break;
4082         }
4084         intPrevValue = 11;
4085                 
4086         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
4087         intiter != SplitPoints.end(); ++intiter){
4088         
4089                 SLiter = SplitLength.find(intiter->first);
4090         
4091                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
4092                 
4093                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
4094                 PropertyName = PropertyElement.GetNextToken();                          
4095                 PropertyValue = PropertyElement.GetNextToken();
4096                 
4097                 intPrevValue = intiter->second;
4098                 
4099                 // Process properties.
4100                 
4101                 size_t intPropertyValueLen = PropertyValue.Len();
4102                 
4103                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
4104                         
4105                         PropertyValue.Trim();
4106                         PropertyValue.RemoveLast();
4107                         
4108                 }                               
4109                 
4110                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
4111                         
4112                         PropertyValue.Remove(0, 1);
4113                         
4114                 }                               
4115                 
4116                 CaptureString(&PropertyValue, FALSE);
4117                 
4118                 if (PropertyName == wxT("ALTID")){
4119                 
4120                         CategoriesListAltID.erase(*CategoryCount);
4121                         CategoriesListAltID.insert(std::make_pair(*CategoryCount, PropertyValue));
4122                 
4123                 } else if (PropertyName == wxT("PID")){
4125                         CategoriesListPID.erase(*CategoryCount);
4126                         CategoriesListPID.insert(std::make_pair(*CategoryCount, PropertyValue));
4127                 
4128                 } else if (PropertyName == wxT("PREF")){
4129                                 
4130                         int PriorityNumber = 0;
4131                         bool ValidNumber = TRUE;
4132                         
4133                         try{
4134                                 PriorityNumber = std::stoi(PropertyValue.ToStdString());
4135                         }
4136                         
4137                         catch(std::invalid_argument &e){
4138                                 ValidNumber = FALSE;
4139                         }
4141                         if (ValidNumber == TRUE){
4143                                 CategoriesListPref.erase(*CategoryCount);
4144                                 CategoriesListPref.insert(std::make_pair(*CategoryCount, PriorityNumber));
4146                         }
4147                                         
4148                 } else if (PropertyName == wxT("LANGUAGE")){
4149                 
4150                         CategoriesListLanguage.erase(*CategoryCount);
4151                         CategoriesListLanguage.insert(std::make_pair(*CategoryCount, PropertyValue));
4152                 
4153                 } else {
4154                 
4155                         // Something else we don't know about so append
4156                         // to the tokens variable.
4157                 
4158                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
4159                 
4160                                 if (FirstToken == TRUE){
4161                         
4162                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
4163                                         FirstToken = FALSE;
4164                         
4165                                 } else {
4166                         
4167                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
4168                         
4169                                 }
4170                 
4171                         }
4172                 
4173                 }
4174         
4175         }
4176         
4177         // Deal with multiple categories.
4178         
4179         int intOrigCatCount = *CategoryCount;
4180         bool FirstCategoryProcessed = TRUE;
4181         bool AfterFirstToken = FALSE;
4182         int intSplitSize = 0;
4183         int intSplitsFound = 0;
4184         int intSplitSeek = 0;
4185         int intPropertyLen = PropertySeg2.Len();
4186         
4187         SplitPoints.clear();
4188         SplitLength.clear();
4189         intPrevValue = 0;
4190         
4191         for (int i = 0; i <= intPropertyLen; i++){
4192         
4193                 if (intSplitSize == 0 && PropertySeg2.Mid(i, 1) == wxT(" ")){
4194         
4195                         continue;
4196                 
4197                 }
4198         
4199                 intSplitSize++;
4200         
4201                 if (PropertySeg2.Mid(i, 1) == wxT(",") && PropertySeg2.Mid((i - 1), 1) != wxT("\\")){
4202         
4203                         if (AfterFirstToken == TRUE){
4204                 
4205                                 SplitPoints.insert(std::make_pair(intSplitsFound, (i - intSplitSize + 1)));
4206                                 SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 2)));
4207                         
4208                         } else {
4209                         
4210                                 SplitPoints.insert(std::make_pair(intSplitsFound, 0));
4211                                 SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 2)));                                 
4212                                 AfterFirstToken = TRUE;
4214                         }
4216                         intSplitsFound++;
4217                         intSplitSeek = i;
4218                         intSplitSize = 0;                               
4219         
4220                 }                       
4221         
4222         }
4223         
4224         if (SplitPoints.size() > 0){
4225         
4226                 SplitPoints.insert(std::make_pair(intSplitsFound, (intSplitSeek + 1)));
4227                 SplitLength.insert(std::make_pair(intSplitsFound, intSplitSize));
4228         
4229         }
4230         
4231         if (SplitPoints.size() == 0){
4232         
4233                 CategoriesList.insert(std::make_pair(*CategoryCount, PropertySeg2));
4234         
4235                 if (!PropertyTokens.IsEmpty()){
4236                 
4237                         CategoriesListTokens.insert(std::make_pair(*CategoryCount, PropertyTokens));
4238                 
4239                 }
4240         
4241         }
4242         
4243         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
4244         intiter != SplitPoints.end(); ++intiter){
4245         
4246                 SLiter = SplitLength.find(intiter->first);
4247         
4248                 intPrevValue = intiter->second;
4249         
4250                 PropertyData = PropertySeg2.Mid(intPrevValue, (SLiter->second + 1));
4251                 
4252                 // Add the data to the General/Home/Work address variables.
4253         
4254                 // Trim any whitespace from the start and end.
4255         
4256                 PropertyData = PropertyData.Trim(FALSE);
4257                 PropertyData = PropertyData.Trim(TRUE); 
4258         
4259                 CaptureString(&PropertyData, FALSE);
4260                 
4261                 if (FirstCategoryProcessed == TRUE){
4262                 
4263                         FirstCategoryProcessed = FALSE;
4264                         
4265                         CategoriesList.insert(std::make_pair(*CategoryCount, PropertyData));
4266         
4267                         if (!PropertyTokens.IsEmpty()){
4268                 
4269                                 CategoriesListTokens.insert(std::make_pair(*CategoryCount, PropertyTokens));
4270                 
4271                         }
4272                         
4273                         continue;
4274                 
4275                 } else {
4277                         (*CategoryCount)++;
4278                         
4279                         CategoriesList.insert(std::make_pair(*CategoryCount, PropertyData));
4280                 
4281                         if (!PropertyTokens.IsEmpty()){
4282                 
4283                                 CategoriesListTokens.insert(std::make_pair(*CategoryCount, PropertyTokens));
4284                 
4285                         }
4286                 
4287                 }
4288                 
4289                 // Copy the properties to each of the categories (if it exists).
4290                 
4291                 if (!PropertyTokens.IsEmpty()){
4292                 
4293                         CategoriesListTokens.insert(std::make_pair(*CategoryCount, CategoriesListTokens.find(intOrigCatCount)->second));
4294                 
4295                 }
4296                 
4297                 // Check if ALTID was used.
4298                 
4299                 if (CategoriesListAltID.find(intOrigCatCount) != CategoriesListAltID.end()){
4300                 
4301                         CategoriesListAltID.insert(std::make_pair(*CategoryCount, CategoriesListAltID.find(intOrigCatCount)->second));
4302                 
4303                 }
4304                 
4305                 // Check if PID was used.
4306                 
4307                 if (CategoriesListPID.find(intOrigCatCount) != CategoriesListPID.end()){
4308                 
4309                         CategoriesListPID.insert(std::make_pair(*CategoryCount, CategoriesListPID.find(intOrigCatCount)->second));
4310                 
4311                 }
4312         
4313                 // Check if PREF was used.
4314         
4315                 if (CategoriesListPref.find(intOrigCatCount) != CategoriesListPref.end()){
4316                 
4317                         CategoriesListPref.insert(std::make_pair(*CategoryCount, CategoriesListPref.find(intOrigCatCount)->second));
4318                 
4319                 }
4320                 
4321                 // Check if LANGUAGE was used.
4322                 
4323                 if (CategoriesListLanguage.find(intOrigCatCount) != CategoriesListLanguage.end()){
4324                 
4325                         CategoriesListLanguage.insert(std::make_pair(*CategoryCount, CategoriesListLanguage.find(intOrigCatCount)->second));
4326                 
4327                 }
4328                 
4329                 // Check if TYPE was used.
4330                 
4331                 switch(PropType){
4332                         case PROPERTY_NONE:
4333                                 break;
4334                         case PROPERTY_HOME:
4335                                 CategoriesListType.insert(std::make_pair(*CategoryCount, "home"));
4336                                 break;
4337                         case PROPERTY_WORK:
4338                                 CategoriesListType.insert(std::make_pair(*CategoryCount, "work"));
4339                                 break;
4340                 }
4341         
4342         }
4346 void ContactDataObject::ProcessPhoto(wxString PropertySeg1, wxString PropertySeg2, int *PhotoCount){
4348         size_t intPropertyLen = PropertySeg1.Len();
4349         std::map<int, int> SplitPoints;
4350         std::map<int, int> SplitLength;
4351         std::map<int, int>::iterator SLiter;                    
4352         wxString PropertyData;
4353         wxString PropertyName;
4354         wxString PropertyValue;
4355         wxString PropertyTokens;
4356         bool FirstToken = TRUE;
4357         int intSplitsFound = 0;
4358         int intSplitSize = 0;
4359         int intPrevValue = 7;
4360         int intPref = 0;                        
4361         int intType = 0;
4362         
4363         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
4364         
4365         intPrevValue = 6;
4366         
4367         PropertyType PropType = PROPERTY_NONE;
4368                 
4369         // Look for type before continuing.
4370         
4371         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
4373         intPrevValue = 6;
4375         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
4376         intiter != SplitPoints.end(); ++intiter){
4377         
4378                 SLiter = SplitLength.find(intiter->first);
4379         
4380                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
4381                 
4382                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
4383                 PropertyName = PropertyElement.GetNextToken();                          
4384                 PropertyValue = PropertyElement.GetNextToken();
4385                 
4386                 intPrevValue = intiter->second;
4387                 
4388                 // Process properties.
4389                 
4390                 size_t intPropertyValueLen = PropertyValue.Len();
4391                 
4392                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
4393                         
4394                         PropertyValue.Trim();
4395                         PropertyValue.RemoveLast();
4396                         
4397                 }                               
4398                 
4399                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
4400                         
4401                         PropertyValue.Remove(0, 1);
4402                         
4403                 }
4404                 
4405                 CaptureString(&PropertyValue, FALSE);
4406                 
4407                 if (PropertyName == wxT("ALTID")){
4409                         PicturesListAltID.erase(*PhotoCount);
4410                         PicturesListAltID.insert(std::make_pair(*PhotoCount, PropertyValue));
4411                 
4412                 } else if (PropertyName == wxT("PID")){
4414                         PicturesListPID.erase(*PhotoCount);
4415                         PicturesListPID.insert(std::make_pair(*PhotoCount, PropertyValue));
4416                 
4417                 } else if (PropertyName == wxT("PREF")){
4418                         
4419                         int PriorityNumber = 0;
4420                         bool ValidNumber = TRUE;
4421                         
4422                         try{
4423                                 PriorityNumber = std::stoi(PropertyValue.ToStdString());
4424                         }
4425                         
4426                         catch(std::invalid_argument &e){
4427                                 ValidNumber = FALSE;
4428                         }
4430                         if (ValidNumber == TRUE){
4432                                 PicturesListPref.erase(*PhotoCount);
4433                                 PicturesListPref.insert(std::make_pair(*PhotoCount, PriorityNumber));
4435                         }
4436                 
4437                 } else if (PropertyName == wxT("MEDIATYPE")){
4438                 
4439                         PicturesListMediatype.erase(*PhotoCount);
4440                         PicturesListMediatype.insert(std::make_pair(*PhotoCount, PropertyValue));
4441                                         
4442                 } else {
4443                 
4444                         // Something else we don't know about so append
4445                         // to the tokens variable.
4446                         
4447                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
4448                         
4449                                 if (FirstToken == TRUE){
4450                                 
4451                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
4452                                         FirstToken = FALSE;
4453                                 
4454                                 } else {
4455                                 
4456                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
4457                                 
4458                                 }
4459                         
4460                         }
4461                 
4462                 }
4463         
4464         }       
4465         
4466         intPropertyLen = PropertySeg2.Len();
4467         SplitPoints.clear();
4468         SplitLength.clear();
4469         intSplitsFound = 0;
4470         intSplitSize = 0;
4471         intPrevValue = 0;                       
4472         
4473         CaptureString(&PropertySeg2, FALSE);
4474         
4475         for (int i = 0; i <= intPropertyLen; i++){
4477                 intSplitSize++;
4478         
4479                 if (PropertySeg2.Mid(i, 1) == wxT(";")){
4480         
4481                         intSplitsFound++;
4482                         SplitPoints.insert(std::make_pair(intSplitsFound, (i + 1)));
4483                         
4484                         if (intSplitsFound == 6){ 
4485                         
4486                                 SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1)));
4487                                 break; 
4488                                 
4489                         } else {
4490                         
4491                                 SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1)));
4492                         
4493                         }
4494                         
4495                         intSplitSize = 0;                                       
4496         
4497                 }
4499         }
4500         
4501         wxString wxSPhotoURI;
4502         wxString wxSPhotoMIME;
4503         wxString wxSPhotoEncoding;
4504         wxString wxSPhotoData;
4505         std::string base64enc;
4506         
4507         if (intSplitsFound == 0){
4508         
4509         } else {
4510         
4511                 std::map<int, int>::iterator striter;
4512         
4513                 striter = SplitLength.find(1);
4514         
4515                 wxStringTokenizer wSTDataType(PropertySeg2.Mid(0, striter->second), wxT(":"));
4516         
4517                 while (wSTDataType.HasMoreTokens() == TRUE){
4518                 
4519                         wxSPhotoURI = wSTDataType.GetNextToken();
4520                         wxSPhotoMIME = wSTDataType.GetNextToken();
4521                         break;
4522                 
4523                 }                       
4524         
4525                 wxStringTokenizer wSTDataInfo(PropertySeg2.Mid((striter->second + 1)), wxT(","));                       
4526         
4527                 while (wSTDataInfo.HasMoreTokens() == TRUE){
4528                 
4529                         wxSPhotoEncoding = wSTDataInfo.GetNextToken();
4530                         wxSPhotoData = wSTDataInfo.GetNextToken();
4531                         base64enc = wxSPhotoData.mb_str();
4532                         break;
4533                 
4534                 }
4535         
4536         }
4537         
4538         // Add the data to the General/Home/Work address variables.
4539         
4540         PicturesList.insert(std::make_pair(*PhotoCount, base64enc));
4541         PicturesListPictureType.insert(std::make_pair(*PhotoCount, wxSPhotoMIME));
4542         PicturesListPicEncType.insert(std::make_pair(*PhotoCount, wxSPhotoEncoding));
4543         
4544         switch(PropType){
4545                 case PROPERTY_NONE:
4546                         break;
4547                 case PROPERTY_HOME:
4548                         PicturesListType.insert(std::make_pair(*PhotoCount, "home"));
4549                         break;
4550                 case PROPERTY_WORK:
4551                         PicturesListType.insert(std::make_pair(*PhotoCount, "work"));
4552                         break;
4553         }
4554         
4555         if (!PropertyTokens.IsEmpty()){
4557                 PicturesListTokens.insert(std::make_pair(*PhotoCount, PropertyTokens));
4558         
4559         }
4563 void ContactDataObject::ProcessLogo(wxString PropertySeg1, wxString PropertySeg2, int *LogoCount){
4565         size_t intPropertyLen = PropertySeg1.Len();
4566         std::map<int, int> SplitPoints;
4567         std::map<int, int> SplitLength;
4568         std::map<int, int>::iterator SLiter;                    
4569         wxString PropertyData;
4570         wxString PropertyName;
4571         wxString PropertyValue;
4572         wxString PropertyTokens;
4573         bool FirstToken = TRUE;
4574         int intSplitsFound = 0;
4575         int intSplitSize = 0;
4576         int intPrevValue = 6;
4577         int intPref = 0;                        
4578         int intType = 0;
4579         
4580         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
4581         
4582         intPrevValue = 5;
4583         
4584         PropertyType PropType = PROPERTY_NONE;
4585                 
4586         // Look for type before continuing.
4587         
4588         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
4590         intPrevValue = 5;
4592         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
4593         intiter != SplitPoints.end(); ++intiter){
4594         
4595                 SLiter = SplitLength.find(intiter->first);
4596         
4597                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
4598                 
4599                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
4600                 PropertyName = PropertyElement.GetNextToken();                          
4601                 PropertyValue = PropertyElement.GetNextToken();
4602                 
4603                 intPrevValue = intiter->second;
4604                 
4605                 // Process properties.
4606                 
4607                 size_t intPropertyValueLen = PropertyValue.Len();
4608                 
4609                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
4610                         
4611                         PropertyValue.Trim();
4612                         PropertyValue.RemoveLast();
4613                         
4614                 }                               
4615                 
4616                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
4617                         
4618                         PropertyValue.Remove(0, 1);
4619                         
4620                 }
4621                 
4622                 CaptureString(&PropertyValue, FALSE);
4623                 
4624                 if (PropertyName == wxT("ALTID")){
4626                         LogosListAltID.erase(*LogoCount);
4627                         LogosListAltID.insert(std::make_pair(*LogoCount, PropertyValue));
4628                 
4629                 } else if (PropertyName == wxT("PID")){
4631                         LogosListPID.erase(*LogoCount);
4632                         LogosListPID.insert(std::make_pair(*LogoCount, PropertyValue));
4633                 
4634                 } else if (PropertyName == wxT("PREF")){
4635                         
4636                         int PriorityNumber = 0;
4637                         bool ValidNumber = TRUE;
4638                         
4639                         try{
4640                                 PriorityNumber = std::stoi(PropertyValue.ToStdString());
4641                         }
4642                         
4643                         catch(std::invalid_argument &e){
4644                                 ValidNumber = FALSE;
4645                         }
4647                         if (ValidNumber == TRUE){
4649                                 LogosListPref.erase(*LogoCount);
4650                                 LogosListPref.insert(std::make_pair(*LogoCount, PriorityNumber));
4652                         }
4653                 
4654                 } else if (PropertyName == wxT("MEDIATYPE")){
4655                 
4656                         LogosListMediatype.erase(*LogoCount);
4657                         LogosListMediatype.insert(std::make_pair(*LogoCount, PropertyValue));
4658                                         
4659                 } else {
4660                 
4661                         // Something else we don't know about so append
4662                         // to the tokens variable.
4663                         
4664                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
4665                         
4666                                 if (FirstToken == TRUE){
4667                                 
4668                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
4669                                         FirstToken = FALSE;
4670                                 
4671                                 } else {
4672                                 
4673                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
4674                                 
4675                                 }
4676                         
4677                         }
4678                 
4679                 }
4680         
4681         }       
4682         
4683         intPropertyLen = PropertySeg2.Len();
4684         SplitPoints.clear();
4685         SplitLength.clear();
4686         intSplitsFound = 0;
4687         intSplitSize = 0;
4688         intPrevValue = 0;                       
4689         
4690         CaptureString(&PropertySeg2, FALSE);
4691         
4692         for (int i = 0; i <= intPropertyLen; i++){
4694                 intSplitSize++;
4695         
4696                 if (PropertySeg2.Mid(i, 1) == wxT(";")){
4697         
4698                         intSplitsFound++;
4699                         SplitPoints.insert(std::make_pair(intSplitsFound, (i + 1)));
4700                         
4701                         if (intSplitsFound == 6){ 
4702                         
4703                                 SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1)));
4704                                 break; 
4705                                 
4706                         } else {
4707                         
4708                                 SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1)));
4709                         
4710                         }
4711                         
4712                         intSplitSize = 0;                                       
4713         
4714                 }
4716         }
4717         
4718         wxString wxSPhotoURI;
4719         wxString wxSPhotoMIME;
4720         wxString wxSPhotoEncoding;
4721         wxString wxSPhotoData;
4722         std::string base64enc;
4723         
4724         if (intSplitsFound == 0){
4725         
4726         } else {
4727         
4728                 std::map<int, int>::iterator striter;
4729         
4730                 striter = SplitLength.find(1);
4731         
4732                 wxStringTokenizer wSTDataType(PropertySeg2.Mid(0, striter->second), wxT(":"));
4733         
4734                 while (wSTDataType.HasMoreTokens() == TRUE){
4735                 
4736                         wxSPhotoURI = wSTDataType.GetNextToken();
4737                         wxSPhotoMIME = wSTDataType.GetNextToken();
4738                         break;
4739                 
4740                 }                       
4741         
4742                 wxStringTokenizer wSTDataInfo(PropertySeg2.Mid((striter->second + 1)), wxT(","));                       
4743         
4744                 while (wSTDataInfo.HasMoreTokens() == TRUE){
4745                 
4746                         wxSPhotoEncoding = wSTDataInfo.GetNextToken();
4747                         wxSPhotoData = wSTDataInfo.GetNextToken();
4748                         base64enc = wxSPhotoData.mb_str();
4749                         break;
4750                 
4751                 }
4752         
4753         }
4754         
4755         // Add the data to the General/Home/Work address variables.
4756         
4757         LogosList.insert(std::make_pair(*LogoCount, base64enc));
4758         LogosListPictureType.insert(std::make_pair(*LogoCount, wxSPhotoMIME));
4759         LogosListPicEncType.insert(std::make_pair(*LogoCount, wxSPhotoEncoding));
4760         
4761         switch(PropType){
4762                 case PROPERTY_NONE:
4763                         break;
4764                 case PROPERTY_HOME:
4765                         LogosListType.insert(std::make_pair(*LogoCount, "home"));
4766                         break;
4767                 case PROPERTY_WORK:
4768                         LogosListType.insert(std::make_pair(*LogoCount, "work"));
4769                         break;
4770         }
4771         
4772         if (!PropertyTokens.IsEmpty()){
4774                 LogosListTokens.insert(std::make_pair(*LogoCount, PropertyTokens));
4775         
4776         }
4780 void ContactDataObject::ProcessSound(wxString PropertySeg1, wxString PropertySeg2, int *SoundCount){
4782         size_t intPropertyLen = PropertySeg1.Len();
4783         std::map<int, int> SplitPoints;
4784         std::map<int, int> SplitLength;
4785         std::map<int, int>::iterator SLiter;                    
4786         wxString PropertyData;
4787         wxString PropertyName;
4788         wxString PropertyValue;
4789         wxString PropertyTokens;
4790         bool FirstToken = TRUE;
4791         int intSplitsFound = 0;
4792         int intSplitSize = 0;
4793         int intPrevValue = 7;
4794         int intPref = 0;                        
4795         int intType = 0;
4796         
4797         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
4798         
4799         intPrevValue = 6;
4800         
4801         PropertyType PropType = PROPERTY_NONE;
4802         
4803         // Look for type before continuing.                     
4805         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
4807         intPrevValue = 6;
4809         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
4810         intiter != SplitPoints.end(); ++intiter){
4811         
4812                 SLiter = SplitLength.find(intiter->first);
4813         
4814                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
4815                 
4816                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
4817                 PropertyName = PropertyElement.GetNextToken();                          
4818                 PropertyValue = PropertyElement.GetNextToken();
4819                 
4820                 intPrevValue = intiter->second;
4821                 
4822                 // Process properties.
4823                 
4824                 size_t intPropertyValueLen = PropertyValue.Len();
4825                 
4826                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
4827                         
4828                         PropertyValue.Trim();
4829                         PropertyValue.RemoveLast();
4830                         
4831                 }                               
4832                 
4833                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
4834                         
4835                         PropertyValue.Remove(0, 1);
4836                         
4837                 }                       
4838                 
4839                 CaptureString(&PropertyValue, FALSE);
4840                 
4841                 if (PropertyName == wxT("ALTID")){
4843                         SoundsListAltID.erase(*SoundCount);
4844                         SoundsListAltID.insert(std::make_pair(*SoundCount, PropertyValue));
4845                 
4846                 } else if (PropertyName == wxT("PID")){
4848                         SoundsListPID.erase(*SoundCount);
4849                         SoundsListPID.insert(std::make_pair(*SoundCount, PropertyValue));
4850                 
4851                 } else if (PropertyName == wxT("PREF")){
4852                         
4853                         int PriorityNumber = 0;
4854                         bool ValidNumber = TRUE;
4855                         
4856                         try{
4857                                 PriorityNumber = std::stoi(PropertyValue.ToStdString());
4858                         }
4859                         
4860                         catch(std::invalid_argument &e){
4861                                 ValidNumber = FALSE;
4862                         }
4864                         if (ValidNumber == TRUE){
4866                                 SoundsListPref.erase(*SoundCount);
4867                                 SoundsListPref.insert(std::make_pair(*SoundCount, PriorityNumber));
4869                         }
4870                 
4871                 } else if (PropertyName == wxT("MEDIATYPE")){
4872                 
4873                         SoundsListMediatype.erase(*SoundCount);
4874                         SoundsListMediatype.insert(std::make_pair(*SoundCount, PropertyValue));
4876                 } else if (PropertyName == wxT("LANGUAGE")){
4877                 
4878                         SoundsListLanguage.erase(*SoundCount);
4879                         SoundsListLanguage.insert(std::make_pair(*SoundCount, PropertyValue));
4881                 } else {
4882                 
4883                         // Something else we don't know about so append
4884                         // to the tokens variable.
4885                         
4886                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
4887                         
4888                                 if (FirstToken == TRUE){
4889                                 
4890                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
4891                                         FirstToken = FALSE;
4892                                 
4893                                 } else {
4894                                 
4895                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
4896                                 
4897                                 }
4898                         
4899                         }
4900                 
4901                 }
4902         
4903         }       
4904         
4905         intPropertyLen = PropertySeg2.Len();
4906         SplitPoints.clear();
4907         SplitLength.clear();
4908         intSplitsFound = 0;
4909         intSplitSize = 0;
4910         intPrevValue = 0;
4911         
4912         CaptureString(&PropertySeg2, FALSE);
4913         
4914         for (int i = 0; i <= intPropertyLen; i++){
4916                 intSplitSize++;
4917         
4918                 if (PropertySeg2.Mid(i, 1) == wxT(";")){
4919         
4920                         intSplitsFound++;
4921                         SplitPoints.insert(std::make_pair(intSplitsFound, (i + 1)));
4922                         
4923                         if (intSplitsFound == 6){ 
4924                         
4925                                 SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1)));
4926                                 break; 
4927                                 
4928                         } else {
4929                         
4930                                 SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1)));
4931                         
4932                         }
4933                         
4934                         intSplitSize = 0;                                       
4935         
4936                 }
4938         }
4939         
4940         wxString wxSSoundURI;
4941         wxString wxSSoundMIME;
4942         wxString wxSSoundEncoding;
4943         wxString wxSSoundData;
4944         std::string base64enc;
4945         
4946         if (intSplitsFound == 0){
4947         
4948         } else {
4949         
4950                 std::map<int, int>::iterator striter;
4951         
4952                 striter = SplitLength.find(1);
4953         
4954                 wxStringTokenizer wSTDataType(PropertySeg2.Mid(0, striter->second), wxT(":"));
4955         
4956                 while (wSTDataType.HasMoreTokens() == TRUE){
4957                 
4958                         wxSSoundURI = wSTDataType.GetNextToken();
4959                         wxSSoundMIME = wSTDataType.GetNextToken();
4960                         break;
4961                 
4962                 }                       
4963         
4964                 wxStringTokenizer wSTDataInfo(PropertySeg2.Mid((striter->second + 1)), wxT(","));                       
4965         
4966                 while (wSTDataInfo.HasMoreTokens() == TRUE){
4967                 
4968                         wxSSoundEncoding = wSTDataInfo.GetNextToken();
4969                         wxSSoundData = wSTDataInfo.GetNextToken();                                      
4970                         base64enc = wxSSoundData.mb_str();
4971                         break;
4972                 
4973                 }
4974         
4975         }
4976         
4977         // Add the data to the General/Home/Work address variables.
4978                 
4979         switch(PropType){
4980                 case PROPERTY_NONE:
4981                         break;
4982                 case PROPERTY_HOME:
4983                         SoundsListType.insert(std::make_pair(*SoundCount, "home"));
4984                         break;
4985                 case PROPERTY_WORK:
4986                         SoundsListType.insert(std::make_pair(*SoundCount, "work"));
4987                         break;
4988         }
4989         
4990         SoundsList.insert(std::make_pair(*SoundCount, base64enc));
4991         SoundsListAudioEncType.insert(std::make_pair(*SoundCount, wxSSoundEncoding));
4992         SoundsListAudioType.insert(std::make_pair(*SoundCount, wxSSoundMIME));
4993         
4994         if (!PropertyTokens.IsEmpty()){
4995         
4996                 SoundsListTokens.insert(std::make_pair(*SoundCount, PropertyTokens));
4997         
4998         }
4999         
5002 void ContactDataObject::ProcessCalendarURI(wxString PropertySeg1, wxString PropertySeg2, int *CalURICount){
5004         size_t intPropertyLen = PropertySeg1.Len();
5005         std::map<int, int> SplitPoints;
5006         std::map<int, int> SplitLength;
5007         std::map<int, int>::iterator SLiter;                    
5008         wxString PropertyData;
5009         wxString PropertyName;
5010         wxString PropertyValue;
5011         wxString PropertyTokens;
5012         bool FirstToken = TRUE;
5013         int intSplitsFound = 0;
5014         int intSplitSize = 0;
5015         int intPrevValue = 8;
5016         int intPref = 0;                        
5017         int intType = 0;
5018         
5019         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
5020         
5021         intPrevValue = 7;
5022         
5023         PropertyType PropType = PROPERTY_NONE;
5024         
5025         // Look for type before continuing.                     
5027         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
5029         intPrevValue = 7;
5031         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
5032         intiter != SplitPoints.end(); ++intiter){
5033         
5034                 SLiter = SplitLength.find(intiter->first);
5035         
5036                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
5037                 
5038                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
5039                 PropertyName = PropertyElement.GetNextToken();                          
5040                 PropertyValue = PropertyElement.GetNextToken();
5041                 
5042                 intPrevValue = intiter->second;
5043                 
5044                 // Process properties.
5045                 
5046                 size_t intPropertyValueLen = PropertyValue.Len();
5047                 
5048                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
5049                         
5050                         PropertyValue.Trim();
5051                         PropertyValue.RemoveLast();
5052                         
5053                 }                               
5054                 
5055                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
5056                         
5057                         PropertyValue.Remove(0, 1);
5058                         
5059                 }                       
5060                 
5061                 CaptureString(&PropertyValue, FALSE);
5062                 
5063                 if (PropertyName == wxT("ALTID")){
5065                         CalendarListAltID.erase(*CalURICount);
5066                         CalendarListAltID.insert(std::make_pair(*CalURICount, PropertyValue));
5067                 
5068                 } else if (PropertyName == wxT("PID")){
5070                         CalendarListPID.erase(*CalURICount);
5071                         CalendarListPID.insert(std::make_pair(*CalURICount, PropertyValue));
5072                 
5073                 } else if (PropertyName == wxT("PREF")){
5074                         
5075                         int PriorityNumber = 0;
5076                         bool ValidNumber = TRUE;
5077                         
5078                         try{
5079                                 PriorityNumber = std::stoi(PropertyValue.ToStdString());
5080                         }
5081                         
5082                         catch(std::invalid_argument &e){
5083                                 ValidNumber = FALSE;
5084                         }
5086                         if (ValidNumber == TRUE){
5088                                 CalendarListPref.erase(*CalURICount);
5089                                 CalendarListPref.insert(std::make_pair(*CalURICount, PriorityNumber));
5091                         }
5092                 
5093                 } else if (PropertyName == wxT("MEDIATYPE")){
5094                 
5095                         CalendarListMediatype.erase(*CalURICount);
5096                         CalendarListMediatype.insert(std::make_pair(*CalURICount, PropertyValue));
5098                 } else {
5099                 
5100                         // Something else we don't know about so append
5101                         // to the tokens variable.
5102                         
5103                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
5104                         
5105                                 if (FirstToken == TRUE){
5106                                 
5107                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
5108                                         FirstToken = FALSE;
5109                                 
5110                                 } else {
5111                                 
5112                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
5113                                 
5114                                 }
5115                         
5116                         }
5117                 
5118                 }
5119         
5120         }       
5121         
5122         intPropertyLen = PropertySeg2.Len();
5123         SplitPoints.clear();
5124         SplitLength.clear();
5125         intSplitsFound = 0;
5126         intSplitSize = 0;
5127         intPrevValue = 0;
5128         
5129         CaptureString(&PropertySeg2, FALSE);
5130         
5131         // Add the data to the General/Home/Work address variables.
5132                 
5133         switch(PropType){
5134                 case PROPERTY_NONE:
5135                         break;
5136                 case PROPERTY_HOME:
5137                         CalendarListType.insert(std::make_pair(*CalURICount, "home"));
5138                         break;
5139                 case PROPERTY_WORK:
5140                         CalendarListType.insert(std::make_pair(*CalURICount, "work"));
5141                         break;
5142         }
5143         
5144         CalendarList.insert(std::make_pair(*CalURICount, PropertySeg2));
5145         
5146         if (!PropertyTokens.IsEmpty()){
5147         
5148                 CalendarListTokens.insert(std::make_pair(*CalURICount, PropertyTokens));
5149         
5150         }
5154 void ContactDataObject::ProcessCalendarAddressURI(wxString PropertySeg1, wxString PropertySeg2, int *CalAdrURICount){
5156         size_t intPropertyLen = PropertySeg1.Len();
5157         std::map<int, int> SplitPoints;
5158         std::map<int, int> SplitLength;
5159         std::map<int, int>::iterator SLiter;                    
5160         wxString PropertyData;
5161         wxString PropertyName;
5162         wxString PropertyValue;
5163         wxString PropertyTokens;
5164         bool FirstToken = TRUE;
5165         int intSplitsFound = 0;
5166         int intSplitSize = 0;
5167         int intPrevValue = 8;
5168         int intPref = 0;                        
5169         int intType = 0;
5170         
5171         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
5172         
5173         intPrevValue = 7;
5174         
5175         PropertyType PropType = PROPERTY_NONE;
5176         
5177         // Look for type before continuing.                     
5179         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
5181         intPrevValue = 7;
5183         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
5184         intiter != SplitPoints.end(); ++intiter){
5185         
5186                 SLiter = SplitLength.find(intiter->first);
5187         
5188                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
5189                 
5190                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
5191                 PropertyName = PropertyElement.GetNextToken();                          
5192                 PropertyValue = PropertyElement.GetNextToken();
5193                 
5194                 intPrevValue = intiter->second;
5195                 
5196                 // Process properties.
5197                 
5198                 size_t intPropertyValueLen = PropertyValue.Len();
5199                 
5200                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
5201                         
5202                         PropertyValue.Trim();
5203                         PropertyValue.RemoveLast();
5204                         
5205                 }                               
5206                 
5207                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
5208                         
5209                         PropertyValue.Remove(0, 1);
5210                         
5211                 }                       
5212                 
5213                 CaptureString(&PropertyValue, FALSE);
5214                 
5215                 if (PropertyName == wxT("ALTID")){
5217                         CalendarRequestListAltID.erase(*CalAdrURICount);
5218                         CalendarRequestListAltID.insert(std::make_pair(*CalAdrURICount, PropertyValue));
5219                 
5220                 } else if (PropertyName == wxT("PID")){
5222                         CalendarRequestListPID.erase(*CalAdrURICount);
5223                         CalendarRequestListPID.insert(std::make_pair(*CalAdrURICount, PropertyValue));
5224                 
5225                 } else if (PropertyName == wxT("PREF")){
5226                         
5227                         int PriorityNumber = 0;
5228                         bool ValidNumber = TRUE;
5229                         
5230                         try{
5231                                 PriorityNumber = std::stoi(PropertyValue.ToStdString());
5232                         }
5233                         
5234                         catch(std::invalid_argument &e){
5235                                 ValidNumber = FALSE;
5236                         }
5238                         if (ValidNumber == TRUE){
5240                                 CalendarRequestListPref.erase(*CalAdrURICount);
5241                                 CalendarRequestListPref.insert(std::make_pair(*CalAdrURICount, PriorityNumber));
5243                         }
5244                 
5245                 } else if (PropertyName == wxT("MEDIATYPE")){
5246                 
5247                         CalendarRequestListMediatype.erase(*CalAdrURICount);
5248                         CalendarRequestListMediatype.insert(std::make_pair(*CalAdrURICount, PropertyValue));
5250                 } else {
5251                 
5252                         // Something else we don't know about so append
5253                         // to the tokens variable.
5254                         
5255                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
5256                         
5257                                 if (FirstToken == TRUE){
5258                                 
5259                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
5260                                         FirstToken = FALSE;
5261                                 
5262                                 } else {
5263                                 
5264                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
5265                                 
5266                                 }
5267                         
5268                         }
5269                 
5270                 }
5271         
5272         }       
5273         
5274         intPropertyLen = PropertySeg2.Len();
5275         SplitPoints.clear();
5276         SplitLength.clear();
5277         intSplitsFound = 0;
5278         intSplitSize = 0;
5279         intPrevValue = 0;
5280         
5281         CaptureString(&PropertySeg2, FALSE);
5282         
5283         // Add the data to the General/Home/Work address variables.
5284                 
5285         switch(PropType){
5286                 case PROPERTY_NONE:
5287                         break;
5288                 case PROPERTY_HOME:
5289                         CalendarRequestListType.insert(std::make_pair(*CalAdrURICount, "home"));
5290                         break;
5291                 case PROPERTY_WORK:
5292                         CalendarRequestListType.insert(std::make_pair(*CalAdrURICount, "work"));
5293                         break;
5294         }
5295         
5296         CalendarRequestList.insert(std::make_pair(*CalAdrURICount, PropertySeg2));
5297         
5298         if (!PropertyTokens.IsEmpty()){
5299         
5300                 CalendarRequestListTokens.insert(std::make_pair(*CalAdrURICount, PropertyTokens));
5301         
5302         }       
5303         
5306 void ContactDataObject::ProcessCalendarFreeBusy(wxString PropertySeg1, wxString PropertySeg2, int *FreeBusyAddressCount){
5308         size_t intPropertyLen = PropertySeg1.Len();
5309         std::map<int, int> SplitPoints;
5310         std::map<int, int> SplitLength;
5311         std::map<int, int>::iterator SLiter;                    
5312         wxString PropertyData;
5313         wxString PropertyName;
5314         wxString PropertyValue;
5315         wxString PropertyTokens;
5316         bool FirstToken = TRUE;
5317         int intSplitsFound = 0;
5318         int intSplitSize = 0;
5319         int intPrevValue = 7;
5320         int intPref = 0;                        
5321         int intType = 0;
5322         
5323         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
5324         
5325         intPrevValue = 6;
5326         
5327         PropertyType PropType = PROPERTY_NONE;
5328         
5329         // Look for type before continuing.                     
5331         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
5333         intPrevValue = 6;
5335         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
5336         intiter != SplitPoints.end(); ++intiter){
5337         
5338                 SLiter = SplitLength.find(intiter->first);
5339         
5340                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
5341                 
5342                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
5343                 PropertyName = PropertyElement.GetNextToken();                          
5344                 PropertyValue = PropertyElement.GetNextToken();
5345                 
5346                 intPrevValue = intiter->second;
5347                 
5348                 // Process properties.
5349                 
5350                 size_t intPropertyValueLen = PropertyValue.Len();
5351                 
5352                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
5353                         
5354                         PropertyValue.Trim();
5355                         PropertyValue.RemoveLast();
5356                         
5357                 }                               
5358                 
5359                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
5360                         
5361                         PropertyValue.Remove(0, 1);
5362                         
5363                 }                       
5364                 
5365                 CaptureString(&PropertyValue, FALSE);
5366                 
5367                 if (PropertyName == wxT("ALTID")){
5369                         FreeBusyListAltID.erase(*FreeBusyAddressCount);
5370                         FreeBusyListAltID.insert(std::make_pair(*FreeBusyAddressCount, PropertyValue));
5371                 
5372                 } else if (PropertyName == wxT("PID")){
5374                         FreeBusyListPID.erase(*FreeBusyAddressCount);
5375                         FreeBusyListPID.insert(std::make_pair(*FreeBusyAddressCount, PropertyValue));
5376                 
5377                 } else if (PropertyName == wxT("PREF")){
5378                         
5379                         int PriorityNumber = 0;
5380                         bool ValidNumber = TRUE;
5381                         
5382                         try{
5383                                 PriorityNumber = std::stoi(PropertyValue.ToStdString());
5384                         }
5385                         
5386                         catch(std::invalid_argument &e){
5387                                 ValidNumber = FALSE;
5388                         }
5390                         if (ValidNumber == TRUE){
5392                                 FreeBusyListPref.erase(*FreeBusyAddressCount);
5393                                 FreeBusyListPref.insert(std::make_pair(*FreeBusyAddressCount, PriorityNumber));
5395                         }
5396                 
5397                 } else if (PropertyName == wxT("MEDIATYPE")){
5398                 
5399                         FreeBusyListMediatype.erase(*FreeBusyAddressCount);
5400                         FreeBusyListMediatype.insert(std::make_pair(*FreeBusyAddressCount, PropertyValue));
5402                 } else {
5403                 
5404                         // Something else we don't know about so append
5405                         // to the tokens variable.
5406                         
5407                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
5408                         
5409                                 if (FirstToken == TRUE){
5410                                 
5411                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
5412                                         FirstToken = FALSE;
5413                                 
5414                                 } else {
5415                                 
5416                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
5417                                 
5418                                 }
5419                         
5420                         }
5421                 
5422                 }
5423         
5424         }       
5425         
5426         intPropertyLen = PropertySeg2.Len();
5427         SplitPoints.clear();
5428         SplitLength.clear();
5429         intSplitsFound = 0;
5430         intSplitSize = 0;
5431         intPrevValue = 0;
5432         
5433         CaptureString(&PropertySeg2, FALSE);
5434         
5435         // Add the data to the General/Home/Work address variables.
5436                 
5437         switch(PropType){
5438                 case PROPERTY_NONE:
5439                         break;
5440                 case PROPERTY_HOME:
5441                         FreeBusyListType.insert(std::make_pair(*FreeBusyAddressCount, "home"));
5442                         break;
5443                 case PROPERTY_WORK:
5444                         FreeBusyListType.insert(std::make_pair(*FreeBusyAddressCount, "work"));
5445                         break;
5446         }
5447         
5448         FreeBusyList.insert(std::make_pair(*FreeBusyAddressCount, PropertySeg2));
5449         
5450         if (!PropertyTokens.IsEmpty()){
5451         
5452                 FreeBusyListTokens.insert(std::make_pair(*FreeBusyAddressCount, PropertyTokens));
5453         
5454         }
5458 void ContactDataObject::ProcessKey(wxString PropertySeg1, wxString PropertySeg2, int *KeyCount){
5460         size_t intPropertyLen = PropertySeg1.Len();
5461         std::map<int, int> SplitPoints;
5462         std::map<int, int> SplitLength;
5463         std::map<int, int>::iterator SLiter;                    
5464         wxString PropertyData;
5465         wxString PropertyName;
5466         wxString PropertyValue;
5467         wxString PropertyTokens;
5468         bool FirstToken = TRUE;
5469         int intSplitsFound = 0;
5470         int intSplitSize = 0;
5471         int intPrevValue = 5;
5472         int intPref = 0;                        
5473         int intType = 0;
5474         long ListCtrlIndex;
5475         
5476         SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
5477         
5478         intPrevValue = 4;
5479         
5480         PropertyType PropType = PROPERTY_NONE;
5481         
5482         // Look for type before continuing.
5484         CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
5486         intPrevValue = 4;
5488         for (std::map<int, int>::iterator intiter = SplitPoints.begin(); 
5489         intiter != SplitPoints.end(); ++intiter){
5490         
5491                 SLiter = SplitLength.find(intiter->first);
5492         
5493                 PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
5494                 
5495                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
5496                 PropertyName = PropertyElement.GetNextToken();                          
5497                 PropertyValue = PropertyElement.GetNextToken();
5498                 
5499                 intPrevValue = intiter->second;
5500                 
5501                 // Process properties.
5502                 
5503                 size_t intPropertyValueLen = PropertyValue.Len();
5504                 
5505                 if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){
5506                         
5507                         PropertyValue.Trim();
5508                         PropertyValue.RemoveLast();
5509                         
5510                 }                               
5511                 
5512                 if (PropertyValue.Mid(0, 1) == wxT("\"")){
5513                         
5514                         PropertyValue.Remove(0, 1);
5515                         
5516                 }                               
5517                 
5518                 if (PropertyName == wxT("ALTID")){
5520                         KeyListAltID.erase(*KeyCount);
5521                         KeyListAltID.insert(std::make_pair(*KeyCount, PropertyValue));
5522                 
5523                 } else if (PropertyName == wxT("PID")){
5525                         KeyListPID.erase(*KeyCount);
5526                         KeyListPID.insert(std::make_pair(*KeyCount, PropertyValue));
5527                 
5528                 } else if (PropertyName == wxT("PREF")){
5529                         
5530                         int PriorityNumber = 0;
5531                         bool ValidNumber = TRUE;
5532                         
5533                         try{
5534                                 PriorityNumber = std::stoi(PropertyValue.ToStdString());
5535                         }
5536                         
5537                         catch(std::invalid_argument &e){
5538                                 ValidNumber = FALSE;
5539                         }
5541                         if (ValidNumber == TRUE){
5543                                 KeyListPref.erase(*KeyCount);
5544                                 KeyListPref.insert(std::make_pair(*KeyCount, PriorityNumber));
5546                         }
5547                 
5548                 } else {
5549                 
5550                         // Something else we don't know about so append
5551                         // to the tokens variable.
5552                         
5553                         if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
5554                         
5555                                 if (FirstToken == TRUE){
5556                                 
5557                                         PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue);
5558                                         FirstToken = FALSE;
5559                                 
5560                                 } else {
5561                                 
5562                                         PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue);
5563                                 
5564                                 }
5565                         
5566                         }
5567                 
5568                 }
5569         
5570         }                               
5571         
5572         intPropertyLen = PropertySeg2.Len();
5573         SplitPoints.clear();
5574         SplitLength.clear();
5575         intSplitsFound = 0;
5576         intSplitSize = 0;
5577         intPrevValue = 0;                       
5578         
5579         for (int i = 0; i <= intPropertyLen; i++){
5581                 intSplitSize++;
5582         
5583                 if (PropertySeg2.Mid(i, 1) == wxT(";") && PropertySeg2.Mid((i - 1), 1) != wxT("\\")){
5584         
5585                         intSplitsFound++;
5586                         SplitPoints.insert(std::make_pair(intSplitsFound, (i + 1)));
5587                         
5588                         if (intSplitsFound == 6){ 
5589                         
5590                                 SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1)));
5591                                 break; 
5592                                 
5593                         } else {
5594                         
5595                                 SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1)));
5596                         
5597                         }
5598                         
5599                         intSplitSize = 0;                                       
5600         
5601                 }
5603         }
5604         
5605         wxString wxSKeyURI;
5606         wxString wxSKeyMIME;
5607         wxString wxSKeyEncoding;
5608         wxString wxSKeyData;
5609         std::string base64enc;
5610         
5611         if (intSplitsFound == 0){
5612         
5613         } else {
5614         
5615                 std::map<int, int>::iterator striter;
5616         
5617                 striter = SplitLength.find(1);
5618         
5619                 wxStringTokenizer wSTDataType(PropertySeg2.Mid(0, striter->second), wxT(":"));
5620         
5621                 while (wSTDataType.HasMoreTokens() == TRUE){
5622                 
5623                         wxSKeyURI = wSTDataType.GetNextToken();
5624                         wxSKeyMIME = wSTDataType.GetNextToken();
5625                         break;
5626                 
5627                 }                       
5628         
5629                 if (wxSKeyURI == wxT("data")){
5630                 
5631                                 wxStringTokenizer wSTDataInfo(PropertySeg2.Mid((striter->second + 1)), wxT(","));                       
5632         
5633                                 while (wSTDataInfo.HasMoreTokens() == TRUE){
5634                 
5635                                 wxSKeyEncoding = wSTDataInfo.GetNextToken();
5636                                 wxSKeyData = wSTDataInfo.GetNextToken();
5637                                 break;
5638                 
5639                         }
5640                 
5641                 }
5642         
5643         }
5644         
5645         // Add the data to the General/Home/Work address variables.
5646         
5647         if (wxSKeyURI == wxT("data")){
5648                 
5649                 KeyListDataEncType.erase(*KeyCount);
5650                 KeyListKeyType.erase(*KeyCount);
5651                 KeyListDataEncType.insert(std::make_pair(*KeyCount, wxSKeyEncoding));
5652                 KeyListKeyType.insert(std::make_pair(*KeyCount, TRUE));
5653                 
5654                 KeyList.erase(*KeyCount);
5655                 KeyList.insert(std::make_pair(*KeyCount, wxSKeyData));
5656         
5657         } else {
5658                 
5659                 KeyList.erase(*KeyCount);
5660                 KeyList.insert(std::make_pair(*KeyCount, PropertySeg2));
5661         
5662         }
5663         
5664         KeyListDataType.insert(std::make_pair(*KeyCount, wxSKeyMIME));
5665                 
5666         switch (PropType){
5667                 case PROPERTY_NONE:
5668                         break;
5669                 case PROPERTY_HOME: 
5670                         KeyListType.insert(std::make_pair(*KeyCount, wxT("home")));
5671                         break;
5672                 case PROPERTY_WORK: 
5673                         KeyListType.insert(std::make_pair(*KeyCount, wxT("work")));
5674                         break;
5675         }
5677         if (!PropertyTokens.IsEmpty()){
5679                 KeyListTokens.insert(std::make_pair(*KeyCount, PropertyTokens));
5681         }
5685 void ContactDataObject::ProcessVendor(wxString PropertySeg1, wxString PropertySeg2, int *VendorCount){
5687         // Split the Vendor three ways.
5688         
5689         wxStringTokenizer wSTVendorDetails(PropertySeg1, wxT("-"));
5690         
5691         wxString wxSVNDID;
5692         wxString wxSVNDPropName;
5693         long ListCtrlIndex;                     
5695         while (wSTVendorDetails.HasMoreTokens() == TRUE){
5696         
5697                 wSTVendorDetails.GetNextToken();
5698                 wxSVNDID = wSTVendorDetails.GetNextToken();
5699                 wxSVNDPropName = wSTVendorDetails.GetNextToken();
5700                 break;
5701         
5702         }
5703         
5704         if (!wxSVNDID.IsEmpty() && !wxSVNDPropName.IsEmpty()){
5705         
5706                 // Add the data to the vendor variables.
5707         
5708                 VendorList.erase(*VendorCount);
5709                 VendorListPEN.erase(*VendorCount);
5710                 VendorListElement.erase(*VendorCount);
5711         
5712                 VendorList.insert(std::make_pair(*VendorCount, PropertySeg2));
5713                 VendorListPEN.insert(std::make_pair(*VendorCount, wxSVNDID));
5714                 VendorListElement.insert(std::make_pair(*VendorCount, wxSVNDPropName));
5715         
5716         }
5720 void ProcessIntegerValue(ContactDataObject *ContactData,
5721         std::map<int,int> *PrefPtr, 
5722         wxString *PropertyValue, 
5723         int *ItemCount){
5725         int PriorityNumber = 0; 
5726         bool ValidNumber = TRUE;
5727                         
5728         try{
5729                 PriorityNumber = std::stoi(PropertyValue->ToStdString());
5730         }
5731                         
5732         catch(std::invalid_argument &e){
5733                 ValidNumber = FALSE;
5734         }
5736         if (ValidNumber == TRUE){
5738                 PrefPtr->erase(*ItemCount);
5739                 PrefPtr->insert(std::make_pair(*ItemCount, PriorityNumber));
5741         }
5745 void SplitValues(wxString *PropertyLine, 
5746         std::map<int,int> *SplitPoints, 
5747         std::map<int,int> *SplitLength, 
5748         int intSize){
5749         
5750         size_t intPropertyLen = PropertyLine->Len();
5751         int intSplitsFound = 0;
5752         int intSplitSize = 0;
5753         int intSplitSeek = 0;
5754         
5755         for (int i = intSize; i <= intPropertyLen; i++){
5757                 intSplitSize++;
5758         
5759                 if (PropertyLine->Mid(i, 1) == wxT(";") &&
5760                     PropertyLine->Mid((i - 1), 1) != wxT("\\")){
5761            
5762                     if (intSplitsFound == 0){
5763             
5764                         SplitLength->insert(std::make_pair(intSplitsFound, (intSplitSize)));
5765           
5766                     } else {
5767            
5768                         SplitLength->insert(std::make_pair(intSplitsFound, (intSplitSize - 1)));
5769             
5770                     }
5771             
5772                     SplitPoints->insert(std::make_pair(intSplitsFound, (i + 1)));
5773             
5774                     intSplitsFound++;
5775                     intSplitSeek = i;
5776                     intSplitSize = 0;
5777             
5778                 }
5780         }
5782         if (intSplitsFound == 0){
5784                 SplitPoints->insert(std::make_pair(intSplitsFound, (8 + 1)));
5785                 SplitLength->insert(std::make_pair(intSplitsFound, intSplitSize));
5787         } else {
5789                 SplitPoints->insert(std::make_pair(intSplitsFound, (intSplitSeek + 1)));
5790                 SplitLength->insert(std::make_pair(intSplitsFound, intSplitSize));
5792         }
5796 void CheckType(wxString *PropertySeg1, 
5797         std::map<int,int> *SplitPoints, 
5798         std::map<int,int> *SplitLength, 
5799         int *intPrevValue, 
5800         PropertyType *PropType){
5801         
5802         wxString PropertyData;
5803         wxString PropertyName;
5804         wxString PropertyValue;
5805         std::map<int,int>::iterator SLiter;
5806         
5807         for (std::map<int, int>::iterator intiter = SplitPoints->begin(); 
5808         intiter != SplitPoints->end(); ++intiter){
5809         
5810                 SLiter = SplitLength->find(intiter->first);
5811         
5812                 PropertyData = PropertySeg1->Mid(*intPrevValue, (SLiter->second));
5813                 
5814                 wxStringTokenizer PropertyElement (PropertyData, wxT("="));
5815                 PropertyName = PropertyElement.GetNextToken();                          
5816                 PropertyValue = PropertyElement.GetNextToken();
5817                 
5818                 *intPrevValue = intiter->second;
5819                 
5820                 if (PropertyName == wxT("TYPE")){
5821                                 
5822                         if (PropertyValue == wxT("work")){
5823                         
5824                                 *PropType = PROPERTY_WORK;
5825                                                         
5826                         } else if (PropertyValue == wxT("home")){
5828                                 *PropType = PROPERTY_HOME;
5829                                                         
5830                         } else {
5831                         
5832                                 *PropType = PROPERTY_NONE;
5833                         
5834                         }
5835                 
5836                         return;
5837                 
5838                 }
5839         
5840         }
5841         
Xestia Software Development
Yn Maystri
© 2006 - 2019 Xestia Software Development
Software

Xestia Address Book
Xestia Calendar
Development

Xestia Gelforn
Everything else

About
News
Privacy Policy