public WriteFileWorker(
object sender,
ProgressReporterInterface progress,
string filename,
FamilyFileTypeOperation operation,
int filterIndex,
ref FamilyTreeStoreBaseClass tree)
{
trace = new TraceSource("WriteFileWorker", SourceLevels.Warning);
trace.TraceInformation("WriteFileWorker(" + filename + ")" + DateTime.Now);
progressString = "Exporting...";
familyTree = tree;
this.operation = operation;
this.filterIndex = filterIndex;
progressReporter = progress;
backgroundWorker = new BackgroundWorker();
backgroundWorker.WorkerReportsProgress = true;
backgroundWorker.DoWork += new DoWorkEventHandler(DoWork);
backgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(Completed);
backgroundWorker.ProgressChanged += new ProgressChangedEventHandler(ProgressChanged);
backgroundWorker.RunWorkerAsync(filename);
}
public void FileLoadProgress(int progressPercent, string text = null)
{
trace.TraceInformation("FamilyForm2::FileLoadProgress(" + progressPercent + ")");
if (progressPercent < 0)
{
familyTree = readFileWorker.GetFamilyTree();
if (familyTree != null)
{
if (trace.Switch.Level.HasFlag(SourceLevels.Information))
{
familyTree.Print();
}
toolStripProgressBar1.Visible = false;
toolStripStatusLabel1.Text = familyTree.GetShortTreeInfo();//"I:" + familyTree.individualList.Count + " F:" + familyTree.familyList.Count + " N:" + familyTree.noteList.Count;
//PopulatePersonList();
ConnectPanelsToTree(familyTree);
}
else
{
trace.TraceEvent(TraceEventType.Error, 0, " Error: tree == null! " + DateTime.Now);
}
progressReporter = null;
readFileWorker = null;
}
else
{
TextCallback(progressPercent, text);
}
}
private void ReportMatchingProfiles(FamilyTreeStoreBaseClass familyTree1, string person1, FamilyTreeStoreBaseClass familyTree2, string person2)
{
IndividualClass person1full = familyTree1.GetIndividual(person1);
IndividualClass person2full = familyTree2.GetIndividual(person2);
resultReporterFunction(CreateListItem(familyTree1, person1full, familyTree2, person2full));
}
public static void CompareTrees(FamilyTreeStoreBaseClass familyTree1, FamilyTreeStoreBaseClass familyTree2, ReportCompareResult reportDuplicate, ProgressReporterInterface reporter = null)
{
IEnumerator <IndividualClass> iterator1;
int cnt1 = 0;
iterator1 = familyTree1.SearchPerson(null, reporter);
trace.TraceInformation("CompareTrees() started");
if (iterator1 != null)
{
do
{
IndividualClass person1 = iterator1.Current;
cnt1++;
if (person1 != null)
{
trace.TraceInformation(" 1:" + person1.GetName());
SearchDuplicates(person1, familyTree1, familyTree2, reportDuplicate, reporter);
}
} while (iterator1.MoveNext());
iterator1.Dispose();
}
else
{
trace.TraceInformation("iter=null");
}
trace.TraceInformation("CompareTrees() done");
}
public RelationTreeWorker(
object sender,
ProgressReporterInterface progress,
string startPerson1Xref,
string startPerson2Xref,
int noOfGenerations,
FamilyTreeStoreBaseClass familyTree)
{
trace = new TraceSource("RelationTreeWorker", SourceLevels.Information);
//familyTree = stats.familyTree;
progressReporter = progress;
//this.stats = stats;
this.familyTree = familyTree;
this.startPerson1Xref = startPerson1Xref;
this.startPerson2Xref = startPerson2Xref;
this.noOfGenerations = noOfGenerations;
this.relationList = new RelationStackList();
backgroundWorker = new BackgroundWorker();
backgroundWorker.WorkerReportsProgress = true;
backgroundWorker.DoWork += new DoWorkEventHandler(DoWork);
backgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(Completed);
backgroundWorker.ProgressChanged += new ProgressChangedEventHandler(ProgressChanged);
backgroundWorker.RunWorkerAsync();
}
public override bool OpenFile(String fileName, ref FamilyTreeStoreBaseClass inFamilyTree, CompletedCallback callback)
{
//FamilyTreeStoreRam ramStore = (FamilyTreeStoreRam)inFamilyTree;
trace.TraceInformation("XmlFileType::OpenFile( " + fileName + ") start " + DateTime.Now);
FileStream fileStream = new FileStream(fileName, FileMode.Open);
if (fileStream != null)
{
//DataContractSerializer serializer = new DataContractSerializer(typeof(FamilyTreeStoreRam));
DataContractSerializer serializer = new DataContractSerializer(inFamilyTree.GetType());
try
{
inFamilyTree = (FamilyTreeStoreBaseClass)serializer.ReadObject(fileStream);
}
catch (SerializationException e)
{
trace.TraceInformation("Exceptions:" + e.ToString());
inFamilyTree = null;
}
catch (ArgumentNullException e)
{
trace.TraceInformation("Exceptions:" + e.ToString());
inFamilyTree = null;
}
fileStream.Close();
}
trace.TraceInformation("XmlFileType::OpenFile( " + fileName + ") done " + DateTime.Now);
//anarkivStore.SetFile(fileName);
callback(true);
return(true);
}
public override void SetFamilyTree(FamilyTreeStoreBaseClass inFamilyTree)
{
trace.TraceInformation("TreeViewPanel1::SetFamilyTree()");
familyTree = inFamilyTree;
layoutDone = false;
}
public override bool OpenFile(String fileName, ref FamilyTreeStoreBaseClass inFamilyTree, CompletedCallback callback)
{
trace.TraceInformation("GedcomDecoder::OpenFile( " + fileName + ")");
bool result = ReadFile(fileName, ref inFamilyTree);
callback(result);
return(result);
}
public override void SetFamilyTree(FamilyTreeStoreBaseClass inFamilyTree)
{
if (printMode)
{
Debug.WriteLine("ImageViewPanel1::SetFamilyTree()");
}
familyTree = inFamilyTree;
}
public FindFamilyThread(FamilyTreeStoreBaseClass familyTree, string familyXref, HandleNewFamily familyCallback)
{
this.familyTree = familyTree;
backgroundWorker = new BackgroundWorker();
this.familyCallback = familyCallback;
backgroundWorker.DoWork += new DoWorkEventHandler(DoWork);
backgroundWorker.RunWorkerAsync(familyXref);
this.familyXref = familyXref;
trace.TraceInformation("FindFamilyThread(" + familyXref + ")-start");
}
public FamilyForm2(bool createTree = false)
{
trace = new TraceSource("FamilyForm2", SourceLevels.Warning);
nextTreeTabToAdd = 0;
nextPersonTabToAdd = 0;
InitializeComponent();
filterList = new List <IndividualFilterClass>();
panelList = new List <TreeViewPanelBaseClass>();
AddSearchPanel(new SearchPanel1());
AddTreePanel(new AsyncTreePanel1());
AddTreePanel(new TreeViewPanel2());
AddTreePanel(new TreeViewPanel4());
AddTreePanel(new TreeViewPanel5());
AddTreePanel(new TreeViewPanel1());
AddTreePanel(new ImageViewPanel1());
AddPersonPanel(new PersonViewPanel1());
AddPersonPanel(new SearchPanel1());
AddPersonPanel(new CompletenessViewPanel1());
AddPersonPanel(new RelationFinderPanel());
//AddPersonPanel(new ComparePanel1());
AddPersonPanel(new NotePanel());
searchResultXrefList = new List <string>();
foreach (TreeViewPanelBaseClass panel in panelList)
{
panel.SetParentForm(this);
}
m_addPersonForm = new AddPersonForm();
m_addPersonForm.SetEventHandler(new System.EventHandler(AddPersonEvent));
m_addPersonForm.Visible = false;
if (createTree)
{
FamilyFileTypeCollection codec = new FamilyFileTypeCollection();
//familyTree = new FamilyTreeStoreRam();
//FamilyFileEncoderCollection codec = new FamilyFileEncoderCollection();
familyTree = codec.CreateFamilyTreeStore("", CompletedCallback);
//ConnectPanelsToTree(familyTree);
}
updateTimer = new System.Windows.Forms.Timer();
updateTimer.Tick += new EventHandler(TimerEventProcessor);
updateTimer.Interval = 1000 * 10; // 10 seconds
updateTimer.Enabled = true;
}
public override bool OpenFile(String fileName, ref FamilyTreeStoreBaseClass inFamilyTree, CompletedCallback callback)
{
FamilyTreeStoreMyHeritage myHeritageStore = (FamilyTreeStoreMyHeritage)inFamilyTree;
if (printFlag)
{
trace.TraceInformation("MyHeritageFileType::OpenFile( " + fileName + ")");
}
myHeritageStore.SetFile(fileName);
callback(true);
return(true);
}
public AnarkivMappers(FamilyTreeStoreBaseClass familyTree)
{
this.familyTree = familyTree;
individualXrefMapper = new Dictionary <string, XrefMapperClass>();
familyXrefMapper = new Dictionary <string, XrefMapperClass>();
multimediaXrefMapper = new Dictionary <string, XrefMapperClass>();
noteXrefMapper = new Dictionary <string, XrefMapperClass>();
repositoryXrefMapper = new Dictionary <string, XrefMapperClass>();
sourceXrefMapper = new Dictionary <string, XrefMapperClass>();
submissionXrefMapper = new Dictionary <string, XrefMapperClass>();
submitterXrefMapper = new Dictionary <string, XrefMapperClass>();
}
public FindPersonThread(FamilyTreeStoreBaseClass familyTree, string personXref, HandleNewIndividual individualCallback)
{
this.familyTree = familyTree;
backgroundWorker = new BackgroundWorker();
this.personCallback = individualCallback;
backgroundWorker.DoWork += new DoWorkEventHandler(DoWork);
//backgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(Completed);
backgroundWorker.RunWorkerAsync(personXref);
this.personXref = personXref;
trace.TraceInformation("FindPersonThread(" + personXref + ")-started");
}
public override bool OpenFile(String fileName, ref FamilyTreeStoreBaseClass inFamilyTree, CompletedCallback callback)
{
FamilyTreeStoreGeni2 GeniStore = (FamilyTreeStoreGeni2)inFamilyTree;
trace.TraceInformation("GeniFileType::OpenFile( " + fileName + ")");
GeniStore.SetFile(fileName);
if (!GeniStore.CallbackArmed())
{
callback(true);
}
return(true);
}
void ReadListFromFile()
{
OpenFileDialog fileDlg = new OpenFileDialog();
fileDlg.InitialDirectory = utility.GetCurrentDirectory();
fileDlg.Filter = "Compare List|*.fsc";
if (fileDlg.ShowDialog(this) == System.Windows.Forms.DialogResult.OK)
{
DataContractSerializer serializer = new DataContractSerializer(typeof(SavedMatches));
FileStream readFile = new FileStream(fileDlg.FileName, FileMode.Open);
SavedMatches matches;
matches = (SavedMatches)serializer.ReadObject(readFile);
readFile.Close();
bool found1 = false;
bool found2 = false;
familyTree1 = null;
familyTree2 = null;
int i = 0;
foreach (FamilyForm2 form in formList)
{
if (matches.database1 == form.Text)
{
found1 = true;
selectedForm1 = form;
familyTree1 = form.GetTree();
listBox1.SelectedIndex = i;
}
if (matches.database2 == form.Text)
{
found2 = true;
selectedForm2 = form;
familyTree2 = form.GetTree();
listBox2.SelectedIndex = i;
}
i++;
}
if (found1 && found2)
{
matchListView1.Items.Clear();
AsyncWorkerProgress reporter = new AsyncWorkerProgress(WorkProgress);
compareWorker = new CompareTreeWorker(this, matches, reporter, familyTree1, familyTree2, ReportCompareResultFunction);
}
}
}
public void StoreFile(FamilyTreeStoreBaseClass familyTree, string filename, FamilyFileTypeOperation operation, int variant = 0)
{
trace.TraceInformation("XmlEncoder::StoreFile() start " + DateTime.Now);
FileStream fileStream = new FileStream(filename, FileMode.Create);
DataContractSerializer serializer = new DataContractSerializer(familyTree.GetType());
serializer.WriteObject(fileStream, familyTree);
fileStream.Close();
trace.TraceInformation("XmlEncoder::StoreFile() done " + DateTime.Now);
}
private void button1_Click(object sender, EventArgs e)
{
if (compareWorker != null)
{
trace.TraceInformation("Warning, compare already running...");
return;
}
if (listBox1.SelectedIndex < 0)
{
MessageBox.Show("No tree selected as first", "Error", MessageBoxButtons.OK);
return;
}
if (listBox2.SelectedIndex < 0)
{
MessageBox.Show("No tree selected as second", "Error", MessageBoxButtons.OK);
return;
}
string name1 = listBox1.Items[listBox1.SelectedIndex].ToString();
string name2 = listBox2.Items[listBox2.SelectedIndex].ToString();
FamilyTreeStoreBaseClass familyTree1 = null;
FamilyTreeStoreBaseClass familyTree2 = null;
foreach (FamilyForm2 form in formList)
{
if (form.Text.IndexOf(name1) >= 0)
{
familyTree1 = form.GetTree();
selectedForm1 = form;
}
if (form.Text.IndexOf(name2) >= 0)
{
familyTree2 = form.GetTree();
selectedForm2 = form;
}
}
if ((familyTree1 != null) && (familyTree2 != null))
{
matchListView1.Items.Clear();
AsyncWorkerProgress reporter = new AsyncWorkerProgress(WorkProgress);
compareWorker = new CompareTreeWorker(this, null, reporter, familyTree1, familyTree2, ReportCompareResultFunction);
button1.Text = "Stop";
}
}
public bool OpenFile(String fileName, ref FamilyTreeStoreBaseClass inFamilyTree, CompletedCallback callback)
{
foreach (FamilyFileTypeBaseClass fileType in codecList)
{
trace.TraceInformation("OpenFile(" + fileName + "):" + fileType.GetType() + ":" + fileType.IsKnownFileType(fileName));
if (fileType.IsKnownFileType(fileName))
{
//selectedType = GetType(fileType);
return(fileType.OpenFile(fileName, ref inFamilyTree, callback));
}
}
callback(false);
return(false);
}
public override bool OpenFile(String fileName, ref FamilyTreeStoreBaseClass inFamilyTree, CompletedCallback callback)
{
FamilyTreeStoreAnarkiv anarkivStore;
if (inFamilyTree.GetType() == typeof(FamilyTreeStoreAnarkiv))
{
anarkivStore = (FamilyTreeStoreAnarkiv)inFamilyTree;
}
else
{
anarkivStore = (FamilyTreeStoreAnarkiv)CreateFamilyTreeStore(fileName, callback);
ReadFile(ref inFamilyTree, anarkivStore);
}
trace.TraceInformation("AnarkivFileType::OpenFile( " + fileName + ")");
anarkivStore.SetFile(fileName);
callback(true);
return(true);
}
private void ConnectPanelsToTree(FamilyTreeStoreBaseClass tree)
{
foreach (TreeViewPanelBaseClass panel in panelList)
{
panel.SetFamilyTree(tree);
}
if (tree.GetIndividual() != null)
{
foreach (TreeViewPanelBaseClass panel in panelList)
{
panel.OnSelectedPersonChangedEvent(this, new PersonChangeEvent(tree.GetIndividual()));
//panel.SetSelectedIndividual(tree.GetIndividual().GetXrefName());
}
}
else
{
trace.TraceEvent(TraceEventType.Error, 0, " Error: GetIndividual(first) == null! " + DateTime.Now);
}
}
public ReadFileWorker(
object sender,
ProgressReporterInterface progress,
string filename,
ref FamilyTreeStoreBaseClass tree,
CompletedCallback callback)
{
trace = new TraceSource("ReadFileWorker", SourceLevels.Warning);
familyTree = tree;
progressReporter = progress;
backgroundWorker = new BackgroundWorker();
backgroundWorker.WorkerReportsProgress = true;
backgroundWorker.DoWork += new DoWorkEventHandler(DoWork);
backgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(Completed);
backgroundWorker.ProgressChanged += new ProgressChangedEventHandler(ProgressChanged);
completedCallback = callback;
codec = new FamilyFileTypeCollection();
if (codec.IsKnownFileType(filename))
{
trace.TraceInformation("ReadFileWorker.DoWork(" + filename + "): OK!" + DateTime.Now);
if (familyTree == null)
{
familyTree = codec.CreateFamilyTreeStore(filename, completedCallback);
}
codec.SetProgressTarget(backgroundWorker);
familyTree.SetSourceFileName(filename);
}
else
{
trace.TraceInformation("ReadFileWorker(" + workerFileName + "): Filetype unknown!" + DateTime.Now);
}
workerFileName = filename;
backgroundWorker.RunWorkerAsync(filename);
}
void SearchTree(FamilyTreeStoreBaseClass familyTree, String searchString)
{
IEnumerator <IndividualClass> iterator;
iterator = familyTree.SearchPerson(searchString, progressReporter);
if (iterator != null)
{
while (iterator.MoveNext())
{
IndividualClass person = (IndividualClass)iterator.Current;
if (person != null)
{
AddToSearchResults(person);
}
}
}
}
public TreeWorker(
SearchPanel1 sender,
ProgressReporterInterface progress,
string searchString,
ref FamilyTreeStoreBaseClass familyTree)
{
trace = new TraceSource("TreeWorker", SourceLevels.Warning);
parentWindow = sender;
progressReporter = progress;
this.familyTree = familyTree;
this.searchString = searchString;
backgroundWorker = new BackgroundWorker();
backgroundWorker.WorkerReportsProgress = true;
backgroundWorker.DoWork += new DoWorkEventHandler(DoWork);
backgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(Completed);
backgroundWorker.ProgressChanged += new ProgressChangedEventHandler(ProgressChanged);
backgroundWorker.RunWorkerAsync(searchString);
}
public void StoreFile(FamilyTreeStoreBaseClass familyTree, string filename, FamilyFileTypeOperation operation, int variant = 0)
{
trace.TraceInformation("FamilyFileEncoderCollection.StoreFile({0},{1})", filename, variant);
if (encoderMapList.Count == 0)
{
// We should never have to generate a filter
// list with only one variant at this level...
// The variant parameter has another meaning in this
// class compared to real encoder classes...
GetFileTypeFilter(operation);
}
if (variant < encoderMapList.Count)
{
selectedEncoder = encoderMapList[variant].encoder;
if (storedProgressTarget != null)
{
selectedEncoder.SetProgressTarget(storedProgressTarget);
storedProgressTarget = null;
}
selectedEncoder.StoreFile(familyTree, filename, operation, encoderMapList[variant].variant);
return;
}
foreach (FamilyFileEncoder encoder in encoderList)
{
if (encoder.IsKnownFileType(filename))
{
selectedEncoder = encoder;
if (storedProgressTarget != null)
{
encoder.SetProgressTarget(storedProgressTarget);
storedProgressTarget = null;
}
encoder.StoreFile(familyTree, filename, operation, variant);
}
}
}
public CompareTreeWorker(
object sender,
SavedMatches matches,
AsyncWorkerProgress progress,
FamilyTreeStoreBaseClass familyTree1,
FamilyTreeStoreBaseClass familyTree2,
ReportCompareResult resultReporter)
{
trace = new TraceSource("CompareTreeWorker", SourceLevels.All);
resultReporterFunction = resultReporter;
progressReporter = progress;
this.matches = matches;
backgroundWorker = new BackgroundWorker();
backgroundWorker.WorkerReportsProgress = true;
if (matches == null)
{
backgroundWorker.DoWork += new DoWorkEventHandler(DoWork);
}
else
{
backgroundWorker.DoWork += new DoWorkEventHandler(DoWorkLoadFile);
}
backgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(Completed);
backgroundWorker.ProgressChanged += new ProgressChangedEventHandler(ProgressChanged);
WorkerInterface workerInterface = new WorkerInterface();
workerInterface.familyTree1 = familyTree1;
workerInterface.familyTree2 = familyTree2;
backgroundWorker.RunWorkerAsync(workerInterface);
}
public static void SearchDuplicates(IndividualClass person1, FamilyTreeStoreBaseClass familyTree1, FamilyTreeStoreBaseClass familyTree2, ReportCompareResult reportDuplicate, ProgressReporterInterface reporter = null)
{
IndividualEventClass birth = person1.GetEvent(IndividualEventClass.EventType.Birth);
IndividualEventClass death = person1.GetEvent(IndividualEventClass.EventType.Death);
if (reporter != null)
{
trace.TraceInformation(reporter.ToString());
}
if (((birth != null) && (birth.GetDate() != null) && (birth.GetDate().ValidDate())) ||
((death != null) && (death.GetDate() != null) && (death.GetDate().ValidDate())))
{
string fullName = person1.GetName().Replace("*", "");
IEnumerator <IndividualClass> iterator2 = familyTree2.SearchPerson(fullName);
int cnt2 = 0;
if (iterator2 != null)
{
int cnt3 = 0;
do
{
IndividualClass person2 = iterator2.Current;
if (person2 != null)
{
cnt3++;
//trace.TraceInformation(reporter.ToString() + " 2:" + person2.GetName());
if ((familyTree1 != familyTree2) || (person1.GetXrefName() != person2.GetXrefName()))
{
if (ComparePerson(person1, person2))
{
reportDuplicate(familyTree1, person1.GetXrefName(), familyTree2, person2.GetXrefName());
}
cnt2++;
}
}
} while (iterator2.MoveNext());
iterator2.Dispose();
trace.TraceInformation(" " + fullName + " matched with " + cnt2 + "," + cnt3);
}
if (cnt2 == 0) // No matches found for full name
{
if ((person1.GetPersonalName().GetName(PersonalNameClass.PartialNameType.BirthSurname).Length > 0) &&
(person1.GetPersonalName().GetName(PersonalNameClass.PartialNameType.Surname).Length > 0) &&
!person1.GetPersonalName().GetName(PersonalNameClass.PartialNameType.Surname).Equals(person1.GetPersonalName().GetName(PersonalNameClass.PartialNameType.BirthSurname)))
{
String strippedName = person1.GetName().Replace("*", "");
if (strippedName.Contains(person1.GetPersonalName().GetName(PersonalNameClass.PartialNameType.Surname)))
{
String maidenName = strippedName.Replace(person1.GetPersonalName().GetName(PersonalNameClass.PartialNameType.Surname), "").Replace(" ", " ");
IEnumerator <IndividualClass> iterator3 = familyTree2.SearchPerson(maidenName);
//trace.TraceInformation(" Searching Maiden name " + maidenName);
if (iterator3 != null)
{
int cnt3 = 0;
do
{
IndividualClass person2 = iterator3.Current;
if (person2 != null)
{
if ((familyTree1 != familyTree2) || (person1.GetXrefName() != person2.GetXrefName()))
{
cnt3++;
if (ComparePerson(person1, person2))
{
reportDuplicate(familyTree1, person1.GetXrefName(), familyTree2, person2.GetXrefName());
}
}
}
} while (iterator3.MoveNext());
iterator3.Dispose();
trace.TraceInformation(" Maiden name " + maidenName + " mathched with " + cnt3);
}
}
if (strippedName.Contains(person1.GetPersonalName().GetName(PersonalNameClass.PartialNameType.BirthSurname)))
{
String marriedName = strippedName.Replace(person1.GetPersonalName().GetName(PersonalNameClass.PartialNameType.BirthSurname), "").Replace(" ", " ");
IEnumerator <IndividualClass> iterator3 = familyTree2.SearchPerson(marriedName);
//trace.TraceInformation(" Searching Married name " + marriedName);
if (iterator3 != null)
{
int cnt3 = 0;
do
{
//IndividualClass person1 = iterator1.Current;
IndividualClass person2 = iterator3.Current;
if (person2 != null)
{
//trace.TraceInformation(reporter.ToString() + " 2:" + person2.GetName());
if ((familyTree1 != familyTree2) || (person1.GetXrefName() != person2.GetXrefName()))
{
cnt3++;
if (ComparePerson(person1, person2))
{
reportDuplicate(familyTree1, person1.GetXrefName(), familyTree2, person2.GetXrefName());
}
}
}
} while (iterator3.MoveNext());
iterator3.Dispose();
trace.TraceInformation(" Married name " + marriedName + " matched to " + cnt3);
}
}
}
}
}
else
{
trace.TraceInformation("No valid birth or death date for " + person1.GetName().ToString() + " skip duplicate search");
}
}
public abstract bool OpenFile(String fileName, ref FamilyTreeStoreBaseClass inFamilyTree, CompletedCallback callback);
private void ReadFile(ref FamilyTreeStoreBaseClass inFamilyTree, FamilyTreeStoreAnarkiv anarkivStore)
{
//IndividualClass person = anarkivStore.GetIndividual();
IEnumerator <IndividualClass> people = anarkivStore.SearchPerson();
AnarkivMappers mappers = new AnarkivMappers(inFamilyTree);
IDictionary <string, XrefMapperClass> individualMapper = mappers.GetMapper(XrefType.Individual);
IDictionary <string, XrefMapperClass> familyMapper = mappers.GetMapper(XrefType.Family);
int counter = 0;
while (people.MoveNext())
{
IndividualClass person = people.Current;
trace.TraceInformation("Person[" + counter++ + "]:" + person.GetPersonalName().ToString());
IndividualXrefClass xref = new IndividualXrefClass(inFamilyTree.CreateNewXref(XrefType.Individual));
individualMapper.Add(person.GetXrefName(), new XrefMapperClass(xref.GetXrefName(), true));
person.SetXrefName(xref.GetXrefName());
if (person.GetFamilyChildList() != null)
{
IList <FamilyXrefClass> newChildFamilies = new List <FamilyXrefClass>();
foreach (FamilyXrefClass childFamily in person.GetFamilyChildList())
{
FamilyXrefClass newFamily = new FamilyXrefClass(mappers.GetLocalXRef(XrefType.Family, childFamily.GetXrefName()));
newChildFamilies.Add(newFamily);
}
person.SetFamilyChildList(newChildFamilies);
}
if (person.GetFamilySpouseList() != null)
{
IList <FamilyXrefClass> newSpouseFamilies = new List <FamilyXrefClass>();
foreach (FamilyXrefClass spouseFamily in person.GetFamilySpouseList())
{
FamilyXrefClass newFamily = new FamilyXrefClass(mappers.GetLocalXRef(XrefType.Family, spouseFamily.GetXrefName()));
newSpouseFamilies.Add(newFamily);
}
person.SetFamilySpouseList(newSpouseFamilies);
}
inFamilyTree.AddIndividual(person);
}
IEnumerator <FamilyClass> familyEnumerator = anarkivStore.SearchFamily();
counter = 0;
while (familyEnumerator.MoveNext())
{
FamilyClass family = familyEnumerator.Current;
FamilyClass newFamily = new FamilyClass();
trace.TraceInformation("Family[" + counter++ + "]:" + family.GetXrefName());
newFamily.SetXrefName(mappers.GetLocalXRef(XrefType.Family, family.GetXrefName(), true));
trace.TraceInformation("Family xref " + family.GetXrefName() + " ==> " + newFamily.GetXrefName());
if (family.GetParentList() != null)
{
//IList<IndividualXrefClass> newParentList = new List<IndividualXrefClass>();
foreach (IndividualXrefClass parent in family.GetParentList())
{
IndividualXrefClass newParent = new IndividualXrefClass(mappers.GetLocalXRef(XrefType.Individual, parent.GetXrefName()));
//newParentList.Add(newParent);
newFamily.AddRelation(newParent, FamilyClass.RelationType.Parent);
trace.TraceInformation(" add parent " + parent.GetXrefName() + " => " + newParent.GetXrefName());
}
}
if (family.GetChildList() != null)
{
//IList<IndividualXrefClass> newChildList = new List<IndividualXrefClass>();
foreach (IndividualXrefClass child in family.GetChildList())
{
IndividualXrefClass newChild = new IndividualXrefClass(mappers.GetLocalXRef(XrefType.Individual, child.GetXrefName()));
//newChildList.Add(newChild);
newFamily.AddRelation(newChild, FamilyClass.RelationType.Child);
trace.TraceInformation(" add child " + child.GetXrefName() + " => " + newChild.GetXrefName());
}
}
//family.
inFamilyTree.AddFamily(newFamily);
}
}
public abstract void SetFamilyTree(FamilyTreeStoreBaseClass inFamilyTree);
