private IMenuBarItem createExportODEForRItem(IMoBiSimulation simulation)
{
return(CreateMenuButton.WithCaption(MenuNames.AsDeveloperOnly(MenuNames.ExportODEForR))
.WithCommandFor <ExportODEForRUICommand, IMoBiSimulation>(simulation)
.WithIcon(ApplicationIcons.R)
.ForDeveloper());
}
protected IMenuBarItem ExportODEForRMenuItem(TSimulation simulation)
{
return(CreateMenuButton.WithCaption(MenuNames.AsDeveloperOnly(MenuNames.ExportODEForR))
.WithCommandFor <ExportODEForRUICommand, Simulation>(simulation)
.WithIcon(ApplicationIcons.R)
.ForDeveloper());
}
public static IMenuBarItem ExportSnapshotMenuFor <T>(T objectToExport) where T : class, IObjectBase
{
return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.DevOnlyMenuNameFor("Save Snapshot"))
.WithCommandFor <ExportSnapshotUICommand <T>, T>(objectToExport)
.WithIcon(ApplicationIcons.SnapshotExport)
.ForDeveloper());
}
private IMenuBarItem createDeleteItem(IMoBiSimulation simulation)
{
return(CreateMenuButton.WithCaption(AppConstants.MenuNames.Delete)
.WithCommandFor <RemoveSimulationUICommand, IMoBiSimulation>(simulation)
.WithIcon(ApplicationIcons.Delete)
.AsGroupStarter());
}
private IMenuBarItem exportSimulationResultsToExcel(IMoBiSimulation simulation)
{
//create sub menu containing all compounds
return(CreateMenuButton.WithCaption(AppConstants.MenuNames.ExportSimulationResultsToExcel)
.WithCommandFor <ExportSimulationResultsToExcelCommand, IMoBiSimulation>(simulation)
.WithIcon(ApplicationIcons.ObservedData));
}
protected IMenuBarItem SaveAsSystemTemplateMenuFor(TBuildingBlock buildingBlock)
{
return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.SaveAsSystemTemplate)
.WithCommandFor <SaveBuildingBlockAsSystemTemplateCommand <TBuildingBlock>, IReadOnlyList <TBuildingBlock> >(new[] { buildingBlock, })
.WithIcon(ApplicationIcons.SaveAsTemplate)
.ForDeveloper());
}
private IEnumerable <IMenuBarItem> allMenuItemsFor(IMoleculesPresenter presenter)
{
yield return
(CreateMenuButton.WithCaption(_addProteinCaption)
.WithActionCommand(presenter.AddMolecule <TMolecule>)
.WithIcon(_addProteinIcon));
}
public ObservedDataFolderContextMenu(
ITreeNode <RootNodeType> treeNode,
IMenuBarItemRepository repository,
IBuildingBlockRepository buildingBlockRepository,
IBuildingBlockExplorerPresenter presenter,
IUserSettings userSettings)
{
var allCompounds = buildingBlockRepository.All <Compound>().ToList();
//create sub menu containing all compounds
var addObservedDataFor = CreateSubMenu.WithCaption(PKSimConstants.MenuNames.AddObservedDataFor)
.WithIcon(ApplicationIcons.ObservedDataForMolecule);
foreach (var compound in allCompounds)
{
addObservedDataFor.AddItem(CreateMenuButton.WithCaption(compound.Name)
.WithCommandFor <AddObservedDataForCompoundUICommand, Compound>(compound));
}
_view.AddMenuItem(repository[MenuBarItemIds.AddObservedData]);
if (allCompounds.Any())
{
_view.AddMenuItem(addObservedDataFor);
}
if (treeNode.HasChildren)
{
_view.AddMenuItem(ObservedDataClassificationCommonContextMenuItems.ColorGroupObservedData(userSettings));
}
_view.AddMenuItem(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.LoadFromTemplate)
.WithCommand <LoadObservedDataFromTemplateUICommand>()
.WithIcon(ApplicationIcons.LoadFromTemplate)
.AsGroupStarter());
_view.AddMenuItem(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.AsDeveloperOnly("Load from Snapshot"))
.WithCommand <LoadObservedDataFromSnapshotUICommand>()
.WithIcon(ApplicationIcons.SnapshotImport)
.ForDeveloper());
if (treeNode.AllLeafNodes.OfType <ObservedDataNode>().Any())
{
_view.AddMenuItem(ObservedDataClassificationCommonContextMenuItems.EditMultipleMetaData(treeNode).AsGroupStarter());
}
_view.AddMenuItem(ClassificationCommonContextMenuItems.CreateClassificationUnderMenu(treeNode, presenter));
var groupMenu = createGroupingSubMenu(treeNode, presenter);
if (groupMenu.AllItems().Any())
{
_view.AddMenuItem(groupMenu);
}
_view.AddMenuItem(createDeleteSubMenu(treeNode, presenter));
}
protected override IEnumerable <IMenuBarItem> AllMenuItemsFor(IReadOnlyList <DataRepository> results)
{
yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.Delete)
.WithCommandFor <RemoveMultipleResultsUICommand, IReadOnlyList <DataRepository> >(results)
.AsGroupStarter()
.WithIcon(ApplicationIcons.Delete));
}
protected override IEnumerable <IMenuBarItem> AllMenuItemsFor(ISimulationComparison simulationComparison)
{
yield return(GenericMenu.EditMenuFor <EditSubjectUICommand <ISimulationComparison>, ISimulationComparison>(simulationComparison));
yield return(GenericMenu.RenameMenuFor(simulationComparison));
yield return(GenericMenu.EditDescriptionMenuFor(simulationComparison)
.AsGroupStarter());
var populationSimulationComparison = simulationComparison as PopulationSimulationComparison;
if (populationSimulationComparison != null)
{
yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.Configure)
.WithCommandFor <ConfigurePopulationSimulationComparison, PopulationSimulationComparison>(populationSimulationComparison)
.AsGroupStarter());
}
yield return(GenericMenu.ExportToPDFMenuFor(simulationComparison)
.AsGroupStarter());
yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.Delete)
.WithCommandFor <DeleteSimulationComparisonsUICommand, IReadOnlyList <ISimulationComparison> >(new[] { simulationComparison })
.WithIcon(ApplicationIcons.Delete)
.AsGroupStarter());
}
protected override IEnumerable <IMenuBarItem> AllMenuItemsFor(UsedObservedData usedObservedData)
{
yield return(CreateMenuButton.WithCaption(MenuNames.Remove)
.WithCommand(IoC.Resolve <DeleteUsedObservedDataUICommand>().For(usedObservedData))
.WithIcon(ApplicationIcons.Remove)
.AsGroupStarter());
}
private static IMenuBarItem loadSimulationFromSnapshot()
{
return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.AsDeveloperOnly("Load from Snapshot"))
.WithCommand <LoadSimulationFromSnapshotUICommand>()
.WithIcon(ApplicationIcons.SnapshotImport)
.ForDeveloper());
}
protected override IEnumerable <IMenuBarItem> AllMenuItemsFor(IReadOnlyList <UsedObservedData> usedObservedData)
{
yield return(CreateMenuButton.WithCaption(MenuNames.Remove)
.WithCommandFor <DeleteUsedObservedDataUICommand, IReadOnlyList <UsedObservedData> >(usedObservedData)
.WithIcon(ApplicationIcons.Remove)
.AsGroupStarter());
}
public override IEnumerable <IMenuBarItem> AllMenuItems()
{
yield return(_menuBarItemRepository[MenuBarItemIds.AddObservedData]);
yield return(_menuBarItemRepository[MenuBarItemIds.LoadObservedData]);
yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.ExportToPDF)
.WithCommand <ExportCollectionToPDFCommand <DataRepository> >()
.WithIcon(ApplicationIcons.ExportToPDF));
if (_treeNode.AllLeafNodes.OfType <ObservedDataNode>().Any())
{
yield return(ObservedDataClassificationCommonContextMenuItems.CreateEditMultipleMetaDataMenuButton(_treeNode).AsGroupStarter());
}
yield return(ClassificationCommonContextMenuItems.CreateClassificationUnderMenu(_treeNode, _presenter));
var groupMenu = createGroupingSubMenu(_treeNode, _presenter);
if (groupMenu.AllItems().Any())
{
yield return(groupMenu);
}
yield return(ClassificationCommonContextMenuItems.RemoveClassificationFolderMainMenu(_treeNode, _presenter).AsGroupStarter());
}
private IMenuBarItem createReloadItemFor(DataRepository dataRepository)
{
return(CreateMenuButton.WithCaption(AppConstants.MenuNames.ReloadAll) //ToDo: move to Core, also from PK-Sim
.WithCommandFor <ReloadAllObservedDataCommand, DataRepository>(dataRepository)
.AsDisabledIf(string.IsNullOrEmpty(dataRepository.ConfigurationId))
.WithIcon(ApplicationIcons.Excel));
}
private IMenuBarItem createConfigure(IMoBiSimulation simulation)
{
return(CreateMenuButton.WithCaption(AppConstants.MenuNames.Configure)
.WithIcon(ApplicationIcons.SimulationConfigure)
.WithCommandFor <ConfigureSimulationUICommand, IMoBiSimulation>(simulation)
.AsGroupStarter());
}
protected override IEnumerable <IMenuBarItem> ExportMenuItemsSpecificToType(IndividualSimulation individualSimulation)
{
var exportToExcel = CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ExportSimulationResultsToExcel)
.WithCommandFor <ExportSimulationResultsToExcelCommand, IndividualSimulation>(individualSimulation)
.WithIcon(ApplicationIcons.ExportToExcel);
exportToExcel.Enabled = simulationHasResult(individualSimulation);
yield return(exportToExcel);
var exportToCSV = CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ExportSimulationResultsToCSV)
.WithCommandFor <ExportSimulationResultsToCSVCommand, Simulation>(individualSimulation)
.WithIcon(ApplicationIcons.ExportToCSV);
exportToCSV.Enabled = simulationHasResult(individualSimulation);
yield return(exportToCSV);
yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ExportForMatlab)
.WithIcon(ApplicationIcons.Matlab)
.WithCommandFor <ExportToMatlabOrRCommand, Simulation>(individualSimulation));
yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ExportSimulationModelToFile)
.WithIcon(ApplicationIcons.Report)
.WithCommandFor <CreateSimulationReportCommand, Simulation>(individualSimulation));
}
public static IMenuBarItem CreateParameterIdentification()
{
return(CreateMenuButton.WithCaption(MenuNames.AddParameterIdentification)
.WithDescription(MenuDescriptions.CreateParameterIdentification)
.WithIcon(ApplicationIcons.ParameterIdentification)
.WithCommand <CreateParameterIdentificationUICommand>());
}
protected override IEnumerable <IMenuBarItem> AllMenuItemsFor(ITreeNode nodeRequestingContextMenu, ICompoundProcessesPresenter presenter)
{
yield return
(CreateMenuButton.WithCaption(PKSimConstants.UI.AddInductionProcess)
.WithActionCommand(presenter.AddInductionProcess)
.WithIcon(ApplicationIcons.Induction));
}
protected override IEnumerable <IMenuBarItem> DebugMenuFor(IndividualSimulation simulation)
{
yield return(CreateMenuButton.WithCaption(MenuNames.ExportSimModelXml)
.WithCommandFor <ExportSimulationToSimModelXmlUICommand, Simulation>(simulation)
.AsGroupStarter()
.ForDeveloper());
yield return(ExportSimulationToCppMenuItem(simulation));
yield return(ExportODEForMatlabMenuItem(simulation));
yield return(ExportODEForRMenuItem(simulation));
yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.AsDeveloperOnly("Parameter Ids Export"))
.WithCommandFor <ParameterExportForDebugCommand, Simulation>(simulation)
.ForDeveloper());
yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.AsDeveloperOnly("Simulation Serialization Xml Export"))
.WithCommandFor <SimulationXmlExportCommand, Simulation>(simulation)
.ForDeveloper());
yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.AsDeveloperOnly("Simulation Parameter Export To CSV"))
.WithCommandFor <SimulationParameterExportToCsvCommand, Simulation>(simulation)
.ForDeveloper());
yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.AsDeveloperOnly("Save Snapshot"))
.WithCommandFor <ExportSimulationSnapshotUICommand, Simulation>(simulation)
.WithIcon(ApplicationIcons.SnapshotExport)
.ForDeveloper());
}
private static IMenuBarButton scaleIndividualMenuFor(Individual individual)
{
return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.Scale)
.WithIcon(ApplicationIcons.ScaleIndividual)
.WithCommandFor <ScaleIndividualCommand, Individual>(individual)
.AsGroupStarter());
}
protected override IEnumerable <IMenuBarItem> AllMenuItemsFor(IReadOnlyList <CurveChart> charts)
{
yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.Delete)
.WithCommandFor <RemoveMultipleSummaryChartUICommand, IReadOnlyList <CurveChart> >(charts)
.AsGroupStarter()
.WithIcon(ApplicationIcons.Delete));
}
private IMenuBarItem createNewSimulationMenuBarItem()
{
return(CreateMenuButton.WithCaption(AppConstants.MenuNames.AddNew(ObjectTypes.Simulation))
.WithIcon(ApplicationIcons.Simulation)
.WithCommand <NewSimulationCommand>()
.AsGroupStarter());
}
public static IMenuBarItem Edit(SensitivityAnalysis sensitivityAnalysis)
{
return(CreateMenuButton
.WithCaption(MenuNames.Edit)
.WithIcon(ApplicationIcons.Edit)
.WithCommandFor <EditSensitivityAnalysisUICommand, SensitivityAnalysis>(sensitivityAnalysis));
}
private IMenuBarItem createImportReactionParameters(IMoBiSimulation simulation)
{
return(CreateMenuButton.WithCaption(AppConstants.Captions.ImportSimulationParameters.WithEllipsis())
.WithIcon(ApplicationIcons.ParameterStartValuesImport)
.WithCommandFor <ImportSimulationParameterValuesUICommand, IMoBiSimulation>(simulation)
.AsGroupStarter());
}
protected void AddTemplateLayoutMenuItems(IContextMenuView contextMenuView, IContainerBase containerBase)
{
string containerType = "Diagram";
if (containerBase.IsAnImplementationOf <IContainerNode>())
{
containerType = "Container";
}
IHasLayoutInfo selectedNode = Presenter.GetFirstSelected <IContainerNode>();
if (selectedNode != null)
{
SubMenuLayout.AddItem(CreateMenuButton.WithCaption("Apply Named Template to Selection...")
.WithActionCommand(() => Presenter.ApplyLayoutTemplateToSelection()).AsGroupStarter());
}
else
{
SubMenuLayout.AddItem(CreateMenuButton.WithCaption("Apply Named Template to " + containerType + "...")
.WithActionCommand(() => Presenter.ApplyLayoutTemplate(containerBase, "", false)));
}
SubMenuLayout.AddItem(CreateMenuButton.WithCaption("Apply Named Template to " + containerType + " Recursive...")
.WithActionCommand(() => Presenter.ApplyLayoutTemplate(containerBase, "", true)));
SubMenuLayout.AddItem(CreateMenuButton.WithCaption("Save " + containerType + " as Named Template...")
.WithActionCommand(() => Presenter.SaveContainerToXml(containerBase, "")));
}
private IEnumerable <IMenuBarItem> commonItemsForSimulations(TSimulation simulation)
{
yield return(GenericMenu.EditMenuFor <EditSimulationCommand, Simulation>(simulation));
yield return(RenameMenuFor(simulation));
yield return(DescriptionMenuFor(simulation)
.AsGroupStarter());
yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.Clone)
.WithCommandFor <CloneSimulationCommand, Simulation>(simulation)
.WithIcon(ApplicationIcons.SimulationClone)
.AsDisabledIf(simulation.IsImported)
.AsGroupStarter());
yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.Configure)
.AsDisabledIf(simulation.IsImported)
.WithIcon(ApplicationIcons.SimulationConfigure)
.WithCommandFor <ConfigureSimulationCommand, Simulation>(simulation));
yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.Run)
.WithCommandFor <RunSimulationCommand, Simulation>(simulation)
.WithIcon(ApplicationIcons.Run)
.AsGroupStarter());
}
protected void AddExpandMenuItems(IMenuBarSubMenu subMenuExpand)
{
subMenuExpand.AddItem(CreateMenuButton.WithCaption("Expand Selection").WithActionCommand(() => Presenter.ExpandSelection()));
subMenuExpand.AddItem(CreateMenuButton.WithCaption("Collapse Selection").WithActionCommand(() => Presenter.CollapseSelection()));
subMenuExpand.AddItem(CreateMenuButton.WithCaption("Collapse all Except Selection").WithActionCommand(() => Presenter.CollapseAllExceptSelection()).AsGroupStarter());
}
public static IMenuBarItem LoadBuildingBlockFromSnapshot <T>() where T : class, IPKSimBuildingBlock
{
return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.DevOnlyMenuNameFor("Load from Snapshot"))
.WithCommand <LoadBuildingBlockFromSnapshotUICommand <T> >()
.WithIcon(ApplicationIcons.SnapshotImport)
.ForDeveloper());
}
protected override IEnumerable <IMenuBarItem> AllMenuItemsFor(SystemicProcessNodeType systemicProcessNodeType, ICompoundProcessesPresenter presenter)
{
yield return
(CreateMenuButton.WithCaption(PKSimConstants.UI.AddPartialProcess(systemicProcessNodeType.Name))
.WithActionCommand(() => presenter.AddSystemicProcess(systemicProcessNodeType.SystemicTypes))
.WithIcon(systemicProcessNodeType.Icon));
}
