protected override void Context()
{
_treeNodeFactory = A.Fake <ITreeNodeFactory>();
_projectRetriever = A.Fake <IProjectRetriever>();
_observedDataTask = A.Fake <IObservedDataTask>();
sut = new ObservedDataInExplorerPresenter(_projectRetriever, _treeNodeFactory, _observedDataTask);
_explorerPresenter = A.Fake <IExplorerPresenter>();
_classificationPresenter = A.Fake <IClassificationPresenter>();
_explorerView = A.Fake <IExplorerView>();
A.CallTo(() => _explorerPresenter.BaseView).Returns(_explorerView);
_rootNodeObservedDataFolder = new RootNodeType("ObservedData", ApplicationIcons.ObservedDataFolder, ClassificationType.ObservedData);
_rootNodeIndividualFolder = new RootNodeType("Individual", ApplicationIcons.IndividualFolder);
_observationRootNode = new RootNode(_rootNodeObservedDataFolder);
_individualRootNode = new RootNode(_rootNodeIndividualFolder);
sut.InitializeWith(_explorerPresenter, _classificationPresenter, _rootNodeObservedDataFolder);
_project = A.Fake <IProject>();
A.CallTo(() => _explorerPresenter.NodeByType(_rootNodeObservedDataFolder)).Returns(_observationRootNode);
A.CallTo(() => _explorerView.TreeView.NodeById(_rootNodeObservedDataFolder.Id)).Returns(_observationRootNode);
A.CallTo(() => _explorerView.AddNode(A <ITreeNode> ._)).ReturnsLazily(s => s.Arguments[0].DowncastTo <ITreeNode>());
}
public FallbackNodeFactory(
ITreeNodeFactory <TModel> customFactory,
ITreeNodeFactory <TModel> fallbackFactory)
{
this.CustomFactory = customFactory;
this.FallbackFactory = fallbackFactory;
}
public DecoratorNodeFactory(
ITreeNodeFactory <TModel> factory,
IEnumerable <ITreeNodeDecorator> decorators)
{
this.NodeFactory = factory;
this.NodeDecorators = decorators.ToList();
}
public ObjectExplorerPresenter(IObjectExplorerView view)
{
nodesForItem = new Dictionary <ObjectExplorerItem, List <ITreeNode> >();
View = view;
view.Loaded += View_Load;
view.NodeMouseClick += View_NodeMouseClick;
view.NodeAfterSelect += View_NodeAfterSelect;
Container = ContainerDelivery.GetContainer();
TreeNodeFactory = Container.Resolve <ITreeNodeFactory>();
ObjectExplorerRepositoryFactory = Container.Resolve <IObjectExplorerRepositoryFactory>();
MenuFactory = Container.Resolve <IMenuFactory>();
CommandBus = Container.Resolve <ICommandBus>();
documentsController = Container.Resolve <IDocumentsController>();
documentsController.DocumentActivationChanged += DocumentsController_DocumentActivationChanged;
documentConnector = Container.Resolve <IDocumentConnector>();
documentConnector.ConnectingStarted += DocumentConnector_ConnectingStarted;
documentConnector.ConnectingFinished += DocumentConnector_ConnectingFinished;
documentConnector.Disconnected += DocumentConnector_Disconnected;
}
public ResourceSearchStrategy(ApiVisibility apiVisibility, SearchRequest request, IProducerConsumerCollection <SearchResult> resultQueue)
: base(request, resultQueue)
{
this.treeNodeFactory = request.TreeNodeFactory;
this.apiVisibility = apiVisibility;
this.searchInside = true;
}
protected override void Context()
{
_view = A.Fake <IParameterIdentificationSimulationSelectionView>();
_treeNodeFactory = A.Fake <ITreeNodeFactory>();
_applicationController = A.Fake <IApplicationController>();
_lazyLoadTask = A.Fake <ILazyLoadTask>();
_treeNodeContextMenuFactory = A.Fake <ITreeNodeContextMenuFactory>();
_multipleTreeNodeContextMenuFactory = A.Fake <IMultipleTreeNodeContextMenuFactory>();
_dialogCreator = A.Fake <IDialogCreator>();
_parameterIdentificationTask = A.Fake <IParameterIdentificationTask>();
sut = new ParameterIdentificationSimulationSelectionPresenter(_view, _treeNodeFactory, _applicationController, _lazyLoadTask, _treeNodeContextMenuFactory,
_multipleTreeNodeContextMenuFactory, _dialogCreator, _parameterIdentificationTask);
_parameterIdentification = new ParameterIdentification();
_simulation = A.Fake <ISimulation>().WithId("Id").WithName("S");
_parameterIdentification.AddSimulation(_simulation);
_outputMapping = new OutputMapping
{
OutputSelection = new SimulationQuantitySelection(_simulation, new QuantitySelection("PATH", QuantityType.Drug))
};
_parameterIdentification.AddOutputMapping(_outputMapping);
_simulationNode = A.Fake <ITreeNode>();
A.CallTo(() => _treeNodeFactory.CreateFor(_simulation)).Returns(_simulationNode);
_simulationSelectionPresenter = A.Fake <ISelectionSimulationPresenter>();
A.CallTo(() => _applicationController.Start <ISelectionSimulationPresenter>()).Returns(_simulationSelectionPresenter);
sut.EditParameterIdentification(_parameterIdentification);
}
public CustomSolutionNode(IVsSolutionHierarchyNode node,
Lazy <ITreeNode> parent,
ITreeNodeFactory <IVsSolutionHierarchyNode> nodeFactory,
IAdapterService adapterService)
: base(SolutionNodeKind.Custom, node, parent, nodeFactory, adapterService)
{
}
protected override void Context()
{
_view = A.Fake <IMoleculeListView>();
_moleculeBuilderToDTOMoleculeBuilderMapper = A.Fake <IMoleculeBuilderToMoleculeBuilderDTOMapper>();
_viewItemContextMenuFactory = A.Fake <IViewItemContextMenuFactory>();
_context = A.Fake <IMoBiContext>();
_treeNodeFactory = A.Fake <ITreeNodeFactory>();
sut = new MoleculeListPresenter(_view, _moleculeBuilderToDTOMoleculeBuilderMapper, _viewItemContextMenuFactory,
_context, _treeNodeFactory);
}
public ParameterIdentificationSimulationSelectionPresenter(IParameterIdentificationSimulationSelectionView view, ITreeNodeFactory treeNodeFactory,
IApplicationController applicationController, ILazyLoadTask lazyLoadTask, ITreeNodeContextMenuFactory treeNodeContextMenuFactory,
IMultipleTreeNodeContextMenuFactory multipleTreeNodeContextMenuFactory, IDialogCreator dialogCreator, IParameterIdentificationTask parameterIdentificationTask) : base(view)
{
_treeNodeFactory = treeNodeFactory;
_applicationController = applicationController;
_lazyLoadTask = lazyLoadTask;
_treeNodeContextMenuFactory = treeNodeContextMenuFactory;
_multipleTreeNodeContextMenuFactory = multipleTreeNodeContextMenuFactory;
_dialogCreator = dialogCreator;
_parameterIdentificationTask = parameterIdentificationTask;
}
/// <summary>
/// Initializes a new instance of the <see cref="FolderNode"/> class.
/// </summary>
/// <param name="hierarchyNode">The underlying hierarchy represented by this node.</param>
/// <param name="parentNode">The parent node accessor.</param>
/// <param name="nodeFactory">The factory for child nodes.</param>
/// <param name="adapter">The adapter service that implements the smart cast <see cref="ITreeNode.As{T}"/>.</param>
public FolderNode(
IVsSolutionHierarchyNode hierarchyNode,
Lazy <ITreeNode> parentNode,
ITreeNodeFactory <IVsSolutionHierarchyNode> nodeFactory,
IAdapterService adapter)
: base(SolutionNodeKind.Folder, hierarchyNode, parentNode, nodeFactory, adapter)
{
Guard.NotNull(() => parentNode, parentNode);
this.Folder = new Lazy <EnvDTE.ProjectItem>(
() => (EnvDTE.ProjectItem)hierarchyNode.VsHierarchy.Properties(hierarchyNode.ItemId).ExtenderObject);
}
/// <summary>
/// Initializes a new instance of the <see cref="ReferenceNode"/> class.
/// </summary>
/// <param name="hierarchyNode">The underlying hierarchy represented by this node.</param>
/// <param name="parentNode">The parent node accessor.</param>
/// <param name="nodeFactory">The factory for child nodes.</param>
/// <param name="adapter">The adapter service that implements the smart cast <see cref="ITreeNode.As{T}"/>.</param>
public ReferenceNode(
IVsSolutionHierarchyNode hierarchyNode,
Lazy <ITreeNode> parentNode,
ITreeNodeFactory <IVsSolutionHierarchyNode> nodeFactory,
IAdapterService adapter)
: base(SolutionNodeKind.Reference, hierarchyNode, parentNode, nodeFactory, adapter)
{
Guard.NotNull(() => parentNode, parentNode);
this.Reference = new Lazy <VSLangProj.Reference>(
() => (VSLangProj.Reference)hierarchyNode.VsHierarchy.Properties(hierarchyNode.ItemId).ExtenderObject);
}
/// <summary>
/// Initializes a new instance of the <see cref="ReferencesNode"/> class.
/// </summary>
/// <param name="hierarchyNode">The underlying hierarchy represented by this node.</param>
/// <param name="parentNode">The parent node accessor.</param>
/// <param name="nodeFactory">The factory for child nodes.</param>
/// <param name="adapter">The adapter service that implements the smart cast <see cref="ITreeNode.As{T}"/>.</param>
public ReferencesNode(
IVsSolutionHierarchyNode hierarchyNode,
Lazy <ITreeNode> parentNode,
ITreeNodeFactory <IVsSolutionHierarchyNode> nodeFactory,
IAdapterService adapter)
: base(SolutionNodeKind.ReferencesFolder, hierarchyNode, parentNode, nodeFactory, adapter)
{
Guard.NotNull(() => parentNode, parentNode);
this.References = new Lazy <References>(() =>
((VSProject)((Project)hierarchyNode.VsHierarchy.Properties(VSConstants.VSITEMID_ROOT).ExtenderObject).Object).References);
}
protected override void Context()
{
_view = A.Fake <IBuildingBlockFromTemplateView>();
_templateTaskQuery = A.Fake <ITemplateTaskQuery>();
_objectTypeResolver = A.Fake <IObjectTypeResolver>();
_treeNodeFactory = A.Fake <ITreeNodeFactory>();
_contextMenuFactory = A.Fake <ITreeNodeContextMenuFactory>();
_applicationController = A.Fake <IApplicationController>();
_dialogCreator = A.Fake <IDialogCreator>();
_startOptions = A.Fake <IStartOptions>();
sut = new TemplatePresenter(_view, _templateTaskQuery, _objectTypeResolver, _treeNodeFactory, _contextMenuFactory, _applicationController, _dialogCreator, _startOptions);
}
/// <summary>
/// Initializes a new instance of the <see cref="ProjectNode"/> class.
/// </summary>
/// <param name="hierarchyNode">The underlying hierarchy represented by this node.</param>
/// <param name="parentNode">The parent node accessor.</param>
/// <param name="nodeFactory">The factory for child nodes.</param>
/// <param name="adapter">The adapter service that implements the smart cast <see cref="ITreeNode.As{T}"/>.</param>
public ProjectNode(
IVsSolutionHierarchyNode hierarchyNode,
Lazy <ITreeNode> parentNode,
ITreeNodeFactory <IVsSolutionHierarchyNode> nodeFactory,
IAdapterService adapter)
: base(SolutionNodeKind.Project, hierarchyNode, parentNode, nodeFactory, adapter)
{
Guard.NotNull(() => parentNode, parentNode);
this.Project = new Lazy <EnvDTE.Project>(() => (EnvDTE.Project)hierarchyNode.VsHierarchy.Properties(hierarchyNode.ItemId).ExtenderObject);
this.properties = new Lazy <GlobalProjectProperties>(() => new GlobalProjectProperties(this));
this.Configuration = new ProjectConfiguration(this);
}
public static ITreeNode ToUITreeNode(this ObjectExplorerItem item, ITreeNodeFactory factory, Action <ITreeNode, ObjectExplorerItem> action)
{
ITreeNode uinode = factory.Create();
uinode.Text = item.Name;
uinode.Data = item;
action?.Invoke(uinode, item);
foreach (var explorerItem in item.Items)
{
uinode.Nodes.Add(explorerItem.ToUITreeNode(factory, action));
}
return(uinode);
}
/// <summary>
/// Initializes a new instance of the <see cref="ProjectItemNode"/> class.
/// </summary>
/// <param name="kind">The kind of project node.</param>
/// <param name="hierarchyNode">The underlying hierarchy represented by this node.</param>
/// <param name="parentNode">The parent node accessor.</param>
/// <param name="nodeFactory">The factory for child nodes.</param>
/// <param name="adapter">The adapter service that implements the smart cast <see cref="ITreeNode.As{T}"/>.</param>
public ProjectItemNode(
SolutionNodeKind kind,
IVsSolutionHierarchyNode hierarchyNode,
Lazy <ITreeNode> parentNode,
ITreeNodeFactory <IVsSolutionHierarchyNode> nodeFactory,
IAdapterService adapter)
: base(kind, hierarchyNode, parentNode, nodeFactory, adapter)
{
this.nodeFactory = nodeFactory;
this.owningProject = new Lazy <IProjectNode>(() =>
{
var owningHierarchy = new VsSolutionHierarchyNode(hierarchyNode.VsHierarchy, VSConstants.VSITEMID_ROOT);
return(this.nodeFactory.CreateNode(GetParent(owningHierarchy), owningHierarchy) as IProjectNode);
});
}
/// <summary>
/// Initializes a new instance of the <see cref="ProjectItemNode"/> class.
/// </summary>
/// <param name="kind">The kind of project node.</param>
/// <param name="hierarchyNode">The underlying hierarchy represented by this node.</param>
/// <param name="parentNode">The parent node accessor.</param>
/// <param name="nodeFactory">The factory for child nodes.</param>
/// <param name="adapter">The adapter service that implements the smart cast <see cref="ITreeNode.As{T}"/>.</param>
public ProjectItemNode(
SolutionNodeKind kind,
IVsSolutionHierarchyNode hierarchyNode,
Lazy<ITreeNode> parentNode,
ITreeNodeFactory<IVsSolutionHierarchyNode> nodeFactory,
IAdapterService adapter)
: base(kind, hierarchyNode, parentNode, nodeFactory, adapter)
{
this.nodeFactory = nodeFactory;
this.owningProject = new Lazy<IProjectNode>(() =>
{
var owningHierarchy = new VsSolutionHierarchyNode(hierarchyNode.VsHierarchy, VSConstants.VSITEMID_ROOT);
return this.nodeFactory.CreateNode(GetParent(owningHierarchy), owningHierarchy) as IProjectNode;
});
}
/// <summary>
/// Initializes a new instance of the <see cref="SolutionTreeNode"/> class.
/// </summary>
/// <param name="nodeKind">Kind of the node.</param>
/// <param name="hierarchyNode">The underlying hierarchy represented by this node.</param>
/// <param name="parentNode">The parent node accessor.</param>
/// <param name="nodeFactory">The factory for child nodes.</param>
/// <param name="adapter">The adapter service that implements the smart cast <see cref="ITreeNode.As{T}"/>.</param>
protected SolutionTreeNode(
SolutionNodeKind nodeKind,
IVsSolutionHierarchyNode hierarchyNode,
Lazy <ITreeNode> parentNode,
ITreeNodeFactory <IVsSolutionHierarchyNode> nodeFactory,
IAdapterService adapter)
{
Guard.NotNull(() => hierarchyNode, hierarchyNode);
Guard.NotNull(() => nodeFactory, nodeFactory);
Guard.NotNull(() => adapter, adapter);
this.hierarchyNode = hierarchyNode;
this.factory = nodeFactory;
this.adapter = adapter;
this.window = new Lazy <IVsUIHierarchyWindow>(() => GetWindow(this.hierarchyNode.ServiceProvider));
this.parent = parentNode ?? new Lazy <ITreeNode>(() => null);
this.DisplayName = this.hierarchyNode.VsHierarchy.Properties(hierarchyNode.ItemId).DisplayName;
this.Kind = nodeKind;
Func <bool> getHiddenProperty = () => GetProperty <bool?>(
this.hierarchyNode.VsHierarchy,
__VSHPROPID.VSHPROPID_IsHiddenItem,
this.hierarchyNode.ItemId).GetValueOrDefault();
this.isHidden = parentNode != null ?
new Lazy <bool>(() => getHiddenProperty() || parentNode.Value.IsHidden) :
new Lazy <bool>(() => getHiddenProperty());
if (System.Diagnostics.Debugger.IsAttached)
{
this.debuggerDisplay = BuildDebuggerDisplay();
}
this.solutionNode = new Lazy <ISolutionNode>(() =>
{
var solutionHierarchy = new VsSolutionHierarchyNode(
(IVsHierarchy)this.hierarchyNode.ServiceProvider.GetService <SVsSolution, IVsSolution>(),
VSConstants.VSITEMID_ROOT);
return((ISolutionNode)this.factory.CreateNode(null, solutionHierarchy));
});
}
/// <summary>
/// Initializes a new instance of the <see cref="SolutionItemNode"/> class.
/// </summary>
/// <param name="hierarchyNode">The underlying hierarchy represented by this node.</param>
/// <param name="parentNode">The parent node accessor.</param>
/// <param name="nodeFactory">The factory for child nodes.</param>
/// <param name="adapter">The adapter service that implements the smart cast <see cref="ITreeNode.As{T}"/>.</param>
public SolutionItemNode(
IVsSolutionHierarchyNode hierarchyNode,
Lazy <ITreeNode> parentNode,
ITreeNodeFactory <IVsSolutionHierarchyNode> nodeFactory,
IAdapterService adapter)
: base(SolutionNodeKind.SolutionItem, hierarchyNode, parentNode, nodeFactory, adapter)
{
Guard.NotNull(() => parentNode, parentNode);
this.nodeFactory = nodeFactory;
this.Item = new Lazy <EnvDTE.ProjectItem>(
() => (EnvDTE.ProjectItem)hierarchyNode.VsHierarchy.Properties(hierarchyNode.ItemId).ExtenderObject);
this.owningFolder = new Lazy <ISolutionFolderNode>(() =>
{
var owningHierarchy = new VsSolutionHierarchyNode(hierarchyNode.VsHierarchy, VSConstants.VSITEMID_ROOT);
return(this.nodeFactory.CreateNode(GetParent(owningHierarchy), owningHierarchy) as ISolutionFolderNode);
});
}
/// <summary>
/// Initializes a new instance of the <see cref="SolutionNode"/> class.
/// </summary>
/// <param name="hierarchyNode">The underlying hierarchy represented by this node.</param>
/// <param name="childNodeFactory">The factory for child nodes.</param>
/// <param name="looseNodeFactory">The explorer node factory used to create "loose" nodes from solution explorer.</param>
/// <param name="locator">The service locator.</param>
/// <param name="adapter">The adapter service that implements the smart cast <see cref="ITreeNode.As{T}"/>.</param>
/// <param name="solutionEvents">The solution events.</param>
/// <param name="uiThread">The UI thread.</param>
public SolutionNode(
IVsSolutionHierarchyNode hierarchyNode,
// This is the regular node factory for trees, that receives a lazy
// pointer to the parent tree node.
ITreeNodeFactory <IVsSolutionHierarchyNode> childNodeFactory,
// This factory is used to create "loose" nodes from solution explorer
ISolutionExplorerNodeFactory looseNodeFactory,
IServiceLocator locator,
IAdapterService adapter,
ISolutionEvents solutionEvents,
// Retrieving current selection must be done on the UI thread.
IUIThread uiThread)
: base(SolutionNodeKind.Solution, hierarchyNode, null, childNodeFactory, adapter)
{
this.Solution = new Lazy <EnvDTE.Solution>(() => hierarchyNode.ServiceProvider.GetService <EnvDTE.DTE>().Solution);
this.nodeFactory = childNodeFactory;
this.explorerNodeFactory = looseNodeFactory;
this.events = solutionEvents;
this.selection = new Lazy <IVsMonitorSelection>(() => locator.GetService <SVsShellMonitorSelection, IVsMonitorSelection>());
this.uiThread = uiThread;
}
public ObservedDataInExplorerPresenter(IProjectRetriever projectRetriever, ITreeNodeFactory treeNodeFactory, IObservedDataTask observedDataTask)
{
_projectRetriever = projectRetriever;
_treeNodeFactory = treeNodeFactory;
_observedDataTask = observedDataTask;
}
public ParameterAnalysablesInExplorerPresenter(IParameterIdentificationTask parameterIdentificationTask, ISensitivityAnalysisTask sensitivityAnalysisTask, ITreeNodeFactory treeNodeFactory)
{
_parameterIdentificationTask = parameterIdentificationTask;
_sensitivityAnalysisTask = sensitivityAnalysisTask;
_treeNodeFactory = treeNodeFactory;
}
public IndividualMoleculesPresenter(IMoleculesView view, IMoleculeExpressionTask <Individual> moleculeExpressionTask, ITreeNodeFactory treeNodeFactory,
ITreeNodeContextMenuFactory contextMenuFactory, IDialogCreator dialogCreator, IEntityTask entityTask,
IRootNodeToIndividualExpressionsPresenterMapper <Individual> expressionsPresenterMapper, INoItemInSelectionPresenter noItemInSelectionPresenter)
: base(view, moleculeExpressionTask, treeNodeFactory, contextMenuFactory, dialogCreator, entityTask, expressionsPresenterMapper, noItemInSelectionPresenter)
{
}
public HierarchicalSimulationPresenter(IHierarchicalStructureView view, IMoBiContext context,
IObjectBaseToObjectBaseDTOMapper objectBaseMapper,
ISimulationSettingsToObjectBaseDTOMapper simulationSettingsMapper, ITreeNodeFactory treeNodeFactory, IViewItemContextMenuFactory contextMenuFactory)
: base(view, context, objectBaseMapper, treeNodeFactory)
{
_simulationSettingsMapper = simulationSettingsMapper;
_contextMenuFactory = contextMenuFactory;
}
public HierarchicalSpatialStructurePresenter(IHierarchicalStructureView view, IMoBiContext context,
IObjectBaseToObjectBaseDTOMapper objectBaseMapper, IViewItemContextMenuFactory contextMenuFactory, ITreeNodeFactory treeNodeFactory)
: base(view, context, objectBaseMapper, treeNodeFactory)
{
_contextMenuFactory = contextMenuFactory;
}
public static T CreateNode <T>(this ITreeNodeFactory nodeFactory) where T : class, ITreeNode
{
return(nodeFactory.CreateNode(typeof(T)) as T);
}
public EditorEnvironment(ITreeNodeFactory nodeFactory, IUndoRedoStack undoRedoStack)
{
NodeFactory = nodeFactory;
UndoRedoStack = undoRedoStack;
}
public DesignDataService(IDesignDataHelper designDataHelper, ITreeNodeFactory treeNodeFactory, ITreeNodeCollectionFactory treeNodeCollectionFactory)
{
_designDataHelper = designDataHelper;
_treeNodeFactory = treeNodeFactory;
}
