private void CreateMapData()
        {
            mapDataCollection    = new MapDataCollection(FailureMechanism.Name);
            referenceLineMapData = RiskeerMapDataFactory.CreateReferenceLineMapData();
            hydraulicBoundaryLocationsMapLayer = new HydraulicBoundaryLocationsMapLayer(AssessmentSection);

            MapDataCollection sectionsMapDataCollection = RiskeerMapDataFactory.CreateSectionsMapDataCollection();

            sectionsMapData           = RiskeerMapDataFactory.CreateFailureMechanismSectionsMapData();
            sectionsStartPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsStartPointMapData();
            sectionsEndPointMapData   = RiskeerMapDataFactory.CreateFailureMechanismSectionsEndPointMapData();

            assemblyResultMapLayer = new NonCalculatableFailureMechanismSectionResultsMapLayer <TSectionResult>(
                FailureMechanism, performAssemblyFunc);

            mapDataCollection.Add(referenceLineMapData);

            sectionsMapDataCollection.Add(sectionsMapData);
            sectionsMapDataCollection.Add(sectionsStartPointMapData);
            sectionsMapDataCollection.Add(sectionsEndPointMapData);
            mapDataCollection.Add(sectionsMapDataCollection);

            mapDataCollection.Add(assemblyResultMapLayer.MapData);
            mapDataCollection.Add(hydraulicBoundaryLocationsMapLayer.MapData);
        }
Example #2
0
        /// <summary>
        /// Creates the map data.
        /// </summary>
        protected virtual void CreateMapData()
        {
            MapDataCollection            = new MapDataCollection(DuneErosionDataResources.DuneErosionFailureMechanism_DisplayName);
            referenceLineMapData         = RiskeerMapDataFactory.CreateReferenceLineMapData();
            duneErosionLocationsMapLayer = new DuneErosionLocationsMapLayer(FailureMechanism);

            MapDataCollection.Add(referenceLineMapData);
            MapDataCollection.Add(duneErosionLocationsMapLayer.MapData);
        }
Example #3
0
        /// <summary>
        /// Creates the map data.
        /// </summary>
        protected virtual void CreateMapData()
        {
            hydraulicBoundaryLocationsMapLayer = new HydraulicBoundaryLocationsMapLayer(AssessmentSection);
            MapDataCollection        = new MapDataCollection(WaveImpactAsphaltCoverDataResources.WaveImpactAsphaltCoverFailureMechanism_DisplayName);
            referenceLineMapData     = RiskeerMapDataFactory.CreateReferenceLineMapData();
            foreshoreProfilesMapData = RiskeerMapDataFactory.CreateForeshoreProfileMapData();
            calculationsMapData      = RiskeerMapDataFactory.CreateCalculationsMapData();

            MapDataCollection.Add(referenceLineMapData);
            MapDataCollection.Add(hydraulicBoundaryLocationsMapLayer.MapData);
            MapDataCollection.Add(foreshoreProfilesMapData);
            MapDataCollection.Add(calculationsMapData);
        }
Example #4
0
        public void IsVisible_WithAllChildrenVisibleTrue_ReturnsTrue()
        {
            // Setup
            var collection = new MapDataCollection("test");

            collection.Add(new TestMapData());
            collection.Add(new TestMapData());

            // Call
            bool isVisible = collection.IsVisible;

            // Assert
            Assert.IsTrue(isVisible);
        }
Example #5
0
        public void GetVisibility_AllChildrenVisibleTrue_ReturnVisible()
        {
            // Setup
            var collection = new MapDataCollection("test");

            collection.Add(new TestMapData());
            collection.Add(new TestMapData());

            // Call
            MapDataCollectionVisibility visibility = collection.GetVisibility();

            // Assert
            Assert.AreEqual(MapDataCollectionVisibility.Visible, visibility);
        }
        /// <summary>
        /// Creates the map data.
        /// </summary>
        protected virtual void CreateMapData()
        {
            hydraulicBoundaryLocationsMapLayer = new HydraulicBoundaryLocationsMapLayer(AssessmentSection);
            MapDataCollection           = new MapDataCollection(MacroStabilityInwardsDataResources.MacroStabilityInwardsFailureMechanism_DisplayName);
            referenceLineMapData        = RiskeerMapDataFactory.CreateReferenceLineMapData();
            stochasticSoilModelsMapData = RiskeerMapDataFactory.CreateStochasticSoilModelsMapData();
            surfaceLinesMapData         = RiskeerMapDataFactory.CreateSurfaceLinesMapData();
            calculationsMapData         = RiskeerMapDataFactory.CreateCalculationsMapData();

            MapDataCollection.Add(referenceLineMapData);
            MapDataCollection.Add(stochasticSoilModelsMapData);
            MapDataCollection.Add(surfaceLinesMapData);
            MapDataCollection.Add(hydraulicBoundaryLocationsMapLayer.MapData);
            MapDataCollection.Add(calculationsMapData);
        }
        public void OnNodeChecked_WithContext_NotifyObserversOfParentMapDataCollections()
        {
            // Setup
            var collectionObserver = mocks.StrictMock <IObserver>();

            collectionObserver.Expect(o => o.UpdateObserver());
            var parentCollectionObserver = mocks.StrictMock <IObserver>();

            parentCollectionObserver.Expect(o => o.UpdateObserver());
            mocks.ReplayAll();

            var featureBasedMapData     = new TestFeatureBasedMapData();
            var nestedMapDataCollection = new MapDataCollection("nested");

            nestedMapDataCollection.Add(featureBasedMapData);
            var mapDataCollection = new MapDataCollection("test");

            mapDataCollection.Add(nestedMapDataCollection);

            MapDataCollectionContext   rootCollectionContext      = GetContext(mapDataCollection);
            MapDataCollectionContext   nestedCollectionContext    = GetContext(nestedMapDataCollection, rootCollectionContext);
            FeatureBasedMapDataContext featureBasedMapDataContext = GetContext(featureBasedMapData, nestedCollectionContext);

            nestedMapDataCollection.Attach(collectionObserver);
            mapDataCollection.Attach(parentCollectionObserver);

            // Call
            info.OnNodeChecked(featureBasedMapDataContext, null);

            // Assert
            mocks.VerifyAll();
        }
Example #8
0
        public void GivenMapLegendView_WhenSelectedNodeChanged_SelectionChangedFired()
        {
            // Given
            var mapData           = new MapPointData("test");
            var mapDataCollection = new MapDataCollection("collection");

            mapDataCollection.Add(mapData);

            using (var view = new MapLegendView(contextMenuBuilderProvider)
            {
                Data = mapDataCollection
            })
            {
                var treeViewControl = TypeUtils.GetField <TreeViewControl>(view, "treeViewControl");
                WindowsFormsTestHelper.Show(treeViewControl);

                var selectionChangedCount = 0;
                view.SelectionChanged += (sender, args) => selectionChangedCount++;

                // When
                var context = new MapPointDataContext(mapData, new MapDataCollectionContext(mapDataCollection, null));
                treeViewControl.TrySelectNodeForData(context);

                // Then
                Assert.AreEqual(1, selectionChangedCount);
            }

            WindowsFormsTestHelper.CloseAll();
        }
        /// <summary>
        /// Creates the map data.
        /// </summary>
        protected virtual void CreateMapData()
        {
            hydraulicBoundaryLocationsMapLayer = new HydraulicBoundaryLocationsMapLayer(AssessmentSection);

            MapDataCollection        = new MapDataCollection(GrassCoverErosionInwardsDataResources.GrassCoverErosionInwardsFailureMechanism_DisplayName);
            referenceLineMapData     = RiskeerMapDataFactory.CreateReferenceLineMapData();
            dikeProfilesMapData      = RiskeerMapDataFactory.CreateDikeProfileMapData();
            foreshoreProfilesMapData = RiskeerMapDataFactory.CreateForeshoreProfileMapData();
            calculationsMapData      = RiskeerMapDataFactory.CreateCalculationsMapData();

            MapDataCollection.Add(referenceLineMapData);
            MapDataCollection.Add(hydraulicBoundaryLocationsMapLayer.MapData);
            MapDataCollection.Add(dikeProfilesMapData);
            MapDataCollection.Add(foreshoreProfilesMapData);
            MapDataCollection.Add(calculationsMapData);
        }
        public void ContextMenuStrip_EnabledZoomToAllContextMenuItemClicked_DoZoomToVisibleData()
        {
            // Setup
            var mapData             = new MapDataCollection("A");
            var featureBasedMapData = new TestFeatureBasedMapData
            {
                IsVisible = true,
                Features  = new[]
                {
                    new MapFeature(Enumerable.Empty <MapGeometry>())
                }
            };

            mapData.Add(featureBasedMapData);

            var builder = new CustomItemsOnlyContextMenuBuilder();

            contextMenuBuilderProvider.Stub(p => p.Get(null, null)).IgnoreArguments().Return(builder);
            var mapControl = mocks.StrictMock <IMapControl>();

            mapControl.Expect(c => c.Data).Return(mapData);
            mapControl.Expect(c => c.ZoomToVisibleLayers(mapData));
            mocks.ReplayAll();

            mapLegendView.MapControl = mapControl;

            using (ContextMenuStrip contextMenu = info.ContextMenuStrip(GetContext(mapData), null, null))
            {
                // Call
                contextMenu.Items[contextMenuZoomToAllIndex].PerformClick();

                // Assert
                // Assert expectancies are called in TearDown()
            }
        }
        public void ContextMenuStrip_VisibleFeatureBasedMapDataWithoutFeaturesInMapDataCollection_ZoomToAllItemDisabled()
        {
            // Setup
            var featureBasedMapData = new TestFeatureBasedMapData
            {
                IsVisible = true
            };
            var mapDataCollection = new MapDataCollection("test data");

            mapDataCollection.Add(featureBasedMapData);

            using (var treeViewControl = new TreeViewControl())
            {
                var builder = new CustomItemsOnlyContextMenuBuilder();
                contextMenuBuilderProvider.Expect(cmbp => cmbp.Get(null, null)).IgnoreArguments().Return(builder);
                mocks.ReplayAll();

                // Call
                using (ContextMenuStrip contextMenu = info.ContextMenuStrip(GetContext(mapDataCollection), null, treeViewControl))
                {
                    // Assert
                    TestHelper.AssertContextMenuStripContainsItem(contextMenu, contextMenuZoomToAllIndex,
                                                                  "&Zoom naar alles",
                                                                  "Om het zoomniveau aan te passen moet minstens één van de zichtbare kaartlagen in deze map met kaartlagen elementen bevatten.",
                                                                  Resources.ZoomToAllIcon,
                                                                  false);
                }
            }
        }
        public void ContextMenuStrip_VisibleFeatureBasedMapDataWithFeaturesInMapDataCollection_ZoomToAllItemEnabled()
        {
            // Setup
            var featureBasedMapData = new TestFeatureBasedMapData
            {
                IsVisible = true,
                Features  = new[]
                {
                    new MapFeature(Enumerable.Empty <MapGeometry>())
                }
            };

            var mapDataCollection = new MapDataCollection("test data");

            mapDataCollection.Add(featureBasedMapData);

            using (var treeViewControl = new TreeViewControl())
            {
                var builder = new CustomItemsOnlyContextMenuBuilder();
                contextMenuBuilderProvider.Expect(cmbp => cmbp.Get(null, null)).IgnoreArguments().Return(builder);
                mocks.ReplayAll();

                // Call
                using (ContextMenuStrip contextMenu = info.ContextMenuStrip(GetContext(mapDataCollection), null, treeViewControl))
                {
                    // Assert
                    TestHelper.AssertContextMenuStripContainsItem(contextMenu, contextMenuZoomToAllIndex,
                                                                  "&Zoom naar alles",
                                                                  "Zet het zoomniveau van de kaart dusdanig dat alle zichtbare kaartlagen in deze map met kaartlagen precies in het beeld passen.",
                                                                  Resources.ZoomToAllIcon);
                }
            }
        }
        public void GetNestedCollectionVisibilityStates_MapDataCollectionWithChildren_ReturnsDictionary()
        {
            // Setup
            var mapDataCollection = new MapDataCollection("test");
            var mapData1          = new TestFeatureBasedMapData();
            var mapData2          = new TestFeatureBasedMapData
            {
                IsVisible = false
            };
            var mapData3 = new TestFeatureBasedMapData
            {
                IsVisible = false
            };
            var nestedCollection = new MapDataCollection("nested");

            nestedCollection.Add(mapData3);

            mapDataCollection.Add(mapData1);
            mapDataCollection.Add(mapData2);
            mapDataCollection.Add(nestedCollection);

            // Call
            Dictionary <MapDataCollection, MapDataCollectionVisibility> states = MapDataCollectionHelper.GetNestedCollectionVisibilityStates(mapDataCollection);

            // Assert
            var expectedDictionary = new Dictionary <MapDataCollection, MapDataCollectionVisibility>
            {
                {
                    nestedCollection, MapDataCollectionVisibility.NotVisible
                }
            };

            CollectionAssert.AreEqual(expectedDictionary, states);
        }
        public void OnNodeChecked_WithContext_SetMapDataVisibilityAndNotifyObservers(bool initialVisibleState)
        {
            // Setup
            var collectionObserver = mocks.StrictMock <IObserver>();

            collectionObserver.Expect(o => o.UpdateObserver());
            mocks.ReplayAll();

            var featureBasedMapData = new TestFeatureBasedMapData();
            var mapDataCollection   = new MapDataCollection("test");

            mapDataCollection.Add(featureBasedMapData);

            MapDataCollectionContext context = GetContext(mapDataCollection);

            context.WrappedData.IsVisible = initialVisibleState;

            context.WrappedData.Attach(collectionObserver);

            // Call
            info.OnNodeChecked(context, null);

            // Assert
            Assert.AreEqual(!initialVisibleState, context.WrappedData.IsVisible);
            Assert.AreEqual(!initialVisibleState, featureBasedMapData.IsVisible);
            mocks.VerifyAll();
        }
        protected virtual void CreateMapData()
        {
            hydraulicBoundaryLocationsMapLayer = new HydraulicBoundaryLocationsMapLayer(AssessmentSection);

            MapDataCollection        = new MapDataCollection(StabilityPointStructuresDataResources.StabilityPointStructuresFailureMechanism_DisplayName);
            referenceLineMapData     = RiskeerMapDataFactory.CreateReferenceLineMapData();
            foreshoreProfilesMapData = RiskeerMapDataFactory.CreateForeshoreProfileMapData();
            calculationsMapData      = RiskeerMapDataFactory.CreateCalculationsMapData();
            structuresMapData        = RiskeerMapDataFactory.CreateStructuresMapData();

            MapDataCollection.Add(referenceLineMapData);
            MapDataCollection.Add(hydraulicBoundaryLocationsMapLayer.MapData);
            MapDataCollection.Add(foreshoreProfilesMapData);
            MapDataCollection.Add(structuresMapData);
            MapDataCollection.Add(calculationsMapData);
        }
Example #16
0
        public void Selection_Always_ReturnsDataContext()
        {
            // Setup
            var mapData           = new TestFeatureBasedMapData();
            var mapDataCollection = new MapDataCollection("collection");

            mapDataCollection.Add(mapData);

            using (var view = new MapLegendView(contextMenuBuilderProvider)
            {
                Data = mapDataCollection
            })
            {
                var treeViewControl = TypeUtils.GetField <TreeViewControl>(view, "treeViewControl");
                WindowsFormsTestHelper.Show(treeViewControl);
                treeViewControl.TrySelectNodeForData(view.Data);

                // Call
                var selection = (MapDataCollectionContext)view.Selection;

                // Assert
                Assert.AreSame(mapDataCollection, selection.WrappedData);
            }

            WindowsFormsTestHelper.CloseAll();
        }
Example #17
0
        public void GetVisibility_WithVisibleAndNotVisibleMapDataAsChildren_ReturnsMixed()
        {
            // Setup
            var collection = new MapDataCollection("test");

            collection.Add(new TestMapData());
            collection.Add(new TestMapData
            {
                IsVisible = false
            });

            // Call
            MapDataCollectionVisibility visibility = collection.GetVisibility();

            // Assert
            Assert.AreEqual(MapDataCollectionVisibility.Mixed, visibility);
        }
        /// <summary>
        /// Creates the map data.
        /// </summary>
        protected virtual void CreateMapData()
        {
            hydraulicBoundaryLocationsMapLayer = new HydraulicBoundaryLocationsMapLayer(AssessmentSection);

            MapDataCollection                    = new MapDataCollection(PipingDataResources.PipingFailureMechanism_DisplayName);
            referenceLineMapData                 = RiskeerMapDataFactory.CreateReferenceLineMapData();
            stochasticSoilModelsMapData          = RiskeerMapDataFactory.CreateStochasticSoilModelsMapData();
            surfaceLinesMapData                  = RiskeerMapDataFactory.CreateSurfaceLinesMapData();
            semiProbabilisticCalculationsMapData = PipingMapDataFactory.CreateSemiProbabilisticCalculationsMapData();
            probabilisticCalculationsMapData     = PipingMapDataFactory.CreateProbabilisticCalculationsMapData();

            MapDataCollection sectionsMapDataCollection = RiskeerMapDataFactory.CreateSectionsMapDataCollection();

            sectionsMapData           = RiskeerMapDataFactory.CreateFailureMechanismSectionsMapData();
            sectionsStartPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsStartPointMapData();
            sectionsEndPointMapData   = RiskeerMapDataFactory.CreateFailureMechanismSectionsEndPointMapData();

            MapDataCollection.Add(referenceLineMapData);
            MapDataCollection.Add(stochasticSoilModelsMapData);
            MapDataCollection.Add(surfaceLinesMapData);

            sectionsMapDataCollection.Add(sectionsMapData);
            sectionsMapDataCollection.Add(sectionsStartPointMapData);
            sectionsMapDataCollection.Add(sectionsEndPointMapData);
            MapDataCollection.Add(sectionsMapDataCollection);
            MapDataCollection.Add(hydraulicBoundaryLocationsMapLayer.MapData);
            MapDataCollection.Add(probabilisticCalculationsMapData);
            MapDataCollection.Add(semiProbabilisticCalculationsMapData);
        }
Example #19
0
        public void GetVisibility_WithVisibleMapDataAndEmptyCollectionAsChildren_ReturnsVisible()
        {
            // Setup
            var collection = new MapDataCollection("test");

            collection.Add(new TestMapData());
            var nestedCollection = new MapDataCollection("nested");

            collection.Add(nestedCollection);

            // Precondition
            Assert.AreEqual(MapDataCollectionVisibility.NotVisible, nestedCollection.GetVisibility());

            // Call
            MapDataCollectionVisibility visibility = collection.GetVisibility();

            // Assert
            Assert.AreEqual(MapDataCollectionVisibility.Visible, visibility);
        }
Example #20
0
        public void IsVisible_WithVisibleMapDataAndEmptyCollectionAsChildren_ReturnsTrue()
        {
            // Setup
            var collection = new MapDataCollection("test");

            collection.Add(new TestMapData());
            var nestedCollection = new MapDataCollection("nested");

            collection.Add(nestedCollection);

            // Precondition
            Assert.IsFalse(nestedCollection.IsVisible);

            // Call
            bool isVisible = collection.IsVisible;

            // Assert
            Assert.IsTrue(isVisible);
        }
Example #21
0
        public void Clear_Always_RemovesAllItems()
        {
            // Setup
            var item1             = new MapLineData("test");
            var item2             = new MapLineData("test");
            var mapDataCollection = new MapDataCollection("test");

            mapDataCollection.Add(item1);
            mapDataCollection.Add(item2);

            // Precondition
            Assert.AreEqual(2, mapDataCollection.Collection.Count());

            // Call
            mapDataCollection.Clear();

            // Assert
            CollectionAssert.IsEmpty(mapDataCollection.Collection);
        }
        protected override void CreateMapData()
        {
            base.CreateMapData();

            MapDataCollection sectionsMapDataCollection = RiskeerMapDataFactory.CreateSectionsMapDataCollection();

            sectionsMapData           = RiskeerMapDataFactory.CreateFailureMechanismSectionsMapData();
            sectionsStartPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsStartPointMapData();
            sectionsEndPointMapData   = RiskeerMapDataFactory.CreateFailureMechanismSectionsEndPointMapData();

            assemblyResultMapLayer = new NonCalculatableFailureMechanismSectionResultsMapLayer <NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
                FailureMechanism, sr => StabilityStoneCoverFailureMechanismAssemblyFactory.AssembleSection(sr, FailureMechanism, AssessmentSection).AssemblyResult);

            sectionsMapDataCollection.Add(sectionsMapData);
            sectionsMapDataCollection.Add(sectionsStartPointMapData);
            sectionsMapDataCollection.Add(sectionsEndPointMapData);
            MapDataCollection.Insert(1, sectionsMapDataCollection);

            MapDataCollection.Insert(2, assemblyResultMapLayer.MapData);
        }
        protected override void CreateMapData()
        {
            base.CreateMapData();

            MapDataCollection sectionsMapDataCollection = RiskeerMapDataFactory.CreateSectionsMapDataCollection();

            sectionsMapData           = RiskeerMapDataFactory.CreateFailureMechanismSectionsMapData();
            sectionsStartPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsStartPointMapData();
            sectionsEndPointMapData   = RiskeerMapDataFactory.CreateFailureMechanismSectionsEndPointMapData();

            assemblyResultsMapLayer = new CalculatableFailureMechanismSectionResultsMapLayer <ClosingStructuresFailureMechanism, AdoptableFailureMechanismSectionResult, ClosingStructuresInput>(
                FailureMechanism, sr => StructuresFailureMechanismAssemblyFactory.AssembleSection <ClosingStructuresInput>(sr, FailureMechanism, AssessmentSection).AssemblyResult);

            sectionsMapDataCollection.Add(sectionsMapData);
            sectionsMapDataCollection.Add(sectionsStartPointMapData);
            sectionsMapDataCollection.Add(sectionsEndPointMapData);
            MapDataCollection.Insert(1, sectionsMapDataCollection);

            MapDataCollection.Insert(2, assemblyResultsMapLayer.MapData);
        }
Example #24
0
        public void UpdateObserver_DataUpdated_MapLayersSameOrder()
        {
            // Setup
            var referenceLine = new ReferenceLine();

            referenceLine.SetGeometry(new[]
            {
                new Point2D(1.0, 2.0),
                new Point2D(2.0, 1.0)
            });

            var assessmentSection = new AssessmentSectionStub
            {
                ReferenceLine = referenceLine
            };

            assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
            {
                new HydraulicBoundaryLocation(1, "test1", 1.0, 2.0)
            });

            AssessmentSectionExtendedView extendedView = ShowCalculationsView(assessmentSection);
            MapDataCollection             mapData      = extendedView.Map.Data;

            MapData dataToMove = mapData.Collection.ElementAt(0);

            mapData.Remove(dataToMove);
            mapData.Add(dataToMove);

            // Precondition
            var referenceLineMapData = (MapLineData)mapData.Collection.ElementAt(referenceLineIndex + 1);

            Assert.AreEqual("Referentielijn", referenceLineMapData.Name);

            var hrLocationsMapData = (MapPointData)mapData.Collection.ElementAt(hydraulicBoundaryLocationsIndex - 1);

            Assert.AreEqual("Hydraulische belastingen", hrLocationsMapData.Name);

            // Call
            assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
            {
                new HydraulicBoundaryLocation(2, "test2", 2.0, 3.0)
            });
            assessmentSection.HydraulicBoundaryDatabase.Locations.NotifyObservers();

            // Assert
            var actualReferenceLineMapData = (MapLineData)mapData.Collection.ElementAt(referenceLineIndex + 1);

            Assert.AreEqual("Referentielijn", actualReferenceLineMapData.Name);

            var actualHrLocationsMapData = (MapPointData)mapData.Collection.ElementAt(hydraulicBoundaryLocationsIndex - 1);

            Assert.AreEqual("Hydraulische belastingen", actualHrLocationsMapData.Name);
        }
        protected override void CreateMapData()
        {
            base.CreateMapData();

            MapDataCollection sectionsMapDataCollection = RiskeerMapDataFactory.CreateSectionsMapDataCollection();

            sectionsMapData           = RiskeerMapDataFactory.CreateFailureMechanismSectionsMapData();
            sectionsStartPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsStartPointMapData();
            sectionsEndPointMapData   = RiskeerMapDataFactory.CreateFailureMechanismSectionsEndPointMapData();

            assemblyResultsMapLayer = new CalculatableFailureMechanismSectionResultsMapLayer <MacroStabilityInwardsFailureMechanism, AdoptableWithProfileProbabilityFailureMechanismSectionResult, MacroStabilityInwardsInput>(
                FailureMechanism, sr => MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleSection(sr, FailureMechanism, AssessmentSection).AssemblyResult);

            sectionsMapDataCollection.Add(sectionsMapData);
            sectionsMapDataCollection.Add(sectionsStartPointMapData);
            sectionsMapDataCollection.Add(sectionsEndPointMapData);
            MapDataCollection.Insert(3, sectionsMapDataCollection);

            MapDataCollection.Insert(4, assemblyResultsMapLayer.MapData);
        }
Example #26
0
        public void UpdateObserver_DataUpdated_MapLayersSameOrder()
        {
            // Setup
            const int updatedReferenceLineLayerIndex = referenceLineIndex + 1;
            const int updatedDuneLocationsLayerIndex = duneLocationsIndex - 1;

            var assessmentSection = new AssessmentSectionStub();
            var failureMechanism  = new DuneErosionFailureMechanism();

            DuneErosionFailureMechanismView view = CreateView(failureMechanism, assessmentSection);

            IMapControl map = ((RiskeerMapControl)view.Controls[0]).MapControl;

            MapDataCollection mapData = map.Data;

            var dataToMove = (MapLineData)map.Data.Collection.ElementAt(referenceLineIndex);

            mapData.Remove(dataToMove);
            mapData.Add(dataToMove);

            List <MapData> mapDataList = mapData.Collection.ToList();

            // Precondition
            var referenceLineData = (MapLineData)mapDataList[updatedReferenceLineLayerIndex];

            Assert.AreEqual("Referentielijn", referenceLineData.Name);

            var duneLocationsData = (MapPointData)mapDataList[updatedDuneLocationsLayerIndex];

            Assert.AreEqual("Hydraulische belastingen", duneLocationsData.Name);

            var points = new List <Point2D>
            {
                new Point2D(2.0, 5.0),
                new Point2D(4.0, 3.0)
            };
            var referenceLine = new ReferenceLine();

            referenceLine.SetGeometry(points);
            assessmentSection.ReferenceLine = referenceLine;

            // Call
            assessmentSection.NotifyObservers();

            // Assert
            var actualReferenceLineData = (MapLineData)mapDataList[updatedReferenceLineLayerIndex];

            Assert.AreEqual("Referentielijn", actualReferenceLineData.Name);

            var actualDuneLocationsData = (MapPointData)mapDataList[updatedDuneLocationsLayerIndex];

            Assert.AreEqual("Hydraulische belastingen", actualDuneLocationsData.Name);
        }
        public void CheckedState_WithContextAndMapDataCollectionVisibilityMixed_ReturnsStateMixed()
        {
            // Setup
            var featureBasedMapData1 = new TestFeatureBasedMapData();
            var featureBasedMapData2 = new TestFeatureBasedMapData
            {
                IsVisible = false
            };
            var mapDataCollection = new MapDataCollection("test");

            mapDataCollection.Add(featureBasedMapData1);
            mapDataCollection.Add(featureBasedMapData2);

            MapDataCollectionContext context = GetContext(mapDataCollection);

            // Call
            TreeNodeCheckedState checkedState = info.CheckedState(context);

            // Assert
            Assert.AreEqual(TreeNodeCheckedState.Mixed, checkedState);
        }
        public void OnNodeChecked_WithContext_NotifyObserversOfChangedChildrenOnly(bool initialVisibility, int expectedNotifications)
        {
            // Setup
            var observer = mocks.StrictMock <IObserver>();

            observer.Expect(o => o.UpdateObserver()).Repeat.Times(expectedNotifications);
            mocks.ReplayAll();

            var featureBasedMapData1 = new TestFeatureBasedMapData();
            var featureBasedMapData2 = new TestFeatureBasedMapData
            {
                IsVisible = initialVisibility
            };
            var featureBasedMapData3 = new TestFeatureBasedMapData
            {
                IsVisible = initialVisibility
            };
            var nestedMapDataCollection = new MapDataCollection("nested");

            nestedMapDataCollection.Add(featureBasedMapData1);
            nestedMapDataCollection.Add(featureBasedMapData3);

            var mapDataCollection = new MapDataCollection("test");

            mapDataCollection.Add(nestedMapDataCollection);
            mapDataCollection.Add(featureBasedMapData2);

            MapDataCollectionContext context = GetContext(mapDataCollection);

            nestedMapDataCollection.Attach(observer);
            featureBasedMapData1.Attach(observer);
            featureBasedMapData2.Attach(observer);
            featureBasedMapData3.Attach(observer);

            // Call
            info.OnNodeChecked(context, null);

            // Assert
            mocks.VerifyAll();
        }
Example #29
0
        public void GetVisibility_WithMixedCollectionAsChild_ReturnsMixed()
        {
            var nestedCollection = new MapDataCollection("test");

            nestedCollection.Add(new TestMapData());
            nestedCollection.Add(new TestMapData
            {
                IsVisible = false
            });
            var collection = new MapDataCollection("test");

            collection.Add(nestedCollection);

            // Precondition
            Assert.AreEqual(MapDataCollectionVisibility.Mixed, nestedCollection.GetVisibility());

            // Call
            MapDataCollectionVisibility visibility = collection.GetVisibility();

            // Assert
            Assert.AreEqual(MapDataCollectionVisibility.Mixed, visibility);
        }
Example #30
0
        public void Add_Null_ThrowsArgumentNullException()
        {
            // Setup
            var mapDataCollection = new MapDataCollection("test");

            // Call
            TestDelegate call = () => mapDataCollection.Add(null);

            // Assert
            const string expectedMessage = "An item cannot be null when adding it to the collection.";

            TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentNullException>(call, expectedMessage);
        }