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();
}
public void RemoveNode(IViewerNode node, bool registerForUndo)
{
throw new NotImplementedException();
}
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);
}
