コード例 #1
0
        //---------------------------------------------------------------------------------
        void UpdateList()
        {
            listAscendants.Items.Clear();
            if (_Selected == null)
            {
                return;
            }
            List <TaxonTreeNode> Ascendants = new List <TaxonTreeNode>();

            _Selected.GetAllParents(Ascendants, true, true, false);
            listAscendants.Items.AddRange(Ascendants.ToArray());
        }
コード例 #2
0
        //---------------------------------------------------------------------------------
        public void ShowInfo(TaxonTreeNode _taxon)
        {
            if (_taxon == null)
            {
                textBox1.Text = "";
                return;
            }

            //---------------------------------------------------------------------
            // nom du père
            TaxonTreeNode DirectParentList = _taxon.Father;

            string text = "";

            //crée une string avec le text du parent
            string DirectParent = "pas de parent direct, c'est le root de l'arbre";

            if (DirectParentList != null)
            {
                DirectParent = "le parent direct est: " + DirectParentList.Desc.RefAllNames;
            }
            text += DirectParent + "\r\n\r\n";

            //---------------------------------------------------------------------
            // génération :
            text += "Generation = " + _taxon.GetGeneration().ToString() + "\r\n";
            text += "    Max level descendant = " + _taxon.GetMaxDescendentGeneration().ToString() + "\r\n";
            text += "    Last All visible generation= " + GetLastFullVisibleGeneration(_taxon).ToString() + "\r\n\r\n";

            //---------------------------------------------------------------------
            // nom de tous les enfants
            // un peu trop long maintenant

            /*
             * List<Taxon> AllChildList = new List<Taxon>();
             * _taxon.getAllChildrenRecursively(AllChildList);
             * string AllChildListAllElements;
             * if (AllChildList.Count == 0)
             *  AllChildListAllElements = "pas d'enfants.";
             * else
             * {
             *  AllChildListAllElements = "La liste de tous les enfants est : \r\n" + AllChildList[0].Name;
             *  for (int i = 1; i < AllChildList.Count; i++)
             *      AllChildListAllElements += ", " + AllChildList[i].Name;
             * }
             * text += AllChildListAllElements + "\r\n\r\n";
             */
            //---------------------------------------------------------------------
            List <TaxonTreeNode> DirectChildList = _taxon.Children;
            string DirectChildListAllElements;

            //crée une string avec le text de tous les labels de la liste
            if (DirectChildList.Count == 0)
            {
                DirectChildListAllElements = "pas d'enfants directs";
            }
            else
            {
                DirectChildListAllElements = "les enfants directs sont : \r\n" + DirectChildList[0].Desc.RefMainName;
                for (int i = 1; i < DirectChildList.Count; i++)
                {
                    DirectChildListAllElements += ", " + DirectChildList[i].Desc.RefMainName;
                }
            }
            text += DirectChildListAllElements + "\r\n\r\n";

            //---------------------------------------------------------------------
            List <TaxonTreeNode> AllParentList = new List <TaxonTreeNode>();

            _taxon.GetAllParents(AllParentList);
            string AllParentListAllElements = "les ascendants sont : \r\n";

            //crée une string avec le text de tous les labels de la liste
            for (int i = 0; i < AllParentList.Count; i++)
            {
                AllParentListAllElements += AllParentList[i].Desc.RefMainName + ", ";
            }
            text += AllParentListAllElements + "\r\n\r\n";

            //-----------------------------------------------------------------------
            List <TaxonTreeNode> genList = new List <TaxonTreeNode>();

            _taxon.GetDescendentLevel(4, genList);
            string GivenGenerationChildListAllElements = "les enfants de génération 4 de ce label sont : \r\n";

            //crée une string avec le text de tous les labels de la liste
            for (int i = 0; i < genList.Count; i++)
            {
                GivenGenerationChildListAllElements += genList[i].Desc.RefMainName + ", ";
            }
            text += GivenGenerationChildListAllElements;

            textBox1.Text = text;
        }
コード例 #3
0
ファイル: GraphMenu.cs プロジェクト: karimsqualli/treeoflife
        //-------------------------------------------------------------------
        private void GraphContextMenu_Opening(object sender, CancelEventArgs e)
        {
            // remove previously added menu
            int index = GraphContextMenu.Items.IndexOf(toolStripMenuItemAdvanced) + 1;

            while (GraphContextMenu.Items.Count > index)
            {
                GraphContextMenu.Items.RemoveAt(index);
            }
            Localization.Manager.DoMenu(GraphContextMenu);

            _MenuTaxonTreeNode = BelowMouse;

            bool fullMenu = true;
            ToolStripMenuItem advanced = BuildAdvancedMenu();

            if (ModifierKeys == Keys.Shift && advanced != null)
            {
                fullMenu = false;
            }

            foreach (ToolStripItem item in GraphContextMenu.Items)
            {
                item.Visible = fullMenu;
            }

            if (fullMenu)
            {
                GraphContextMenu.Enabled = (Root != null);

                collapseAllToolStripMenuItem.Visible = false;
                expandAllToolStripMenuItem.Visible   = false;

                setAsNewRootToolStripMenuItem.Visible = TaxonUtils.CanPushSubRoot(_MenuTaxonTreeNode);

                bool gotoSelected = TaxonUtils.SelectedTaxon() != null && TaxonUtils.SelectedTaxon() != _MenuTaxonTreeNode;
                gotoSelectedToolStripMenuItem.Visible = gotoSelected;
                if (gotoSelected)
                {
                    gotoSelectedToolStripMenuItem.Text = Localization.Manager.Get("_GotoTaxon", "Goto {0}", TaxonUtils.SelectedTaxon().Desc.RefMainName);
                }

                restoreRootToolStripMenuItem.Visible     = TaxonUtils.HasSubRoots();
                toolStripMenuItem1.Visible               = _MenuTaxonTreeNode != null;
                selectAscendantToolStripMenuItem.Visible = _MenuTaxonTreeNode != null;
                collapseTaxonToolStripMenuItem.Visible   = _MenuTaxonTreeNode != null;
                expandTaxonToolStripMenuItem.Visible     = _MenuTaxonTreeNode != null;
                favoritesToolStripMenuItem.Visible       = _MenuTaxonTreeNode != null;

                if (_MenuTaxonTreeNode != null)
                {
                    selectAscendantToolStripMenuItem.Text = Localization.Manager.Get("_SelectAscendant", "Select ascendant");
                    List <TaxonTreeNode> Ascendants = new List <TaxonTreeNode>();
                    _MenuTaxonTreeNode.GetAllParents(Ascendants, false, false, false);
                    if (Ascendants.Count == 0)
                    {
                        selectAscendantToolStripMenuItem.Enabled = false;
                    }
                    else
                    {
                        selectAscendantToolStripMenuItem.Enabled = true;
                        selectAscendantToolStripMenuItem.DropDownItems.Clear();
                        foreach (TaxonTreeNode node in Ascendants)
                        {
                            ToolStripMenuItem subMenuItem = new ToolStripMenuItem(node.Desc.RefMainName, null, new System.EventHandler(OnSelect))
                            {
                                Tag = node
                            };
                            selectAscendantToolStripMenuItem.DropDownItems.Add(subMenuItem);
                        }
                    }

                    collapseTaxonToolStripMenuItem.Text    = Localization.Manager.Get("_CollapseTaxon", "Collapse {0}", _MenuTaxonTreeNode.Desc.RefMainName);
                    collapseTaxonToolStripMenuItem.Enabled = _MenuTaxonTreeNode.HasAllChildVisible;
                    expandTaxonToolStripMenuItem.Text      = Localization.Manager.Get("_ExpandTaxon", "Expand {0}", _MenuTaxonTreeNode.Desc.RefMainName);
                    string favoritesMenuItemText = TaxonUtils.FavoritesMenuItemText(_MenuTaxonTreeNode);
                    favoritesToolStripMenuItem.Visible = favoritesMenuItemText != null;
                    if (favoritesMenuItemText != null)
                    {
                        favoritesToolStripMenuItem.Text = favoritesMenuItemText;
                    }
                }
            }

            if (advanced == null)
            {
                toolStripMenuItemAdvanced.Visible = false;
            }
            else if (fullMenu)
            {
                toolStripMenuItemAdvanced.Visible = true;
                GraphContextMenu.Items.Add(advanced);
            }
            else
            {
                while (advanced.DropDownItems.Count > 0)
                {
                    GraphContextMenu.Items.Add(advanced.DropDownItems[0]);
                }
            }
        }