// ContactDataObject.cpp - Client Data Object.
//
// (c) 2012-2016 Xestia Software Development.
//
// This file is part of Xestia Address Book.
//
// Xestia Address Book is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by the
// Free Software Foundation, version 3 of the license.
//
// Xestia Address Book is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with Xestia Address Book. If not, see
#include "ContactDataObject.h"
ContactLoadStatus ContactDataObject::LoadFile(wxString Filename){
// Load the ContactDataObject using the Filename given.
if (!wxFileExists(Filename)){
return CONTACTLOAD_FILEMISSING;
}
wxFile ContactFile;
if (!ContactFile.Open(Filename, wxFile::read, wxS_DEFAULT)){
return CONTACTLOAD_FILEERROR;
}
// Check that the vCard is a valid vCard 4.0 file.
vCard vCard4FormatCheck;
vCard4FormatCheck.LoadFile(Filename);
if (vCard4FormatCheck.Get("VERSION") != wxT("4.0")){
return CONTACTLOAD_FILEINVALIDFORMAT;
}
// Check that the vCard meets the base specification.
if (!vCard4FormatCheck.MeetBaseSpecification()){
return CONTACTLOAD_FILEBASESPECFAIL;
}
wxStringTokenizer wSTContactFileLines(vCard4FormatCheck.WriteString(), wxT("\r\n"));
std::map ContactFileLines;
int ContactLineSeek = 0;
while (wSTContactFileLines.HasMoreTokens() == TRUE){
wxString ContactLine = wSTContactFileLines.GetNextToken();
ContactFileLines.insert(std::make_pair(ContactLineSeek, ContactLine));
ContactLineSeek++;
}
wxString wxSPropertyNextLine;
bool ExtraLineSeek = TRUE;
bool QuoteMode = FALSE;
bool PropertyFind = TRUE;
bool KindProcessed = FALSE;
bool NameProcessed = FALSE;
bool GenderProcessed = FALSE;
bool BirthdayProcessed = FALSE;
bool AnniversaryProcessed = FALSE;
bool UIDProcessed = FALSE;
bool RevisionProcessed = FALSE;
int ContactLineLen = 0;
int QuoteBreakPoint = 0;
int SourceCount = 0;
int GroupCount = 0;
int FNCount = 0;
int NicknameCount = 0;
int TimeZoneCount = 0;
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;
int ClientPIDCount = 0;
wxString ContactLine;
wxString PropertyLine;
wxString PropertySeg1;
wxString PropertySeg2;
wxString PropertyNextLine;
wxString Property;
for (std::map::iterator iter = ContactFileLines.begin();
iter != ContactFileLines.end(); ++iter){
ExtraLineSeek = TRUE;
QuoteMode = FALSE;
PropertyFind = TRUE;
ContactLineLen = 0;
QuoteBreakPoint = 0;
ContactLine.Clear();
PropertyLine.Clear();
PropertySeg1.Clear();
PropertySeg2.Clear();
Property.Clear();
ContactLine = iter->second;
while (ExtraLineSeek == TRUE){
// Check if there is extra data on the next line
// (indicated by space or tab at the start) and add data.
iter++;
if (iter == ContactFileLines.end()){
iter--;
break;
}
PropertyNextLine = iter->second;
if (PropertyNextLine.Mid(0, 1) == wxT(" ") || PropertyNextLine.Mid(0, 1) == wxT("\t")){
PropertyNextLine.Remove(0, 1);
ContactLine.Append(PropertyNextLine);
} else {
iter--;
ExtraLineSeek = FALSE;
}
}
ContactLineLen = ContactLine.Len();
// Make sure we are not in quotation mode.
// Make sure colon does not have \ or \\ before it.
for (int i = 0; i <= ContactLineLen; i++){
if ((ContactLine.Mid(i, 1) == wxT(";") || ContactLine.Mid(i, 1) == wxT(":")) && PropertyFind == TRUE){
PropertyFind = FALSE;
} else if (PropertyFind == TRUE){
Property.Append(ContactLine.Mid(i, 1));
}
if (ContactLine.Mid(i, 1) == wxT("\"")){
if (QuoteMode == TRUE){
QuoteMode = FALSE;
} else {
QuoteMode = TRUE;
}
}
if (ContactLine.Mid(i, 1) == wxT(":") && ContactLine.Mid((i - 1), 1) != wxT("\\") && QuoteMode == FALSE){
QuoteBreakPoint = i;
break;
}
}
// Split that line at the point into two variables (ignore the colon).
PropertySeg1 = ContactLine.Mid(0, QuoteBreakPoint);
PropertySeg2 = ContactLine.Mid((QuoteBreakPoint + 1));
if (Property == wxT("KIND") && KindProcessed == FALSE){
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("REV") && RevisionProcessed == FALSE){
ProcessRevision(PropertySeg1, PropertySeg2);
RevisionProcessed = TRUE;
} else if (Property == wxT("MEMBER")){
ProcessMember(PropertySeg1, PropertySeg2, &GroupCount);
GroupCount++;
} else if (Property == wxT("FN")){
ProcessFN(PropertySeg1, PropertySeg2, &FNCount);
FNCount++;
} else if (Property == wxT("N") && NameProcessed == FALSE){
ProcessN(PropertySeg1, PropertySeg2);
NameProcessed = TRUE;
} else if (Property == wxT("CLIENTPIDMAP")){
ProcessClientPIDMap(PropertySeg1, PropertySeg2, &ClientPIDCount);
ClientPIDCount++;
} else if (Property == wxT("NICKNAME")){
ProcessNickname(PropertySeg1, PropertySeg2, &NicknameCount);
NicknameCount++;
} else if (Property == wxT("GENDER") && GenderProcessed == FALSE){
ProcessGender(PropertySeg1, PropertySeg2);
GenderProcessed = TRUE;
} else if (Property == wxT("BDAY") && BirthdayProcessed == FALSE){
ProcessBirthday(PropertySeg1, PropertySeg2);
BirthdayProcessed = TRUE;
} else if (Property == wxT("ANNIVERSARY") && AnniversaryProcessed == FALSE){
ProcessAnniversary(PropertySeg1, PropertySeg2);
AnniversaryProcessed = TRUE;
} else if (Property == wxT("TZ")){
ProcessTimeZone(PropertySeg1, PropertySeg2, &TimeZoneCount);
TimeZoneCount++;
} else if (Property == wxT("ADR")){
ProcessAddress(PropertySeg1, PropertySeg2, &AddressCount);
AddressCount++;
} else if (Property == wxT("EMAIL")){
ProcessEmail(PropertySeg1, PropertySeg2, &EmailCount);
EmailCount++;
} else if (Property == wxT("IMPP")){
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("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++;
}
}
return CONTACTLOAD_OK;
}
void ContactDataObject::ProcessKind(wxString KindType){
// Process the type of contact.
if (KindType == wxT("individual")){
ContactKind = CONTACTKIND_INDIVIDUAL;
} else if (KindType == wxT("group")){
ContactKind = CONTACTKIND_GROUP;
} else if (KindType == wxT("org")){
ContactKind = CONTACTKIND_ORGANISATION;
} else if (KindType == wxT("location")){
ContactKind = CONTACTKIND_LOCATION;
} else {
ContactKind = CONTACTKIND_NONE;
}
}
void ContactDataObject::ProcessRevision(wxString PropertySeg1, wxString PropertySeg2){
// Process the revision date.
std::map SplitPoints;
std::map SplitLength;
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
bool FirstToken = TRUE;
int intPrevValue = 5;
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));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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);
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
CaptureString(&PropertySeg2, FALSE);
Revision = PropertySeg2;
if (!PropertyTokens.IsEmpty()){
RevisionTokens = PropertyTokens;
}
}
void ContactDataObject::ProcessSource(wxString PropertySeg1, wxString PropertySeg2, int *SourceCount){
// Process the source address.
std::map SplitPoints;
std::map SplitLength;
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
bool FirstToken = TRUE;
bool PropertyMatched = FALSE;
int intPrevValue = 8;
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));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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);
ProcessStringValue(&PropertyName, "ALTID", &SourceListAltID, &PropertyValue, SourceCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", &SourceListPID, &PropertyValue, SourceCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "MEDIATYPE", &SourceListMediatype, &PropertyValue, SourceCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", &SourceListPref, &PropertyValue, SourceCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
SplitPoints.clear();
SplitLength.clear();
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){
// Process the XML data.
std::map SplitPoints;
std::map SplitLength;
int intPrevValue = 5;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 4;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyData;
wxString PropertyTokens;
std::map::iterator SLiter;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
intPrevValue = intiter->second;
CaptureString(&PropertyValue, FALSE);
ProcessStringValue(&PropertyName, "ALTID", &XMLListAltID, &PropertyValue, XMLCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
}
XMLList.insert(std::make_pair(*XMLCount, PropertySeg2));
}
void ContactDataObject::ProcessMember(wxString PropertySeg1, wxString PropertySeg2, int *GroupCount){
// Process the membership data.
std::map SplitPoints;
std::map SplitLength;
int intPrevValue = 8;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 7;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyData;
wxString PropertyTokens;
std::map::iterator SLiter;
bool FirstToken = TRUE;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
intPrevValue = intiter->second;
CaptureString(&PropertyValue, FALSE);
ProcessStringValue(&PropertyName, "ALTID", &GroupsListAltID, &PropertyValue, GroupCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", &GroupsListPID, &PropertyValue, GroupCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "MEDIATYPE", &GroupsListMediaType, &PropertyValue, GroupCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", &GroupsListPref, &PropertyValue, GroupCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
GroupsList.insert(std::make_pair(*GroupCount, PropertySeg2));
if (!PropertyTokens.IsEmpty()){
GroupsListTokens.insert(std::make_pair(*GroupCount, PropertyTokens));
}
}
void ContactDataObject::ProcessFN(wxString PropertySeg1, wxString PropertySeg2, int *FNCount){
// Process the full name.
std::map SplitPoints;
std::map SplitLength;
int intPrevValue = 4;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 3;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyData;
wxString PropertyTokens;
std::map::iterator SLiter;
bool FirstToken = TRUE;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
intPrevValue = intiter->second;
CaptureString(&PropertyValue, FALSE);
if (PropertyName == wxT("TYPE")){
if (!PropertyValue.IsEmpty() || PropertyValue == wxT("home") ||
PropertyValue == wxT("work") ){
FullNamesListType.erase(*FNCount);
FullNamesListType.insert(std::make_pair(*FNCount, PropertyValue));
}
PropertyMatched = TRUE;
}
ProcessStringValue(&PropertyName, "ALTID", &FullNamesListAltID, &PropertyValue, FNCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", &FullNamesListPID, &PropertyValue, FNCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "LANGUAGE", &FullNamesListLanguage, &PropertyValue, FNCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", &FullNamesListPref, &PropertyValue, FNCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
FullNamesList.insert(std::make_pair(*FNCount, PropertySeg2));
if (!PropertyTokens.IsEmpty()){
FullNamesListTokens.insert(std::make_pair(*FNCount, PropertyTokens));
}
}
void ContactDataObject::ProcessN(wxString PropertySeg1, wxString PropertySeg2){
// Process the name.
std::map SplitPoints;
std::map SplitLength;
int intPrevValue = 3;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 2;
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));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
intPrevValue = intiter->second;
CaptureString(&PropertyValue, FALSE);
if (PropertyName == wxT("ALTID")){
NameAltID = PropertyValue;
} else if (PropertyName == wxT("LANGUAGE")){
NameLanguage = PropertyValue;
} else if (PropertyName == wxT("SORT-AS")){
if (PropertyValue.Left(1) == wxT("\"") && PropertyValue.Right(1) == wxT("\"") &&
PropertyValue.Len() >= 3){
NameDisplayAs = PropertyValue.Mid(1, (PropertyValue.Len() - 2));
}
} else if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty()){
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
}
// Split the name data.
int intSplitSeek = 0;
int intSplitsFound = 0;
int intSplitSize = 0;
int intPropertyLen = PropertySeg2.Len();
std::map NameValues;
intPrevValue = 0;
for (int i = 0; i <= intPropertyLen; i++){
if (PropertySeg2.Mid(i, 1) == wxT(";") && PropertySeg2.Mid((i - 1), 1) != wxT("\\")){
NameValues.insert(std::make_pair(++intSplitsFound, PropertySeg2.Mid(intSplitSeek, intSplitSize)));
intSplitSeek = i;
intSplitSeek++;
if (intSplitsFound == 4){
NameValues.insert(std::make_pair(++intSplitsFound, PropertySeg2.Mid(intSplitSeek, wxString::npos)));
break;
}
intSplitSize = 0;
continue;
}
intSplitSize++;
}
// Split the data into several parts.
for (std::map::iterator iter = NameValues.begin();
iter != NameValues.end(); ++iter){
if (iter->first == 1){
// Deal with family name.
NameSurname = iter->second;
} else if (iter->first == 2){
// Deal with given names.
NameForename = iter->second;
} else if (iter->first == 3){
// Deal with additional names.
NameOtherNames = iter->second;
} else if (iter->first == 4){
// Deal with honorifix prefixes and suffixes.
NameTitle = iter->second;
iter++;
if (iter == NameValues.end()){
break;
}
NameSuffix = iter->second;
}
}
// Add the name token data.
if (!PropertyTokens.IsEmpty()){
NameTokens = PropertyTokens;
}
}
void ContactDataObject::ProcessClientPIDMap(wxString PropertySeg1, wxString PropertySeg2, int *ClientPIDCount){
// Process the Client PID Map.
std::map SplitPoints;
std::map SplitLength;
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
bool FirstToken = TRUE;
int intPrevValue = 14;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 13;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
intPrevValue = intiter->second;
// Process properties.
CaptureString(&PropertyValue, FALSE);
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
CaptureString(&PropertySeg2, FALSE);
ClientPIDList.insert(std::make_pair(*ClientPIDCount, PropertySeg2));
if (!PropertyTokens.IsEmpty()){
ClientPIDListTokens.insert(std::make_pair(*ClientPIDCount, PropertyTokens));
}
}
void ContactDataObject::ProcessNickname(wxString PropertySeg1, wxString PropertySeg2, int *NicknameCount){
// Process the Nickname.
std::map SplitPoints;
std::map SplitLength;
int intPrevValue = 10;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 9;
PropertyType PropType = PROPERTY_NONE;
// Look for type before continuing.
CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
intPrevValue = 9;
std::map *NicknamesList = NULL;
std::map *NicknamesListType = NULL;
std::map *NicknamesListLanguage = NULL;
std::map *NicknamesListAltID = NULL;
std::map *NicknamesListPID = NULL;
std::map *NicknamesListTokens = NULL;
std::map *NicknamesListPref = NULL;
switch(PropType){
case PROPERTY_NONE:
NicknamesList = &GeneralNicknamesList;
NicknamesListType = &GeneralNicknamesListType;
NicknamesListLanguage = &GeneralNicknamesListLanguage;
NicknamesListAltID = &GeneralNicknamesListAltID;
NicknamesListPID = &GeneralNicknamesListPID;
NicknamesListTokens = &GeneralNicknamesListTokens;
NicknamesListPref = &GeneralNicknamesListPref;
break;
case PROPERTY_HOME:
NicknamesList = &HomeNicknamesList;
NicknamesListType = &HomeNicknamesListType;
NicknamesListLanguage = &HomeNicknamesListLanguage;
NicknamesListAltID = &HomeNicknamesListAltID;
NicknamesListPID = &HomeNicknamesListPID;
NicknamesListTokens = &HomeNicknamesListTokens;
NicknamesListPref = &HomeNicknamesListPref;
break;
case PROPERTY_WORK:
NicknamesList = &BusinessNicknamesList;
NicknamesListType = &BusinessNicknamesListType;
NicknamesListLanguage = &BusinessNicknamesListLanguage;
NicknamesListAltID = &BusinessNicknamesListAltID;
NicknamesListPID = &BusinessNicknamesListPID;
NicknamesListTokens = &BusinessNicknamesListTokens;
NicknamesListPref = &BusinessNicknamesListPref;
break;
}
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
bool FirstToken = TRUE;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
intPrevValue = intiter->second;
CaptureString(&PropertyValue, FALSE);
ProcessStringValue(&PropertyName, "ALTID", NicknamesListAltID, &PropertyValue, NicknameCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", NicknamesListPID, &PropertyValue, NicknameCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "LANGUAGE", NicknamesListLanguage, &PropertyValue, NicknameCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", NicknamesListPref, &PropertyValue, NicknameCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
NicknamesList->insert(std::make_pair(*NicknameCount, PropertySeg2));
// Add the name token data.
if (!PropertyTokens.IsEmpty()){
NicknamesListTokens->insert(std::make_pair(*NicknameCount, PropertyTokens));
}
}
void ContactDataObject::ProcessGender(wxString PropertySeg1, wxString PropertySeg2){
// Process the gender.
std::map SplitPoints;
std::map SplitLength;
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
bool FirstToken = TRUE;
int intPrevValue = 8;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 7;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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);
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
wxStringTokenizer GenderData (PropertySeg2, wxT(";"));
wxString GenderComponent;
if (GenderData.CountTokens() >= 2){
Gender = GenderData.GetNextToken();
GenderDetails = GenderData.GetString();
CaptureString(&GenderDetails, FALSE);
} else {
Gender = GenderData.GetNextToken();
}
if (!PropertyTokens.IsEmpty()){
GenderTokens = PropertyTokens;
}
}
void ContactDataObject::ProcessBirthday(wxString PropertySeg1, wxString PropertySeg2){
// Process birthday date.
std::map SplitPoints;
std::map SplitLength;
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
int intPrevValue = 6;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 5;
// 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);
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
intPrevValue = intiter->second;
if (PropertyName == wxT("VALUE") && PropertyValue == wxT("text") && BirthdayText == FALSE){
CaptureString(&PropertySeg2, FALSE);
Birthday = PropertySeg2;
BirthdayText = TRUE;
}
}
// Setup blank lines for later on.
intPrevValue = 5;
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);
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
intPrevValue = intiter->second;
// Process properties.
CaptureString(&PropertyValue, FALSE);
if (PropertyValue.Mid((PropertyValue.Len() - 1), 1) == wxT("\"")){
PropertyValue.Trim();
PropertyValue.RemoveLast();
}
if (PropertyValue.Mid(0, 1) == wxT("\"")){
PropertyValue.Remove(0, 1);
}
if (PropertyName == wxT("ALTID")){
BirthdayAltID = PropertyValue;
} else if (PropertyName == wxT("CALSCALE")){
BirthdayCalScale = PropertyValue;
} else if (PropertyName != wxT("VALUE")) {
// Something else we don't know about so append
// to the tokens variable.
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
}
// Add the data to the variables and form.
if (BirthdayText == FALSE){
Birthday = PropertySeg2;
}
if (!PropertyTokens.IsEmpty()){
BirthdayTokens = PropertyTokens;
}
}
void ContactDataObject::ProcessAnniversary(wxString PropertySeg1, wxString PropertySeg2){
// Process the anniversary.
std::map SplitPoints;
std::map SplitLength;
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
int intPrevValue = 13;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 12;
// 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);
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
intPrevValue = intiter->second;
if (PropertyName == wxT("VALUE") && PropertyValue == wxT("text") && AnniversaryText == FALSE){
CaptureString(&PropertySeg2, FALSE);
Anniversary = PropertySeg2;
AnniversaryText = TRUE;
}
}
// Setup blank lines for later on.
intPrevValue = 12;
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);
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
intPrevValue = intiter->second;
// Process properties.
CaptureString(&PropertyValue, FALSE);
if (PropertyValue.Mid((PropertyValue.Len() - 1), 1) == wxT("\"")){
PropertyValue.Trim();
PropertyValue.RemoveLast();
}
if (PropertyValue.Mid(0, 1) == wxT("\"")){
PropertyValue.Remove(0, 1);
}
if (PropertyName == wxT("ALTID")){
AnniversaryAltID = PropertyValue;
} else if (PropertyName == wxT("CALSCALE")){
AnniversaryCalScale = PropertyValue;
} else if (PropertyName != wxT("VALUE")) {
// Something else we don't know about so append
// to the tokens variable.
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
}
// Add the data to the variables and form.
if (AnniversaryText == FALSE){
Anniversary = PropertySeg2;
}
if (!PropertyTokens.IsEmpty()){
AnniversaryTokens = PropertyTokens;
}
}
void ContactDataObject::ProcessTimeZone(wxString PropertySeg1, wxString PropertySeg2, int *TimeZoneCount){
// Process the timezone.
std::map SplitPoints;
std::map SplitLength;
int intPrevValue = 4;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 3;
PropertyType PropType = PROPERTY_NONE;
// Look for type before continuing.
CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
intPrevValue = 3;
std::map *TZList = NULL;
std::map *TZListType = NULL;
std::map *TZListMediatype = NULL;
std::map *TZListAltID = NULL;
std::map *TZListPID = NULL;
std::map *TZListTokens = NULL;
std::map *TZListPref = NULL;
switch(PropType){
case PROPERTY_NONE:
TZList = &GeneralTZList;
TZListType = &GeneralTZListType;
TZListMediatype = &GeneralTZListMediatype;
TZListAltID = &GeneralTZListAltID;
TZListPID = &GeneralTZListPID;
TZListTokens = &GeneralTZListTokens;
TZListPref = &GeneralTZListPref;
break;
case PROPERTY_HOME:
TZList = &HomeTZList;
TZListType = &HomeTZListType;
TZListMediatype = &HomeTZListMediatype;
TZListAltID = &HomeTZListAltID;
TZListPID = &HomeTZListPID;
TZListTokens = &HomeTZListTokens;
TZListPref = &HomeTZListPref;
break;
case PROPERTY_WORK:
TZList = &BusinessTZList;
TZListType = &BusinessTZListType;
TZListMediatype = &BusinessTZListMediatype;
TZListAltID = &BusinessTZListAltID;
TZListPID = &BusinessTZListPID;
TZListTokens = &BusinessTZListTokens;
TZListPref = &BusinessTZListPref;
break;
}
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
bool FirstToken = TRUE;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
intPrevValue = intiter->second;
CaptureString(&PropertyValue, FALSE);
ProcessStringValue(&PropertyName, "ALTID", TZListAltID, &PropertyValue, TimeZoneCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", TZListPID, &PropertyValue, TimeZoneCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "MEDIATYPE", TZListMediatype, &PropertyValue, TimeZoneCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", TZListPref, &PropertyValue, TimeZoneCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
if (!PropertyName.IsEmpty() && !PropertyValue.IsEmpty() && PropertyName != wxT("TYPE")){
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
}
TZList->insert(std::make_pair(*TimeZoneCount, PropertySeg2));
// Add the name token data.
if (!PropertyTokens.IsEmpty()){
TZListTokens->insert(std::make_pair(*TimeZoneCount, PropertyTokens));
}
}
void ContactDataObject::ProcessAddress(wxString PropertySeg1, wxString PropertySeg2, int *AddressCount){
// Process the address.
size_t intPropertyLen = PropertySeg1.Len();
std::map SplitPoints;
std::map SplitLength;
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
wxString AddressLabel;
wxString AddressLang;
wxString AddressAltID;
wxString AddressPID;
wxString AddressTokens;
wxString AddressGeo;
wxString AddressTimezone;
wxString AddressType;
wxString AddressMediatype;
wxString AddressPOBox;
wxString AddressExtended;
wxString AddressStreet;
wxString AddressLocality;
wxString AddressCity;
wxString AddressRegion;
wxString AddressPostalCode;
wxString AddressCountry;
bool FirstToken = TRUE;
int intSplitsFound = 0;
int intSplitSize = 0;
int intPrevValue = 5;
bool PropertyMatched = FALSE;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 4;
PropertyType PropType = PROPERTY_NONE;
// Look for type before continuing.
CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
intPrevValue = 4;
std::map *AddressList = NULL;
std::map *AddressListTown = NULL;
std::map *AddressListCounty = NULL;
std::map *AddressListPostCode = NULL;
std::map *AddressListCountry = NULL;
std::map *AddressListLabel = NULL;
std::map *AddressListLang = NULL;
std::map *AddressListAltID = NULL;
std::map *AddressListPID = NULL;
std::map *AddressListTokens = NULL;
std::map *AddressListGeo = NULL;
std::map *AddressListTimezone = NULL;
std::map *AddressListType = NULL;
std::map *AddressListMediatype = NULL;
std::map *AddressListPref = NULL;
switch(PropType){
case PROPERTY_NONE:
AddressList = &GeneralAddressList;
AddressListTown = &GeneralAddressListTown;
AddressListCounty = &GeneralAddressListCounty;
AddressListPostCode = &GeneralAddressListPostCode;
AddressListCountry = &GeneralAddressListCountry;
AddressListLabel = &GeneralAddressListLabel;
AddressListLang = &GeneralAddressListLang;
AddressListAltID = &GeneralAddressListAltID;
AddressListPID = &GeneralAddressListPID;
AddressListTokens = &GeneralAddressListTokens;
AddressListGeo = &GeneralAddressListGeo;
AddressListTimezone = &GeneralAddressListTimezone;
AddressListType = &GeneralAddressListType;
AddressListMediatype = &GeneralAddressListMediatype;
AddressListPref = &GeneralAddressListPref;
break;
case PROPERTY_HOME:
AddressList = &HomeAddressList;
AddressListTown = &HomeAddressListTown;
AddressListCounty = &HomeAddressListCounty;
AddressListPostCode = &HomeAddressListPostCode;
AddressListCountry = &HomeAddressListCountry;
AddressListLabel = &HomeAddressListLabel;
AddressListLang = &HomeAddressListLang;
AddressListAltID = &HomeAddressListAltID;
AddressListPID = &HomeAddressListPID;
AddressListTokens = &HomeAddressListTokens;
AddressListGeo = &HomeAddressListGeo;
AddressListTimezone = &HomeAddressListTimezone;
AddressListType = &HomeAddressListType;
AddressListMediatype = &HomeAddressListMediatype;
AddressListPref = &HomeAddressListPref;
break;
case PROPERTY_WORK:
AddressList = &BusinessAddressList;
AddressListTown = &BusinessAddressListTown;
AddressListCounty = &BusinessAddressListCounty;
AddressListPostCode = &BusinessAddressListPostCode;
AddressListCountry = &BusinessAddressListCountry;
AddressListLabel = &BusinessAddressListLabel;
AddressListLang = &BusinessAddressListLang;
AddressListAltID = &BusinessAddressListAltID;
AddressListPID = &BusinessAddressListPID;
AddressListTokens = &BusinessAddressListTokens;
AddressListGeo = &BusinessAddressListGeo;
AddressListTimezone = &BusinessAddressListTimezone;
AddressListType = &BusinessAddressListType;
AddressListMediatype = &BusinessAddressListMediatype;
AddressListPref = &BusinessAddressListPref;
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));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
intPrevValue = intiter->second;
if (PropertyName == "GEO"){
CaptureString(&PropertyValue, TRUE);
} else {
CaptureString(&PropertyValue, FALSE);
}
// Process properties.
ProcessStringValue(&PropertyName, "LABEL", AddressListLabel, &PropertyValue, AddressCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "LANGUAGE", AddressListLang, &PropertyValue, AddressCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "ALTID", AddressListAltID, &PropertyValue, AddressCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", AddressListPID, &PropertyValue, AddressCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "GEO", AddressListGeo, &PropertyValue, AddressCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "TZ", AddressListTimezone, &PropertyValue, AddressCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "MEDIATYPE", AddressListMediatype, &PropertyValue, AddressCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", AddressListPref, &PropertyValue, AddressCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
// Split the address.
//std::map::iterator SLiter;
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;
}
}
// Split the data into several parts.
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
if (intiter->first == 1){
// Deal with PO Box.
SLiter = SplitLength.find(1);
AddressPOBox = PropertySeg2.Mid(0, SLiter->second);
intPrevValue = intiter->second;
} else if (intiter->first == 2){
// Deal with extended address.
SLiter = SplitLength.find(2);
AddressExtended = PropertySeg2.Mid(intPrevValue, SLiter->second);
intPrevValue = intiter->second;
} else if (intiter->first == 3){
// Deal with street address.
SLiter = SplitLength.find(3);
AddressStreet = PropertySeg2.Mid(intPrevValue, SLiter->second);
intPrevValue = intiter->second;
} else if (intiter->first == 4){
// Deal with locality
SLiter = SplitLength.find(4);
AddressLocality = PropertySeg2.Mid(intPrevValue, SLiter->second);
intPrevValue = intiter->second;
} else if (intiter->first == 5){
// Deal with region.
SLiter = SplitLength.find(5);
AddressRegion = PropertySeg2.Mid(intPrevValue, SLiter->second);
intPrevValue = intiter->second;
} else if (intiter->first == 6){
// Deal with post code.
SLiter = SplitLength.find(6);
AddressPostalCode = PropertySeg2.Mid(intPrevValue, SLiter->second);
intPrevValue = intiter->second;
// Deal with country.
AddressCountry = PropertySeg2.Mid(intPrevValue, wxString::npos);
break;
}
}
// Add the data to the General/Home/Work address variables.
CaptureString(&AddressStreet, FALSE);
CaptureString(&AddressLocality, FALSE);
CaptureString(&AddressRegion, FALSE);
CaptureString(&AddressPostalCode, FALSE);
CaptureString(&AddressCountry, FALSE);
if (!PropertyTokens.IsEmpty()){
AddressListTokens->insert(std::make_pair(*AddressCount, PropertyTokens));
}
AddressListCountry->insert(std::make_pair(*AddressCount, AddressCountry));
AddressList->insert(std::make_pair(*AddressCount, AddressStreet));
AddressListTown->insert(std::make_pair(*AddressCount, AddressLocality));
AddressListCounty->insert(std::make_pair(*AddressCount, AddressRegion));
AddressListPostCode->insert(std::make_pair(*AddressCount, AddressPostalCode));
switch(PropType){
case PROPERTY_NONE:
AddressListType->insert(std::make_pair(*AddressCount, wxT("")));
break;
case PROPERTY_HOME:
AddressListType->insert(std::make_pair(*AddressCount, wxT("home")));
break;
case PROPERTY_WORK:
AddressListType->insert(std::make_pair(*AddressCount, wxT("work")));
break;
}
AddressListTokens->insert(std::make_pair(*AddressCount, PropertyTokens));
}
void ContactDataObject::ProcessEmail(wxString PropertySeg1, wxString PropertySeg2, int *EmailCount){
// Process the email address.
std::map SplitPoints;
std::map SplitLength;
int intPrevValue = 7;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 6;
PropertyType PropType = PROPERTY_NONE;
// Look for type before continuing.
CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
std::map *EmailList = NULL;
std::map *EmailListType = NULL;
std::map *EmailListAltID = NULL;
std::map *EmailListPID = NULL;
std::map *EmailListTokens = NULL;
std::map *EmailListPref = NULL;
switch(PropType){
case PROPERTY_NONE:
EmailList = &GeneralEmailList;
EmailListType = &GeneralEmailListType;
EmailListAltID = &GeneralEmailListAltID;
EmailListPID = &GeneralEmailListPID;
EmailListTokens = &GeneralEmailListTokens;
EmailListPref = &GeneralEmailListPref;
break;
case PROPERTY_HOME:
EmailList = &HomeEmailList;
EmailListType = &HomeEmailListType;
EmailListAltID = &HomeEmailListAltID;
EmailListPID = &HomeEmailListPID;
EmailListTokens = &HomeEmailListTokens;
EmailListPref = &HomeEmailListPref;
break;
case PROPERTY_WORK:
EmailList = &BusinessEmailList;
EmailListType = &BusinessEmailListType;
EmailListAltID = &BusinessEmailListAltID;
EmailListPID = &BusinessEmailListPID;
EmailListTokens = &BusinessEmailListTokens;
EmailListPref = &BusinessEmailListPref;
break;
}
intPrevValue = 6;
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
bool FirstToken = TRUE;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
intPrevValue = intiter->second;
CaptureString(&PropertyValue, FALSE);
// Process properties.
ProcessStringValue(&PropertyName, "ALTID", EmailListAltID, &PropertyValue, EmailCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", EmailListPID, &PropertyValue, EmailCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", EmailListPref, &PropertyValue, EmailCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
EmailList->insert(std::make_pair(*EmailCount, PropertySeg2));
// Add the name token data.
if (!PropertyTokens.IsEmpty()){
EmailListTokens->insert(std::make_pair(*EmailCount, PropertyTokens));
}
}
void ContactDataObject::ProcessIM(wxString PropertySeg1, wxString PropertySeg2, int *IMCount){
// Process the IM.
std::map SplitPoints;
std::map SplitLength;
int intPrevValue = 6;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 5;
PropertyType PropType = PROPERTY_NONE;
// Look for type before continuing.
CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
std::map *IMList = NULL;
std::map *IMListType = NULL;
std::map *IMListAltID = NULL;
std::map *IMListPID = NULL;
std::map *IMListTokens = NULL;
std::map *IMListMediatype = NULL;
std::map *IMListTypeInfo = NULL;
std::map *IMListPref = NULL;
switch(PropType){
case PROPERTY_NONE:
IMList = &GeneralIMList;
IMListType = &GeneralIMListType;
IMListAltID = &GeneralIMListAltID;
IMListPID = &GeneralIMListPID;
IMListTokens = &GeneralIMListTokens;
IMListMediatype = &GeneralIMListMediatype;
IMListTypeInfo = &GeneralIMListTypeInfo;
IMListPref = &GeneralIMListPref;
break;
case PROPERTY_HOME:
IMList = &HomeIMList;
IMListType = &HomeIMListType;
IMListAltID = &HomeIMListAltID;
IMListPID = &HomeIMListPID;
IMListTokens = &HomeIMListTokens;
IMListMediatype = &HomeIMListMediatype;
IMListTypeInfo = &HomeIMListTypeInfo;
IMListPref = &HomeIMListPref;
break;
case PROPERTY_WORK:
IMList = &BusinessIMList;
IMListType = &BusinessIMListType;
IMListAltID = &BusinessIMListAltID;
IMListPID = &BusinessIMListPID;
IMListTokens = &BusinessIMListTokens;
IMListMediatype = &BusinessIMListMediatype;
IMListTypeInfo = &BusinessIMListTypeInfo;
IMListPref = &BusinessIMListPref;
break;
}
intPrevValue = 5;
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
bool FirstToken = TRUE;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
intPrevValue = intiter->second;
CaptureString(&PropertyValue, FALSE);
ProcessStringValue(&PropertyName, "ALTID", IMListAltID, &PropertyValue, IMCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", IMListPID, &PropertyValue, IMCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "MEDIATYPE", IMListMediatype, &PropertyValue, IMCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", IMListPref, &PropertyValue, IMCount, &PropertyMatched);
// Process properties.
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
wxStringTokenizer IMPPSplitData(PropertySeg2, wxT(":"));
if (IMPPSplitData.CountTokens() > 1){
IMListTypeInfo->insert(std::make_pair(*IMCount, IMPPSplitData.GetNextToken()));
IMList->insert(std::make_pair(*IMCount, IMPPSplitData.GetString()));
} else {
IMList->insert(std::make_pair(*IMCount, PropertySeg2));
IMListTypeInfo->insert(std::make_pair(*IMCount, "none"));
}
// Add the name token data.
if (!PropertyTokens.IsEmpty()){
IMListTokens->insert(std::make_pair(*IMCount, PropertyTokens));
}
}
void ContactDataObject::ProcessTelephone(wxString PropertySeg1, wxString PropertySeg2, int *TelephoneCount){
// Process the telephone.
std::map SplitPoints;
std::map SplitLength;
std::map::iterator SLiter;
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 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));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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;
bool TypeFound = FALSE;
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") && TypeFound == FALSE){
PropType = PROPERTY_HOME;
TypeFound = TRUE;
} else if (TypePropertyName == wxT("work") && TypeFound == FALSE){
PropType = PROPERTY_WORK;
TypeFound = TRUE;
}
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(_("cell"));
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 *TelephoneListDataType = NULL;
std::map *TelephoneListPref = NULL;
switch(PropType){
case PROPERTY_NONE:
TelephoneList = &GeneralTelephoneList;
TelephoneListType = &GeneralTelephoneListType;
TelephoneListAltID = &GeneralTelephoneListAltID;
TelephoneListPID = &GeneralTelephoneListPID;
TelephoneListTokens = &GeneralTelephoneListTokens;
TelephoneListTypeInfo = &GeneralTelephoneListTypeInfo;
TelephoneListDataType = &GeneralTelephoneListDataType;
TelephoneListPref = &GeneralTelephoneListPref;
break;
case PROPERTY_HOME:
TelephoneList = &HomeTelephoneList;
TelephoneListType = &HomeTelephoneListType;
TelephoneListAltID = &HomeTelephoneListAltID;
TelephoneListPID = &HomeTelephoneListPID;
TelephoneListTokens = &HomeTelephoneListTokens;
TelephoneListTypeInfo = &HomeTelephoneListTypeInfo;
TelephoneListDataType = &HomeTelephoneListDataType;
TelephoneListPref = &HomeTelephoneListPref;
break;
case PROPERTY_WORK:
TelephoneList = &BusinessTelephoneList;
TelephoneListType = &BusinessTelephoneListType;
TelephoneListAltID = &BusinessTelephoneListAltID;
TelephoneListPID = &BusinessTelephoneListPID;
TelephoneListTokens = &BusinessTelephoneListTokens;
TelephoneListTypeInfo = &BusinessTelephoneListTypeInfo;
TelephoneListDataType = &BusinessTelephoneListDataType;
TelephoneListPref = &BusinessTelephoneListPref;
break;
}
// Process the properties.
bool FirstToken = TRUE;
intPrevValue = 5;
SplitPoints.clear();
SplitLength.clear();
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 4;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
intPrevValue = intiter->second;
CaptureString(&PropertyValue, FALSE);
// Process properties.
ProcessStringValue(&PropertyName, "ALTID", TelephoneListAltID, &PropertyValue, TelephoneCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", TelephoneListPID, &PropertyValue, TelephoneCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", TelephoneListPref, &PropertyValue, TelephoneCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
// Check for the type information and split it down.
wxStringTokenizer TelSplitData(PropertySeg2, wxT(":"));
if (TelSplitData.CountTokens() > 1){
TelephoneListDataType->insert(std::make_pair(*TelephoneCount, TelSplitData.GetNextToken()));
TelephoneList->insert(std::make_pair(*TelephoneCount, TelSplitData.GetString()));
} else {
TelephoneList->insert(std::make_pair(*TelephoneCount, PropertySeg2));
TelephoneListDataType->insert(std::make_pair(*TelephoneCount, "tel"));
}
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){
// Process the language.
std::map SplitPoints;
std::map SplitLength;
int intPrevValue = 6;
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;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
intPrevValue = intiter->second;
CaptureString(&PropertyValue, FALSE);
// Process properties.
ProcessStringValue(&PropertyName, "ALTID", LanguageListAltID, &PropertyValue, LanguageCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", LanguageListPID, &PropertyValue, LanguageCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", LanguageListPref, &PropertyValue, LanguageCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
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){
// Process the geographic location.
std::map SplitPoints;
std::map SplitLength;
int intPrevValue = 5;
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 *GeopositionListDataType = NULL;
std::map *GeopositionListPref = NULL;
switch(PropType){
case PROPERTY_NONE:
GeopositionList = &GeneralGeographyList;
GeopositionListType = &GeneralGeographyListType;
GeopositionListAltID = &GeneralGeographyListAltID;
GeopositionListPID = &GeneralGeographyListPID;
GeopositionListTokens = &GeneralGeographyListTokens;
GeopositionListMediatype = &GeneralGeographyListMediatype;
GeopositionListDataType = &GeneralGeographyListDataType;
GeopositionListPref = &GeneralGeographyListPref;
break;
case PROPERTY_HOME:
GeopositionList = &HomeGeographyList;
GeopositionListType = &HomeGeographyListType;
GeopositionListAltID = &HomeGeographyListAltID;
GeopositionListPID = &HomeGeographyListPID;
GeopositionListTokens = &HomeGeographyListTokens;
GeopositionListMediatype = &HomeGeographyListMediatype;
GeopositionListDataType = &HomeGeographyListDataType;
GeopositionListPref = &HomeGeographyListPref;
break;
case PROPERTY_WORK:
GeopositionList = &BusinessGeographyList;
GeopositionListType = &BusinessGeographyListType;
GeopositionListAltID = &BusinessGeographyListAltID;
GeopositionListPID = &BusinessGeographyListPID;
GeopositionListTokens = &BusinessGeographyListTokens;
GeopositionListMediatype = &BusinessGeographyListMediatype;
GeopositionListDataType = &BusinessGeographyListDataType;
GeopositionListPref = &BusinessGeographyListPref;
break;
}
intPrevValue = 4;
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
bool FirstToken = TRUE;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
intPrevValue = intiter->second;
CaptureString(&PropertyValue, FALSE);
// Process properties.
ProcessStringValue(&PropertyName, "ALTID", GeopositionListAltID, &PropertyValue, GeographicCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", GeopositionListPID, &PropertyValue, GeographicCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "MEDIATYPE", GeopositionListMediatype, &PropertyValue, GeographicCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", GeopositionListPref, &PropertyValue, GeographicCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
wxStringTokenizer GeoSplitData(PropertySeg2, wxT(":"));
if (GeoSplitData.CountTokens() > 1){
GeopositionListDataType->insert(std::make_pair(*GeographicCount, GeoSplitData.GetNextToken()));
GeopositionList->insert(std::make_pair(*GeographicCount, GeoSplitData.GetString()));
} else {
GeopositionList->insert(std::make_pair(*GeographicCount, PropertySeg2));
GeopositionListDataType->insert(std::make_pair(*GeographicCount, "tel"));
}
// Add the name token data.
if (!PropertyTokens.IsEmpty()){
GeopositionListTokens->insert(std::make_pair(*GeographicCount, PropertyTokens));
}
}
void ContactDataObject::ProcessRelated(wxString PropertySeg1, wxString PropertySeg2, int *RelatedCount){
// Process the relation.
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 intPrevValue = 9;
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));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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);
ProcessStringValue(&PropertyName, "ALTID", &GeneralRelatedListAltID, &PropertyValue, RelatedCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", &GeneralRelatedListPID, &PropertyValue, RelatedCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "LANGUAGE", &GeneralRelatedListLanguage, &PropertyValue, RelatedCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", &GeneralRelatedListPref, &PropertyValue, RelatedCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
// 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){
// Process the URL.
std::map SplitPoints;
std::map SplitLength;
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
bool FirstToken = TRUE;
int intPrevValue = 5;
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;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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);
ProcessStringValue(&PropertyName, "ALTID", WebsiteListAltID, &PropertyValue, URLCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", WebsiteListPID, &PropertyValue, URLCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "MEDIATYPE", WebsiteListMediatype, &PropertyValue, URLCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", WebsiteListPref, &PropertyValue, URLCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
// 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){
// Process the title.
std::map SplitPoints;
std::map SplitLength;
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
bool FirstToken = TRUE;
int intPrevValue = 7;
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;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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);
ProcessStringValue(&PropertyName, "ALTID", TitleListAltID, &PropertyValue, TitleCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", TitleListPID, &PropertyValue, TitleCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "LANGUAGE", TitleListLanguage, &PropertyValue, TitleCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", TitleListPref, &PropertyValue, TitleCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
// 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){
// Process the role.
std::map SplitPoints;
std::map SplitLength;
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
bool FirstToken = TRUE;
int intPrevValue = 6;
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;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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);
ProcessStringValue(&PropertyName, "ALTID", RoleListAltID, &PropertyValue, RoleCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", RoleListPID, &PropertyValue, RoleCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "LANGUAGE", RoleListLanguage, &PropertyValue, RoleCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", RoleListPref, &PropertyValue, RoleCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
// 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){
// Process the organisation.
std::map SplitPoints;
std::map SplitLength;
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
bool FirstToken = TRUE;
int intPrevValue = 5;
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;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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);
ProcessStringValue(&PropertyName, "ALTID", OrganisationsListAltID, &PropertyValue, OrganisationCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", OrganisationsListPID, &PropertyValue, OrganisationCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "LANGUAGE", OrganisationsListLanguage, &PropertyValue, OrganisationCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "SORT-AS", OrganisationsListSortAs, &PropertyValue, OrganisationCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", OrganisationsListPref, &PropertyValue, OrganisationCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
// 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){
// Process the note.
std::map SplitPoints;
std::map SplitLength;
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
bool FirstToken = TRUE;
int intPrevValue = 6;
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;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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);
ProcessStringValue(&PropertyName, "ALTID", NoteListAltID, &PropertyValue, NoteCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", NoteListPID, &PropertyValue, NoteCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "LANGUAGE", NoteListLanguage, &PropertyValue, NoteCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", NoteListPref, &PropertyValue, NoteCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
// 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){
// Process the category.
std::map SplitPoints;
std::map SplitLength;
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
bool FirstToken = TRUE;
int intPrevValue = 12;
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;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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);
ProcessStringValue(&PropertyName, "ALTID", &CategoriesListAltID, &PropertyValue, CategoryCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", &CategoriesListPID, &PropertyValue, CategoryCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "LANGUAGE", &CategoriesListLanguage, &PropertyValue, CategoryCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", &CategoriesListPref, &PropertyValue, CategoryCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
// 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){
// Process the photo.
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;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 6;
PropertyType PropType = PROPERTY_NONE;
// Look for type before continuing.
CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
intPrevValue = 6;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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);
ProcessStringValue(&PropertyName, "ALTID", &PicturesListAltID, &PropertyValue, PhotoCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", &PicturesListPID, &PropertyValue, PhotoCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "MEDIATYPE", &PicturesListMediatype, &PropertyValue, PhotoCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", &PicturesListPref, &PropertyValue, PhotoCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
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){
// Process the logo.
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;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 5;
PropertyType PropType = PROPERTY_NONE;
// Look for type before continuing.
CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
intPrevValue = 5;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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);
ProcessStringValue(&PropertyName, "ALTID", &LogosListAltID, &PropertyValue, LogoCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", &LogosListPID, &PropertyValue, LogoCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "MEDIATYPE", &LogosListMediatype, &PropertyValue, LogoCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", &LogosListPref, &PropertyValue, LogoCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
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){
// Process the sound.
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;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 6;
PropertyType PropType = PROPERTY_NONE;
// Look for type before continuing.
CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
intPrevValue = 6;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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);
ProcessStringValue(&PropertyName, "ALTID", &SoundsListAltID, &PropertyValue, SoundCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", &SoundsListPID, &PropertyValue, SoundCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "MEDIATYPE", &SoundsListMediatype, &PropertyValue, SoundCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "LANGUAGE", &SoundsListLanguage, &PropertyValue, SoundCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", &SoundsListPref, &PropertyValue, SoundCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
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){
// Process the calendar URI.
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 intPrevValue = 8;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 7;
PropertyType PropType = PROPERTY_NONE;
// Look for type before continuing.
CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
intPrevValue = 7;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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);
ProcessStringValue(&PropertyName, "ALTID", &CalendarListAltID, &PropertyValue, CalURICount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", &CalendarListPID, &PropertyValue, CalURICount, &PropertyMatched);
ProcessStringValue(&PropertyName, "MEDIATYPE", &CalendarListMediatype, &PropertyValue, CalURICount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", &CalendarListPref, &PropertyValue, CalURICount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
SplitPoints.clear();
SplitLength.clear();
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){
// Process the calendar address URI.
std::map SplitPoints;
std::map SplitLength;
std::map::iterator SLiter;
wxString PropertyData;
wxString PropertyName;
wxString PropertyValue;
wxString PropertyTokens;
bool FirstToken = TRUE;
int intPrevValue = 8;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 7;
PropertyType PropType = PROPERTY_NONE;
// Look for type before continuing.
CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
intPrevValue = 7;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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);
ProcessStringValue(&PropertyName, "ALTID", &CalendarRequestListAltID, &PropertyValue, CalAdrURICount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", &CalendarRequestListPID, &PropertyValue, CalAdrURICount, &PropertyMatched);
ProcessStringValue(&PropertyName, "MEDIATYPE", &CalendarRequestListMediatype, &PropertyValue, CalAdrURICount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", &CalendarRequestListPref, &PropertyValue, CalAdrURICount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
SplitPoints.clear();
SplitLength.clear();
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){
// Process the calendar free busy URL.
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 intPrevValue = 7;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 6;
PropertyType PropType = PROPERTY_NONE;
// Look for type before continuing.
CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
intPrevValue = 6;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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);
ProcessStringValue(&PropertyName, "ALTID", &FreeBusyListAltID, &PropertyValue, FreeBusyAddressCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", &FreeBusyListPID, &PropertyValue, FreeBusyAddressCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "MEDIATYPE", &FreeBusyListMediatype, &PropertyValue, FreeBusyAddressCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", &FreeBusyListPref, &PropertyValue, FreeBusyAddressCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
intPropertyLen = PropertySeg2.Len();
SplitPoints.clear();
SplitLength.clear();
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){
// Process the key.
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;
SplitValues(&PropertySeg1, &SplitPoints, &SplitLength, intPrevValue);
intPrevValue = 4;
PropertyType PropType = PROPERTY_NONE;
// Look for type before continuing.
CheckType(&PropertySeg1, &SplitPoints, &SplitLength, &intPrevValue, &PropType);
intPrevValue = 4;
bool PropertyMatched = FALSE;
for (std::map::iterator intiter = SplitPoints.begin();
intiter != SplitPoints.end(); ++intiter){
SLiter = SplitLength.find(intiter->first);
PropertyData = PropertySeg1.Mid(intPrevValue, (SLiter->second));
ProcessNameValue(&PropertyData, &PropertyName, &PropertyValue);
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);
}
ProcessStringValue(&PropertyName, "ALTID", &KeyListAltID, &PropertyValue, KeyCount, &PropertyMatched);
ProcessStringValue(&PropertyName, "PID", &KeyListPID, &PropertyValue, KeyCount, &PropertyMatched);
ProcessIntegerValue(&PropertyName, "PREF", &KeyListPref, &PropertyValue, KeyCount, &PropertyMatched);
if (PropertyMatched == TRUE){
PropertyMatched = FALSE;
continue;
}
ProcessTokens(&PropertyName, &PropertyValue, &PropertyTokens, &FirstToken);
}
size_t 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){
// Process the vendor information.
// Split the Vendor three ways.
wxStringTokenizer wSTVendorDetails(PropertySeg1, wxT("-"));
wxString wxSVNDID;
wxString wxSVNDPropName;
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));
}
}
void ContactDataObject::ClearData(){
// Clear the contact information.
NameTitle.clear();
NameForename.clear();
NameSurname.clear();
NameOtherNames.clear();
NameSuffix.clear();
NameNickname.clear();
NameDisplayAs.clear();
NameLanguage.clear();
NameAltID.clear();
NameTokens.clear();
Birthday.clear();
BirthdayAltID.clear();
BirthdayCalScale.clear();
BirthdayTokens.clear();
Anniversary.clear();
AnniversaryAltID.clear();
AnniversaryCalScale.clear();
AnniversaryTokens.clear();
Gender.clear();
GenderDetails.clear();
GenderTokens.clear();
UIDToken.clear();
Revision.clear();
RevisionTokens.clear();
SourceList.clear();
SourceListAltID.clear();
SourceListPID.clear();
SourceListType.clear();
SourceListTokens.clear();
SourceListMediatype.clear();
SourceListPref.clear();
XMLList.clear();
XMLListAltID.clear();
ClientPIDList.clear();
ClientPIDListTokens.clear();
FullNamesList.clear();
FullNamesListType.clear();
FullNamesListLanguage.clear();
FullNamesListAltID.clear();
FullNamesListPID.clear();
FullNamesListTokens.clear();
FullNamesListPref.clear();
GeneralNicknamesList.clear();
GeneralNicknamesListType.clear();
GeneralNicknamesListLanguage.clear();
GeneralNicknamesListAltID.clear();
GeneralNicknamesListPID.clear();
GeneralNicknamesListTokens.clear();
GeneralNicknamesListPref.clear();
GeneralAddressList.clear();
GeneralAddressListTown.clear();
GeneralAddressListCounty.clear();
GeneralAddressListPostCode.clear();
GeneralAddressListCountry.clear();
GeneralAddressListLabel.clear();
GeneralAddressListLang.clear();
GeneralAddressListAltID.clear();
GeneralAddressListPID.clear();
GeneralAddressListTokens.clear();
GeneralAddressListGeo.clear();
GeneralAddressListTimezone.clear();
GeneralAddressListType.clear();
GeneralAddressListMediatype.clear();
GeneralAddressListPref.clear();
GeneralEmailList.clear();
GeneralEmailListAltID.clear();
GeneralEmailListPID.clear();
GeneralEmailListType.clear();
GeneralEmailListTokens.clear();
GeneralEmailListPref.clear();
GeneralIMList.clear();
GeneralIMListAltID.clear();
GeneralIMListPID.clear();
GeneralIMListType.clear();
GeneralIMListTypeInfo.clear();
GeneralIMListTokens.clear();
GeneralIMListMediatype.clear();
GeneralIMListPref.clear();
GeneralTelephoneList.clear();
GeneralTelephoneListAltID.clear();
GeneralTelephoneListPID.clear();
GeneralTelephoneListType.clear();
GeneralTelephoneListTokens.clear();
GeneralTelephoneListTypeInfo.clear();
GeneralTelephoneListPref.clear();
GeneralLanguageList.clear();
GeneralLanguageListAltID.clear();
GeneralLanguageListPID.clear();
GeneralLanguageListType.clear();
GeneralLanguageListTokens.clear();
GeneralLanguageListPref.clear();
GeneralTZList.clear();
GeneralTZListAltID.clear();
GeneralTZListPID.clear();
GeneralTZListType.clear();
GeneralTZListTokens.clear();
GeneralTZListMediatype.clear();
GeneralTZListPref.clear();
GeneralGeographyList.clear();
GeneralGeographyListAltID.clear();
GeneralGeographyListPID.clear();
GeneralGeographyListType.clear();
GeneralGeographyListTokens.clear();
GeneralGeographyListMediatype.clear();
GeneralGeographyListPref.clear();
GeneralRelatedList.clear();
GeneralRelatedListRelType.clear();
GeneralRelatedListLanguage.clear();
GeneralRelatedListAltID.clear();
GeneralRelatedListPID.clear();
GeneralRelatedListType.clear();
GeneralRelatedListTokens.clear();
GeneralRelatedListPref.clear();
GeneralWebsiteList.clear();
GeneralWebsiteListAltID.clear();
GeneralWebsiteListPID.clear();
GeneralWebsiteListType.clear();
GeneralWebsiteListTokens.clear();
GeneralWebsiteListMediatype.clear();
GeneralWebsiteListPref.clear();
GeneralTitleList.clear();
GeneralTitleListLanguage.clear();
GeneralTitleListAltID.clear();
GeneralTitleListPID.clear();
GeneralTitleListType.clear();
GeneralTitleListTokens.clear();
GeneralTitleListPref.clear();
GeneralRoleList.clear();
GeneralRoleListLanguage.clear();
GeneralRoleListAltID.clear();
GeneralRoleListPID.clear();
GeneralRoleListType.clear();
GeneralRoleListTokens.clear();
GeneralRoleListPref.clear();
GeneralOrganisationsList.clear();
GeneralOrganisationsListLanguage.clear();
GeneralOrganisationsListAltID.clear();
GeneralOrganisationsListPID.clear();
GeneralOrganisationsListType.clear();
GeneralOrganisationsListTokens.clear();
GeneralOrganisationsListSortAs.clear();
GeneralOrganisationsListPref.clear();
GeneralNoteList.clear();
GeneralNoteListLanguage.clear();
GeneralNoteListAltID.clear();
GeneralNoteListPID.clear();
GeneralNoteListType.clear();
GeneralNoteListTokens.clear();
GeneralNoteListPref.clear();
/* Items on Home Tab */
HomeNicknamesList.clear();
HomeNicknamesListType.clear();
HomeNicknamesListLanguage.clear();
HomeNicknamesListAltID.clear();
HomeNicknamesListPID.clear();
HomeNicknamesListTokens.clear();
HomeNicknamesListPref.clear();
HomeAddressList.clear();
HomeAddressListTown.clear();
HomeAddressListCounty.clear();
HomeAddressListPostCode.clear();
HomeAddressListCountry.clear();
HomeAddressListLabel.clear();
HomeAddressListLang.clear();
HomeAddressListAltID.clear();
HomeAddressListPID.clear();
HomeAddressListTokens.clear();
HomeAddressListGeo.clear();
HomeAddressListTimezone.clear();
HomeAddressListType.clear();
HomeAddressListMediatype.clear();
HomeAddressListPref.clear();
HomeEmailList.clear();
HomeEmailListAltID.clear();
HomeEmailListPID.clear();
HomeEmailListType.clear();
HomeEmailListTokens.clear();
HomeEmailListPref.clear();
HomeIMList.clear();
HomeIMListAltID.clear();
HomeIMListPID.clear();
HomeIMListType.clear();
HomeIMListTypeInfo.clear();
HomeIMListTokens.clear();
HomeIMListMediatype.clear();
HomeIMListPref.clear();
HomeTelephoneList.clear();
HomeTelephoneListAltID.clear();
HomeTelephoneListPID.clear();
HomeTelephoneListType.clear();
HomeTelephoneListTokens.clear();
HomeTelephoneListTypeInfo.clear();
HomeTelephoneListPref.clear();
HomeLanguageList.clear();
HomeLanguageListAltID.clear();
HomeLanguageListPID.clear();
HomeLanguageListType.clear();
HomeLanguageListTokens.clear();
HomeLanguageListPref.clear();
HomeTZList.clear();
HomeTZListAltID.clear();
HomeTZListPID.clear();
HomeTZListType.clear();
HomeTZListTokens.clear();
HomeTZListMediatype.clear();
HomeTZListPref.clear();
HomeGeographyList.clear();
HomeGeographyListAltID.clear();
HomeGeographyListPID.clear();
HomeGeographyListType.clear();
HomeGeographyListTokens.clear();
HomeGeographyListMediatype.clear();
HomeGeographyListPref.clear();
HomeWebsiteList.clear();
HomeWebsiteListAltID.clear();
HomeWebsiteListPID.clear();
HomeWebsiteListType.clear();
HomeWebsiteListTokens.clear();
HomeWebsiteListMediatype.clear();
HomeWebsiteListPref.clear();
HomeTitleList.clear();
HomeTitleListLanguage.clear();
HomeTitleListAltID.clear();
HomeTitleListPID.clear();
HomeTitleListType.clear();
HomeTitleListTokens.clear();
HomeTitleListPref.clear();
HomeRoleList.clear();
HomeRoleListLanguage.clear();
HomeRoleListAltID.clear();
HomeRoleListPID.clear();
HomeRoleListType.clear();
HomeRoleListTokens.clear();
HomeRoleListPref.clear();
HomeOrganisationsList.clear();
HomeOrganisationsListLanguage.clear();
HomeOrganisationsListAltID.clear();
HomeOrganisationsListPID.clear();
HomeOrganisationsListType.clear();
HomeOrganisationsListTokens.clear();
HomeOrganisationsListSortAs.clear();
HomeOrganisationsListPref.clear();
HomeNoteList.clear();
HomeNoteListLanguage.clear();
HomeNoteListAltID.clear();
HomeNoteListPID.clear();
HomeNoteListType.clear();
HomeNoteListTokens.clear();
HomeNoteListPref.clear();
/* Items on the Business tab */
BusinessNicknamesList.clear();
BusinessNicknamesListType.clear();
BusinessNicknamesListLanguage.clear();
BusinessNicknamesListAltID.clear();
BusinessNicknamesListPID.clear();
BusinessNicknamesListTokens.clear();
BusinessNicknamesListPref.clear();
BusinessAddressList.clear();
BusinessAddressListTown.clear();
BusinessAddressListCounty.clear();
BusinessAddressListPostCode.clear();
BusinessAddressListCountry.clear();
BusinessAddressListLabel.clear();
BusinessAddressListLang.clear();
BusinessAddressListAltID.clear();
BusinessAddressListPID.clear();
BusinessAddressListTokens.clear();
BusinessAddressListGeo.clear();
BusinessAddressListTimezone.clear();
BusinessAddressListType.clear();
BusinessAddressListMediatype.clear();
BusinessAddressListPref.clear();
BusinessEmailList.clear();
BusinessEmailListAltID.clear();
BusinessEmailListPID.clear();
BusinessEmailListType.clear();
BusinessEmailListTokens.clear();
BusinessEmailListPref.clear();
BusinessIMList.clear();
BusinessIMListAltID.clear();
BusinessIMListPID.clear();
BusinessIMListType.clear();
BusinessIMListTokens.clear();
BusinessIMListMediatype.clear();
BusinessIMListPref.clear();
BusinessTelephoneList.clear();
BusinessTelephoneListAltID.clear();
BusinessTelephoneListPID.clear();
BusinessTelephoneListType.clear();
BusinessTelephoneListTokens.clear();
BusinessTelephoneListPref.clear();
BusinessLanguageList.clear();
BusinessLanguageListAltID.clear();
BusinessLanguageListPID.clear();
BusinessLanguageListType.clear();
BusinessLanguageListTokens.clear();
BusinessLanguageListPref.clear();
BusinessTZList.clear();
BusinessTZListAltID.clear();
BusinessTZListPID.clear();
BusinessTZListType.clear();
BusinessTZListTokens.clear();
BusinessTZListMediatype.clear();
BusinessTZListPref.clear();
BusinessGeographyList.clear();
BusinessGeographyListAltID.clear();
BusinessGeographyListPID.clear();
BusinessGeographyListType.clear();
BusinessGeographyListTokens.clear();
BusinessGeographyListMediatype.clear();
BusinessGeographyListPref.clear();
BusinessWebsiteList.clear();
BusinessWebsiteListAltID.clear();
BusinessWebsiteListPID.clear();
BusinessWebsiteListType.clear();
BusinessWebsiteListTokens.clear();
BusinessWebsiteListMediatype.clear();
BusinessWebsiteListPref.clear();
BusinessTitleList.clear();
BusinessTitleListLanguage.clear();
BusinessTitleListAltID.clear();
BusinessTitleListPID.clear();
BusinessTitleListType.clear();
BusinessTitleListTokens.clear();
BusinessTitleListPref.clear();
BusinessRoleList.clear();
BusinessRoleListLanguage.clear();
BusinessRoleListAltID.clear();
BusinessRoleListPID.clear();
BusinessRoleListType.clear();
BusinessRoleListTokens.clear();
BusinessRoleListPref.clear();
BusinessOrganisationsList.clear();
BusinessOrganisationsListLanguage.clear();
BusinessOrganisationsListAltID.clear();
BusinessOrganisationsListPID.clear();
BusinessOrganisationsListType.clear();
BusinessOrganisationsListTokens.clear();
BusinessOrganisationsListSortAs.clear();
BusinessOrganisationsListPref.clear();
BusinessNoteList.clear();
BusinessNoteListLanguage.clear();
BusinessNoteListAltID.clear();
BusinessNoteListPID.clear();
BusinessNoteListType.clear();
BusinessNoteListTokens.clear();
BusinessNoteListPref.clear();
/* Items on the Categories tab */
CategoriesList.clear();
CategoriesListAltID.clear();
CategoriesListPID.clear();
CategoriesListType.clear();
CategoriesListTokens.clear();
CategoriesListLanguage.clear();
CategoriesListPref.clear();
/* Items on the Groups tab */
GroupsList.clear();
GroupsListAltID.clear();
GroupsListPID.clear();
GroupsListType.clear();
GroupsListMediaType.clear();
GroupsListTokens.clear();
GroupsListPref.clear();
/* Items on the Pictures tab */
PicturesList.clear();
PicturesListAltID.clear();
PicturesListPID.clear();
PicturesListType.clear();
PicturesListPicEncType.clear();
PicturesListPictureType.clear();
PicturesListTokens.clear();
PicturesListMediatype.clear();
PicturesListPref.clear();
/* Items on the Logos tab */
LogosList.clear();
LogosListAltID.clear();
LogosListPID.clear();
LogosListType.clear();
LogosListPicEncType.clear();
LogosListPictureType.clear();
LogosListTokens.clear();
LogosListMediatype.clear();
LogosListPref.clear();
/* Items on the Sounds tab */
SoundsList.clear();
SoundsListAltID.clear();
SoundsListPID.clear();
SoundsListType.clear();
SoundsListAudioEncType.clear();
SoundsListAudioType.clear();
SoundsListTokens.clear();
SoundsListMediatype.clear();
SoundsListPref.clear();
/* Items on the Calendaring tab */
CalendarList.clear();
CalendarListAltID.clear();
CalendarListPID.clear();
CalendarListType.clear();
CalendarListTokens.clear();
CalendarListMediatype.clear();
CalendarListPref.clear();
CalendarRequestList.clear();
CalendarRequestListAltID.clear();
CalendarRequestListPID.clear();
CalendarRequestListType.clear();
CalendarRequestListTokens.clear();
CalendarRequestListMediatype.clear();
CalendarRequestListPref.clear();
FreeBusyList.clear();
FreeBusyListAltID.clear();
FreeBusyListPID.clear();
FreeBusyListType.clear();
FreeBusyListTokens.clear();
FreeBusyListMediatype.clear();
FreeBusyListPref.clear();
/* Items on the Security tab */
KeyList.clear();
KeyListAltID.clear();
KeyListPID.clear();
KeyListKeyType.clear();
KeyListDataType.clear();
KeyListDataEncType.clear();
KeyListType.clear();
KeyListTokens.clear();
KeyListPref.clear();
/* Items on the Other tab */
VendorList.clear();
VendorListPEN.clear();
VendorListElement.clear();
XTokenList.clear();
XTokenListTokens.clear();
}
void ProcessNameValue(wxString *PropertyData,
wxString *PropertyName,
wxString *PropertyValue){
// Proces the name and value information.
wxStringTokenizer PropertyElement (*PropertyData, wxT("="));
*PropertyName = PropertyElement.GetNextToken();
*PropertyValue = PropertyElement.GetNextToken();
}
void ProcessTokens(wxString *PropertyName,
wxString *PropertyValue,
wxString *PropertyTokens,
bool *FirstToken){
// Process the tokens.
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);
}
}
}
void ProcessStringValue(wxString *PropertyName,
wxString PropertyNameMatch,
std::map *MapPtr,
wxString *PropertyValue,
int *ItemCount,
bool *PropertyMatched){
// Process the string value.
if (*PropertyName == PropertyNameMatch){
MapPtr->erase(*ItemCount);
MapPtr->insert(std::make_pair(*ItemCount, *PropertyValue));
*PropertyMatched = TRUE;
}
}
void ProcessIntegerValue(wxString *PropertyName,
wxString PropertyNameMatch,
std::map *PrefPtr,
wxString *PropertyValue,
int *ItemCount,
bool *PropertyMatched){
// Process the integer value.
if (*PropertyName == PropertyNameMatch){
*PropertyMatched = TRUE;
} else {
return;
}
int PriorityNumber = 0;
bool ValidNumber = TRUE;
try{
PriorityNumber = std::stoi(PropertyValue->ToStdString());
}
catch(std::invalid_argument &e){
ValidNumber = FALSE;
}
if (ValidNumber == TRUE){
PrefPtr->erase(*ItemCount);
PrefPtr->insert(std::make_pair(*ItemCount, PriorityNumber));
}
}
void SplitValues(wxString *PropertyLine,
std::map *SplitPoints,
std::map *SplitLength,
int intSize){
// Split values from a string supplied by PropertyLine.
size_t intPropertyLen = PropertyLine->Len();
int intSplitsFound = 0;
int intSplitSize = 0;
int intSplitSeek = 0;
for (int i = intSize; i <= intPropertyLen; i++){
intSplitSize++;
if (PropertyLine->Mid(i, 1) == wxT(";") &&
PropertyLine->Mid((i - 1), 1) != wxT("\\")){
if (intSplitsFound == 0){
SplitLength->insert(std::make_pair(intSplitsFound, (intSplitSize)));
} else {
SplitLength->insert(std::make_pair(intSplitsFound, (intSplitSize - 1)));
}
SplitPoints->insert(std::make_pair(intSplitsFound, (i + 1)));
intSplitsFound++;
intSplitSeek = i;
intSplitSize = 0;
}
}
if (intSplitsFound == 0){
SplitPoints->insert(std::make_pair(intSplitsFound, (8 + 1)));
SplitLength->insert(std::make_pair(intSplitsFound, intSplitSize));
} else {
SplitPoints->insert(std::make_pair(intSplitsFound, (intSplitSeek + 1)));
SplitLength->insert(std::make_pair(intSplitsFound, intSplitSize));
}
}
void CheckType(wxString *PropertySeg1,
std::map *SplitPoints,
std::map