private ISet <Guid> GetIncludedProjectIds(ISolutionHierarchyItem item, HashSet <Guid> ids, bool isParentIncluded)
{
bool value;
bool?itemInclusionState;
if (m_projects.TryGetValue(item.Id, out value))
{
itemInclusionState = value;
}
else
{
itemInclusionState = null;
}
bool isItemIncluded = isParentIncluded && itemInclusionState == null || itemInclusionState == true;
if (isItemIncluded)
{
ids.Add(item.Id);
}
ISolutionHierarchyContainerItem container = item as ISolutionHierarchyContainerItem;
if (container != null)
{
foreach (ISolutionHierarchyItem child in container.Children)
{
GetIncludedProjectIds(child, ids, isItemIncluded);
}
}
return(ids);
}
public void PopulateFrom(ISolutionHierarchyContainerItem solutionRoot)
{
m_projects.Clear();
foreach (var item in new StateItem(solutionRoot).GetAll().Where(s => s.State != null))
{
m_projects.Add(item.Item.Id, item.State.Value);
}
}
protected ProjectSetContainerNodeViewModel(ProjectSetViewModel owner, ISolutionHierarchyContainerItem node, ProjectSetContainerNodeViewModel parent)
: base(owner, node, parent)
{
m_children = new List <ProjectSetNodeViewModel>(node.Children.Count);
foreach (var item in node.Children.OrderBy(c => c.ItemType == SolutionHierarchyItemType.SolutionFolder ? 0 : 1).ThenBy(c => c.Name, StringComparer.OrdinalIgnoreCase))
{
m_children.Add(CreateFrom(owner, item, this));
}
}
public ISet <Guid> GetIncludedProjectIds(ISolutionHierarchyContainerItem solutionRoot)
{
if (solutionRoot == null)
{
throw new ArgumentNullException("solutionRoot", "solutionRoot is null.");
}
HashSet <Guid> ids = new HashSet <Guid>();
return(GetIncludedProjectIds(solutionRoot, ids, false));
}
public ISolutionHierarchyContainerItem GetSolutionHierarchy(bool visibleNodesOnly = false)
{
Dispatcher.CurrentDispatcher.VerifyAccess();
ISolutionHierarchyContainerItem solution = CreateSolutionHierarchyItem((IVsHierarchy)m_solution, (uint)Microsoft.VisualStudio.VSConstants.VSITEMID_ROOT) as ISolutionHierarchyContainerItem;
if (solution != null)
{
PopulateHierarchy(solution.VsHierarchy, solution.HierarchyItemId, visibleNodesOnly, solution, solution);
}
return(solution);
}
private ISolutionHierarchyItem PopulateHierarchy(IVsHierarchy hierarchy, uint itemId, bool visibleNodesOnly, ISolutionHierarchyContainerItem solutionNode, ISolutionHierarchyItem thisNode)
{
Dispatcher.CurrentDispatcher.VerifyAccess();
ISolutionHierarchyContainerItem container = thisNode as ISolutionHierarchyContainerItem;
if (container != null)
{
if (solutionNode == null)
{
solutionNode = container;
}
IEnumerable <uint> childIds = EnumerateChildIds(hierarchy, itemId, visibleNodesOnly);
List <ISolutionHierarchyItem> list = new List <ISolutionHierarchyItem>();
foreach (uint childId in childIds)
{
ISolutionHierarchyItem childItem = CreateSolutionHierarchyItem(hierarchy, childId);
if (childItem != null)
{
container.Children.Add(childItem);
list.Add(childItem);
// Due to a bug in VS, enumerating the solution node actually returns all projects within the solution, at any depth,
// so we need to remove them here if found.
if (container != solutionNode)
{
solutionNode.Children.Remove(childItem.Id);
}
}
}
foreach (var childItem in list.OfType <ISolutionHierarchyContainerItem>())
{
if (container.Children.Contains(childItem.Id)) // On SolutionNode the child may actually have been removed (see below)
{
PopulateHierarchy(childItem.VsHierarchy, childItem.HierarchyItemId, visibleNodesOnly, solutionNode, childItem);
}
}
}
return(thisNode);
}
public StateItem(ISolutionHierarchyItem item)
{
m_item = item;
ISolutionHierarchyContainerItem container = item as ISolutionHierarchyContainerItem;
if (container == null)
{
m_children = new List <StateItem>();
State = item.ItemType != SolutionHierarchyItemType.UnloadedProject;
}
else
{
m_children = container.Children.Select(c => new StateItem(c)).ToList();
int inclusionCount = m_children.Count(c => c.State == true);
int exclusionCount = m_children.Count - inclusionCount;
if (exclusionCount == 0)
{
m_children.ForEach(si => si.State = null);
State = true;
}
else if (inclusionCount == 0)
{
m_children.ForEach(si => si.State = null);
State = false;
}
else if (inclusionCount == exclusionCount && item.ItemType != SolutionHierarchyItemType.Solution || inclusionCount > exclusionCount)
{
State = true;
m_children.ForEach(si => si.State = si.State == true ? (bool?)null : si.State);
}
else
{
State = false;
m_children.ForEach(si => si.State = si.State == false ? (bool?)null : si.State);
}
}
}
public ProjectSetSolutionFolderNodeViewModel(ProjectSetViewModel owner, ISolutionHierarchyContainerItem node, ProjectSetContainerNodeViewModel parent)
: base(owner, node, parent)
{
}
public ProjectSetSolutionRootNodeViewModel(ProjectSetViewModel owner, ISolutionHierarchyContainerItem node)
: base(owner, node, null)
{
}
public ProjectSetViewModel(ProjectSet projectSet, ISolutionHierarchyContainerItem solutionNode)
{
m_projectSet = projectSet;
m_rootNode = new ProjectSetSolutionRootNodeViewModel(this, solutionNode);
}
private ISolutionHierarchyItem GetSolutionHierarchy(IVsHierarchy hierarchy, uint itemId, bool visibleNodesOnly, ISolutionHierarchyContainerItem solutionNode)
{
Dispatcher.CurrentDispatcher.VerifyAccess();
int hr;
IntPtr nestedHierarchyObj;
uint nestedItemId;
Guid hierGuid = typeof(IVsHierarchy).GUID;
// Check first if this node has a nested hierarchy. If so, then there really are two
// identities for this node: 1. hierarchy/itemid 2. nestedHierarchy/nestedItemId.
// We will recurse and call EnumHierarchyItems which will display this node using
// the inner nestedHierarchy/nestedItemId identity.
hr = hierarchy.GetNestedHierarchy(itemId, ref hierGuid, out nestedHierarchyObj, out nestedItemId);
if (VSConstants.S_OK == hr && IntPtr.Zero != nestedHierarchyObj)
{
IVsHierarchy nestedHierarchy = Marshal.GetObjectForIUnknown(nestedHierarchyObj) as IVsHierarchy;
Marshal.Release(nestedHierarchyObj); // we are responsible to release the refcount on the out IntPtr parameter
if (nestedHierarchy != null)
{
// Display name and type of the node in the Output Window
return(GetSolutionHierarchy(nestedHierarchy, nestedItemId, visibleNodesOnly, solutionNode));
}
return(null);
}
else
{
ISolutionHierarchyItem item = CreateSolutionHierarchyItemDirect(hierarchy, itemId);
ISolutionHierarchyContainerItem container = item as ISolutionHierarchyContainerItem;
if (container != null)
{
if (solutionNode == null)
{
solutionNode = container;
}
IEnumerable <uint> childIds = EnumerateChildIds(hierarchy, itemId, visibleNodesOnly);
if (container == solutionNode && solutionNode != null)
{
childIds = childIds.OrderBy(id => IsSolutionFolder(hierarchy, id) ? 1 : 0);
}
foreach (uint childId in childIds)
{
ISolutionHierarchyItem childItem = GetSolutionHierarchy(hierarchy, childId, visibleNodesOnly, solutionNode);
if (childItem != null)
{
container.Children.Add(childItem);
// Due to a bug in VS, enumerating the solution node actually returns all projects within the solution, at any depth,
// so we need to remove them here if found.
if (container != solutionNode)
{
solutionNode.Children.Remove(childItem.Id);
}
}
}
}
return(item);
}
}
