/// <summary>
/// Updates or creates new IProjectItemTree node
/// </summary>
private IProjectTree CreateOrUpdateProjectItemTreeNode(
IProjectTree node,
IDependencyViewModel viewModel,
IRule rule,
ProjectTreeFlags?additionalFlags = null,
ProjectTreeFlags?excludedFlags = null)
{
if (node == null)
{
var flags = FilterFlags(viewModel.Flags, additionalFlags, excludedFlags);
var itemContext = ProjectPropertiesContext.GetContext(
CommonServices.Project,
file: viewModel.FilePath,
itemType: viewModel.SchemaItemType,
itemName: viewModel.FilePath);
node = TreeServices.CreateTree(
caption: viewModel.Caption,
itemContext: itemContext,
propertySheet: null,
visible: true,
browseObjectProperties: rule,
flags: viewModel.Flags,
icon: viewModel.Icon.ToProjectSystemType(),
expandedIcon: viewModel.ExpandedIcon.ToProjectSystemType());
}
else
{
node = UpdateTreeNode(node, viewModel, rule);
}
return(node);
}
private IProjectTree CreateProjectTreeNode(
IDependencyViewModel viewModel,
IRule rule,
ProjectTreeFlags?additionalFlags = null,
ProjectTreeFlags?excludedFlags = null)
{
// For IProjectTree remove ProjectTreeFlags.Common.Reference flag, otherwise CPS would fail to
// map this node to graph node and GraphProvider would be never called.
// Only IProjectItemTree can have this flag
ProjectTreeFlags flags = FilterFlags(viewModel.Flags.Except(DependencyTreeFlags.BaseReferenceFlags),
additionalFlags,
excludedFlags);
string filePath = (viewModel.OriginalModel != null && viewModel.OriginalModel.TopLevel &&
viewModel.OriginalModel.Resolved)
? viewModel.OriginalModel.GetTopLevelId()
: viewModel.FilePath;
return(TreeServices.CreateTree(
caption: viewModel.Caption,
filePath: filePath,
visible: true,
browseObjectProperties: rule,
flags: flags,
icon: viewModel.Icon.ToProjectSystemType(),
expandedIcon: viewModel.ExpandedIcon.ToProjectSystemType()));
}
private IProjectTree CreateProjectItemTreeNode(
IDependencyViewModel viewModel,
IRule rule,
ProjectTreeFlags?additionalFlags = null,
ProjectTreeFlags?excludedFlags = null)
{
ProjectTreeFlags flags = FilterFlags(viewModel.Flags, additionalFlags, excludedFlags);
string filePath = (viewModel.OriginalModel != null && viewModel.OriginalModel.TopLevel &&
viewModel.OriginalModel.Resolved)
? viewModel.OriginalModel.GetTopLevelId()
: viewModel.FilePath;
var itemContext = ProjectPropertiesContext.GetContext(
CommonServices.Project,
file: filePath,
itemType: viewModel.SchemaItemType,
itemName: filePath);
return(TreeServices.CreateTree(
caption: viewModel.Caption,
itemContext: itemContext,
propertySheet: null,
browseObjectProperties: rule,
icon: viewModel.Icon.ToProjectSystemType(),
expandedIcon: viewModel.ExpandedIcon.ToProjectSystemType(),
visible: true,
flags: flags));
}
/// <summary>
/// Updates or creates new IProjectTree node
/// </summary>
private IProjectTree CreateOrUpdateProjectTreeNode(
IProjectTree node,
IDependencyViewModel viewModel,
IRule rule,
ProjectTreeFlags?additionalFlags = null,
ProjectTreeFlags?excludedFlags = null)
{
if (node == null)
{
// For IProjectTree remove ProjectTreeFlags.Common.Reference flag, otherwise CPS would fail to
// map this node to graph node and GraphProvider would be never called.
// Only IProjectItemTree can have this flag
var flags = FilterFlags(viewModel.Flags.Except(DependencyTreeFlags.BaseReferenceFlags),
additionalFlags,
excludedFlags);
node = TreeServices.CreateTree(
caption: viewModel.Caption,
filePath: viewModel.FilePath,
visible: true,
browseObjectProperties: rule,
flags: flags,
icon: viewModel.Icon.ToProjectSystemType(),
expandedIcon: viewModel.ExpandedIcon.ToProjectSystemType());
}
else
{
node = UpdateTreeNode(node, viewModel, rule);
}
return(node);
}
private GraphNode DoAddGraphNode(
GraphNodeId graphNodeId,
IGraphContext graphContext,
string projectPath,
GraphNode parentNode,
IDependencyViewModel viewModel)
{
RegisterIcons(viewModel.GetIcons());
var newNode = graphContext.Graph.Nodes.GetOrCreate(graphNodeId, viewModel.Caption, null);
newNode.SetValue(DgmlNodeProperties.Icon, GetIconStringName(viewModel.Icon));
// priority sets correct order among peers
newNode.SetValue(CodeNodeProperties.SourceLocation,
new SourceLocation(projectPath, new Position(viewModel.Priority, 0)));
newNode.AddCategory(DependenciesGraphSchema.CategoryDependency);
if (viewModel.OriginalModel != null)
{
newNode.SetValue(DependenciesGraphSchema.DependencyIdProperty, viewModel.OriginalModel.Id);
newNode.SetValue(DependenciesGraphSchema.ResolvedProperty, viewModel.OriginalModel.Resolved);
}
graphContext.OutputNodes.Add(newNode);
if (parentNode != null)
{
graphContext.Graph.Links.GetOrCreate(parentNode, newNode, /*label*/ null, CodeLinkCategories.Contains);
}
return(newNode);
}
public GraphNode AddTopLevelGraphNode(
IGraphContext graphContext,
string projectPath,
IDependencyViewModel viewModel)
{
var newNodeId = GetTopLevelGraphNodeId(projectPath, viewModel.OriginalModel.GetTopLevelId());
return(DoAddGraphNode(newNodeId, graphContext, projectPath, parentNode: null, viewModel: viewModel));
}
public GraphNode AddGraphNode(
IGraphContext graphContext,
string projectPath,
GraphNode parentNode,
IDependencyViewModel viewModel)
{
var newNodeId = GetGraphNodeId(projectPath, parentNode, viewModel);
return(DoAddGraphNode(newNodeId, graphContext, projectPath, parentNode, viewModel));
}
public GraphNode AddGraphNode(
IGraphContext graphContext,
string projectPath,
GraphNode parentNode,
IDependencyViewModel viewModel)
{
var modelId = viewModel.OriginalModel == null ? viewModel.Caption : viewModel.OriginalModel.Id;
var newNodeId = GetGraphNodeId(projectPath, parentNode, modelId);
return(DoAddGraphNode(newNodeId, graphContext, projectPath, parentNode, viewModel));
}
public GraphNode AddTopLevelGraphNode(
IGraphContext graphContext,
string projectPath,
IDependencyViewModel viewModel)
{
Assumes.True(IsInitialized);
GraphNodeId newNodeId = GetTopLevelGraphNodeId(projectPath, viewModel.OriginalModel.GetTopLevelId());
return(DoAddGraphNode(newNodeId, graphContext, projectPath, parentNode: null, viewModel));
}
/// <summary>
/// Updates or creates new node
/// </summary>
private IProjectTree CreateOrUpdateNode(
IProjectTree node,
IDependencyViewModel viewModel,
IRule rule,
bool isProjectItem,
ProjectTreeFlags?additionalFlags = null,
ProjectTreeFlags?excludedFlags = null)
{
return(isProjectItem
? CreateOrUpdateProjectItemTreeNode(node, viewModel, rule, additionalFlags, excludedFlags)
: CreateOrUpdateProjectTreeNode(node, viewModel, rule, additionalFlags, excludedFlags));
}
public GraphNode AddGraphNode(
IGraphContext graphContext,
string projectPath,
GraphNode parentNode,
IDependencyViewModel viewModel)
{
Assumes.True(IsInitialized);
string modelId = viewModel.OriginalModel == null ? viewModel.Caption : viewModel.OriginalModel.Id;
GraphNodeId newNodeId = GetGraphNodeId(projectPath, parentNode, modelId);
return(DoAddGraphNode(newNodeId, graphContext, projectPath, parentNode, viewModel));
}
public IDependency CreateDependencyModel(IDependencyViewModel dependency)
{
switch (dependency)
{
case ConditionResultDependencyViewModel conditionResultDependencyViewModel:
return(new ConditionResultDependency()
{
Condition = _conditionFillHelper.CreateConditionFromViewModel(conditionResultDependencyViewModel.SelectedConditionViewModel),
Result = _resultFillHelper.CreateResultFromViewModel(conditionResultDependencyViewModel.SelectedResultViewModel)
});
break;
}
return(null);
}
private IProjectTree UpdateTreeNode(
IProjectTree node,
IDependencyViewModel viewModel,
IRule rule)
{
ProjectTreeCustomizablePropertyContext updatedNodeParentContext = GetCustomPropertyContext(node.Parent);
var updatedValues = new ReferencesProjectTreeCustomizablePropertyValues
{
Caption = viewModel.Caption,
Flags = viewModel.Flags,
Icon = viewModel.Icon.ToProjectSystemType(),
ExpandedIcon = viewModel.ExpandedIcon.ToProjectSystemType()
};
ApplyProjectTreePropertiesCustomization(updatedNodeParentContext, updatedValues);
return(node.SetProperties(
caption: viewModel.Caption,
browseObjectProperties: rule,
icon: viewModel.Icon.ToProjectSystemType(),
expandedIcon: viewModel.ExpandedIcon.ToProjectSystemType()));
}
private IProjectTree CreateOrUpdateNode(
IProjectTree?node,
IDependencyViewModel viewModel,
IRule?browseObjectProperties,
bool isProjectItem,
ProjectTreeFlags?additionalFlags = null,
ProjectTreeFlags?excludedFlags = null)
{
if (node != null)
{
return(UpdateTreeNode());
}
ProjectTreeFlags filteredFlags = FilterFlags(viewModel.Flags);
return(isProjectItem
? CreateProjectItemTreeNode()
: CreateProjectTreeNode());
IProjectTree CreateProjectTreeNode()
{
return(_treeServices.CreateTree(
caption: viewModel.Caption,
filePath: viewModel.FilePath,
browseObjectProperties: browseObjectProperties,
icon: viewModel.Icon.ToProjectSystemType(),
expandedIcon: viewModel.ExpandedIcon.ToProjectSystemType(),
visible: true,
flags: filteredFlags));
}
IProjectTree CreateProjectItemTreeNode()
{
var itemContext = ProjectPropertiesContext.GetContext(
_commonServices.Project,
file: viewModel.FilePath,
itemType: viewModel.SchemaItemType,
itemName: viewModel.FilePath);
return(_treeServices.CreateTree(
caption: viewModel.Caption,
itemContext: itemContext,
browseObjectProperties: browseObjectProperties,
icon: viewModel.Icon.ToProjectSystemType(),
expandedIcon: viewModel.ExpandedIcon.ToProjectSystemType(),
visible: true,
flags: filteredFlags));
}
IProjectTree UpdateTreeNode()
{
var updatedNodeParentContext = new ProjectTreeCustomizablePropertyContext
{
ExistsOnDisk = false,
ParentNodeFlags = node !.Parent?.Flags ?? default
};
var updatedValues = new ReferencesProjectTreeCustomizablePropertyValues
{
Caption = viewModel.Caption,
Flags = viewModel.Flags,
Icon = viewModel.Icon.ToProjectSystemType(),
ExpandedIcon = viewModel.ExpandedIcon.ToProjectSystemType()
};
foreach (Lazy <IProjectTreePropertiesProvider, IOrderPrecedenceMetadataView> provider in _projectTreePropertiesProviders)
{
provider.Value.CalculatePropertyValues(updatedNodeParentContext, updatedValues);
}
return(node.SetProperties(
caption: updatedValues.Caption,
browseObjectProperties: browseObjectProperties,
icon: updatedValues.Icon,
expandedIcon: updatedValues.ExpandedIcon,
flags: updatedValues.Flags));
}
ProjectTreeFlags FilterFlags(ProjectTreeFlags flags)
{
if (additionalFlags.HasValue)
{
flags = flags.Union(additionalFlags.Value);
}
if (excludedFlags.HasValue)
{
flags = flags.Except(excludedFlags.Value);
}
return(flags);
}
}
public async Task <IProjectTree> BuildTreeAsync(
IProjectTree dependenciesTree,
DependenciesSnapshot snapshot,
CancellationToken cancellationToken = default)
{
// Keep a reference to the original tree to return in case we are cancelled.
IProjectTree originalTree = dependenciesTree;
bool hasSingleTarget = snapshot.DependenciesByTargetFramework.Count(x => !x.Key.Equals(TargetFramework.Any)) == 1;
var currentTopLevelNodes = new HashSet <IProjectTree>();
if (hasSingleTarget)
{
await BuildSingleTargetTreeAsync();
}
else
{
await BuildMultiTargetTreeAsync();
}
if (cancellationToken.IsCancellationRequested)
{
return(originalTree);
}
dependenciesTree = CleanupOldNodes(dependenciesTree, currentTopLevelNodes);
ProjectImageMoniker rootIcon = _viewModelFactory.GetDependenciesRootIcon(snapshot.HasReachableVisibleUnresolvedDependency).ToProjectSystemType();
return(dependenciesTree.SetProperties(icon: rootIcon, expandedIcon: rootIcon));
async Task BuildSingleTargetTreeAsync()
{
foreach ((ITargetFramework _, TargetedDependenciesSnapshot targetedSnapshot) in snapshot.DependenciesByTargetFramework)
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
dependenciesTree = await BuildSubTreesAsync(
rootNode : dependenciesTree,
snapshot.ActiveTargetFramework,
targetedSnapshot,
RememberNewNodes);
}
}
async Task BuildMultiTargetTreeAsync()
{
foreach ((ITargetFramework targetFramework, TargetedDependenciesSnapshot targetedSnapshot) in snapshot.DependenciesByTargetFramework)
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
if (targetFramework.Equals(TargetFramework.Any))
{
dependenciesTree = await BuildSubTreesAsync(
rootNode : dependenciesTree,
snapshot.ActiveTargetFramework,
targetedSnapshot,
RememberNewNodes);
}
else
{
IProjectTree? node = dependenciesTree.FindChildWithCaption(targetFramework.FriendlyName);
bool shouldAddTargetNode = node == null;
IDependencyViewModel targetViewModel = _viewModelFactory.CreateTargetViewModel(targetedSnapshot);
node = CreateOrUpdateNode(
node,
targetViewModel,
browseObjectProperties: null,
isProjectItem: false,
additionalFlags: ProjectTreeFlags.Create(ProjectTreeFlags.Common.BubbleUp));
node = await BuildSubTreesAsync(
rootNode : node,
snapshot.ActiveTargetFramework,
targetedSnapshot,
CleanupOldNodes);
dependenciesTree = shouldAddTargetNode
? dependenciesTree.Add(node).Parent !
: node.Parent !;
Assumes.NotNull(dependenciesTree);
currentTopLevelNodes.Add(node);
}
}
}
IProjectTree RememberNewNodes(IProjectTree rootNode, IEnumerable <IProjectTree> currentNodes)
{
if (currentNodes != null)
{
currentTopLevelNodes.AddRange(currentNodes);
}
return(rootNode);
}
}
private IProjectTree CreateOrUpdateNode(
IProjectTree?node,
IDependencyViewModel viewModel,
IRule?browseObjectProperties,
bool isProjectItem,
ProjectTreeFlags?additionalFlags = null,
ProjectTreeFlags?excludedFlags = null)
{
if (node != null)
{
return(UpdateTreeNode());
}
string?filePath = viewModel.OriginalModel != null &&
viewModel.OriginalModel.TopLevel &&
viewModel.OriginalModel.Resolved
? viewModel.OriginalModel.GetTopLevelId()
: viewModel.FilePath;
ProjectTreeFlags filteredFlags = FilterFlags(viewModel.Flags);
return(isProjectItem
? CreateProjectItemTreeNode()
: CreateProjectTreeNode());
IProjectTree CreateProjectTreeNode()
{
// For IProjectTree remove ProjectTreeFlags.Common.Reference flag, otherwise CPS would fail to
// map this node to graph node and GraphProvider would be never called.
// Only IProjectItemTree can have this flag
filteredFlags = filteredFlags.Except(DependencyTreeFlags.BaseReferenceFlags);
return(_treeServices.CreateTree(
caption: viewModel.Caption,
filePath,
browseObjectProperties: browseObjectProperties,
icon: viewModel.Icon.ToProjectSystemType(),
expandedIcon: viewModel.ExpandedIcon.ToProjectSystemType(),
visible: true,
flags: filteredFlags));
}
IProjectTree CreateProjectItemTreeNode()
{
Assumes.NotNull(filePath);
var itemContext = ProjectPropertiesContext.GetContext(
_commonServices.Project,
file: filePath,
itemType: viewModel.SchemaItemType,
itemName: filePath);
return(_treeServices.CreateTree(
caption: viewModel.Caption,
itemContext: itemContext,
browseObjectProperties: browseObjectProperties,
icon: viewModel.Icon.ToProjectSystemType(),
expandedIcon: viewModel.ExpandedIcon.ToProjectSystemType(),
visible: true,
flags: filteredFlags));
}
IProjectTree UpdateTreeNode()
{
var updatedNodeParentContext = new ProjectTreeCustomizablePropertyContext
{
ExistsOnDisk = false,
ParentNodeFlags = node !.Parent?.Flags ?? default
};
var updatedValues = new ReferencesProjectTreeCustomizablePropertyValues
{
Caption = viewModel.Caption,
Flags = viewModel.Flags,
Icon = viewModel.Icon.ToProjectSystemType(),
ExpandedIcon = viewModel.ExpandedIcon.ToProjectSystemType()
};
foreach (Lazy <IProjectTreePropertiesProvider, IOrderPrecedenceMetadataView> provider in _projectTreePropertiesProviders)
{
provider.Value.CalculatePropertyValues(updatedNodeParentContext, updatedValues);
}
return(node.SetProperties(
caption: updatedValues.Caption,
browseObjectProperties: browseObjectProperties,
icon: updatedValues.Icon,
expandedIcon: updatedValues.ExpandedIcon,
flags: updatedValues.Flags));
}
ProjectTreeFlags FilterFlags(ProjectTreeFlags flags)
{
if (additionalFlags.HasValue)
{
flags = flags.Union(additionalFlags.Value);
}
if (excludedFlags.HasValue)
{
flags = flags.Except(excludedFlags.Value);
}
return(flags);
}
}
/// <summary>
/// Builds Dependencies tree for given dependencies snapshot
/// </summary>
public override async Task <IProjectTree> BuildTreeAsync(
IProjectTree dependenciesTree,
IDependenciesSnapshot snapshot,
CancellationToken cancellationToken = default)
{
IProjectTree originalTree = dependenciesTree;
var currentTopLevelNodes = new List <IProjectTree>();
IProjectTree RememberNewNodes(IProjectTree rootNode, IEnumerable <IProjectTree> currentNodes)
{
if (currentNodes != null)
{
currentTopLevelNodes.AddRange(currentNodes);
}
return(rootNode);
}
if (snapshot.Targets.Count(x => !x.Key.Equals(TargetFramework.Any)) == 1)
{
foreach ((ITargetFramework _, ITargetedDependenciesSnapshot targetedSnapshot) in snapshot.Targets)
{
if (cancellationToken.IsCancellationRequested)
{
return(originalTree);
}
dependenciesTree = await BuildSubTreesAsync(
rootNode : dependenciesTree,
snapshot.ActiveTarget,
targetedSnapshot,
RememberNewNodes);
}
}
else
{
foreach ((ITargetFramework targetFramework, ITargetedDependenciesSnapshot targetedSnapshot) in snapshot.Targets)
{
if (cancellationToken.IsCancellationRequested)
{
return(originalTree);
}
if (targetFramework.Equals(TargetFramework.Any))
{
dependenciesTree = await BuildSubTreesAsync(
rootNode : dependenciesTree,
snapshot.ActiveTarget,
targetedSnapshot,
RememberNewNodes);
}
else
{
IProjectTree node = dependenciesTree.FindChildWithCaption(targetFramework.FriendlyName);
bool shouldAddTargetNode = node == null;
IDependencyViewModel targetViewModel = ViewModelFactory.CreateTargetViewModel(targetedSnapshot);
node = CreateOrUpdateNode(
node,
targetViewModel,
rule: null,
isProjectItem: false,
additionalFlags: ProjectTreeFlags.Create(ProjectTreeFlags.Common.BubbleUp));
node = await BuildSubTreesAsync(
rootNode : node,
snapshot.ActiveTarget,
targetedSnapshot,
CleanupOldNodes);
dependenciesTree = shouldAddTargetNode
? dependenciesTree.Add(node).Parent
: node.Parent;
currentTopLevelNodes.Add(node);
}
}
}
dependenciesTree = CleanupOldNodes(dependenciesTree, currentTopLevelNodes);
// now update root Dependencies node status
ProjectImageMoniker rootIcon = ViewModelFactory.GetDependenciesRootIcon(snapshot.HasUnresolvedDependency).ToProjectSystemType();
return(dependenciesTree.SetProperties(icon: rootIcon, expandedIcon: rootIcon));
}
/// <summary>
/// Builds all available sub trees under root: target framework or Dependencies node
/// when there is only one target.
/// </summary>
private async Task <IProjectTree> BuildSubTreesAsync(
IProjectTree rootNode,
ITargetFramework activeTarget,
ITargetedDependenciesSnapshot targetedSnapshot,
IProjectCatalogSnapshot catalogs,
Func <IProjectTree, IEnumerable <IProjectTree>, IProjectTree> syncFunc)
{
var currentNodes = new List <IProjectTree>();
var grouppedByProviderType = new Dictionary <string, List <IDependency> >(StringComparer.OrdinalIgnoreCase);
foreach (IDependency dependency in targetedSnapshot.TopLevelDependencies)
{
if (!dependency.Visible)
{
if (dependency.Flags.Contains(DependencyTreeFlags.ShowEmptyProviderRootNode))
{
// if provider sends special invisible node with flag ShowEmptyProviderRootNode, we
// need to show provider node even if it does not have any dependencies.
grouppedByProviderType.Add(dependency.ProviderType, new List <IDependency>());
}
continue;
}
if (!grouppedByProviderType.TryGetValue(dependency.ProviderType, out List <IDependency> dependencies))
{
dependencies = new List <IDependency>();
grouppedByProviderType.Add(dependency.ProviderType, dependencies);
}
dependencies.Add(dependency);
}
bool isActiveTarget = targetedSnapshot.TargetFramework.Equals(activeTarget);
foreach (KeyValuePair <string, List <IDependency> > dependencyGroup in grouppedByProviderType)
{
IDependencyViewModel subTreeViewModel = ViewModelFactory.CreateRootViewModel(
dependencyGroup.Key, targetedSnapshot.CheckForUnresolvedDependencies(dependencyGroup.Key));
IProjectTree subTreeNode = rootNode.FindNodeByCaption(subTreeViewModel.Caption);
bool isNewSubTreeNode = subTreeNode == null;
ProjectTreeFlags excludedFlags = ProjectTreeFlags.Empty;
if (targetedSnapshot.TargetFramework.Equals(TargetFramework.Any))
{
excludedFlags = ProjectTreeFlags.Create(ProjectTreeFlags.Common.BubbleUp);
}
subTreeNode = CreateOrUpdateNode(
subTreeNode,
subTreeViewModel,
rule: null,
isProjectItem: false,
excludedFlags: excludedFlags);
subTreeNode = await BuildSubTreeAsync(
subTreeNode,
targetedSnapshot,
dependencyGroup.Value,
catalogs,
isActiveTarget,
shouldCleanup : !isNewSubTreeNode).ConfigureAwait(false);
currentNodes.Add(subTreeNode);
if (isNewSubTreeNode)
{
rootNode = rootNode.Add(subTreeNode).Parent;
}
else
{
rootNode = subTreeNode.Parent;
}
}
return(syncFunc(rootNode, currentNodes));
}
/// <summary>
/// Builds all available sub trees under root: target framework or Dependencies node
/// when there is only one target.
/// </summary>
private async Task <IProjectTree> BuildSubTreesAsync(
IProjectTree rootNode,
ITargetFramework activeTarget,
ITargetedDependenciesSnapshot targetedSnapshot,
Func <IProjectTree, IEnumerable <IProjectTree>, IProjectTree> syncFunc)
{
var groupedByProviderType = new Dictionary <string, List <IDependency> >(StringComparers.DependencyProviderTypes);
foreach (IDependency dependency in targetedSnapshot.TopLevelDependencies)
{
if (!dependency.Visible)
{
if (dependency.Flags.Contains(DependencyTreeFlags.ShowEmptyProviderRootNode))
{
// if provider sends special invisible node with flag ShowEmptyProviderRootNode, we
// need to show provider node even if it does not have any dependencies.
groupedByProviderType.Add(dependency.ProviderType, new List <IDependency>());
}
continue;
}
if (!groupedByProviderType.TryGetValue(dependency.ProviderType, out List <IDependency> dependencies))
{
dependencies = new List <IDependency>();
groupedByProviderType.Add(dependency.ProviderType, dependencies);
}
dependencies.Add(dependency);
}
var currentNodes = new List <IProjectTree>(capacity: groupedByProviderType.Count);
bool isActiveTarget = targetedSnapshot.TargetFramework.Equals(activeTarget);
foreach ((string providerType, List <IDependency> dependencies) in groupedByProviderType)
{
IDependencyViewModel subTreeViewModel = ViewModelFactory.CreateRootViewModel(
providerType, targetedSnapshot.CheckForUnresolvedDependencies(providerType));
IProjectTree subTreeNode = rootNode.FindChildWithCaption(subTreeViewModel.Caption);
bool isNewSubTreeNode = subTreeNode == null;
ProjectTreeFlags excludedFlags = targetedSnapshot.TargetFramework.Equals(TargetFramework.Any)
? ProjectTreeFlags.Create(ProjectTreeFlags.Common.BubbleUp)
: ProjectTreeFlags.Empty;
subTreeNode = CreateOrUpdateNode(
subTreeNode,
subTreeViewModel,
rule: null,
isProjectItem: false,
excludedFlags: excludedFlags);
subTreeNode = await BuildSubTreeAsync(
subTreeNode,
targetedSnapshot,
dependencies,
isActiveTarget,
shouldCleanup : !isNewSubTreeNode);
currentNodes.Add(subTreeNode);
rootNode = isNewSubTreeNode
? rootNode.Add(subTreeNode).Parent
: subTreeNode.Parent;
}
return(syncFunc(rootNode, currentNodes));
}
private GraphNodeId GetGraphNodeId(string projectPath, GraphNode parentNode, IDependencyViewModel viewModel)
{
return(GetGraphNodeId(projectPath, parentNode, viewModel.Caption));
}
public static IEnumerable <ImageMoniker> GetIcons(this IDependencyViewModel self)
{
yield return(self.Icon);
yield return(self.ExpandedIcon);
}
