static TaxonTreeNode LoadBin(string _fileName)
        {
            TaxonTreeNode result = null;

            _LoadCanceled = false;
            LoadCounterInit();

            try
            {
                using (FileStream fs = File.Open(_fileName, FileMode.Open, FileAccess.Read))
                {
                    using (DeflateStream deflateStream = new DeflateStream(fs, CompressionMode.Decompress))
                    {
                        using (BinaryReader r = new BinaryReader(deflateStream))
                        {
                            uint version = r.ReadUInt32();
                            result = LoadBin(r, version);
                            r.Close();
                            deflateStream.Close();
                            fs.Close();
                        }
                    }
                }
            }
            catch { }
            return(result);
        }
Example #2
0
        //---------------------------------------------------------------------------------
        private void Picture_SetSpeciesAndSubSpecies(TaxonTreeNode _species, int _previousImageIndex)
        {
            _CurrentTaxonIsSpecies = true;

            TaxonBigVignette.Visible      = true;
            TaxonBigVignette.CurrentTaxon = _species;
            TaxonBigVignette.Tag          = _species;

            List <TaxonTreeNode> speciesList = new List <TaxonTreeNode>();

            _species.GetAllChildrenWithImageRecursively(speciesList);

            //if (TaxonUtils.CurrentFilters.HasFilter(TaxonFilters.FilterAlive))
            //    speciesList = speciesList.Where(node => node.Desc.IsExtinct).ToList();

            if (speciesList.Contains(_species))
            {
                speciesList.Remove(_species);
            }
            else
            {
                _species = null;
            }

            _MultiImages.SetLists(speciesList, _species);
            _MultiImages.ScrollMode_UpdateOutputImages();
            _MultiImages.Visible = true;
        }
Example #3
0
        //-------------------------------------------------------------------
        public void AddFather(TaxonTreeNode _taxon)
        {
            if (_taxon == null)
            {
                return;
            }
            TaxonDialog.NewTaxon dlg = new TaxonDialog.NewTaxon
            {
                TopMost        = true,
                CheckNameUsage = true
            };
            dlg.ShowDialog();
            if (dlg.DialogResult != DialogResult.OK)
            {
                return;
            }

            TaxonDesc     newTaxon = new TaxonDesc(dlg.TaxonName);
            TaxonTreeNode newNode  = new TaxonTreeNode(newTaxon);

            TaxonTreeNode OldFather = _taxon.Father;

            OldFather.ReplaceChild(_taxon, newNode);
            newNode.AddChild(_taxon);
            OldFather.Expand();
            newNode.Expand();
            RefreshGraph();
        }
Example #4
0
        //-------------------------------------------------------------------
        public void AddFatherAll(TaxonTreeNode _taxon)
        {
            if (_taxon == null)
            {
                return;
            }
            TaxonDialog.NewTaxon dlg = new TaxonDialog.NewTaxon
            {
                TopMost        = true,
                CheckNameUsage = true
            };
            dlg.ShowDialog();
            if (dlg.DialogResult != DialogResult.OK)
            {
                return;
            }

            TaxonDesc     newTaxon = new TaxonDesc(dlg.TaxonName);
            TaxonTreeNode newNode  = new TaxonTreeNode(newTaxon);

            TaxonTreeNode OldFather = _taxon.Father;

            foreach (TaxonTreeNode child in OldFather.Children)
            {
                newNode.AddChild(child);
            }

            OldFather.Children.Clear();
            OldFather.AddChild(newNode);

            OldFather.Expand();
            newNode.Expand();
            RefreshGraph();
        }
Example #5
0
        public static CommentFileCreateResult CommentFileCreate(TaxonTreeNode _node)
        {
            if (_node == null)
            {
                return(CommentFileCreateResult.Failed);
            }

            if (TaxonComments.Manager.AvailableCollections.Count == 0)
            {
                return(CommentFileCreateResult.NoCollection);
            }
            CommentsCollection collection = TaxonComments.Manager.AvailableCollections[0];

            string name = CommentFilename(_node.Desc);

            if (string.IsNullOrEmpty(name))
            {
                return(CommentFileCreateResult.NoNameAndID);
            }

            string path = CommentFileDesc.BuildHtlmName(collection, name);

            if (File.Exists(path))
            {
                return(CommentFileCreateResult.ExistsAlready);
            }

            Manager.CreateHtmlComment(path, name);
            Manager.CleanCommentInMemory(0);
            return(CommentFileCreateResult.Success);
        }
        //-------------------------------------------------------------------
        protected override void OnMouseDown(MouseEventArgs e)
        {
            if (Root == null)
            {
                return;
            }

            if (e.Button == MouseButtons.Right)
            {
                TaxonTreeNode pick = PickTaxon(Root, ClientToGraph(e.Location))?.GetMain();
                if (pick != Selected)
                {
                    Selected = pick;
                }
                return;
            }

            mouseDown = true;
            mouseX    = e.Location.X;
            mouseY    = e.Location.Y;
            moveX     = Origin.X;
            moveY     = Origin.Y;

            _InertiaMove.Stop();
        }
Example #7
0
 //-------------------------------------------------------------------
 private void TextBoxSearch_KeyDown(object sender, KeyEventArgs e)
 {
     if (e.KeyCode == Keys.Return)
     {
         e.Handled = true;
         if (textBoxSearch.Text.Length < 2)
         {
             TaxonSearchAsync.Search(_Root, textBoxSearch.Text);
         }
         if (listBoxResult.Items.Count > 0)
         {
             TaxonTreeNode taxon = listBoxResult.GetAt(0);
             if (taxon != null)
             {
                 TaxonUtils.GotoTaxon(taxon);
                 TaxonUtils.SelectTaxon(taxon);
             }
         }
     }
     if (e.KeyCode == Keys.Down)
     {
         if (listBoxResult.Items.Count > 0)
         {
             e.Handled = true;
             listBoxResult.Focus();
             if (listBoxResult.SelectedIndex == -1)
             {
                 listBoxResult.SelectedIndex = 0;
             }
         }
     }
 }
Example #8
0
        //méthode pour retourner la liste des parents
        public void GetAllParents(List <TaxonTreeNode> _list, bool _includeFirst = true, bool _fromFatherToChild = true, bool _includeUnnamed = true)
        {
            TaxonTreeNode current = this;

            if (!_includeFirst)
            {
                current = current.Father;
            }
            if (_includeUnnamed)
            {
                while (current != null)
                {
                    _list.Add(current);
                    current = current._Father;
                }
            }
            else
            {
                while (current != null)
                {
                    if (!current.Desc.IsUnnamed)
                    {
                        _list.Add(current);
                    }
                    current = current._Father;
                }
            }
            if (_fromFatherToChild)
            {
                _list.Reverse();
            }
        }
Example #9
0
        //---------------------------------------------------------------------------------
        private void createNewTreeToolStripMenuItem_Click(object sender, EventArgs e)
        {
            TaxonTreeNode root = new TaxonTreeNode(new TaxonDesc("root"));

            TaxonUtils.Save(root, true, true);
            TaxonUtils.SetOriginalRoot(root);
        }
Example #10
0
        //------------------------------------------
        private TaxonTreeNode FindTaxonByFullNameRecursive(string _fullname)
        {
            int index = _fullname.IndexOf('|');

            if (index == -1)
            {
                foreach (TaxonTreeNode child in _Children)
                {
                    if (child.Desc.RefMultiName.Main == _fullname)
                    {
                        return(child);
                    }
                }
            }
            else
            {
                string name = _fullname.Substring(0, index);

                foreach (TaxonTreeNode child in _Children)
                {
                    if (child.Desc.RefMultiName.Main == name)
                    {
                        TaxonTreeNode result = child.FindTaxonByFullNameRecursive(_fullname.Substring(index + 1));
                        if (result != null)
                        {
                            return(result);
                        }
                    }
                }
            }
            return(null);
        }
Example #11
0
        //---------------------------------------------------------------------------------------
        public static CommentFileDesc CommentFile(TaxonTreeNode _node)
        {
            if (_node == null)
            {
                return(null);
            }
            string filename = CommentFilename(_node.Desc);

            CommentFileDesc result;

            foreach (CommentsCollection collection in TaxonComments.Manager.AvailableCollections)
            {
                if (filename != null && collection.IsDistant() && collection.DistantReferences.ContainsKey(filename))
                {
                    result = new CommentFileDesc(collection, filename);
                }
                else
                {
                    result = CommentFileDesc.CreateOnlyIfFileExists(collection, filename);
                }
                if (result != null)
                {
                    return(result);
                }
            }
            return(null);
        }
Example #12
0
        //---------------------------------------------------------------------------------
        public static int Compare(TaxonTreeNode t1, TaxonTreeNode t2)
        {
            if (t1 == t2)
            {
                return(0);
            }

            if (t1.Father == t2.Father)
            {
                return((t1.Father.Children.IndexOf(t1) < t2.Father.Children.IndexOf(t2)) ? -1 : 1);
            }

            int level1 = t1.GetGeneration();
            int level2 = t2.GetGeneration();

            if (level1 < level2)
            {
                return(Compare(t1, t2.Father));
            }
            if (level2 < level1)
            {
                return(Compare(t1.Father, t2));
            }
            return(Compare(t1.Father, t2.Father));
        }
 void PasteClipboard(TaxonTreeNode _to)
 {
     if (Clipboard.ContainsData("TaxonTreeNodeXmlMemoryStream"))
     {
         object o = Clipboard.GetData("TaxonTreeNodeXmlMemoryStream");
         if (o is System.IO.MemoryStream ms)
         {
             TaxonTreeNode node = TaxonTreeNode.LoadXMLFromMemory(ms);
             if (node != null)
             {
                 ImportNode(_to, node);
             }
         }
     }
     else if (Clipboard.ContainsData(DataFormats.Text))
     {
         string name = Clipboard.GetText();
         if (name == null)
         {
             return;
         }
         TaxonTreeNode node = Root.FindTaxonByFullName(name);
         if (node != null)
         {
             TaxonUtils.GotoTaxon(node);
             TaxonUtils.SelectTaxon(node);
         }
     }
 }
Example #14
0
        //---------------------------------------------------------------------------------
        // Display Image of taxon
        private void Pictures_Display(TaxonTreeNode _taxon, TaxonTreeNode _previousSelectedTaxon = null, List <TaxonTreeNode> _previousDisplayedTaxons = null, int _previousImageIndex = -1)
        {
            if (_taxon == null)
            {
                return;
            }

            if (!_taxon.HasChildren)
            {
                Pictures_SetSpecies(_taxon, _previousImageIndex);    // display taxon image
            }
            else if (_taxon.Desc.ClassicRank == ClassicRankEnum.Espece)
            {
                Picture_SetSpeciesAndSubSpecies(_taxon, _previousImageIndex);
            }
            else
            {
                Pictures_SetFamily(_taxon, _previousSelectedTaxon, _previousDisplayedTaxons);
            }

            UpdateCheckBoxes();

            if (_CurrentTaxonIsSpecies)
            {
                TaxonBigVignette.Width = _MultiImages.Width;
            }
            else
            {
                TaxonBigVignette.Width = _MultiImages.Width - 32;
            }
        }
        //-------------------------------------------------------------------
        public void Goto(TaxonTreeNode _taxon)
        {
            if (_taxon == null)
            {
                return;
            }
            if (!_taxon.Visible)
            {
                return;
            }

            // get taxon center;
            Point pt;

            /* Removing CircleDisplayMode
             * if (Options.DisplayMode == GraphOptions.DisplayModeEnum.Circle)
             *  pt = new Point((int)_taxon.CircularInfo.X, (int) _taxon.CircularInfo.Y);
             * else*/
            pt = new Point(_taxon.R.Left + Options.ZoomedWidth / 2, _taxon.R.Top + _taxon.R.Height / 2);
            // in Client space
            pt = GraphToClient(pt);
            // compute delta to move pt to client middle (Width/2, Height/2);
            // pt.X + deltaX = Width / 2
            // pt.Y + deltaY = Height / 2
            OffsetOrigin(Width / 2 - pt.X, Height / 2 - pt.Y);
            ConstraintGraphInClient();
            Invalidate();
        }
        //=========================================================================================
        // PICKING
        //

        //-------------------------------------------------------------------
        public static TaxonTreeNode PickTaxonRectangularStatic(TaxonTreeNode _in, int X, int Y)
        {
            if (X < _in.R.Left)
            {
                return(null);
            }
            if (Y < _in.R.Top)
            {
                return(null);
            }
            if (Y > _in.R.Bottom)
            {
                return(null);
            }

            if (_in.R.Contains(X, Y))
            {
                return(_in);
            }

            foreach (TaxonTreeNode child in _in.Children)
            {
                TaxonTreeNode result = PickTaxonRectangularStatic(child, X, Y);
                if (result != null)
                {
                    return(result);
                }
            }
            return(null);
        }
Example #17
0
        //---------------------------------------------------------------------------------
        // debut de database
        //Database.SQL DataBase = new Database.SQL();

        //---------------------------------------------------------------------------------
        public Form1(string[] args)
        {
            //----- tip manager
            TipManager.Start();

            //----- menu
            InitializeComponent();
            ApplyTheme();
            UpdateUI();

            //----- args
            if (args.Length > 0 && File.Exists(args[0]))
            {
                FileInfo fi = new FileInfo(args[0]);
                TaxonUtils.MyConfig.TaxonPath     = fi.Directory.FullName;
                TaxonUtils.MyConfig.TaxonFileName = fi.Name;
            }

            //----- load
            DateTime      startLoad  = DateTime.Now;
            TaxonTreeNode loadedNode = null;

            if (TaxonUtils.Exists())
            {
                loadedNode = TaxonTreeNode.Load(TaxonUtils.GetTaxonFileName());
            }
            if (loadedNode == null)
            {
                if (!TaxonTreeNode.LoadHasBeenCanceled() && !TaxonUtils.MyConfig.emptyTreeAtStartup)
                {
                    Loggers.WriteError(LogTags.Data, "Cannot open taxon file data : \n\n    " + TaxonUtils.GetTaxonFileName());
                }
            }
            else
            {
                string message = "open " + TaxonUtils.GetTaxonFileName() + " successful";
                message += "\n    " + loadedNode.Count() + " taxon loaded";
                message += "\n    " + loadedNode.Count(ClassicRankEnum.Espece) + " " + VinceToolbox.Helpers.enumHelper.GetEnumDescription(ClassicRankEnum.Espece);
                message += "," + loadedNode.Count(ClassicRankEnum.SousEspece) + " " + VinceToolbox.Helpers.enumHelper.GetEnumDescription(ClassicRankEnum.SousEspece);
                Loggers.WriteInformation(LogTags.Data, message);
            }

            FormAbout.SetSplashScreenMessage(".. End initialization ...");
            TaxonUtils.SetOriginalRoot(loadedNode);
            TaxonUtils.MainWindow = this;

            DateTime endLoad = DateTime.Now;

            TaxonControlList.OnRegisterTaxonControl      += TaxonControlList_OnRegisterTaxonControl;
            TaxonControlList.OnInitTaxonControlAfterLoad += TaxonControlList_OnInitTaxonControlAfterLoad;
            TaxonControlList.OnUnregisterTaxonControl    += TaxonControlList_OnUnregisterTaxonControl;
            SystemConfig.OnRunningModeChanged            += SystemConfig_OnRunningModeChanged;
            SystemConfig_OnRunningModeChanged(null, EventArgs.Empty);

            TaxonUtils.MyConfig.ToUI();
            taxonGraph_AddOneIfNone();

            Loggers.WriteInformation(LogTags.Data, "Total loading time: " + (int)((endLoad - startLoad).TotalMilliseconds));
        }
Example #18
0
 public virtual TaxonTreeNode GetFiltered(TaxonTreeNode _root)
 {
     if (_root == null)
     {
         return(null);
     }
     return(_root.FindTaxon(Desc));
 }
Example #19
0
 //---------------------------------------------------------------------------------
 private void HighlightFrenchName(TaxonTreeNode _node)
 {
     _node.Highlight = _node.Desc.HasFrenchName;
     foreach (TaxonTreeNode child in _node.Children)
     {
         HighlightFrenchName(child);
     }
 }
Example #20
0
 //---------------------------------------------------------------------------------
 public override void OnSelectTaxon(TaxonTreeNode _taxon)
 {
     if (checkBoxLock.Checked)
     {
         return;
     }
     Edited = _taxon;
 }
Example #21
0
 void RegisterTaxon(TaxonTreeNode _node)
 {
     if (_node.Desc.IsUnnamed)
     {
         return;
     }
     Add(_node.Desc.RefMultiName.Main, _node);
 }
Example #22
0
 public TaxonSearch(TaxonTreeNode _root, bool _init = true, bool _useAlternativeNames = false)
 {
     _Root = _root;
     if (_init)
     {
         Init(_useAlternativeNames);
     }
 }
 bool CanPasteClipboard(TaxonTreeNode _to)
 {
     if (Selected == null || Selected.IsFiltered())
     {
         return(false);
     }
     return(Clipboard.ContainsData("TaxonTreeNodeXmlMemoryStream"));
 }
Example #24
0
        public TaxonTreeNode Duplicate()
        {
            MemoryStream  s         = SaveXMLInMemory();
            TaxonTreeNode duplicata = LoadXMLFromMemory(s);

            s.Dispose();
            return(duplicata);
        }
Example #25
0
        public int GetLastFullVisibleGeneration(TaxonTreeNode _origin)
        {
            List <TaxonTreeNode> list = new List <TaxonTreeNode> {
                _origin
            };

            return(GetLastFullVisibleGeneration(_origin, list));
        }
Example #26
0
        public static TaxonIds Compute(TaxonTreeNode _node)
        {
            TaxonIds Data = new TaxonIds();

            _node.ParseNodeDesc(CheckIds, Data);
            Data.BuildRanges();
            return(Data);
        }
Example #27
0
 public Synonyms(TaxonTreeNode _root)
 {
     _root.ParseNodeDesc((d) => { if (d.RefMultiName.HasSynonym)
                                  {
                                      this.Add(new Synonym(d));
                                  }
                         });
 }
Example #28
0
 //---------------------------------------------------------------------------------
 private void HighlightImage(TaxonTreeNode _node)
 {
     _node.Highlight = _node.Desc.HasImage;
     foreach (TaxonTreeNode child in _node.Children)
     {
         HighlightImage(child);
     }
 }
Example #29
0
 //---------------------------------------------------------------------------------
 private void HighlightSound(TaxonTreeNode _node)
 {
     _node.Highlight = _node.Desc.HasSound;
     foreach (TaxonTreeNode child in _node.Children)
     {
         HighlightSound(child);
     }
 }
Example #30
0
 //---------------------------------------------------------------------------------
 private void HighlightClassikRank(TaxonTreeNode _node)
 {
     _node.Highlight = _node.Desc.ClassicRank != ClassicRankEnum.None;
     //_node.Highlight = _node.Desc.ClassicRank == ClassicRankEnum.Classe;
     foreach (TaxonTreeNode child in _node.Children)
     {
         HighlightClassikRank(child);
     }
 }