protected override void Context()
        {
            base.Context();
            CreateSutForSettings(ParameterGroupingModeId.Simple);

            _fullPath = "A B C";
            _group    = new Group {
                Name = "toto"
            };
            _group.IsAdvanced = false;

            _anotherGroup = new Group {
                Name = "toto"
            };
            _anotherGroup.IsAdvanced = false;

            _parameterEditPresenter = A.Fake <ICustomParametersPresenter>();
            A.CallTo(() => _parameterEditPresenter.BaseView).Returns(A.Fake <IMultiParameterEditView>());
            //One visible parameter
            _visibleParameter = A.Fake <IParameter>();
            A.CallTo(() => _visibleParameter.Rules).Returns(new BusinessRuleSet());
            _visibleParameter.Visible = true;
            _visibleParameter.Name    = "toto";
            A.CallTo(() => _visibleParameter.GroupName).Returns("toto");
            //One hidden parameter
            _hiddenParameter         = A.Fake <IParameter>();
            _hiddenParameter.Visible = false;
            A.CallTo(() => _hiddenParameter.GroupName).Returns("tata");
            _hiddenParameter.Name = "tata";

            _allParameters.AddRange(new[] { _visibleParameter, _hiddenParameter });
            _parameterGroupNode      = A.Fake <ITreeNode <IGroup> >();
            _parameterGroupNode.Text = "toto";
            A.CallTo(() => _parameterGroupNode.FullPath(PKSimConstants.UI.DisplayPathSeparator)).Returns(_fullPath);
            _selectedGroup             = A.Fake <IGroup>();
            _selectedGroup.DisplayName = "toto";
            A.CallTo(() => _parameterGroupNode.Tag).Returns(_selectedGroup);
            A.CallTo(() => _parameterGroupTask.TopGroupsUsedBy(A <IEnumerable <IParameter> > .Ignored)).Returns(new[] { _selectedGroup });

            A.CallTo(() => _parameterPresenterMapper.MapFrom(_parameterGroupNode)).Returns(_parameterEditPresenter);
            A.CallTo(() => _parameterGroupTask.ParametersIn(_selectedGroup, A <IEnumerable <IParameter> > .Ignored)).Returns(new[] { _visibleParameter });
            A.CallTo(() => _groupRepository.GroupByName(_visibleParameter.GroupName)).Returns(_group);
            A.CallTo(() => _groupRepository.GroupByName(_hiddenParameter.GroupName)).Returns(_anotherGroup);
            var visibleParameterDTO = A.Fake <ParameterDTO>();

            A.CallTo(() => visibleParameterDTO.Name).Returns(_visibleParameter.Name);

            sut.InitializeWith(_organism, _allParameters);
        }
Пример #2
0
        public void ActivateNode(ITreeNode node)
        {
            if (node == null)
            {
                return;
            }
            //one of the root has been selected
            _view.GroupCaption = node.FullPath(PKSimConstants.UI.DisplayPathSeparator);
            if (nodeRepresentsMoleculeFolder(node))
            {
                _view.ActivateView(_noItemInSelectionPresenter.BaseView);
                return;
            }
            var rootNode = node.ParentNode.DowncastTo <RootNode>();

            _activePresenter = presenterFor(rootNode);
            _activePresenter.OntogenyVisible           = _simulationSubject.IsAgeDependent;
            _activePresenter.MoleculeParametersVisible = _simulationSubject.IsAnImplementationOf <Individual>();
            _activePresenter.ActivateMolecule(moleculeFrom(node));
            _view.ActivateView(_activePresenter.BaseView);
        }
        public void ActivateNode(ITreeNode node)
        {
            if (node == null)
            {
                return;
            }
            _view.GroupCaption = node.FullPath(PKSimConstants.UI.DisplayPathSeparator);

            var enzymaticProcess = node.TagAsObject as EnzymaticProcess;

            if (enzymaticProcess != null)
            {
                _view.ActivateView(_compoundEnzymaticProcessPresenter.BaseView);
                _compoundEnzymaticProcessPresenter.Edit(enzymaticProcess);
                return;
            }

            var process = node.TagAsObject as CompoundProcess;

            if (process != null)
            {
                _view.ActivateView(_compoundProcessPresenter.BaseView);
                _compoundProcessPresenter.Edit(process);
                return;
            }

            var definition = node.TagAsObject as CompoundParameterNodeType;
            var presenter  = compoundParameterGroupPresenterFor(definition);

            if (canEditCompoundParameter(definition, presenter))
            {
                _view.ActivateView(presenter.BaseView);
                presenter.EditCompound(_compound);
                return;
            }

            //nothing to display: Reset view
            _view.ActivateView(_noItemInSelectionPresenter.BaseView);
        }
Пример #4
0
        public void ActivateNode(ITreeNode node)
        {
            if (node == null)
            {
                return;
            }

            _view.GroupCaption = node.FullPath(PKSimConstants.UI.DisplayPathSeparator);

            bool alreadyLoaded = _parameterPresenterCache.Contains(node);

            _activePresenter         = presenterFor(node);
            _settings.SelectedNodeId = node.Id;

            //this needs to be done before editing the parameters
            _view.ActivateView(_activePresenter.BaseView);

            if (alreadyLoaded)
            {
                return;
            }

            _activePresenter.Edit(allVisibleParametersIn(node));
        }
 public void should_set_the_display_name_of_the_advanced_parameter_to_the_full_path_of_the_node()
 {
     _advancedParameter.FullDisplayName.ShouldBeEqualTo(_treeNode.FullPath());
 }