Пример #1
0
    // Remove the last connected board space
    public void RemoveLastConnected()
    {
        ConnectionLine line = connectionLines.GetLast();

        line.Remove();
        connectedSpaces.RemoveAt(connectedSpaces.Count - 1);
    }
Пример #2
0
 void Start()
 {
     currentDotLink        = new CurrentDotLink();
     dragInput.OnSwipe    += OnSwipe;
     dragInput.OnTouchEnd += OnTouchEnd;
     touchLine             = GameObject.Instantiate(connectionLinePrefab).GetComponent <ConnectionLine>();
 }
 public void StyleLineShouldSetThickness()
 {
     ConsumeAssociation target = AssociationTestData.ConsumeAssociationFullModel(this.factory, typeof(string), new List<string>(), 5);
     var line = new ConnectionLine();
     target.StyleLine(line);
     Assert.IsTrue(line.Thickness > 1);
 }
Пример #4
0
        /// <summary>
        /// Merges two connection objects into one
        /// </summary>
        /// <param name="fromConnection">the remaining connection</param>
        /// <param name="toConnection">the connection that gets merged</param>
        private void MergeConnections(GraphicConnection fromConnection, PointF fromPoint, GraphicConnection toConnection, PointF toPoint)
        {
            if (fromConnection.Equals(toConnection))
            {
                return;
            }
            if (MessageBox.Show(String.Format("Sollen die Verbindungen \"{0}\" und \"{1}\" miteinander verbunden werden?",
                                              fromConnection.Name, toConnection.Name), "Frage", MessageBoxButtons.YesNo,
                                MessageBoxIcon.Question, MessageBoxDefaultButton.Button1) == DialogResult.Yes)
            {
                //derive all Terminals and ConnectionItems (lines, nodes)
                fromConnection.Merge(toConnection);

                IConnectionItem item1 = fromConnection.GetItemAt(fromPoint);
                IConnectionItem item2 = fromConnection.GetItemAt(toPoint);
                if (item1 is ConnectionLine)
                {
                    item1 = SplitConnectionLine(item1 as ConnectionLine, fromPoint);
                }
                if (item2 is ConnectionLine)
                {
                    item2 = SplitConnectionLine(item2 as ConnectionLine, fromPoint);
                }
                ConnectionLine line = new ConnectionLine(item1 as ConnectionNode, item2 as ConnectionNode);
                fromConnection.AddChild(line);

                m_Editor.RemoveElement(toConnection);
                m_Editor.UpdateDrawing();
                m_Editor.RaiseChangedEvent();
            }
        }
Пример #5
0
        public static List <ConnectionLine> find(UIElementCollection entities, UIEntity entity)
        {
            List <ConnectionLine> result = new List <ConnectionLine>();

            foreach (UIEntity e in entities)
            {
                if (e is ConnectionLine)
                {
                    ConnectionLine    conenctor = e as ConnectionLine;
                    BindingExpression srcExp    = conenctor.GetBindingExpression(ConnectionLine.SourceProperty);
                    BindingExpression dstExp    = conenctor.GetBindingExpression(ConnectionLine.DestinationProperty);

                    if (srcExp != null && dstExp != null)
                    {
                        Port src = srcExp.DataItem as Port;
                        Port dst = dstExp.DataItem as Port;

                        //if (entity.Equals(src.Owner) || entity.Equals(dst.Owner))
                        if (entity.Equals(entity, src.Owner) || entity.Equals(entity, dst.Owner))
                        {
                            result.Add(conenctor);
                        }
                    }
                }
            }

            return(result);
        }
        private ConnectionItemData[] ConvertConnectionItems(Connection connection)
        {
            GraphicConnection         graphicConnection = connection.LinkedObject as GraphicConnection;
            List <ConnectionItemData> itemdatalist      = new List <ConnectionItemData>(graphicConnection.Children.Count);

            foreach (IConnectionItem item in graphicConnection.Children)
            {
                if (item is ConnectionLine)
                {
                    ConnectionLine line     = item as ConnectionLine;
                    LineItemData   linedata = new LineItemData(line.Nodes[0].Name, line.Nodes[1].Name);
                    itemdatalist.Add(linedata);
                }
                if (item is ConnectionNode)
                {
                    ConnectionNode node = item as ConnectionNode;
                    //if (node.Parent is GraphicTerminal) //impossible
                    //{
                    //    NodeItemData nodedata = new NodeItemData(node.Name);
                    //    nodedata.IsTerminalNode = true; //not needed
                    //    itemdatalist.Add(nodedata);
                    //} else
                    if (node.Parent is GraphicConnection)
                    {
                        NodeItemData nodedata = new NodeItemData(node.Name);
                        //nodedata.IsTerminalNode = false; //not needed
                        nodedata.X = node.Location.X;
                        nodedata.Y = node.Location.Y;
                        itemdatalist.Add(nodedata);
                    }
                }
            }

            return(itemdatalist.ToArray());
        }
Пример #7
0
    private void MouseOverNode(DNANode node)
    {
        if (editMode == EditMode.CreateDNA)
        {
            return;
        }

        if (!isClicking)
        {
            return;
        }

        if (firstConNode == null)
        {
            firstConNode = node;
            if (ConnectionLine == null)
            {
                ConnectionLine = Instantiate(ConnectionLinePrefub);
            }
            return;
        }

        if (secondConNode == null && firstConNode != node)
        {
            secondConNode = node;
        }
    }
 public void CompareToObjectShouldReturnNegative()
 {
     var target = new ConnectionLine { Distance = 3.4 };
     object compareTo = new ConnectionLine { Distance = 10.1 };
     var result = target.CompareTo(compareTo);
     Assert.IsTrue(result < 0);
 }
 public void CompareToShouldReturnPositive()
 {
     var target = new ConnectionLine { Distance = 20.1 };
     var compareTo = new ConnectionLine { Distance = 10.1 };
     var result = target.CompareTo(compareTo);
     Assert.IsTrue(result > 0);
 }
 public void CompareToShouldReturnZero()
 {
     var target = new ConnectionLine { Distance = 3.4 };
     var compareTo = new ConnectionLine { Distance = 3.4 };
     var result = target.CompareTo(compareTo);
     Assert.IsTrue(result == 0);
 }
Пример #11
0
 public void StyleLineShouldSetThickness()
 {
     ParentAssociation target = AssociationTestData.ParentAssociationIsolated(this.mockModelBuilder, this.mockType);
     var line = new ConnectionLine();
     target.StyleLine(line);
     line.Thickness.Should().BeGreaterThan(0);
 }
Пример #12
0
        private UserCard CreateUserCard(UserVo user, int level)
        {
            var userCard = new UserCard {
                User = user
            };

            double left = Math.Round(HorizontalCenter - (userCard.Width * _itemsLevels[level].Count / 2));

            userCard.Top  = VerticalGap * (level + 1) + userCard.Height * level;
            userCard.Left = left + userCard.Width * _itemsLevels[level].Proccesed +
                            HorizontalGap * (_itemsLevels[level].Proccesed + 1);

            userCard.SetValue(FrameworkElement.NameProperty, "UserCard" + _userCardNumber++);
            Canvas.SetZIndex(userCard, 2);
            userCard.MouseLeftButtonDown += _mouseLeftButtonDownHandler;
            _whitespace.Children.Add(userCard);

            _itemsLevels[level].Proccesed++;

            foreach (UserVo childUser in user.Users)
            {
                UserCard childUserCard = CreateUserCard(childUser, level + 1);

                var line = new ConnectionLine {
                    ParentUserCard = userCard, ChildUserCard = childUserCard
                };
                Canvas.SetZIndex(line, 1);
                _whitespace.Children.Add(line);
            }

            return(userCard);
        }
Пример #13
0
    // Connect this board space with another, creating a line between them
    public void Connect(BoardSpace space)
    {
        Vector3        lineStart = GetScreenPosition();
        Vector3        lineEnd   = space.GetScreenPosition();
        ConnectionLine line      = connectionLines.GetUnusedLine();

        line.SetPoints(lineStart, lineEnd);
        connectedSpaces.Add(space);
    }
Пример #14
0
    //Remove connection
    private void OnClickRemoveConnection(ConnectionLine connection)
    {
        //Save for undoing
        Undo.RecordObject(branchingTreeObj, "Remove connection");

        int tempIn  = -1;
        int tempOut = -1;

        //Remove the connections between the nodes
        for (int i = 0; i < nodes.Count; i++)
        {
            if (connection.inNode == nodes[i])
            {
                tempIn = i;
            }
            else if (connection.outNode == nodes[i])
            {
                tempOut = i;
            }
        }

        NodeConnectionCouple tempNCC = new NodeConnectionCouple();

        //foreach inNode connection on the inNode, check to see if it's connected to the outNode
        //If so, remove that connection
        for (int i = 0; i < nodes[tempIn].inNodes.Count; i++)
        {
            if (nodes[tempIn].inNodes[i].n == connection.outNode)
            {
                tempNCC = nodes[tempIn].inNodes[i];
                break;
            }
        }

        nodes[tempIn].RemoveInNode(tempNCC);

        //foreach inNode connection on the inNode, check to see if it's connected to the outNode
        //If so, remove that connection
        for (int i = 0; i < nodes[tempOut].outNodes.Count; i++)
        {
            if (nodes[tempOut].outNodes[i].n == connection.inNode)
            {
                tempNCC = nodes[tempOut].outNodes[i];
                break;
            }
        }

        nodes[tempOut].RemoveOutNode(tempNCC);

        connections.Remove(connection);

        //connectionCount = connections.Count;

        //Save for undoing
        SaveTree();
    }
Пример #15
0
 void Start()
 {
     connectionLines = new List <ConnectionLine>();
     for (int i = 0; i < connectionLinesPerSpace; i++)
     {
         GameObject     newConnectionLine = GameObject.Instantiate(linePrefab);
         ConnectionLine connectionLine    = newConnectionLine.GetComponent <ConnectionLine>();
         connectionLines.Add(connectionLine);
     }
 }
Пример #16
0
        public ConnectionLine ToConnectionLine()
        {
            var connectionLine = new ConnectionLine
            {
                Name  = this.Name,
                Start = this.Start,
                End   = this.End
            };

            return(connectionLine);
        }
Пример #17
0
 private void addLinkForRealEntities(ConnectionLine c, Entity realSrc, Entity realDest)
 {
     if (c.SourcePort.PortType == PortType.OUTPUT && c.DestinationPort.PortType == PortType.INPUT)
     {
         realSrc.addOutput(realDest);
         realDest.addInput(realSrc);
     }
     else if (c.SourcePort.PortType == PortType.INPUT && c.DestinationPort.PortType == PortType.OUTPUT)
     {
         realSrc.addInput(realDest);
         realDest.addOutput(realSrc);
     }
 }
Пример #18
0
 void startLine()
 {
     if (standingOver != null)
     {
         connectionOrigin = standingOver;
         inConnectMode    = true;
         GameObject l = Instantiate(connectionLine, transform.position, Quaternion.identity);
         GetComponentInChildren <SpriteRenderer>().color = connectingColor;
         currentConnectionLine = l;
         ConnectionLine c = l.GetComponent <ConnectionLine>();
         c.origin = transform.position;
         c.end    = transform;
     }
 }
Пример #19
0
 private void OnMouseDown(Vector2 touchPos, Transform hitTransform)
 {
     if (!ProcessUserInput || remainingLineCount <= 0)
     {
         return;
     }
     if (hitTransform && hitTransform.tag == "Node" && hitTransform.GetComponent <Node>().GraphId == graph.Id)
     {
         touchStartNode      = hitTransform.GetComponent <Node>();
         currentLine         = Instantiate(ConnectionLinePrefab, new Vector2(0, 0), Quaternion.identity, transform);
         currentLine.Scale   = Scale;
         currentLine.GraphId = graph.Id;
         currentLine.SetPositions(touchStartNode.transform.position, touchPos, StaticValues.ColorByIndex[touchStartNode.ColorId - 1], StaticValues.ColorByIndex[touchStartNode.ColorId - 1]);
     }
 }
Пример #20
0
        private void processConnectionLine(ConnectionLine c, bool skipSubprocess)
        {
            UIEntity src  = c.SourcePort.Owner;
            UIEntity dest = c.DestinationPort.Owner;

            if (skipSubprocess && (src is SubDiagram || dest is SubDiagram))
            {
                return;
            }

            if (map.ContainsKey(src) && map.ContainsKey(dest))
            {
                addLinkForRealEntities(c, map[src] as Entity, map[dest] as Entity);
            }
        }
Пример #21
0
        /// <summary>
        /// Splits the connection line at the given point and places a node there
        /// </summary>
        /// <param name="line">the line to split</param>
        /// <param name="atPoint">the point to place a node</param>
        /// <returns>the placed node</returns>
        private ConnectionNode SplitConnectionLine(ConnectionLine line, PointF atPoint)
        {
            GraphicConnection connection = line.Parent as GraphicConnection;

            ConnectionNode node  = new ConnectionNode(line.NearestPointOnLine(m_Editor.AlignToGrid(atPoint)));
            ConnectionLine line1 = new ConnectionLine(line.Nodes[0], node);
            ConnectionLine line2 = new ConnectionLine(line.Nodes[1], node);

            connection.RemoveChild(line);
            connection.AddChild(node);
            connection.AddChild(line1);
            connection.AddChild(line2);

            return(node);
        }
Пример #22
0
        internal override void StyleLine(ConnectionLine line)
        {
            if (line == null)
            {
                throw new ArgumentNullResourceException("line", Resources.General_Given_Parameter_Cannot_Be_Null);
            }

            double thickness = 1.25 + (this.UsageCount * 0.75);
            if (thickness > 15)
            {
                thickness = 15;
            }

            line.Thickness = thickness;
            line.Style = this.IsTrivialAssociation() ? "ConsumptionLineTrivial" : "ConsumptionLineStrong";
        }
        private void CreateConnectionLines(Circuit circuit, GraphicConnection graphicConnection, ConnectionData connectionData)
        {
            if (connectionData.Items == null || connectionData.Items.Length == 0)
            {
                //downward compatibility - no detailed information available:
                Connection      connection = graphicConnection.LinkedObject as Connection;
                GraphicTerminal previous   = null;
                //displays straight lines from one terminal to another
                foreach (Terminal terminal in connection.Terminals)
                {
                    GraphicTerminal graphicTerminal = terminal.LinkedObject as GraphicTerminal;
                    if (previous != null)
                    {
                        graphicConnection.AddChild(new ConnectionLine(previous.ConnectionNode, graphicTerminal.ConnectionNode));
                    }
                    previous = graphicTerminal;
                }
                return;
            }
            //create nodes
            foreach (ConnectionItemData itemData in connectionData.Items)
            {
                if (itemData is NodeItemData)
                {
                    NodeItemData   nodeData = itemData as NodeItemData;
                    ConnectionNode node     = new ConnectionNode(nodeData.X, nodeData.Y);
                    graphicConnection.AddChild(node);
                }
            }
            //create lines
            foreach (ConnectionItemData itemData in connectionData.Items)
            {
                if (itemData is LineItemData)
                {
                    LineItemData lineData = itemData as LineItemData;

                    ConnectionNode node1 = SearchNode(lineData.Node1, circuit, graphicConnection);
                    ConnectionNode node2 = SearchNode(lineData.Node2, circuit, graphicConnection);

                    if (node1 != null && node2 != null)
                    {
                        ConnectionLine line = new ConnectionLine(node1, node2);
                        graphicConnection.AddChild(line);
                    }
                }
            }
        }
Пример #24
0
 private void OnMouseUp(Vector2 touchPos, Transform hitTransform)
 {
     if (!ProcessUserInput)
     {
         return;
     }
     if (hitTransform)
     {
         if (hitTransform.tag == "Line" && !touchStartNode)
         {
             var line = hitTransform.GetComponent <ConnectionLine>();
             if (line.GraphId == graph.Id)
             {
                 Graph.RemoveConnectionMatrix(graph, line.Node1Index, line.Node2Index);
                 connectionLines.Remove(line);
                 nodes[line.Node1Index].lines.Remove(line);
                 nodes[line.Node2Index].lines.Remove(line);
                 Destroy(line.gameObject);
             }
         }
         else if (hitTransform.tag == "Node" && hitTransform.GetComponent <Node>().GraphId == graph.Id)
         {
             var node2 = hitTransform.GetComponent <Node>();
             if (touchStartNode && touchStartNode.Id != node2.Id && !Graph.IsNodesConnectedMatrix(graph, touchStartNode.Index, node2.Index))
             {
                 var node1 = touchStartNode;
                 currentLine.SetConnectedNodes(node1.Index, node1.transform.position, node2.Index, node2.transform.position, StaticValues.ColorByIndex[node1.ColorId - 1], StaticValues.ColorByIndex[node2.ColorId - 1]);
                 connectionLines.Add(currentLine);
                 node1.lines.Add(currentLine);
                 node2.lines.Add(currentLine);
                 currentLine = null;
                 Graph.AddConnectionMatrix(graph, node1.Index, node2.Index);
                 --remainingLineCount;
                 if (TxtRemainingLineCount)
                 {
                     TxtRemainingLineCount.text = remainingLineCount.ToString();
                 }
             }
         }
     }
     touchStartNode = null;
     if (currentLine)
     {
         Destroy(currentLine.gameObject); //TODO: instead, hide it to use later
     }
 }
Пример #25
0
 /// <summary>
 /// Connect to a Connection
 /// </summary>
 /// <param name="connection"></param>
 private void TryConnectToConnection(GraphicConnection connection, PointF location)
 {
     if (m_FromElement is GraphicTerminal)
     {
         Terminal fromTerminal = m_FromElement.LinkedObject as Terminal;
         if (fromTerminal.Connection != null)
         {
             MergeConnections(fromTerminal.Connection.LinkedObject as GraphicConnection, m_LastMouseLocation, connection, location);
         }
         else
         {
             IConnectionItem connectionItem = connection.GetItemAt(location);
             if (connectionItem is ConnectionNode)
             {
                 //user clicked near a node - connect to this
                 ConnectionLine line = new ConnectionLine((m_FromElement as GraphicTerminal).ConnectionNode, connectionItem as ConnectionNode);
                 connection.AddChild(line);
             }
             else if (connectionItem is ConnectionLine)
             {
                 //user clicked near a line
                 ConnectionLine prevLine = connectionItem as ConnectionLine;
                 //place a connection node at location - split connection line
                 ConnectionNode node = SplitConnectionLine(prevLine, location);
                 ConnectionLine line = new ConnectionLine(node, (m_FromElement as GraphicTerminal).ConnectionNode);
                 connection.AddChild(line);
             }
             connection.ConnectTerminal(m_FromElement as GraphicTerminal);
             m_Editor.UpdateDrawing();
             m_Editor.RaiseChangedEvent();
         }
     }
     else if (m_FromElement is GraphicConnection)
     {
         MergeConnections(m_FromElement as GraphicConnection, m_LastMouseLocation, connection, location);
     }
     else if (m_FromElement is ConnectionNode)
     {
         MergeConnections(m_FromElement.Parent as GraphicConnection, m_LastMouseLocation, connection, location);
         //GraphicConnection fromConnection = m_FromElement.Parent as GraphicConnection;
     }
     m_FromElement = null;
     m_Editor.Invalidate();
 }
Пример #26
0
 private void NodeOnSlotConnected(Slot slot)
 {
     Dispatcher.Invoke(() =>
     {
         ConnectionLine line;
         if (_lines.TryGetValue(slot, out line))
         {
             line.Dispose();
         }
         if (slot.Mode == InOut.In)
         {
             if (slot.Output != null)
             {
                 line         = new ConnectionLine(Canvas, slot, slot.Output);
                 _lines[slot] = line;
             }
         }
     });
 }
Пример #27
0
        public JsonSchemaConnectionLine(ConnectionLine connectionLine)
        {
            if (connectionLine == null)
            {
                return;
            }
            this.Type = CreativeMode.Line;
            this.Name = connectionLine.Name;

            // this.PathGeometry = connectionLine.PathGeometry;
            this.Start = connectionLine.Start;
            this.End   = connectionLine.End;

            this.Element1Name = connectionLine.Element1?.Name;
            this.Element2Name = connectionLine.Element2?.Name;


            // this.Element1 = connectionLine.Element1 is Module ? new JsonSchemaModule(connectionLine.Element1 as Module): null;
            // this.Element2 = connectionLine.Element2 is Module ? new JsonSchemaModule(connectionLine.Element2 as Module) : null;
        }
Пример #28
0
    private void MouseButtonUp()
    {
        if (editMode == EditMode.CreateDNA)
        {
            return;
        }

        if (firstConNode != null && secondConNode != null)
        {
            ConnectionLine = null;
            connectionsCount++;
            updateVirusMetaInfo();
        }
        else
        {
            if (ConnectionLine != null)
            {
                Destroy(ConnectionLine.gameObject);
                ConnectionLine = null;
            }
        }
        firstConNode  = null;
        secondConNode = null;
    }
        public ViewModelComponentLine(PointPin point0, PointPin point1, Canvas _surface, int id = -1)
        {
            BaseComponentUI componentUi;

            if (id == -1)
            {
                componentUi = new ComponentUIConnectionLine(BaseElement.IdCounter);
                element     = new ConnectionLine(BaseElement.IdCounter);
            }
            else
            {
                componentUi = new ComponentUIConnectionLine(id);
                element     = new ConnectionLine(id);
            }

            Panel.SetZIndex(componentUi, -1000000);
            ((ConnectionLine)element).OnPropertyChangedModel += PropertyChanged;
            componentUi.DataContext = this;
            FirstPin = point0;
            LastPin  = point1;
            BuildLine(point0, point1);
            componentUi.OnDeleteElement += OnDelete;
            _surface.Children.Add(componentUi);
        }
Пример #30
0
        private void restoreConnectionLines(MainWindow mw)
        {
            List <ConnectionLine> connections = ConnectorFinder.find(owner.canvas.Children, owner);

            foreach (ConnectionLine cl in connections)
            {
                // can use ==, because it's same object instance
                UIEntity connectedTo = cl.SourcePort.Owner != owner ? cl.SourcePort.Owner : cl.DestinationPort.Owner;
                PortType srcPortType = cl.SourcePort.Owner != owner ? cl.SourcePort.PortType : cl.DestinationPort.PortType;
                PortType dstPortType = cl.SourcePort.Owner != owner ? cl.DestinationPort.PortType : cl.SourcePort.PortType;

                if (!(ParameterProccesor.newResource.GetType() == typeof(MaterialResource) && PortType.BOTTOM_RESOURCE.Equals(dstPortType)))
                {
                    ConnectionLine newCl = new ConnectionLine(owner.canvas);

                    newCl.SetBinding(ConnectionLine.SourceProperty, new Binding()
                    {
                        Source = connectedTo.findPort(srcPortType),
                        Path   = new PropertyPath(Port.AnchorPointProperty)
                    });
                    newCl.SetBinding(ConnectionLine.DestinationProperty, new Binding()
                    {
                        Source = ParameterProccesor.newResource.findPort(dstPortType),
                        Path   = new PropertyPath(Port.AnchorPointProperty)
                    });


                    newCl.MouseLeftButtonDown += mw.Shape_MouseLeftButtonDown;
                    newCl.MouseLeftButtonUp   += mw.Shape_MouseLeftButtonUp;

                    ZIndexUtil.setCorrectZIndex(newCl.canvas, newCl);

                    owner.canvas.Children.Add(newCl);
                }
            }
        }
Пример #31
0
        internal override void StyleLine(ConnectionLine line)
        {
            if (!this.IsInitialised)
            {
                CannotUseWithoutInitializationFirst();
            }

            if (line == null)
            {
                throw new ArgumentNullResourceException("line", Resources.General_Given_Parameter_Cannot_Be_Null);
            }

            line.Style = this.AssociatedTo.Modifiers.Kind == TypeKind.Interface ? "ImplementsLine" : "InheritanceLine";
        }
Пример #32
0
        public void StyleLineShouldSetThicknessTo16WhenUsageIsHigh()
        {
            FieldAssociation target = AssociationTestData.FieldAssociationFullModel(this.factory, typeof(string), new List<string> { "one", "two" }, 20);
            var line = new ConnectionLine();
            target.StyleLine(line);

            Assert.AreEqual(16, line.Thickness);
        }
Пример #33
0
 internal override void StyleLine(ConnectionLine line)
 {
     throw new NotImplementedException();
 }
Пример #34
0
        /// <summary>
        /// Connect to a Terminal (resp. its connection)
        /// </summary>
        /// <param name="graphicTerminal"></param>
        private void TryConnectToTerminal(GraphicTerminal graphicTerminal, PointF location)
        {
            Terminal toTerminal = graphicTerminal.LinkedObject as Terminal;

            if (toTerminal.Connection != null)
            {
                //merging connections not supported by clicking terminals
                return;
            }
            if (m_FromElement is GraphicTerminal)
            {
                Terminal fromTerminal = m_FromElement.LinkedObject as Terminal;
                //if (fromTerminal.Connection != null && toTerminal.Connection != null)
                //{
                //    MergeConnections(fromTerminal.Connection.LinkedObject as GraphicConnection, m_LastMouseLocation,
                //        toTerminal.Connection.LinkedObject as GraphicConnection, location);
                //}
                //else if (fromTerminal.Connection != null)
                //{
                //    //IDEE: suche über allen linien die kürzeste entfernung vom ziel zur verbindung
                //    GraphicConnection graphicConnection = fromTerminal.Connection.LinkedObject as GraphicConnection;

                //    ConnectionLine line = new ConnectionLine((m_FromElement as GraphicTerminal).ConnectionNode, graphicTerminal.ConnectionNode);
                //    graphicConnection.AddChild(line);

                //    graphicConnection.ConnectTerminal(graphicTerminal);
                //    m_Editor.UpdateDrawing();
                //    m_Editor.RaiseChangedEvent();
                //}
                //else if (toTerminal.Connection != null)
                //{
                //    GraphicConnection graphicConnection = toTerminal.Connection.LinkedObject as GraphicConnection;
                //    graphicConnection.ConnectTerminal(m_FromElement as GraphicTerminal);
                //    m_Editor.UpdateDrawing();
                //    m_Editor.RaiseChangedEvent();
                //}
                //else
                if (fromTerminal.Connection == null && toTerminal.Connection == null)
                {
                    GraphicTerminal fromGraphicTerminal = m_FromElement as GraphicTerminal;
                    if (IsOrthogonal(fromGraphicTerminal.ConnectionNode.Location, graphicTerminal.ConnectionNode.Location) == false)
                    {
                        return;
                    }
                    GraphicConnection graphicConnection
                        = GraphicObjectFactory.CreateInstance(typeof(Connection), new Connection()) as GraphicConnection;
                    graphicConnection.Name = UniqueName.GetUniqueName(m_Editor.Circuit, typeof(Connection));
                    graphicConnection.ConnectTerminal(fromGraphicTerminal);
                    graphicConnection.ConnectTerminal(graphicTerminal);

                    ConnectionLine line = new ConnectionLine(fromGraphicTerminal.ConnectionNode, graphicTerminal.ConnectionNode);
                    graphicConnection.AddChild(line);

                    m_Editor.AddElement(graphicConnection);
                    m_Editor.UpdateDrawing();
                    m_Editor.RaiseChangedEvent();
                }
            }
            if (m_FromElement is GraphicConnection)
            {
                GraphicConnection fromConnection = m_FromElement as GraphicConnection;
                IConnectionItem   connectionItem = fromConnection.GetItemAt(m_LastMouseLocation);

                if (connectionItem is ConnectionNode)
                {
                    ConnectionLine line = new ConnectionLine(connectionItem as ConnectionNode, graphicTerminal.ConnectionNode);
                    fromConnection.AddChild(line);
                }
                else if (connectionItem is ConnectionLine)
                {
                    ConnectionLine prevLine = connectionItem as ConnectionLine;
                    ConnectionNode node     = new ConnectionNode(prevLine.NearestPointOnLine(m_LastMouseLocation));
                    ConnectionLine line1    = new ConnectionLine(prevLine.Nodes[0], node);
                    ConnectionLine line2    = new ConnectionLine(prevLine.Nodes[1], node);
                    fromConnection.RemoveChild(prevLine);
                    fromConnection.AddChild(node);
                    fromConnection.AddChild(line1);
                    fromConnection.AddChild(line2);

                    ConnectionLine line = new ConnectionLine(node, graphicTerminal.ConnectionNode);
                    fromConnection.AddChild(line);
                }

                fromConnection.ConnectTerminal(graphicTerminal);
                m_Editor.UpdateDrawing();
                m_Editor.RaiseChangedEvent();
            }
            if (m_FromElement is ConnectionNode)
            {
                m_FromElement.Location = ForceOrthogonality(graphicTerminal.ConnectionNode.Location, m_FromElement.Location);
                ConnectionLine line = new ConnectionLine(m_FromElement as ConnectionNode, graphicTerminal.ConnectionNode);
                m_FromElement.Parent.AddChild(line);

                (m_FromElement.Parent as GraphicConnection).ConnectTerminal(graphicTerminal);
                m_Editor.UpdateDrawing();
                m_Editor.RaiseChangedEvent();
            }
            m_FromElement = null;
            m_Editor.Invalidate();
        }
Пример #35
0
 public BoardInput(Board board, ConnectionLine connectionLine)
 {
     this.board          = board;
     this.connectionLine = connectionLine;
     SelectedElements    = new List <BoardElement>();;
 }
Пример #36
0
        /// <summary>
        /// Create a floating connnection, i.e. not completely connected everywhere
        /// </summary>
        /// <param name="location"></param>
        private void FloatingConnection(PointF location)
        {
            if (m_FromElement is GraphicConnection)
            {
                GraphicConnection graphicConnection = m_FromElement as GraphicConnection;
                IConnectionItem   connectionItem    = graphicConnection.GetItemAt(m_LastMouseLocation);
                if (connectionItem is ConnectionNode)
                {
                    //user clicked near a node at fist, connect to this
                    ConnectionNode prevNode = connectionItem as ConnectionNode;
                    location = ForceOrthogonality(prevNode.Location, m_Editor.AlignToGrid(location));
                    bool skip = false;
                    //check whether the new line would just lenghten the previous line
                    if (prevNode.Lines.Length == 1)
                    {
                        ConnectionLine prevLine = prevNode.Lines[0];
                        if (prevLine.LineStyle == ConnectionLine.DetermineLineStyle(prevNode.Location, location))
                        {
                            //place the node at the new location in this case
                            prevNode.Location = location;
                            skip = true;
                        }
                    }
                    if (skip == false)
                    {
                        //place a new line
                        ConnectionNode node = new ConnectionNode(location);
                        ConnectionLine line = new ConnectionLine(prevNode, node);

                        m_FromElement.AddChild(node);
                        m_FromElement.AddChild(line);

                        m_FromElement = node;
                    }
                }
                else if (connectionItem is ConnectionLine)
                {
                    //user clicked near a line at first
                    ConnectionLine prevLine = connectionItem as ConnectionLine;
                    //place a connection node at location - split connection line
                    ConnectionNode node = SplitConnectionLine(prevLine, m_LastMouseLocation);

                    //the new node/line
                    location = ForceOrthogonality(node.Location, m_Editor.AlignToGrid(location));
                    ConnectionNode fnode = new ConnectionNode(location);
                    ConnectionLine line  = new ConnectionLine(node, fnode);
                    m_FromElement.AddChild(fnode);
                    m_FromElement.AddChild(line);

                    m_FromElement = fnode;
                }
            }
            else if (m_FromElement is GraphicTerminal)
            {
                //floating connection from a terminal
                GraphicTerminal graphicTerminal = m_FromElement as GraphicTerminal;
                location = ForceOrthogonality(graphicTerminal.ConnectionNode.Location, m_Editor.AlignToGrid(location));
                ConnectionNode node = new ConnectionNode(location);
                ConnectionLine line = new ConnectionLine(node, graphicTerminal.ConnectionNode);

                GraphicConnection graphicConnection =
                    GraphicObjectFactory.CreateInstance(typeof(Connection), new Connection()) as GraphicConnection;
                graphicConnection.Name = UniqueName.GetUniqueName(m_Editor.Circuit, typeof(Connection));
                graphicConnection.AddChild(node);
                graphicConnection.AddChild(line);

                graphicConnection.ConnectTerminal(graphicTerminal);
                m_Editor.AddElement(graphicConnection);

                //proceed connecting with this node
                m_FromElement = node;
            }
            else if (m_FromElement is ConnectionNode)
            {
                //special case -> could be covered by "is GraphicConnection"
                //sequential floating lines
                ConnectionNode prevNode = m_FromElement as ConnectionNode;
                location = ForceOrthogonality(prevNode.Location, m_Editor.AlignToGrid(location));
                bool skip = false;
                //check whether the new line would just lenghten the previous line
                if (prevNode.Lines.Length == 1)
                {
                    ConnectionLine prevLine = prevNode.Lines[0];
                    if (prevLine.LineStyle == ConnectionLine.DetermineLineStyle(prevNode.Location, location))
                    {
                        //place the node at the new location in this case
                        prevNode.Location = location;
                        skip = true;
                    }
                }
                if (skip == false)
                {
                    //place a new line
                    ConnectionNode node = new ConnectionNode(location);
                    ConnectionLine line = new ConnectionLine(prevNode, node);

                    GraphicConnection graphicConnection = prevNode.Parent as GraphicConnection;
                    graphicConnection.AddChild(node);
                    graphicConnection.AddChild(line);

                    m_FromElement = node;
                }
            }
            m_Editor.UpdateDrawing();
            m_Editor.RaiseChangedEvent();
            m_Editor.Invalidate();
        }
Пример #37
0
        /// <summary>
        /// The style line.
        /// </summary>
        /// <param name="line">
        /// The line.
        /// </param>
        internal override void StyleLine(ConnectionLine line)
        {
            if (!this.IsInitialised)
            {
                CannotUseWithoutInitializationFirst();
            }

            StyleLineForNonParentAssociation(line, this.UsageCount, this.AssociatedTo, this.IsTrivialAssociation());
        }
Пример #38
0
 public abstract (bool success, string validationError) VisitConnectionLine(ConnectionLine connectionLine);
Пример #39
0
 internal abstract void StyleLine(ConnectionLine line);
 public ConnectionRouteEventArgs(ConnectionLine route)
 {
     this.Line = route;
 }
 public void CompareToShouldThrowWhenGivenNull()
 {
     var target = new ConnectionLine();
     var result = target.CompareTo(null);
 }
Пример #42
0
        internal static void StyleLineForNonParentAssociation(ConnectionLine line, int usageCount, IVisualisableType associatedTo, bool isTrivial)
        {
            if (line == null)
            {
                throw new ArgumentNullResourceException("line", Resources.General_Given_Parameter_Cannot_Be_Null);
            }

            double thickness = 2.25 + (usageCount * 0.75);
            if (thickness > 15)
            {
                thickness = 15;
            }

            if (associatedTo.Modifiers.Kind == TypeKind.Interface)
            {
                line.Style = "AssociationLineInterface";
                line.Thickness = thickness;
            }
            else if (isTrivial)
            {
                line.Style = "AssociationLineTrivial";
                line.Thickness = thickness;
            }
            else
            {
                line.Style = "AssociationLineStrong";
                line.Thickness = thickness + 1;
            }
        }
Пример #43
0
 internal override void StyleLine(ConnectionLine line)
 {
     // A subject association may still be asked to style a line if a secondary relationship points back to the subject.
     FieldAssociation.StyleLineForNonParentAssociation(line, 1, this.AssociatedTo, this.IsTrivialAssociation());
 }
Пример #44
0
 /// <summary>
 /// Erstellt eine Linie zu der angegebenen EpicControl
 /// </summary>
 /// <param name="ec"></param>
 private void CreateLine(EpicControl ec)
 {
     ec.IsHiddenChanged += ec_IsHiddenChanged;
     Line = new ConnectionLine(this, ec);
 }