/// <summary> /// Redraws the graph with the specified layout type /// </summary> /// <param name="layout">Type of graph layout</param> /// <param name="isAnimated">Specifies whether or not to animate the graph when it's laid out</param> /// <param name="scope">Specifies the default graph scope</param> /// <param name="rootNode">Specifies the root node for layouts that require one</param> public void LayoutGraph(LayoutBase layout, bool isAnimated, string scope, NodeViewModelBase rootNode) { LayoutManager flyweight = LayoutManager.Instance; // Make sure we have a scope if (String.IsNullOrWhiteSpace(scope)) { scope = this.defaultComponentInstanceScope; } // Get the graph as a GraphMapData object GraphMapData graphMapData = GetGraphComponents(scope).ExportGraph(); // Execute the layout DispatcherHelper.UIDispatcher.BeginInvoke(() => { if (rootNode != null) { layout.CalculateLayout(graphMapData, rootNode.ParentNode); } else { layout.CalculateLayout(graphMapData); } System.Diagnostics.Debug.WriteLine(""); foreach (Delegate d in ContextMenuManager.Instance.GetContextMenuOpeningInvocationList()) { System.Diagnostics.Debug.WriteLine((d.Target as GraphComponents).Scope); } layout.PositionNodes(isAnimated, graphMapData); }); }
/// <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); } }
/// <summary> /// Visualizes the target node's importance by altering it's color /// </summary> /// <param name="target">The node that is the target for this visualization</param> /// <param name="importance">A value that indicates how important the target /// is. This value affects the target visualization.</param> public void Visualize(NodeViewModelBase target, double importance) { // Compute the color that should be used Color computedColor = new Color { A = 255, R = (byte)(_delta.R * importance / _range + _lowerColor.R), G = (byte)(_delta.G * importance / _range + _lowerColor.G), B = (byte)(_delta.B * importance / _range + _lowerColor.B) }; // Check if the current background color is Transparent //if (target.BackgroundColor.Color != Colors.Transparent) //{ // Check if the color for this node has already // been saved if (!_storedColors.ContainsKey(target.ParentNode.ID)) { // Save the color for this node _storedColors.Add(target.ParentNode.ID, target.BackgroundColor.Color); } //} // Set the node's background color target.BackgroundColor = new SolidColorBrush(computedColor); }
private void AddEdges(List <IEdgeViewModel> edges, NodeViewModelBase parentNode) { // Record the new edges addedEdges.Add(parentNode, edges); // Add the edges to the graph graph.AddEdgeViewModels(edges); }
private void AddNewRow(TableModel model, NodeViewModelBase itemToRemove) { if (model.IsCollapsed) model.IsCollapsed = false; if (itemToRemove == null) model.AddItem(new RowModel() { ColumnName = "NewRow", DataType = DataType.String }); else model.AddItem(itemToRemove); }
/// <summary> /// Handles the MouseLeftButtonDown event /// </summary> /// <param name="args">The arguments for the event</param> public void NodeMouseLeftButtonDownEventHandler(NodeViewModelMouseEventArgs <MouseButtonEventArgs> args) { // Turn on node dragging if we are in node selection mode if (!isPanMode) { isLeftButtonDown = true; dragTargetNode = args.NodeViewModel; isMouseDownHandled = true; } }
private void RemoveRow(TableModel model, NodeViewModelBase itemToRemove) { var dc = this.DataContext as TablesGraphSource; if (dc != null && model != null && itemToRemove != null) { if (model.IsCollapsed) model.IsCollapsed = false; dc.RemoveItem(itemToRemove); } CommandManager.InvalidateRequerySuggested(); }
private void RemoveEdges(List <IEdgeViewModel> edges, NodeViewModelBase parentNode) { // Save the edges savedEdges.Add(parentNode, edges); graph.RemoveEdgeViewModels(edges); // Loop over all the edge view models that were provided // that need to be removed //foreach (IEdgeViewModel edgeVM in edges) //{ // edgeVM.Visibility = Visibility.Collapsed; //} }
/// <summary> /// Returns a PartitionNode instance for the next connected /// component contained in the provided list. The collection /// provided is altered and should not be changed between calls /// to this method. /// </summary> /// <param name="nodeVMs">The collection of node view models to be processed</param> /// <param name="partitionGraphScope">The scope for the paritioned graph</param> /// <param name="originalScope">The scope for the original graph</param> /// <returns>a PartitionNode containing a set of connected nodes</returns> private PartitionNode GetNextConnectedComponent(IList <NodeViewModelBase> nodeVMs, string scope) { // Make sure node view models were provided if (nodeVMs.Count == 0) { return(null); } // Create a new partition node to hold these components PartitionNode partitionNode = new PartitionNode(scope, "PN-" + nodeVMs.Count); // Start at the first nodeVMs List <NodeViewModelBase> visitedNodes = new List <NodeViewModelBase>(); List <NodeViewModelBase> rootNodes = new List <NodeViewModelBase>(); // Add the first node view model to the root and visited lists rootNodes.Add(nodeVMs[0]); visitedNodes.Add(nodeVMs[0]); // Itterate over the root nodes while (rootNodes.Count > 0) { int currentNodeIndex = 0; // Add the current node view model to the // current PartitionNode partitionNode.AddNode(rootNodes[currentNodeIndex]); // Itterate over the node's neighbors foreach (Model.INode node in GetGraphComponents(rootNodes[currentNodeIndex].Scope).Data.Neighbors(rootNodes[currentNodeIndex].ParentNode)) { // Get the nodeVM for this node NodeViewModelBase nodeVM = GetGraphComponents(rootNodes[currentNodeIndex].Scope).GetNodeViewModel(node) as NodeViewModelBase; // Check if this node has already been visisted if (!visitedNodes.Contains(nodeVM)) { // Add this node to our two holder collections rootNodes.Add(nodeVM); visitedNodes.Add(nodeVM); } } // Remove the current node since it has been processed nodeVMs.Remove(rootNodes[currentNodeIndex]); rootNodes.RemoveAt(currentNodeIndex); } return(partitionNode); }
/// <summary> /// Visualizes the target node's importance by altering it's size /// </summary> /// <param name="target">The node that is the target for this visualization</param> /// <param name="importance">A value that indicates how important the target /// is. This value affects the visualization functionality.</param> public void Visualize(NodeViewModelBase target, double importance) { if (importance == 0) { target.Scale = 0.75; } else if (importance == 1) { target.Scale = 3; } else { target.Scale = 1.0 + importance; } }
private void RemoveRow(TableModel model, NodeViewModelBase itemToRemove) { var dc = this.DataContext as TablesGraphSource; if (dc != null && model != null && itemToRemove != null) { if (model.IsCollapsed) { model.IsCollapsed = false; } dc.RemoveItem(itemToRemove); } CommandManager.InvalidateRequerySuggested(); }
public static NodeMapData GetNode(NodeViewModelBase uiNodeVM) { NodeMapData objNode; if (uiNodeVM.GetType().Equals(typeof(IconNodeViewModel))) { objNode = new IconNodeMapData(uiNodeVM.ParentNode.ID); // Property IconNodeViewModel iconNodeVM = (IconNodeViewModel)uiNodeVM; if (iconNodeVM.ImageSource != null) { ((IconNodeMapData)objNode).ImageSource = new System.Uri(iconNodeVM.ImageSource, UriKind.Relative); } } else { objNode = new TextNodeMapData(uiNodeVM.ParentNode.ID); } // Properties objNode.Description = uiNodeVM.Description; objNode.Label = uiNodeVM.DisplayValue; Size dimension = new Size(uiNodeVM.Width, uiNodeVM.Height); objNode.Dimension = dimension; objNode.Position = uiNodeVM.Position; objNode.IsHidden = uiNodeVM.IsHidden; objNode.BackgroundColor = uiNodeVM.BackgroundColor.Color; objNode.SelectionColor = uiNodeVM.SelectionColor.Color; // Attributes foreach (KeyValuePair <string, AttributeValue> uiNodeVMAttrKVP in uiNodeVM.ParentNode.Attributes) { Attributes.Attribute uiNodeVMAttribute = GlobalAttributeCollection.GetInstance(uiNodeVM.Scope).GetAttribute(uiNodeVMAttrKVP.Key); AttributeMapData objNodeAttribute = new AttributeMapData(uiNodeVMAttrKVP.Key, uiNodeVMAttrKVP.Value.Value); objNode.Attributes.Add(objNodeAttribute.Name, objNodeAttribute); objNodeAttribute.SemanticType = uiNodeVMAttribute.SemanticType; objNodeAttribute.SimilarityMeasure = uiNodeVMAttribute.PreferredSimilarityMeasure; objNodeAttribute.IsHidden = !uiNodeVMAttribute.Visible; } return(objNode); }
/// <summary> /// Executes the JavaScript function specified by <paramref name="callbackName"/> /// </summary> /// <param name="sender">The NodeViewModel that raised the event</param> /// <param name="callbackName">The name of the JavaScript function to execute</param> private static void ExecuteNodeJSCallback(object sender, string callbackName) { //TODO: VALIDATE CALLBACK try { NodeViewModelBase nodeVM = (NodeViewModelBase)sender; NodeMapData nodeMapData = MappingExtensions.GetNode(nodeVM); ScriptableNodeMapData scriptableNodeMapData = ScriptableMapper.GetNode(nodeMapData); HtmlPage.Window.Invoke(callbackName, scriptableNodeMapData); } catch (InvalidOperationException) { MessageBox.Show("Unable to find the '" + callbackName + "' method in the host application", "Unknown callback", MessageBoxButton.OK); // Swallow error for now //TODO: LOG THIS CASE } }
private void AddNewRow(TableModel model, NodeViewModelBase itemToRemove) { if (model.IsCollapsed) { model.IsCollapsed = false; } if (itemToRemove == null) { model.AddItem(new RowModel() { ColumnName = "NewRow", DataType = DataType.String }); } else { model.AddItem(itemToRemove); } }
public void SetPlayingVideo(NodeViewModelBase video) { var node = Items.FirstOrDefault(n => n.Id == video.Id); var videoItem = node as VideoItemViewModel; if (videoItem == null) { return; } var nowPlaying = GetNowPlayingVideo(); if (nowPlaying == null) { return; } nowPlaying.IsNowPlaying = false; videoItem.IsNowPlaying = true; }
/// <summary> /// Handles the ToolbarItemClicked event /// </summary> /// <param name="args">The arguments for the event</param> public void ToolbarItemClickedEventHandler(ToolBarItemEventArgs args) { NodeViewModelBase rootNode = GetGraphComponents(args.Scope).NodeSelector.SelectedNode; // TODO: USE CONSTANT FOR ITEM NAME // TODO: Controls should control their own behavior if (args.ToolBarItem.Name == "GENERATOR") { CreateRandomGraph(args.Scope); } else if (args.ToolBarItem.Name.EndsWith("_LAYOUT")) { LayoutBase layout = InitializeLayout(args.ToolBarItem.Name, args.Scope); // Perform the layout LayoutGraph(layout, false, args.Scope, rootNode); } else if (args.ToolBarItem.Name == "IMPORT") { PerformImport(args.Scope, new GraphMLGraphDataFormat()); // TODO: Determine which type at runtime } else if (args.ToolBarItem.Name == "EXPORT") { PerformExport(args.Scope); } else if (args.ToolBarItem.Name == "GRAPH_TO_IMAGE") { SaveGraphAsImage(); } else if (args.ToolBarItem.Name == "PRINT_GRAPH") { PrintGraph(); } else if (args.ToolBarItem.Name == "RESIZE") { UI.GraphViewModel graphVM = UI.ViewModelLocator.GraphDataStatic; graphVM.ResizeToFit(); //TODO: THIS SHOULD BE DECOUPLED } }
private void RadDiagram_PreviewDrop(object sender, System.Windows.DragEventArgs e) { var droppedRow = e.Data.GetData(typeof(GridViewRow)); var employee = (droppedRow as GridViewRow).DataContext as Employee; NodeViewModelBase node = new NodeViewModelBase(); node.Position = e.GetPosition(this.xDiagram); node.Content = employee.FirstName + " " + employee.LastName; var droppedUIElement = e.OriginalSource as UIElement; var droppedInsideContainer = droppedUIElement.ParentOfType <RadDiagramContainerShape>(); if (droppedInsideContainer != null) { var division = droppedInsideContainer.DataContext as Division; node.Position = this.InsertAtPositionOfDroppedContainer(droppedInsideContainer); division.AddItem(node); } (this.DataContext as MainViewModel).EmployeeGraphSource.AddNode(node); (this.DataContext as MainViewModel).EmployeeData.Remove(employee); }
/// <summary> /// Creates a new instance of the Berico.SnagL.Events. /// NodeEventArgs class using the provided NodeViewModelBase /// 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 NodeViewModelMouseEventArgs(NodeViewModelBase _nodeVM, T _args, string _scope) : base(_nodeVM, _scope) { MouseArgs = _args; }
private void RankingCompletedHandler(object sender, RankingEventArgs e) { // Remove event handler for currently selected ranker SelectedRanker.RankingCompleted -= RankingCompletedHandler; GraphComponents graph = GraphManager.Instance.DefaultGraphComponentsInstance; List <RankingData> data = new List <RankingData>(); if (_colorVisualizer == null) { _colorVisualizer = new ColorVisualizer(e.Results.Values.Min(), e.Results.Values.Max()); } else { _colorVisualizer.Reset(e.Results.Values.Min(), e.Results.Values.Max()); } _scaleVisualizer = new ScaleVisualizer(); foreach (INode node in e.Results.Keys) { RankingData rankingData = new RankingData { Score = e.Results[node], NodeCount = 1 }; if (data.Contains(rankingData)) { data[data.IndexOf(rankingData)].NodeCount += 1; } else { data.Add(rankingData); } NodeViewModelBase nodeVM = graph.GetNodeViewModel(node) as NodeViewModelBase; if (nodeVM != null) { if ((VisualizationOption & VisualizationOptions.Color) == VisualizationOptions.Color) { _colorVisualizer.Visualize(nodeVM, e.Results[node]); } else { _colorVisualizer.ClearVisualization(nodeVM); } if ((VisualizationOption & VisualizationOptions.Scale) == VisualizationOptions.Scale) { _scaleVisualizer.Visualize(nodeVM, e.Results[node]); } else { _scaleVisualizer.ClearVisualization(nodeVM); } } } Scores = new ObservableCollection <RankingData>(data.OrderBy(rankData => rankData.Score)); IsActive = true; }
/// <summary> /// Event raised while the user is dragging a node. /// </summary> private void NodeItem_Dragging(object source, NodeDraggingEventArgs e) { e.Handled = true; // // Cache the NodeItem for each selected node whilst dragging is in progress. // if (this.cachedSelectedNodeItems == null) { this.cachedSelectedNodeItems = new List <Node>(); foreach (var selectedNode in this.SelectedNodes) { Node nodeItem = FindAssociatedNodeItem(selectedNode); if (nodeItem == null) { throw new ApplicationException("Unexpected code path!"); } this.cachedSelectedNodeItems.Add(nodeItem); } } // // Update the position of the node within the Canvas. // foreach (var nodeItem in this.cachedSelectedNodeItems) { nodeItem.X += e.HorizontalChange; nodeItem.Y += e.VerticalChange; NodeViewModelBase vm = nodeItem.Content as NodeViewModelBase; if (vm != null) { vm.Left.X += e.HorizontalChange; vm.Left.Y += e.VerticalChange; vm.Right.X += e.HorizontalChange; vm.Right.Y += e.VerticalChange; } } //Detect Selected node insert operation Point p = Mouse.GetPosition(this); List <object> unselected = new List <object>(); foreach (var node in Nodes) { if (!SelectedNodes.Contains(node)) { unselected.Add(node); } } foreach (var node in unselected) { Node nodeItem = FindAssociatedNodeItem(node); NodeViewModelBase vm = nodeItem.Content as NodeViewModelBase; if (vm == null) { throw new NotSupportedException("Node Control contents must inherit from NodeViewModelBase."); } var targetRect = new Rect(new Point(vm.Left.X, vm.Left.Y), new Size(vm.Left.Width, vm.Left.Height)); } var eventArgs = new NodeDraggingEventArgs(NodeDraggingEvent, this, this.SelectedNodes, e.HorizontalChange, e.VerticalChange); RaiseEvent(eventArgs); }
/// <summary> /// Determines which operation (Collapse or Expand) is most appropriate /// and executes it /// </summary> /// <param name="targetNode">The node view model that is being collapsed or expanded</param> private void CollapseOrExpandNode(NodeViewModelBase targetNode) { //TODO: check collection to determine if this node has already been collapsed CollapseNode(targetNode); }
/// <summary> /// Creates a new instance of the NodePositionAnimator class using /// the provided target node and target position /// </summary> /// <param name="_targetNode">The node being animated</param> /// <param name="_targetPosition">The position the node should be /// moved to</param> /// <param name="_duration">The duration of the animation</param> public NodePositionAnimator(NodeViewModelBase _targetNode, Point _targetPosition, int _duration) : this(_targetNode, _targetPosition, _duration, 0) { }
/// <summary> /// Creates a new instance of the NodePositionAnimator class using /// the provided target node and target position /// </summary> /// <param name="_targetNode">The node being animated</param> /// <param name="_targetPosition">The position the node should be /// moved to</param> /// <param name="_duration">The duration of the animation</param> /// <param name="_frameRate">The frame rate of the animation</param> public NodePositionAnimator(NodeViewModelBase _targetNode, Point _targetPosition, int _duration, int _frameRate) : base(_duration, _frameRate) { this.targetNode = _targetNode; this.targetPosition = _targetPosition; }
/// <summary> /// Removes the scale visualization from the target node /// </summary> /// <param name="target">The node whose visualization is to be removed</param> public void ClearVisualization(NodeViewModelBase target) { target.Scale = 1.0; }
public NavigationObject(NodeViewModelBase nodeViewModel, Page page) { ViewModel = nodeViewModel; NavigationService = page.NavigationService; }
/// <summary> /// Handles the MouseLeftButtonUp event /// </summary> /// <param name="args">The arguments for the event</param> public void NodeMouseLeftButtonUpEventHandler(NodeViewModelMouseEventArgs <MouseButtonEventArgs> args) { // Only allow node manipulation if we are not in pan mode if (!isPanMode) { NodeSelector nodeSelector = GraphManager.Instance.DefaultGraphComponentsInstance.NodeSelector; // Check if we were dragging the node if (isNodeDragging) { // Turn off node dragging isNodeDragging = false; dragTargetNode = null; } else { // Check if any nodes are currently selected if (nodeSelector.AreAnyNodesSelected) { // Check if Control is pressed if ((Keyboard.Modifiers & ModifierKeys.Alt) > 0) { nodeSelector.InvertSelection(); } else { // Check if multiple nodes are selected if (nodeSelector.AreMultipleNodesSelected) { // Check if target node is already selected if (nodeSelector.SelectedNodes.Contains(args.NodeViewModel)) { // Check if Control is pressed if ((Keyboard.Modifiers & ModifierKeys.Control) > 0) { nodeSelector.Unselect(args.NodeViewModel); return; } else { nodeSelector.UnselectAll(); } } else // Target node is not selected { // Check if Control is pressed if ((Keyboard.Modifiers & ModifierKeys.Control) == 0) { nodeSelector.UnselectAll(); } } } else // Only one node is selected { // Check if the target node is already selected if (nodeSelector.SelectedNode.Equals(args.NodeViewModel)) { nodeSelector.Unselect(nodeSelector.SelectedNode); return; } else // Target node is not selected { // Check if Control is pressed if ((Keyboard.Modifiers & ModifierKeys.Control) == 0) { nodeSelector.Unselect(nodeSelector.SelectedNode); } } } } } // Set the SELECTED state of the clicked node nodeSelector.Select(args.NodeViewModel); } } }
/// <summary> /// Adds the specificed node /// </summary> /// <param name="graphComponents">The Graph that data is being imported into</param> /// <param name="creationType">The specified CreationType</param> /// <param name="objNode">Node to be added</param> public static void AddNode(GraphComponents graphComponents, CreationType creationType, NodeMapData objNode) { // Create new node Node uiNode = new Node(objNode.Id); uiNode.SourceMechanism = creationType; // TODO as NodeMapData types expands, this needs to be adjusted NodeTypes uiNodeType = NodeTypes.Simple; if (objNode is IconNodeMapData) { uiNodeType = NodeTypes.Icon; } else if (objNode is TextNodeMapData) { uiNodeType = NodeTypes.Text; } NodeViewModelBase uiNodeVM = NodeViewModelBase.GetNodeViewModel(uiNodeType, uiNode, graphComponents.Scope); // Properties if (uiNodeType == NodeTypes.Icon) { IconNodeMapData objIconNode = (IconNodeMapData)objNode; if (objIconNode.ImageSource != null) { ((IconNodeViewModel)uiNodeVM).ImageSource = objIconNode.ImageSource.ToString(); } } uiNodeVM.Description = objNode.Description; uiNodeVM.DisplayValue = objNode.Label; uiNodeVM.Width = objNode.Dimension.Width; uiNodeVM.Height = objNode.Dimension.Height; uiNodeVM.Position = objNode.Position; uiNodeVM.IsHidden = objNode.IsHidden; SolidColorBrush uiBackgroundColorBrush = new SolidColorBrush(objNode.BackgroundColor); uiNodeVM.BackgroundColor = uiBackgroundColorBrush; SolidColorBrush uiSelectionColorBrush = new SolidColorBrush(objNode.SelectionColor); uiNodeVM.SelectionColor = uiSelectionColorBrush; if (uiNodeVM.Height == 0) { uiNodeVM.Height = 45; } if (uiNodeVM.Width == 0) { uiNodeVM.Width = 45; } // Add the node to the graph graphComponents.AddNodeViewModel(uiNodeVM); // Attributes foreach (KeyValuePair <string, AttributeMapData> objNodeAttrKVP in objNode.Attributes) { Attributes.Attribute uiNodeAttribute = new Attributes.Attribute(objNodeAttrKVP.Value.Name); AttributeValue uiNodeAttributeValue = new AttributeValue(objNodeAttrKVP.Value.Value); uiNode.Attributes.Add(uiNodeAttribute.Name, uiNodeAttributeValue); GlobalAttributeCollection.GetInstance(graphComponents.Scope).Add(uiNodeAttribute, uiNodeAttributeValue); uiNodeAttribute.SemanticType = objNodeAttrKVP.Value.SemanticType; uiNodeAttribute.PreferredSimilarityMeasure = objNodeAttrKVP.Value.SimilarityMeasure; uiNodeAttribute.Visible = !objNodeAttrKVP.Value.IsHidden; } }
/// <summary> /// /// </summary> /// <param name="nodeVM"></param> public void AddNode(NodeViewModelBase nodeVM) { // Check and make sure that the provided node view // model is not already part of this partition node if (nodes.Contains(nodeVM)) { return; } // Add the node to the partition nodes.Add(nodeVM); // Create a temporary edge collection List <Edge> tempEdgeList = new List <Edge>(); // Analyze the collection of existing external connections foreach (Edge edge in externalConnections) { // Check if the current node is this edge's // Target node if (edge.Target.Equals(nodeVM.ParentNode)) { // Add this edge to our temporary edge // collection tempEdgeList.Add(edge); } // Check if the node is this edge's Source node else if (edge.Source.Equals(nodeVM.ParentNode)) { // Since this node is the source node for this // edge, and the node is part of the Partition, // it needs to be removed from the external // incomming connections collection. externalIncommingConnections.Remove(edge); } } // Remove all the edges in the temporary collection // from the external edges collection. foreach (Edge edge in tempEdgeList) { externalConnections.Remove(edge); } tempEdgeList.Clear(); // Analyze the collection of existing external incomming // connections foreach (Edge edge in externalIncommingConnections) { // Check if the current node is this edge's // Source node if (edge.Source.Equals(nodeVM.ParentNode)) { // Add this edge to our temporary edge // collection tempEdgeList.Add(edge); } else if (edge.Target.Equals(nodeVM.ParentNode)) { externalConnections.Remove(edge); } } // Remove all the edges in the temporary collection // from the external incomming edges collection. foreach (Edge edge in tempEdgeList) { externalIncommingConnections.Remove(edge); } //TODO: VALIDATE GRAPHMANAGER CALL RESULTS BEFORE USING VALUES // Loop over all the edges for this nodes foreach (Edge edge in GraphManager.Instance.GetGraphComponents(nodeVM.Scope).Data.Edges(nodeVM.ParentNode)) { NodeViewModelBase targetNodeVM = (GraphManager.Instance.GetGraphComponents(nodeVM.Scope).GetNodeViewModel(edge.Target)) as NodeViewModelBase; NodeViewModelBase sourceNodeVM = (GraphManager.Instance.GetGraphComponents(nodeVM.Scope).GetNodeViewModel(edge.Source)) as NodeViewModelBase; // Check if the current node is this edge's // Target node if (edge.Target != nodeVM.ParentNode && !nodes.Contains(targetNodeVM)) { // If we are here, this edge is an outgoing edge // whose target is not part of this PartionNode externalConnections.Add(edge); } else if (edge.Source != nodeVM.ParentNode && !nodes.Contains(sourceNodeVM)) { // If we are here, this edge is an incomming edge // whose source is not part of this PartitionNode externalIncommingConnections.Add(edge); } } }
/// <summary> /// Creates a new instance of the Berico.SnagL.Events. /// NodeEventArgs class using the provided NodeViewModelBase /// and MouseEventArgs. /// </summary> /// <param name="_nodeVM">The view model class for the node involved /// in the event</param> /// <param name="_sourceID">The ID for graph that this object belongs to</param> public NodeViewModelEventArgs(NodeViewModelBase _nodeVM, string _scope) { NodeViewModel = _nodeVM; Scope = _scope; }
/// <summary> /// Removes the color visualization from the target node /// </summary> /// <param name="target">The node whose visualization is to be removed</param> public void ClearVisualization(NodeViewModelBase target) { target.BackgroundColor = _storedColors.ContainsKey(target.ParentNode.ID) ? new SolidColorBrush(_storedColors[target.ParentNode.ID]) : new SolidColorBrush(Colors.Transparent); }