/// <summary> /// Disables the simulator by deleting the project information /// </summary> public void DeactivateSimulator() { //If the simulator is running, it stops if (this.state == SimState.Running) { this.stopSimulate = true; this.simulatorThread.Join(); this.state = SimState.Pause; if (this.StateChanged != null) { this.StateChanged(this, new EventArgs()); } } //All simulation layers are hidden from all functions foreach (GraphDiagram function in this.functions.Values) { function.SimulatorLayer.Visible = false; } //The stroke indicator of the current function is removed this.presentFunction.SimulatorLayer.Remove(this.graphTrace); this.presentFunction.SimulatorLayer.UpdateSurface(); //The Simulator status is updated this.state = SimState.Inactive; if (this.StateChanged != null) { this.StateChanged(this, new EventArgs()); } //Project information is deleted to simulate this.mainFunction = null; this.functions.Clear(); this.variables = null; //The simulated model of the Moway is eliminated this.mowayModel = null; }
public void Undo() { //The entered arrow is removed GraphDiagram.DeleteElement(this.diagramLayer, this.diagram, this.graphArrow); //Add the deleted arrow starting with the next element this.graphArrowToDelete.Next.AddPrevious(this.graphArrowToDelete.FinalConnector, this.graphArrowToDelete); foreach (GraphElement prevElement in this.graphArrowToDelete.Previous) { if (prevElement is GraphConditional) { ((GraphConditional)prevElement).AddNext(this.graphArrowToDelete.InitConnector, this.graphArrowToDelete, this.conditionalOut); } else { prevElement.AddNext(this.graphArrowToDelete.InitConnector, this.graphArrowToDelete); } } //The arrow is added to the diagram layer, and to the logical diagram this.diagramLayer.AddElement(this.graphArrowToDelete); this.diagram.AddElement(this.graphArrowToDelete.Element); //The diagram layer is updated this.diagramLayer.UpdateSurface(); //It is indicated that the diagram has changed if (this.DiagramChanged != null) { this.DiagramChanged(this, new EventArgs()); } }
public override void SaveInFile(XmlWriter file, int elementId, Hashtable elementsId) { file.WriteElementString("id", elementId.ToString()); file.WriteElementString("key", this.key); file.WriteStartElement("start"); file.WriteStartElement("position"); file.WriteElementString("x", this.Center.X.ToString()); file.WriteElementString("y", this.Center.Y.ToString()); file.WriteEndElement(); file.WriteStartElement("next"); if (this.Next != null) { int id; if (elementsId.ContainsKey(this.Next)) { id = (int)elementsId[this.Next]; } else { id = GraphDiagram.GetElementId(); elementsId.Add(this.Next, id); } file.WriteElementString("elementId", id.ToString()); file.WriteElementString("connectorId", this.next.IdConnector.ToString()); } file.WriteEndElement(); file.WriteEndElement(); }
/// <summary> /// Undo the operation /// </summary> public void Undo() { //The entered arrow is removed GraphDiagram.DeleteElement(this.diagramLayer, this.diagram, this.graphArrow); //Resets the eliminated arrow in the case that there was if (this.graphArrowToDelete != null) { //Add the deleted arrow starting with the element next this.graphArrowToDelete.Next.AddPrevious(this.graphArrowToDelete.FinalConnector, this.graphArrowToDelete); foreach (GraphElement prevElement in this.graphArrowToDelete.Previous) { prevElement.AddNext(this.graphArrowToDelete.InitConnector, this.graphArrowToDelete); } //The arrow is added to the diagram layer, and to the logical diagram this.diagramLayer.AddElement(this.graphArrowToDelete); this.diagram.AddElement(this.graphArrowToDelete.Element); } //The diagram layer is updated this.diagramLayer.UpdateSurface(); //it is indicated that the diagram has changed if (this.DiagramChanged != null) { this.DiagramChanged(this, new EventArgs()); } }
private void CreateArrowSurface(List <Point> locations) { Point minPoint = GraphDiagram.MinPoint(locations); Point maxPoint = GraphDiagram.MaxPoint(locations); this.Position = new Point(minPoint.X - 5, minPoint.Y - 5); this.segments.Clear(); for (int i = 0; i < locations.Count - 1; i++) { if (i == 0) { this.segments.Add(new StartSegment(this.initConnector, (Point)locations[i], (Point)locations[i + 1], this.Position)); } else if (i < locations.Count - 2) { this.segments.Add(new LineSegment((Point)locations[i], (Point)locations[i + 1], (Point)locations[i - 1], this.Position)); } else { this.segments.Add(new EndSegment(this.next, (Point)locations[i], (Point)locations[i + 1], (Point)locations[i - 1], this.Position)); } } Size size = new Size(maxPoint.X - minPoint.X + 10, maxPoint.Y - minPoint.Y + 10); this.Surface = new Surface(size); //the color of transparency is indicated this.Transparent = true; this.TransparentColor = GraphDiagram.TRASPARENT_COLOR; this.UpdateSurface(); }
public override void SaveInFile(XmlWriter file, int elementId, Hashtable elementsId) { file.WriteElementString("id", elementId.ToString()); file.WriteElementString("key", this.key); file.WriteStartElement("finish"); file.WriteStartElement("position"); file.WriteElementString("x", this.Center.X.ToString()); file.WriteElementString("y", this.Center.Y.ToString()); file.WriteEndElement(); file.WriteStartElement("previous"); foreach (Connector connector in this.previous) { foreach (GraphElement prevElement in connector.Connections) { int id; if (elementsId.ContainsKey(prevElement)) { id = (int)elementsId[prevElement]; } else { id = GraphDiagram.GetElementId(); elementsId.Add(prevElement, id); } file.WriteElementString("elementId", id.ToString()); file.WriteElementString("connectorId", connector.IdConnector.ToString()); } } file.WriteEndElement(); file.WriteEndElement(); }
private List <Point> GetPathPoints(GridPoint[,] gridPoints) { List <Point> locations = new List <Point>(); // you get the arrow path List <GridPoint> path = GraphDiagram.GetGridPath(gridPoints, GraphDiagram.GetNearGridPoint(this.initConnector), this.initConnector.Side, GraphDiagram.GetNearGridPoint(this.next)); locations.Add(this.initConnector.AbsCenter); locations.Add(path[0].Location); //one must always be kept so that the beginning and end of the arrow are created //If the arrow path has more than one element, it seeks to minimize the sectors if (path.Count != 1) { int presentX = locations[1].X; int presentY = locations[1].Y; for (int i = 2; i < path.Count; i++) { if ((path[i].Location.X != presentX) && (path[i].Location.Y != presentY)) { locations.Add(path[i - 1].Location); presentX = path[i - 1].Location.X; presentY = path[i - 1].Location.Y; } } locations.Add(path[path.Count - 1].Location); } locations.Add(this.next.AbsCenter); return(locations); }
/// <summary> /// Insert Operation Builder /// </summary> /// <param name="diagram">Logical diagram del GraphDrawing</param> /// <param name="diagramLayer">GraphDrawing diagram Layer</param> /// <param name="tempLayer">Temporal layer of the GraphDrawing</param> /// <param name="element">Elements to insert</param> public Paste(Diagram diagram, GraphLayer diagramLayer, GraphLayer tempLayer) { this.diagram = diagram; this.diagramLayer = diagramLayer; this.tempLayer = tempLayer; this.tempLayer.Visible = true; this.displacement = new Point(0, 0); //You get the items to paste this.graphElements.AddRange(GraphDiagram.CloneElements(GraphManager.Clipboard.GetElements())); //Add the item to the temporary layer from the Clipboard this.tempLayer.AddElements(this.graphElements); foreach (GraphElement element in this.tempLayer.Elements) { if (!(element is GraphArrow)) { this.displacement = element.Center; break; } } this.tempLayer.UpdateSurface(); //The initial positions of the items to be moved are saved foreach (GraphElement element in this.tempLayer.Elements) { this.initLocations.Add(element, new Point(element.Center.X - this.displacement.X, element.Center.Y - displacement.Y)); } MenuItem miCancel = new MenuItem(PasteMessages.CANCEL); miCancel.Click += new EventHandler(MiCancel_Click); this.menu = new ContextMenu(new MenuItem[] { miCancel }); }
/// <summary> /// This method executes the insert operation after the insertion position has been set /// </summary> public void Do() { if (!GraphDiagram.ValidateCopy(this.selectLayer.Elements)) { MowayMessageBox.Show(CutMessages.CUT_START, CutMessages.CUT, MessageBoxButtons.OK, MessageBoxIcon.Error); this.Cancel(); return; } //The items to be copied are loaded List <GraphElement> elementsToCut = GraphDiagram.GetElementsToCopy(this.selectLayer); List <GraphElement> cloneElements = GraphDiagram.CloneElements(elementsToCut); GraphManager.Clipboard.SetElements(cloneElements); this.elementsToDelete = GraphDiagram.GetElementsToDelete(this.selectLayer); GraphDiagram.DeleteElements(this.diagramLayer, this.diagram, this.elementsToDelete); //Cleans and hides the selection layer this.selectLayer.ClearAndHide(); //Updates the diagram layer this.diagramLayer.UpdateSurface(); if (this.DiagramChanged != null) { this.DiagramChanged(this, new EventArgs()); } if (this.ElementSelectedChanged != null) { this.ElementSelectedChanged(this, new EventArgs()); } //Launch Event of operation completed if (this.OperationFinished != null) { this.OperationFinished(this, new OperationEventArgs(Operation.Cut)); } }
/// <summary> /// Press one of the mouse buttons (at the moment of pressing) /// </summary> /// <param name="e">Mouse Properties</param> public void MouseDown(MouseEventArgs e) { //If the initial connector is empty... if (this.initialConnector == null) { //You look for if you clicked on a different element of an arrow or a finish GraphElement element = GraphDiagram.GetElement(this.diagramLayer, e.Location); if ((element != null) && !((element is GraphArrow) || (element is GraphFinish))) { Connector connector = element.GetConnector(e.Location); if (connector != null) { this.initialConnector = connector; this.initFixed = true; } else { this.initialConnector = this.GetConnector(element, e.Location); } if (this.initialConnector.Parent is GraphConditional) { this.conditionalOut = ((GraphConditional)this.initialConnector.Parent).GetPredefOut(this.initialConnector); } element.DisableConnectors(); element.EnableConnector(this.initialConnector); this.tempGraphArrow.UpdateArrow(this.initialConnector.AbsCenter, e.Location); this.tempLayer.UpdateSurface(); } } }
public void MouseUp(MouseEventArgs e) { if (!this.preCanceled) { this.finalConnector = GraphDiagram.GetConnector(this.tempLayer, e.Location); if (this.finalConnector == null) { this.PreCancel(); throw new OperationException(Operation.InsertArrow, "Change to Nop Operation"); } else if (this.finalConnector == this.initialConnector) { this.finalConnector = null; dragMode = false; } else { this.Do(); throw new OperationException(Operation.InsertArrow, "Send a MouseMoveEvent"); } } else { this.Cancel(); } }
/// <summary> /// Press one of the mouse buttons (at the moment of release) /// </summary> /// <param name="e">Mouse Properties</param> public void MouseUp(MouseEventArgs e) { if (this.initialConnector != null) { GraphElement element = GraphDiagram.GetElement(this.diagramLayer, e.Location); if ((element != null) && !(element is GraphArrow)) { if (this.initialConnector.Parent == element) { if (this.initFixed) { Connector connector = element.GetConnector(e.Location); if (this.initialConnector == connector) { this.dragMode = false; } else if (connector != null) { this.finalConnector = this.presentConnector; this.Do(); } } else { this.dragMode = false; } } else if (!(element is GraphStart)) { this.finalConnector = this.presentConnector; this.Do(); } } } }
/// <summary> /// Updates the stroke flag in the simulation graphical layer (updates the function and current element if they were different from the function parameters) /// </summary> /// <param name="function"></param> /// <param name="element"></param> /// <returns></returns> private void UpdateTrace(GraphDiagram function, GraphElement element) { //The item to be noted is updated if it is not the same as the current if (this.presentElement != element) { this.presentElement = element; } //The stroke is placed on the current element if ((this.presentElement is GraphStart) || (this.presentElement is GraphFinish)) { this.graphTrace.Position = new Point(this.presentElement.Position.X - 12, this.presentElement.Position.Y + 3); } else if (this.presentElement is GraphModule) { this.graphTrace.Position = new Point(this.presentElement.Position.X - 14, this.presentElement.Position.Y + 9); } else if (this.presentElement is GraphConditional) { this.graphTrace.Position = new Point(this.presentElement.Position.X - 6, this.presentElement.Position.Y + 19); } else { throw new SimulatorException("Ningún otro elemento puede ser apuntado por la flecha"); } //Update the simulation layer of the current function if (this.presentFunction != function) { this.presentFunction.SimulatorLayer.Remove(this.graphTrace); this.presentFunction.SimulatorLayer.UpdateSurface(); this.presentFunction = function; this.presentFunction.SimulatorLayer.Add(this.graphTrace); } this.presentFunction.SimulatorLayer.UpdateSurface(); }
/// <summary> /// Completely reset the simulator /// </summary> private void ResetSimulator() { //indicated that a reset is not necessary this.requireReset = false; //The simulator indicator is updated with new references this.UpdateTrace(this.mainFunction, this.mainFunction.StartElement); this.tempFunction = presentFunction; //The function returns stack is cleaned this.functionCallstack.Clear(); //Model records are reset foreach (Variable variable in this.variables) { this.mowayModel.GetRegister(variable.Name).Value = variable.InitValue; } //Model is reset this.mowayModel.ResetSimulation(); //The simulated state is updated if it is different from Pause if (this.state != SimState.Pause) { this.state = SimState.Pause; if (this.StateChanged != null) { this.StateChanged(this, new EventArgs()); } } }
public EditAreaSizeForm(GraphDiagram graphDiagram) { InitializeComponent(); this.graphDiagram = graphDiagram; switch (this.graphDiagram.AreaFormat) { case AreaFormat.A3_Vertical: this.cbSize.SelectedIndex = 0; this.rbVertical.Checked = true; break; case AreaFormat.A3_Horizontal: this.cbSize.SelectedIndex = 0; this.rbHorizontal.Checked = true; break; case AreaFormat.A4_Vertical: this.cbSize.SelectedIndex = 1; this.rbVertical.Checked = true; break; case AreaFormat.A4_Horizontal: this.cbSize.SelectedIndex = 1; this.rbHorizontal.Checked = true; break; } }
public GraphPdfDocument(string projectName, string projectOwner, GraphDiagram function) : base() { this.projectName = projectName; this.projectOwner = projectOwner; this.function = function; }
public GraphPrintDocument(string projectName, string projectOwner, GraphDiagram presentFunction, List <GraphDiagram> functions) { this.projectName = projectName; this.projectOwner = projectOwner; this.presentFunction = presentFunction; this.functions = functions; this.PrintPage += new PrintPageEventHandler(PrinterDocument_PrintPage); }
/// <summary> /// Removes a function /// </summary> /// <param name="function">function to delete</param> public void RemoveFunction(GraphDiagram function) { if (!this.functions.ContainsValue(function)) { throw new SimulatorException("Simulator don't constain this function"); } this.functions.Remove(function.Name); this.requireValidate = true; }
public void MouseUp(MouseEventArgs e) { //Only checks for left mouse button if (e.Button == MouseButtons.Left) { //Looking for the affected element GraphElement element = GraphDiagram.GetElement(this.diagramLayer, e.Location); //If there is none, it is changed to Operation Nop if (element == null) { //The context of the Select operation is cleaned this.ClearOperationContext(); throw new OperationException(Operation.Select, "Change to Nop Operation"); } else { //If you are pressing the CONTROL key, a multiple selection is being made if (Control.ModifierKeys == Keys.Control) { //If the item is selected, it is deselected if (element.Selected) { DeselectElement(element); //If there is no item selected, it changes to the NOP operation if (this.selectLayer.Elements.Count == 0) { //The context of the Select operation is cleaned this.ClearOperationContext(); throw new OperationException(Operation.Select, "Change to Nop Operation"); } } //without, it selects else { this.SelectElement(element); } this.selectLayer.UpdateSurface(); if (this.ElementSelectedChanged != null) { this.ElementSelectedChanged(this, new EventArgs()); } } //If the item is not selected, the others are deselected and the current is selected else if (!element.Selected) { this.DeselectAll(); this.SelectElement(element); //The temporary layer is updated this.selectLayer.UpdateSurface(); if (this.ElementSelectedChanged != null) { this.ElementSelectedChanged(this, new EventArgs()); } } } } }
/// <summary> /// Add a new feature /// </summary> /// <param name="function">New Function</param> public void AddFunction(GraphDiagram function) { if (this.functions.ContainsValue(function)) { throw new SimulatorException("Simulator already constain this function"); } function.SimulatorLayer.Visible = true; this.functions.Add(function.Name, function); this.requireValidate = true; }
public void Do() { //If you are modifying the next of an item... if (this.nextEnable) { if (this.presentConnector.Parent is GraphConditional) { this.conditionalOut = ((GraphConditional)this.presentConnector.Parent).GetPredefOut(this.presentConnector); if ((conditionalOut == ConditionalOut.True) && (((GraphConditional)this.presentConnector.Parent).NextTrue != null)) { if (DialogResult.Yes != MowayMessageBox.Show(InsertArrowMessages.REPLACE_TRUE + "\r\n" + InsertArrowMessages.CONTINUE, InsertArrowMessages.INSERT_ARROW, MessageBoxButtons.YesNo, MessageBoxIcon.Warning)) { this.Cancel(); return; } else if ((conditionalOut == ConditionalOut.False) && (((GraphConditional)this.presentConnector.Parent).NextFalse != null)) { if (DialogResult.Yes != MowayMessageBox.Show(InsertArrowMessages.REPLACE_FALSE + "\r\n" + InsertArrowMessages.CONTINUE, InsertArrowMessages.INSERT_ARROW, MessageBoxButtons.YesNo, MessageBoxIcon.Warning)) { this.Cancel(); return; } } } } GraphDiagram.DeleteElement(diagramLayer, diagram, this.graphArrowToDelete); this.graphArrow = GraphDiagram.InsertArrow(this.diagram, this.diagramLayer, this.presentConnector, this.fixedConnector, this.conditionalOut, this.gridStatus); } else //If you are modifying an item's prev { if (fixedConnector.Parent is GraphConditional) { if (((GraphConditional)fixedConnector.Parent).NextTrue == this.graphArrowToDelete) { this.conditionalOut = ConditionalOut.True; } else { this.conditionalOut = ConditionalOut.False; } } GraphDiagram.DeleteElement(this.diagramLayer, this.diagram, this.graphArrowToDelete); this.graphArrow = GraphDiagram.InsertArrow(this.diagram, this.diagramLayer, this.fixedConnector, this.presentConnector, this.conditionalOut, this.gridStatus); } foreach (GraphElement element in this.tempLayer.Elements) { element.DisableConnectors(); } this.tempLayer.ClearAndHide(); this.diagramLayer.UpdateSurface(); if (this.OperationFinished != null) { this.OperationFinished(this, new OperationEventArgs(Operation.Reconnect)); } }
public void MouseMove(MouseEventArgs e) { GraphElement element = GraphDiagram.GetElement(this.diagramLayer, e.Location); //If you are right-clicking and no item found, you switch to Operation Nop if ((e.Button == MouseButtons.Right) && (element == null)) { //The context of the Select operation is cleaned this.ClearOperationContext(); throw new OperationException(Operation.Select, "Change to Nop operation"); } //If you are pressing the left button, the selection is checked and Drag & Drop operation starts else if (e.Button == MouseButtons.Left) { if (element == null) { element = GraphDiagram.GetElement(this.diagramLayer, this.downInitialpoint); } //If the item is not selected, it is selected before the drag & Drop operation is started if (!element.Selected) { //If the CONTROL key is not pressed the other elements are deselected if (Control.ModifierKeys != Keys.Control) { DeselectAll(); } SelectElement(element); //The temporary layer is updated this.selectLayer.UpdateSurface(); if (this.ElementSelectedChanged != null) { this.ElementSelectedChanged(this, new EventArgs()); } } throw new OperationException(Operation.Select, "Change to Drag&Drop operation"); } //The mouse cursor is updated as appropriate else { if (element == null) { if ((Cursor.Current != Cursors.Hand) && (this.CursorChanged != null)) { this.CursorChanged(this, new CursorEventArgs(Cursors.Hand)); } } else if ((Cursor.Current != Cursors.Default) && (this.CursorChanged != null)) { this.CursorChanged(this, new CursorEventArgs(Cursors.Default)); } } }
/// <summary> /// This method undos the operation /// </summary> public void Undo() { //se eliminan los GraphElements de la capa de diagrama y del Logical diagram GraphDiagram.DeleteElements(this.diagramLayer, this.diagram, this.graphElements); //The diagram layer is updated this.diagramLayer.UpdateSurface(); //It is indicated that the diagram has changed if (this.DiagramChanged != null) { this.DiagramChanged(this, new EventArgs()); } }
/// <summary> /// This method undos the operation /// </summary> public void Undo() { //The GraphElement of the diagram layer and the logical diagram is removed GraphDiagram.DeleteElement(this.diagramLayer, this.diagram, this.graphElement); //The diagram layer is updated this.diagramLayer.UpdateSurface(); //It is indicated that the diagram has changed if (this.DiagramChanged != null) { this.DiagramChanged(this, new EventArgs()); } }
public void CanConstructGraphDiagram() { var A = Tensor.TwoD("A", (4, 3), "a", out Index a, out Index b); var B = Tensor.TwoD("B", (6, 7)); var C = Tensor.TwoD("C", (8, 9)); TensorExpression te = A[a, b]; GraphDiagram d = new GraphDiagram(te.ToTree()); Assert.Equal(4, d.Graph.NodeCount); Assert.Equal(3, d.Graph.EdgeCount); te = A[a, b] * C[a, b]; d = new GraphDiagram(te.ToTree()); }
/// <summary> /// Initializes a new instance of the UndirectedConnectToExpression object. /// </summary> /// <param name="graph">Reference to the graph that contains all nodes in the set of sources.</param> /// <param name="sources">The set of sources.</param> public UndirectedConnectToExpression(GraphDiagram <T, UndirectedEdge> graph, IEnumerable <GraphNode <T, UndirectedEdge> > sources) { if (null == graph) { throw new ArgumentNullException(); } if (null == sources) { throw new ArgumentNullException(); } this.graph = graph; this.sources = sources; }
public void MouseDown(MouseEventArgs e) { //This is for the right and left mouse buttons if ((e.Button == MouseButtons.Left) || (e.Button == MouseButtons.Right)) { //The position of the Down event is saved for possible new operations this.downInitialpoint = e.Location; GraphElement element = GraphDiagram.GetElement(this.diagramLayer, e.Location); //If it is not pressed on any element, it is changed to the Nop operation if (element == null) { //The context of the Select operation is cleaned this.ClearOperationContext(); throw new OperationException(Operation.Select, "Change to Nop Operation"); } } }
/// <summary> /// Occurs when the context menu is opened: Selects the item if it is not in that state /// </summary> /// <param name="sender"></param> /// <param name="e"></param> void Menu_Popup(object sender, EventArgs e) { GraphElement element = GraphDiagram.GetElement(this.diagramLayer, this.downInitialpoint); //You look at the selected state of the item if (!element.Selected) { //If the CONTROL key is not pressed the other elements are deselected if (Control.ModifierKeys != Keys.Control) { DeselectAll(); } SelectElement(element); //The temporary layer is updated this.selectLayer.UpdateSurface(); } }
/// <summary> /// Selects the item sent as a parameter /// </summary> /// <param name="element">Item to select</param> private void SelectElement(GraphElement element) { //The item is selected element.Selected = true; //The element is loaded into the temporary layer this.selectLayer.AddElement(element); if (GraphDiagram.ValidateCopy(this.selectLayer.Elements)) { this.miCopy.Enabled = true; this.miCut.Enabled = true; } else { if (this.OperationDisabled != null) { this.OperationDisabled(this, new OperationEventArgs(Operation.Copy)); this.OperationDisabled(this, new OperationEventArgs(Operation.Cut)); } this.miCopy.Enabled = false; this.miCut.Enabled = false; } if (GraphDiagram.ValidateDelete(this.selectLayer.Elements)) { this.miRemove.Enabled = true; } else { if (this.OperationDisabled != null) { this.OperationDisabled(this, new OperationEventArgs(Operation.Delete)); } this.miRemove.Enabled = false; } if (GraphDiagram.ValidateSettings(this.selectLayer.Elements)) { this.miSettings.Enabled = true; } else { if (this.OperationDisabled != null) { this.OperationDisabled(this, new OperationEventArgs(Operation.Settings)); } this.miSettings.Enabled = false; } }
public void UpdateArrow(List <Point> points, Color arrowColor) { Point minPoint = GraphDiagram.MinPoint(points); Point maxPoint = GraphDiagram.MaxPoint(points); Size size = new Size(maxPoint.X - minPoint.X + 1, maxPoint.Y - minPoint.Y + 1); this.Surface = new Surface(size); this.Surface.Fill(GraphDiagram.TRASPARENT_COLOR); for (int i = 0; i < (points.Count - 1); i++) { this.Surface.Draw(new Line(new Point(points[i].X - minPoint.X, points[i].Y - minPoint.Y), new Point(points[i + 1].X - minPoint.X, points[i + 1].Y - minPoint.Y)), arrowColor); } //The color of transparency is indicated this.Transparent = true; this.TransparentColor = GraphDiagram.TRASPARENT_COLOR; this.Position = minPoint; }