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));
        }
Exemplo n.º 2
0
        public IMenuBarSubMenu CreateChartTemplateButton(IWithChartTemplates withChartTemplates, Func <CurveChart> retrieveActiveCurveChartFunc,
                                                         Action <CurveChartTemplate> applyTemplateAction)
        {
            _curveChart         = retrieveActiveCurveChartFunc;
            _withChartTemplates = withChartTemplates;
            _loadMenuAction     = applyTemplateAction;

            var chartTemplate = CreateSubMenu.WithCaption(MenuNames.ChartTemplate);

            chartTemplate.AddItem(createLoadButton(loadMenuFor));

            var fromChart = createFromChartMenu();

            var createNew = createCreateMenu();

            fromChart.AddItem(createNew);

            createUpdateMenu(fromChart);

            chartTemplate.AddItem(fromChart);

            var manageTemplatesMenu = createManageMenu();

            chartTemplate.AddItem(manageTemplatesMenu);

            return(chartTemplate);
        }
Exemplo n.º 3
0
    void createSwitch()
    {
        bool found_location = false;

        for (int i = 0; i < 12; i++)
        {
            server = GameObject.Find("/Racks").GetComponent <RackObjectData>().switches[i];

            if (!server.obj.activeSelf)
            {
                found_location = true;
                server.obj.SetActive(true);
                break;
            }
        }

        if (!found_location)
        {
            switch_text.text = "No Switches";
        }
        else
        {
            /*
             *  Call Victor's Function (for ID)
             */
            //server.id = ;

            // highlight object
            subMenuScript = GameObject.Find("/OVRPlayerController/OVRCameraRig/TrackingSpace/RightHandAnchor/Create SubMenu").GetComponent <CreateSubMenu>();
            subMenuScript.created_server = server;

            gameObject.SetActive(false);
            subMenu.SetActive(true);
        }
    }
Exemplo n.º 4
0
        public static IMenuBarItem RemoveSimulationFolderMainMenu(ITreeNode <RootNodeType> simulationFolderNode, IExplorerPresenter presenter)
        {
            var groupMenu = CreateSubMenu.WithCaption(MenuNames.DeleteSubMenu)
                            .WithIcon(ApplicationIcons.Remove)
                            .AsGroupStarter();

            groupMenu.AddItem(ClassificationCommonContextMenuItems.DeleteChildrenClassificationsAndDateMenu(simulationFolderNode, presenter));
            groupMenu.AddItem(ClassificationCommonContextMenuItems.DeleteChildrenClassificationsAndKeepDataMenu(simulationFolderNode, presenter));
            return(groupMenu);
        }
Exemplo n.º 5
0
        private static IMenuBarSubMenu createGroupingSubMenu(ITreeNode <RootNodeType> treeNode, IBuildingBlockExplorerPresenter presenter)
        {
            var groupMenu = CreateSubMenu.WithCaption(MenuNames.GroupBy);

            presenter.AvailableClassificationCategories(treeNode)
            .Each(classification => groupMenu.AddItem(
                      CreateMenuButton.WithCaption(classification.ClassificationName)
                      .WithActionCommand(() => presenter.AddToClassificationTree(treeNode, classification.ClassificationName))));

            return(groupMenu);
        }
        /// <summary>
        ///    Returns the main menu entry for the remove section of a classification Node
        /// </summary>
        public static IMenuBarItem RemoveClassificationMainMenu(ITreeNode <IClassification> classificationNode, IExplorerPresenter presenter)
        {
            var groupMenu = CreateSubMenu.WithCaption(MenuNames.DeleteSubMenu)
                            .WithIcon(ApplicationIcons.Delete)
                            .AsGroupStarter();

            groupMenu.AddItem(DeleteClassificationAndDataMenu(classificationNode, presenter));
            groupMenu.AddItem(DeleteClassificationAndKeepDataMenu(classificationNode, presenter));

            return(groupMenu);
        }
        protected static IMenuBarSubMenu AddClassificationMenu(ClassificationNode classificationNode, TPresenter presenter)
        {
            var groupMenu = CreateSubMenu.WithCaption(MenuNames.GroupBy);

            presenter.AvailableClassificationCategories(classificationNode)
            .Each(classification => groupMenu.AddItem(
                      CreateMenuButton.WithCaption(classification.ClassificationName)
                      .WithIcon(classification.Icon)
                      .WithActionCommand(() => presenter.AddToClassificationTree(classificationNode, classification.ClassificationName))));

            return(groupMenu);
        }
Exemplo n.º 8
0
        private void createUpdateMenu(IMenuBarSubMenu chartTemplate)
        {
            var chartTemplates = allSimulationTemplates().ToList();

            if (chartTemplates.Any())
            {
                var overwrite = CreateSubMenu.WithCaption(MenuNames.UpdateExistingTemplate)
                                .WithIcon(ApplicationIcons.SaveAsTemplate);

                chartTemplates.Each(t => overwrite.AddItem(updateMenuFor(t)));
                chartTemplate.AddItem(overwrite);
            }
        }
Exemplo n.º 9
0
    void createRouter()
    {
        bool found_location = false;

        for (int i = 0; i < 12; i++)
        {
            // server = GameObject.Find("/Racks").GetComponent<RackObjectData>().routers[i];

            if (!GameObject.Find("/Racks").GetComponent <RackObjectData>().routers[i].obj.activeSelf)
            {
                router_index   = i;
                found_location = true;
                GameObject.Find("/Racks").GetComponent <RackObjectData>().routers[i].obj.SetActive(true);
                break;
            }
        }

        if (!found_location)
        {
            router_text.text = "No Routers";
        }
        else
        {
            /*
             *  Call Victor's Function (for ID) 1966b864-93e7-32d5-965f-001384eec461
             */
            StartCoroutine(projectHandle.CreateAppliance(
                               "7465a102-5c54-4cc6-ab76-7e917955223b", // c7200 id
                               (GNS3ProjectHandle.Node node) =>
            {
                //server.name = node.name;
                GameObject.Find("/Racks").GetComponent <RackObjectData>().routers[router_index].name = node.name;

                //server.id = node.node_id;
                GameObject.Find("/Racks").GetComponent <RackObjectData>().routers[router_index].id = node.node_id;

                Debug.Log("Successfully created appliance");

                subMenuScript = GameObject.Find("/OVRPlayerController/OVRCameraRig/TrackingSpace/RightHandAnchor/Create SubMenu").GetComponent <CreateSubMenu>();
                subMenuScript.created_server = GameObject.Find("/Racks").GetComponent <RackObjectData>().routers[router_index];
                sleepMenu();
                //gameObject.SetActive(false);
                subMenu.SetActive(true);
            },
                               () => Debug.Log("Failed to create router")
                               ));
            //server.id =
            // highlight object
        }
    }
Exemplo n.º 10
0
        protected virtual void SetSelectionMenuItems(IContextMenuView contextMenuView, IContainerBase containerBase, IBaseNode node)
        {
            contextMenuView.AddMenuItem(SubMenuSelect);

            if (containerBase != null)
            {
                SubMenuSelect.AddItem(CreateMenuButton.WithCaption("All Children")
                                      .WithActionCommand(() => Presenter.SelectChildren(containerBase)));
            }

            if (Presenter.SelectionContains <IBaseNode>())
            {
                SubMenuSelect.AddItem(CreateMenuButton.WithCaption("Visible Linked nodes")
                                      .WithActionCommand(() => Presenter.SelectVisibleLinkedNodesForDiagramSelection()));
                if (node != null)
                {
                    SubMenuSelect.AddItem(CreateMenuButton.WithCaption("Invert Selection")
                                          .WithActionCommand(() => Presenter.InvertSelection(node.GetParent())));
                }

                IHasLayoutInfo selectedNode = Presenter.GetFirstSelected <IHasLayoutInfo>();
                if (selectedNode != null)
                {
                    SubMenuDiagram.AddItem(CreateMenuCheckButton.WithCaption("Location Fixed").AsGroupStarter()
                                           .WithChecked(selectedNode.LocationFixed)
                                           .WithCheckedAction(locationFixed => Presenter.SetLocationFixedForDiagramSelection(locationFixed)));
                }

                contextMenuView.AddMenuItem(CreateMenuButton.WithCaption("Hide Selection").WithActionCommand(() => Presenter.HideSelection()));
            }

            if (Presenter.SelectionContains <IElementBaseNode>())
            {
                var subMenuNodeSize = CreateSubMenu.WithCaption("Nodesize")
                                      .WithItem(CreateMenuButton.WithCaption("Large").WithActionCommand(() => Presenter.SetNodeSizeForDiagramSelection(NodeSize.Large)))
                                      .WithItem(CreateMenuButton.WithCaption("Middle").WithActionCommand(() => Presenter.SetNodeSizeForDiagramSelection(NodeSize.Middle)))
                                      .WithItem(CreateMenuButton.WithCaption("Small").WithActionCommand(() => Presenter.SetNodeSizeForDiagramSelection(NodeSize.Small)));
                contextMenuView.AddMenuItem(subMenuNodeSize);
            }

            // Shows all children (e.g. after hiding a selection)

            if (containerBase != null)
            {
                contextMenuView.AddMenuItem(CreateMenuButton.WithCaption("Show All Children").WithActionCommand(() => Presenter.ShowChildren(containerBase)));
            }
        }
Exemplo n.º 11
0
        private IMenuBarItem createLoadButton(Func <CurveChartTemplate, IMenuBarButton> loadMenuFor)
        {
            var loadTemplate = CreateSubMenu.WithCaption(MenuNames.ApplyChartTemplate)
                               .WithIcon(ApplicationIcons.Load);

            var noTemplateAvailable = CreateMenuButton.WithCaption(MenuNames.NoTemplateAvailable).WithActionCommand(() => { });
            var chartTemplates      = _withChartTemplates.ChartTemplates.ToList();

            if (chartTemplates.Any())
            {
                chartTemplates.Each(t => loadTemplate.AddItem(loadMenuFor(t)));
            }
            else
            {
                loadTemplate.AddItem(noTemplateAvailable);
            }

            return(loadTemplate);
        }
Exemplo n.º 12
0
    void createSwitch()
    {
        bool found_location = false;

        for (int i = 0; i < 12; i++)
        {
            // server = GameObject.Find("/Racks").GetComponent<RackObjectData>().switches[i];

            if (!GameObject.Find("/Racks").GetComponent <RackObjectData>().switches[i].obj.activeSelf)
            {
                found_location = true;
                switch_index   = i;
                GameObject.Find("/Racks").GetComponent <RackObjectData>().switches[i].obj.SetActive(true);
                break;
            }
        }

        if (!found_location)
        {
            switch_text.text = "No Switches";
        }
        else
        {
            StartCoroutine(projectHandle.CreateAppliance(
                               "1966b864-93e7-32d5-965f-001384eec461", // c7200 id
                               (GNS3ProjectHandle.Node node) =>
            {
                //server.name = node.name;
                GameObject.Find("/Racks").GetComponent <RackObjectData>().switches[switch_index].name = node.name;

                //server.id = node.node_id;
                GameObject.Find("/Racks").GetComponent <RackObjectData>().switches[switch_index].id = node.node_id;

                subMenuScript = GameObject.Find("/OVRPlayerController/OVRCameraRig/TrackingSpace/RightHandAnchor/Create SubMenu").GetComponent <CreateSubMenu>();
                subMenuScript.created_server = GameObject.Find("/Racks").GetComponent <RackObjectData>().switches[switch_index];
                sleepMenu();
                //gameObject.SetActive(false);
                subMenu.SetActive(true);
            },
                               () => Debug.Log("Failed to create router")
                               ));
        }
    }
Exemplo n.º 13
0
        public void ReloadMenus()
        {
            ChartEditorPresenter.ClearButtons();
            var saveAsTemplate = new TestProgramButton("Save as Chart Template", onChartSave);

            ChartEditorPresenter.AddButton(saveAsTemplate);


            var groupMenu = CreateSubMenu.WithCaption("Layouts");

            EnumHelper.AllValuesFor <Layouts>().Each(
                layout => groupMenu.AddItem(new TestProgramButton(layout.ToString(), onLayouts)));

            groupMenu.AddItem(new TestProgramButton("Dummy", () => { }).AsGroupStarter());

            ChartEditorPresenter.AddButton(groupMenu);

            ChartEditorPresenter.AddUsedInMenuItem();

            ChartEditorPresenter.AddChartTemplateMenu(_simulationSettings, template => loadFromTemplate(template));
        }
Exemplo n.º 14
0
        public void Show(IView parentView, Point popupLocationInParentView, PointF locationInDiagramView, IContainerBase containerBase, IBaseNode node)
        {
            var contextMenuView = IoC.Resolve <IContextMenuView>();

            Presenter.CurrentInsertLocation = locationInDiagramView;

            SubMenuSelect  = CreateSubMenu.WithCaption("Select").AsGroupStarter();
            SubMenuLayout  = CreateSubMenu.WithCaption("Layout").AsGroupStarter();
            SubMenuDiagram = CreateSubMenu.WithCaption("Diagram").AsGroupStarter();

            SetModelMenuItems(contextMenuView, containerBase, node);
            SetSelectionMenuItems(contextMenuView, containerBase, node);
            if (containerBase != null)
            {
                SetLayoutMenuItems(contextMenuView, containerBase);
            }
            SetDiagramMenuItems(contextMenuView, containerBase);
            SetDetailedMenuItems(contextMenuView, containerBase);

            contextMenuView.Display(parentView, popupLocationInParentView);
        }
Exemplo n.º 15
0
    void createRouter()
    {
        bool found_location = false;

        if (!found_location)
        {
            router_text.text = "No Routers";
        }
        else
        {
            /*
             *  Call Victor's Function (for ID)
             */
            //server.id = ;

            // highlight object
            subMenuScript = GameObject.Find("/OVRPlayerController/OVRCameraRig/TrackingSpace/RightHandAnchor/Create SubMenu").GetComponent <CreateSubMenu>();
            subMenuScript.created_server = server;

            gameObject.SetActive(false);
            subMenu.SetActive(true);
        }
    }
        protected override IEnumerable <IMenuBarItem> AllMenuBarItems()
        {
            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.NewProject)
                         .WithId(MenuBarItemIds.NewProject)
                         .WithCommand <NewProjectCommand>()
                         .WithIcon(ApplicationIcons.ProjectNew)
                         .WithDescription(PKSimConstants.UI.NewProjectDescription)
                         .WithShortcut(Keys.Control | Keys.N));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.OpenProject)
                         .WithId(MenuBarItemIds.OpenProject)
                         .WithCommand <OpenProjectCommand>()
                         .WithDescription(PKSimConstants.UI.OpenProjectDescription)
                         .WithIcon(ApplicationIcons.ProjectOpen)
                         .WithShortcut(Keys.Control | Keys.O));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ProjectDescription)
                         .WithId(MenuBarItemIds.ProjectDescription)
                         .WithCommand <EditProjectDescriptionCommand>()
                         .WithDescription(PKSimConstants.UI.ProjectDescriptionDescription)
                         .WithIcon(ApplicationIcons.ProjectDescription)
                         .WithShortcut(Keys.Control | Keys.D));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ExportProjectToSnapshot)
                         .WithId(MenuBarItemIds.ExportProjectToSnapshot)
                         .WithCommand <ExportProjectToSnapshotCommand>()
                         .WithDescription(PKSimConstants.UI.ExportProjectToSnapshotDescription)
                         .WithIcon(ApplicationIcons.SnapshotExport));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.LoadProjectFromSnapshot)
                         .WithId(MenuBarItemIds.LoadProjectFromSnahpshot)
                         .WithCommand <LoadProjectFromSnapshotUICommand>()
                         .WithDescription(PKSimConstants.UI.LoadProjectFromSnapshotDescription)
                         .WithIcon(ApplicationIcons.SnapshotImport));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.CloseProject)
                         .WithId(MenuBarItemIds.CloseProject)
                         .WithDescription(PKSimConstants.UI.CloseProjectDescription)
                         .WithCommand <CloseProjectCommand>()
                         .WithIcon(ApplicationIcons.Close));

            yield return(CreateSubMenu.WithCaption(PKSimConstants.MenuNames.SaveProject)
                         .WithId(MenuBarItemIds.SaveGroup)
                         .WithDescription(PKSimConstants.UI.SaveProjectDescription)
                         .WithIcon(ApplicationIcons.Save));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.SaveProject)
                         .WithId(MenuBarItemIds.SaveProject)
                         .WithDescription(PKSimConstants.UI.SaveProjectDescription)
                         .WithCommand <SaveProjectCommand>()
                         .WithIcon(ApplicationIcons.Save)
                         .WithShortcut(Keys.Control | Keys.S));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.SaveProjectAs)
                         .WithId(MenuBarItemIds.SaveProjectAs)
                         .WithDescription(PKSimConstants.UI.SaveProjectAsDescription)
                         .WithIcon(ApplicationIcons.SaveAs)
                         .WithCommand <SaveProjectAsCommand>());

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.NewSimulation)
                         .WithId(MenuBarItemIds.NewSimulation)
                         .WithCommand <AddSimulationCommand>()
                         .WithDescription(PKSimConstants.UI.NewSimulationDescription)
                         .WithIcon(ApplicationIcons.Simulation)
                         .WithShortcut(Keys.Control | Keys.Alt | Keys.S));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ImportIndividualSimulation)
                         .WithId(MenuBarItemIds.NewImportIndividualSimulation)
                         .WithCommand <NewImportIndividualSimulationCommand>()
                         .WithDescription(PKSimConstants.UI.ImportIndividualSimulationDescription)
                         .WithIcon(ApplicationIcons.IndividualSimulationLoad));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ImportPopulationSimulation)
                         .WithId(MenuBarItemIds.NewImportPopulationSimulation)
                         .WithCommand <NewImportPopulationSimulationCommand>()
                         .WithDescription(PKSimConstants.UI.ImportPopulationSimulationDescription)
                         .WithIcon(ApplicationIcons.PopulationSimulationLoad));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.NewIndividual)
                         .WithId(MenuBarItemIds.NewIndividual)
                         .WithCommand <AddIndividualCommand>()
                         .WithDescription(PKSimConstants.UI.NewIndividualDescription)
                         .WithIcon(ApplicationIcons.Individual)
                         .WithShortcut(Keys.Control | Keys.Alt | Keys.I));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.LoadFromTemplate)
                         .WithId(MenuBarItemIds.LoadIndividual)
                         .WithCommand <LoadIndividualCommand>()
                         .WithIcon(ApplicationIcons.LoadFromTemplate));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.NewPopulation)
                         .WithId(MenuBarItemIds.NewPopulation)
                         .WithCommand <AddRandomPopulationCommand>()
                         .WithDescription(PKSimConstants.UI.NewPopulationDescription)
                         .WithIcon(ApplicationIcons.Population)
                         .WithShortcut(Keys.Control | Keys.Alt | Keys.P));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ImportPopulation)
                         .WithId(MenuBarItemIds.ImportPopulation)
                         .WithCommand <ImportPopulationCommand>()
                         .WithDescription(PKSimConstants.UI.ImportPopulationDescription)
                         .WithIcon(ApplicationIcons.MergePopulation));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.LoadFromTemplate)
                         .WithId(MenuBarItemIds.LoadPopulation)
                         .WithCommand <LoadPopulationCommand>()
                         .WithIcon(ApplicationIcons.LoadFromTemplate));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.NewAdministrationProtocol)
                         .WithId(MenuBarItemIds.NewProtocol)
                         .WithCommand <AddProtocolCommand>()
                         .WithDescription(PKSimConstants.UI.NewProtocolDescription)
                         .WithIcon(ApplicationIcons.Protocol)
                         .WithShortcut(Keys.Control | Keys.Alt | Keys.A));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.LoadFromTemplate)
                         .WithId(MenuBarItemIds.LoadProtocol)
                         .WithCommand <LoadProtocolCommand>()
                         .WithIcon(ApplicationIcons.LoadFromTemplate));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.NewFormulation)
                         .WithId(MenuBarItemIds.NewFormulation)
                         .WithCommand <AddFormulationCommand>()
                         .WithDescription(PKSimConstants.UI.NewFormulationDescription)
                         .WithIcon(ApplicationIcons.Formulation)
                         .WithShortcut(Keys.Control | Keys.Alt | Keys.F));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.LoadFromTemplate)
                         .WithId(MenuBarItemIds.LoadFormulationFromTemplate)
                         .WithCommand <LoadFormulationCommand>()
                         .WithIcon(ApplicationIcons.LoadFromTemplate));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.NewEvent)
                         .WithId(MenuBarItemIds.NewEvent)
                         .WithCommand <AddEventCommand>()
                         .WithDescription(PKSimConstants.UI.NewEventDescription)
                         .WithIcon(ApplicationIcons.Event)
                         .WithShortcut(Keys.Control | Keys.Alt | Keys.E));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.LoadFromTemplate)
                         .WithId(MenuBarItemIds.LoadEvent)
                         .WithCommand <LoadEventCommand>()
                         .WithIcon(ApplicationIcons.LoadFromTemplate));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.NewObservers)
                         .WithId(MenuBarItemIds.NewObserverSet)
                         .WithCommand <AddObserverSetCommand>()
                         .WithDescription(PKSimConstants.UI.NewObserversDescription)
                         .WithIcon(ApplicationIcons.Observer));

//            .WithShortcut(Keys.Control | Keys.Alt | Keys.O);

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.LoadFromTemplate)
                         .WithId(MenuBarItemIds.LoadObserverSet)
                         .WithCommand <LoadObserverSetCommand>()
                         .WithIcon(ApplicationIcons.LoadFromTemplate));

            var newExpressionProfile = CreateSubMenu.WithCaption(PKSimConstants.MenuNames.NewExpressionProfile)
                                       .WithIcon(ApplicationIcons.ExpressionProfile)
                                       .WithDescription(PKSimConstants.UI.NewExpressionProfileDescription)
                                       .WithId(MenuBarItemIds.NewExpressionProfile);

            var newEnzyme = CreateMenuButton.WithCaption(PKSimConstants.UI.AddMetabolizingEnzyme)
                            .WithId(MenuBarItemIds.NewExpressionProfileEnzyme)
                            .WithCommand <AddExpressionProfileCommand <IndividualEnzyme> >()
                            .WithIcon(ApplicationIcons.Enzyme);

            var newTransporter = CreateMenuButton.WithCaption(PKSimConstants.UI.AddTransportProtein)
                                 .WithId(MenuBarItemIds.NewExpressionProfileTransporter)
                                 .WithCommand <AddExpressionProfileCommand <IndividualTransporter> >()
                                 .WithIcon(ApplicationIcons.Transporter);

            var newSpecificBinding = CreateMenuButton.WithCaption(PKSimConstants.UI.AddSpecificBindingPartner)
                                     .WithId(MenuBarItemIds.NewExpressionProfileSpecificBindingPartner)
                                     .WithCommand <AddExpressionProfileCommand <IndividualOtherProtein> >()
                                     .WithIcon(ApplicationIcons.SpecificBinding);

            newExpressionProfile.AddItem(newEnzyme);
            newExpressionProfile.AddItem(newTransporter);
            newExpressionProfile.AddItem(newSpecificBinding);

            yield return(newExpressionProfile);

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.LoadFromTemplate)
                         .WithId(MenuBarItemIds.LoadExpressionProfile)
                         .WithCommand <LoadExpressionProfileCommand>()
                         .WithIcon(ApplicationIcons.LoadFromTemplate));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.About)
                         .WithId(MenuBarItemIds.About)
                         .WithCommand <ShowAboutUICommand>()
                         .WithIcon(ApplicationIcons.Info)
                         .WithDescription(PKSimConstants.UI.AboutThisApplication));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.NewCompound)
                         .WithId(MenuBarItemIds.NewCompound)
                         .WithCommand <AddCompoundUICommand>()
                         .WithDescription(PKSimConstants.UI.NewCompoundDescription)
                         .WithIcon(ApplicationIcons.Compound)
                         .WithShortcut(Keys.Control | Keys.Alt | Keys.C));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.LoadFromTemplate)
                         .WithId(MenuBarItemIds.LoadCompound)
                         .WithCommand <LoadCompoundCommand>()
                         .WithIcon(ApplicationIcons.LoadFromTemplate));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.GarbageCollection)
                         .WithId(MenuBarItemIds.GarbageCollection)
                         .WithCommand <GarbageCollectionCommand>()
                         .ForDeveloper());

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.GenerateCalculationMethods)
                         .WithId(MenuBarItemIds.GenerateCalculationMethods)
                         .WithCommand <GenerateCalculationMethodsCommand>()
                         .WithIcon(ApplicationIcons.DistributionCalculation)
                         .ForDeveloper());

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.GeneratePKMLTemplates)
                         .WithId(MenuBarItemIds.GeneratePKMLTemplates)
                         .WithCommand <GeneratePKMLTemplatesCommand>()
                         .WithIcon(ApplicationIcons.PKML)
                         .ForDeveloper());

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.GenerateGroupsTemplate)
                         .WithId(MenuBarItemIds.GenerateGroupsTemplate)
                         .WithCommand <GenerateGroupsTemplateCommand>()
                         .WithIcon(ApplicationIcons.PKML)
                         .ForDeveloper());

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.Options)
                         .WithId(MenuBarItemIds.Options)
                         .WithCommand <SettingsCommand>()
                         .WithDescription(PKSimConstants.UI.OptionsDescription)
                         .WithIcon(ApplicationIcons.Settings)
                         .WithShortcut(Keys.Control | Keys.Shift | Keys.O));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.Exit)
                         .WithId(MenuBarItemIds.Exit)
                         .WithCommand <IExitCommand>()
                         .WithDescription(PKSimConstants.UI.ExitDescription)
                         .WithIcon(ApplicationIcons.Exit)
                         .WithShortcut(Keys.Alt | Keys.F4));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.Run)
                         .WithId(MenuBarItemIds.Run)
                         .WithDescription(PKSimConstants.UI.RunDescription)
                         .WithCommand <RunSimulationCommand>()
                         .WithIcon(ApplicationIcons.Run)
                         .WithShortcut(Keys.F5));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.RunWithSettings)
                         .WithId(MenuBarItemIds.RunWithSettings)
                         .WithDescription(PKSimConstants.UI.RunWithSettingsDescription)
                         .WithCommand <RunSimulationWithSettingsCommand>()
                         .WithIcon(ApplicationIcons.ConfigureAndRun));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.Stop)
                         .WithId(MenuBarItemIds.Stop)
                         .WithDescription(PKSimConstants.UI.StopDescription)
                         .WithCommand <StopSimulationCommand>()
                         .WithIcon(ApplicationIcons.Stop));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.TimeProfileAnalysis)
                         .WithId(MenuBarItemIds.ShowIndividualResults)
                         .WithDescription(PKSimConstants.UI.ShowIndividualResultsDescription)
                         .WithCommand <ShowSimulationResultsCommand>()
                         .WithIcon(ApplicationIcons.TimeProfileAnalysis));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.BoxWhiskerAnalysis)
                         .WithId(MenuBarItemIds.BoxWhiskerAnalysis)
                         .WithDescription(PKSimConstants.UI.BoxWhiskerAnalysisDescription)
                         .WithCommand <StartBoxWhiskerAnalysisCommand>()
                         .WithIcon(ApplicationIcons.BoxWhiskerAnalysis));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ScatterAnalysis)
                         .WithId(MenuBarItemIds.ScatterAnalysis)
                         .WithCommand <StartScatterAnalysisCommand>()
                         .WithDescription(PKSimConstants.UI.ScatterAnalysisDescription)
                         .WithIcon(ApplicationIcons.ScatterAnalysis));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.RangeAnalysis)
                         .WithId(MenuBarItemIds.RangeAnalysis)
                         .WithCommand <StartRangeAnalysisCommand>()
                         .WithDescription(PKSimConstants.UI.RangeAnalysisDescription)
                         .WithIcon(ApplicationIcons.RangeAnalysis));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.TimeProfileAnalysis)
                         .WithId(MenuBarItemIds.TimeProfileAnalysis)
                         .WithCommand <StartTimeProfileAnalysisCommand>()
                         .WithDescription(PKSimConstants.UI.TimeProfileAnalysisDescription)
                         .WithIcon(ApplicationIcons.TimeProfileAnalysis));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.IndividualSimulationComparison)
                         .WithId(MenuBarItemIds.IndividualSimulationComparison)
                         .WithDescription(PKSimConstants.UI.IndividualSimulationComparisonDescription)
                         .WithCommand <CreateIndividualSimulationComparisonUICommand>()
                         .WithIcon(ApplicationIcons.IndividualSimulationComparison));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.Comparison)
                         .WithId(MenuBarItemIds.IndividualSimulationComparisonInAnalyze)
                         .WithDescription(PKSimConstants.UI.IndividualSimulationComparisonDescription)
                         .WithCommand <CreateIndividualSimulationComparisonUICommand>()
                         .WithIcon(ApplicationIcons.IndividualSimulationComparison));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.PopulationPopulationComparison)
                         .WithId(MenuBarItemIds.PopulationSimulationComparison)
                         .WithDescription(PKSimConstants.UI.PopulationSimulationComparisonDescription)
                         .WithCommand <CreatePopulationSimulationComparisonUICommand>()
                         .WithIcon(ApplicationIcons.PopulationSimulationComparison));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.Comparison)
                         .WithId(MenuBarItemIds.PopulationSimulationComparisonInAnalyze)
                         .WithDescription(PKSimConstants.UI.PopulationSimulationComparisonDescription)
                         .WithCommand <CreatePopulationSimulationComparisonUICommand>()
                         .WithIcon(ApplicationIcons.PopulationSimulationComparison));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.HistoryView)
                         .WithId(MenuBarItemIds.HistoryView)
                         .WithDescription(PKSimConstants.UI.HistoryViewDescription)
                         .WithCommand <HistoryVisibilityCommand>()
                         .WithIcon(ApplicationIcons.History)
                         .WithShortcut(Keys.Control | Keys.Shift | Keys.H));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ComparisonView)
                         .WithId(MenuBarItemIds.ComparisonView)
                         .WithDescription(PKSimConstants.UI.ComparisonViewDescription)
                         .WithCommand <ComparisonVisibilityUICommand>()
                         .WithIcon(ApplicationIcons.Comparison)
                         .WithShortcut(Keys.Control | Keys.Shift | Keys.N));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.SimulationExplorerView)
                         .WithId(MenuBarItemIds.SimulationExplorerView)
                         .WithDescription(PKSimConstants.UI.SimulationExplorerViewDescription)
                         .WithCommand <SimulationExplorerVisibilityCommand>()
                         .WithIcon(ApplicationIcons.SimulationExplorer)
                         .WithShortcut(Keys.Control | Keys.Shift | Keys.S));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.BuildingBlockExplorerView)
                         .WithId(MenuBarItemIds.BuildingBlockExplorerView)
                         .WithDescription(PKSimConstants.UI.BuildingBlockExplorerViewDescription)
                         .WithCommand <BuildingBlockExplorerVisibilityCommand>()
                         .WithIcon(ApplicationIcons.BuildingBlockExplorer)
                         .WithShortcut(Keys.Control | Keys.Shift | Keys.B));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.AddObservedData)
                         .WithId(MenuBarItemIds.AddObservedData)
                         .WithDescription(PKSimConstants.UI.AddObservedDataDescription)
                         .WithCommand <ImportConcentrationDataCommand>()
                         .WithIcon(ApplicationIcons.ObservedData));

            yield return(CreateSubMenu.WithCaption(PKSimConstants.MenuNames.ExportHistory)
                         .WithId(MenuBarItemIds.HistoryReportGroup)
                         .WithIcon(ApplicationIcons.HistoryExport));

            yield return(CreateMenuButton.WithCaption(MenuNames.ExportToExcel)
                         .WithId(MenuBarItemIds.HistoryReportExcel)
                         .WithDescription(PKSimConstants.UI.ExportHistoryToExcelDescription)
                         .WithCommand <ExportHistoryToExcelCommand>()
                         .WithIcon(ApplicationIcons.Excel));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.CloneMenu)
                         .WithId(MenuBarItemIds.CloneActiveSimulation)
                         .WithDescription(PKSimConstants.UI.CloneSimulation)
                         .WithCommand <CloneSimulationCommand>()
                         .WithIcon(ApplicationIcons.SimulationClone));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ConfigureShortMenu)
                         .WithId(MenuBarItemIds.ConfigureActiveSimulation)
                         .WithDescription(PKSimConstants.UI.ConfigureSimulationDescription)
                         .WithCommand <ConfigureSimulationCommand>()
                         .WithIcon(ApplicationIcons.SimulationConfigure));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ExportToMoBiShortMEnu)
                         .WithId(MenuBarItemIds.ExportActiveSimulationToMoBi)
                         .WithDescription(PKSimConstants.UI.ExportActiveSimulationToMoBiDescription)
                         .WithCommand <ExportSimulationToMoBiCommand>()
                         .WithIcon(ApplicationIcons.MoBi));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ExportToPKMLShortMenu)
                         .WithId(MenuBarItemIds.ExportActiveSimulationToPkml)
                         .WithDescription(PKSimConstants.UI.ExportSimulationToMoBiTitle)
                         .WithCommand <SaveSimulationToMoBiFileCommand>()
                         .WithIcon(ApplicationIcons.PKMLSave));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ExportSimulationResultsToExcelMenu)
                         .WithId(MenuBarItemIds.ExportActiveSimulationResultsToExcel)
                         .WithDescription(PKSimConstants.UI.ExportSimulationResultsToExcel)
                         .WithCommand <ExportSimulationResultsToExcelCommand>()
                         .WithIcon(ApplicationIcons.ExportToExcel));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ExportSimulationResultsToCSVMenu)
                         .WithId(MenuBarItemIds.ExportActiveSimulationResultsToCSV)
                         .WithDescription(PKSimConstants.UI.ExportSimulationResultsToCSV)
                         .WithCommand <ExportSimulationResultsToCSVCommand>()
                         .WithIcon(ApplicationIcons.ExportToCSV));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ExportPopulationToCSVMenu)
                         .WithId(MenuBarItemIds.ExportActiveSimulationPopulationToExcel)
                         .WithDescription(PKSimConstants.UI.ExportPopulationToCSVTitle)
                         .WithCommand <ExportPopulationSimulationToCSVCommand>()
                         .WithIcon(ApplicationIcons.PopulationExportToCSV));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ExportPKAnalysesToCSVMenu)
                         .WithId(MenuBarItemIds.ExportActiveSimulationPKAnalysesToCSV)
                         .WithDescription(PKSimConstants.MenuNames.ExportPKAnalysesToCSV)
                         .WithCommand <ExportPopulationSimulationPKAnalysesCommand>()
                         .WithIcon(ApplicationIcons.PKAnalysesExportToCSV));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ExportForClusterComputationsMenu)
                         .WithId(MenuBarItemIds.ExportActiveSimulationForClusterComputations)
                         .WithCommand <ExportPopulationSimulationForClusterCommand>()
                         .WithIcon(ApplicationIcons.ClusterExport));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ImportSimulationResultsFromCSVMenu)
                         .WithId(MenuBarItemIds.ImportActiveSimulationResults)
                         .WithCommand <ImportSimulationResultsCommand>()
                         .WithIcon(ApplicationIcons.ResultsImportFromCSV));

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.ImportPKAnalysesFromCSVMenu)
                         .WithId(MenuBarItemIds.ImportActiveSimulationPKParameters)
                         .WithIcon(ApplicationIcons.PKAnalysesImportFromCSV)
                         .WithCommand <ImportPKAnalysesCommand>());

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.LoadPopulationAnalysisWorkflowFromTemplateMenu)
                         .WithId(MenuBarItemIds.LoadPopulationSimulationWorkflow)
                         .WithDescription(PKSimConstants.UI.LoadPopulationAnalysisWorkflowFromTemplateDescription)
                         .WithIcon(ApplicationIcons.AnalysesLoad)
                         .WithCommand <LoadPopulationAnalysisWorkflowFromTemplateUICommand>());

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.SavePopulationAnalysisWorkflowToTemplateMenu)
                         .WithId(MenuBarItemIds.SavePopulationSimulationWorkflow)
                         .WithDescription(PKSimConstants.UI.SavePopulationAnalysisWorkflowToTemplateDescription)
                         .WithIcon(ApplicationIcons.AnalysesSave)
                         .WithCommand <SavePopulationAnalysisWorkflowToTemplateUICommand>());

            yield return(CreateMenuButton.WithCaption(PKSimConstants.MenuNames.RemoveUnusedContent)
                         .WithId(MenuBarItemIds.RemoveUnusedContent)
                         .WithCommand <RemoveUnusedContentUICommand>()
                         .WithIcon(ApplicationIcons.Delete)
                         .ForDeveloper());

            yield return(CommonMenuBarButtons.ManageUserDisplayUnits(MenuBarItemIds.ManageUserDisplayUnits));

            yield return(CommonMenuBarButtons.ManageProjectDisplayUnits(MenuBarItemIds.ManageProjectDisplayUnits));

            yield return(CommonMenuBarButtons.UpdateAllToDisplayUnits(MenuBarItemIds.UpdateAllToDisplayUnits));

            yield return(CommonMenuBarButtons.ClearHistory(MenuBarItemIds.ClearHistory));

            yield return(CommonMenuBarButtons.Help(MenuBarItemIds.Help));

            yield return(JournalMenuBarButtons.JournalView(MenuBarItemIds.JournalView));

            yield return(JournalMenuBarButtons.CreateJournalPage(MenuBarItemIds.CreateJournalPage));

            yield return(JournalMenuBarButtons.SelectJournal(MenuBarItemIds.SelectJournal));

            yield return(JournalMenuBarButtons.JournalEditorView(MenuBarItemIds.JournalEditorView));

            yield return(CommonMenuBarButtons.JournalDiagramView(MenuBarItemIds.JournalDiagramView));

            yield return(JournalMenuBarButtons.SearchJournal(MenuBarItemIds.SearchJournal));

            yield return(CommonMenuBarButtons.LoadFavoritesFromFile(MenuBarItemIds.LoadFavorites));

            yield return(CommonMenuBarButtons.SaveFavoritesToFile(MenuBarItemIds.SaveFavorites));

            yield return(JournalMenuBarButtons.ExportJournal(MenuBarItemIds.ExportJournal));

            yield return(JournalMenuBarButtons.RefreshJournal(MenuBarItemIds.RefreshJournal));

            yield return(ParameterIdentificationMenuBarButtons.CreateParameterIdentification(MenuBarItemIds.CreateParameterIdentification));

            yield return(ParameterIdentificationMenuBarButtons.RunParameterIdentification(MenuBarItemIds.RunParameterIdentification));

            yield return(ParameterIdentificationMenuBarButtons.StopParameterIdentification(MenuBarItemIds.StopParameterIdentification));

            yield return(ParameterIdentificationMenuBarButtons.TimeProfileParameterIdentification(MenuBarItemIds.TimeProfileParameterIdentification));

            yield return(ParameterIdentificationMenuBarButtons.PredictedVsObservedParameterIdentification(MenuBarItemIds.PredictedVsObservedParameterIdentification));

            yield return(ParameterIdentificationMenuBarButtons.ResidualsVsTimeParameterIdentification(MenuBarItemIds.ResidualsVsTimeParameterIdentifcation));

            yield return(ParameterIdentificationMenuBarButtons.ResidualHistogramParameterIdentification(MenuBarItemIds.ResidualHistogramParameterIdentification));

            yield return(ParameterIdentificationMenuBarButtons.CorrelationMatrixParameterIdentification(MenuBarItemIds.CorrelationMatrixParameterIdentification));

            yield return(ParameterIdentificationMenuBarButtons.CovarianceMatrixParameterIdentification(MenuBarItemIds.CovarianceMatrixParameterIdentification));

            yield return(ParameterIdentificationMenuBarButtons.ParameterIdentificationFeedbackView(MenuBarItemIds.ParameterIdentificationFeedbackView));

            yield return(ParameterIdentificationMenuBarButtons.TimeProfilePredictionInterval(MenuBarItemIds.TimeProfilePredictionInterval));

            yield return(ParameterIdentificationMenuBarButtons.TimeProfileVPCInterval(MenuBarItemIds.TimeProfileVPCInterval));

            yield return(ParameterIdentificationMenuBarButtons.TimeProfileConfidenceInterval(MenuBarItemIds.TimeProfileConfidenceInterval));

            yield return(SensitivityAnalysisMenuBarButtons.SensitivityAnalysisPKParameterAnalysis(MenuBarItemIds.SensitivityAnalysisPKParameterAnalysis));

            yield return(SensitivityAnalysisMenuBarButtons.CreateSensitivityAnalysis(MenuBarItemIds.CreateSensitivityAnalysis));

            yield return(SensitivityAnalysisMenuBarButtons.SensitivityAnalysisFeedbackView(MenuBarItemIds.SensitivityAnalysisFeedbackView));

            yield return(SensitivityAnalysisMenuBarButtons.RunSensitivityAnalysis(MenuBarItemIds.RunSensitivityAnalysis));

            yield return(SensitivityAnalysisMenuBarButtons.StopSensitivityAnalysis(MenuBarItemIds.StopSensitivityAnalysis));
        }
Exemplo n.º 17
0
        protected override IEnumerable <IMenuBarItem> AllMenuBarItems()
        {
            yield return(CreateSubMenu.WithCaption(AppConstants.MenuNames.NewProject)
                         .WithId(MenuBarItemIds.NewProject)
                         .WithDescription(ToolTips.FileRibbon.NewProjectDescription)
                         .WithIcon(ApplicationIcons.ProjectNew));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NewAmountProject)
                         .WithId(MenuBarItemIds.NewAmountProject)
                         .WithDescription(ToolTips.FileRibbon.NewAmountProjectDescription)
                         .WithIcon(ApplicationIcons.AmountProjectNew)
                         .WithCommand <NewAmountProjectCommand>());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NewConcentrationProject)
                         .WithId(MenuBarItemIds.NewConcentrationProject)
                         .WithDescription(ToolTips.FileRibbon.NewConcentrationProjectDescription)
                         .WithIcon(ApplicationIcons.ConcentrationProjectNew)
                         .WithCommand <NewConcentrationProjectCommand>());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.OpenProject)
                         .WithId(MenuBarItemIds.OpenProject)
                         .WithDescription(ToolTips.FileRibbon.OpenProjectDescription)
                         .WithCommand <OpenProjectCommand>()
                         .WithIcon(ApplicationIcons.ProjectOpen)
                         .WithShortcut(Keys.Control | Keys.O));

            yield return(CreateSubMenu.WithCaption(AppConstants.MenuNames.SaveProject)
                         .WithId(MenuBarItemIds.SaveGroup)
                         .WithDescription(ToolTips.FileRibbon.SaveProjectDescription)
                         .WithIcon(ApplicationIcons.Save));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.SaveProject)
                         .WithId(MenuBarItemIds.SaveProject)
                         .WithDescription(ToolTips.FileRibbon.SaveProjectDescription)
                         .WithCommand <SaveProjectCommand>()
                         .WithIcon(ApplicationIcons.Save)
                         .WithShortcut(Keys.Control | Keys.S));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.SaveAs)
                         .WithId(MenuBarItemIds.SaveProjectAs)
                         .WithDescription(ToolTips.FileRibbon.SaveProjectDescription)
                         .WithIcon(ApplicationIcons.SaveAs)
                         .WithCommand <SaveProjectAsCommand>());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.About)
                         .WithId(MenuBarItemIds.About)
                         .WithCommand <ShowAboutUICommand>()
                         .WithIcon(ApplicationIcons.About)
                         .WithDescription(ToolTips.FileRibbon.AboutThisApplication));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.Merge)
                         .WithId(MenuBarItemIds.Merge)
                         .WithDescription(ToolTips.WorkFlowRibbon.Merge)
                         .WithCommand <MergeBuildingBlocksUICommand>()
                         .WithIcon(ApplicationIcons.Merge));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.CloseProject)
                         .WithId(MenuBarItemIds.CloseProject)
                         .WithDescription(ToolTips.FileRibbon.CloseProjectDescription)
                         .WithIcon(ApplicationIcons.CloseProject)
                         .WithCommand <CloseProjectCommand>());


            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.GarbageCollection)
                         .WithId(MenuBarItemIds.GarbageCollection)
                         .WithCommand <GarbageCollectionCommand>()
                         .ForDeveloper());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.Options)
                         .WithId(MenuBarItemIds.Options)
                         .WithCommand <UserSettingsCommand>()
                         .WithIcon(ApplicationIcons.UserSettings)
                         .WithDescription(ToolTips.ExtrasRibbon.Options)
                         .WithShortcut(Keys.Control | Keys.Shift | Keys.O));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.Exit)
                         .WithId(MenuBarItemIds.Exit)
                         .WithIcon(ApplicationIcons.Exit)
                         .WithDescription(ToolTips.FileRibbon.ExitDescription)
                         .WithCommand <IExitCommand>()
                         .WithShortcut(Keys.Alt | Keys.F4));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.Run)
                         .WithId(MenuBarItemIds.Run)
                         .WithDescription(ToolTips.SimulationRibbon.RunSimulation)
                         .WithCommand <RunActiveSimulationCommand>()
                         .WithIcon(ApplicationIcons.Run)
                         .WithShortcut(Keys.F5));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.RunWithSettings)
                         .WithId(MenuBarItemIds.RunWithSettings)
                         .WithDescription(ToolTips.SimulationRibbon.RunWithSettingsDescription)
                         .WithCommand <RunActiveSimulationWithSettingsCommand>()
                         .WithIcon(ApplicationIcons.ConfigureAndRun));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.CalculateScaleDivisor)
                         .WithId(MenuBarItemIds.CalculateScaleFactors)
                         .WithDescription(ToolTips.SimulationRibbon.CalculateScaleFactors)
                         .WithCommand <CalculateScaleFactorCommand>()
                         .WithIcon(ApplicationIcons.ScaleFactor));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.Stop)
                         .WithId(MenuBarItemIds.Stop)
                         .WithDescription(ToolTips.SimulationRibbon.StopSimulation)
                         .WithCommand <StopSimulationCommand>()
                         .WithIcon(ApplicationIcons.Stop));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.HistoryView)
                         .WithId(MenuBarItemIds.HistoryView)
                         .WithDescription(ToolTips.ViewRibbon.ViewsHistoryManager)
                         .WithCommand <ShowHistoryCommand>()
                         .WithIcon(ApplicationIcons.History)
                         .WithShortcut(Keys.Control | Keys.Shift | Keys.H));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.SearchView)
                         .WithId(MenuBarItemIds.SearchView)
                         .WithDescription(ToolTips.ViewRibbon.ViewSearch)
                         .WithIcon(ApplicationIcons.Search)
                         .WithCommand <ShowSearchCommand>()
                         .WithShortcut(Keys.Control | Keys.Shift | Keys.F));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NotificationView)
                         .WithId(MenuBarItemIds.NotificationView)
                         .WithDescription(ToolTips.ViewRibbon.ViewNotification)
                         .WithIcon(ApplicationIcons.Warning)
                         .WithCommand <ShowNotificationCommand>()
                         .WithShortcut(Keys.Control | Keys.Shift | Keys.W));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.ComparisonView)
                         .WithId(MenuBarItemIds.ComparisonView)
                         .WithDescription(ToolTips.ViewRibbon.ViewComparison)
                         .WithIcon(ApplicationIcons.Comparison)
                         .WithCommand <ComparisonVisibilityUICommand>()
                         .WithShortcut(Keys.Control | Keys.Shift | Keys.N));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.OpenSimulation)
                         .WithId(MenuBarItemIds.OpenSimulation)
                         .WithDescription(ToolTips.FileRibbon.OpenSimulationDescription)
                         .WithCommand <OpenSimulationCommand>()
                         .WithIcon(ApplicationIcons.Simulation));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.LoadIntoProject)
                         .WithId(MenuBarItemIds.LoadSimulationIntoProject)
                         .WithDescription(ToolTips.ImportRibbon.LoadSimulation)
                         .WithCommand <LoadProjectUICommand>()
                         .WithIcon(ApplicationIcons.Simulation));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.AddObservedData)
                         .WithId(MenuBarItemIds.AddObservedData)
                         .WithDescription(ToolTips.ImportRibbon.AddObservedData)
                         .WithIcon(ApplicationIcons.ObservedData)
                         .WithCommand <ImportDataRepositoryUICommand>());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.LoadObservedData)
                         .WithId(MenuBarItemIds.LoadObservedData)
                         .WithDescription(ToolTips.ImportRibbon.LoadObservedData)
                         .WithIcon(ApplicationIcons.PKMLLoad)
                         .WithCommand <LoadDataRepositoryUICommand>());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.BuildingBlockExplorer)
                         .WithId(MenuBarItemIds.BuildingBlockExplorerView)
                         .WithIcon(ApplicationIcons.BuildingBlockExplorer)
                         .WithDescription(ToolTips.ViewRibbon.ViewBBs)
                         .WithCommand <ShowBuildingBlockExplorerCommand>()
                         .WithShortcut(Keys.Control | Keys.Shift | Keys.B));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.SimulationExplorer)
                         .WithId(MenuBarItemIds.SimulationExplorerView)
                         .WithDescription(ToolTips.ViewRibbon.ViewSims)
                         .WithIcon(ApplicationIcons.SimulationExplorer)
                         .WithCommand <ShowSimulationExplorerCommand>()
                         .WithShortcut(Keys.Control | Keys.Shift | Keys.S));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NewMoleculeBuildingBlock)
                         .WithId(MenuBarItemIds.NewMoleculesBB)
                         .WithIcon(ApplicationIcons.Molecule)
                         .WithDescription(ToolTips.ModellingRibbon.CreateMoleculesBB)
                         .WithShortcut(Keys.Control | Keys.Alt | Keys.Shift | Keys.M)
                         .WithCommand <AddNewBuildingBlockCommand <IMoleculeBuildingBlock> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NewReactionBuildingBlock)
                         .WithId(MenuBarItemIds.NewReactionBB)
                         .WithDescription(ToolTips.ModellingRibbon.CreateReactionsBB)
                         .WithIcon(ApplicationIcons.Reaction)
                         .WithShortcut(Keys.Control | Keys.Alt | Keys.Shift | Keys.R)
                         .WithCommand <AddNewBuildingBlockCommand <IMoBiReactionBuildingBlock> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NewSpatialStructure)
                         .WithId(MenuBarItemIds.NewSpatialStructure)
                         .WithIcon(ApplicationIcons.SpatialStructure)
                         .WithDescription(ToolTips.ModellingRibbon.CreateSpatStructuresBB)
                         .WithShortcut(Keys.Control | Keys.Alt | Keys.Shift | Keys.P)
                         .WithCommand <AddNewBuildingBlockCommand <IMoBiSpatialStructure> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NewPassiveTransportBuildingBlock)
                         .WithId(MenuBarItemIds.NewPassiveTransportBB)
                         .WithIcon(ApplicationIcons.PassiveTransport)
                         .WithDescription(ToolTips.ModellingRibbon.CreatePassiveTansportsBB)
                         .WithShortcut(Keys.Control | Keys.Alt | Keys.Shift | Keys.T)
                         .WithCommand <AddNewBuildingBlockCommand <IPassiveTransportBuildingBlock> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NewEventsBuildingBlock)
                         .WithId(MenuBarItemIds.NewEventBB)
                         .WithIcon(ApplicationIcons.Event)
                         .WithDescription(ToolTips.ModellingRibbon.CreateEventGroupsBB)
                         .WithShortcut(Keys.Control | Keys.Alt | Keys.Shift | Keys.E)
                         .WithCommand <AddNewBuildingBlockCommand <IEventGroupBuildingBlock> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NewSimulationSettingsBuildingBlock)
                         .WithId(MenuBarItemIds.NewSimulationSettingsBB)
                         .WithIcon(ApplicationIcons.SimulationSettings)
                         .WithDescription(ToolTips.ModellingRibbon.CreateSimulationSettingsBB)
                         .WithShortcut(Keys.Control | Keys.Alt | Keys.Shift | Keys.N)
                         .WithCommand <AddNewBuildingBlockCommand <ISimulationSettings> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NewObserverBuildingBlock)
                         .WithId(MenuBarItemIds.NewObserverBB)
                         .WithIcon(ApplicationIcons.Observer)
                         .WithDescription(ToolTips.ModellingRibbon.CreateObserversBB)
                         .WithShortcut(Keys.Control | Keys.Alt | Keys.Shift | Keys.O)
                         .WithCommand <AddNewBuildingBlockCommand <IObserverBuildingBlock> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NewSimulation)
                         .WithId(MenuBarItemIds.NewSimulation)
                         .WithCommand <NewSimulationCommand>()
                         .WithDescription(ToolTips.SimulationRibbon.CreateSimulation)
                         .WithIcon(ApplicationIcons.Simulation)
                         .WithShortcut(Keys.Control | Keys.Alt | Keys.Shift | Keys.S));

            yield return(CreateSubMenu.WithCaption(AppConstants.MenuNames.ExportHistory)
                         .WithId(MenuBarItemIds.HistoryReportGroup)
                         .WithIcon(ApplicationIcons.HistoryExport));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.ExportHistoryToExcel)
                         .WithId(MenuBarItemIds.ExportHistoryToExcel)
                         .WithDescription(ToolTips.ExportRibbon.CreateReport)
                         .WithIcon(ApplicationIcons.Excel)
                         .WithCommand <ExportHistoryUICommand>());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.ExportHistoryToPDF)
                         .WithId(MenuBarItemIds.ExportHistoryToPDF)
                         .WithDescription(ToolTips.ExportRibbon.ExportHistoryToPDF)
                         .WithIcon(ApplicationIcons.ExportToPDF)
                         .WithCommand <ExportHistoryToPDFCommand>());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.ProjectReport)
                         .WithId(MenuBarItemIds.ExportProjectToPDF)
                         .WithDescription(ToolTips.ExportRibbon.ExportToPDF)
                         .WithIcon(ApplicationIcons.ExportToPDF)
                         .WithCommand <ExportProjectToPDFCommand>());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NewMolecule)
                         .WithId(MenuBarItemIds.NewMolecule)
                         .WithDescription(ToolTips.BuildingBlockMolecule.NewMolecule)
                         .WithIcon(ApplicationIcons.MoleculeAdd)
                         .WithCommand <AddNewCommandFor <IMoleculeBuildingBlock, IMoleculeBuilder> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.LoadMolecule)
                         .WithId(MenuBarItemIds.LoadMolecule)
                         .WithDescription(ToolTips.BuildingBlockMolecule.LoadMolecule)
                         .WithIcon(ApplicationIcons.MoleculeLoad)
                         .WithCommand <AddExistingCommandFor <IMoleculeBuildingBlock, IMoleculeBuilder> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.LoadMoleculeFromTemplate)
                         .WithId(MenuBarItemIds.LoadMoleculeFromTemplate)
                         .WithDescription(ToolTips.BuildingBlockMolecule.LoadMolecule)
                         .WithIcon(ApplicationIcons.LoadFromTemplate)
                         .WithCommand <AddExistingFromTemplateCommandFor <IMoleculeBuildingBlock, IMoleculeBuilder> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.AddPKSimMolecule)
                         .WithId(MenuBarItemIds.AddPKSimMolecule)
                         .WithDescription(ToolTips.BuildingBlockMolecule.AddPKSimMolecule)
                         .WithIcon(ApplicationIcons.PKSimMoleculeAdd)
                         .WithCommand <AddPKSimMoleculeCommand>());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NewReaction)
                         .WithId(MenuBarItemIds.NewReaction)
                         .WithDescription(ToolTips.BuildingBlockReaction.NewReaction)
                         .WithIcon(ApplicationIcons.ReactionAdd)
                         .WithCommand <AddNewCommandFor <IMoBiReactionBuildingBlock, IReactionBuilder> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.LoadReaction)
                         .WithId(MenuBarItemIds.LoadReaction)
                         .WithDescription(ToolTips.BuildingBlockReaction.LoadReaction)
                         .WithIcon(ApplicationIcons.ReactionLoad)
                         .WithCommand <AddExistingCommandFor <IMoBiReactionBuildingBlock, IReactionBuilder> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.LoadReactionFromTemplate)
                         .WithId(MenuBarItemIds.LoadReactionFromTemplate)
                         .WithDescription(ToolTips.BuildingBlockReaction.LoadReaction)
                         .WithIcon(ApplicationIcons.LoadFromTemplate)
                         .WithCommand <AddExistingFromTemplateCommandFor <IMoBiReactionBuildingBlock, IReactionBuilder> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NewTopContainer)
                         .WithId(MenuBarItemIds.NewTopContainer)
                         .WithDescription(ToolTips.BuildingBlockSpatialStructure.NewTopContainer)
                         .WithIcon(ApplicationIcons.ContainerAdd)
                         .WithCommand <AddNewTopContainerCommand>());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.LoadTopContainer)
                         .WithId(MenuBarItemIds.LoadTopContainer)
                         .WithDescription(ToolTips.BuildingBlockSpatialStructure.LoadTopContainer)
                         .WithIcon(ApplicationIcons.ContainerLoad)
                         .WithCommand <AddExistingTopContainerCommand>());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.LoadTopContainerFromTemplate)
                         .WithId(MenuBarItemIds.LoadTopContainerFromTemplate)
                         .WithDescription(ToolTips.BuildingBlockSpatialStructure.LoadTopContainer)
                         .WithIcon(ApplicationIcons.LoadFromTemplate)
                         .WithCommand <AddExistingFromTemplateTopContainerCommand>());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NewPassiveTransport)
                         .WithId(MenuBarItemIds.NewPassiveTransport)
                         .WithDescription(ToolTips.BuildingBlockPassiveTransport.NewTransport)
                         .WithIcon(ApplicationIcons.Create)
                         .WithCommand <AddNewCommandFor <IPassiveTransportBuildingBlock, ITransportBuilder> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.LoadPassiveTransport)
                         .WithId(MenuBarItemIds.LoadPassiveTransport)
                         .WithIcon(ApplicationIcons.PKMLLoad)
                         .WithDescription(ToolTips.BuildingBlockPassiveTransport.LoadTransport)
                         .WithCommand <AddExistingCommandFor <IPassiveTransportBuildingBlock, ITransportBuilder> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.LoadPassiveTransportFromTemplate)
                         .WithId(MenuBarItemIds.LoadPassiveTransportFromTemplate)
                         .WithIcon(ApplicationIcons.LoadFromTemplate)
                         .WithDescription(ToolTips.BuildingBlockPassiveTransport.LoadTransport)
                         .WithCommand <AddExistingFromTemplateCommandFor <IPassiveTransportBuildingBlock, ITransportBuilder> >());

            yield return(CreateSubMenu.WithCaption(AppConstants.MenuNames.NewObserver)
                         .WithId(MenuBarItemIds.NewObserverGroup)
                         .WithDescription(ToolTips.BuildingBlockObserver.NewObserver)
                         .WithIcon(ApplicationIcons.Create));

            yield return(CreateSubMenu.WithCaption(AppConstants.MenuNames.LoadObserver)
                         .WithId(MenuBarItemIds.LoadObserverGroup)
                         .WithDescription(ToolTips.BuildingBlockObserver.LoadObserver)
                         .WithIcon(ApplicationIcons.ObserverLoad));

            yield return(CreateSubMenu.WithCaption(AppConstants.MenuNames.LoadObserverFromTemplate)
                         .WithId(MenuBarItemIds.LoadObserverFromTemplateGroup)
                         .WithDescription(ToolTips.BuildingBlockObserver.LoadObserver)
                         .WithIcon(ApplicationIcons.LoadFromTemplate));

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NewAmountObserver)
                         .WithId(MenuBarItemIds.NewAmountObserver)
                         .WithIcon(ApplicationIcons.Create)
                         .WithDescription(ToolTips.BuildingBlockObserver.NewAmountObs)
                         .WithCommand <AddNewCommandFor <IObserverBuildingBlock, IAmountObserverBuilder> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NewContainerObserver)
                         .WithId(MenuBarItemIds.NewContainerObserver)
                         .WithDescription(ToolTips.BuildingBlockObserver.NewContainerObs)
                         .WithIcon(ApplicationIcons.Create)
                         .WithCommand <AddNewCommandFor <IObserverBuildingBlock, IContainerObserverBuilder> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.LoadContainerObserver)
                         .WithId(MenuBarItemIds.LoadContainerObserver)
                         .WithDescription(ToolTips.BuildingBlockObserver.LoadContainerObs)
                         .WithIcon(ApplicationIcons.ObserverLoad)
                         .WithCommand <AddExistingCommandFor <IObserverBuildingBlock, IContainerObserverBuilder> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.LoadContainerObserverFromTemplate)
                         .WithId(MenuBarItemIds.LoadContainerObserverFromTemplate)
                         .WithDescription(ToolTips.BuildingBlockObserver.LoadContainerObs)
                         .WithIcon(ApplicationIcons.LoadFromTemplate)
                         .WithCommand <AddExistingFromTemplateCommandFor <IObserverBuildingBlock, IContainerObserverBuilder> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.LoadAmountObserver)
                         .WithId(MenuBarItemIds.LoadAmountObserver)
                         .WithDescription(ToolTips.BuildingBlockObserver.LoadAmountObs)
                         .WithIcon(ApplicationIcons.ObserverLoad)
                         .WithCommand <AddExistingCommandFor <IObserverBuildingBlock, IAmountObserverBuilder> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.LoadAmountObserverFromTemplate)
                         .WithId(MenuBarItemIds.LoadAmountObserverFromTemplate)
                         .WithDescription(ToolTips.BuildingBlockObserver.LoadAmountObs)
                         .WithIcon(ApplicationIcons.LoadFromTemplate)
                         .WithCommand <AddExistingFromTemplateCommandFor <IObserverBuildingBlock, IAmountObserverBuilder> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.NewEvent)
                         .WithId(MenuBarItemIds.NewEvent)
                         .WithDescription(ToolTips.BuildingBlockEventGroup.NewEventGroup)
                         .WithIcon(ApplicationIcons.EventAdd)
                         .WithCommand <AddNewCommandFor <IEventGroupBuildingBlock, IEventGroupBuilder> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.LoadEvent)
                         .WithId(MenuBarItemIds.LoadEvent)
                         .WithDescription(ToolTips.BuildingBlockEventGroup.LoadEventGroup)
                         .WithIcon(ApplicationIcons.EventLoad)
                         .WithCommand <AddExistingCommandFor <IEventGroupBuildingBlock, IEventGroupBuilder> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.LoadEventFromTemplate)
                         .WithId(MenuBarItemIds.LoadEventFromTemplate)
                         .WithDescription(ToolTips.BuildingBlockEventGroup.LoadEventGroup)
                         .WithIcon(ApplicationIcons.LoadFromTemplate)
                         .WithCommand <AddExistingFromTemplateCommandFor <IEventGroupBuildingBlock, IEventGroupBuilder> >());

            yield return(CreateMenuButton.WithCaption(AppConstants.RibbonButtonNames.NewMolecule)
                         .WithId(MenuBarItemIds.NewReactionMolecule)
                         .WithDescription(ToolTips.BuildingBlockReaction.NewMolecule)
                         .WithIcon(ApplicationIcons.MoleculeAdd)
                         .WithCommand <AddMoleculeNameUICommand>());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.ZoomIn)
                         .WithId(MenuBarItemIds.ZoomIn)
                         .WithDescription(ToolTips.ZoomIn)
                         .WithIcon(ApplicationIcons.ZoomIn)
                         .WithCommand <ZoomInCommand>());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.ZoomOut)
                         .WithId(MenuBarItemIds.ZoomOut)
                         .WithDescription(ToolTips.ZoomOut)
                         .WithIcon(ApplicationIcons.ZoomOut)
                         .WithCommand <ZoomOutCommand>());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.FitToPage)
                         .WithId(MenuBarItemIds.FitToPage)
                         .WithDescription(ToolTips.FitToPage)
                         .WithIcon(ApplicationIcons.FitToPage)
                         .WithCommand <FitToPageCommand>());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.Extend)
                         .WithId(MenuBarItemIds.MoleculeStartValuesExtend)
                         .WithDescription(ToolTips.Extend)
                         .WithIcon(ApplicationIcons.ExtendMoleculeStartValues)
                         .WithCommand <MoleculeStartValuesExtendUICommand>());

            yield return(CreateMenuButton.WithCaption(AppConstants.MenuNames.Extend)
                         .WithId(MenuBarItemIds.ParameterStartValuesExtend)
                         .WithDescription(ToolTips.Extend)
                         .WithIcon(ApplicationIcons.ExtendParameterStartValues)
                         .WithCommand <ParameterStartValuesExtendUICommand>());

            yield return(CreateMenuButton
                         .WithCaption(AppConstants.MenuNames.NewParameterStartValue)
                         .WithId(MenuBarItemIds.NewParameterStartValue)
                         .WithIcon(ApplicationIcons.AddParameterStartValues)
                         .WithCommand <AddParameterStartValuesUICommand>());

            yield return(CreateMenuButton
                         .WithCaption(AppConstants.MenuNames.NewMoleculeStartValue)
                         .WithId(MenuBarItemIds.NewMoleculeStartValue)
                         .WithIcon(ApplicationIcons.AddMoleculeStartValues)
                         .WithCommand <AddMoleculeStartValuesUICommand>());

            yield return(CreateMenuButton
                         .WithCaption(AppConstants.MenuNames.ImportSBML)
                         .WithId(MenuBarItemIds.ImportSBML)
                         .WithDescription(ToolTips.FileRibbon.ImportSBMLDescription)
                         .WithIcon(ApplicationIcons.SBML)
                         .WithCommand <ImportSbmlUICommand>());

            yield return(CommonMenuBarButtons.ManageUserDisplayUnits(MenuBarItemIds.ManageUserDisplayUnits));

            yield return(CommonMenuBarButtons.ManageProjectDisplayUnits(MenuBarItemIds.ManageProjectDisplayUnits));

            yield return(CommonMenuBarButtons.UpdateAllToDisplayUnits(MenuBarItemIds.UpdateAllToDisplayUnits));

            yield return(CommonMenuBarButtons.LoadFavoritesFromFile(MenuBarItemIds.LoadFavorites));

            yield return(CommonMenuBarButtons.SaveFavoritesToFile(MenuBarItemIds.SaveFavorites));

            yield return(CommonMenuBarButtons.ClearHistory(MenuBarItemIds.ClearHistory));

            yield return(CommonMenuBarButtons.Help(MenuBarItemIds.Help));

            yield return(JournalMenuBarButtons.JournalView(MenuBarItemIds.JournalView));

            yield return(JournalMenuBarButtons.CreateJournalPage(MenuBarItemIds.CreateJournalPage));

            yield return(JournalMenuBarButtons.SelectJournal(MenuBarItemIds.SelectJournal));

            yield return(JournalMenuBarButtons.JournalEditorView(MenuBarItemIds.JournalEditorView));

            yield return(CommonMenuBarButtons.JournalDiagramView(MenuBarItemIds.JournalDiagramView));

            yield return(JournalMenuBarButtons.SearchJournal(MenuBarItemIds.SearchJournal));

            yield return(JournalMenuBarButtons.ExportJournal(MenuBarItemIds.ExportJournal));

            yield return(JournalMenuBarButtons.RefreshJournal(MenuBarItemIds.RefreshJournal));

            yield return(ParameterIdentificationMenuBarButtons.CreateParameterIdentification(MenuBarItemIds.CreateParameterIdentification));

            yield return(ParameterIdentificationMenuBarButtons.RunParameterIdentification(MenuBarItemIds.RunParameterIdentification));

            yield return(ParameterIdentificationMenuBarButtons.StopParameterIdentification(MenuBarItemIds.StopParameterIdentification));

            yield return(ParameterIdentificationMenuBarButtons.TimeProfileParameterIdentification(MenuBarItemIds.TimeProfileParameterIdentification));

            yield return(ParameterIdentificationMenuBarButtons.PredictedVsObservedParameterIdentification(MenuBarItemIds.PredictedVsObservedParameterIdentification));

            yield return(ParameterIdentificationMenuBarButtons.ResidualsVsTimeParameterIdentifcation(MenuBarItemIds.ResidualsVsTimeParameterIdentifcation));

            yield return(ParameterIdentificationMenuBarButtons.ResidualHistogramParameterIdentification(MenuBarItemIds.ResidualHistogramParameterIdentification));

            yield return(ParameterIdentificationMenuBarButtons.CorrelationMatrixParameterIdentification(MenuBarItemIds.CorrelationMatrixParameterIdentification));

            yield return(ParameterIdentificationMenuBarButtons.CovarianceMatrixParameterIdentification(MenuBarItemIds.CovarianceMatrixParameterIdentification));

            yield return(ParameterIdentificationMenuBarButtons.ParameterIdentificationFeedbackView(MenuBarItemIds.ParameterIdentificationFeedbackView));

            yield return(ParameterIdentificationMenuBarButtons.TimeProfilePredictionInterval(MenuBarItemIds.TimeProfilePredictionInterval));

            yield return(ParameterIdentificationMenuBarButtons.TimeProfileVPCInterval(MenuBarItemIds.TimeProfileVPCInterval));

            yield return(ParameterIdentificationMenuBarButtons.TimeProfileConfidenceInterval(MenuBarItemIds.TimeProfileConfidenceInterval));

            yield return(SensitivityAnalysisMenuBarButtons.SensitivityAnalysisPKParameterAnalysis(MenuBarItemIds.SensitivityAnalysisPKParameterAnalysis));

            yield return(SensitivityAnalysisMenuBarButtons.CreateSensitivityAnalysis(MenuBarItemIds.CreateSensitivityAnalysis));

            yield return(SensitivityAnalysisMenuBarButtons.SensitivityAnalysisFeedbackView(MenuBarItemIds.SensitivityAnalysisFeedbackView));

            yield return(SensitivityAnalysisMenuBarButtons.RunSensitivityAnalysis(MenuBarItemIds.RunSensitivityAnalysis));

            yield return(SensitivityAnalysisMenuBarButtons.StopSensitivityAnalysis(MenuBarItemIds.StopSensitivityAnalysis));
        }
Exemplo n.º 18
0
        protected void SetDetailedMenuItems(IContextMenuView contextMenuView, IContainerBase containerBase)
        {
            var subMenuDetailed = CreateSubMenu.WithCaption("Expert Functions").AsGroupStarter();

            contextMenuView.AddMenuItem(subMenuDetailed);


            var subMenuShow = CreateSubMenu.WithCaption("Show / Hide");

            if (Presenter.SelectionContains <IBaseNode>())
            {
                subMenuDetailed.AddItem(subMenuShow);
            }

            subMenuShow.AddItem(
                CreateMenuButton.WithCaption("Hide not Linked Nodes").WithActionCommand(() => Presenter.HideNotLinkedNodes()));
            subMenuShow.AddItem(
                CreateMenuButton.WithCaption("Show Linked Nodes").WithActionCommand(() => Presenter.ShowLinkedNodes()));

            var subMenuExpand = CreateSubMenu.WithCaption("Expand / Collapse");

            subMenuDetailed.AddItem(subMenuExpand);

            subMenuExpand.AddItem(
                CreateMenuButton.WithCaption("Set Default Expansion").WithActionCommand(() => Presenter.SetDefaultExpansion()));
            subMenuExpand.AddItem(
                CreateMenuButton.WithCaption("Show Default Expansion")
                .WithActionCommand(() => Presenter.ShowDefaultExpansion()));

            if (Presenter.SelectionContains <IContainerNode>())
            {
                AddExpandMenuItems(subMenuExpand);
            }


            var subMenuDiagram = CreateSubMenu.WithCaption("Diagram");

            subMenuDetailed.AddItem(subMenuDiagram);

            subMenuDiagram.AddItem(
                CreateMenuButton.WithCaption("Copy clipping as Bitmap")
                .WithActionCommand(() => Presenter.CopyBitmapToClipboard(null)));
            subMenuDiagram.AddItem(
                CreateMenuButton.WithCaption("Print Preview...").WithActionCommand(() => Presenter.PrintDiagram()));

            var subMenuLayout = CreateSubMenu.WithCaption("Layout");

            if (containerBase != null)
            {
                subMenuDetailed.AddItem(subMenuLayout);
            }
            subMenuLayout.AddItem(
                CreateMenuButton.WithCaption("AutoLayout Grandchildren")
                .WithActionCommand(
                    () =>
                    Presenter.Layout(containerBase, AppConstants.Diagram.Base.LayoutDepthGrandChildren,
                                     null)));
            subMenuLayout.AddItem(
                CreateMenuButton.WithCaption("AutoLayout all Descendants")
                .WithActionCommand(
                    () => Presenter.Layout(containerBase, AppConstants.Diagram.Base.LayoutDepthAll, null)));
            if (_runOptions.IsDeveloperMode)
            {
                var subMenuDeveloper = CreateSubMenu.WithCaption("Developer Functions").AsGroupStarter()
                                       .WithItem(
                    CreateMenuButton.WithCaption("Position at 0")
                    .WithActionCommand(() => Presenter.Position0Selection()));
                subMenuDetailed.AddItem(subMenuDeveloper);
            }
        }
Exemplo n.º 19
0
 private IMenuBarSubMenu createFromChartMenu()
 {
     return(CreateSubMenu.WithCaption(MenuNames.FromCurrentChart));
 }