Index: Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Forms/ChangeHandlers/ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationChangeHandler.cs
===================================================================
diff -u -rddad7117cf82255493a1a9f80b2c6562dc88bfd2 -r4d1f9c305a8d9854683ae67395694f72ce248f38
--- Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Forms/ChangeHandlers/ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationChangeHandler.cs	(.../ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationChangeHandler.cs)	(revision ddad7117cf82255493a1a9f80b2c6562dc88bfd2)
+++ Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Forms/ChangeHandlers/ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationChangeHandler.cs	(.../ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationChangeHandler.cs)	(revision 4d1f9c305a8d9854683ae67395694f72ce248f38)
@@ -20,6 +20,7 @@
 // All rights reserved.
 
 using System;
+using Core.Common.Gui.Commands;
 using Core.Common.Gui.Helpers;
 using Riskeer.Common.Forms.ChangeHandlers;
 using Riskeer.GrassCoverErosionInwards.Data;
@@ -38,20 +39,43 @@
         /// </summary>
         /// <param name="calculation">The calculation to clear the illustration points for.</param>
         /// <param name="inquiryHelper">Object responsible for inquiring confirmation.</param>
+        /// <param name="viewCommands">The view commands used to close views for the illustration points.</param>
         /// <exception cref="ArgumentNullException">Thrown when any argument is <c>null</c>.</exception>
         public ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationChangeHandler(
-            GrassCoverErosionInwardsCalculation calculation, IInquiryHelper inquiryHelper)
-            : base(calculation, inquiryHelper) {}
+            GrassCoverErosionInwardsCalculation calculation, IInquiryHelper inquiryHelper, IViewCommands viewCommands)
+            : base(calculation, inquiryHelper, viewCommands) {}
 
         public override bool ClearIllustrationPoints()
         {
             if (GrassCoverErosionInwardsIllustrationPointsHelper.HasIllustrationPoints(Calculation))
             {
+                CloseViews();
+
                 Calculation.ClearIllustrationPoints();
                 return true;
             }
 
             return false;
         }
+
+        private void CloseViews()
+        {
+            GrassCoverErosionInwardsOutput output = Calculation.Output;
+
+            if (GrassCoverErosionInwardsIllustrationPointsHelper.HasOverToppingIllustrationPoints(output))
+            {
+                ViewCommands.RemoveAllViewsForItem(output.OvertoppingOutput.GeneralResult);
+            }
+
+            if (GrassCoverErosionInwardsIllustrationPointsHelper.HasDikeHeightOutputWithIllustrationPoints(output))
+            {
+                ViewCommands.RemoveAllViewsForItem(output.DikeHeightOutput.GeneralResult);
+            }
+
+            if (GrassCoverErosionInwardsIllustrationPointsHelper.HasOverToppingRateOutputWithIllustrationPoints(output))
+            {
+                ViewCommands.RemoveAllViewsForItem(output.OvertoppingRateOutput.GeneralResult);
+            }
+        }
     }
 }
\ No newline at end of file
Index: Riskeer/GrassCoverErosionInwards/test/Riskeer.GrassCoverErosionInwards.Forms.Test/ChangeHandlers/ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationChangeHandlerTest.cs
===================================================================
diff -u -rddad7117cf82255493a1a9f80b2c6562dc88bfd2 -r4d1f9c305a8d9854683ae67395694f72ce248f38
--- Riskeer/GrassCoverErosionInwards/test/Riskeer.GrassCoverErosionInwards.Forms.Test/ChangeHandlers/ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationChangeHandlerTest.cs	(.../ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationChangeHandlerTest.cs)	(revision ddad7117cf82255493a1a9f80b2c6562dc88bfd2)
+++ Riskeer/GrassCoverErosionInwards/test/Riskeer.GrassCoverErosionInwards.Forms.Test/ChangeHandlers/ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationChangeHandlerTest.cs	(.../ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationChangeHandlerTest.cs)	(revision 4d1f9c305a8d9854683ae67395694f72ce248f38)
@@ -19,8 +19,7 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
-using System;
-using System.Collections.Generic;
+using Core.Common.Gui.Commands;
 using Core.Common.Gui.Helpers;
 using NUnit.Framework;
 using Rhino.Mocks;
@@ -29,91 +28,112 @@
 using Riskeer.GrassCoverErosionInwards.Data;
 using Riskeer.GrassCoverErosionInwards.Data.TestUtil;
 using Riskeer.GrassCoverErosionInwards.Forms.ChangeHandlers;
+using Riskeer.GrassCoverErosionInwards.Util;
 
 namespace Riskeer.GrassCoverErosionInwards.Forms.Test.ChangeHandlers
 {
     [TestFixture]
     public class ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationChangeHandlerTest
     {
         [Test]
-        public void Constructor_WithArguments_ExpectedValues()
+        public void Constructor_ExpectedValues()
         {
             // Setup
             var mocks = new MockRepository();
             var inquiryHelper = mocks.Stub<IInquiryHelper>();
+            var viewCommands = mocks.Stub<IViewCommands>();
             mocks.ReplayAll();
 
             var calculation = new GrassCoverErosionInwardsCalculation();
 
             // Call
-            var handler = new ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationChangeHandler(calculation, inquiryHelper);
+            var handler = new ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationChangeHandler(
+                calculation, inquiryHelper, viewCommands);
 
             // Assert
             Assert.IsInstanceOf<ClearIllustrationPointsOfCalculationChangeHandlerBase<GrassCoverErosionInwardsCalculation>>(handler);
             mocks.VerifyAll();
         }
 
         [Test]
-        [TestCaseSource(nameof(GetCalculationConfigurations))]
-        public void ClearIllustrationPoints_WithVariousCalculationConfigurations_ClearsIllustrationPointsAndReturnsExpectedResult(
-            GrassCoverErosionInwardsCalculation calculation,
-            bool expectedResult)
+        public void GivenCalculationWithoutOutput_WhenClearIllustrationPoints_ThenNothingHappensAndReturnFalse()
         {
-            // Setup
+            // Given
             var mocks = new MockRepository();
-            var inquiryHelper = mocks.StrictMock<IInquiryHelper>();
+            var inquiryHelper = mocks.Stub<IInquiryHelper>();
+            var viewCommands = mocks.StrictMock<IViewCommands>();
             mocks.ReplayAll();
 
-            var handler = new ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationChangeHandler(calculation, inquiryHelper);
+            var calculation = new GrassCoverErosionInwardsCalculation();
 
-            // Call
-            bool result = handler.ClearIllustrationPoints();
+            var handler = new ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationChangeHandler(
+                calculation, inquiryHelper, viewCommands);
 
-            // Assert
-            Assert.AreEqual(expectedResult, result);
+            // When
+            bool isCalculationAffected = handler.ClearIllustrationPoints();
 
-            Assert.IsNull(calculation.Output?.OvertoppingOutput.GeneralResult);
-            Assert.IsNull(calculation.Output?.OvertoppingRateOutput?.GeneralResult);
-            Assert.IsNull(calculation.Output?.DikeHeightOutput?.GeneralResult);
+            // Then
+            Assert.IsFalse(isCalculationAffected);
+            Assert.IsFalse(calculation.HasOutput);
+            Assert.IsFalse(GrassCoverErosionInwardsIllustrationPointsHelper.HasIllustrationPoints(calculation));
             mocks.VerifyAll();
         }
 
-        private static IEnumerable<TestCaseData> GetCalculationConfigurations()
+        [Test]
+        [Combinatorial]
+        public void ClearIllustrationPoints_WithVariousCalculationConfigurations_ClearsIllustrationPointsAndReturnsExpectedResult(
+            [Values(true, false)] bool hasOvertoppingIllustrationPoints,
+            [Values(true, false)] bool hasDikeHeightIllustrationPoints,
+            [Values(true, false)] bool hasOvertoppingRateIllustrationPoints)
         {
-            var random = new Random(21);
-            var calculationWithOverToppingOutputWithIllustrationPoints = new GrassCoverErosionInwardsCalculation
+            // Setup
+            var calculation = new GrassCoverErosionInwardsCalculation
             {
-                Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(new TestGeneralResultFaultTreeIllustrationPoint()),
-                                                            null,
-                                                            null)
+                Output = new GrassCoverErosionInwardsOutput(
+                    new TestOvertoppingOutput(hasOvertoppingIllustrationPoints
+                                                  ? new TestGeneralResultFaultTreeIllustrationPoint()
+                                                  : null),
+                    new TestDikeHeightOutput(hasDikeHeightIllustrationPoints
+                                                 ? new TestGeneralResultFaultTreeIllustrationPoint()
+                                                 : null),
+                    new TestOvertoppingRateOutput(hasOvertoppingRateIllustrationPoints
+                                                      ? new TestGeneralResultFaultTreeIllustrationPoint()
+                                                      : null))
             };
 
-            var calculationWithDikeHeightRateWithIllustrationPoints = new GrassCoverErosionInwardsCalculation
+            var mocks = new MockRepository();
+            var inquiryHelper = mocks.Stub<IInquiryHelper>();
+            var viewCommands = mocks.StrictMock<IViewCommands>();
+
+            if (hasOvertoppingIllustrationPoints)
             {
-                Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(random.NextDouble()),
-                                                            new TestDikeHeightOutput(new TestGeneralResultFaultTreeIllustrationPoint()),
-                                                            null)
-            };
+                viewCommands.Expect(vc => vc.RemoveAllViewsForItem(calculation.Output.OvertoppingOutput.GeneralResult));
+            }
 
-            var calculationWithOvertoppingRateWithIllustrationPoints = new GrassCoverErosionInwardsCalculation
+            if (hasDikeHeightIllustrationPoints)
             {
-                Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(random.NextDouble()),
-                                                            null,
-                                                            new TestOvertoppingRateOutput(new TestGeneralResultFaultTreeIllustrationPoint()))
-            };
+                viewCommands.Expect(vc => vc.RemoveAllViewsForItem(calculation.Output.DikeHeightOutput.GeneralResult));
+            }
 
-            var calculationWitNoIllustrationPoints = new GrassCoverErosionInwardsCalculation
+            if (hasOvertoppingRateIllustrationPoints)
             {
-                Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(random.NextDouble()),
-                                                            null,
-                                                            null)
-            };
+                viewCommands.Expect(vc => vc.RemoveAllViewsForItem(calculation.Output.OvertoppingRateOutput.GeneralResult));
+            }
+            mocks.ReplayAll();
 
-            yield return new TestCaseData(calculationWithOverToppingOutputWithIllustrationPoints, true);
-            yield return new TestCaseData(calculationWithDikeHeightRateWithIllustrationPoints, true);
-            yield return new TestCaseData(calculationWithOvertoppingRateWithIllustrationPoints, true);
-            yield return new TestCaseData(calculationWitNoIllustrationPoints, false);
-            yield return new TestCaseData(new GrassCoverErosionInwardsCalculation(), false);
+            var handler = new ClearIllustrationPointsOfGrassCoverErosionInwardsCalculationChangeHandler(calculation, inquiryHelper, viewCommands);
+
+            // Call
+            bool isCalculationAffected = handler.ClearIllustrationPoints();
+
+            // Assert
+            bool expectedResult = hasOvertoppingIllustrationPoints || hasDikeHeightIllustrationPoints || hasOvertoppingRateIllustrationPoints;
+            Assert.AreEqual(expectedResult, isCalculationAffected);
+            Assert.IsTrue(calculation.HasOutput);
+            Assert.IsNull(calculation.Output.OvertoppingOutput.GeneralResult);
+            Assert.IsNull(calculation.Output.OvertoppingRateOutput.GeneralResult);
+            Assert.IsNull(calculation.Output.DikeHeightOutput.GeneralResult);
+            mocks.VerifyAll();
         }
     }
 }
\ No newline at end of file