private void OnNodeUnmarkedForDragging(object sender, EventArgs e) { selectedNode = null; richtextboxInformation.Clear(); this.OnObjectUnmarkedForDragging(sender, e); }
private Set <object> GetSetOfAffectedObjs(IViewerObject draggableObj) { Set <object> ret = new Set <object>(); ret.Insert(draggableObj); IViewerNode node = draggableObj as IViewerNode; if (node != null) { foreach (IViewerEdge edge in Edges(node)) { ret.Insert(edge); } } else { IViewerEdge edge = draggableObj as IViewerEdge; if (edge != null) { ret += GetSetOfAffectedObjs(edge.Source); ret += GetSetOfAffectedObjs(edge.Target); } else { IViewerObject label = draggableObj as IViewerObject; if (label != null) { ret.Insert(draggableObj); } } } return(ret); }
/// <summary> /// Draw new shape /// </summary> /// <param name="centerLocation"></param> /// <param name="id"></param> /// <returns></returns> private Microsoft.Msagl.Drawing.Node Draw(Microsoft.Msagl.Core.Geometry.Point centerLocation) { graph = gViewer.Graph; var id = drawForm.ShapeId; Microsoft.Msagl.Drawing.Node node = graph.AddNode(id); node.Label.Text = drawForm.ShapeLabel; node.Attr.Shape = drawForm.ChosenShape; node.Attr.Color = Color.Black; node.Attr.FillColor = new Microsoft.Msagl.Drawing.Color(drawForm.ChosenColor.A, drawForm.ChosenColor.R, drawForm.ChosenColor.G, drawForm.ChosenColor.B); node.Attr.LineWidth = MinSize / 5; node.Attr.XRadius = node.Attr.YRadius = MinSize / 2; node.Label.FontColor = Color.Black; node.Label.FontSize = drawForm.FontSize; NodeWidth = drawForm.ShapeWidth; NodeHeight = drawForm.ShapeHeight; NodeCenter = centerLocation; node.NodeBoundaryDelegate = new DelegateToSetNodeBoundary(DrawCurve); //if (drawForm.BackgroundNode) //{ // node.NodeBoundaryDelegate = new DelegateToSetNodeBoundary(GetNodeBoundary); // node.DrawNodeDelegate = new DelegateToOverrideNodeRendering(DrawImageNode); // drawForm.BackgroundNode = false; //} IViewerNode dNode = gViewer.CreateIViewerNode(node, centerLocation, null); gViewer.AddNode(dNode, true); // gViewer.ResizeNodeToLabel(node); return(node); }
private void OnNodeMarkedForDragging(object sender, EventArgs e) { selectedNode = sender as IViewerNode; var state = selectedNode.Node.UserData as IState; var info = new StringBuilder(); info.Append(@"{\rtf1\ansi\fs18"); if (state.IsInitial) { info.Append(@" \b Initial State \b0 \fs8\par\par\fs18"); } if (state.EnabledActions.Any()) { info.Append(@" \b Enabled Actions \b0 \par "); var text = string.Join <string>(@" \par ", state.EnabledActions); info.Append(text); } if (state.DisabledActions.Any()) { info.Append(@" \fs8\par\par\fs18 \b Disabled Actions \b0 \par "); var text = string.Join <string>(@" \par ", state.DisabledActions); info.Append(text); } info.Append(@"}"); richtextboxInformation.Rtf = info.ToString(); }
void TheDefaultObjectDecorator(Microsoft.Msagl.Drawing.IViewerObject obj) { this.viewer.InvalidateBeforeTheChange(obj); IViewerNode node = obj as IViewerNode; if (node != null) { Node drawingNode = node.Node; double w = drawingNode.Attr.LineWidth; decoratorRemovalsDict[node] = (delegate() { drawingNode.Attr.LineWidth = (int)w; }); drawingNode.Attr.LineWidth = (int)Math.Max(viewer.LineThicknessForEditing, w * 2); } else { IViewerEdge edge = obj as IViewerEdge; if (edge != null) { Edge drawingEdge = edge.Edge; double w = drawingEdge.Attr.LineWidth; decoratorRemovalsDict[edge] = (delegate() { drawingEdge.Attr.LineWidth = (int)w; }); drawingEdge.Attr.LineWidth = (int)Math.Max(viewer.LineThicknessForEditing, w * 2); } } this.viewer.Invalidate(obj); }
void EnlargeNode(IViewerNode node) { var geomNode = node.DrawingObject.GeometryObject as AglNode; geomNode.BoundaryCurve = geomNode.BoundaryCurve.OffsetCurve(geomNode.BoundingBox.Width / 2, new Point(1, 0)); LayoutHelpers.IncrementalLayout(gViewer.Graph.GeometryGraph, geomNode, gViewer.Graph.LayoutAlgorithmSettings as SugiyamaLayoutSettings); }
private IEnumerable <IViewerNode> Nodes() { foreach (IViewerObject o in viewer.Entities) { IViewerNode n = o as IViewerNode; if (n != null) { yield return(n); } } }
public void AddNode(IViewerNode node, bool registerForUndo) { if (drawingGraph == null) { throw new InvalidOperationException(); // adding a node when the graph does not exist } var vNode = (KosmographViewerNode)node; drawingGraph.AddNode(vNode.Node); drawingGraph.GeometryGraph.Nodes.Add(vNode.Node.GeometryNode); layoutEditor.AttachLayoutChangeEvent(vNode); GraphCanvas.Children.Add(vNode.NodeLabel); layoutEditor.CleanObstacles(); }
void viewer_MouseUp(object sender, MsaglMouseEventArgs args) { if (viewer.LayoutIsEditable) { bool click = !MouseDownPointAndMouseUpPointsAreFarEnough(args); if (click && LeftMouseButtonWasPressed) { if (viewer.ObjectUnderMouseCursor is IViewerObject) { AnalyzeLeftMouseButtonClick(); args.Handled = true; } else { UnselectEverything(); } } else if (Dragging) { viewer.OnDragEnd(AffectedObjsEnum()); args.Handled = true; this.geomGraphEditor.OnDragEnd(viewer.ScreenToSource(args) - this.mouseDownSourcePoint); } else if (LeftMouseButtonWasPressed) { if (ToggleEntityPredicate(viewer.ModifierKeys, PressedMouseButtons, true) && (viewer.ModifierKeys & ModifierKeys.Shift) != ModifierKeys.Shift) { SelectEntitiesForDraggingWithRectangle(args); } // else SpreadGroupForMDS(args); } else if (MiddleMouseButtonWasPressed) { viewer.StopDrawingRubberLine(); IViewerNode targetNode = viewer.ObjectUnderMouseCursor as IViewerNode; if (targetNode != null) { IViewerEdge edge = viewer.CreateEdge(SourceOfInsertedEdge.DrawingObject as Node, targetNode.DrawingObject as Node); this.viewer.AddEdge(edge, true); } } } Dragging = false; PolylineVertex = null; ActiveDraggedObject = null; affectedObjects = null; LeftMouseButtonWasPressed = MiddleMouseButtonWasPressed = false; }
IEnumerable <IViewerEdge> Edges(IViewerNode node) { foreach (IViewerEdge edge in node.SelfEdges) { yield return(edge); } foreach (IViewerEdge edge in node.OutEdges) { yield return(edge); } foreach (IViewerEdge edge in node.InEdges) { yield return(edge); } }
private void updateAnalysisStart() { dte.StatusBar.Text = string.Format("Generating contractor graph for {0}", typeFullName); dte.StatusBar.Animate(true, vsStatusAnimation.vsStatusAnimationGeneral); this.graph = new Graph(); this.graph.Attr.OptimizeLabelPositions = true; this.graph.Attr.LayerDirection = LayerDirection.LR; graphViewer.Graph = this.graph; progressbar.Visible = true; selectedNode = null; richtextboxInformation.Clear(); cmdStopAnalysis.Enabled = true; }
public void RemoveNode(IViewerNode node, bool registerForUndo) { lock (this.syncRoot) { RemoveEdges(node.Node.OutEdges); RemoveEdges(node.Node.InEdges); RemoveEdges(node.Node.SelfEdges); drawingObjectsToFrameworkElements.Remove(node.Node); drawingObjectsToIViewerObjects.Remove(node.Node); var vnode = (KosmographViewerNode)node; vnode.DetachFromCanvas(GraphCanvas); drawingGraph.RemoveNode(node.Node); drawingGraph.GeometryGraph.Nodes.Remove(node.Node.GeometryNode); layoutEditor.DetachNode(node); layoutEditor.CleanObstacles(); } }
private Node InsertNode(Microsoft.Msagl.Core.Geometry.Point center, string id) { var node = new Node(id); node.UserData = node.Id = node.Label.Text = id; node.Attr.FillColor = MSAGLColor.Transparent; node.Label.FontColor = MSAGLColor.Black; node.Label.FontSize = this.defaultNodeFontSize; node.Attr.Shape = Microsoft.Msagl.Drawing.Shape.Circle; IViewerNode dNode = this.viewer.CreateIViewerNode(node, center, null); this.viewer.AddNode(dNode, true); this.viewer.ResizeNodeToLabel(node); this.viewer.LayoutEditor.AttachLayoutChangeEvent(dNode); this.viewer.Invalidate(dNode); this.viewer.Refresh(); return(node); }
/// <summary> /// Inserts a new node at the selected point, with standard attributes, and displays it. /// </summary> /// <param name="center">The location of the node on the graph</param> /// <param name="nte">The NodeTypeEntry structure containing the initial aspect of the node</param> /// <param name="id">The id for the node</param> /// <returns>The new node</returns> internal virtual DrawingNode InsertNode(Point center, NodeTypeEntry nte, string id) { var node = new DrawingNode(id); node.Label.Text = nte.DefaultLabel; node.Attr.FillColor = nte.FillColor; node.Label.FontColor = nte.FontColor; node.Label.FontSize = nte.FontSize; node.Attr.Shape = nte.Shape; string s = nte.UserData; node.UserData = s; IViewerNode dNode = gViewer.CreateIViewerNode(node, center, null); gViewer.AddNode(dNode, true); return(node); }
private void Select(MessageCollection <MainWindowCreated, SelectedModelObjectChanged> set) { if (set?.Message2.SelectedObject == null) { return; } IViewerNode node = set.Message1.Window.GraphViewer.Entities .OfType <IViewerNode>() .FirstOrDefault(e => e.DrawingObject.UserData == set.Message2.SelectedObject); if (node == null) { return; } OnMessage(new ViewModelChangeApplying( () => { set.Message1.Window.GraphViewer.NodeToCenterWithScale(node.Node, 1); }, set)); }
internal virtual Node InsertNode(MSAGLPoint center, string id) { var node = new Node(id); node.Label.Text = "default"; node.Attr.FillColor = MSAGLColor.Black; node.Label.FontColor = MSAGLColor.White; node.Label.FontSize = 10; node.Attr.Shape = Shape.Circle; string s = "User Data object"; node.UserData = s; IViewerNode dNode = gViewer.CreateIViewerNode(node, center, null); gViewer.AddNode(dNode, true); gViewer.Invalidate(dNode); //NodeInsertedByUser(this, new NodeInsertedByUserEventArgs(node)); return(node); }
private void viewer_MouseDown(object sender, MsaglMouseEventArgs e) { if (e.RightButtonIsPressed) { IViewerObject ob = gv.ObjectUnderMouseCursor; if (ob == null) { Microsoft.Msagl.Core.Geometry.Point p = gv.ScreenToSource(e.X, e.Y); Node n = new Node(this.FindNewId()); IViewerNode iwn = gv.CreateIViewerNode(n, p, true); gv.AddNode(iwn, true); gv.ResizeNodeToLabel(n); } else if (ob is IViewerNode) { IViewerNode existingNode = ob as IViewerNode; gv.RemoveNode(existingNode, true); } } }
internal virtual Node InsertNode(MSAGLPoint center, object simulationObj) { Node node = null; switch (simulationObj) { case Conveyor <ProductBase> con: node = new Node(con.Name) { UserData = con }; break; case Machine <ProductBase> frth: node = new Node(frth.Name) { UserData = frth }; break; case MintBoxProduct mint: case RedBoxProduct red: case OrangeBoxProduct orange: default: return(null); } node.Attr.Shape = Shape.DrawFromGeometry; node.DrawNodeDelegate = new DelegateToOverrideNodeRendering(DrawNode); node.NodeBoundaryDelegate = new DelegateToSetNodeBoundary(GetNodeBoundary); node.LabelText = "0"; IViewerNode dNode = gViewer.CreateIViewerNode(node, center, null); gViewer.AddNode(dNode, true); Invalidate(); return(node); }
void viewer_MouseDown(object sender, MsaglMouseEventArgs e) { if (viewer.LayoutIsEditable) { PressedMouseButtons = GetPressedButtons(e); mouseDownSourcePoint = viewer.ScreenToSource(e); mouseDownScreenPoint = new Point(e.X, e.Y); if (e.LeftButtonIsPressed) { LeftMouseButtonWasPressed = true; if (!(viewer.ObjectUnderMouseCursor is IViewerEdge)) { ActiveDraggedObject = viewer.ObjectUnderMouseCursor; } if (ActiveDraggedObject != null) { e.Handled = true; } if (this.SelectedEdge != null) { this.CheckIfDraggingPolylineVertex(e); } } else if (e.RightButtonIsPressed) { if (this.SelectedEdge != null) { ProcessRightClickOnSelectedEdge(e); } } else if (e.MiddleButtonIsPressed && viewer.ObjectUnderMouseCursor is IViewerNode) { SourceOfInsertedEdge = viewer.ObjectUnderMouseCursor as IViewerNode; UnselectEverything(); MiddleMouseButtonWasPressed = true; viewer.StartDrawingRubberLine(e); } } }
internal void CreateNode() { IsNodeSelected = false; if (Model == null) { return; } if (drawingNode != null) { IsNodeSelected = drawingNode.Attr.Color == Styles.SELECTED_NODE_LINE_COLOR.ToMsAgl(); DeleteNode(); } GeometryPoint center = new GeometryPoint(Xcoordinate ?? 0.0, Ycoordinate ?? 0.0); NodeAttr attr = CreateNodeAttr(Label, IsNodeSelected); if (Model.Graph != null) { drawingNode = Model.Graph.AddNode(Label); drawingNode.Attr = attr; drawingNode.Label.Text = Entity.Label; drawingNode.UserData = this; CreateNodeGeometry(drawingNode, Model.Graph, Model.GeometryGraph, center, ConnectionToGraph.Connected); } else { drawingNode = new DrawingNode(Label); drawingNode.Attr = attr; drawingNode.Label.Text = Entity.Label; drawingNode.UserData = this; IViewerNode viewerNode = Model.GraphEditor.Viewer.CreateIViewerNode(drawingNode, center, null); Model.GraphEditor.Viewer.AddNode(viewerNode, false); Model.GraphEditor.Viewer.Invalidate(viewerNode); } Model.AutoResize(); }
/// <summary> /// /// </summary> /// <param name="node"></param> public void RegisterNodeAdditionForUndo(IViewerNode node) { AddNodeUndoAction undoAction = new AddNodeUndoAction(this.graph, this.viewer, node); geomGraphEditor.InsertToListAndFixTheBox(undoAction); }
internal RemoveNodeUndoAction(IViewer viewer, IViewerNode node) : base(viewer.ViewerGraph.DrawingGraph.GeometryGraph) { this.viewer = viewer; this.removedNode = node; this.GraphBoundingBoxAfter = viewer.ViewerGraph.DrawingGraph.BoundingBox; //do not change the bounding box }
public void RemoveNode(IViewerNode node, bool registerForUndo) { throw new NotImplementedException(); }
public void AddNode(IViewerNode node, bool registerForUndo) { if (_drawingGraph == null) throw new InvalidOperationException(); // adding a node when the graph does not exist var vNode = (GraphmapsNode) node; _drawingGraph.AddNode(vNode.Node); _drawingGraph.GeometryGraph.Nodes.Add(vNode.Node.GeometryNode); layoutEditor.AttachLayoutChangeEvent(vNode); GraphCanvasChildrenAdd(vNode.FrameworkElementOfNodeForLabel); layoutEditor.CleanObstacles(); }
public void AddCluster(IViewerNode dCluster, bool registerForUndo) { DCluster cluster = dCluster as DCluster; Cluster geometryCluster = cluster.GeometryCluster; Subgraph drawingCluster = cluster.DrawingCluster; // Add the node to my node map, to the drawing graph, and to the geometry graph. NodeMap[drawingCluster.Id] = cluster; if (cluster.ParentObject == this) Graph.RootSubgraph = drawingCluster; else (cluster.ParentObject as DCluster).DrawingCluster.AddSubgraph(drawingCluster); if (cluster.ParentObject == this) Graph.GeometryGraph.RootCluster = geometryCluster; else (cluster.ParentObject as DCluster).GeometryCluster.AddChild(geometryCluster); }
public void AddNode(IViewerNode node, bool registerForUndo) { DNode dNode = node as DNode; DrawingNode drawingNode = dNode.DrawingNode; if (registerForUndo && NodeInsertingByUser != null) NodeInsertingByUser(dNode, EventArgs.Empty); // Add the node to my node map, to the drawing graph, and to the geometry graph. NodeMap[drawingNode.Id] = dNode; Graph.AddNode(drawingNode); Graph.GeometryGraph.Nodes.Add(drawingNode.GeometryNode); // The node may come with edges that also need to be added to the internal edge list, and to the other nodes. foreach (DEdge e in dNode.OutEdges) { e.Target._InEdges.Add(e); e.Target.DrawingNode.AddInEdge(e.DrawingEdge); e.Target.DrawingNode.GeometryNode.AddInEdge(e.DrawingEdge.GeometryEdge); } foreach (DEdge e in dNode.InEdges) { e.Source._OutEdges.Add(e); e.Source.DrawingNode.AddOutEdge(e.DrawingEdge); e.Source.DrawingNode.GeometryNode.AddOutEdge(e.DrawingEdge.GeometryEdge); } // The edges also need to be added to the drawing graph, and to the geometry graph. foreach (DEdge e in dNode.Edges) { Edges.Add(e); Graph.AddPrecalculatedEdge(e.DrawingEdge); Graph.GeometryGraph.Edges.Add(e.DrawingEdge.GeometryEdge); } if (registerForUndo && NodeInsertedByUser != null) NodeInsertedByUser(dNode, EventArgs.Empty); if (!NodeMap.ContainsValue(dNode)) return; DrawingLayoutEditor.AttachLayoutChangeEvent(dNode); // Display the node and edges. dNode.MakeVisual(); if (!MainCanvas.Children.Contains(dNode)) MainCanvas.Children.Add(dNode); foreach (DEdge e in dNode.Edges) { e.MakeVisual(); if (!MainCanvas.Children.Contains(e)) MainCanvas.Children.Add(e); } //BuildBBHierarchy(); FirePropertyChanged("HasContent"); }
/// <summary> /// makes the node unreachable /// </summary> /// <param name="node"></param> void RemoveNodeFromAllGraphs(IViewerNode node) { var drawingNode = node.DrawingObject as DrawingNode; DGraph.RemoveDNode(drawingNode.Id); Graph.NodeMap.Remove(drawingNode.Id); if (drawingNode.GeometryNode != null) { Graph.GeometryGraph.Nodes.Remove(drawingNode.GeometryNode); } foreach (DEdge de in Edges(node as DNode)) { DGraph.Edges.Remove(de); Graph.RemoveEdge(de.DrawingEdge); Graph.GeometryGraph.Edges.Remove(de.DrawingEdge.GeometryEdge); } foreach (DEdge de in node.OutEdges) { de.Target.inEdges.Remove(de); de.Target.DrawingNode.RemoveInEdge(de.DrawingEdge); de.Target.DrawingNode.GeometryNode.RemoveInEdge(de.DrawingEdge.GeometryEdge); } foreach (DEdge de in node.InEdges) { de.Source.outEdges.Remove(de); de.Source.DrawingNode.RemoveOutEdge(de.DrawingEdge); de.Source.DrawingNode.GeometryNode.RemoveOutEdge(de.DrawingEdge.GeometryEdge); } }
internal RemoveNodeUndoAction(IViewer viewer, IViewerNode node) :base(viewer.ViewerGraph.DrawingGraph.GeometryGraph){ this.viewer = viewer; this.removedNode = node; this.GraphBoundingBoxAfter = viewer.ViewerGraph.DrawingGraph.BoundingBox; //do not change the bounding box }
/// <summary> /// /// </summary> /// <param name="node"></param> public void RegisterNodeAdditionForUndo(IViewerNode node) { var undoAction = new AddNodeUndoAction(graph, viewer, node); geomGraphEditor.InsertToListAndSetTheBoxBefore(undoAction); }
/// <summary> /// adding a node to the graph with the undo support /// The node boundary curve should have (0,0) as its internal point. /// The curve will be moved the the node center. /// </summary> /// <param name="node"></param> /// <param name="registerForUndo"></param> public void AddNode(IViewerNode node, bool registerForUndo) { var dNode = node as DNode; DrawingNode drawingNode = dNode.DrawingNode; var viewer = this as IViewer; DGraph.AddNode(dNode); Graph.AddNode(drawingNode); Graph.GeometryGraph.Nodes.Add(drawingNode.GeometryNode); foreach (DEdge e in dNode.outEdges) { e.Target.inEdges.Add(e); e.Target.DrawingNode.AddInEdge(e.DrawingEdge); e.Target.DrawingNode.GeometryNode.AddInEdge(e.DrawingEdge.GeometryEdge); } foreach (DEdge e in dNode.inEdges) { e.Source.outEdges.Add(e); e.Source.DrawingNode.AddOutEdge(e.DrawingEdge); e.Source.DrawingNode.GeometryNode.AddOutEdge(e.DrawingEdge.GeometryEdge); } viewer.Invalidate(node); foreach (DEdge e in Edges(dNode)) { DGraph.Edges.Add(e); Graph.AddPrecalculatedEdge(e.DrawingEdge); Graph.GeometryGraph.Edges.Add(e.DrawingEdge.GeometryEdge); viewer.Invalidate(e); } if (registerForUndo) { layoutEditor.RegisterNodeAdditionForUndo(node); Core.Geometry.Rectangle bounds = Graph.GeometryGraph.BoundingBox; bounds.Add(drawingNode.BoundingBox.LeftTop); bounds.Add(drawingNode.BoundingBox.RightBottom); Graph.GeometryGraph.BoundingBox = bounds; layoutEditor.CurrentUndoAction.GraphBoundingBoxAfter = Graph.BoundingBox; } BbNode = null; viewer.Invalidate(); }
bool NeedToCreateBoundaryPort(Point mousePoint, IViewerNode node, out double portParameter) { var drawingNode = node.DrawingObject as Node; ICurve curve = drawingNode.GeometryNode.BoundaryCurve; portParameter = curve.ClosestParameter(mousePoint); Point pointOnCurve = curve[portParameter]; double length = (mousePoint - pointOnCurve).Length; if (length <= viewer.UnderlyingPolylineCircleRadius*2 + drawingNode.Attr.LineWidth/2) { TryToSnapToTheSegmentEnd(ref portParameter, curve, pointOnCurve); return true; } return false; }
public void RemoveNode(IViewerNode node, bool registerForUndo) { var dNode = node as DNode; var drawingNode = dNode.DrawingNode; if (registerForUndo) LayoutEditor.RegisterNodeForRemoval(node); NodeMap.Remove(drawingNode.Id); Graph.NodeMap.Remove(drawingNode.Id); Graph.GeometryGraph.Nodes.Remove(drawingNode.GeometryNode); foreach (DEdge de in dNode.Edges) { MainCanvas.Children.Remove(de); if (de.Label != null) MainCanvas.Children.Remove(de.Label); Edges.Remove(de); Graph.GeometryGraph.Edges.Remove(de.DrawingEdge.GeometryEdge); } foreach (DEdge de in node.OutEdges) { de.Target._InEdges.Remove(de); de.Target.DrawingNode.RemoveInEdge(de.DrawingEdge); de.Target.DrawingNode.GeometryNode.RemoveInEdge(de.DrawingEdge.GeometryEdge); } foreach (DEdge de in node.InEdges) { de.Source._OutEdges.Remove(de); de.Source.DrawingNode.RemoveOutEdge(de.DrawingEdge); de.Source.DrawingNode.GeometryNode.RemoveOutEdge(de.DrawingEdge.GeometryEdge); } MainCanvas.Children.Remove(dNode); if (dNode.Label != null) MainCanvas.Children.Remove(dNode.Label); BuildBBHierarchy(); }
void RelayoutOnIsCollapsedChanged(IViewerNode iCluster) { geomGraphEditor.PrepareForClusterCollapseChange(new[]{iCluster}); var cluster = (Cluster)iCluster.DrawingObject.GeometryObject; if (cluster.IsCollapsed) CollapseCluster(cluster); else ExpandCluster(cluster); //LayoutAlgorithmSettings.ShowGraph(viewer.Graph.GeometryGraph); foreach(IViewerObject o in geomGraphEditor.CurrentUndoAction.AffectedObjects) viewer.Invalidate(o); }
/// <summary> /// removes a node from the graph with the undo support /// </summary> /// <param name="node"></param> /// <param name="registerForUndo"></param> public void RemoveNode(IViewerNode node, bool registerForUndo) { if (registerForUndo) layoutEditor.RegisterNodeForRemoval(node); RemoveNodeFromAllGraphs(node); BbNode = null; DGraph.BbNode = null; DGraph.BuildBBHierarchy(); Invalidate(); }
static IEnumerable<IViewerEdge> Edges(IViewerNode node) { foreach (IViewerEdge edge in node.SelfEdges) yield return edge; foreach (IViewerEdge edge in node.OutEdges) yield return edge; foreach (IViewerEdge edge in node.InEdges) yield return edge; }
public void RemoveNode(IViewerNode node, bool registerForUndo) { var dNode = node as DNode; var drawingNode = dNode.DrawingNode; if (registerForUndo) DrawingLayoutEditor.RegisterNodeForRemoval(node); NodeMap.Remove(drawingNode.Id); Graph.NodeMap.Remove(drawingNode.Id); Graph.GeometryGraph.Nodes.Remove(drawingNode.GeometryNode); foreach (DEdge de in dNode.Edges) { MainCanvas.Children.Remove(de); if (de.Label != null) MainCanvas.Children.Remove(de.Label); Edges.Remove(de); Graph.RemoveEdge(de.DrawingEdge); Graph.GeometryGraph.Edges.Remove(de.DrawingEdge.GeometryEdge); } foreach (DEdge de in node.OutEdges) { de.Target._InEdges.Remove(de); de.Target.DrawingNode.RemoveInEdge(de.DrawingEdge); de.Target.DrawingNode.GeometryNode.RemoveInEdge(de.DrawingEdge.GeometryEdge); } foreach (DEdge de in node.InEdges) { de.Source._OutEdges.Remove(de); de.Source.DrawingNode.RemoveOutEdge(de.DrawingEdge); de.Source.DrawingNode.GeometryNode.RemoveOutEdge(de.DrawingEdge.GeometryEdge); } MainCanvas.Children.Remove(dNode); if (dNode.Label != null) MainCanvas.Children.Remove(dNode.Label); if (registerForUndo && NodeDeletedByUser != null) NodeDeletedByUser(dNode, EventArgs.Empty); FirePropertyChanged("HasContent"); }
bool TrySetNodePort(MsaglMouseEventArgs e, ref IViewerNode node, ref Port port, out Polyline loosePolyline) { Debug.Assert(InsertingEdge); Point mousePosition = viewer.ScreenToSource(e); loosePolyline = null; if (Graph != null) { if (DraggingStraightLine()) { node= SetPortWhenDraggingStraightLine(ref port, ref mousePosition); } else { if (InteractiveEdgeRouter == null) PrepareForEdgeDragging(); loosePolyline = InteractiveEdgeRouter.GetHitLoosePolyline(viewer.ScreenToSource(e)); if (loosePolyline != null) SetPortUnderLoosePolyline(mousePosition, loosePolyline, ref node, ref port); else { node = null; port = null; } } } return port != null; }
internal AddNodeUndoAction(Graph graph, IViewer viewer, IViewerNode node) : base(graph.GeometryGraph) { this.viewer = viewer; this.addedNode = node; }
void SetPortUnderLoosePolyline(Point mousePosition, Polyline loosePoly, ref IViewerNode node, ref Port port) { double dist = double.PositiveInfinity; double par = 0; foreach (var viewerNode in GetViewerNodesInsideOfLooseObstacle(loosePoly)) { var curve = ((Node)viewerNode.DrawingObject).GeometryNode.BoundaryCurve; if (PointIsInside(mousePosition, curve)) { node = viewerNode; SetPortForMousePositionInsideOfNode(mousePosition, node, ref port); return; } double p = curve.ClosestParameter(mousePosition); double d = (curve[p] - mousePosition).Length; if (d < dist) { par = p; dist = d; node = viewerNode; } } port = CreateOrUpdateCurvePort(par, ((Node)node.DrawingObject).GeometryNode, port); }
public void RemoveNode(IViewerNode node, bool registerForUndo) { lock (this) { RemoveEdges(node.Node.OutEdges); RemoveEdges(node.Node.InEdges); RemoveEdges(node.Node.SelfEdges); _drawingObjectsToIViewerObjects.Remove(node.Node); var vnode = (GraphmapsNode) node; vnode.DetouchFromCanvas(_graphCanvas); _drawingGraph.RemoveNode(node.Node); _drawingGraph.GeometryGraph.Nodes.Remove(node.Node.GeometryNode); layoutEditor.DetachNode(node); layoutEditor.CleanObstacles(); } }
void SetPortForMousePositionInsideOfNode(Point mousePosition, IViewerNode node, ref Port port) { GeometryNode geomNode = GeometryNode(node); double t; if (NeedToCreateBoundaryPort(mousePosition, node, out t)) port = CreateOrUpdateCurvePort(t, geomNode, port); else port = CreateFloatingPort(geomNode, ref mousePosition); }
void EnlargeNode(IViewerNode node) { var geomNode = node.DrawingObject.GeometryObject as AglNode; geomNode.BoundaryCurve = geomNode.BoundaryCurve.OffsetCurve(geomNode.BoundingBox.Width / 2, new Point(1, 0)); }
static GeometryNode GeometryNode(IViewerNode node) { GeometryNode geomNode = ((Node) node.DrawingObject).GeometryNode; return geomNode; }
/// <summary> /// /// </summary> /// <param name="node"></param> public void RegisterNodeForRemoval(IViewerNode node) { geomGraphEditor.InsertToListAndSetTheBoxBefore(new RemoveNodeUndoAction(viewer, node)); }
/// <summary> /// /// </summary> /// <param name="node"></param> public void RegisterNodeForRemoval(IViewerNode node) { geomGraphEditor.InsertToListAndFixTheBox(new RemoveNodeUndoAction(this.viewer, node)); }
#pragma warning disable 1591 public void ScaleNodeAroundCenter(IViewerNode viewerNode, double scale) { #pragma warning restore 1591 var nodePosition = viewerNode.Node.BoundingBox.Center; var scaleMatrix = new PlaneTransformation(scale, 0, 0, 0, scale, 0); var translateToOrigin = new PlaneTransformation(1, 0, -nodePosition.X, 0, 1, -nodePosition.Y); var translateToNode = new PlaneTransformation(1, 0, nodePosition.X, 0, 1, nodePosition.Y); var matrix = translateToNode*scaleMatrix*translateToOrigin; viewerNode.Node.GeometryNode.BoundaryCurve=viewerNode.Node.GeometryNode.BoundaryCurve.Transform(matrix); viewer.Invalidate(viewerNode); foreach (var edge in viewerNode.OutEdges.Concat(viewerNode.InEdges).Concat(viewerNode.SelfEdges)) RecoverEdge(edge); }
/// <summary> /// /// </summary> /// <param name="node"></param> public void DetachNode(IViewerNode node) { if (node == null) return; decoratorRemovalsDict.Remove(node); foreach (var edge in Edges(node)) RemoveObjDraggingDecorations(edge); }
internal AddNodeUndoAction(Graph graph, IViewer viewer, IViewerNode node) :base(graph.GeometryGraph){ this.viewer = viewer; this.addedNode = node; }
void EnlargeNode(IViewerNode node) { var geomNode = node.DrawingObject.GeometryObject as AglNode; geomNode.BoundaryCurve = geomNode.BoundaryCurve.OffsetCurve(geomNode.BoundingBox.Width/2, new Point(1, 0)); LayoutHelpers.IncrementalLayout(gViewer.Graph.GeometryGraph, geomNode, gViewer.Graph.LayoutAlgorithmSettings as SugiyamaLayoutSettings); }