private void GenerateSeparators(TreeNode aNode)
        {
            var nodesToRemove = aNode.Nodes.Cast <TreeNode>().Where(node => (node is SeparatorTreeNode)).ToList();

            foreach (var node in nodesToRemove)
            {
                node.Remove();
            }

            ComplexRequirement req = null;

            if (aNode.Tag is ComplexRequirement cReq)
            {
                req = cReq;
            }

            if (aNode.Tag is SimpleRequirement sReq && sReq.GetKey() is ComplexKey cKey)
            {
                req = cKey.myRequirement;
            }

            if (req == null)
            {
                return;
            }

            var nodesWithoutAddingnode       = aNode.Nodes.Cast <TreeNode>().Where(node => !(node is AddingTreeNode)).ToList();
            var nodesThatShouldHaveSeparator = nodesWithoutAddingnode.Take(nodesWithoutAddingnode.Count - 1).ToList();

            foreach (TreeNode node in nodesThatShouldHaveSeparator)
            {
                aNode.Nodes.Insert(node.Index + 1, new SeparatorTreeNode(req.myType));
            }
        }
        public void SetNode(ComplexRequirement req)
        {
            myRequirement = req;
            if (!myMementos.ContainsKey(req))
            {
                myMementos.Add(req, new List <RequirementMemento>());
            }

            RefreshNode();
        }
        void AddComplexRequirement(DropDownTreeNode parentNode)
        {
            if (parentNode.Tag is ComplexRequirement requirement)
            {
                myMementos[myRequirement].Add(myRequirement.CreateMemento());
                var newReq = new ComplexRequirement();
                requirement.myRequirements.Add(newReq);

                var newNode = new DropDownTreeNode(newReq);
                newNode.Nodes.Add(new AddingTreeNode());

                SaveManager.Dirty = true;

                HideControls();
                parentNode.Nodes.Insert(parentNode.Nodes.Count - 1, newNode);
                GenerateSeparators(parentNode);
                newNode.Expand();
            }
        }
            public DropDownTreeNode(ComplexRequirement req)
                : base()
            {
                Tag = req;

                ComboBox.Tag = this;

                ComboBox.DropDownStyle = ComboBoxStyle.DropDownList;

                ComboBox.Items.AddRange(((RequirementType[])Enum.GetValues(typeof(RequirementType))).Select(x => RequirementTypeConverter.Convert(x)).ToArray());

                if (req.myType == RequirementType.AND)
                {
                    ComboBox.SelectedItem = RequirementTypeConverter.Convert(RequirementType.AND);
                }
                else if (req.myType == RequirementType.OR)
                {
                    ComboBox.SelectedItem = RequirementTypeConverter.Convert(RequirementType.OR);
                }
            }
 public KeyTreeNode(ComplexRequirement req)
     : base(RequirementTypeConverter.Convert(req.myType))
 {
     Tag = req;
 }