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()));
}
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);
}
}
/// <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 Dependencies tree for given dependencies snapshot
/// </summary>
public override IProjectTree BuildTree(
IProjectTree dependenciesTree,
IDependenciesSnapshot snapshot,
CancellationToken cancellationToken = default(CancellationToken))
{
var originalTree = dependenciesTree;
var currentTopLevelNodes = new List <IProjectTree>();
Func <IProjectTree, IEnumerable <IProjectTree>, IProjectTree> rememberNewNodes = (rootNode, currentNodes) =>
{
if (currentNodes != null)
{
currentTopLevelNodes.AddRange(currentNodes);
}
return(rootNode);
};
if (snapshot.Targets.Where(x => !x.Key.Equals(TargetFramework.Any)).Count() == 1)
{
foreach (var target in snapshot.Targets)
{
if (cancellationToken.IsCancellationRequested)
{
return(originalTree);
}
dependenciesTree = BuildSubTrees(
dependenciesTree,
snapshot.ActiveTarget,
target.Value,
target.Value.Catalogs,
rememberNewNodes);
}
}
else
{
foreach (var target in snapshot.Targets)
{
if (cancellationToken.IsCancellationRequested)
{
return(originalTree);
}
if (target.Key.Equals(TargetFramework.Any))
{
dependenciesTree = BuildSubTrees(dependenciesTree,
snapshot.ActiveTarget,
target.Value,
target.Value.Catalogs,
rememberNewNodes);
}
else
{
var node = dependenciesTree.FindNodeByCaption(target.Key.FriendlyName);
var shouldAddTargetNode = node == null;
var targetViewModel = ViewModelFactory.CreateTargetViewModel(target.Value);
node = CreateOrUpdateNode(node,
targetViewModel,
rule: null,
isProjectItem: false,
additionalFlags: ProjectTreeFlags.Create(ProjectTreeFlags.Common.BubbleUp));
node = BuildSubTrees(node, snapshot.ActiveTarget, target.Value, target.Value.Catalogs, CleanupOldNodes);
if (shouldAddTargetNode)
{
dependenciesTree = dependenciesTree.Add(node).Parent;
}
else
{
dependenciesTree = node.Parent;
}
currentTopLevelNodes.Add(node);
}
}
}
dependenciesTree = CleanupOldNodes(dependenciesTree, currentTopLevelNodes);
// now update root Dependencies node status
var rootIcon = ViewModelFactory.GetDependenciesRootIcon(snapshot.HasUnresolvedDependency).ToProjectSystemType();
return(dependenciesTree.SetProperties(icon: rootIcon, expandedIcon: rootIcon));
}
private IProjectTree CreateOrUpdateNode(
IProjectTree node,
IDependencyViewModel viewModel,
IRule rule,
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: rule,
icon: viewModel.Icon.ToProjectSystemType(),
expandedIcon: viewModel.ExpandedIcon.ToProjectSystemType(),
visible: true,
flags: filteredFlags));
}
IProjectTree CreateProjectItemTreeNode()
{
var itemContext = ProjectPropertiesContext.GetContext(
_commonServices.Project,
file: filePath,
itemType: viewModel.SchemaItemType,
itemName: filePath);
return(_treeServices.CreateTree(
caption: viewModel.Caption,
itemContext: itemContext,
browseObjectProperties: rule,
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: rule,
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);
}
}
