private void OnLeave(object parameter)
        {
            PathPointNode node = parameter as PathPointNode;

            if (node != null)
            {
                Parent.LeaveSequence(node);
            }
        }
        private void OnEnter(object parameter)
        {
            PathPointNode node = parameter as PathPointNode;

            if (node != null)
            {
                Parent.EnterSequence(this, node);
            }
        }
        private void OnAdd(object parameter)
        {
            PathPointNode node = parameter as PathPointNode;

            if (node != null)
            {
                if (node.MyPath == null)
                {
                    node.MyPath = Parent.CreatePath();
                }
                Parent.StartPath(this, ref node);
            }
        }
        private bool CanAdd(object parameter)
        {
            if (Parent == null)
            {
                return(false);
            }
            PathPointNode node = parameter as PathPointNode;

            if (node != null)
            {
                if (node.DirectionType == PathPointNode.TypeDirection.IN)
                {
                    return(false);
                }
            }
            return(true);
        }
        private void OnEnter(object parameter)
        {
            PathPointNode node = parameter as PathPointNode;

            if (node != null)
            {
                if (node.DirectionType == PathPointNode.TypeDirection.IN)
                {
                    Input = node;
                }
                else if (node.DirectionType == PathPointNode.TypeDirection.OUT)
                {
                    Output = node;
                }

                Parent.EnterSequence(ModuleViewModle, node);
            }
        }
Beispiel #6
0
        private void AddPathDrawable(string Name, IEnumerable <BasePathGroup> Groups, Color color, bool CanConnect = true)
        {
            //Create a connectable object to connect each point
            var renderablePathConnected = new RenderableConnectedPaths(color);

            if (Name == "Lap Path" || Name == "Gravity Path")
            {
                renderablePathConnected.Use4PointConnection = true;
            }

            if (CanConnect)
            {
                viewport.AddDrawable(renderablePathConnected);
            }

            //Load a node wrapper to the tree
            var pathNode = new PathCollectionNode(Name);

            treeView1.Nodes.Add(pathNode);

            int groupIndex = 0;

            foreach (var group in Groups)
            {
                if (CanConnect)
                {
                    renderablePathConnected.AddGroup(group);
                }

                var groupNode = new PathGroupNode($"{Name} Group{groupIndex++}");
                pathNode.Nodes.Add(groupNode);

                int pointIndex = 0;
                foreach (var path in group.PathPoints)
                {
                    var pontNode = new PathPointNode($"{Name} Point{pointIndex++}");
                    pontNode.PathPoint = path;
                    groupNode.Nodes.Add(pontNode);

                    path.OnPathMoved = OnPathMoved;
                    viewport.AddDrawable(path.RenderablePoint);
                }
            }
        }
        private bool CanAdd(object parameter)
        {
            PathPointNode node = parameter as PathPointNode;

            if (node != null)
            {
                if (node.DirectionType == PathPointNode.TypeDirection.IN)
                {
                    Input = node;
                    return(false);
                }


                if (node.DirectionType == PathPointNode.TypeDirection.OUT)
                {
                    Output = node;
                }
            }

            return(true);
        }