Index: Ringtoets/Common/src/Ringtoets.Common.Forms/TreeNodeInfos/RingtoetsContextMenuBuilder.cs
===================================================================
diff -u -re13aad684439fe0ce56760077b13a7c5b03674de -re2991a38a1982398a6cbb35e38e534e26ba8930d
--- Ringtoets/Common/src/Ringtoets.Common.Forms/TreeNodeInfos/RingtoetsContextMenuBuilder.cs	(.../RingtoetsContextMenuBuilder.cs)	(revision e13aad684439fe0ce56760077b13a7c5b03674de)
+++ Ringtoets/Common/src/Ringtoets.Common.Forms/TreeNodeInfos/RingtoetsContextMenuBuilder.cs	(.../RingtoetsContextMenuBuilder.cs)	(revision e2991a38a1982398a6cbb35e38e534e26ba8930d)
@@ -19,17 +19,22 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
+using System;
 using System.Windows.Forms;
 using Core.Common.Gui.ContextMenu;
+using Ringtoets.Common.Data.Calculation;
+using Ringtoets.Common.Data.FailureMechanism;
+using Ringtoets.Common.Forms.PresentationObjects;
 
 namespace Ringtoets.Common.Forms.TreeNodeInfos
 {
     /// <summary>
     /// Decorator for <see cref="ContextMenuBuilder"/>.
     /// </summary>
-    public class RingtoetsContextMenuBuilder : IContextMenuBuilder
+    public class RingtoetsContextMenuBuilder
     {
         private readonly IContextMenuBuilder contextMenuBuilder;
+        private readonly RingtoetsContextMenuItemFactory ringtoetsContextMenuItemFactory;
 
         /// <summary>
         /// Creates a new instance of the <see cref="RingtoetsContextMenuBuilder"/>.
@@ -38,61 +43,131 @@
         public RingtoetsContextMenuBuilder(IContextMenuBuilder contextMenuBuilder)
         {
             this.contextMenuBuilder = contextMenuBuilder;
+
+            ringtoetsContextMenuItemFactory = new RingtoetsContextMenuItemFactory();
         }
 
-        public IContextMenuBuilder AddRenameItem()
+        public RingtoetsContextMenuBuilder AddCreateCalculationGroupItem(CalculationGroup calculationGroup)
         {
-            return contextMenuBuilder.AddRenameItem();
+            contextMenuBuilder.AddCustomItem(ringtoetsContextMenuItemFactory.CreateAddCalculationGroupItem(calculationGroup));
+            return this;
         }
 
-        public IContextMenuBuilder AddDeleteItem()
+        public RingtoetsContextMenuBuilder AddCreateCalculationItem<TCalculationContext>(
+            TCalculationContext calculationGroupContext,
+            Action<TCalculationContext> addCalculation)
+            where TCalculationContext : ICalculationContext<CalculationGroup, IFailureMechanism>
         {
-            return contextMenuBuilder.AddDeleteItem();
+            contextMenuBuilder.AddCustomItem(ringtoetsContextMenuItemFactory.CreateAddCalculationItem(calculationGroupContext, addCalculation));
+            return this;
         }
 
-        public IContextMenuBuilder AddExpandAllItem()
+        public RingtoetsContextMenuBuilder AddClearAllCalculationOutputInGroupItem(CalculationGroup calculationGroup)
         {
-            return contextMenuBuilder.AddExpandAllItem();
+            contextMenuBuilder.AddCustomItem(ringtoetsContextMenuItemFactory.CreateClearAllCalculationOutputInGroupItem(calculationGroup));
+            return this;
         }
 
-        public IContextMenuBuilder AddCollapseAllItem()
+        public RingtoetsContextMenuBuilder AddPerformAllCalculationsInGroupItem<TCalculationContext>(
+            CalculationGroup calculationGroup,
+            TCalculationContext context,
+            Action<CalculationGroup, TCalculationContext> calculateAll)
+            where TCalculationContext : ICalculationContext<CalculationGroup, IFailureMechanism>
         {
-            return contextMenuBuilder.AddCollapseAllItem();
+            contextMenuBuilder.AddCustomItem(ringtoetsContextMenuItemFactory.CreatePerformAllCalculationsInGroupItem(calculationGroup, context, calculateAll));
+            return this;
         }
 
-        public IContextMenuBuilder AddOpenItem()
+        public RingtoetsContextMenuBuilder AddPerformCalculationItem<TCalculation, TCalculationContext>(
+            TCalculation calculation,
+            TCalculationContext context,
+            Action<TCalculation, TCalculationContext> calculate)
+            where TCalculationContext : ICalculationContext<TCalculation, IFailureMechanism>
+            where TCalculation : ICalculation
         {
-            return contextMenuBuilder.AddOpenItem();
+            contextMenuBuilder.AddCustomItem(ringtoetsContextMenuItemFactory.CreatePerformCalculationItem(calculation, context, calculate));
+            return this;
         }
 
-        public IContextMenuBuilder AddExportItem()
+        public RingtoetsContextMenuBuilder AddClearCalculationOutputItem(ICalculation calculation)
         {
-            return contextMenuBuilder.AddExportItem();
+            contextMenuBuilder.AddCustomItem(ringtoetsContextMenuItemFactory.CreateClearCalculationOutputItem(calculation));
+            return this;
         }
 
-        public IContextMenuBuilder AddImportItem()
+        public RingtoetsContextMenuBuilder AddDisabledChangeRelevancyItem(IFailureMechanismContext<IFailureMechanism> failureMechanismContext)
         {
-            return contextMenuBuilder.AddImportItem();
+            contextMenuBuilder.AddCustomItem(ringtoetsContextMenuItemFactory.CreateDisabledChangeRelevancyItem(failureMechanismContext));
+            return this;
         }
 
-        public IContextMenuBuilder AddPropertiesItem()
+        # region Decorated interface members
+
+        public RingtoetsContextMenuBuilder AddRenameItem()
         {
-            return contextMenuBuilder.AddPropertiesItem();
+            contextMenuBuilder.AddRenameItem();
+            return this;
         }
 
-        public IContextMenuBuilder AddSeparator()
+        public RingtoetsContextMenuBuilder AddDeleteItem()
         {
-            return contextMenuBuilder.AddSeparator();
+            contextMenuBuilder.AddDeleteItem();
+            return this;
         }
 
-        public IContextMenuBuilder AddCustomItem(StrictContextMenuItem item)
+        public RingtoetsContextMenuBuilder AddExpandAllItem()
         {
-            return contextMenuBuilder.AddCustomItem(item);
+            contextMenuBuilder.AddExpandAllItem();
+            return this;
         }
 
+        public RingtoetsContextMenuBuilder AddCollapseAllItem()
+        {
+            contextMenuBuilder.AddCollapseAllItem();
+            return this;
+        }
+
+        public RingtoetsContextMenuBuilder AddOpenItem()
+        {
+            contextMenuBuilder.AddOpenItem();
+            return this;
+        }
+
+        public RingtoetsContextMenuBuilder AddExportItem()
+        {
+            contextMenuBuilder.AddExportItem();
+            return this;
+        }
+
+        public RingtoetsContextMenuBuilder AddImportItem()
+        {
+            contextMenuBuilder.AddImportItem();
+            return this;
+        }
+
+        public RingtoetsContextMenuBuilder AddPropertiesItem()
+        {
+            contextMenuBuilder.AddPropertiesItem();
+            return this;
+        }
+
+        public RingtoetsContextMenuBuilder AddSeparator()
+        {
+            contextMenuBuilder.AddSeparator();
+            return this;
+        }
+
+        public RingtoetsContextMenuBuilder AddCustomItem(StrictContextMenuItem item)
+        {
+            contextMenuBuilder.AddCustomItem(item);
+            return this;
+        }
+
         public ContextMenuStrip Build()
         {
             return contextMenuBuilder.Build();
         }
+
+        # endregion
     }
 }
Index: Ringtoets/Common/src/Ringtoets.Common.Forms/TreeNodeInfos/RingtoetsContextMenuItemFactory.cs
===================================================================
diff -u -r36b6f1f7c1ddf585689512eb61256d41a1e0ca64 -re2991a38a1982398a6cbb35e38e534e26ba8930d
--- Ringtoets/Common/src/Ringtoets.Common.Forms/TreeNodeInfos/RingtoetsContextMenuItemFactory.cs	(.../RingtoetsContextMenuItemFactory.cs)	(revision 36b6f1f7c1ddf585689512eb61256d41a1e0ca64)
+++ Ringtoets/Common/src/Ringtoets.Common.Forms/TreeNodeInfos/RingtoetsContextMenuItemFactory.cs	(.../RingtoetsContextMenuItemFactory.cs)	(revision e2991a38a1982398a6cbb35e38e534e26ba8930d)
@@ -36,48 +36,46 @@
     /// <summary>
     /// This class represents a factory for creating <see cref="ToolStripItem"/>.
     /// </summary>
-    public static class RingtoetsContextMenuItemFactory
+    public class RingtoetsContextMenuItemFactory
     {
         /// <summary>
-        /// This method adds a context menu item for creating new calculation groups.
+        /// Creates a <see cref="StrictContextMenuItem"/> which is bound to the action of adding new calculation groups.
         /// </summary>
-        /// <param name="builder">The builder to add the context menu item to.</param>
         /// <param name="calculationGroup">The calculation group involved.</param>
-        public static void AddCreateCalculationGroupItem(IContextMenuBuilder builder, CalculationGroup calculationGroup)
+        /// <returns>The created <see cref="StrictContextMenuItem"/>.</returns>
+        public StrictContextMenuItem CreateAddCalculationGroupItem(CalculationGroup calculationGroup)
         {
-            var createCalculationGroupItem = new StrictContextMenuItem(
+            return new StrictContextMenuItem(
                 Resources.CalculationGroup_Add_CalculationGroup,
                 Resources.CalculationGroup_Add_CalculationGroup_Tooltip,
                 Resources.AddFolderIcon,
                 (o, args) => CreateCalculationGroup(calculationGroup));
-
-            builder.AddCustomItem(createCalculationGroupItem);
         }
 
         /// <summary>
-        /// This method adds a context menu item for creating new calculations.
+        /// Creates a <see cref="StrictContextMenuItem"/> which is bound to the action of adding new calculations.
         /// </summary>
-        /// <param name="builder">The builder to add the context menu item to.</param>
         /// <param name="calculationGroupContext">The calculation group context involved.</param>
         /// <param name="addCalculation">The action for adding a calculation to the calculation group.</param>
-        public static void AddCreateCalculationItem<TCalculationGroupContext>(IContextMenuBuilder builder, TCalculationGroupContext calculationGroupContext, Action<TCalculationGroupContext> addCalculation)
-            where TCalculationGroupContext : ICalculationContext<CalculationGroup, IFailureMechanism>
+        /// <returns>The created <see cref="StrictContextMenuItem"/>.</returns>
+        public StrictContextMenuItem CreateAddCalculationItem<TCalculationContext>(
+            TCalculationContext calculationGroupContext,
+            Action<TCalculationContext> addCalculation)
+            where TCalculationContext : ICalculationContext<CalculationGroup, IFailureMechanism>
         {
-            var createCalculationItem = new StrictContextMenuItem(
+            return new StrictContextMenuItem(
                 Resources.CalculationGroup_Add_Calculation,
                 Resources.CalculationGroup_Add_Calculation_Tooltip,
                 Resources.FailureMechanismIcon,
                 (o, args) => addCalculation(calculationGroupContext));
-
-            builder.AddCustomItem(createCalculationItem);
         }
 
         /// <summary>
-        /// This method adds a context menu item for clearing the output of all calculations in the calculation group.
+        /// Creates a <see cref="StrictContextMenuItem"/> which is bound to the action of clearing the output of all calculations in the calculation group.
         /// </summary>
-        /// <param name="builder">The builder to add the context menu item to.</param>
         /// <param name="calculationGroup">The calculation group involved.</param>
-        public static void AddClearAllCalculationOutputInGroupItem(IContextMenuBuilder builder, CalculationGroup calculationGroup)
+        /// <returns>The created <see cref="StrictContextMenuItem"/>.</returns>
+        public StrictContextMenuItem CreateClearAllCalculationOutputInGroupItem(CalculationGroup calculationGroup)
         {
             var clearAllItem = new StrictContextMenuItem(
                 Resources.Clear_all_output,
@@ -91,19 +89,21 @@
                 clearAllItem.ToolTipText = Resources.CalculationGroup_ClearOutput_No_calculation_with_output_to_clear;
             }
 
-            builder.AddCustomItem(clearAllItem);
+            return clearAllItem;
         }
 
         /// <summary>
-        /// This method adds a context menu item for performing all calculations in the calculation group.
+        /// Creates a <see cref="StrictContextMenuItem"/> which is bound to the action of performing all calculations in a calculation group.
         /// </summary>
-        /// <param name="builder">The builder to add the context menu item to.</param>
         /// <param name="calculationGroup">The calculation group involved.</param>
         /// <param name="context">The calculation group context belonging to the calculation group.</param>
         /// <param name="calculateAll">The action that performs all calculations.</param>
-        public static void AddPerformAllCalculationsInGroupItem<TCalculationGroupContext>
-            (IContextMenuBuilder builder, CalculationGroup calculationGroup, TCalculationGroupContext context, Action<CalculationGroup, TCalculationGroupContext> calculateAll)
-            where TCalculationGroupContext : ICalculationContext<CalculationGroup, IFailureMechanism>
+        /// <returns>The created <see cref="StrictContextMenuItem"/>.</returns>
+        public StrictContextMenuItem CreatePerformAllCalculationsInGroupItem<TCalculationContext>(
+            CalculationGroup calculationGroup,
+            TCalculationContext context,
+            Action<CalculationGroup, TCalculationContext> calculateAll)
+            where TCalculationContext : ICalculationContext<CalculationGroup, IFailureMechanism>
         {
             var performAllItem = new StrictContextMenuItem(
                 Resources.Calculate_all,
@@ -117,36 +117,36 @@
                 performAllItem.ToolTipText = Resources.CalculationGroup_CalculateAll_No_calculations_to_run;
             }
 
-            builder.AddCustomItem(performAllItem);
+            return performAllItem;
         }
 
         /// <summary>
-        /// This method adds a context menu item for performing a calculation.
+        /// Creates a <see cref="StrictContextMenuItem"/> which is bound to the action of performing a calculation.
         /// </summary>
-        /// <param name="builder">The builder to add the context menu item to.</param>
         /// <param name="calculation">The calculation involved.</param>
         /// <param name="context">The calculation context belonging to the calculation.</param>
         /// <param name="calculate">The action that performs the calculation.</param>
-        public static void AddPerformCalculationItem<TCalculation, TCalculationContext>(
-            IContextMenuBuilder builder, TCalculation calculation, TCalculationContext context, Action<TCalculation, TCalculationContext> calculate)
+        /// <returns>The created <see cref="StrictContextMenuItem"/>.</returns>
+        public StrictContextMenuItem CreatePerformCalculationItem<TCalculation, TCalculationContext>(
+            TCalculation calculation,
+            TCalculationContext context,
+            Action<TCalculation, TCalculationContext> calculate)
+            where TCalculationContext : ICalculationContext<TCalculation, IFailureMechanism>
             where TCalculation : ICalculation
-            where TCalculationContext : ICalculationContext<ICalculation, IFailureMechanism>
         {
-            var calculateItem = new StrictContextMenuItem(
+            return new StrictContextMenuItem(
                 Resources.Calculate,
                 Resources.Calculate_ToolTip,
                 Resources.CalculateIcon,
                 (o, args) => calculate(calculation, context));
-
-            builder.AddCustomItem(calculateItem);
         }
 
         /// <summary>
-        /// This method adds a context menu item for clearing the output of a calculation.
+        /// Creates a <see cref="StrictContextMenuItem"/> which is bound to the action of clearing the output of a calculation.
         /// </summary>
-        /// <param name="builder">The builder to add the context menu item to.</param>
         /// <param name="calculation">The calculation involved.</param>
-        public static void AddClearCalculationOutputItem(IContextMenuBuilder builder, ICalculation calculation)
+        /// <returns>The created <see cref="StrictContextMenuItem"/>.</returns>
+        public StrictContextMenuItem CreateClearCalculationOutputItem(ICalculation calculation)
         {
             var clearOutputItem = new StrictContextMenuItem(
                 Resources.Clear_output,
@@ -160,18 +160,17 @@
                 clearOutputItem.ToolTipText = Resources.ClearOutput_No_output_to_clear;
             }
 
-            builder.AddCustomItem(clearOutputItem);
+            return clearOutputItem;
         }
 
         /// <summary>
-        /// This method adds a context menu item for changing the relevancy state of a disabled failure mechanism.
+        /// Creates a <see cref="StrictContextMenuItem"/> which is bound to the action of changing the relevancy state of a disabled failure mechanism.
         /// </summary>
-        /// <param name="builder">The builder to add the context menu item to.</param>
         /// <param name="failureMechanismContext">The failure mechanism context involved.</param>
-        public static void AddDisabledChangeRelevancyItem<TFailureMechanismContext>(IContextMenuBuilder builder, TFailureMechanismContext failureMechanismContext)
-            where TFailureMechanismContext : IFailureMechanismContext<IFailureMechanism>
+        /// <returns>The created <see cref="StrictContextMenuItem"/>.</returns>
+        public StrictContextMenuItem CreateDisabledChangeRelevancyItem(IFailureMechanismContext<IFailureMechanism> failureMechanismContext)
         {
-            var changeRelevancyItem = new StrictContextMenuItem(
+            return new StrictContextMenuItem(
                 Resources.FailureMechanismContextMenuStrip_Is_relevant,
                 Resources.FailureMechanismContextMenuStrip_Is_relevant_Tooltip,
                 Resources.Checkbox_empty,
@@ -180,8 +179,6 @@
                     failureMechanismContext.WrappedData.IsRelevant = true;
                     failureMechanismContext.WrappedData.NotifyObservers();
                 });
-
-            builder.AddCustomItem(changeRelevancyItem);
         }
 
         private static void CreateCalculationGroup(CalculationGroup calculationGroup)
Index: Ringtoets/Common/test/Ringtoets.Common.Forms.Test/TreeNodeInfos/RingtoetsContextMenuItemFactoryTest.cs
===================================================================
diff -u -r0a94ed42cb943659d68be2ce6fb430f8f29fc3f3 -re2991a38a1982398a6cbb35e38e534e26ba8930d
--- Ringtoets/Common/test/Ringtoets.Common.Forms.Test/TreeNodeInfos/RingtoetsContextMenuItemFactoryTest.cs	(.../RingtoetsContextMenuItemFactoryTest.cs)	(revision 0a94ed42cb943659d68be2ce6fb430f8f29fc3f3)
+++ Ringtoets/Common/test/Ringtoets.Common.Forms.Test/TreeNodeInfos/RingtoetsContextMenuItemFactoryTest.cs	(.../RingtoetsContextMenuItemFactoryTest.cs)	(revision e2991a38a1982398a6cbb35e38e534e26ba8930d)
@@ -20,9 +20,6 @@
 // All rights reserved.
 
 using Core.Common.Base;
-using Core.Common.Controls.TreeView;
-using Core.Common.Gui.Commands;
-using Core.Common.Gui.ContextMenu;
 using Core.Common.TestUtil;
 using NUnit.Extensions.Forms;
 using NUnit.Framework;
@@ -39,120 +36,96 @@
     [TestFixture]
     public class RingtoetsContextMenuItemFactoryTest : NUnitFormTest
     {
+        private RingtoetsContextMenuItemFactory factory;
+
+        [TestFixtureSetUp]
+        public void TestFixtureSetUp()
+        {
+            factory = new RingtoetsContextMenuItemFactory();
+        }
+
         [Test]
-        public void AddCreateCalculationGroupItem_Always_CreatesDecoratedCalculationGroupItem()
+        public void CreateAddCalculationGroupItem_Always_CreatesDecoratedItem()
         {
             // Setup
-            var mocks = new MockRepository();
-            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
-            var exportImportHandler = mocks.Stub<IExportImportCommandHandler>();
-            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
-            var treeViewControl = mocks.StrictMock<TreeViewControl>();
-
-            mocks.ReplayAll();
-
             var calculationGroup = new CalculationGroup();
-            var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler, exportImportHandler, viewCommandsHandler, calculationGroup, treeViewControl);
 
             // Call
-            RingtoetsContextMenuItemFactory.AddCreateCalculationGroupItem(menuBuilder, calculationGroup);
+            var toolStripItem = factory.CreateAddCalculationGroupItem(calculationGroup);
 
             // Assert
-            TestHelper.AssertContextMenuStripContainsItem(menuBuilder.Build(), 0,
-                                                          RingtoetsFormsResources.CalculationGroup_Add_CalculationGroup,
-                                                          RingtoetsFormsResources.CalculationGroup_Add_CalculationGroup_Tooltip,
-                                                          RingtoetsFormsResources.AddFolderIcon);
+            Assert.AreEqual(RingtoetsFormsResources.CalculationGroup_Add_CalculationGroup, toolStripItem.Text);
+            Assert.AreEqual(RingtoetsFormsResources.CalculationGroup_Add_CalculationGroup_Tooltip, toolStripItem.ToolTipText);
+            TestHelper.AssertImagesAreEqual(RingtoetsFormsResources.AddFolderIcon, toolStripItem.Image);
+            Assert.IsTrue(toolStripItem.Enabled);
         }
 
         [Test]
-        public void AddCreateCalculationGroupItem_PerformClickOnCreatedItem_CalculationGroupAdded()
+        public void CreateAddCalculationGroupItem_PerformClickOnCreatedItem_CalculationGroupAdded()
         {
             // Setup
-            var mocks = new MockRepository();
-            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
-            var exportImportHandler = mocks.Stub<IExportImportCommandHandler>();
-            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
-            var treeViewControl = mocks.StrictMock<TreeViewControl>();
-
-            mocks.ReplayAll();
-
             var calculationGroup = new CalculationGroup();
-            var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler, exportImportHandler, viewCommandsHandler, calculationGroup, treeViewControl);
-            RingtoetsContextMenuItemFactory.AddCreateCalculationGroupItem(menuBuilder, calculationGroup);
-            var contextMenuItem = menuBuilder.Build().Items[0];
+            var toolStripItem = factory.CreateAddCalculationGroupItem(calculationGroup);
 
             // Call
-            contextMenuItem.PerformClick();
+            toolStripItem.PerformClick();
 
             // Assert
             Assert.AreEqual(1, calculationGroup.Children.Count);
             Assert.IsTrue(calculationGroup.Children[0] is CalculationGroup);
         }
 
         [Test]
-        public void AddCreateCalculationItem_Always_CreatesDecoratedCalculationItem()
+        public void CreateAddCalculationItem_Always_CreatesDecoratedItem()
         {
             // Setup
             var mocks = new MockRepository();
             var failureMechanism = mocks.Stub<IFailureMechanism>();
-            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
-            var exportImportHandler = mocks.Stub<IExportImportCommandHandler>();
-            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
-            var treeViewControl = mocks.StrictMock<TreeViewControl>();
 
             mocks.ReplayAll();
 
             var calculationGroup = new CalculationGroup();
             var calculationGroupContext = new TestCalculationGroupContext(calculationGroup, failureMechanism);
-            var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler, exportImportHandler, viewCommandsHandler, calculationGroup, treeViewControl);
 
             // Call
-            RingtoetsContextMenuItemFactory.AddCreateCalculationItem(menuBuilder, calculationGroupContext, null);
+            var toolStripItem = factory.CreateAddCalculationItem(calculationGroupContext, context => { });
 
             // Assert
-            TestHelper.AssertContextMenuStripContainsItem(menuBuilder.Build(), 0,
-                                                          RingtoetsFormsResources.CalculationGroup_Add_Calculation,
-                                                          RingtoetsFormsResources.CalculationGroup_Add_Calculation_Tooltip,
-                                                          RingtoetsFormsResources.FailureMechanismIcon);
+            Assert.AreEqual(RingtoetsFormsResources.CalculationGroup_Add_Calculation, toolStripItem.Text);
+            Assert.AreEqual(RingtoetsFormsResources.CalculationGroup_Add_Calculation_Tooltip, toolStripItem.ToolTipText);
+            TestHelper.AssertImagesAreEqual(RingtoetsFormsResources.FailureMechanismIcon, toolStripItem.Image);
+            Assert.IsTrue(toolStripItem.Enabled);
+
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void AddCreateCalculationItem_PerformClickOnCreatedItem_AddCalculationMethodPerformed()
+        public void CreateAddCalculationItem_PerformClickOnCreatedItem_AddCalculationMethodPerformed()
         {
             // Setup
             var mocks = new MockRepository();
             var failureMechanism = mocks.Stub<IFailureMechanism>();
-            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
-            var exportImportHandler = mocks.Stub<IExportImportCommandHandler>();
-            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
-            var treeViewControl = mocks.StrictMock<TreeViewControl>();
 
             mocks.ReplayAll();
 
             var counter = 0;
             var calculationGroup = new CalculationGroup();
             var calculationGroupContext = new TestCalculationGroupContext(calculationGroup, failureMechanism);
-            var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler, exportImportHandler, viewCommandsHandler, calculationGroup, treeViewControl);
+            var toolStripItem = factory.CreateAddCalculationItem(calculationGroupContext, context => counter++);
 
-            RingtoetsContextMenuItemFactory.AddCreateCalculationItem(menuBuilder, calculationGroupContext, context => counter++);
-            var contextMenuItem = menuBuilder.Build().Items[0];
-
             // Call
-            contextMenuItem.PerformClick();
+            toolStripItem.PerformClick();
 
             // Assert
             Assert.AreEqual(1, counter);
+            mocks.VerifyAll();
         }
 
         [Test]
-        public void AddClearAllCalculationOutputInGroupItem_GroupWithCalculationOutput_CreatesDecoratedAndEnabledClearItem()
+        public void CreateClearAllCalculationOutputInGroupItem_GroupWithCalculationOutput_CreatesDecoratedAndEnabledItem()
         {
             // Setup
             var mocks = new MockRepository();
-            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
-            var exportImportHandler = mocks.Stub<IExportImportCommandHandler>();
-            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
-            var treeViewControl = mocks.StrictMock<TreeViewControl>();
             var calculationWithOutput = mocks.StrictMock<ICalculation>();
 
             calculationWithOutput.Expect(c => c.HasOutput).Return(true);
@@ -167,27 +140,21 @@
                 }
             };
 
-            var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler, exportImportHandler, viewCommandsHandler, calculationGroup, treeViewControl);
-
             // Call
-            RingtoetsContextMenuItemFactory.AddClearAllCalculationOutputInGroupItem(menuBuilder, calculationGroup);
+            var toolStripItem = factory.CreateClearAllCalculationOutputInGroupItem(calculationGroup);
 
             // Assert
-            TestHelper.AssertContextMenuStripContainsItem(menuBuilder.Build(), 0,
-                                                          RingtoetsFormsResources.Clear_all_output,
-                                                          RingtoetsFormsResources.CalculationGroup_ClearOutput_ToolTip,
-                                                          RingtoetsFormsResources.ClearIcon);
+            Assert.AreEqual(RingtoetsFormsResources.Clear_all_output, toolStripItem.Text);
+            Assert.AreEqual(RingtoetsFormsResources.CalculationGroup_ClearOutput_ToolTip, toolStripItem.ToolTipText);
+            TestHelper.AssertImagesAreEqual(RingtoetsFormsResources.ClearIcon, toolStripItem.Image);
+            Assert.IsTrue(toolStripItem.Enabled);
         }
 
         [Test]
-        public void AddClearAllCalculationOutputInGroupItem_GroupWithoutCalculationOutput_CreatesDecoratedAndDisabledClearItem()
+        public void CreateClearAllCalculationOutputInGroupItem_GroupWithoutCalculationOutput_CreatesDecoratedAndDisabledItem()
         {
             // Setup
             var mocks = new MockRepository();
-            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
-            var exportImportHandler = mocks.Stub<IExportImportCommandHandler>();
-            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
-            var treeViewControl = mocks.StrictMock<TreeViewControl>();
             var calculationWithoutOutput = mocks.StrictMock<ICalculation>();
 
             calculationWithoutOutput.Expect(c => c.HasOutput).Return(false);
@@ -202,29 +169,22 @@
                 }
             };
 
-            var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler, exportImportHandler, viewCommandsHandler, calculationGroup, treeViewControl);
-
             // Call
-            RingtoetsContextMenuItemFactory.AddClearAllCalculationOutputInGroupItem(menuBuilder, calculationGroup);
+            var toolStripItem = factory.CreateClearAllCalculationOutputInGroupItem(calculationGroup);
 
             // Assert
-            TestHelper.AssertContextMenuStripContainsItem(menuBuilder.Build(), 0,
-                                                          RingtoetsFormsResources.Clear_all_output,
-                                                          RingtoetsFormsResources.CalculationGroup_ClearOutput_No_calculation_with_output_to_clear,
-                                                          RingtoetsFormsResources.ClearIcon,
-                                                          false);
+            Assert.AreEqual(RingtoetsFormsResources.Clear_all_output, toolStripItem.Text);
+            Assert.AreEqual(RingtoetsFormsResources.CalculationGroup_ClearOutput_No_calculation_with_output_to_clear, toolStripItem.ToolTipText);
+            TestHelper.AssertImagesAreEqual(RingtoetsFormsResources.ClearIcon, toolStripItem.Image);
+            Assert.IsFalse(toolStripItem.Enabled);
         }
 
         [Test]
-        public void AddClearAllCalculationOutputInGroupItem_PerformClickOnCreatedItemAndConfirmChange_CalculationOutputClearedAndObserversNotified()
+        public void CreateClearAllCalculationOutputInGroupItem_PerformClickOnCreatedItemAndConfirmChange_CalculationOutputClearedAndObserversNotified()
         {
             var messageBoxText = "";
             var messageBoxTitle = "";
             var mocks = new MockRepository();
-            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
-            var exportImportHandler = mocks.Stub<IExportImportCommandHandler>();
-            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
-            var treeViewControl = mocks.StrictMock<TreeViewControl>();
             var calculationWithOutput1 = mocks.StrictMock<ICalculation>();
             var calculationWithOutput2 = mocks.StrictMock<ICalculation>();
             var calculationWithoutOutput = mocks.StrictMock<ICalculation>();
@@ -265,13 +225,10 @@
                 }
             };
 
-            var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler, exportImportHandler, viewCommandsHandler, calculationGroup, treeViewControl);
+            var toolStripItem = factory.CreateClearAllCalculationOutputInGroupItem(calculationGroup);
 
-            RingtoetsContextMenuItemFactory.AddClearAllCalculationOutputInGroupItem(menuBuilder, calculationGroup);
-            var contextMenuItem = menuBuilder.Build().Items[0];
-
             // Call
-            contextMenuItem.PerformClick();
+            toolStripItem.PerformClick();
 
             // Assert
             Assert.AreEqual(BaseResources.Confirm, messageBoxTitle);
@@ -281,13 +238,9 @@
         }
 
         [Test]
-        public void AddClearAllCalculationOutputInGroupItem_PerformClickOnCreatedItemAndCancelChange_CalculationOutputNotCleared()
+        public void CreateClearAllCalculationOutputInGroupItem_PerformClickOnCreatedItemAndCancelChange_CalculationOutputNotCleared()
         {
             var mocks = new MockRepository();
-            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
-            var exportImportHandler = mocks.Stub<IExportImportCommandHandler>();
-            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
-            var treeViewControl = mocks.StrictMock<TreeViewControl>();
             var calculationWithOutput1 = mocks.StrictMock<ICalculation>();
             var calculationWithOutput2 = mocks.StrictMock<ICalculation>();
             var calculationWithoutOutput = mocks.StrictMock<ICalculation>();
@@ -321,85 +274,71 @@
                 }
             };
 
-            var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler, exportImportHandler, viewCommandsHandler, calculationGroup, treeViewControl);
+            var toolStripItem = factory.CreateClearAllCalculationOutputInGroupItem(calculationGroup);
 
-            RingtoetsContextMenuItemFactory.AddClearAllCalculationOutputInGroupItem(menuBuilder, calculationGroup);
-            var contextMenuItem = menuBuilder.Build().Items[0];
-
             // Call
-            contextMenuItem.PerformClick();
+            toolStripItem.PerformClick();
 
+            // Assert
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddPerformAllCalculationsInGroupItem_GroupWithCalculations_CreatesDecoratedAndEnabledPerformItem()
+        public void CreatePerformAllCalculationsInGroupItem_GroupWithCalculations_CreatesDecoratedAndEnabledItem()
         {
             // Setup
             var mocks = new MockRepository();
-            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
-            var exportImportHandler = mocks.Stub<IExportImportCommandHandler>();
-            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
-            var treeViewControl = mocks.StrictMock<TreeViewControl>();
-            var calculation = mocks.StrictMock<ICalculation>();
+            var failureMechanisMock = mocks.StrictMock<IFailureMechanism>();
 
             mocks.ReplayAll();
 
+            var calculation = new TestCalculation();
             var calculationGroup = new CalculationGroup
             {
                 Children =
                 {
                     calculation
                 }
             };
+            var testCalculationGroupContext = new TestCalculationGroupContext(calculationGroup, failureMechanisMock);
 
-            var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler, exportImportHandler, viewCommandsHandler, calculationGroup, treeViewControl);
-
             // Call
-            RingtoetsContextMenuItemFactory.AddPerformAllCalculationsInGroupItem<TestCalculationGroupContext>(menuBuilder, calculationGroup, null, null);
+            var toolStripItem = factory.CreatePerformAllCalculationsInGroupItem(calculationGroup, testCalculationGroupContext, null);
 
             // Assert
-            TestHelper.AssertContextMenuStripContainsItem(menuBuilder.Build(), 0,
-                                                          RingtoetsFormsResources.Calculate_all,
-                                                          RingtoetsFormsResources.CalculationGroup_CalculateAll_ToolTip,
-                                                          RingtoetsFormsResources.CalculateAllIcon);
+            Assert.AreEqual(RingtoetsFormsResources.Calculate_all, toolStripItem.Text);
+            Assert.AreEqual(RingtoetsFormsResources.CalculationGroup_CalculateAll_ToolTip, toolStripItem.ToolTipText);
+            TestHelper.AssertImagesAreEqual(RingtoetsFormsResources.CalculateAllIcon, toolStripItem.Image);
+            Assert.IsTrue(toolStripItem.Enabled);
         }
 
         [Test]
-        public void AddPerformAllCalculationsInGroupItem_GroupWithoutCalculations_CreatesDecoratedAndDisabledPerformItem()
+        public void CreatePerformAllCalculationsInGroupItem_GroupWithoutCalculations_CreatesDecoratedAndDisabledItem()
         {
             // Setup
             var mocks = new MockRepository();
-            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
-            var exportImportHandler = mocks.Stub<IExportImportCommandHandler>();
-            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
-            var treeViewControl = mocks.StrictMock<TreeViewControl>();
+            var failureMechanisMock = mocks.StrictMock<IFailureMechanism>();
 
             mocks.ReplayAll();
 
             var calculationGroup = new CalculationGroup();
-            var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler, exportImportHandler, viewCommandsHandler, calculationGroup, treeViewControl);
+            var testCalculationGroupContext = new TestCalculationGroupContext(calculationGroup, failureMechanisMock);
 
             // Call
-            RingtoetsContextMenuItemFactory.AddPerformAllCalculationsInGroupItem<TestCalculationGroupContext>(menuBuilder, calculationGroup, null, null);
+            var toolStripItem = factory.CreatePerformAllCalculationsInGroupItem(calculationGroup, testCalculationGroupContext, null);
 
             // Assert
-            TestHelper.AssertContextMenuStripContainsItem(menuBuilder.Build(), 0,
-                                                          RingtoetsFormsResources.Calculate_all,
-                                                          RingtoetsFormsResources.CalculationGroup_CalculateAll_No_calculations_to_run,
-                                                          RingtoetsFormsResources.CalculateAllIcon,
-                                                          false);
+            Assert.AreEqual(RingtoetsFormsResources.Calculate_all, toolStripItem.Text);
+            Assert.AreEqual(RingtoetsFormsResources.CalculationGroup_CalculateAll_No_calculations_to_run, toolStripItem.ToolTipText);
+            TestHelper.AssertImagesAreEqual(RingtoetsFormsResources.CalculateAllIcon, toolStripItem.Image);
+            Assert.IsFalse(toolStripItem.Enabled);
         }
 
         [Test]
-        public void AddPerformAllCalculationsInGroupItem_PerformClickOnCreatedItem_PerformAllCalculationMethodPerformed()
+        public void CreatePerformAllCalculationsInGroupItem_PerformClickOnCreatedItem_PerformAllCalculationMethodPerformed()
         {
             // Setup
             var mocks = new MockRepository();
-            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
-            var exportImportHandler = mocks.Stub<IExportImportCommandHandler>();
-            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
-            var treeViewControl = mocks.StrictMock<TreeViewControl>();
             var calculation = mocks.StrictMock<ICalculation>();
             var failureMechanism = mocks.StrictMock<IFailureMechanism>();
 
@@ -416,147 +355,117 @@
 
             var calculationGroupContext = new TestCalculationGroupContext(calculationGroup, failureMechanism);
 
-            var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler, exportImportHandler, viewCommandsHandler, calculationGroup, treeViewControl);
+            var toolStripItem = factory.CreatePerformAllCalculationsInGroupItem(calculationGroup, calculationGroupContext, (group, context) => counter++);
 
-            RingtoetsContextMenuItemFactory.AddPerformAllCalculationsInGroupItem(menuBuilder, calculationGroup, calculationGroupContext, (group, context) => counter++);
-            var contextMenuItem = menuBuilder.Build().Items[0];
-
             // Call
-            contextMenuItem.PerformClick();
+            toolStripItem.PerformClick();
 
             // Assert
             Assert.AreEqual(1, counter);
         }
 
         [Test]
-        public void AddPerformCalculationItem_Always_CreatesPerformItem()
+        public void CreatePerformCalculationItem_Always_CreatesDecoratedItem()
         {
             // Setup
             var mocks = new MockRepository();
-            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
-            var exportImportHandler = mocks.Stub<IExportImportCommandHandler>();
-            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
-            var treeViewControl = mocks.StrictMock<TreeViewControl>();
+            var failureMechanisMock = mocks.StrictMock<IFailureMechanism>();
 
             mocks.ReplayAll();
 
             var calculation = new TestCalculation();
+            var calculationContext = new TestCalculationContext(calculation, failureMechanisMock);
 
-            var menubuilder = new ContextMenuBuilder(applicationFeatureCommandHandler, exportImportHandler, viewCommandsHandler, calculation, treeViewControl);
-
             // Call
-            RingtoetsContextMenuItemFactory.AddPerformCalculationItem<TestCalculation, TestCalculationContext>(menubuilder, calculation, null, null);
+            var toolStripItem = factory.CreatePerformCalculationItem(calculation, calculationContext, null);
 
             // Assert
-            TestHelper.AssertContextMenuStripContainsItem(menubuilder.Build(), 0,
-                                                          RingtoetsFormsResources.Calculate,
-                                                          RingtoetsFormsResources.Calculate_ToolTip,
-                                                          RingtoetsFormsResources.CalculateIcon);
+            Assert.AreEqual(RingtoetsFormsResources.Calculate, toolStripItem.Text);
+            Assert.AreEqual(RingtoetsFormsResources.Calculate_ToolTip, toolStripItem.ToolTipText);
+            TestHelper.AssertImagesAreEqual(RingtoetsFormsResources.CalculateIcon, toolStripItem.Image);
+            Assert.IsTrue(toolStripItem.Enabled);
 
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddPerformCalculationItem_PerformClickOnCreatedItem_PerformCalculationMethod()
+        public void CreatePerformCalculationItem_PerformClickOnCreatedItem_PerformCalculationMethod()
         {
             // Setup
             var mocks = new MockRepository();
-            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
-            var exportImportHandler = mocks.Stub<IExportImportCommandHandler>();
-            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
             var failureMechanisMock = mocks.StrictMock<IFailureMechanism>();
-            var treeViewControl = mocks.StrictMock<TreeViewControl>();
 
             mocks.ReplayAll();
 
             var calculation = new TestCalculation();
             var testCalculationContext = new TestCalculationContext(calculation, failureMechanisMock);
 
             var counter = 0;
+            var toolStripItem = factory.CreatePerformCalculationItem(calculation, testCalculationContext, (calc, context) => counter++);
 
-            var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler, exportImportHandler, viewCommandsHandler, calculation, treeViewControl);
-            RingtoetsContextMenuItemFactory.AddPerformCalculationItem(menuBuilder, calculation, testCalculationContext, (calc, context) => counter++);
-            var contextMenuItem = menuBuilder.Build().Items[0];
-
             // Call
-            contextMenuItem.PerformClick();
+            toolStripItem.PerformClick();
 
             // Assert
             Assert.AreEqual(1, counter);
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddClearCalculationOutputItem_CalculationWithOutput_CreatesDecoratedAndEnabledClearItem()
+        public void CreateClearCalculationOutputItem_CalculationWithOutput_CreatesDecoratedAndEnabledItem()
         {
             // Setup
             var mocks = new MockRepository();
-            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
-            var exportImportHandler = mocks.Stub<IExportImportCommandHandler>();
-            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
-            var treeViewControl = mocks.StrictMock<TreeViewControl>();
             var calculationWithOutput = mocks.StrictMock<ICalculation>();
 
             calculationWithOutput.Expect(c => c.HasOutput).Return(true);
 
             mocks.ReplayAll();
 
-            var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler, exportImportHandler, viewCommandsHandler, calculationWithOutput, treeViewControl);
-
             // Call
-            RingtoetsContextMenuItemFactory.AddClearCalculationOutputItem(menuBuilder, calculationWithOutput);
+            var toolStripItem = factory.CreateClearCalculationOutputItem(calculationWithOutput);
 
             // Assert
-            TestHelper.AssertContextMenuStripContainsItem(menuBuilder.Build(), 0,
-                                                          RingtoetsFormsResources.Clear_output,
-                                                          RingtoetsFormsResources.Clear_output_ToolTip,
-                                                          RingtoetsFormsResources.ClearIcon);
+            Assert.AreEqual(RingtoetsFormsResources.Clear_output, toolStripItem.Text);
+            Assert.AreEqual(RingtoetsFormsResources.Clear_output_ToolTip, toolStripItem.ToolTipText);
+            TestHelper.AssertImagesAreEqual(RingtoetsFormsResources.ClearIcon, toolStripItem.Image);
+            Assert.IsTrue(toolStripItem.Enabled);
+
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddClearCalculationOutputItem_CalculationWithoutOutput_CreatesDecoratedAndDisabledClearItem()
+        public void CreateClearCalculationOutputItem_CalculationWithoutOutput_CreatesDecoratedAndDisabledItem()
         {
             // Setup
             var mocks = new MockRepository();
-            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
-            var exportImportHandler = mocks.Stub<IExportImportCommandHandler>();
-            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
-            var treeViewControl = mocks.StrictMock<TreeViewControl>();
             var calculationWithOutput = mocks.StrictMock<ICalculation>();
 
             calculationWithOutput.Expect(c => c.HasOutput).Return(false);
 
             mocks.ReplayAll();
 
-            var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler, exportImportHandler, viewCommandsHandler, calculationWithOutput, treeViewControl);
-
             // Call
-            RingtoetsContextMenuItemFactory.AddClearCalculationOutputItem(menuBuilder, calculationWithOutput);
+            var toolStripItem = factory.CreateClearCalculationOutputItem(calculationWithOutput);
 
             // Assert
-            TestHelper.AssertContextMenuStripContainsItem(menuBuilder.Build(), 0,
-                                                          RingtoetsFormsResources.Clear_output,
-                                                          RingtoetsFormsResources.ClearOutput_No_output_to_clear,
-                                                          RingtoetsFormsResources.ClearIcon,
-                                                          false);
+            Assert.AreEqual(RingtoetsFormsResources.Clear_output, toolStripItem.Text);
+            Assert.AreEqual(RingtoetsFormsResources.ClearOutput_No_output_to_clear, toolStripItem.ToolTipText);
+            TestHelper.AssertImagesAreEqual(RingtoetsFormsResources.ClearIcon, toolStripItem.Image);
+            Assert.IsFalse(toolStripItem.Enabled);
+
             mocks.VerifyAll();
         }
 
         [Test]
-        public void AddClearCalculationOutputItem_PerformClickOnCreatedItemAndConfirmChange_CalculationOutputClearedAndObserversNotified()
+        public void CreateClearCalculationOutputItem_PerformClickOnCreatedItemAndConfirmChange_CalculationOutputClearedAndObserversNotified()
         {
             var messageBoxText = "";
             var messageBoxTitle = "";
             var mocks = new MockRepository();
-            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
-            var exportImportHandler = mocks.Stub<IExportImportCommandHandler>();
-            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
-            var treeViewControl = mocks.StrictMock<TreeViewControl>();
             var calculationWithOutput = mocks.StrictMock<ICalculation>();
 
             calculationWithOutput.Stub(c => c.HasOutput).Return(true);
-
             calculationWithOutput.Expect(c => c.ClearOutput());
             calculationWithOutput.Expect(c => c.NotifyObservers());
 
@@ -571,13 +480,10 @@
                 messageBox.ClickOk();
             };
 
-            var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler, exportImportHandler, viewCommandsHandler, calculationWithOutput, treeViewControl);
+            var toolStripItem = factory.CreateClearCalculationOutputItem(calculationWithOutput);
 
-            RingtoetsContextMenuItemFactory.AddClearCalculationOutputItem(menuBuilder, calculationWithOutput);
-            var contextMenuItem = menuBuilder.Build().Items[0];
-
             // Call
-            contextMenuItem.PerformClick();
+            toolStripItem.PerformClick();
 
             // Assert
             Assert.AreEqual(BaseResources.Confirm, messageBoxTitle);
@@ -587,13 +493,9 @@
         }
 
         [Test]
-        public void AddClearCalculationOutputItem_PerformClickOnCreatedItemAndCancelChange_CalculationOutputNotCleared()
+        public void CreateClearCalculationOutputItem_PerformClickOnCreatedItemAndCancelChange_CalculationOutputNotCleared()
         {
             var mocks = new MockRepository();
-            var applicationFeatureCommandHandler = mocks.Stub<IApplicationFeatureCommands>();
-            var exportImportHandler = mocks.Stub<IExportImportCommandHandler>();
-            var viewCommandsHandler = mocks.StrictMock<IViewCommands>();
-            var treeViewControl = mocks.StrictMock<TreeViewControl>();
             var calculationWithOutput = mocks.StrictMock<ICalculation>();
 
             calculationWithOutput.Stub(c => c.HasOutput).Return(true);
@@ -607,13 +509,10 @@
                 messageBox.ClickCancel();
             };
 
-            var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler, exportImportHandler, viewCommandsHandler, calculationWithOutput, treeViewControl);
+            var toolStripItem = factory.CreateClearCalculationOutputItem(calculationWithOutput);
 
-            RingtoetsContextMenuItemFactory.AddClearCalculationOutputItem(menuBuilder, calculationWithOutput);
-            var contextMenuItem = menuBuilder.Build().Items[0];
-
             // Call
-            contextMenuItem.PerformClick();
+            toolStripItem.PerformClick();
 
             mocks.VerifyAll();
         }
Index: Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Plugin/GrassCoverErosionInwardsGuiPlugin.cs
===================================================================
diff -u -r89cf0d104a6e12180d2fae471ae318cad256707a -re2991a38a1982398a6cbb35e38e534e26ba8930d
--- Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Plugin/GrassCoverErosionInwardsGuiPlugin.cs	(.../GrassCoverErosionInwardsGuiPlugin.cs)	(revision 89cf0d104a6e12180d2fae471ae318cad256707a)
+++ Ringtoets/GrassCoverErosionInwards/src/Ringtoets.GrassCoverErosionInwards.Plugin/GrassCoverErosionInwardsGuiPlugin.cs	(.../GrassCoverErosionInwardsGuiPlugin.cs)	(revision e2991a38a1982398a6cbb35e38e534e26ba8930d)
@@ -289,11 +289,10 @@
 
         private ContextMenuStrip FailureMechanismDisabledContextMenuStrip(GrassCoverErosionInwardsFailureMechanismContext grassCoverErosionInwardsFailureMechanismContext, object parentData, TreeViewControl treeViewControl)
         {
-            var builder = Gui.Get(grassCoverErosionInwardsFailureMechanismContext, treeViewControl);
+            var builder = new RingtoetsContextMenuBuilder(Gui.Get(grassCoverErosionInwardsFailureMechanismContext, treeViewControl));
 
-            RingtoetsContextMenuItemFactory.AddDisabledChangeRelevancyItem(builder, grassCoverErosionInwardsFailureMechanismContext);
-
-            return builder.AddSeparator()
+            return builder.AddDisabledChangeRelevancyItem(grassCoverErosionInwardsFailureMechanismContext)
+                          .AddSeparator()
                           .AddExpandAllItem()
                           .AddCollapseAllItem()
                           .Build();
@@ -388,7 +387,7 @@
         private ContextMenuStrip CalculationGroupContextContextMenuStrip(GrassCoverErosionInwardsCalculationGroupContext nodeData, object parentData, TreeViewControl treeViewControl)
         {
             var group = nodeData.WrappedData;
-            var builder = Gui.Get(nodeData, treeViewControl);
+            var builder = new RingtoetsContextMenuBuilder(Gui.Get(nodeData, treeViewControl));
             var isNestedGroup = parentData is GrassCoverErosionInwardsCalculationGroupContext;
 
             if (!isNestedGroup)
@@ -397,11 +396,11 @@
                        .AddSeparator();
             }
 
-            RingtoetsContextMenuItemFactory.AddCreateCalculationGroupItem(builder, group);
-            RingtoetsContextMenuItemFactory.AddCreateCalculationItem(builder, nodeData, AddCalculation);
+            builder.AddCreateCalculationGroupItem(group);
+            builder.AddCreateCalculationItem(nodeData, AddCalculation);
             builder.AddSeparator();
-            RingtoetsContextMenuItemFactory.AddPerformAllCalculationsInGroupItem(builder, group, nodeData, CalculateAll);
-            RingtoetsContextMenuItemFactory.AddClearAllCalculationOutputInGroupItem(builder, group);
+            builder.AddPerformAllCalculationsInGroupItem(group, nodeData, CalculateAll);
+            builder.AddClearAllCalculationOutputInGroupItem(group);
             builder.AddSeparator();
 
             if (isNestedGroup)
@@ -459,30 +458,24 @@
 
         private ContextMenuStrip CalculationContextContextmenuStrip(GrassCoverErosionInwardsCalculationContext nodeData, object parentData, TreeViewControl treeViewControl)
         {
-            var builder = Gui.Get(nodeData, treeViewControl);
+            var builder = new RingtoetsContextMenuBuilder(Gui.Get(nodeData, treeViewControl));
 
             GrassCoverErosionInwardsCalculation calculation = nodeData.WrappedData;
 
-            RingtoetsContextMenuItemFactory.AddPerformCalculationItem(
-                builder,
-                calculation,
-                nodeData,
-                PerformCalculation);
-            RingtoetsContextMenuItemFactory.AddClearCalculationOutputItem(builder, calculation);
-            builder.AddSeparator();
-
-            return builder
-                .AddRenameItem()
-                .AddDeleteItem()
-                .AddSeparator()
-                .AddImportItem()
-                .AddExportItem()
-                .AddSeparator()
-                .AddExpandAllItem()
-                .AddCollapseAllItem()
-                .AddSeparator()
-                .AddPropertiesItem()
-                .Build();
+            return builder.AddPerformCalculationItem(calculation, nodeData, PerformCalculation)
+                          .AddClearCalculationOutputItem(calculation)
+                          .AddSeparator()
+                          .AddRenameItem()
+                          .AddDeleteItem()
+                          .AddSeparator()
+                          .AddImportItem()
+                          .AddExportItem()
+                          .AddSeparator()
+                          .AddExpandAllItem()
+                          .AddCollapseAllItem()
+                          .AddSeparator()
+                          .AddPropertiesItem()
+                          .Build();
         }
 
         private void PerformCalculation(GrassCoverErosionInwardsCalculation calculation, GrassCoverErosionInwardsCalculationContext context)
Index: Ringtoets/Integration/src/Ringtoets.Integration.Plugin/RingtoetsGuiPlugin.cs
===================================================================
diff -u -rf02aacfe462777023a9657e3f8269dedbae3c2b6 -re2991a38a1982398a6cbb35e38e534e26ba8930d
--- Ringtoets/Integration/src/Ringtoets.Integration.Plugin/RingtoetsGuiPlugin.cs	(.../RingtoetsGuiPlugin.cs)	(revision f02aacfe462777023a9657e3f8269dedbae3c2b6)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Plugin/RingtoetsGuiPlugin.cs	(.../RingtoetsGuiPlugin.cs)	(revision e2991a38a1982398a6cbb35e38e534e26ba8930d)
@@ -558,11 +558,10 @@
 
         private ContextMenuStrip StandAloneFailureMechanismDisabledContextMenuStrip(StandAloneFailureMechanismContext nodeData, object parentData, TreeViewControl treeViewControl)
         {
-            var builder = Gui.Get(nodeData, treeViewControl);
+            var builder = new RingtoetsContextMenuBuilder(Gui.Get(nodeData, treeViewControl));
 
-            RingtoetsContextMenuItemFactory.AddDisabledChangeRelevancyItem(builder, nodeData);
-
-            return builder.AddSeparator()
+            return builder.AddDisabledChangeRelevancyItem(nodeData)
+                          .AddSeparator()
                           .AddExpandAllItem()
                           .AddCollapseAllItem()
                           .Build();
Index: Ringtoets/Piping/src/Ringtoets.Piping.Plugin/PipingGuiPlugin.cs
===================================================================
diff -u -r89cf0d104a6e12180d2fae471ae318cad256707a -re2991a38a1982398a6cbb35e38e534e26ba8930d
--- Ringtoets/Piping/src/Ringtoets.Piping.Plugin/PipingGuiPlugin.cs	(.../PipingGuiPlugin.cs)	(revision 89cf0d104a6e12180d2fae471ae318cad256707a)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Plugin/PipingGuiPlugin.cs	(.../PipingGuiPlugin.cs)	(revision e2991a38a1982398a6cbb35e38e534e26ba8930d)
@@ -323,11 +323,10 @@
 
         private ContextMenuStrip FailureMechanismDisabledContextMenuStrip(PipingFailureMechanismContext pipingFailureMechanismContext, object parentData, TreeViewControl treeViewControl)
         {
-            var builder = Gui.Get(pipingFailureMechanismContext, treeViewControl);
+            var builder = new RingtoetsContextMenuBuilder(Gui.Get(pipingFailureMechanismContext, treeViewControl));
 
-            RingtoetsContextMenuItemFactory.AddDisabledChangeRelevancyItem(builder, pipingFailureMechanismContext);
-
-            return builder.AddSeparator()
+            return builder.AddDisabledChangeRelevancyItem(pipingFailureMechanismContext)
+                          .AddSeparator()
                           .AddExpandAllItem()
                           .AddCollapseAllItem()
                           .Build();
@@ -445,20 +444,20 @@
 
         private ContextMenuStrip PipingCalculationContextContextMenuStrip(PipingCalculationScenarioContext nodeData, object parentData, TreeViewControl treeViewControl)
         {
-            var builder = Gui.Get(nodeData, treeViewControl);
+            var builder = new RingtoetsContextMenuBuilder(Gui.Get(nodeData, treeViewControl));
 
             PipingCalculation calculation = nodeData.WrappedData;
+
             var validateItem = new StrictContextMenuItem(RingtoetsCommonFormsResources.Validate,
                                                          RingtoetsCommonFormsResources.Validate_ToolTip,
                                                          RingtoetsCommonFormsResources.ValidateIcon,
                                                          (o, args) => { PipingCalculationService.Validate(calculation); });
 
-            builder.AddCustomItem(validateItem);
-            RingtoetsContextMenuItemFactory.AddPerformCalculationItem(builder, calculation, nodeData, PerformCalculation);
-            RingtoetsContextMenuItemFactory.AddClearCalculationOutputItem(builder, calculation);
-            builder.AddSeparator();
-
-            return builder.AddRenameItem()
+            return builder.AddCustomItem(validateItem)
+                          .AddPerformCalculationItem(calculation, nodeData, PerformCalculation)
+                          .AddClearCalculationOutputItem(calculation)
+                          .AddSeparator()
+                          .AddRenameItem()
                           .AddDeleteItem()
                           .AddSeparator()
                           .AddImportItem()
@@ -558,7 +557,7 @@
         private ContextMenuStrip PipingCalculationGroupContextContextMenuStrip(PipingCalculationGroupContext nodeData, object parentData, TreeViewControl treeViewControl)
         {
             var group = nodeData.WrappedData;
-            var builder = Gui.Get(nodeData, treeViewControl);
+            var builder = new RingtoetsContextMenuBuilder(Gui.Get(nodeData, treeViewControl));
             var isNestedGroup = parentData is PipingCalculationGroupContext;
 
             var generateCalculationsItem = CreateGeneratePipingCalculationsItem(nodeData);
@@ -572,13 +571,13 @@
                        .AddSeparator();
             }
 
-            RingtoetsContextMenuItemFactory.AddCreateCalculationGroupItem(builder, group);
-            RingtoetsContextMenuItemFactory.AddCreateCalculationItem(builder, nodeData, AddCalculationScenario);
-            builder.AddSeparator();
-            builder.AddCustomItem(validateAllItem);
-            RingtoetsContextMenuItemFactory.AddPerformAllCalculationsInGroupItem(builder, group, nodeData, CalculateAll);
-            RingtoetsContextMenuItemFactory.AddClearAllCalculationOutputInGroupItem(builder, group);
-            builder.AddSeparator();
+            builder.AddCreateCalculationGroupItem(group)
+                   .AddCreateCalculationItem(nodeData, AddCalculationScenario)
+                   .AddSeparator()
+                   .AddCustomItem(validateAllItem)
+                   .AddPerformAllCalculationsInGroupItem(group, nodeData, CalculateAll)
+                   .AddClearAllCalculationOutputInGroupItem(group)
+                   .AddSeparator();
 
             if (isNestedGroup)
             {