Beispiel #1
0
        public List <IAllocatable> GetIAChildrenForIAllocatable(IAllocatable parentIA)
        {
            GraphNode parentNode = parentIA as GraphNode;

            List <IAllocatable> nodeList = new List <IAllocatable>();

            if (GraphNodes.Contains(parentNode))
            {
                if (ParentToChildrenMap.ContainsKey(parentNode))
                {
                    nodeList = ParentToChildrenMap[parentNode].Cast <IAllocatable>().ToList();
                }
            }
            else
            {
                throw new InvalidOperationException("Graph does not contain node specified!");
            }

            //add  AtomicRITE
            List <IAllocatable> aRiteList = new List <IAllocatable>();

            foreach (AtomicRITE aR in parentNode.ResidualAtomicRITEs)
            {
                IAllocatable aIA = aR as IAllocatable;
                aRiteList.Add(aIA);
            }

            return(nodeList.Union(aRiteList).ToList());
        }
Beispiel #2
0
        protected void LoadGraphUI()
        {
            foreach (Node n in Graph.Nodes)
            {
                UINode unode = new UINode(n, this, n.ViewOriginX, n.ViewOriginY, XShift, YShift, Scale);

                unode.HorizontalAlignment = HorizontalAlignment.Left;
                unode.VerticalAlignment   = VerticalAlignment.Top;
                ViewPort.Children.Add(unode);
                GraphNodes.Add(unode);

                lookup[n.Id] = unode;
            }

            Task.Delay(250).ContinueWith((Task t) =>
            {
                App.Current.Dispatcher.Invoke(() =>
                {
                    //foreach uinode connect up
                    foreach (UINode n in GraphNodes)
                    {
                        n.LoadConnections(lookup);
                    }

                    Graph.ReadOnly = ReadOnly;
                });
            });
        }
Beispiel #3
0
        public void Release()
        {
            if (UINodeParameters.Instance != null)
            {
                UINodeParameters.Instance.ClearView();
            }

            foreach (UINode n in GraphNodes)
            {
                ViewPort.Children.Remove(n);
            }

            lookup.Clear();
            GraphNodes.Clear();

            if (Graph != null)
            {
                Graph.OnGraphUpdated -= Graph_OnGraphUpdated;

                Graph.Dispose();
                Graph = null;
            }

            if (Original != null)
            {
                Original.Dispose();
                Original = null;
            }

            ViewPort.Children.Clear();
        }
Beispiel #4
0
        /// <summary>
        /// Helper for Undo Redo system. Does not trigger new undo added to stack
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public Tuple <string, Point, List <Tuple <string, List <NodeOutputConnection> > > > RemoveNode(string id)
        {
            var n = GraphNodes.Find(m => m.Id.Equals(id));

            Tuple <string, Point, List <Tuple <string, List <NodeOutputConnection> > > > result = null;

            if (n != null)
            {
                result = new Tuple <string, Point, List <Tuple <string, List <NodeOutputConnection> > > >(n.Node.GetJson(), n.Origin, n.Node.GetParentsConnections());

                //to remove connections but not to remove from graph
                n.DisposeNoRemove();

                GraphNodes.Remove(n);
                ViewPort.Children.Remove(n);
                lookup.Remove(n.Id);

                //remove from underlying graph
                Graph.Remove(n.Node);

                Modified = true;
            }

            return(result);
        }
Beispiel #5
0
        protected void AddNode(string type, Point p)
        {
            Node   n     = null;
            UINode unode = null;

            n = Graph.CreateNode(type);

            if (n != null)
            {
                if (n is GraphInstanceNode)
                {
                    GraphInstanceNode gn = (GraphInstanceNode)n;
                    gn.Load(type);
                }

                Modified = true;

                n.ViewOriginX = p.X;
                n.ViewOriginY = p.Y;

                Graph.Add(n);
                unode = new UINode(n, this, p.X, p.Y, XShift, YShift, Scale);
                unode.HorizontalAlignment = HorizontalAlignment.Left;
                unode.VerticalAlignment   = VerticalAlignment.Top;
                lookup[n.Id] = unode;
                ViewPort.Children.Add(unode);
                GraphNodes.Add(unode);

                UndoRedoManager.AddUndo(new UndoCreateNode(Id, unode.Id, this));
            }
        }
Beispiel #6
0
        /// <summary>
        /// Helper for Undeo Redo System. Does not trigger new undo added to stack.
        /// </summary>
        /// <param name="json"></param>
        /// <param name="p"></param>
        /// <returns></returns>
        public UINode AddNodeFromJson(string json, Point p)
        {
            try
            {
                Node.NodeData nd = JsonConvert.DeserializeObject <Node.NodeData>(json);

                if (nd == null)
                {
                    return(null);
                }

                Node   n     = null;
                UINode unode = null;

                n = Graph.CreateNode(nd.type);

                if (n != null)
                {
                    if (n is GraphInstanceNode)
                    {
                        GraphInstanceNode gn = (GraphInstanceNode)n;
                        gn.Load(nd.type);
                    }

                    n.Id = nd.id;

                    n.Width  = nd.width;
                    n.Height = nd.height;

                    Graph.Add(n);

                    n.FromJson(Graph.NodeLookup, json);

                    unode = new UINode(n, this, p.X, p.Y, XShift, YShift, Scale);
                    unode.HorizontalAlignment = HorizontalAlignment.Left;
                    unode.VerticalAlignment   = VerticalAlignment.Top;
                    lookup[n.Id] = unode;
                    ViewPort.Children.Add(unode);
                    GraphNodes.Add(unode);

                    Modified = true;

                    Task.Delay(250).ContinueWith(t =>
                    {
                        unode.LoadConnections(lookup);
                    });
                }

                return(unode);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.StackTrace);
            }

            return(null);
        }
Beispiel #7
0
            public void Run()
            {
                GraphNodes.ForEach(s => s.Visited = false);

                foreach (var v in GraphNodes)
                {
                    if (!v.Visited)
                    {
                        Visit(v);
                    }
                }
            }
Beispiel #8
0
        /// <summary>
        /// real lookup is required as the nodes added from json
        /// from a paste command will have new ids
        /// but will need to lookup the old ids
        /// to reconnect any that may have been connected when pasted
        /// </summary>
        /// <param name="json"></param>
        /// <param name="realLookup"></param>
        /// <returns></returns>
        protected UINode AddNodeFromJson(string json, Dictionary <string, Node> realLookup)
        {
            try
            {
                Node.NodeData nd = JsonConvert.DeserializeObject <Node.NodeData>(json);

                if (nd == null)
                {
                    return(null);
                }

                Node   n     = null;
                UINode unode = null;

                n = Graph.CreateNode(nd.type);

                if (n != null)
                {
                    if (n is GraphInstanceNode)
                    {
                        GraphInstanceNode gn = (GraphInstanceNode)n;
                        gn.Load(nd.type);
                    }

                    realLookup[nd.id] = n;

                    Graph.Add(n);

                    unode = new UINode(n, this, 0, 0, XShift, YShift, Scale);
                    unode.HorizontalAlignment = HorizontalAlignment.Left;
                    unode.VerticalAlignment   = VerticalAlignment.Top;
                    lookup[n.Id] = unode;
                    ViewPort.Children.Add(unode);
                    GraphNodes.Add(unode);

                    UndoRedoManager.AddUndo(new UndoCreateNode(Id, unode.Id, this));

                    Modified = true;
                }

                return(unode);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.StackTrace);
                return(null);
            }
        }
Beispiel #9
0
        public void RemoveNode(UINode n)
        {
            string json = n.Node.GetJson();
            Point  p    = n.Origin;

            UndoRedoManager.AddUndo(new UndoDeleteNode(Id, json, p, n.Node.GetParentsConnections(), this));

            GraphNodes.Remove(n);
            ViewPort.Children.Remove(n);
            lookup.Remove(n.Id);

            //remove from underlying graph
            Graph.Remove(n.Node);

            Modified = true;
        }
Beispiel #10
0
        public void ClearView()
        {
            //reset viewport etc
            XShift = 0;
            YShift = 0;
            Scale  = 1;

            foreach (UINode n in GraphNodes)
            {
                ViewPort.Children.Remove(n);
            }

            lookup.Clear();
            GraphNodes.Clear();
            ViewPort.Children.Clear();
        }
Beispiel #11
0
        //public abstract List<GraphNode> GetChildrenForNode(GraphNode parentNode);

        public List <GraphNode> GetChildrenForNode(GraphNode parentNode)
        {
            if (GraphNodes.Contains(parentNode))
            {
                if (ParentToChildrenMap.ContainsKey(parentNode))
                {
                    return(ParentToChildrenMap[parentNode]);
                }
                else
                {
                    return(new List <GraphNode>());//throw new InvalidOperationException("Node does not have any children!");
                }
            }
            else
            {
                throw new InvalidOperationException("Graph does not contain node specified!");
            }
        }
Beispiel #12
0
        private void CalculatePositions()
        {
            if (GraphNodes == null)
            {
                return;
            }

            var nodes = GraphNodes.ToArray();

            try
            {
                CalculateNodes(nodes);
                CalculateEdges(nodes);
            }
            catch (Exception ex)
            {
                s_Logger.ErrorFormat("Error while calculating graph: {0}", ex);
            }
        }
Beispiel #13
0
        public void Add_A_Node_to_Graph()
        {
            //Arrange
            var graph = new Graph();

            //Act
            GraphNodes result = graph.AddNode("Piper");

            //Assert - we needed five asserts to make sure that it absolutely was correct
            Assert.NotEmpty(graph.Nodes);
            Assert.Equal(1, graph.Count);

            Assert.NotNull(result);
            Assert.Equal("Piper", result.Value);
            Assert.Contains(result, graph.Nodes);

            //Assert.Empty(result.Neighbors);
            //Assert.Empty(graph.GetNeighbors(result));
        }
Beispiel #14
0
        protected void LoadGraphUI()
        {
            if (Graph is FunctionGraph)
            {
                FunctionGraph fg = (FunctionGraph)Graph;

                OutputRequirementsLabel.Text = "Required Output Node Type: " + fg.ExpectedOutput.ToString();
            }
            else
            {
                OutputRequirementsLabel.Text = "";
            }

            foreach (Node n in Graph.Nodes)
            {
                UINode unode = new UINode(n, this, n.ViewOriginX, n.ViewOriginY, XShift, YShift, Scale);

                unode.HorizontalAlignment = HorizontalAlignment.Left;
                unode.VerticalAlignment   = VerticalAlignment.Top;
                ViewPort.Children.Add(unode);
                GraphNodes.Add(unode);

                lookup[n.Id] = unode;
            }

            Task.Delay(250).ContinueWith((Task t) =>
            {
                App.Current.Dispatcher.Invoke(() =>
                {
                    //foreach uinode connect up
                    foreach (UINode n in GraphNodes)
                    {
                        n.LoadConnections(lookup);
                    }

                    Graph.ReadOnly = ReadOnly;
                });
            });
        }
Beispiel #15
0
        public WPF.Control createGraphNode(string methodSignature)
        {
            if (GraphNodes.hasKey(methodSignature))
            {
                return(GraphNodes[methodSignature]);
            }

            var graphNode = GraphViewer.newInThread <WPF.Label>();
            var iMethod   = AstData.iMethod_withSignature(methodSignature);

            if (iMethod != null)
            {
                //this.GraphModeRightPanels[0].clear();
                //GraphViewer = this.GraphModeRightPanels[0].add_Graph();
                graphNode.set_Content(iMethod.Name);
                //graphNode.set_Tag(iMethod);
                WPF_Controls_ExtensionMethods_Control.color(graphNode, "Black");                 // direct call throws compile error -> graphNode.color("Black");
            }
            else
            {
                WPF_Controls_ExtensionMethods_Control.color(graphNode, "Red");
                graphNode.set_Content(methodSignature);
            }
            if (UseStarAsNodeText)
            {
                graphNode.set_Content("*");
            }
            graphNode.set_Tag(methodSignature);

            graphNode.onMouseDoubleClick <string, WPF.Label>(
                (signature) => {
                addCallerAndCalleesToGraphNode(graphNode, signature);
            });

            GraphNodes.add(methodSignature, graphNode);
            return(graphNode);
        }
Beispiel #16
0
            public void Run()
            {
                _queue = new Queue <GraphNode>();

                var first = GraphNodes.FirstOrDefault();

                first.Visited = true;
                _queue.Enqueue(first);

                while (_queue.Count != 0)
                {
                    var item = _queue.Dequeue();
                    Results.Add(item.Data);

                    foreach (var vertex in item.Edges)
                    {
                        if (!vertex.Visited)
                        {
                            vertex.Visited = true;
                            _queue.Enqueue(vertex);
                        }
                    }
                }
            }
 public void Reset()
 {
     GraphNodes.Clear();
     GraphLinks.Clear();
 }