public void RefreshContent(bool _force = false)
{
TaxonTreeNode node = _MainTaxon;
bool recursive = Recursive;
if (_AlternativeTaxon != null)
{
bool hasComment = TaxonComments.CommentFile(_AlternativeTaxon) != null;
if (!hasComment && AddFranceMap)
{
hasComment = (TaxonUtils.Locations != null) && TaxonUtils.Locations.LocationByTaxon.ContainsKey(_AlternativeTaxon.GetOriginal());
}
if (hasComment)
{
node = _AlternativeTaxon;
recursive = false;
}
}
if (!_force && _Current == node)
{
OnDocumentCompleted?.Invoke(this, EventArgs.Empty);
return;
}
_Current = node;
ClearComments();
if (node != null)
{
TaxonComments.Manager.GetComment(this, node, recursive, OnCommentLoaded);
// BuildHtml();
// webBrowser.DocumentText = HtmlDocument;
}
}
//-------------------------------------------------------------------
public static void OnTaxonChanged(object sender, TaxonTreeNode _taxon)
{
foreach (ITaxonControl itc in _List)
{
itc.OnTaxonChanged(sender, _taxon);
}
}
private void CheckCollectionIds(TaxonTreeNode _node, object _data)
{
if (_node.Desc.Images == null)
{
return;
}
Data data = _data as Data;
foreach (TaxonImageDesc imageDesc in _node.Desc.Images)
{
int count = 0;
if (TaxonImages.Manager.Collection(imageDesc.CollectionId) != null)
{
if (!data.Exists.TryGetValue(imageDesc.CollectionId, out count))
{
count = 0;
}
data.Exists[imageDesc.CollectionId] = count + 1;
}
else
{
if (!data.DontExists.TryGetValue(imageDesc.CollectionId, out count))
{
count = 0;
}
data.DontExists[imageDesc.CollectionId] = count + 1;
}
}
}
//-------------------------------------------------------------------
public static void OnBelowChanged(TaxonTreeNode _selected)
{
foreach (ITaxonControl itc in _List)
{
itc.OnBelowChanged(_selected);
}
}
//-------------------------------------------------------------------
public static void OnSelectTaxon(TaxonTreeNode _selected)
{
foreach (ITaxonControl itc in _List)
{
itc.OnSelectTaxon(_selected);
}
}
public void Constructor()
{
TaxonTreeNode taxonTreeNode;
taxonTreeNode = new TaxonTreeNode();
Assert.IsNotNull(taxonTreeNode);
}
private void buttonCreate_Click(object sender, EventArgs e)
{
DialogResult result = DialogResult.OK;
TaxonName = textBox1.Text.Trim();
if (!CreateUnnamed && CheckNameUsage)
{
if (TaxonUtils.Root != null)
{
TaxonTreeNode otherNode = TaxonUtils.Root.FindTaxonByName(TaxonName.ToLower());
if (otherNode != null)
{
string message = "Name is already used, Create anyway ?";
message += "\n\nClick no to change name, Cancel to abort creation";
result = MessageBox.Show(message, "Warning !", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
if (result == DialogResult.No)
{
return;
}
if (result == DialogResult.Yes)
{
result = DialogResult.OK;
}
}
}
}
DialogResult = result;
Close();
}
public void EndPaint(TaxonTreeNode _taxon, Rectangle _bounds, Graphics _graphics)
{
OnPainted?.Invoke(this, new OnPaintedArgs()
{
Bounds = _bounds, Taxon = _taxon, Graphics = _graphics
});
}
public NewImage(TaxonTreeNode _node, Image _newImage)
{
_Node = _node;
_NewImage = _newImage;
InitializeComponent();
DialogResult = DialogResult.Cancel;
}
public TaxonTreeNodeList GetTaxonTrees(IUserContext userContext, ITaxonTreeSearchCriteria searchCriteria)
{
TaxonTreeNodeList list = new TaxonTreeNodeList();
TaxonTreeNode treeNode = new TaxonTreeNode();
treeNode.Id = 22;
treeNode.Taxon = this.GetReferenceTaxon(userContext, testTaxonId);
TaxonTreeNodeList parentList = new TaxonTreeNodeList();
TaxonTreeNode parentTreeNode = new TaxonTreeNode();
parentTreeNode.Id = 21;
parentTreeNode.Taxon = GetReferenceTaxon(userContext, 100067);
parentList.Add(parentTreeNode);
treeNode.Parents = parentList;
TaxonTreeNodeList childList = new TaxonTreeNodeList();
TaxonTreeNode childTreeNode = new TaxonTreeNode();
childTreeNode.Id = 21;
ITaxon taxon = GetReferenceTaxon(userContext, 100068);
taxon.Category.IsTaxonomic = false;
childTreeNode.Taxon = taxon;
childList.Add(childTreeNode);
treeNode.Children = childList;
list.Add(treeNode);
return(list);
}
private string WriteHtmlGetImage(TaxonTreeNode node, string imageFolder)
{
string image = null;
if (node.Desc.HasImage)
{
List <TaxonImageDesc> available = node.Desc.AvailableImages;
if (available != null && available.Count > 0)
{
string src = available[0].GetPath(node.Desc);
if (src != null)
{
string tgt = imageFolder + Path.DirectorySeparatorChar + Path.GetFileName(src);
if (File.Exists(src))
{
if (!File.Exists(tgt))
{
File.Copy(src, tgt);
}
image = tgt;
}
}
}
}
return(image);
}
void Compute4AnimalsFromFamille(TaxonTreeNode _node)
{
if (_node.Desc.ClassicRank != ClassicRankEnum.None)
{
return;
}
if (_node.Desc.RefMultiName.Main.Contains(' '))
{
return;
}
if (_node.Desc.RefMultiName.Main.EndsWith("oidea"))
{
List <TaxonTreeNode> descendants = new List <TaxonTreeNode>();
_node.GetAllChildrenRecursively(descendants, ClassicRankEnum.Famille);
if (descendants.Count > 0)
{
_node.Desc.ClassicRank = ClassicRankEnum.SuperFamille;
_Data.NewSuperFamille++;
_Data.AnimalSuperFamille.Add(_node);
}
}
else if (_node.Desc.RefMultiName.Main.EndsWith("formes") || _node.Desc.RefMultiName.Main.EndsWith("formia"))
{
List <TaxonTreeNode> descendants = new List <TaxonTreeNode>();
_node.GetAllChildrenRecursively(descendants, ClassicRankEnum.Famille);
if (descendants.Count > 0)
{
_node.Desc.ClassicRank = ClassicRankEnum.Ordre;
_Data.NewOrder++;
_Data.AnimalOrdre.Add(_node);
}
}
}
//-------------------------------------------------------------------
public static void SetRoot(TaxonTreeNode _root)
{
foreach (ITaxonControl itc in _List)
{
itc.SetRoot(_root);
}
}
public void addTaxonRecursive(TaxonTreeNode _current)
{
addTaxon(_current.Desc.RefAllNames);
foreach (TaxonTreeNode child in _current.Children)
{
addTaxonRecursive(child);
}
}
void SortChildren(TaxonTreeNode _taxon)
{
if (!_taxon.HasChildren)
{
return;
}
_taxon.SortChildren();
NumTaxonSorted++;
}
private void OnSelectAndSetAsNewRoot(object sender, EventArgs e)
{
TaxonTreeNode selected = GetSelected();
TaxonUtils.CleanSubRoots();
TaxonUtils.PushSubRoot(selected);
TaxonUtils.GotoTaxon(selected);
TaxonUtils.SelectTaxon(selected);
}
private void WriteHtmlTaxonImage(StreamWriter sw, TaxonTreeNode node, string imageFolder, int rootPathLength)
{
string image = WriteHtmlGetImage(node, imageFolder);
if (image != null)
{
sw.WriteLine(_htmlOneImage.Replace("[IMAGE]", image.Substring(rootPathLength)));
}
}
public bool Match(TaxonTreeNode _node)
{
int flag = 1 << (int)_node.Desc.RedListCategory;
if ((flag & HiddenCategory) == flag)
{
return(false);
}
return(true);
}
//----------------------------------------------------------------------------------------
// first pass :
private void ComputeGenreFirst()
{
_Data.Writer.WriteLine("------------------------------------------------------------");
_Data.Writer.WriteLine(String.Format("Genre first pass, parsing all species"));
uint oldNumber = _Data.NewGenre;
List <TaxonTreeNode> species = new List <TaxonTreeNode>();
TaxonUtils.OriginalRoot.GetAllChildrenRecursively(species, ClassicRankEnum.Espece);
foreach (TaxonTreeNode spec in species)
{
int index = spec.Desc.RefMultiName.Main.IndexOf(' ');
if (index == -1)
{
continue;
}
string genreName = spec.Desc.RefMultiName.Main.Substring(0, index);
TaxonTreeNode parent = spec.Father;
TaxonTreeNode parentWithSameName = null;
while (parent != null)
{
if (parent.Desc.ClassicRank == ClassicRankEnum.Genre)
{
break;
}
if (parent.Desc.RefMultiName.Main == genreName)
{
parentWithSameName = parent;
}
parent = parent.Father;
}
if (parent != null)
{
continue;
}
if (parentWithSameName == null)
{
continue;
}
parentWithSameName.Desc.ClassicRank = ClassicRankEnum.Genre;
_Data.NewGenre++;
_Data.Writer.WriteLine(" " + parentWithSameName.Desc.RefMultiName.Main);
}
if (oldNumber != _Data.NewGenre)
{
_Data.Writer.WriteLine(String.Format(" {0} new genre", _Data.NewGenre - oldNumber));
}
else
{
_Data.Writer.WriteLine(" No new genre detected");
}
}
public void ScriptCall(string _name, int _index)
{
if (_index >= 0 && _index < Owner._HtmlDivs.Count)
{
TaxonTreeNode node = Owner._HtmlDivs[_index].Taxon;
if (node != null && _name == node.Desc.RefMainName)
{
TaxonUtils.GotoTaxon(node);
}
}
}
//-------------------------------------------------------------------
public static void OnReselectTaxon(TaxonTreeNode _selected = null)
{
if (_selected == null && TaxonUtils.MainGraph != null)
{
_selected = TaxonUtils.MainGraph.Selected;
}
foreach (ITaxonControl itc in _List)
{
itc.OnReselectTaxon(_selected);
}
}
public FilterResultEnum Evaluate(TaxonTreeNode _node)
{
if ((_node.RedListCategoryFlags & HiddenCategory) == _node.RedListCategoryFlags)
{
return(FilterResultEnum.YesAndChildToo);
}
if (_CheckExtinctSubdivision && _node.Desc.HasFlag(FlagsEnum.ExtinctInherited))
{
return(FilterResultEnum.Yes);
}
return(FilterResultEnum.No);
}
void ComputeWLN(TaxonTreeNode _node)
{
if (_node.Desc.ClassicRank != ClassicRankEnum.None)
{
return;
}
if (IsWithoutLatinName(_node.Desc.RefMultiName.Main))
{
_node.Desc.ClassicRank = ClassicRankEnum.WithoutLatinName;
_Data.WithoutLatinName.Add(_node);
}
}
public void End(TaxonTreeNode _node)
{
if (_CheckExtinctSubdivision)
{
_node.ParseNode((n) =>
{
if (n.HasVisibleChild && n.HasHiddenChildren)
{
n.Expand();
}
});
}
}
//----------------------------------------------------------------------------------------
// first pass species :
// Si un taxon
// - n’a pas déjà de Classic Rank ET est en bout d’arbre ET ( est en deux mots OU contient la string « sp ») *
// * avec un espace de chaque côté de « sp »
// >>>alors Classic rank = Espece
//
private void ComputeSpeciesFirst()
{
_Data.Writer.WriteLine("------------------------------------------------------------");
_Data.Writer.WriteLine(String.Format("Species first pass, parsing {0} leaves", _Data.Leaves.Count));
uint oldNumber = _Data.NewSpecies;
foreach (TaxonTreeNode node in _Data.Leaves)
{
TaxonTreeNode nodeToTreat = node;
string name;
if (node.Desc.ClassicRank == ClassicRankEnum.SousEspece)
{
nodeToTreat = node.Father;
if (nodeToTreat.Desc.ClassicRank != ClassicRankEnum.None)
{
continue;
}
name = nodeToTreat.Desc.RefMultiName.Main;
}
else if (node.Desc.ClassicRank == ClassicRankEnum.None)
{
name = node.Desc.RefMultiName.Main;
string nameNorm = name.ToLower();
if (!nameNorm.Contains(" sp ") && nameNorm.Split(_Data.SpaceSep).Length != 2)
{
continue;
}
}
else
{
continue;
}
nodeToTreat.Desc.ClassicRank = ClassicRankEnum.Espece;
if (oldNumber == _Data.NewSpecies)
{
_Data.Writer.WriteLine(" New species detected:");
}
_Data.NewSpecies++;
_Data.Writer.WriteLine(" " + name);
}
if (oldNumber != _Data.NewSpecies)
{
_Data.Writer.WriteLine(String.Format(" {0} new species", _Data.NewSpecies - oldNumber));
}
else
{
_Data.Writer.WriteLine(" No new species detected");
}
}
void CheckLeaf(TaxonTreeNode _taxon)
{
if (_taxon.HasChildren)
{
return;
}
if (_taxon.Desc.ClassicRank == ClassicRankEnum.Espece || _taxon.Desc.ClassicRank == ClassicRankEnum.SousEspece)
{
return;
}
if (_taxon.Desc.ClassicRank == ClassicRankEnum.WithoutLatinName || _taxon.Desc.ClassicRank == ClassicRankEnum.None)
{
return;
}
_Result.Add(_taxon);
}
public GenerateNewDatabaseDialog(TaxonTreeNode _taxon, GenerateNewDatabaseConfig _config)
{
InitializeComponent();
_Taxon = _taxon;
_Config = _config;
if (_Taxon == null)
{
return;
}
labelTaxon.Text = _Taxon.Desc.RefMainName;
labelTaxon.Tag = new Localization.Tag {
Ignore = true
};
labelFolder.Text = Path.Combine(TaxonUtils.GetTaxonPath(), "NewDatas");
ApplyConfig();
}
private TaxonTreeNode GetTaxonTreeNode(Boolean refresh = false, TaxonId?taxonId = null)
{
ITaxon taxon;
if (_taxonTreeNode.IsNull() || refresh)
{
if (taxonId.HasValue)
{
taxon = CoreData.TaxonManager.GetTaxon(GetUserContext(), taxonId.Value);
}
else
{
taxon = CoreData.TaxonManager.GetTaxon(GetUserContext(), TaxonId.Mammals);
}
_taxonTreeNode = (TaxonTreeNode)(taxon.GetTaxonTree(GetUserContext(), true));
}
return(_taxonTreeNode);
}
//--------------------------------------------------------------------------------------
void ContextMenuStrip_Opening(object sender, System.ComponentModel.CancelEventArgs e)
{
ContextMenuStrip.Items.Clear();
ToolStripMenuItem menuItem;
TaxonTreeNode taxon = GetSelected();
if (taxon != null)
{
menuItem = new ToolStripMenuItem(Localization.Manager.Get("_GotoTaxon", "Goto {0}", taxon.Desc.RefMainName), null, new System.EventHandler(OnGoto));
ContextMenuStrip.Items.Add(menuItem);
menuItem = new ToolStripMenuItem(Localization.Manager.Get("_SelectTaxon", "Select {0}", taxon.Desc.RefMainName), null, new System.EventHandler(OnSelect));
ContextMenuStrip.Items.Add(menuItem);
menuItem = new ToolStripMenuItem(Localization.Manager.Get("_SelectTaxonAndSetAsNewRoot", "Select and set as new root {0}", taxon.Desc.RefMainName), null, new System.EventHandler(OnSelectAndSetAsNewRoot));
ContextMenuStrip.Items.Add(menuItem);
menuItem = TaxonUtils.FavoritesMenuItem(taxon);
if (menuItem != null)
{
ContextMenuStrip.Items.Add(new ToolStripSeparator());
ContextMenuStrip.Items.Add(menuItem);
}
}
if (CanBeSorted)
{
List <TaxonTreeNode> list = DataSource as List <TaxonTreeNode>;
if (list.Count > 1)
{
if (ContextMenuStrip.Items.Count > 0)
{
ContextMenuStrip.Items.Add(new ToolStripSeparator());
}
menuItem = new ToolStripMenuItem(Localization.Manager.Get("_Sort", "Sort"));
menuItem.DropDownItems.Add(Localization.Manager.Get("_SortAlpha", "Alpha"), null, new System.EventHandler(OnSort));
menuItem.DropDownItems.Add(Localization.Manager.Get("_SortReverseAlpha", "Reverse Alpha"), null, new System.EventHandler(OnSort));
menuItem.DropDownItems.Add(Localization.Manager.Get("_SortTree", "Tree"), null, new System.EventHandler(OnSort));
menuItem.DropDownItems.Add(Localization.Manager.Get("_SortReverseTree", "Reverse Tree"), null, new System.EventHandler(OnSort));
ContextMenuStrip.Items.Add(menuItem);
}
}
e.Cancel = ContextMenuStrip.Items.Count == 0;
}
void Compute4OthersFromGenre(TaxonTreeNode _node)
{
if (_node.Desc.ClassicRank != ClassicRankEnum.None)
{
return;
}
if (_node.Desc.RefMultiName.Main.Contains(' '))
{
return;
}
List <TaxonTreeNode> parents = new List <TaxonTreeNode>();
_node.GetAllParents(parents, true);
if (parents.Contains(_Data.Holozoa))
{
return;
}
if (_node.Desc.RefMultiName.Main.EndsWith("eae") && !_node.Desc.RefMultiName.Main.EndsWith("aceae") && !_node.Desc.RefMultiName.Main.EndsWith("oideae"))
{
List <TaxonTreeNode> descendants = new List <TaxonTreeNode>();
_node.GetAllChildrenRecursively(descendants, ClassicRankEnum.Genre);
if (descendants.Count > 0)
{
_node.Desc.ClassicRank = ClassicRankEnum.SousFamille;
_Data.NewSousFamille++;
_Data.OtherSousFamille.Add(_node);
}
}
else if (_node.Desc.RefMultiName.Main.EndsWith("aceae") || _node.Desc.RefMultiName.Main.EndsWith("yceae"))
{
List <TaxonTreeNode> descendants = new List <TaxonTreeNode>();
_node.GetAllChildrenRecursively(descendants, ClassicRankEnum.Genre);
if (descendants.Count > 0)
{
_node.Desc.ClassicRank = ClassicRankEnum.Famille;
_Data.NewFamille++;
_Data.OtherFamille.Add(_node);
}
}
}
