Exemplo n.º 1
0
        private void AffixConduitEnd(LineBlock nodeContainerBlock, SpanEquipmentViewModel viewModel)
        {
            var routeSpanDiagramInfo = viewModel.RootSpanDiagramInfo("OuterConduit");

            var blockSide = viewModel.BlockSideWhereSpanEquipmentShouldBeAffixed();

            // Create block port representing the outer conduit
            var outerConduitPort = CreatePortForOuterConduitEnd(viewModel, blockSide);

            nodeContainerBlock.AddPort(outerConduitPort);

            List <SpanDiagramInfo> innerSpanData = viewModel.GetInnerSpanDiagramInfos("InnerConduit");

            bool innerSpansFound = false;

            // Create inner conduit ends as port terminals
            foreach (var innerSpanDiagramInfo in innerSpanData)
            {
                CreateTerminalForInnerConduitEnd(viewModel, outerConduitPort, innerSpanDiagramInfo);
                innerSpansFound = true;
            }

            // We're dealing with a multi conduit without any inner conduits or a single span conduit
            if (!innerSpansFound)
            {
                // We're dealing with a single span conduit
                if (viewModel.IsSingleSpan)
                {
                    CreateTerminalForSingleConduitEnd(viewModel, outerConduitPort);
                }
                // We're dealing with a multi level conduit with no inner conduits
                else
                {
                    // Check if cables are related to the outer conduir
                    if (_nodeContainerViewModel.Data.ConduitSegmentToCableChildRelations.ContainsKey(routeSpanDiagramInfo.SegmentId))
                    {
                        CreateTerminalsForCablesRelatedToSingleConduitEnd(viewModel, outerConduitPort);
                    }
                    // No cables so we create one terminal that shows where the empty multi conduit is heading
                    else
                    {
                        CreateTerminalForShowingWhereEmptySingleConduitIsHeading(viewModel, outerConduitPort);
                    }
                }
            }
        }
Exemplo n.º 2
0
        private LineBlock CreateConduitPassThroughBlock()
        {
            // Create outer conduits
            var rootSpanInfo = _spanEquipmentViewModel.RootSpanDiagramInfo("OuterConduit");

            var spanEquipmentBlock = new LineBlock()
            {
                MinWidth     = _spanEquipmentAreaWidth,
                IsVisible    = _spanEquipmentViewModel.IsSingleSpan ? false : true,
                Style        = rootSpanInfo.StyleName,
                Margin       = _spanEquipmentViewModel.IsSingleSpan ? 0 : _spanEquipmentBlockMargin,
                DrawingOrder = 400
            };

            spanEquipmentBlock.SetReference(rootSpanInfo.IngoingSegmentId, "SpanSegment");

            // Create inner conduits
            var innerSpanData = _spanEquipmentViewModel.GetInnerSpanDiagramInfos("InnerConduit");

            var fromPort = _spanEquipmentViewModel.IsSingleSpan ?
                           new BlockPort(BlockSideEnum.West, null, null, 0, -1, 0)
            {
                IsVisible = false, DrawingOrder = 420
            } :
            new BlockPort(BlockSideEnum.West)
            {
                IsVisible = false, DrawingOrder = 420
            };

            spanEquipmentBlock.AddPort(fromPort);

            var toPort = _spanEquipmentViewModel.IsSingleSpan ?
                         new BlockPort(BlockSideEnum.East, null, null, 0, -1, 0)
            {
                IsVisible = false, DrawingOrder = 420
            } :
            new BlockPort(BlockSideEnum.East)
            {
                IsVisible = false, DrawingOrder = 420
            };

            spanEquipmentBlock.AddPort(toPort);

            int terminalNo = 1;

            var orderedinnerSpanData = innerSpanData.OrderBy(i => (1000 - i.Position));

            bool innerSpansFound = false;

            foreach (var spanInfo in orderedinnerSpanData)
            {
                var fromTerminal = new BlockPortTerminal(fromPort)
                {
                    IsVisible    = true,
                    ShapeType    = TerminalShapeTypeEnum.Point,
                    PointStyle   = "WestTerminalLabel",
                    PointLabel   = _spanEquipmentViewModel.GetIngoingRouteNodeName(spanInfo.SegmentId),
                    DrawingOrder = 520
                };

                fromTerminal.SetReference(spanInfo.IngoingSegmentId, "SpanSegment");

                var toTerminal = new BlockPortTerminal(toPort)
                {
                    IsVisible    = true,
                    ShapeType    = TerminalShapeTypeEnum.Point,
                    PointStyle   = "EastTerminalLabel",
                    PointLabel   = _spanEquipmentViewModel.GetOutgoingRouteNodeName(spanInfo.SegmentId),
                    DrawingOrder = 520
                };

                toTerminal.SetReference(spanInfo.OutgoingSegmentId, "SpanSegment");

                var terminalConnection = spanEquipmentBlock.AddTerminalConnection(BlockSideEnum.West, 1, terminalNo, BlockSideEnum.East, 1, terminalNo, null, spanInfo.StyleName, LineShapeTypeEnum.Polygon);
                terminalConnection.DrawingOrder = 510;
                terminalConnection.SetReference(spanInfo.IngoingSegmentId, "SpanSegment");

                // Add eventually cable running through inner conduit
                if (_spanEquipmentViewModel.Data.ConduitSegmentToCableChildRelations.ContainsKey(spanInfo.SegmentId))
                {
                    var cableId             = _spanEquipmentViewModel.Data.ConduitSegmentToCableChildRelations[spanInfo.SegmentId].First();
                    var fiberCableLineLabel = _spanEquipmentViewModel.Data.GetCableEquipmentLineLabel(cableId);


                    var cableTerminalConnection = spanEquipmentBlock.AddTerminalConnection(BlockSideEnum.West, 1, terminalNo, BlockSideEnum.East, 1, terminalNo, fiberCableLineLabel, "FiberCable", LineShapeTypeEnum.Line);
                    cableTerminalConnection.DrawingOrder = 600;
                    cableTerminalConnection.SetReference(cableId, "SpanSegment");
                }

                terminalNo++;

                innerSpansFound = true;
            }

            if (!innerSpansFound)
            {
                var fromTerminal = new BlockPortTerminal(fromPort)
                {
                    IsVisible    = true,
                    ShapeType    = TerminalShapeTypeEnum.Point,
                    PointStyle   = "WestTerminalLabel",
                    PointLabel   = _spanEquipmentViewModel.GetIngoingRouteNodeName(rootSpanInfo.SegmentId),
                    DrawingOrder = 520
                };

                fromTerminal.SetReference(rootSpanInfo.IngoingSegmentId, "SpanSegment");

                var toTerminal = new BlockPortTerminal(toPort)
                {
                    IsVisible    = true,
                    ShapeType    = TerminalShapeTypeEnum.Point,
                    PointStyle   = "EastTerminalLabel",
                    PointLabel   = _spanEquipmentViewModel.GetOutgoingRouteNodeName(rootSpanInfo.SegmentId),
                    DrawingOrder = 520
                };

                toTerminal.SetReference(rootSpanInfo.OutgoingSegmentId, "SpanSegment");


                // If a single conduit
                if (_spanEquipmentViewModel.IsSingleSpan)
                {
                    var terminalConnection = spanEquipmentBlock.AddTerminalConnection(BlockSideEnum.West, 1, terminalNo, BlockSideEnum.East, 1, terminalNo, null, rootSpanInfo.StyleName, LineShapeTypeEnum.Polygon);
                    terminalConnection.DrawingOrder = 510;
                    terminalConnection.SetReference(rootSpanInfo.SegmentId, "SpanSegment");


                    // Add eventually cable running through inner conduit
                    if (_spanEquipmentViewModel.Data.ConduitSegmentToCableChildRelations.ContainsKey(rootSpanInfo.SegmentId))
                    {
                        var cableId             = _spanEquipmentViewModel.Data.ConduitSegmentToCableChildRelations[rootSpanInfo.SegmentId].First();
                        var fiberCableLineLabel = _spanEquipmentViewModel.Data.GetCableEquipmentLineLabel(cableId);


                        var cableTerminalConnection = spanEquipmentBlock.AddTerminalConnection(BlockSideEnum.West, 1, terminalNo, BlockSideEnum.East, 1, terminalNo, fiberCableLineLabel, "FiberCable", LineShapeTypeEnum.Line);
                        cableTerminalConnection.DrawingOrder = 600;
                        cableTerminalConnection.SetReference(cableId, "SpanSegment");
                    }
                }


                terminalNo++;
            }

            return(spanEquipmentBlock);
        }
Exemplo n.º 3
0
        private void AffixPassThroughConduit(LineBlock nodeContainerBlock, SpanEquipmentViewModel viewModel)
        {
            var spanDiagramInfo = viewModel.RootSpanDiagramInfo("OuterConduit");

            BlockSideEnum fromSide = viewModel.BlockSideWhereSpanEquipmentShouldBeAffixed();
            BlockSideEnum toSide   = viewModel.OppositeBlockSideWhereSpanEquipmentShouldBeAffixed();

            bool portsVisible = true;

            // If cut we want to draw the port polygons, because otherwise the outer conduit cannot be seen on the diagram (due to missing connection between the two sides)
            if (spanDiagramInfo.IsPassThrough)
            {
                portsVisible = false;
            }

            // Create outer conduit as port
            var fromPort = new BlockPort(fromSide)
            {
                IsVisible  = portsVisible,
                Margin     = _portMargin,
                Style      = spanDiagramInfo.StyleName,
                PointStyle = fromSide.ToString() + "TerminalLabel",
                PointLabel = viewModel.GetConduitEquipmentLabel()
            };

            fromPort.DrawingOrder = 420;
            fromPort.SetReference(viewModel.RootSpanDiagramInfo("OuterConduit").IngoingSegmentId, "SpanSegment");
            nodeContainerBlock.AddPort(fromPort);

            var toPort = new BlockPort(toSide)
            {
                IsVisible  = portsVisible,
                Margin     = _portMargin,
                Style      = spanDiagramInfo.StyleName,
                PointStyle = toSide.ToString() + "TerminalLabel",
                PointLabel = viewModel.GetConduitEquipmentLabel()
            };

            toPort.DrawingOrder = 420;
            toPort.SetReference(viewModel.RootSpanDiagramInfo("OuterConduit").OutgoingSegmentId, "SpanSegment");

            nodeContainerBlock.AddPort(toPort);

            if (spanDiagramInfo.IsPassThrough)
            {
                var portConnection = nodeContainerBlock.AddPortConnection(fromSide, fromPort.Index, toSide, toPort.Index, null, spanDiagramInfo.StyleName);
                portConnection.SetReference(spanDiagramInfo.SegmentId, "SpanSegment");
                portConnection.DrawingOrder = 410;
            }

            List <SpanDiagramInfo> innerSpanData = viewModel.GetInnerSpanDiagramInfos("InnerConduit");

            bool innerSpansFound = false;

            int terminalNo = 1;

            if (innerSpanData.Count == 6)
            {
            }

            foreach (var innerSpan in innerSpanData)
            {
                TerminalShapeTypeEnum terminalShapeType = TerminalShapeTypeEnum.Point;

                // If cut we want to draw the terminal polygon, because otherwise the conduit cannot be seen on the diagram (due to missing connection between the two sides)
                if (!innerSpan.IsPassThrough)
                {
                    terminalShapeType = TerminalShapeTypeEnum.PointAndPolygon;
                }


                string fromNodeName = "NA";
                string toNodeName   = "NA";

                if (innerSpan.IsPassThrough)
                {
                    fromNodeName = viewModel.GetIngoingRouteNodeName(innerSpan.SegmentId);
                    toNodeName   = viewModel.GetOutgoingRouteNodeName(innerSpan.SegmentId);
                }
                else
                {
                    fromNodeName = viewModel.GetIngoingRouteNodeName(innerSpan.IngoingSpanSegment.Id);
                    toNodeName   = viewModel.GetOutgoingRouteNodeName(innerSpan.OutgoingSpanSegment.Id);
                }

                var fromTerminal = new BlockPortTerminal(fromPort)
                {
                    IsVisible    = true,
                    ShapeType    = terminalShapeType,
                    PointStyle   = fromSide.ToString() + "TerminalLabel",
                    PointLabel   = fromNodeName,
                    PolygonStyle = innerSpan.StyleName
                };

                fromTerminal.SetReference(innerSpan.IngoingSegmentId, "SpanSegment");
                fromTerminal.DrawingOrder = 620;

                var toTerminal = new BlockPortTerminal(toPort)
                {
                    IsVisible    = true,
                    ShapeType    = terminalShapeType,
                    PointStyle   = toSide.ToString() + "TerminalLabel",
                    PointLabel   = toNodeName,
                    PolygonStyle = innerSpan.StyleName
                };

                toTerminal.SetReference(innerSpan.OutgoingSegmentId, "SpanSegment");
                toTerminal.DrawingOrder = 620;

                // Connect the two sides, if the inner conduit is not cut / passing through
                if (innerSpan.IsPassThrough)
                {
                    var terminalConnection = nodeContainerBlock.AddTerminalConnection(fromSide, fromPort.Index, terminalNo, toSide, toPort.Index, terminalNo, null, innerSpan.StyleName, LineShapeTypeEnum.Polygon);
                    terminalConnection.SetReference(innerSpan.IngoingSegmentId, "SpanSegment");
                    terminalConnection.DrawingOrder = 510;

                    // Add eventually cable running through inner conduit
                    if (_nodeContainerViewModel.Data.ConduitSegmentToCableChildRelations.ContainsKey(innerSpan.IngoingSegmentId))
                    {
                        var cableId             = _nodeContainerViewModel.Data.ConduitSegmentToCableChildRelations[innerSpan.IngoingSegmentId].First();
                        var fiberCableLineLabel = _nodeContainerViewModel.Data.GetCableEquipmentLineLabel(cableId);


                        var cableTerminalConnection = nodeContainerBlock.AddTerminalConnection(BlockSideEnum.West, 1, terminalNo, BlockSideEnum.East, 1, terminalNo, fiberCableLineLabel, "FiberCable", LineShapeTypeEnum.Line);
                        cableTerminalConnection.DrawingOrder = 600;
                        cableTerminalConnection.SetReference(cableId, "SpanSegment");
                    }
                }
                else
                {
                    // Add from terminal / ingoing segment to ends
                    AddToTerminalEnds(innerSpan.IngoingTerminalId, innerSpan.IngoingSpanSegment, fromTerminal, innerSpan.StyleName);

                    // Add to terminal / outgoing segment to ends
                    AddToTerminalEnds(innerSpan.OutgoingTerminalId, innerSpan.OutgoingSpanSegment, toTerminal, innerSpan.StyleName);
                }

                terminalNo++;
                innerSpansFound = true;
            }

            // Create fake inner terminals used to display where the empty multi conduit is heading
            if (!innerSpansFound)
            {
                var fromTerminal = new BlockPortTerminal(fromPort)
                {
                    IsVisible    = true,
                    ShapeType    = TerminalShapeTypeEnum.Point,
                    PointStyle   = fromSide.ToString() + "TerminalLabel",
                    PointLabel   = viewModel.GetIngoingRouteNodeName(spanDiagramInfo.IngoingSegmentId),
                    DrawingOrder = 520
                };

                fromTerminal.SetReference(spanDiagramInfo.IngoingSegmentId, "SpanSegment");

                var toTerminal = new BlockPortTerminal(toPort)
                {
                    IsVisible    = true,
                    ShapeType    = TerminalShapeTypeEnum.Point,
                    PointStyle   = toSide.ToString() + "TerminalLabel",
                    PointLabel   = viewModel.GetOutgoingRouteNodeName(spanDiagramInfo.IngoingSegmentId),
                    DrawingOrder = 520
                };

                toTerminal.SetReference(spanDiagramInfo.OutgoingSegmentId, "SpanSegment");

                terminalNo++;
            }
        }