X-Git-Url: http://Server1/repobrowser/?p=xestiaab%2F.git;a=blobdiff_plain;f=source%2Fcontacteditor%2FContactDataObject.cpp;h=b9035ed311aa7004c4d2572539450f2df62418dd;hp=b158e1904e8fc025b358f037b1ba9b94f6280bd3;hb=db50ff1e15d18ad7e4451279f91086cc4d6050c5;hpb=c1482227d7cb5d0fdc539682d0fbda830cb28001 diff --git a/source/contacteditor/ContactDataObject.cpp b/source/contacteditor/ContactDataObject.cpp index b158e19..b9035ed 100644 --- a/source/contacteditor/ContactDataObject.cpp +++ b/source/contacteditor/ContactDataObject.cpp @@ -78,8 +78,10 @@ ContactLoadStatus ContactDataObject::LoadFile(wxString Filename){ bool GenderProcessed = FALSE; bool BirthdayProcessed = FALSE; bool AnniversaryProcessed = FALSE; + bool UIDProcessed = FALSE; int ContactLineLen = 0; int QuoteBreakPoint = 0; + int SourceCount = 0; int GroupCount = 0; int FNCount = 0; int NicknameCount = 0; @@ -87,6 +89,26 @@ ContactLoadStatus ContactDataObject::LoadFile(wxString Filename){ int AddressCount = 0; int EmailCount = 0; int IMCount = 0; + int TelephoneCount = 0; + int LanguageCount = 0; + int GeographicCount = 0; + int RelatedCount = 0; + int URLCount = 0; + int TitleCount = 0; + int RoleCount = 0; + int OrganisationCount = 0; + int NoteCount = 0; + int CategoryCount = 0; + int PhotoCount = 0; + int LogoCount = 0; + int SoundCount = 0; + int CalendarCount = 0; + int CalendarAddressCount = 0; + int FreeBusyAddressCount = 0; + int KeyCount = 0; + int VendorCount = 0; + int XTokenCount = 0; + int XMLCount = 0; wxString ContactLine; wxString PropertyLine; wxString PropertySeg1; @@ -189,6 +211,21 @@ ContactLoadStatus ContactDataObject::LoadFile(wxString Filename){ ProcessKind(PropertySeg2); + } else if (Property == wxT("UID") && UIDProcessed == FALSE){ + + UIDToken = PropertySeg2; + UIDProcessed = TRUE; + + } else if (Property == wxT("SOURCE")){ + + ProcessSource(PropertySeg1, PropertySeg2, &SourceCount); + SourceCount++; + + } else if (Property == wxT("XML")){ + + ProcessXML(PropertySeg1, PropertySeg2, &XMLCount); + XMLCount++; + } else if (Property == wxT("MEMBER")){ ProcessMember(PropertySeg1, PropertySeg2, &GroupCount); @@ -235,19 +272,148 @@ ContactLoadStatus ContactDataObject::LoadFile(wxString Filename){ AddressCount++; } else if (Property == wxT("EMAIL")){ - - // See frmContactEditor-LoadEmail.cpp - + ProcessEmail(PropertySeg1, PropertySeg2, &EmailCount); EmailCount++; } else if (Property == wxT("IMPP")){ - // See frmContactEditor-LoadIM.cpp - ProcessIM(PropertySeg1, PropertySeg2, &IMCount); IMCount++; + } else if (Property == wxT("TEL")){ + + ProcessTelephone(PropertySeg1, PropertySeg2, &TelephoneCount); + TelephoneCount++; + + } else if (Property == wxT("LANG")){ + + // See frmContactEditor-LoadLanguage.cpp + + ProcessLanguage(PropertySeg1, PropertySeg2, &LanguageCount); + LanguageCount++; + + } else if (Property == wxT("GEO")){ + + // See frmContactEditor-LoadGeo.cpp + + ProcessGeographic(PropertySeg1, PropertySeg2, &GeographicCount); + GeographicCount++; + + } else if (Property == wxT("RELATED")){ + + // See fromContactEditor-LoadRelated.cpp + + ProcessRelated(PropertySeg1, PropertySeg2, &RelatedCount); + RelatedCount++; + + } else if (Property == wxT("URL")){ + + // See frmContactEditor-LoadURL.cpp + + ProcessURL(PropertySeg1, PropertySeg2, &URLCount); + URLCount++; + + } else if (Property == wxT("TITLE")) { + + // See frmContactEditor-LoadTitle.cpp + + ProcessTitle(PropertySeg1, PropertySeg2, &TitleCount); + TitleCount++; + + } else if (Property == wxT("ROLE")) { + + // See frmContactEditor-LoadTitle.cpp + + ProcessRole(PropertySeg1, PropertySeg2, &RoleCount); + RoleCount++; + + } else if (Property == wxT("ORG")) { + + // See frmContactEditor-LoadOrg.cpp + + ProcessOrganisation(PropertySeg1, PropertySeg2, &OrganisationCount); + OrganisationCount++; + + } else if (Property == wxT("NOTE")) { + + // See frmContactEditor-LoadNote.cpp + + ProcessNote(PropertySeg1, PropertySeg2, &NoteCount); + NoteCount++; + + } else if (Property == wxT("CATEGORIES")) { + + // See frmContactEditor-LoadCategory.cpp + + ProcessCategory(PropertySeg1, PropertySeg2, &CategoryCount); + CategoryCount++; + + } else if (Property == wxT("PHOTO")) { + + // See frmContactEditor-LoadPhoto.cpp + + ProcessPhoto(PropertySeg1, PropertySeg2, &PhotoCount); + PhotoCount++; + + } else if (Property == wxT("LOGO")) { + + // See frmContactEditor-LoadPhoto.cpp + + ProcessLogo(PropertySeg1, PropertySeg2, &LogoCount); + LogoCount++; + + } else if (Property == wxT("LOGO")) { + + // See frmContactEditor-LoadPhoto.cpp + + ProcessLogo(PropertySeg1, PropertySeg2, &LogoCount); + LogoCount++; + + } else if (Property == wxT("SOUND")) { + + // See frmContactEditor-LoadSound.cpp + + ProcessSound(PropertySeg1, PropertySeg2, &SoundCount); + SoundCount++; + + } else if (Property == wxT("CALURI")){ + + // See frmContactEditor-LoadCalendar.cpp + + ProcessCalendarURI(PropertySeg1, PropertySeg2, &CalendarCount); + CalendarCount++; + + } else if (Property == wxT("CALADRURI")){ + + ProcessCalendarAddressURI(PropertySeg1, PropertySeg2, &CalendarAddressCount); + CalendarAddressCount++; + + } else if (Property == wxT("FBURL")){ + + // See frmContactEditor-LoadCalendar.cpp + + ProcessCalendarFreeBusy(PropertySeg1, PropertySeg2, &FreeBusyAddressCount); + FreeBusyAddressCount++; + + } else if (Property == wxT("KEY")){ + + // See frmContactEditor-LoadKey.cpp + + ProcessKey(PropertySeg1, PropertySeg2, &KeyCount); + KeyCount++; + + } else if (Property.Mid(0, 3) == wxT("VND")){ + + ProcessVendor(PropertySeg1, PropertySeg2, &VendorCount); + VendorCount++; + + } else if (Property.Mid(0, 2) == wxT("X-")){ + + XTokenList.insert(std::make_pair(XTokenCount, PropertySeg2)); + XTokenListTokens.insert(std::make_pair(XTokenCount, PropertySeg1.Mid(2))); + XTokenCount++; + } } @@ -281,6 +447,206 @@ void ContactDataObject::ProcessKind(wxString KindType){ } +void ContactDataObject::ProcessSource(wxString PropertySeg1, wxString PropertySeg2, int *SourceCount){ + + size_t intPropertyLen = PropertySeg1.Len(); + std::map SplitPoints; + std::map SplitLength; + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + bool FirstToken = TRUE; + int intSplitsFound = 0; + int intSplitSize = 0; + int intPrevValue = 8; + int intPref = 0; + int intType = 0; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 7; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType); + + intPrevValue = 7; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + // Process properties. + + size_t intPropertyValueLen = PropertyValue.Len(); + + if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){ + + PropertyValue.Trim(); + PropertyValue.RemoveLast(); + + } + + if (PropertyValue.Mid(0, 1) == wxT("\"")){ + + PropertyValue.Remove(0, 1); + + } + + CaptureString(&PropertyValue, FALSE); + + if (PropertyName == wxT("ALTID")){ + + SourceListAltID.erase(*SourceCount); + SourceListAltID.insert(std::make_pair(*SourceCount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + SourceListPID.erase(*SourceCount); + SourceListPID.insert(std::make_pair(*SourceCount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + SourceListPref.erase(*SourceCount); + SourceListPref.insert(std::make_pair(*SourceCount, PriorityNumber)); + + } + + } else if (PropertyName == wxT("MEDIATYPE")){ + + SourceListMediatype.erase(*SourceCount); + SourceListMediatype.insert(std::make_pair(*SourceCount, PropertyValue)); + + } else { + + // Something else we don't know about so append + // to the tokens variable. + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + intPropertyLen = PropertySeg2.Len(); + SplitPoints.clear(); + SplitLength.clear(); + intSplitsFound = 0; + intSplitSize = 0; + intPrevValue = 0; + + CaptureString(&PropertySeg2, FALSE); + + // Add the data to the General/Home/Work address variables. + + switch(PropType){ + case PROPERTY_NONE: + break; + case PROPERTY_HOME: + SourceListType.insert(std::make_pair(*SourceCount, "home")); + break; + case PROPERTY_WORK: + SourceListType.insert(std::make_pair(*SourceCount, "work")); + break; + } + + SourceList.insert(std::make_pair(*SourceCount, PropertySeg2)); + + if (!PropertyTokens.IsEmpty()){ + + SourceListTokens.insert(std::make_pair(*SourceCount, PropertyTokens)); + + } + +} + +void ContactDataObject::ProcessXML(wxString PropertySeg1, wxString PropertySeg2, int *XMLCount){ + + std::map SplitPoints; + std::map SplitLength; + + int intPrevValue = 5; + int intPref = 0; + int intType = 0; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 4; + + wxString PropertyName; + wxString PropertyValue; + wxString PropertyData; + wxString PropertyTokens; + std::map::iterator SLiter; + bool FirstToken = TRUE; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + CaptureString(&PropertyValue, FALSE); + + if (PropertyName == wxT("ALTID")){ + + XMLListAltID.erase(*XMLCount); + XMLListAltID.insert(std::make_pair(*XMLCount, PropertyValue)); + + } + + } + + XMLList.insert(std::make_pair(*XMLCount, PropertySeg2)); + +} + void ContactDataObject::ProcessMember(wxString PropertySeg1, wxString PropertySeg2, int *GroupCount){ std::map SplitPoints; @@ -1936,7 +2302,3403 @@ void ContactDataObject::ProcessIM(wxString PropertySeg1, wxString PropertySeg2, IMListTokens->insert(std::make_pair(*IMCount, PropertyTokens)); - } + } + +} + +void ContactDataObject::ProcessTelephone(wxString PropertySeg1, wxString PropertySeg2, int *TelephoneCount){ + + std::map SplitPoints; + std::map SplitLength; + std::map::iterator SLiter; + + int intPref = 0; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + wxString TelTypeUI; + wxString TelTypeDetail; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + + std::map TypeSplitPoints; + std::map TypeSplitLength; + std::map::iterator TSLiter; + + int intSplitSize = 0; + int intSplitsFound = 0; + int intSplitPoint = 0; + int intType = 0; + int intPrevValue = 5; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 4; + + // Look for type before continuing. + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + if (PropertyName == wxT("TYPE")){ + + // Process each value in type and translate each + // part. + + // Strip out the quotes if they are there. + + size_t intPropertyValueLen = PropertyValue.Len(); + + if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){ + + PropertyValue.Trim(); + PropertyValue.RemoveLast(); + + } + + if (PropertyValue.Mid(0, 1) == wxT("\"")){ + + PropertyValue.Remove(0, 1); + + } + + TelTypeDetail = PropertyValue; + + intSplitSize = 0; + intSplitsFound = 0; + intSplitPoint = 0; + + for (int i = 0; i <= intPropertyValueLen; i++){ + + intSplitSize++; + + if (PropertyValue.Mid(i, 1) == wxT(",") && PropertyValue.Mid((i - 1), 1) != wxT("\\")){ + + if (intSplitsFound == 0){ + + TypeSplitPoints.insert(std::make_pair(intSplitsFound, intSplitPoint)); + TypeSplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1))); + + } else { + + TypeSplitPoints.insert(std::make_pair(intSplitsFound, intSplitPoint)); + TypeSplitLength.insert(std::make_pair(intSplitsFound, intSplitSize)); + + } + + intSplitsFound++; + i++; + intSplitPoint = i; + intSplitSize = 0; + + } + + } + + TypeSplitPoints.insert(std::make_pair(intSplitsFound, intSplitPoint)); + TypeSplitLength.insert(std::make_pair(intSplitsFound, intSplitSize)); + + int intTypeSeek = 0; + + for (std::map::iterator typeiter = TypeSplitPoints.begin(); + typeiter != TypeSplitPoints.end(); ++typeiter){ + + wxString TypePropertyName; + + TSLiter = TypeSplitLength.find(typeiter->first); + + TypePropertyName = PropertyValue.Mid(typeiter->second, TSLiter->second); + + if (intTypeSeek == 0){ + + + } else { + + TelTypeUI.Append(wxT(",")); + + } + + if (TypePropertyName == wxT("home")){ + + PropType = PROPERTY_HOME; + + } else if (TypePropertyName == wxT("work")){ + + PropType = PROPERTY_WORK; + + } + + + if (TypePropertyName == wxT("text")){ + + TelTypeUI.Append(_("text")); + intTypeSeek++; + + } else if (TypePropertyName == wxT("voice")){ + + TelTypeUI.Append(_("voice")); + intTypeSeek++; + + } else if (TypePropertyName == wxT("fax")){ + + TelTypeUI.Append(_("fax")); + intTypeSeek++; + + } else if (TypePropertyName == wxT("cell")){ + + TelTypeUI.Append(_("mobile")); + intTypeSeek++; + + } else if (TypePropertyName == wxT("video")){ + + TelTypeUI.Append(_("video")); + intTypeSeek++; + + } else if (TypePropertyName == wxT("pager")){ + + TelTypeUI.Append(_("pager")); + intTypeSeek++; + + } else if (TypePropertyName == wxT("textphone")){ + + TelTypeUI.Append(_("textphone")); + intTypeSeek++; + + } + + } + + } + + } + + std::map *TelephoneList = NULL; + std::map *TelephoneListType = NULL; + std::map *TelephoneListAltID = NULL; + std::map *TelephoneListPID = NULL; + std::map *TelephoneListTokens = NULL; + std::map *TelephoneListTypeInfo = NULL; + std::map *TelephoneListPref = NULL; + + switch(PropType){ + case PROPERTY_NONE: + TelephoneList = &GeneralTelephoneList; + TelephoneListType = &GeneralTelephoneListType; + TelephoneListAltID = &GeneralTelephoneListAltID; + TelephoneListPID = &GeneralTelephoneListPID; + TelephoneListTokens = &GeneralTelephoneListTokens; + TelephoneListTypeInfo = &GeneralTelephoneListTypeInfo; + TelephoneListPref = &GeneralTelephoneListPref; + break; + case PROPERTY_HOME: + TelephoneList = &HomeTelephoneList; + TelephoneListType = &HomeTelephoneListType; + TelephoneListAltID = &HomeTelephoneListAltID; + TelephoneListPID = &HomeTelephoneListPID; + TelephoneListTokens = &HomeTelephoneListTokens; + TelephoneListTypeInfo = &HomeTelephoneListTypeInfo; + TelephoneListPref = &HomeTelephoneListPref; + break; + case PROPERTY_WORK: + TelephoneList = &BusinessTelephoneList; + TelephoneListType = &BusinessTelephoneListType; + TelephoneListAltID = &BusinessTelephoneListAltID; + TelephoneListPID = &BusinessTelephoneListPID; + TelephoneListTokens = &BusinessTelephoneListTokens; + TelephoneListTypeInfo = &BusinessTelephoneListTypeInfo; + TelephoneListPref = &BusinessTelephoneListPref; + break; + } + + // Process the properties. + + bool FirstToken = TRUE; + + intPrevValue = 5; + SplitPoints.clear(); + SplitLength.clear(); + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 4; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + CaptureString(&PropertyValue, FALSE); + + // Process properties. + + if (PropertyName == wxT("ALTID")){ + + TelephoneListAltID->erase(*TelephoneCount); + TelephoneListAltID->insert(std::make_pair(*TelephoneCount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + TelephoneListPID->erase(*TelephoneCount); + TelephoneListPID->insert(std::make_pair(*TelephoneCount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + TelephoneListPref->erase(*TelephoneCount); + TelephoneListPref->insert(std::make_pair(*TelephoneCount, PriorityNumber)); + + } + + } else { + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + TelephoneList->insert(std::make_pair(*TelephoneCount, PropertySeg2)); + TelephoneListTypeInfo->insert(std::make_pair(*TelephoneCount, TelTypeUI)); + + // Add the name token data. + + if (!PropertyTokens.IsEmpty()){ + + TelephoneListTokens->insert(std::make_pair(*TelephoneCount, PropertyTokens)); + + } + +} + +void ContactDataObject::ProcessLanguage(wxString PropertySeg1, wxString PropertySeg2, int *LanguageCount){ + + std::map SplitPoints; + std::map SplitLength; + + int intPrevValue = 6; + int intPref = 0; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 5; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType); + + std::map *LanguageList = NULL; + std::map *LanguageListType = NULL; + std::map *LanguageListAltID = NULL; + std::map *LanguageListPID = NULL; + std::map *LanguageListTokens = NULL; + std::map *LanguageListPref = NULL; + + switch(PropType){ + case PROPERTY_NONE: + LanguageList = &GeneralLanguageList; + LanguageListType = &GeneralLanguageListType; + LanguageListAltID = &GeneralLanguageListAltID; + LanguageListPID = &GeneralLanguageListPID; + LanguageListTokens = &GeneralLanguageListTokens; + LanguageListPref = &GeneralLanguageListPref; + break; + case PROPERTY_HOME: + LanguageList = &HomeLanguageList; + LanguageListType = &HomeLanguageListType; + LanguageListAltID = &HomeLanguageListAltID; + LanguageListPID = &HomeLanguageListPID; + LanguageListTokens = &HomeLanguageListTokens; + LanguageListPref = &HomeLanguageListPref; + break; + case PROPERTY_WORK: + LanguageList = &BusinessLanguageList; + LanguageListType = &BusinessLanguageListType; + LanguageListAltID = &BusinessLanguageListAltID; + LanguageListPID = &BusinessLanguageListPID; + LanguageListTokens = &BusinessLanguageListTokens; + LanguageListPref = &BusinessLanguageListPref; + break; + } + + intPrevValue = 5; + + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + bool FirstToken = TRUE; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + CaptureString(&PropertyValue, FALSE); + + // Process properties. + + if (PropertyName == wxT("ALTID")){ + + LanguageListAltID->erase(*LanguageCount); + LanguageListAltID->insert(std::make_pair(*LanguageCount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + LanguageListPID->erase(*LanguageCount); + LanguageListPID->insert(std::make_pair(*LanguageCount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + LanguageListPref->erase(*LanguageCount); + LanguageListPref->insert(std::make_pair(*LanguageCount, PriorityNumber)); + + } + + } else { + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + LanguageList->insert(std::make_pair(*LanguageCount, PropertySeg2)); + + // Add the name token data. + + if (!PropertyTokens.IsEmpty()){ + + LanguageListTokens->insert(std::make_pair(*LanguageCount, PropertyTokens)); + + } + +} + +void ContactDataObject::ProcessGeographic(wxString PropertySeg1, wxString PropertySeg2, int *GeographicCount){ + + std::map SplitPoints; + std::map SplitLength; + + int intPrevValue = 5; + int intPref = 0; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 4; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType); + + std::map *GeopositionList = NULL; + std::map *GeopositionListType = NULL; + std::map *GeopositionListAltID = NULL; + std::map *GeopositionListPID = NULL; + std::map *GeopositionListTokens = NULL; + std::map *GeopositionListMediatype = NULL; + std::map *GeopositionListPref = NULL; + + switch(PropType){ + case PROPERTY_NONE: + GeopositionList = &GeneralGeographyList; + GeopositionListType = &GeneralGeographyListType; + GeopositionListAltID = &GeneralGeographyListAltID; + GeopositionListPID = &GeneralGeographyListPID; + GeopositionListTokens = &GeneralGeographyListTokens; + GeopositionListMediatype = &GeneralGeographyListMediatype; + GeopositionListPref = &GeneralGeographyListPref; + break; + case PROPERTY_HOME: + GeopositionList = &HomeGeographyList; + GeopositionListType = &HomeGeographyListType; + GeopositionListAltID = &HomeGeographyListAltID; + GeopositionListPID = &HomeGeographyListPID; + GeopositionListTokens = &HomeGeographyListTokens; + GeopositionListMediatype = &HomeGeographyListMediatype; + GeopositionListPref = &HomeGeographyListPref; + break; + case PROPERTY_WORK: + GeopositionList = &BusinessGeographyList; + GeopositionListType = &BusinessGeographyListType; + GeopositionListAltID = &BusinessGeographyListAltID; + GeopositionListPID = &BusinessGeographyListPID; + GeopositionListTokens = &BusinessGeographyListTokens; + GeopositionListMediatype = &BusinessGeographyListMediatype; + GeopositionListPref = &BusinessGeographyListPref; + break; + } + + intPrevValue = 4; + + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + bool FirstToken = TRUE; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + CaptureString(&PropertyValue, FALSE); + + // Process properties. + + if (PropertyName == wxT("ALTID")){ + + GeopositionListAltID->erase(*GeographicCount); + GeopositionListAltID->insert(std::make_pair(*GeographicCount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + GeopositionListPID->erase(*GeographicCount); + GeopositionListPID->insert(std::make_pair(*GeographicCount, PropertyValue)); + + } else if (PropertyName == wxT("MEDIATYPE")){ + + GeopositionListMediatype->erase(*GeographicCount); + GeopositionListMediatype->insert(std::make_pair(*GeographicCount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + GeopositionListPref->erase(*GeographicCount); + GeopositionListPref->insert(std::make_pair(*GeographicCount, PriorityNumber)); + + } + + } else { + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + GeopositionList->insert(std::make_pair(*GeographicCount, PropertySeg2)); + + // Add the name token data. + + if (!PropertyTokens.IsEmpty()){ + + GeopositionListTokens->insert(std::make_pair(*GeographicCount, PropertyTokens)); + + } + +} + +void ContactDataObject::ProcessRelated(wxString PropertySeg1, wxString PropertySeg2, int *RelatedCount){ + + size_t intPropertyLen = PropertySeg1.Len(); + std::map SplitPoints; + std::map SplitLength; + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + wxString RelatedType; + wxString RelatedTypeOriginal; + wxString RelatedName; + bool FirstToken = TRUE; + int intSplitsFound = 0; + int intSplitSize = 0; + int intPrevValue = 9; + int intPref = 0; + long ListCtrlIndex; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 8; + + // Look for type before continuing. + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + // Process these. + + RelatedTypeOriginal = PropertyValue; + + if (PropertyName == wxT("TYPE")){ + + if (PropertyValue == wxT("contact")){ + + RelatedType = _("Contact"); + + } else if (PropertyValue == wxT("acquaintance")){ + + RelatedType = _("Acquaintance"); + + } else if (PropertyValue == wxT("friend")){ + + RelatedType = _("Friend"); + + } else if (PropertyValue == wxT("met")){ + + RelatedType = _("Met"); + + } else if (PropertyValue == wxT("co-worker")){ + + RelatedType = _("Co-worker"); + + } else if (PropertyValue == wxT("colleague")){ + + RelatedType = _("Colleague"); + + } else if (PropertyValue == wxT("co-resident")){ + + RelatedType = _("Co-resident"); + + } else if (PropertyValue == wxT("neighbor")){ + + RelatedType = _("Neighbour"); + + } else if (PropertyValue == wxT("child")){ + + RelatedType = _("Child"); + + } else if (PropertyValue == wxT("parent")){ + + RelatedType = _("Parent"); + + } else if (PropertyValue == wxT("sibling")){ + + RelatedType = _("Sibling"); + + } else if (PropertyValue == wxT("spouse")){ + + RelatedType = _("Spouse"); + + } else if (PropertyValue == wxT("kin")){ + + RelatedType = _("Kin"); + + } else if (PropertyValue == wxT("muse")){ + + RelatedType = _("Muse"); + + } else if (PropertyValue == wxT("crush")){ + + RelatedType = _("Crush"); + + } else if (PropertyValue == wxT("date")){ + + RelatedType = _("Date"); + + } else if (PropertyValue == wxT("sweetheart")){ + + RelatedType = _("Sweetheart"); + + } else if (PropertyValue == wxT("me")){ + + RelatedType = _("Me"); + + } else if (PropertyValue == wxT("agent")){ + + RelatedType = _("Agent"); + + } else if (PropertyValue == wxT("emergency")){ + + RelatedType = _("Emergency"); + + } else { + + RelatedType = PropertyValue; + + } + + } + + } + + intPrevValue = 8; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + // Process properties. + + size_t intPropertyValueLen = PropertyValue.Len(); + + if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){ + + PropertyValue.Trim(); + PropertyValue.RemoveLast(); + + } + + if (PropertyValue.Mid(0, 1) == wxT("\"")){ + + PropertyValue.Remove(0, 1); + + } + + CaptureString(&PropertyValue, FALSE); + + if (PropertyName == wxT("ALTID")){ + + GeneralRelatedListAltID.erase(*RelatedCount); + GeneralRelatedListAltID.insert(std::make_pair(*RelatedCount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + GeneralRelatedListPID.erase(*RelatedCount); + GeneralRelatedListPID.insert(std::make_pair(*RelatedCount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + GeneralRelatedListPref.erase(*RelatedCount); + GeneralRelatedListPref.insert(std::make_pair(*RelatedCount, PriorityNumber)); + + } + + } else if (PropertyName == wxT("LANGUAGE")){ + + GeneralRelatedListLanguage.erase(*RelatedCount); + GeneralRelatedListLanguage.insert(std::make_pair(*RelatedCount, PropertyValue)); + + } else if (PropertyName != wxT("TYPE")) { + + // Something else we don't know about so append + // to the tokens variable. + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + // Add the data to the General/Home/Work address variables. + + GeneralRelatedList.erase(*RelatedCount); + GeneralRelatedListRelType.erase(*RelatedCount); + GeneralRelatedListType.erase(*RelatedCount); + GeneralRelatedListTokens.erase(*RelatedCount); + GeneralRelatedList.insert(std::make_pair(*RelatedCount, PropertySeg2)); + GeneralRelatedListRelType.insert(std::make_pair(*RelatedCount, RelatedType)); + GeneralRelatedListType.insert(std::make_pair(*RelatedCount, RelatedType)); + GeneralRelatedListTokens.insert(std::make_pair(*RelatedCount, PropertyTokens)); + +} + +void ContactDataObject::ProcessURL(wxString PropertySeg1, wxString PropertySeg2, int *URLCount){ + + std::map SplitPoints; + std::map SplitLength; + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + bool FirstToken = TRUE; + int intPrevValue = 5; + int intPref = 0; + int intType = 0; + long ListCtrlIndex; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 4; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType); + + // Setup the pointers. + + std::map *WebsiteList = NULL; + std::map *WebsiteListAltID = NULL; + std::map *WebsiteListPID = NULL; + std::map *WebsiteListType = NULL; + std::map *WebsiteListTokens = NULL; + std::map *WebsiteListMediatype = NULL; + std::map *WebsiteListPref = NULL; + + // Setup blank lines for later on. + + switch(PropType){ + case PROPERTY_NONE: + WebsiteList = &GeneralWebsiteList; + WebsiteListType = &GeneralWebsiteListType; + WebsiteListAltID = &GeneralWebsiteListAltID; + WebsiteListPID = &GeneralWebsiteListPID; + WebsiteListTokens = &GeneralWebsiteListTokens; + WebsiteListMediatype = &GeneralWebsiteListMediatype; + WebsiteListPref = &GeneralWebsiteListPref; + break; + case PROPERTY_HOME: + WebsiteList = &HomeWebsiteList; + WebsiteListType = &HomeWebsiteListType; + WebsiteListAltID = &HomeWebsiteListAltID; + WebsiteListPID = &HomeWebsiteListPID; + WebsiteListTokens = &HomeWebsiteListTokens; + WebsiteListMediatype = &HomeWebsiteListMediatype; + WebsiteListPref = &HomeWebsiteListPref; + break; + case PROPERTY_WORK: + WebsiteList = &BusinessWebsiteList; + WebsiteListType = &BusinessWebsiteListType; + WebsiteListAltID = &BusinessWebsiteListAltID; + WebsiteListPID = &BusinessWebsiteListPID; + WebsiteListTokens = &BusinessWebsiteListTokens; + WebsiteListMediatype = &BusinessWebsiteListMediatype; + WebsiteListPref = &BusinessWebsiteListPref; + break; + } + + intPrevValue = 4; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + // Process properties. + + size_t intPropertyValueLen = PropertyValue.Len(); + + if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){ + + PropertyValue.Trim(); + PropertyValue.RemoveLast(); + + } + + if (PropertyValue.Mid(0, 1) == wxT("\"")){ + + PropertyValue.Remove(0, 1); + + } + + CaptureString(&PropertyValue, FALSE); + + if (PropertyName == wxT("ALTID")){ + + WebsiteListAltID->erase(*URLCount); + WebsiteListAltID->insert(std::make_pair(*URLCount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + WebsiteListPID->erase(*URLCount); + WebsiteListPID->insert(std::make_pair(*URLCount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + WebsiteListPref->erase(*URLCount); + WebsiteListPref->insert(std::make_pair(*URLCount, PriorityNumber)); + + } + + } else if (PropertyName == wxT("MEDIATYPE")){ + + WebsiteListMediatype->erase(*URLCount); + WebsiteListMediatype->insert(std::make_pair(*URLCount, PropertyValue)); + + } else { + + // Something else we don't know about so append + // to the tokens variable. + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + // Add the data to the General/Home/Work address variables. + + CaptureString(&PropertySeg2, FALSE); + + WebsiteList->insert(std::make_pair(*URLCount, PropertySeg2)); + + if (!PropertyTokens.IsEmpty()){ + + WebsiteListTokens->insert(std::make_pair(*URLCount, PropertyTokens)); + + } + +} + +void ContactDataObject::ProcessTitle(wxString PropertySeg1, wxString PropertySeg2, int *TitleCount){ + + std::map SplitPoints; + std::map SplitLength; + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + bool FirstToken = TRUE; + int intPrevValue = 7; + int intPref = 0; + int intType = 0; + long ListCtrlIndex; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 6; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType); + + // Setup the pointers. + + std::map *TitleList = NULL; + std::map *TitleListAltID = NULL; + std::map *TitleListPID = NULL; + std::map *TitleListType = NULL; + std::map *TitleListTokens = NULL; + std::map *TitleListLanguage = NULL; + std::map *TitleListPref = NULL; + + // Setup blank lines for later on. + + switch(PropType){ + case PROPERTY_NONE: + TitleList = &GeneralTitleList; + TitleListType = &GeneralTitleListType; + TitleListAltID = &GeneralTitleListAltID; + TitleListPID = &GeneralTitleListPID; + TitleListTokens = &GeneralTitleListTokens; + TitleListLanguage = &GeneralTitleListLanguage; + TitleListPref = &GeneralTitleListPref; + break; + case PROPERTY_HOME: + TitleList = &HomeTitleList; + TitleListType = &HomeTitleListType; + TitleListAltID = &HomeTitleListAltID; + TitleListPID = &HomeTitleListPID; + TitleListTokens = &HomeTitleListTokens; + TitleListLanguage = &HomeTitleListLanguage; + TitleListPref = &HomeTitleListPref; + break; + case PROPERTY_WORK: + TitleList = &BusinessTitleList; + TitleListType = &BusinessTitleListType; + TitleListAltID = &BusinessTitleListAltID; + TitleListPID = &BusinessTitleListPID; + TitleListTokens = &BusinessTitleListTokens; + TitleListLanguage = &BusinessTitleListLanguage; + TitleListPref = &BusinessTitleListPref; + break; + } + + intPrevValue = 6; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + // Process properties. + + size_t intPropertyValueLen = PropertyValue.Len(); + + if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){ + + PropertyValue.Trim(); + PropertyValue.RemoveLast(); + + } + + if (PropertyValue.Mid(0, 1) == wxT("\"")){ + + PropertyValue.Remove(0, 1); + + } + + CaptureString(&PropertyValue, FALSE); + + if (PropertyName == wxT("ALTID")){ + + TitleListAltID->erase(*TitleCount); + TitleListAltID->insert(std::make_pair(*TitleCount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + TitleListPID->erase(*TitleCount); + TitleListPID->insert(std::make_pair(*TitleCount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + TitleListPref->erase(*TitleCount); + TitleListPref->insert(std::make_pair(*TitleCount, PriorityNumber)); + + } + + } else if (PropertyName == wxT("LANGUAGE")){ + + TitleListLanguage->erase(*TitleCount); + TitleListLanguage->insert(std::make_pair(*TitleCount, PropertyValue)); + + } else { + + // Something else we don't know about so append + // to the tokens variable. + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + // Add the data to the General/Home/Work address variables. + + CaptureString(&PropertySeg2, FALSE); + + TitleList->insert(std::make_pair(*TitleCount, PropertySeg2)); + + if (!PropertyTokens.IsEmpty()){ + + TitleListTokens->insert(std::make_pair(*TitleCount, PropertyTokens)); + + } + +} + +void ContactDataObject::ProcessRole(wxString PropertySeg1, wxString PropertySeg2, int *RoleCount){ + + std::map SplitPoints; + std::map SplitLength; + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + bool FirstToken = TRUE; + int intPrevValue = 6; + int intPref = 0; + int intType = 0; + long ListCtrlIndex; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 5; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType); + + // Setup the pointers. + + std::map *RoleList = NULL; + std::map *RoleListAltID = NULL; + std::map *RoleListPID = NULL; + std::map *RoleListType = NULL; + std::map *RoleListTokens = NULL; + std::map *RoleListLanguage = NULL; + std::map *RoleListPref = NULL; + + // Setup blank lines for later on. + + switch(PropType){ + case PROPERTY_NONE: + RoleList = &GeneralRoleList; + RoleListType = &GeneralRoleListType; + RoleListAltID = &GeneralRoleListAltID; + RoleListPID = &GeneralRoleListPID; + RoleListTokens = &GeneralRoleListTokens; + RoleListLanguage = &GeneralRoleListLanguage; + RoleListPref = &GeneralRoleListPref; + break; + case PROPERTY_HOME: + RoleList = &HomeRoleList; + RoleListType = &HomeRoleListType; + RoleListAltID = &HomeRoleListAltID; + RoleListPID = &HomeRoleListPID; + RoleListTokens = &HomeRoleListTokens; + RoleListLanguage = &HomeRoleListLanguage; + RoleListPref = &HomeRoleListPref; + break; + case PROPERTY_WORK: + RoleList = &BusinessRoleList; + RoleListType = &BusinessRoleListType; + RoleListAltID = &BusinessRoleListAltID; + RoleListPID = &BusinessRoleListPID; + RoleListTokens = &BusinessRoleListTokens; + RoleListLanguage = &BusinessRoleListLanguage; + RoleListPref = &BusinessRoleListPref; + break; + } + + intPrevValue = 5; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + // Process properties. + + size_t intPropertyValueLen = PropertyValue.Len(); + + if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){ + + PropertyValue.Trim(); + PropertyValue.RemoveLast(); + + } + + if (PropertyValue.Mid(0, 1) == wxT("\"")){ + + PropertyValue.Remove(0, 1); + + } + + CaptureString(&PropertyValue, FALSE); + + if (PropertyName == wxT("ALTID")){ + + RoleListAltID->erase(*RoleCount); + RoleListAltID->insert(std::make_pair(*RoleCount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + RoleListPID->erase(*RoleCount); + RoleListPID->insert(std::make_pair(*RoleCount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + RoleListPref->erase(*RoleCount); + RoleListPref->insert(std::make_pair(*RoleCount, PriorityNumber)); + + } + + } else if (PropertyName == wxT("LANGUAGE")){ + + RoleListLanguage->erase(*RoleCount); + RoleListLanguage->insert(std::make_pair(*RoleCount, PropertyValue)); + + } else { + + // Something else we don't know about so append + // to the tokens variable. + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + // Add the data to the General/Home/Work address variables. + + CaptureString(&PropertySeg2, FALSE); + + RoleList->insert(std::make_pair(*RoleCount, PropertySeg2)); + + if (!PropertyTokens.IsEmpty()){ + + RoleListTokens->insert(std::make_pair(*RoleCount, PropertyTokens)); + + } + +} + +void ContactDataObject::ProcessOrganisation(wxString PropertySeg1, wxString PropertySeg2, int *OrganisationCount){ + + std::map SplitPoints; + std::map SplitLength; + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + bool FirstToken = TRUE; + int intPrevValue = 5; + int intPref = 0; + int intType = 0; + long ListCtrlIndex; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 4; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType); + + // Setup the pointers. + + std::map *OrganisationsList = NULL; + std::map *OrganisationsListAltID = NULL; + std::map *OrganisationsListPID = NULL; + std::map *OrganisationsListType = NULL; + std::map *OrganisationsListTokens = NULL; + std::map *OrganisationsListLanguage = NULL; + std::map *OrganisationsListSortAs = NULL; + std::map *OrganisationsListPref = NULL; + + // Setup blank lines for later on. + + switch(PropType){ + case PROPERTY_NONE: + OrganisationsList = &GeneralOrganisationsList; + OrganisationsListType = &GeneralOrganisationsListType; + OrganisationsListAltID = &GeneralOrganisationsListAltID; + OrganisationsListPID = &GeneralOrganisationsListPID; + OrganisationsListTokens = &GeneralOrganisationsListTokens; + OrganisationsListLanguage = &GeneralOrganisationsListLanguage; + OrganisationsListSortAs = &GeneralOrganisationsListSortAs; + OrganisationsListPref = &GeneralOrganisationsListPref; + break; + case PROPERTY_HOME: + OrganisationsList = &HomeOrganisationsList; + OrganisationsListType = &HomeOrganisationsListType; + OrganisationsListAltID = &HomeOrganisationsListAltID; + OrganisationsListPID = &HomeOrganisationsListPID; + OrganisationsListTokens = &HomeOrganisationsListTokens; + OrganisationsListLanguage = &HomeOrganisationsListLanguage; + OrganisationsListSortAs = &HomeOrganisationsListSortAs; + OrganisationsListPref = &HomeOrganisationsListPref; + break; + case PROPERTY_WORK: + OrganisationsList = &BusinessOrganisationsList; + OrganisationsListType = &BusinessOrganisationsListType; + OrganisationsListAltID = &BusinessOrganisationsListAltID; + OrganisationsListPID = &BusinessOrganisationsListPID; + OrganisationsListTokens = &BusinessOrganisationsListTokens; + OrganisationsListLanguage = &BusinessOrganisationsListLanguage; + OrganisationsListSortAs = &BusinessOrganisationsListSortAs; + OrganisationsListPref = &BusinessOrganisationsListPref; + break; + } + + intPrevValue = 4; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + // Process properties. + + size_t intPropertyValueLen = PropertyValue.Len(); + + if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){ + + PropertyValue.Trim(); + PropertyValue.RemoveLast(); + + } + + if (PropertyValue.Mid(0, 1) == wxT("\"")){ + + PropertyValue.Remove(0, 1); + + } + + CaptureString(&PropertyValue, FALSE); + + if (PropertyName == wxT("ALTID")){ + + OrganisationsListAltID->erase(*OrganisationCount); + OrganisationsListAltID->insert(std::make_pair(*OrganisationCount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + OrganisationsListPID->erase(*OrganisationCount); + OrganisationsListPID->insert(std::make_pair(*OrganisationCount, PropertyValue)); + + } else if (PropertyName == wxT("SORT-AS")){ + + OrganisationsListSortAs->erase(*OrganisationCount); + OrganisationsListSortAs->insert(std::make_pair(*OrganisationCount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + OrganisationsListPref->erase(*OrganisationCount); + OrganisationsListPref->insert(std::make_pair(*OrganisationCount, PriorityNumber)); + + } + + } else if (PropertyName == wxT("LANGUAGE")){ + + OrganisationsListLanguage->erase(*OrganisationCount); + OrganisationsListLanguage->insert(std::make_pair(*OrganisationCount, PropertyValue)); + + } else { + + // Something else we don't know about so append + // to the tokens variable. + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + // Add the data to the General/Home/Work address variables. + + CaptureString(&PropertySeg2, FALSE); + + OrganisationsList->insert(std::make_pair(*OrganisationCount, PropertySeg2)); + + if (!PropertyTokens.IsEmpty()){ + + OrganisationsListTokens->insert(std::make_pair(*OrganisationCount, PropertyTokens)); + + } + +} + +void ContactDataObject::ProcessNote(wxString PropertySeg1, wxString PropertySeg2, int *NoteCount){ + + std::map SplitPoints; + std::map SplitLength; + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + bool FirstToken = TRUE; + int intPrevValue = 6; + int intPref = 0; + int intType = 0; + long ListCtrlIndex; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 5; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType); + + // Setup the pointers. + + std::map *NoteList = NULL; + std::map *NoteListAltID = NULL; + std::map *NoteListPID = NULL; + std::map *NoteListType = NULL; + std::map *NoteListTokens = NULL; + std::map *NoteListLanguage = NULL; + std::map *NoteListPref = NULL; + + // Setup blank lines for later on. + + switch(PropType){ + case PROPERTY_NONE: + NoteList = &GeneralNoteList; + NoteListType = &GeneralNoteListType; + NoteListAltID = &GeneralNoteListAltID; + NoteListPID = &GeneralNoteListPID; + NoteListTokens = &GeneralNoteListTokens; + NoteListLanguage = &GeneralNoteListLanguage; + NoteListPref = &GeneralNoteListPref; + break; + case PROPERTY_HOME: + NoteList = &HomeNoteList; + NoteListType = &HomeNoteListType; + NoteListAltID = &HomeNoteListAltID; + NoteListPID = &HomeNoteListPID; + NoteListTokens = &HomeNoteListTokens; + NoteListLanguage = &HomeNoteListLanguage; + NoteListPref = &HomeNoteListPref; + break; + case PROPERTY_WORK: + NoteList = &BusinessNoteList; + NoteListType = &BusinessNoteListType; + NoteListAltID = &BusinessNoteListAltID; + NoteListPID = &BusinessNoteListPID; + NoteListTokens = &BusinessNoteListTokens; + NoteListLanguage = &BusinessNoteListLanguage; + NoteListPref = &BusinessNoteListPref; + break; + } + + intPrevValue = 5; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + // Process properties. + + size_t intPropertyValueLen = PropertyValue.Len(); + + if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){ + + PropertyValue.Trim(); + PropertyValue.RemoveLast(); + + } + + if (PropertyValue.Mid(0, 1) == wxT("\"")){ + + PropertyValue.Remove(0, 1); + + } + + CaptureString(&PropertyValue, FALSE); + + if (PropertyName == wxT("ALTID")){ + + NoteListAltID->erase(*NoteCount); + NoteListAltID->insert(std::make_pair(*NoteCount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + NoteListPID->erase(*NoteCount); + NoteListPID->insert(std::make_pair(*NoteCount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + NoteListPref->erase(*NoteCount); + NoteListPref->insert(std::make_pair(*NoteCount, PriorityNumber)); + + } + + } else if (PropertyName == wxT("LANGUAGE")){ + + NoteListLanguage->erase(*NoteCount); + NoteListLanguage->insert(std::make_pair(*NoteCount, PropertyValue)); + + } else { + + // Something else we don't know about so append + // to the tokens variable. + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + // Add the data to the General/Home/Work address variables. + + CaptureString(&PropertySeg2, FALSE); + + NoteList->insert(std::make_pair(*NoteCount, PropertySeg2)); + + if (!PropertyTokens.IsEmpty()){ + + NoteListTokens->insert(std::make_pair(*NoteCount, PropertyTokens)); + + } + +} + +void ContactDataObject::ProcessCategory(wxString PropertySeg1, wxString PropertySeg2, int *CategoryCount){ + + std::map SplitPoints; + std::map SplitLength; + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + bool FirstToken = TRUE; + int intPrevValue = 12; + int intPref = 0; + int intType = 0; + long ListCtrlIndex; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 11; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType); + + // Setup blank lines for later on. + + switch(PropType){ + case PROPERTY_NONE: + break; + case PROPERTY_HOME: + CategoriesListType.insert(std::make_pair(*CategoryCount, "home")); + break; + case PROPERTY_WORK: + CategoriesListType.insert(std::make_pair(*CategoryCount, "work")); + break; + } + + intPrevValue = 11; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + // Process properties. + + size_t intPropertyValueLen = PropertyValue.Len(); + + if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){ + + PropertyValue.Trim(); + PropertyValue.RemoveLast(); + + } + + if (PropertyValue.Mid(0, 1) == wxT("\"")){ + + PropertyValue.Remove(0, 1); + + } + + CaptureString(&PropertyValue, FALSE); + + if (PropertyName == wxT("ALTID")){ + + CategoriesListAltID.erase(*CategoryCount); + CategoriesListAltID.insert(std::make_pair(*CategoryCount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + CategoriesListPID.erase(*CategoryCount); + CategoriesListPID.insert(std::make_pair(*CategoryCount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + CategoriesListPref.erase(*CategoryCount); + CategoriesListPref.insert(std::make_pair(*CategoryCount, PriorityNumber)); + + } + + } else if (PropertyName == wxT("LANGUAGE")){ + + CategoriesListLanguage.erase(*CategoryCount); + CategoriesListLanguage.insert(std::make_pair(*CategoryCount, PropertyValue)); + + } else { + + // Something else we don't know about so append + // to the tokens variable. + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + // Deal with multiple categories. + + int intOrigCatCount = *CategoryCount; + bool FirstCategoryProcessed = TRUE; + bool AfterFirstToken = FALSE; + int intSplitSize = 0; + int intSplitsFound = 0; + int intSplitSeek = 0; + int intPropertyLen = PropertySeg2.Len(); + + SplitPoints.clear(); + SplitLength.clear(); + intPrevValue = 0; + + for (int i = 0; i <= intPropertyLen; i++){ + + if (intSplitSize == 0 && PropertySeg2.Mid(i, 1) == wxT(" ")){ + + continue; + + } + + intSplitSize++; + + if (PropertySeg2.Mid(i, 1) == wxT(",") && PropertySeg2.Mid((i - 1), 1) != wxT("\\")){ + + if (AfterFirstToken == TRUE){ + + SplitPoints.insert(std::make_pair(intSplitsFound, (i - intSplitSize + 1))); + SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 2))); + + } else { + + SplitPoints.insert(std::make_pair(intSplitsFound, 0)); + SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 2))); + AfterFirstToken = TRUE; + + } + + intSplitsFound++; + intSplitSeek = i; + intSplitSize = 0; + + } + + } + + if (SplitPoints.size() > 0){ + + SplitPoints.insert(std::make_pair(intSplitsFound, (intSplitSeek + 1))); + SplitLength.insert(std::make_pair(intSplitsFound, intSplitSize)); + + } + + if (SplitPoints.size() == 0){ + + CategoriesList.insert(std::make_pair(*CategoryCount, PropertySeg2)); + + if (!PropertyTokens.IsEmpty()){ + + CategoriesListTokens.insert(std::make_pair(*CategoryCount, PropertyTokens)); + + } + + } + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + intPrevValue = intiter->second; + + PropertyData = PropertySeg2.Mid(intPrevValue, (SLiter->second + 1)); + + // Add the data to the General/Home/Work address variables. + + // Trim any whitespace from the start and end. + + PropertyData = PropertyData.Trim(FALSE); + PropertyData = PropertyData.Trim(TRUE); + + CaptureString(&PropertyData, FALSE); + + if (FirstCategoryProcessed == TRUE){ + + FirstCategoryProcessed = FALSE; + + CategoriesList.insert(std::make_pair(*CategoryCount, PropertyData)); + + if (!PropertyTokens.IsEmpty()){ + + CategoriesListTokens.insert(std::make_pair(*CategoryCount, PropertyTokens)); + + } + + continue; + + } else { + + (*CategoryCount)++; + + CategoriesList.insert(std::make_pair(*CategoryCount, PropertyData)); + + if (!PropertyTokens.IsEmpty()){ + + CategoriesListTokens.insert(std::make_pair(*CategoryCount, PropertyTokens)); + + } + + } + + // Copy the properties to each of the categories (if it exists). + + if (!PropertyTokens.IsEmpty()){ + + CategoriesListTokens.insert(std::make_pair(*CategoryCount, CategoriesListTokens.find(intOrigCatCount)->second)); + + } + + // Check if ALTID was used. + + if (CategoriesListAltID.find(intOrigCatCount) != CategoriesListAltID.end()){ + + CategoriesListAltID.insert(std::make_pair(*CategoryCount, CategoriesListAltID.find(intOrigCatCount)->second)); + + } + + // Check if PID was used. + + if (CategoriesListPID.find(intOrigCatCount) != CategoriesListPID.end()){ + + CategoriesListPID.insert(std::make_pair(*CategoryCount, CategoriesListPID.find(intOrigCatCount)->second)); + + } + + // Check if PREF was used. + + if (CategoriesListPref.find(intOrigCatCount) != CategoriesListPref.end()){ + + CategoriesListPref.insert(std::make_pair(*CategoryCount, CategoriesListPref.find(intOrigCatCount)->second)); + + } + + // Check if LANGUAGE was used. + + if (CategoriesListLanguage.find(intOrigCatCount) != CategoriesListLanguage.end()){ + + CategoriesListLanguage.insert(std::make_pair(*CategoryCount, CategoriesListLanguage.find(intOrigCatCount)->second)); + + } + + // Check if TYPE was used. + + switch(PropType){ + case PROPERTY_NONE: + break; + case PROPERTY_HOME: + CategoriesListType.insert(std::make_pair(*CategoryCount, "home")); + break; + case PROPERTY_WORK: + CategoriesListType.insert(std::make_pair(*CategoryCount, "work")); + break; + } + + } + +} + +void ContactDataObject::ProcessPhoto(wxString PropertySeg1, wxString PropertySeg2, int *PhotoCount){ + + size_t intPropertyLen = PropertySeg1.Len(); + std::map SplitPoints; + std::map SplitLength; + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + bool FirstToken = TRUE; + int intSplitsFound = 0; + int intSplitSize = 0; + int intPrevValue = 7; + int intPref = 0; + int intType = 0; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 6; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType); + + intPrevValue = 6; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + // Process properties. + + size_t intPropertyValueLen = PropertyValue.Len(); + + if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){ + + PropertyValue.Trim(); + PropertyValue.RemoveLast(); + + } + + if (PropertyValue.Mid(0, 1) == wxT("\"")){ + + PropertyValue.Remove(0, 1); + + } + + CaptureString(&PropertyValue, FALSE); + + if (PropertyName == wxT("ALTID")){ + + PicturesListAltID.erase(*PhotoCount); + PicturesListAltID.insert(std::make_pair(*PhotoCount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + PicturesListPID.erase(*PhotoCount); + PicturesListPID.insert(std::make_pair(*PhotoCount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + PicturesListPref.erase(*PhotoCount); + PicturesListPref.insert(std::make_pair(*PhotoCount, PriorityNumber)); + + } + + } else if (PropertyName == wxT("MEDIATYPE")){ + + PicturesListMediatype.erase(*PhotoCount); + PicturesListMediatype.insert(std::make_pair(*PhotoCount, PropertyValue)); + + } else { + + // Something else we don't know about so append + // to the tokens variable. + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + intPropertyLen = PropertySeg2.Len(); + SplitPoints.clear(); + SplitLength.clear(); + intSplitsFound = 0; + intSplitSize = 0; + intPrevValue = 0; + + CaptureString(&PropertySeg2, FALSE); + + for (int i = 0; i <= intPropertyLen; i++){ + + intSplitSize++; + + if (PropertySeg2.Mid(i, 1) == wxT(";")){ + + intSplitsFound++; + SplitPoints.insert(std::make_pair(intSplitsFound, (i + 1))); + + if (intSplitsFound == 6){ + + SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1))); + break; + + } else { + + SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1))); + + } + + intSplitSize = 0; + + } + + } + + wxString wxSPhotoURI; + wxString wxSPhotoMIME; + wxString wxSPhotoEncoding; + wxString wxSPhotoData; + std::string base64enc; + + if (intSplitsFound == 0){ + + } else { + + std::map::iterator striter; + + striter = SplitLength.find(1); + + wxStringTokenizer wSTDataType(PropertySeg2.Mid(0, striter->second), wxT(":")); + + while (wSTDataType.HasMoreTokens() == TRUE){ + + wxSPhotoURI = wSTDataType.GetNextToken(); + wxSPhotoMIME = wSTDataType.GetNextToken(); + break; + + } + + wxStringTokenizer wSTDataInfo(PropertySeg2.Mid((striter->second + 1)), wxT(",")); + + while (wSTDataInfo.HasMoreTokens() == TRUE){ + + wxSPhotoEncoding = wSTDataInfo.GetNextToken(); + wxSPhotoData = wSTDataInfo.GetNextToken(); + base64enc = wxSPhotoData.mb_str(); + break; + + } + + } + + // Add the data to the General/Home/Work address variables. + + PicturesList.insert(std::make_pair(*PhotoCount, base64enc)); + PicturesListPictureType.insert(std::make_pair(*PhotoCount, wxSPhotoMIME)); + PicturesListPicEncType.insert(std::make_pair(*PhotoCount, wxSPhotoEncoding)); + + switch(PropType){ + case PROPERTY_NONE: + break; + case PROPERTY_HOME: + PicturesListType.insert(std::make_pair(*PhotoCount, "home")); + break; + case PROPERTY_WORK: + PicturesListType.insert(std::make_pair(*PhotoCount, "work")); + break; + } + + if (!PropertyTokens.IsEmpty()){ + + PicturesListTokens.insert(std::make_pair(*PhotoCount, PropertyTokens)); + + } + +} + +void ContactDataObject::ProcessLogo(wxString PropertySeg1, wxString PropertySeg2, int *LogoCount){ + + size_t intPropertyLen = PropertySeg1.Len(); + std::map SplitPoints; + std::map SplitLength; + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + bool FirstToken = TRUE; + int intSplitsFound = 0; + int intSplitSize = 0; + int intPrevValue = 6; + int intPref = 0; + int intType = 0; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 5; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType); + + intPrevValue = 5; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + // Process properties. + + size_t intPropertyValueLen = PropertyValue.Len(); + + if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){ + + PropertyValue.Trim(); + PropertyValue.RemoveLast(); + + } + + if (PropertyValue.Mid(0, 1) == wxT("\"")){ + + PropertyValue.Remove(0, 1); + + } + + CaptureString(&PropertyValue, FALSE); + + if (PropertyName == wxT("ALTID")){ + + LogosListAltID.erase(*LogoCount); + LogosListAltID.insert(std::make_pair(*LogoCount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + LogosListPID.erase(*LogoCount); + LogosListPID.insert(std::make_pair(*LogoCount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + LogosListPref.erase(*LogoCount); + LogosListPref.insert(std::make_pair(*LogoCount, PriorityNumber)); + + } + + } else if (PropertyName == wxT("MEDIATYPE")){ + + LogosListMediatype.erase(*LogoCount); + LogosListMediatype.insert(std::make_pair(*LogoCount, PropertyValue)); + + } else { + + // Something else we don't know about so append + // to the tokens variable. + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + intPropertyLen = PropertySeg2.Len(); + SplitPoints.clear(); + SplitLength.clear(); + intSplitsFound = 0; + intSplitSize = 0; + intPrevValue = 0; + + CaptureString(&PropertySeg2, FALSE); + + for (int i = 0; i <= intPropertyLen; i++){ + + intSplitSize++; + + if (PropertySeg2.Mid(i, 1) == wxT(";")){ + + intSplitsFound++; + SplitPoints.insert(std::make_pair(intSplitsFound, (i + 1))); + + if (intSplitsFound == 6){ + + SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1))); + break; + + } else { + + SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1))); + + } + + intSplitSize = 0; + + } + + } + + wxString wxSPhotoURI; + wxString wxSPhotoMIME; + wxString wxSPhotoEncoding; + wxString wxSPhotoData; + std::string base64enc; + + if (intSplitsFound == 0){ + + } else { + + std::map::iterator striter; + + striter = SplitLength.find(1); + + wxStringTokenizer wSTDataType(PropertySeg2.Mid(0, striter->second), wxT(":")); + + while (wSTDataType.HasMoreTokens() == TRUE){ + + wxSPhotoURI = wSTDataType.GetNextToken(); + wxSPhotoMIME = wSTDataType.GetNextToken(); + break; + + } + + wxStringTokenizer wSTDataInfo(PropertySeg2.Mid((striter->second + 1)), wxT(",")); + + while (wSTDataInfo.HasMoreTokens() == TRUE){ + + wxSPhotoEncoding = wSTDataInfo.GetNextToken(); + wxSPhotoData = wSTDataInfo.GetNextToken(); + base64enc = wxSPhotoData.mb_str(); + break; + + } + + } + + // Add the data to the General/Home/Work address variables. + + LogosList.insert(std::make_pair(*LogoCount, base64enc)); + LogosListPictureType.insert(std::make_pair(*LogoCount, wxSPhotoMIME)); + LogosListPicEncType.insert(std::make_pair(*LogoCount, wxSPhotoEncoding)); + + switch(PropType){ + case PROPERTY_NONE: + break; + case PROPERTY_HOME: + LogosListType.insert(std::make_pair(*LogoCount, "home")); + break; + case PROPERTY_WORK: + LogosListType.insert(std::make_pair(*LogoCount, "work")); + break; + } + + if (!PropertyTokens.IsEmpty()){ + + LogosListTokens.insert(std::make_pair(*LogoCount, PropertyTokens)); + + } + +} + +void ContactDataObject::ProcessSound(wxString PropertySeg1, wxString PropertySeg2, int *SoundCount){ + + size_t intPropertyLen = PropertySeg1.Len(); + std::map SplitPoints; + std::map SplitLength; + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + bool FirstToken = TRUE; + int intSplitsFound = 0; + int intSplitSize = 0; + int intPrevValue = 7; + int intPref = 0; + int intType = 0; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 6; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType); + + intPrevValue = 6; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + // Process properties. + + size_t intPropertyValueLen = PropertyValue.Len(); + + if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){ + + PropertyValue.Trim(); + PropertyValue.RemoveLast(); + + } + + if (PropertyValue.Mid(0, 1) == wxT("\"")){ + + PropertyValue.Remove(0, 1); + + } + + CaptureString(&PropertyValue, FALSE); + + if (PropertyName == wxT("ALTID")){ + + SoundsListAltID.erase(*SoundCount); + SoundsListAltID.insert(std::make_pair(*SoundCount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + SoundsListPID.erase(*SoundCount); + SoundsListPID.insert(std::make_pair(*SoundCount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + SoundsListPref.erase(*SoundCount); + SoundsListPref.insert(std::make_pair(*SoundCount, PriorityNumber)); + + } + + } else if (PropertyName == wxT("MEDIATYPE")){ + + SoundsListMediatype.erase(*SoundCount); + SoundsListMediatype.insert(std::make_pair(*SoundCount, PropertyValue)); + + } else if (PropertyName == wxT("LANGUAGE")){ + + SoundsListLanguage.erase(*SoundCount); + SoundsListLanguage.insert(std::make_pair(*SoundCount, PropertyValue)); + + } else { + + // Something else we don't know about so append + // to the tokens variable. + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + intPropertyLen = PropertySeg2.Len(); + SplitPoints.clear(); + SplitLength.clear(); + intSplitsFound = 0; + intSplitSize = 0; + intPrevValue = 0; + + CaptureString(&PropertySeg2, FALSE); + + for (int i = 0; i <= intPropertyLen; i++){ + + intSplitSize++; + + if (PropertySeg2.Mid(i, 1) == wxT(";")){ + + intSplitsFound++; + SplitPoints.insert(std::make_pair(intSplitsFound, (i + 1))); + + if (intSplitsFound == 6){ + + SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1))); + break; + + } else { + + SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1))); + + } + + intSplitSize = 0; + + } + + } + + wxString wxSSoundURI; + wxString wxSSoundMIME; + wxString wxSSoundEncoding; + wxString wxSSoundData; + std::string base64enc; + + if (intSplitsFound == 0){ + + } else { + + std::map::iterator striter; + + striter = SplitLength.find(1); + + wxStringTokenizer wSTDataType(PropertySeg2.Mid(0, striter->second), wxT(":")); + + while (wSTDataType.HasMoreTokens() == TRUE){ + + wxSSoundURI = wSTDataType.GetNextToken(); + wxSSoundMIME = wSTDataType.GetNextToken(); + break; + + } + + wxStringTokenizer wSTDataInfo(PropertySeg2.Mid((striter->second + 1)), wxT(",")); + + while (wSTDataInfo.HasMoreTokens() == TRUE){ + + wxSSoundEncoding = wSTDataInfo.GetNextToken(); + wxSSoundData = wSTDataInfo.GetNextToken(); + base64enc = wxSSoundData.mb_str(); + break; + + } + + } + + // Add the data to the General/Home/Work address variables. + + switch(PropType){ + case PROPERTY_NONE: + break; + case PROPERTY_HOME: + SoundsListType.insert(std::make_pair(*SoundCount, "home")); + break; + case PROPERTY_WORK: + SoundsListType.insert(std::make_pair(*SoundCount, "work")); + break; + } + + SoundsList.insert(std::make_pair(*SoundCount, base64enc)); + SoundsListAudioEncType.insert(std::make_pair(*SoundCount, wxSSoundEncoding)); + SoundsListAudioType.insert(std::make_pair(*SoundCount, wxSSoundMIME)); + + if (!PropertyTokens.IsEmpty()){ + + SoundsListTokens.insert(std::make_pair(*SoundCount, PropertyTokens)); + + } + +} + +void ContactDataObject::ProcessCalendarURI(wxString PropertySeg1, wxString PropertySeg2, int *CalURICount){ + + size_t intPropertyLen = PropertySeg1.Len(); + std::map SplitPoints; + std::map SplitLength; + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + bool FirstToken = TRUE; + int intSplitsFound = 0; + int intSplitSize = 0; + int intPrevValue = 8; + int intPref = 0; + int intType = 0; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 7; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType); + + intPrevValue = 7; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + // Process properties. + + size_t intPropertyValueLen = PropertyValue.Len(); + + if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){ + + PropertyValue.Trim(); + PropertyValue.RemoveLast(); + + } + + if (PropertyValue.Mid(0, 1) == wxT("\"")){ + + PropertyValue.Remove(0, 1); + + } + + CaptureString(&PropertyValue, FALSE); + + if (PropertyName == wxT("ALTID")){ + + CalendarListAltID.erase(*CalURICount); + CalendarListAltID.insert(std::make_pair(*CalURICount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + CalendarListPID.erase(*CalURICount); + CalendarListPID.insert(std::make_pair(*CalURICount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + CalendarListPref.erase(*CalURICount); + CalendarListPref.insert(std::make_pair(*CalURICount, PriorityNumber)); + + } + + } else if (PropertyName == wxT("MEDIATYPE")){ + + CalendarListMediatype.erase(*CalURICount); + CalendarListMediatype.insert(std::make_pair(*CalURICount, PropertyValue)); + + } else { + + // Something else we don't know about so append + // to the tokens variable. + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + intPropertyLen = PropertySeg2.Len(); + SplitPoints.clear(); + SplitLength.clear(); + intSplitsFound = 0; + intSplitSize = 0; + intPrevValue = 0; + + CaptureString(&PropertySeg2, FALSE); + + // Add the data to the General/Home/Work address variables. + + switch(PropType){ + case PROPERTY_NONE: + break; + case PROPERTY_HOME: + CalendarListType.insert(std::make_pair(*CalURICount, "home")); + break; + case PROPERTY_WORK: + CalendarListType.insert(std::make_pair(*CalURICount, "work")); + break; + } + + CalendarList.insert(std::make_pair(*CalURICount, PropertySeg2)); + + if (!PropertyTokens.IsEmpty()){ + + CalendarListTokens.insert(std::make_pair(*CalURICount, PropertyTokens)); + + } + +} + +void ContactDataObject::ProcessCalendarAddressURI(wxString PropertySeg1, wxString PropertySeg2, int *CalAdrURICount){ + + size_t intPropertyLen = PropertySeg1.Len(); + std::map SplitPoints; + std::map SplitLength; + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + bool FirstToken = TRUE; + int intSplitsFound = 0; + int intSplitSize = 0; + int intPrevValue = 8; + int intPref = 0; + int intType = 0; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 7; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType); + + intPrevValue = 7; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + // Process properties. + + size_t intPropertyValueLen = PropertyValue.Len(); + + if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){ + + PropertyValue.Trim(); + PropertyValue.RemoveLast(); + + } + + if (PropertyValue.Mid(0, 1) == wxT("\"")){ + + PropertyValue.Remove(0, 1); + + } + + CaptureString(&PropertyValue, FALSE); + + if (PropertyName == wxT("ALTID")){ + + CalendarRequestListAltID.erase(*CalAdrURICount); + CalendarRequestListAltID.insert(std::make_pair(*CalAdrURICount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + CalendarRequestListPID.erase(*CalAdrURICount); + CalendarRequestListPID.insert(std::make_pair(*CalAdrURICount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + CalendarRequestListPref.erase(*CalAdrURICount); + CalendarRequestListPref.insert(std::make_pair(*CalAdrURICount, PriorityNumber)); + + } + + } else if (PropertyName == wxT("MEDIATYPE")){ + + CalendarRequestListMediatype.erase(*CalAdrURICount); + CalendarRequestListMediatype.insert(std::make_pair(*CalAdrURICount, PropertyValue)); + + } else { + + // Something else we don't know about so append + // to the tokens variable. + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + intPropertyLen = PropertySeg2.Len(); + SplitPoints.clear(); + SplitLength.clear(); + intSplitsFound = 0; + intSplitSize = 0; + intPrevValue = 0; + + CaptureString(&PropertySeg2, FALSE); + + // Add the data to the General/Home/Work address variables. + + switch(PropType){ + case PROPERTY_NONE: + break; + case PROPERTY_HOME: + CalendarRequestListType.insert(std::make_pair(*CalAdrURICount, "home")); + break; + case PROPERTY_WORK: + CalendarRequestListType.insert(std::make_pair(*CalAdrURICount, "work")); + break; + } + + CalendarRequestList.insert(std::make_pair(*CalAdrURICount, PropertySeg2)); + + if (!PropertyTokens.IsEmpty()){ + + CalendarRequestListTokens.insert(std::make_pair(*CalAdrURICount, PropertyTokens)); + + } + +} + +void ContactDataObject::ProcessCalendarFreeBusy(wxString PropertySeg1, wxString PropertySeg2, int *FreeBusyAddressCount){ + + size_t intPropertyLen = PropertySeg1.Len(); + std::map SplitPoints; + std::map SplitLength; + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + bool FirstToken = TRUE; + int intSplitsFound = 0; + int intSplitSize = 0; + int intPrevValue = 7; + int intPref = 0; + int intType = 0; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 6; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType); + + intPrevValue = 6; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + // Process properties. + + size_t intPropertyValueLen = PropertyValue.Len(); + + if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){ + + PropertyValue.Trim(); + PropertyValue.RemoveLast(); + + } + + if (PropertyValue.Mid(0, 1) == wxT("\"")){ + + PropertyValue.Remove(0, 1); + + } + + CaptureString(&PropertyValue, FALSE); + + if (PropertyName == wxT("ALTID")){ + + FreeBusyListAltID.erase(*FreeBusyAddressCount); + FreeBusyListAltID.insert(std::make_pair(*FreeBusyAddressCount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + FreeBusyListPID.erase(*FreeBusyAddressCount); + FreeBusyListPID.insert(std::make_pair(*FreeBusyAddressCount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + FreeBusyListPref.erase(*FreeBusyAddressCount); + FreeBusyListPref.insert(std::make_pair(*FreeBusyAddressCount, PriorityNumber)); + + } + + } else if (PropertyName == wxT("MEDIATYPE")){ + + FreeBusyListMediatype.erase(*FreeBusyAddressCount); + FreeBusyListMediatype.insert(std::make_pair(*FreeBusyAddressCount, PropertyValue)); + + } else { + + // Something else we don't know about so append + // to the tokens variable. + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + intPropertyLen = PropertySeg2.Len(); + SplitPoints.clear(); + SplitLength.clear(); + intSplitsFound = 0; + intSplitSize = 0; + intPrevValue = 0; + + CaptureString(&PropertySeg2, FALSE); + + // Add the data to the General/Home/Work address variables. + + switch(PropType){ + case PROPERTY_NONE: + break; + case PROPERTY_HOME: + FreeBusyListType.insert(std::make_pair(*FreeBusyAddressCount, "home")); + break; + case PROPERTY_WORK: + FreeBusyListType.insert(std::make_pair(*FreeBusyAddressCount, "work")); + break; + } + + FreeBusyList.insert(std::make_pair(*FreeBusyAddressCount, PropertySeg2)); + + if (!PropertyTokens.IsEmpty()){ + + FreeBusyListTokens.insert(std::make_pair(*FreeBusyAddressCount, PropertyTokens)); + + } + +} + +void ContactDataObject::ProcessKey(wxString PropertySeg1, wxString PropertySeg2, int *KeyCount){ + + size_t intPropertyLen = PropertySeg1.Len(); + std::map SplitPoints; + std::map SplitLength; + std::map::iterator SLiter; + wxString PropertyData; + wxString PropertyName; + wxString PropertyValue; + wxString PropertyTokens; + bool FirstToken = TRUE; + int intSplitsFound = 0; + int intSplitSize = 0; + int intPrevValue = 5; + int intPref = 0; + int intType = 0; + long ListCtrlIndex; + + SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue); + + intPrevValue = 4; + + PropertyType PropType = PROPERTY_NONE; + + // Look for type before continuing. + + CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType); + + intPrevValue = 4; + + for (std::map::iterator intiter = SplitPoints.begin(); + intiter != SplitPoints.end(); ++intiter){ + + SLiter = SplitLength.find(intiter->first); + + PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second)); + + wxStringTokenizer PropertyElement (PropertyData, wxT("=")); + PropertyName = PropertyElement.GetNextToken(); + PropertyValue = PropertyElement.GetNextToken(); + + intPrevValue = intiter->second; + + // Process properties. + + size_t intPropertyValueLen = PropertyValue.Len(); + + if (PropertyValue.Mid((intPropertyValueLen - 1), 1) == wxT("\"")){ + + PropertyValue.Trim(); + PropertyValue.RemoveLast(); + + } + + if (PropertyValue.Mid(0, 1) == wxT("\"")){ + + PropertyValue.Remove(0, 1); + + } + + if (PropertyName == wxT("ALTID")){ + + KeyListAltID.erase(*KeyCount); + KeyListAltID.insert(std::make_pair(*KeyCount, PropertyValue)); + + } else if (PropertyName == wxT("PID")){ + + KeyListPID.erase(*KeyCount); + KeyListPID.insert(std::make_pair(*KeyCount, PropertyValue)); + + } else if (PropertyName == wxT("PREF")){ + + int PriorityNumber = 0; + bool ValidNumber = TRUE; + + try{ + PriorityNumber = std::stoi(PropertyValue.ToStdString()); + } + + catch(std::invalid_argument &e){ + ValidNumber = FALSE; + } + + if (ValidNumber == TRUE){ + + KeyListPref.erase(*KeyCount); + KeyListPref.insert(std::make_pair(*KeyCount, PriorityNumber)); + + } + + } else { + + // Something else we don't know about so append + // to the tokens variable. + + if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){ + + if (FirstToken == TRUE){ + + PropertyTokens.Append(PropertyName + wxT("=") + PropertyValue); + FirstToken = FALSE; + + } else { + + PropertyTokens.Append(wxT(";") + PropertyName + wxT("=") + PropertyValue); + + } + + } + + } + + } + + intPropertyLen = PropertySeg2.Len(); + SplitPoints.clear(); + SplitLength.clear(); + intSplitsFound = 0; + intSplitSize = 0; + intPrevValue = 0; + + for (int i = 0; i <= intPropertyLen; i++){ + + intSplitSize++; + + if (PropertySeg2.Mid(i, 1) == wxT(";") && PropertySeg2.Mid((i - 1), 1) != wxT("\\")){ + + intSplitsFound++; + SplitPoints.insert(std::make_pair(intSplitsFound, (i + 1))); + + if (intSplitsFound == 6){ + + SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1))); + break; + + } else { + + SplitLength.insert(std::make_pair(intSplitsFound, (intSplitSize - 1))); + + } + + intSplitSize = 0; + + } + + } + + wxString wxSKeyURI; + wxString wxSKeyMIME; + wxString wxSKeyEncoding; + wxString wxSKeyData; + std::string base64enc; + + if (intSplitsFound == 0){ + + } else { + + std::map::iterator striter; + + striter = SplitLength.find(1); + + wxStringTokenizer wSTDataType(PropertySeg2.Mid(0, striter->second), wxT(":")); + + while (wSTDataType.HasMoreTokens() == TRUE){ + + wxSKeyURI = wSTDataType.GetNextToken(); + wxSKeyMIME = wSTDataType.GetNextToken(); + break; + + } + + if (wxSKeyURI == wxT("data")){ + + wxStringTokenizer wSTDataInfo(PropertySeg2.Mid((striter->second + 1)), wxT(",")); + + while (wSTDataInfo.HasMoreTokens() == TRUE){ + + wxSKeyEncoding = wSTDataInfo.GetNextToken(); + wxSKeyData = wSTDataInfo.GetNextToken(); + break; + + } + + } + + } + + // Add the data to the General/Home/Work address variables. + + if (wxSKeyURI == wxT("data")){ + + KeyListDataEncType.erase(*KeyCount); + KeyListKeyType.erase(*KeyCount); + KeyListDataEncType.insert(std::make_pair(*KeyCount, wxSKeyEncoding)); + KeyListKeyType.insert(std::make_pair(*KeyCount, TRUE)); + + KeyList.erase(*KeyCount); + KeyList.insert(std::make_pair(*KeyCount, wxSKeyData)); + + } else { + + KeyList.erase(*KeyCount); + KeyList.insert(std::make_pair(*KeyCount, PropertySeg2)); + + } + + KeyListDataType.insert(std::make_pair(*KeyCount, wxSKeyMIME)); + + switch (PropType){ + case PROPERTY_NONE: + break; + case PROPERTY_HOME: + KeyListType.insert(std::make_pair(*KeyCount, wxT("home"))); + break; + case PROPERTY_WORK: + KeyListType.insert(std::make_pair(*KeyCount, wxT("work"))); + break; + } + + if (!PropertyTokens.IsEmpty()){ + + KeyListTokens.insert(std::make_pair(*KeyCount, PropertyTokens)); + + } + +} + +void ContactDataObject::ProcessVendor(wxString PropertySeg1, wxString PropertySeg2, int *VendorCount){ + + // Split the Vendor three ways. + + wxStringTokenizer wSTVendorDetails(PropertySeg1, wxT("-")); + + wxString wxSVNDID; + wxString wxSVNDPropName; + long ListCtrlIndex; + + while (wSTVendorDetails.HasMoreTokens() == TRUE){ + + wSTVendorDetails.GetNextToken(); + wxSVNDID = wSTVendorDetails.GetNextToken(); + wxSVNDPropName = wSTVendorDetails.GetNextToken(); + break; + + } + + if (!wxSVNDID.IsEmpty() && !wxSVNDPropName.IsEmpty()){ + + // Add the data to the vendor variables. + + VendorList.erase(*VendorCount); + VendorListPEN.erase(*VendorCount); + VendorListElement.erase(*VendorCount); + + VendorList.insert(std::make_pair(*VendorCount, PropertySeg2)); + VendorListPEN.insert(std::make_pair(*VendorCount, wxSVNDID)); + VendorListElement.insert(std::make_pair(*VendorCount, wxSVNDPropName)); + + } }