/// <summary>
/// Creates a <see cref="StrictContextMenuItem"/> which is bound to the action of validating the input of each calculation
/// in a calculation group.
/// </summary>
/// <typeparam name="TCalculationGroupContext">The type of the calculation group context.</typeparam>
/// <param name="calculationGroupContext">The calculation group context belonging to the calculation group.</param>
/// <param name="validateAllAction">The action that validates all calculations.</param>
/// <param name="enableMenuItemFunction">The function which determines whether the item should be enabled. If the
/// item should not be enabled, then the reason for that should be returned by the function and will be shown as a tooltip.
/// If the item should be enabled then the function should return a <c>null</c> or empty string.</param>
/// <returns>The created <see cref="StrictContextMenuItem"/>.</returns>
public static StrictContextMenuItem CreateValidateAllCalculationsInGroupItem <TCalculationGroupContext>(
TCalculationGroupContext calculationGroupContext,
Action <TCalculationGroupContext> validateAllAction,
Func <TCalculationGroupContext, string> enableMenuItemFunction)
where TCalculationGroupContext : ICalculationContext <CalculationGroup, ICalculatableFailureMechanism>
{
CalculationGroup calculationGroup = calculationGroupContext.WrappedData;
var menuItem = new StrictContextMenuItem(
Resources.Validate_All,
Resources.CalculationGroup_Validate_All_ToolTip,
Resources.ValidateAllIcon,
(o, args) => validateAllAction(calculationGroupContext));
if (!calculationGroup.GetCalculations().Any())
{
menuItem.Enabled = false;
menuItem.ToolTipText = Resources.ValidateAll_No_calculations_to_validate;
}
else
{
SetStateWithEnableFunction(calculationGroupContext, enableMenuItemFunction, menuItem);
}
return(menuItem);
}
public void Constructor_WithParameters_PropertiesSet()
{
// Setup
var mockRepository = new MockRepository();
const string text = "text";
const string toolTip = "tooltip";
Bitmap image = Resources.ImportIcon;
var counter = 0;
mockRepository.ReplayAll();
EventHandler handler = (s, e) => counter++;
// Call
var result = new StrictContextMenuItem(text, toolTip, image, handler);
result.PerformClick();
// Assert
Assert.IsInstanceOf <StrictContextMenuItem>(result);
Assert.AreEqual(text, result.Text);
Assert.AreEqual(toolTip, result.ToolTipText);
Assert.AreEqual(1, counter);
TestHelper.AssertImagesAreEqual(image, result.Image);
mockRepository.VerifyAll();
}
private ContextMenuStrip HydraulicLoadsStateFailureMechanismContextMenuStrip(HydraulicLoadsStateFailureMechanismContext context,
object parentData,
TreeViewControl treeViewControl)
{
var builder = new RiskeerContextMenuBuilder(Gui.Get(context, treeViewControl));
IAssessmentSection assessmentSection = context.Parent;
var calculateAllItem = new StrictContextMenuItem(
RiskeerCommonFormsResources.Calculate_All,
RiskeerCommonFormsResources.Calculate_All_ToolTip,
RiskeerCommonFormsResources.CalculateAllIcon,
(sender, args) =>
{
ActivityProgressDialogRunner.Run(
Gui.MainWindow,
GrassCoverErosionOutwardsCalculationActivityFactory
.CreateWaveConditionsCalculationActivities(context.WrappedData.CalculationsGroup,
context.WrappedData,
assessmentSection));
});
SetHydraulicsMenuItemEnabledStateAndTooltip(assessmentSection,
calculateAllItem);
return(builder.AddOpenItem()
.AddSeparator()
.AddCustomItem(calculateAllItem)
.AddSeparator()
.AddCollapseAllItem()
.AddExpandAllItem()
.AddSeparator()
.AddPropertiesItem()
.Build());
}
private IContextMenuBuilder AddStubItem()
{
ToolStripItem toolStripItem = new StrictContextMenuItem(string.Empty, string.Empty, null, (sender, args) => {});
contextMenu.Items.Add(toolStripItem);
return(this);
}
private static void SetHydraulicsMenuItemEnabledStateAndTooltip(IAssessmentSection assessmentSection,
StrictContextMenuItem menuItem)
{
string validationText = EnableValidateAndCalculateMenuItem(assessmentSection);
if (!string.IsNullOrEmpty(validationText))
{
menuItem.Enabled = false;
menuItem.ToolTipText = validationText;
}
}
/// <summary>
/// Creates a <see cref="StrictContextMenuItem"/> which is bound to the action of validating the input of a calculation.
/// </summary>
/// <typeparam name="TCalculationContext">The type of the calculation context.</typeparam>
/// <param name="calculation">The context containing the calculation to validate.</param>
/// <param name="validateAction">The action that performs the validation.</param>
/// <param name="enableMenuItemFunction">The function which determines whether the item should be enabled. If the
/// item should not be enabled, then the reason for that should be returned by the function and will be shown as a tooltip.
/// If the item should be enabled then the function should return a <c>null</c> or empty string.</param>
/// <returns>The created <see cref="StrictContextMenuItem"/>.</returns>
public static StrictContextMenuItem CreateValidateCalculationItem <TCalculationContext>(
TCalculationContext calculation,
Action <TCalculationContext> validateAction,
Func <TCalculationContext, string> enableMenuItemFunction)
where TCalculationContext : ICalculationContext <ICalculation, ICalculatableFailureMechanism>
{
var menuItem = new StrictContextMenuItem(
Resources.Validate,
Resources.Validate_ToolTip,
Resources.ValidateIcon,
(o, args) => validateAction(calculation));
SetStateWithEnableFunction(calculation, enableMenuItemFunction, menuItem);
return(menuItem);
}
/// <summary>
/// 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="calculationGroup">The calculation group to clear the output for.</param>
/// <returns>The created <see cref="StrictContextMenuItem"/>.</returns>
public static StrictContextMenuItem CreateClearAllCalculationOutputInGroupItem(CalculationGroup calculationGroup)
{
var clearAllItem = new StrictContextMenuItem(
Resources.Clear_all_output,
Resources.CalculationGroup_ClearOutput_ToolTip,
Resources.ClearIcon,
(o, args) => ClearAllCalculationOutputInGroup(calculationGroup));
if (!calculationGroup.HasOutput())
{
clearAllItem.Enabled = false;
clearAllItem.ToolTipText = Resources.CalculationGroup_ClearOutput_No_calculation_with_output_to_clear;
}
return(clearAllItem);
}
/// <summary>
/// Creates a <see cref="StrictContextMenuItem"/> which is bound to the action of clearing the output of all calculations in a failure mechanism.
/// </summary>
/// <param name="failureMechanism">The failure mechanism to clear the output for.</param>
/// <returns>The created <see cref="StrictContextMenuItem"/>.</returns>
public static StrictContextMenuItem CreateClearAllCalculationOutputInFailureMechanismItem(ICalculatableFailureMechanism failureMechanism)
{
var clearAllItem = new StrictContextMenuItem(
Resources.Clear_all_output,
Resources.Clear_all_output_ToolTip,
Resources.ClearIcon,
(o, args) => ClearAllCalculationOutputInFailureMechanism(failureMechanism));
if (!failureMechanism.Calculations.Any(c => c.HasOutput))
{
clearAllItem.Enabled = false;
clearAllItem.ToolTipText = Resources.CalculationGroup_ClearOutput_No_calculation_with_output_to_clear;
}
return(clearAllItem);
}
/// <summary>
/// Creates a <see cref="StrictContextMenuItem"/> which is bound to the action of clearing the output of a calculation.
/// </summary>
/// <param name="calculation">The calculation to clear the output for.</param>
/// <returns>The created <see cref="StrictContextMenuItem"/>.</returns>
public static StrictContextMenuItem CreateClearCalculationOutputItem(ICalculation calculation)
{
var clearOutputItem = new StrictContextMenuItem(
Resources.Clear_output,
Resources.Clear_output_ToolTip,
Resources.ClearIcon,
(o, args) => ClearCalculationOutput(calculation));
if (!calculation.HasOutput)
{
clearOutputItem.Enabled = false;
clearOutputItem.ToolTipText = Resources.ClearOutput_No_output_to_clear;
}
return(clearOutputItem);
}
/// <summary>
/// Creates a <see cref="StrictContextMenuItem"/> which is bound to the action of updating
/// the <see cref="ForeshoreProfile"/> of a <paramref name="calculation"/>.
/// </summary>
/// <typeparam name="TCalculationInput">The type of calculation input that can have a foreshore profile.</typeparam>
/// <param name="calculation">The calculation to update.</param>
/// <param name="inquiryHelper">Object responsible for inquiring the required data.</param>
/// <param name="updateAction">The action to perform when the foreshore profile is updated.</param>
/// <returns>The created <see cref="StrictContextMenuItem"/>.</returns>
public static StrictContextMenuItem CreateUpdateForeshoreProfileOfCalculationItem <TCalculationInput>(
ICalculation <TCalculationInput> calculation,
IInquiryHelper inquiryHelper,
Action <ICalculation <TCalculationInput> > updateAction)
where TCalculationInput : ICalculationInput, IHasForeshoreProfile
{
var contextMenuEnabled = true;
string toolTipMessage = Resources.CreateUpdateForeshoreProfileItem_Update_calculation_with_ForeshoreProfile_ToolTip;
TCalculationInput calculationInputParameters = calculation.InputParameters;
if (calculationInputParameters.ForeshoreProfile == null)
{
contextMenuEnabled = false;
toolTipMessage = Resources.CreateUpdateForeshoreProfileItem_Update_calculation_no_ForeshoreProfile_ToolTip;
}
else if (calculationInputParameters.IsForeshoreProfileInputSynchronized)
{
contextMenuEnabled = false;
toolTipMessage = Resources.CalculationItem_No_changes_to_update_ToolTip;
}
var menuItem = new StrictContextMenuItem(
Resources.CreateUpdateForeshoreProfileItem_Update_ForeshoreProfile_data,
toolTipMessage,
Resources.UpdateItemIcon,
(o, args) =>
{
UpdateForeshoreProfileDependentDataOfCalculation(new[]
{
calculation
},
inquiryHelper,
Resources.VerifyUpdate_Confirm_calculation_output_cleared,
updateAction);
})
{
Enabled = contextMenuEnabled
};
return(menuItem);
}
/// <summary>
/// Creates a <see cref="StrictContextMenuItem"/> which is bound to the action of performing all calculations in a failure mechanism.
/// </summary>
/// <typeparam name="TFailureMechanismContext">The type of the failure mechanism.</typeparam>
/// <param name="failureMechanism">The failure mechanism to validate the calculations of.</param>
/// <param name="validateAllAction">The action that validates all calculations.</param>
/// <param name="enableMenuItemFunction">The function which determines whether the item should be enabled. If the
/// item should not be enabled, then the reason for that should be returned by the function and will be shown as a tooltip.
/// If the item should be enabled then the function should return a <c>null</c> or empty string.</param>
/// <returns>The created <see cref="StrictContextMenuItem"/>.</returns>
public static StrictContextMenuItem CreateValidateAllCalculationsInFailureMechanismItem <TFailureMechanismContext>(
TFailureMechanismContext failureMechanism,
Action <TFailureMechanismContext> validateAllAction,
Func <TFailureMechanismContext, string> enableMenuItemFunction)
where TFailureMechanismContext : IFailureMechanismContext <ICalculatableFailureMechanism>
{
var menuItem = new StrictContextMenuItem(
Resources.Validate_All,
Resources.FailureMechanism_Validate_All_ToolTip,
Resources.ValidateAllIcon,
(o, args) => validateAllAction(failureMechanism));
if (!failureMechanism.WrappedData.Calculations.Any())
{
menuItem.Enabled = false;
menuItem.ToolTipText = Resources.ValidateAll_No_calculations_to_validate;
}
else
{
SetStateWithEnableFunction(failureMechanism, enableMenuItemFunction, menuItem);
}
return(menuItem);
}
/// <summary>
/// Adds a custom item to the <see cref="ContextMenuStrip"/>.
/// </summary>
/// <param name="item">The custom <see cref="StrictContextMenuItem"/> to add to the <see cref="ContextMenuStrip"/>.</param>
/// <returns>The <see cref="RiskeerContextMenuBuilder"/> itself.</returns>
public RiskeerContextMenuBuilder AddCustomItem(StrictContextMenuItem item)
{
contextMenuBuilder.AddCustomItem(item);
return(this);
}
/// <summary>
/// Adds a dummy <see cref="ToolStripItem"/> to the <see cref="ContextMenuStrip"/>.
/// </summary>
/// <param name="item">The custom <see cref="StrictContextMenuItem"/> to add to the <see cref="ContextMenuStrip"/>.</param>
/// <returns>The <see cref="CustomItemsOnlyContextMenuBuilder"/>.</returns>
public IContextMenuBuilder AddCustomItem(StrictContextMenuItem item)
{
contextMenu.Items.Add(item);
return(this);
}
private static void SetStateWithEnableFunction <T>(T context, Func <T, string> enableFunction, StrictContextMenuItem menuItem)
{
string validationText = enableFunction?.Invoke(context);
if (!string.IsNullOrEmpty(validationText))
{
menuItem.Enabled = false;
menuItem.ToolTipText = validationText;
}
}
private ContextMenuStrip CalculationGroupContextContextMenuStrip(WaveImpactAsphaltCoverCalculationGroupContext nodeData,
object parentData, TreeViewControl treeViewControl)
{
CalculationGroup group = nodeData.WrappedData;
IInquiryHelper inquiryHelper = GetInquiryHelper();
var builder = new RiskeerContextMenuBuilder(Gui.Get(nodeData, treeViewControl));
bool isNestedGroup = parentData is WaveImpactAsphaltCoverCalculationGroupContext;
WaveImpactAsphaltCoverWaveConditionsCalculation[] calculations = group
.GetCalculations()
.OfType <WaveImpactAsphaltCoverWaveConditionsCalculation>().ToArray();
StrictContextMenuItem generateCalculationsItem = CreateGenerateWaveConditionsCalculationsItem(nodeData);
builder.AddImportItem()
.AddExportItem()
.AddSeparator();
if (isNestedGroup)
{
builder.AddDuplicateCalculationItem(group, nodeData)
.AddSeparator();
}
else
{
builder.AddCustomItem(generateCalculationsItem)
.AddSeparator();
}
builder.AddCreateCalculationGroupItem(group)
.AddCreateCalculationItem(nodeData, AddWaveConditionsCalculation, CalculationType.Hydraulic)
.AddSeparator();
if (isNestedGroup)
{
builder.AddRenameItem();
}
builder.AddUpdateForeshoreProfileOfCalculationsItem(calculations, inquiryHelper,
SynchronizeCalculationWithForeshoreProfileHelper.UpdateForeshoreProfileDerivedCalculationInput)
.AddSeparator()
.AddValidateAllCalculationsInGroupItem(nodeData,
ValidateAllInCalculationGroup,
EnableValidateAndCalculateMenuItemForCalculationGroup)
.AddPerformAllCalculationsInGroupItem(nodeData,
CalculateAllInCalculationGroup,
EnableValidateAndCalculateMenuItemForCalculationGroup)
.AddSeparator()
.AddClearAllCalculationOutputInGroupItem(group);
if (isNestedGroup)
{
builder.AddDeleteItem();
}
else
{
builder.AddRemoveAllChildrenItem();
}
return(builder.AddSeparator()
.AddCollapseAllItem()
.AddExpandAllItem()
.AddSeparator()
.AddPropertiesItem()
.Build());
}
