/// <summary> /// Collapse all children (outgoing nodes) for the target node /// </summary> /// <param name="targetNode"></param> private void CollapseNode(NodeViewModelBase targetNode) { List <INode> childNodes = new List <INode>(); List <IEdgeViewModel> edgesToBeRemoved = new List <IEdgeViewModel>(); List <IEdgeViewModel> edgesToBeAdded = new List <IEdgeViewModel>(); List <NodeViewModelBase> nodesToBeRemoved = new List <NodeViewModelBase>(); graph = Data.GraphManager.Instance.GetGraphComponents(targetNode.Scope); // Get all the chidren for the target node childNodes = GetChildren(targetNode.ParentNode); // Ensure we have any child nodes before continuing if (childNodes.Count > 0) { foreach (INode childNode in childNodes) { NodeViewModelBase nodeVM = graph.GetNodeViewModel(childNode) as NodeViewModelBase; foreach (IEdge edge in graph.GetEdges(childNode)) { IEdgeViewModel edgeVM = graph.GetEdgeViewModel(edge); // Determine if this is an incoming edge if (edge.Target == childNode) { // Existing incoming edges need to be removed // and new ones need to be added edgesToBeRemoved.Add(edgeVM); // Determine if this edge's source node is inside // of the child nodes being collapsed if (!childNodes.Contains(edge.Source) && edge.Source != targetNode.ParentNode) { IEdgeViewModel newEdgeVM = (edgeVM as EdgeViewModelBase).Copy(edge.Source, targetNode.ParentNode); edgesToBeAdded.Add(newEdgeVM); } } else // Handle the outgoing edges { // Outgoing edges need to be saved and removed edgesToBeRemoved.Add(edgeVM); } } // Remove (hide) the node //nodeVM.IsHidden = true; nodesToBeRemoved.Add(nodeVM); } graph.RemoveNodeViewModels(nodesToBeRemoved); // Remove (hide) the edges RemoveEdges(edgesToBeRemoved, targetNode); // Add new edges AddEdges(edgesToBeAdded, targetNode); } }
public IEdge ConnectNodes(IEdgeViewModel <TEdge> connection, TVertex vertex1Object, TVertex vertex2Object, bool isDirected) { var vertex1 = Graph.Vertices.Single(v => v.Object.Object.Equals(vertex1Object)); var vertex2 = Graph.Vertices.Single(v => v.Object.Object.Equals(vertex2Object)); return(ConnectNodes(connection, vertex1.Id, vertex2.Id, isDirected)); }
/// <summary> /// Handles the NodeLoaded event which indicates that a node /// has been loaded onto the graph /// </summary> /// <param name="sender">The object that fired the event</param> /// <param name="e">The arguments for the event</param> private void nodeViewModel_NodeLoaded(object sender, System.EventArgs e) { // Obtain an instance to the node's view model NodeViewModelBase nodeViewModel = sender as NodeViewModelBase; // Get a reference to all edges associated with this node foreach (IEdge edge in graphData.Edges(nodeViewModel.ParentNode)) { // Get the EdgeViewModel for this edge if (!edgeToEdgeViewModel.ContainsKey(edge)) { continue; } // Obtain an instance to this edge's view model IEdgeViewModel edgeViewModel = edgeToEdgeViewModel[edge]; // Check if the current node is the source or target // so that we know which part of the edge line to // update. Our rule of thumb is that we draw the line // from source to target. if (edge.Source.Equals(nodeViewModel.ParentNode)) { // Update the edge line properties edgeViewModel.X1 = nodeViewModel.CenterPoint.X; edgeViewModel.Y1 = nodeViewModel.CenterPoint.Y; } else { // Update the edge line properties edgeViewModel.X2 = nodeViewModel.CenterPoint.X; edgeViewModel.Y2 = nodeViewModel.CenterPoint.Y; } } }
/// <summary> /// Returns the view model for the provided Edge /// </summary> /// <param name="node">The Edge whose view model is being /// requested</param> /// <returns>the view model for the provided edge</returns> public IEdgeViewModel GetEdgeViewModel(IEdge edge) { IEdgeViewModel edgeVM = null; if (this.edgeToEdgeViewModel.TryGetValue(edge, out edgeVM)) { return(edgeVM); } return(null); }
/// <summary> /// Removes the edge view model for the given edge (and the edge /// itself) /// </summary> /// <param name="edge">The edge whose view model should be removed</param> public void RemoveEdgeViewModel(IEdge edge) { IEdgeViewModel edgeVM = null; // Try and get the edge view model for the provided edge if (this.edgeToEdgeViewModel.TryGetValue(edge, out edgeVM)) { // Remove the edge view model for this edge RemoveEdgeViewModel(edgeVM); } }
/// <summary> /// Returns a new IEdgeViewModel that is a copy of the current /// edge view model but with the specified source and target /// nodes /// </summary> /// <param name="source">The source Node for this edge</param> /// <param name="target">The target Node for this edge</param> /// <returns>an edge view model</returns> public virtual IEdgeViewModel Copy(INode source, INode target) { // Create a copy of the parent edgeLine IEdge newEdge = this.ParentEdge.Copy(source, target); // Create a new edge view model based on the the type // of the new edge that was just created //EdgeViewModelBase oldEdgeVM = GetEdgeViewModel(newEdge); IEdgeViewModel newEdgeVM = null; //TODO: TRY AND UPDATE TO USE GENERICS if (this is SimilarityEdgeViewModel) { newEdgeVM = new SimilarityEdgeViewModel(newEdge as SimilarityDataEdge, this.Scope) { Visibility = this.Visibility, EdgeLine = new EdgeLine(ParentEdge.Type) { Opacity = this.EdgeLine.Opacity, Color = this.EdgeLine.Color, Thickness = this.EdgeLine.Thickness, LabelForegroundColor = this.EdgeLine.LabelForegroundColor, LabelBackgroundColor = this.EdgeLine.LabelBackgroundColor, LabelFontStyle = this.EdgeLine.LabelFontStyle, LabelFontWeight = this.EdgeLine.LabelFontWeight, LabelTextUnderline = this.EdgeLine.LabelTextUnderline, LabelFont = this.EdgeLine.LabelFont } }; } else { newEdgeVM = new StandardEdgeViewModel(newEdge, this.Scope) { Visibility = this.Visibility, EdgeLine = new EdgeLine(ParentEdge.Type) { Opacity = this.EdgeLine.Opacity, Color = this.EdgeLine.Color, Thickness = this.EdgeLine.Thickness, LabelForegroundColor = this.EdgeLine.LabelForegroundColor, LabelBackgroundColor = this.EdgeLine.LabelBackgroundColor, LabelFontStyle = this.EdgeLine.LabelFontStyle, LabelFontWeight = this.EdgeLine.LabelFontWeight, LabelTextUnderline = this.EdgeLine.LabelTextUnderline, LabelFont = this.EdgeLine.LabelFont } }; } return(newEdgeVM); }
/// <summary> /// Removes the edge view model from the graph /// </summary> /// <param name="edgeVM">The edge view model to be removed</param> public void RemoveEdgeViewModel(IEdgeViewModel edgeVM) { // Remove the parent edge this.graphData.RemoveEdge(edgeVM.ParentEdge); // Ensure that the provided edge view model exists if (this.edgeToEdgeViewModel.ContainsKey(edgeVM.ParentEdge)) { // Remove the edge view model from the collection this.edgeToEdgeViewModel.Remove(edgeVM.ParentEdge); // Fire the EdgeViewModelRemoved event OnEdgeViewModelRemoved(new EdgeViewModelEventArgs(edgeVM, this.scope)); } }
public IEdge ConnectNodes(IEdgeViewModel <TEdge> connection, uint vertex1Id, uint vertex2Id, bool isDirected) { var edge = new Edge <IEdgeViewModel <TEdge> >( Graph.GetUnusedEdgeId(), vertex1Id, vertex2Id) { IsDirected = isDirected, Object = connection }; Graph.AddEdge(edge); Edges.Add(connection); RearrangeGraph(); return(edge); }
/// <summary> /// Adds the provided edgeviewmodel (and it's parent edge) /// to the graph /// </summary> /// <param name="edgeVMs">The edge view model to be added to the graph</param> public void AddEdgeViewModel(IEdgeViewModel edgeVM) { // Add the ParentEdge for this view model. The AddEdge method // will check if the edge already exists. this.graphData.AddEdge(edgeVM.ParentEdge); // Check if the edge view model already exists if (!this.edgeToEdgeViewModel.ContainsKey(edgeVM.ParentEdge)) { if (graphData.OrphanEdges.Contains(edgeVM.ParentEdge)) { _orphanEdgeViewModels.Add(edgeVM); } else { // Get the viewmodels for the source and target nodes INodeShape sourceNodeVM = GetNodeViewModel(edgeVM.ParentEdge.Source); INodeShape targetNodeVM = GetNodeViewModel(edgeVM.ParentEdge.Target); // Ensure the edge is attached to its source if (sourceNodeVM != null) { edgeVM.X1 = sourceNodeVM.CenterPoint.X; edgeVM.Y1 = sourceNodeVM.CenterPoint.Y; } // Ensure the edge is attached to its target if (targetNodeVM != null) { edgeVM.X2 = targetNodeVM.CenterPoint.X; edgeVM.Y2 = targetNodeVM.CenterPoint.Y; } // Now we need to update the edge to edgeviewmodels collection edgeToEdgeViewModel.Add(edgeVM.ParentEdge, edgeVM); // Fire the EdgeViewModelAdded event OnEdgeViewModelAdded(new EdgeViewModelEventArgs(edgeVM, this.scope)); } } }
/// <summary> /// Remove an edge view (physical edge line) /// </summary> /// <param name="edgeViewModel">The view model for the edge view to be removed</param> private void RemoveEdgeView(IEdgeViewModel edgeViewModel) { // Remove the physical edge (the line) from the graph surface edgeViewModel.EraseEdgeLine(graphSurface); }
//public void ScaleBy(double scaleChange) //{ // double MIN_SCALE = 0.01; // double MAX_SCALE = 4; // double newScale = this.currentScale + (this.currentScale * scaleChange); // //double newScale = this.scale * scaleChange; // //if (newScale < MIN_SCALE) // //{ // // proposedScale = MIN_SCALE / this.currentScale; // // newScale = this.currentScale * proposedScale; // // scaleChange = MIN_SCALE; // //} // // else if (newScale > MAX_SCALE) // //{ // // proposedScale = MAX_SCALE / this.currentScale; // // newScale = this.currentScale * proposedScale; // // scaleChange = MAX_SCALE; // //} // if (newScale < MIN_SCALE) // return; // if (newScale > MAX_SCALE) // return; // // Set the scale transform // //this.Scale += proposedScale; // this.Scale = newScale; // this.currentScale = newScale; // currentTranslation.X += (GraphSurfaceWidth / currentScale - GraphSurfaceWidth / (currentScale / scaleChange)) / 2; // currentTranslation.Y += (GraphSurfaceHeight / currentScale - GraphSurfaceHeight / (currentScale / scaleChange)) / 2; //} /// <summary> /// Add an edge view (physical edge line) /// </summary> /// <param name="edgeViewModel">The view model for the edge view to be created</param> private void AddEdgeView(IEdgeViewModel edgeViewModel) { // Draw the physical edge (the line) on the graph surface edgeViewModel.DrawEdgeLine(graphSurface); }
/// <summary> /// Creates a new instance of the Berico.SnagL.Events. /// EdgeViewModelMouseEventArgs class using the provided /// IEdgeViewModel and MouseEventArgs. /// </summary> /// <param name="_nodeVM">The view model class for the node involved /// in the event</param> /// <param name="_args">The mouse arguments related to the event</param> /// <param name="_sourceID">The ID for graph that this object belongs to</param> public EdgeViewModelMouseEventArgs(IEdgeViewModel _edgeVM, T _args, string _scope) : base(_edgeVM, _scope) { MouseArgs = _args; }
/// <summary> /// Adds the specificed edge /// </summary> /// <param name="graphComponents">The Graph that data is being imported into</param> /// <param name="creationType">The specified CreationType</param> /// <param name="objEdge">Edge to be added</param> public static void AddEdge(GraphComponents graphComponents, CreationType creationType, EdgeMapData objEdge) { INode uiSourceNode = graphComponents.Data.GetNode(objEdge.Source); if (uiSourceNode == null && creationType == CreationType.Imported) { throw new Exception("Missing Source Node"); } else if (uiSourceNode == null)// && creationType == CreationType.Live { uiSourceNode = new GhostNode(objEdge.Source); } INode uiTargetNode = graphComponents.Data.GetNode(objEdge.Target); if (uiTargetNode == null && creationType == CreationType.Imported) { throw new Exception("Missing Target Node"); } else if (uiTargetNode == null)// && creationType == CreationType.Live { uiTargetNode = new GhostNode(objEdge.Target); } if (string.IsNullOrEmpty(objEdge.Label) && objEdge.Attributes.Count == 0) { Berico.SnagL.Model.Edge uiEdge = new Berico.SnagL.Model.Edge(uiSourceNode, uiTargetNode); uiEdge.SourceMechanism = creationType; // Properties uiEdge.Type = objEdge.Type; // the EdgeViewModel must be created after uiEdge has had a Type specified IEdgeViewModel uiEdgeVM = EdgeViewModelBase.GetEdgeViewModel(uiEdge, graphComponents.Scope); graphComponents.AddEdgeViewModel(uiEdgeVM); } else { DataEdge uiEdge = new DataEdge(uiSourceNode, uiTargetNode); uiEdge.SourceMechanism = creationType; // Properties uiEdge.Type = objEdge.Type; uiEdge.DisplayValue = objEdge.Label; // the EdgeViewModel must be created after uiEdge has had a Type specified IEdgeViewModel uiEdgeVM = EdgeViewModelBase.GetEdgeViewModel(uiEdge, graphComponents.Scope); graphComponents.AddEdgeViewModel(uiEdgeVM); uiEdgeVM.Thickness = objEdge.Thickness; uiEdgeVM.Color = new SolidColorBrush(objEdge.Color); uiEdgeVM.EdgeLine.Text = objEdge.Label; uiEdgeVM.EdgeLine.LabelTextUnderline = objEdge.IsLabelTextUnderlined; uiEdgeVM.EdgeLine.LabelBackgroundColor = new SolidColorBrush(objEdge.LabelBackgroundColor); uiEdgeVM.EdgeLine.LabelForegroundColor = new SolidColorBrush(objEdge.LabelForegroundColor); uiEdgeVM.EdgeLine.LabelFontStyle = objEdge.LabelFontStyle; uiEdgeVM.EdgeLine.LabelFontWeight = objEdge.LabelFontWeight; if (objEdge.LabelFont != null) { uiEdgeVM.EdgeLine.LabelFont = objEdge.LabelFont; } // Attributes foreach (KeyValuePair <string, AttributeMapData> objEdgeAttrKVP in objEdge.Attributes) { Attributes.Attribute uiEdgeAttribute = new Attributes.Attribute(objEdgeAttrKVP.Value.Name); AttributeValue uiEdgeAttributeValue = new AttributeValue(objEdgeAttrKVP.Value.Value); uiEdge.Attributes.Add(uiEdgeAttribute.Name, uiEdgeAttributeValue); //GlobalAttributeCollection.GetInstance(graphComponents.Scope).Add(uiEdgeAttribute, uiEdgeAttributeValue); uiEdgeAttribute.SemanticType = objEdgeAttrKVP.Value.SemanticType; uiEdgeAttribute.PreferredSimilarityMeasure = objEdgeAttrKVP.Value.SimilarityMeasure; uiEdgeAttribute.Visible = !objEdgeAttrKVP.Value.IsHidden; } } }
/// <summary> /// Creates a new instance of the Berico.SnagL.Events. /// EdgeViewModelEventArgs class using the provided /// EdgeViewModelBase /// </summary> /// <param name="_edgeVM">The view model class for the edge involved /// in the event</param> /// <param name="_sourceID">The ID for graph that this object belongs to</param> public EdgeViewModelEventArgs(IEdgeViewModel _edgeVM, string _scope) { EdgeViewModel = _edgeVM; Scope = _scope; }