private void GenerateNodes(IHierarchyNode parentNode, NetworkNodeViewModel parentGraphNode, Point point)
{
int offset = 0;
foreach (IHierarchyNode hierarchyNode in parentNode.Children)
{
Point graphNodeLocation = new Point(point.X, offset);
NetworkNodeViewModel graphNode = null;
if (hierarchyNode is ArtistHierarchyNode)
{
graphNode = CreateArtistGraphNode(hierarchyNode, graphNodeLocation);
}
else if (hierarchyNode is NewReleaseHierarchyNode)
{
graphNode = CreateNewReleasesGraphNode(hierarchyNode, graphNodeLocation);
}
ConnectionViewModel connection = new ConnectionViewModel();
connection.SourceConnector = parentGraphNode.OutputConnectors[0];
connection.DestConnector = graphNode.InputConnectors[0];
// Add the connection to the graph.
this.Network.Connections.Add(connection);
//Generate any children.
GenerateNodes(hierarchyNode, graphNode, new Point(point.X + 1, 0));
offset++;
}
}
public HierarchyTreeViewItem(
IHierarchyNode node,
IEnumerable <HierarchyTreeViewItem> children
)
{
_node = node;
Children = new HierarchyTreeViewItemCollection(children);
_isChecked = false;
_isExpanded = true;
// Connect the children to this parent item.
foreach (var child in Children)
{
child.Parent = this;
}
// If there are children, then that collection could
// change as the items are filtered. We will need to
// update our checked state when that collection changes.
if (Children.Count > 0)
{
Children.CollectionChanged += (s, e) => UpdateCheckedStateFromChildren(true);
}
}
private TreeNode CreateNode(TreeNodeCollection parentCollection, IHierarchyNode hierarchyNode)
{
Debug.Assert(hierarchyNode.Icon != null);
TreeNode node = new TreeNode(hierarchyNode.Name);
if (!treeIcons.Images.ContainsKey(hierarchyNode.IconKey) && hierarchyNode.Icon != null)
{
treeIcons.Images.Add(hierarchyNode.IconKey, hierarchyNode.Icon);
}
node.ImageKey = hierarchyNode.IconKey;
node.SelectedImageKey = hierarchyNode.IconKey;
node.Name = hierarchyNode.Name;
node.Tag = hierarchyNode;
if (hierarchyNode.HasChildren)
{
bool filterAll = true;
foreach (IHierarchyNode child in hierarchyNode.Children)
{
if (!Filter(child))
{
filterAll = false;
break;
}
}
if (!filterAll)
{
TreeNode firstChildNode = new TreeNode {
Tag = _childrenTag
};
node.Nodes.Add(firstChildNode);
}
}
parentCollection.Add(node);
return(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <returns>Returns whether the sub-tree has been fully expanded in the hierarchy.</returns>
public override void GenerateSubTree(IHierarchyNode node)
{
ArtistHierarchyNode subTreeNode = (ArtistHierarchyNode)node;
ArtistGroup relatedArtistList = Client.GetRelatedArtists(subTreeNode.ArtistViewModel.Artist.ID);
//First determine which artists are new; add those.
int nodesAdded = 0;
foreach (Artist relatedArtist in relatedArtistList.Artists)
{
if (NodeDictionary.ContainsKey(relatedArtist.Name))
{
continue;
}
if (nodesAdded < AddChildrenLimit)
{
ArtistViewModel artistViewModel = new ArtistViewModel(relatedArtist);
ArtistHierarchyNode relatedArtistNode = new ArtistHierarchyNode(artistViewModel, this, subTreeNode, subTreeNode.Level + 1);
subTreeNode.Children.Add(relatedArtistNode);
NodeDictionary.Add(relatedArtist.Name, relatedArtistNode);
nodesAdded++;
}
else
{
return;
}
}
}
private void SetUpProjectLinks()
{
Collection <ProjectLinkItem> projectLinks = new Collection <ProjectLinkItem>();
foreach (ProjectLink projectLink in _projectLinkTracker.GetProjectLinks())
{
ProjectLinkItem item = new ProjectLinkItem
{
SourceProjectName = GetProjectNameFromGuid(projectLink.SourceProjectId),
SourceProjectGuid = projectLink.SourceProjectId,
TargetProjectName = GetProjectNameFromGuid(projectLink.TargetProjectId),
TargetProjectGuid = projectLink.TargetProjectId
};
projectLinks.Add(item);
}
_view.ProjectLinks = projectLinks;
IHierarchyNode selectedHierarchyNode = _hierarchyNodeFactory.GetSelectedProject();
if (selectedHierarchyNode != null)
{
string selectedProjectRelativeName = selectedHierarchyNode.SolutionRelativeName;
foreach (ProjectLinkItem linkItem in projectLinks)
{
if (linkItem.TargetProjectName == selectedProjectRelativeName)
{
_view.SelectedProjectLinkItems = new Collection <ProjectLinkItem> {
linkItem
};
break;
}
}
}
}
public SolutionPickerView(IServiceProvider provider, IHierarchyNode targetProject)
{
InitializeComponent();
IVsSolution solution = provider.GetService(typeof(SVsSolution)) as IVsSolution;
new SolutionPickerPresenter(new HierarchyNode(solution), this, targetProject);
this.CenterToParent();
}
/// <summary>
/// Creates an unordered hierarchical list
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="tagBuilder">The tag builder.</param>
/// <param name="rootNode">The root node.</param>
/// <param name="childrenProperty">The children property.</param>
/// <param name="itemContent">Content of the item.</param>
/// <param name="selectedItemContent">Content of the selected item.</param>
/// <param name="expandedItemContent">Content of the expanded item.</param>
/// <param name="enableDisplayInMenu">if set to <c>true</c> [enable display in menu].</param>
private static void AppendChildrenRecursive <T>(TagBuilder tagBuilder, IHierarchyNode <IPageModel> rootNode, Func <IHierarchyNode <IPageModel>, IEnumerable <IHierarchyNode <IPageModel> > > childrenProperty, Func <T, MvcHtmlString> itemContent, Func <T, MvcHtmlString> selectedItemContent, Func <T, MvcHtmlString> expandedItemContent, bool enableDisplayInMenu = true)
{
var children = childrenProperty(rootNode);
if (children != null && enableDisplayInMenu)
{
children = children.Where(x => x.Entity.Metadata.DisplayInMenu);
}
if (!children.Any())
{
tagBuilder.InnerHtml += new TagBuilder("li").ToString(TagRenderMode.EndTag);
return;
}
var ul = new TagBuilder("ul");
foreach (var item in children)
{
RenderLi(ul, (T)item.Entity, item.Entity.Id.Equals(CurrentPage) ? selectedItemContent : (item.Expanded ? expandedItemContent : itemContent));
AppendChildrenRecursive(ul, item, childrenProperty, itemContent, selectedItemContent, expandedItemContent);
}
tagBuilder.InnerHtml += ul.ToString(TagRenderMode.Normal);
tagBuilder.InnerHtml += new TagBuilder("li").ToString(TagRenderMode.EndTag);
}
public SolutionPickerView(IServiceProvider provider, IHierarchyNode targetProject)
{
InitializeComponent();
IVsSolution solution = provider.GetService(typeof(SVsSolution)) as IVsSolution;
new SolutionPickerPresenter(new HierarchyNode(solution), this, targetProject);
CenterToParent();
}
private bool Filter(IHierarchyNode node)
{
if (_filter != null && _filter.Filter(node))
{
return(true);
}
return(false);
}
public SolutionPickerPresenter(IHierarchyNode solutionNode, ISolutionPickerView view, IHierarchyNode targetProject)
{
this.view = view;
this.targetProject = targetProject;
view.CanExit = false;
view.SetRootHierarchyNode(solutionNode);
view.SelectedNodeChanged += new EventHandler(view_SelectedNodeChanged);
}
public SolutionPickerPresenter(IHierarchyNode solutionNode, ISolutionPickerView view, IHierarchyNode targetProject)
{
_view = view;
_targetProject = targetProject;
view.CanExit = false;
view.SetRootHierarchyNode(solutionNode);
view.SelectedNodeChanged += view_SelectedNodeChanged;
}
void view_SelectedNodeChanged(object sender, EventArgs e)
{
IHierarchyNode node = _view.SelectedNode;
bool isValidSelection = node.TypeGuid == _targetProject.TypeGuid;
isValidSelection &= node.ProjectGuid != _targetProject.ProjectGuid;
_view.CanExit = isValidSelection;
}
private bool SelectFilter(IHierarchyNode node)
{
if (_onSelectFilter != null && _onSelectFilter.Filter(node))
{
return(true);
}
return(false);
}
private void Initialize(IHierarchyNode rootNode, ISolutionPickerFilter pickerFilter)
{
_filter = pickerFilter;
_root = rootNode;
InitializeComponent();
SuspendLayout();
CreateNode(solutionTree.Nodes, _root);
solutionTree.Nodes[0].Expand();
ResumeLayout(false);
}
/// <summary>
/// Filter method
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public bool Filter(IHierarchyNode node)
{
if (node.IsSolution)
{
return false;
}
if (node.ExtObject is EnvDTE.Project)
{
return false;
}
return true;
}
/// <summary>
/// Filter method
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public bool Filter(IHierarchyNode node)
{
if (node.IsSolution)
{
return(false);
}
if (node.ExtObject is Project)
{
return(false);
}
return(true);
}
private void OnBeforeExpand(object sender, TreeViewCancelEventArgs e)
{
if (e.Node.Nodes.Count == 1 && e.Node.Nodes[0].Tag == _childrenTag)
{
e.Node.Nodes.Remove(e.Node.Nodes[0]);
IHierarchyNode hierarchyNode = (IHierarchyNode)e.Node.Tag;
foreach (IHierarchyNode child in hierarchyNode.Children)
{
if (!Filter(child))
{
CreateNode(e.Node.Nodes, child);
}
}
}
}
public int GetChildrenDepth(IHierarchyNode targetNode)
{
if (!targetNode.Children.Any())
{
return(1);
}
else
{
int totalDepth = 0;
foreach (IHierarchyNode childNode in targetNode.Children)
{
totalDepth += GetChildrenDepth(childNode);
}
return(totalDepth);
}
}
/// <summary>
/// This function is the callback used to execute the command when the menu item is clicked.
/// See the constructor to see how the menu item is associated with this function using
/// OleMenuCommandService service and MenuCommand class.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Event args.</param>
private void MenuItemCallback(object sender, EventArgs e)
{
IVsSolution solution = _package.GetService <IVsSolution, SVsSolution>();
// As the "Edit Links" command is added on the Project menu even when no solution is opened, it must
// be validated that a solution exists (in case it doesn't, GetSolutionInfo() returns 3 nulled strings).
ErrorHandler.ThrowOnFailure(solution.GetSolutionInfo(out string s1, out string s2, out string s3));
if (s1 != null && s2 != null && s3 != null)
{
IVsUIShell uiShell = _package.GetService <IVsUIShell, SVsUIShell>();
ErrorHandler.ThrowOnFailure(uiShell.GetDialogOwnerHwnd(out IntPtr parentHwnd));
HierarchyNodeFactory hierarchyNodeFactory = new HierarchyNodeFactory(ServiceProvider);
IHierarchyNode targetProject = hierarchyNodeFactory.GetSelectedProject();
SolutionPickerView solutionPicker = new SolutionPickerView(ServiceProvider, targetProject);
DialogResult result = solutionPicker.ShowDialog(new WindowHandleAdapter(parentHwnd));
if (result == DialogResult.OK)
{
try
{
IHierarchyNode sourceProject = solutionPicker.SelectedNode;
IProjectLinkTracker linker = _package.GetService <IProjectLinkTracker, ISProjectLinkTracker>();
// todo
linker.AddProjectLink(sourceProject.ProjectGuid, targetProject.ProjectGuid);
if (solutionPicker.CopyProjectItemsByDefault)
{
linker.LinkAllProjectItems(sourceProject.ProjectGuid, targetProject.ProjectGuid);
}
_package.ShowInformationalMessageBox(
Resources.ProjectLinkerCaption,
Resources.ProjectsSuccessfullyLinked,
false);
}
catch (ProjectLinkerException ex)
{
_package.ShowInformationalMessageBox(Resources.ProjectLinkerCaption, ex.Message, true);
}
}
}
}
public ArtistNetworkNodeViewModel(
ArtistViewModel viewModel,
AtlasHierarchy hierarchy,
IHierarchyNode hierarchyNode,
IPlaylistView playlist)
: base(viewModel.Name)
{
ArtistViewModel = viewModel;
Debug.Assert(hierarchyNode is ArtistHierarchyNode);
_hierarchyNode = (ArtistHierarchyNode)hierarchyNode;
_hierarchy = hierarchy;
_playlist = playlist;
_numTracks = GetArtistTrackCount();
IsHighlighted = SpotifyCacheService.IsArtistFollowed(ArtistViewModel.Artist);
}
/// <summary>
/// Create a graph node and add it to the view-model.
/// </summary>
public NetworkNodeViewModel CreateArtistGraphNode(IHierarchyNode hierarchyNode, Point nodeLocation)
{
Debug.Assert(hierarchyNode is ArtistHierarchyNode);
ArtistViewModel viewModel = ((ArtistHierarchyNode)hierarchyNode).ArtistViewModel;
ArtistNetworkNodeViewModel node = new ArtistNetworkNodeViewModel(viewModel, _hierarchy, ((ArtistHierarchyNode)hierarchyNode), PlaylistService.GetCurrentPlaylist());
// Initialize any style modifiers.
node.X = nodeLocation.X;
node.Y = nodeLocation.Y;
node.InputConnectors.Add(new ConnectorViewModel("", ConnectorType.Input));
node.OutputConnectors.Add(new ConnectorViewModel("", ConnectorType.Output));
hierarchyNode.GraphNodeViewModel = node;
// Add the node to the view-model.
//
this.Network.Nodes.Add(node);
return(node);
}
private static HierarchyTreeViewItem CreateItem(IHierarchyNode node)
{
HierarchyTreeViewItem item;
item = new HierarchyTreeViewItem(node, node.Children.Select(CreateItem));
// Set the checked state of the item. If it has children, then we check
// it based on whether all or none of the children are checked. If it
// doesn't have children, then we check it if the node is loaded. In either
// case, we only set the checked state of the direct item and don't affect
// the children or parent because the children have already been initialized,
// and the parent will be initialized when we return from this method.
item.SetIsChecked(
item.Children.Count > 0 ? item.Children.CalculateCheckedState() : node.IsLoaded,
false,
false
);
return(item);
}
/// <summary>
/// Create a graph node and add it to the view-model.
/// </summary>
public NetworkNodeViewModel CreateNewReleasesGraphNode(IHierarchyNode hierarchyNode, Point nodeLocation)
{
Debug.Assert(hierarchyNode is NewReleaseHierarchyNode);
NewReleaseItem newReleaseItem = ((NewReleaseHierarchyNode)hierarchyNode).NewReleaseItem;
NewReleaseNetworkNodeViewModel node = new NewReleaseNetworkNodeViewModel(newReleaseItem);
// Initialize any style modifiers.
node.X = nodeLocation.X;
node.Y = nodeLocation.Y;
node.InputConnectors.Add(new ConnectorViewModel("", ConnectorType.Input));
node.OutputConnectors.Add(new ConnectorViewModel("", ConnectorType.Output));
hierarchyNode.GraphNodeViewModel = node;
// Add the node to the view-model.
//
this.Network.Nodes.Add(node);
return(node);
}
internal HierarchyItem(IServiceProvider serviceProvider, IHierarchyNode node)
{
this.ServiceProvider = serviceProvider;
this.HierarchyNode = node;
this.Solution = (IVsSolution)serviceProvider.GetService(typeof(SVsSolution));
}
public VsItemDynamicProperties(IHierarchyNode item)
{
this.node = item;
this.debugPropertiesSnapshot = new Lazy<string>(() => ThreadHelper.Generic.Invoke<string>(() => GetProperties()));
}
public void SetRootHierarchyNode(IHierarchyNode value)
{
UpdatePickerControl(value);
}
private void UpdatePickerControl(IHierarchyNode rootNode)
{
if (_pickerControl != null)
{
this.contentPanel.Controls.Remove(_pickerControl);
}
_pickerControl = new SolutionPickerControl(rootNode, new OnlyProjectsFilter());
_pickerControl.Left = 0;
_pickerControl.Top = 0;
_pickerControl.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right;
_pickerControl.Size = contentPanel.ClientSize;
_pickerControl.SelectionChanged += new EventHandler(_pickerControl_SelectionChanged);
this.contentPanel.Controls.Add(_pickerControl);
}
public bool Filter(IHierarchyNode node)
{
return (!(node.ExtObject is EnvDTE.Project) ||
node.TypeGuid == Microsoft.VisualStudio.VSConstants.GUID_ItemType_VirtualFolder);
}
public void SetRootHierarchyNode(IHierarchyNode value)
{
RootHierarchyNode = value;
}
public VsProject(IServiceProvider serviceProvider, IHierarchyNode node)
: base(serviceProvider, node)
{
this.Data = new AllConfigurationsProperties(this, userData: false);
this.UserData = new AllConfigurationsProperties(this, userData: true);
}
public override void GenerateSubTree(IHierarchyNode node) {
//New Release Items do not have sub-trees.
return;
}
private bool Filter(IHierarchyNode node)
{
if (filter != null && filter.Filter(node))
{
return true;
}
return false;
}
public VsSolutionFolder(IServiceProvider serviceProvider, IHierarchyNode node)
: base(serviceProvider, node)
{ }
private void Initialize(IHierarchyNode rootNode, ISolutionPickerFilter pickerFilter)
{
this.filter = pickerFilter;
this.root = rootNode;
InitializeComponent();
this.SuspendLayout();
CreateNode(solutionTree.Nodes, this.root);
solutionTree.Nodes[0].Expand();
this.ResumeLayout(false);
}
/// <summary>
/// Create an IItemContainer wrapper against IHierarchyNode
/// </summary>
internal static IItemContainer CreateItem(IServiceProvider serviceProvider, IHierarchyNode node)
{
if (node == null)
{
return null;
}
var nestedHiearchy = node.GetObject<IVsHierarchy>();
var extObject = node.ExtObject;
if (nestedHiearchy != null)
{
if (nestedHiearchy.GetType().FullName == "Microsoft.VisualStudio.Project.ProjectNode")
{
return new VsProject(serviceProvider, node);
}
else if (nestedHiearchy.GetType().FullName == "Microsoft.VisualStudio.Project.FolderNode")
{
return new VsFolder(serviceProvider, node);
}
else if (nestedHiearchy is VSLangProj.References)
{
return new VsProjectReference(serviceProvider, node);
}
}
if (extObject != null)
{
if (extObject.GetType().FullName == "Microsoft.VisualStudio.Project.Automation.OAProject")
{
return new VsProject(serviceProvider, node);
}
else if (extObject.GetType().FullName == "Microsoft.VisualStudio.Project.Automation.OAFolderItem")
{
return new VsFolder(serviceProvider, node);
}
else if (extObject is EnvDTE.Project)
{
if (((EnvDTE.Project)extObject).Object is EnvDTE80.SolutionFolder)
{
return new VsSolutionFolder(serviceProvider, node);
}
return new VsProject(serviceProvider, node);
}
else if (extObject is EnvDTE.ProjectItem)
{
string kind = null;
try
{
kind = ((EnvDTE.ProjectItem)extObject).Kind;
}
catch (Exception)
{
kind = null;
}
if (kind == EnvDTE.Constants.vsProjectItemKindPhysicalFolder)
{
return new VsFolder(serviceProvider, node);
}
else
{
EnvDTE.ProjectItem x = (EnvDTE.ProjectItem)extObject;
if (x.Object is VSLangProj.References)
{
return new VsProjectReferences(serviceProvider, node);
}
return new VsItem(serviceProvider, node);
}
}
else if (extObject is VSLangProj.Reference)
{
return new VsProjectReference(serviceProvider, node);
}
else if (extObject is EnvDTE.Solution)
{
return new VsSolution(serviceProvider);
}
return new VsUnknownItem(serviceProvider, node);
}
return new VsUnknownItem(serviceProvider, node);
}
/// <summary>
/// Initializes the control receiving the root value
/// to customize the behavior of the control.
/// </summary>
/// <param name="root"></param>
public SolutionPickerControl(IHierarchyNode root)
: this(root, null)
{
}
/// <summary>
/// Create an IItemContainer wrapper against IHierarchyNode
/// </summary>
internal static IItemContainer CreateItem(IServiceProvider serviceProvider, IHierarchyNode node)
{
if (node == null)
{
return(null);
}
var nestedHiearchy = node.GetObject <IVsHierarchy>();
var extObject = node.ExtObject;
if (nestedHiearchy != null)
{
if (nestedHiearchy.GetType().FullName == "Microsoft.VisualStudio.Project.ProjectNode")
{
return(new VsProject(serviceProvider, node));
}
else if (nestedHiearchy.GetType().FullName == "Microsoft.VisualStudio.Project.FolderNode")
{
return(new VsFolder(serviceProvider, node));
}
else if (nestedHiearchy is VSLangProj.References)
{
return(new VsProjectReference(serviceProvider, node));
}
}
if (extObject != null)
{
if (extObject.GetType().FullName == "Microsoft.VisualStudio.Project.Automation.OAProject")
{
return(new VsProject(serviceProvider, node));
}
else if (extObject.GetType().FullName == "Microsoft.VisualStudio.Project.Automation.OAFolderItem")
{
return(new VsFolder(serviceProvider, node));
}
else if (extObject is EnvDTE.Project)
{
if (((EnvDTE.Project)extObject).Object is EnvDTE80.SolutionFolder)
{
return(new VsSolutionFolder(serviceProvider, node));
}
return(new VsProject(serviceProvider, node));
}
else if (extObject is EnvDTE.ProjectItem)
{
string kind = null;
try
{
kind = ((EnvDTE.ProjectItem)extObject).Kind;
}
catch (Exception)
{
kind = null;
}
if (kind == EnvDTE.Constants.vsProjectItemKindPhysicalFolder)
{
return(new VsFolder(serviceProvider, node));
}
else
{
EnvDTE.ProjectItem x = (EnvDTE.ProjectItem)extObject;
if (x.Object is VSLangProj.References)
{
return(new VsProjectReferences(serviceProvider, node));
}
return(new VsItem(serviceProvider, node));
}
}
else if (extObject is VSLangProj.Reference)
{
return(new VsProjectReference(serviceProvider, node));
}
else if (extObject is EnvDTE.Solution)
{
return(new VsSolution(serviceProvider));
}
return(new VsUnknownItem(serviceProvider, node));
}
return(new VsUnknownItem(serviceProvider, node));
}
public VsProject(IServiceProvider serviceProvider, IHierarchyNode node)
: base(serviceProvider, node)
{
this.Data = new AllConfigurationsProperties(this, userData: false);
this.UserData = new AllConfigurationsProperties(this, userData: true);
}
/// <summary>
/// Selected item in the solution explorer based on given hierarchyNode
/// </summary>
public static void Select(IServiceProvider serviceProvider, IHierarchyNode hierarchyNode)
{
Select(serviceProvider, new[] { hierarchyNode });
}
public ArtistHierarchyNode(ArtistViewModel artistViewModel, AtlasHierarchy hierarchy, IHierarchyNode parent, int level)
: base(hierarchy, parent, level)
{
ArtistViewModel = artistViewModel;
}
public VsItem(IServiceProvider serviceProvider, IHierarchyNode node)
: base(serviceProvider, node)
{
this.Data = new VsItemDynamicProperties(node);
}
private TreeNode CreateNode(TreeNodeCollection parentCollection, IHierarchyNode hierarchyNode)
{
Debug.Assert(hierarchyNode.Icon != null);
TreeNode node = new TreeNode(hierarchyNode.Name);
if (!treeIcons.Images.ContainsKey(hierarchyNode.IconKey) && hierarchyNode.Icon != null)
{
treeIcons.Images.Add(hierarchyNode.IconKey, hierarchyNode.Icon);
}
node.ImageKey = hierarchyNode.IconKey;
node.SelectedImageKey = hierarchyNode.IconKey;
node.Name = hierarchyNode.Name;
node.Tag = hierarchyNode;
if (hierarchyNode.HasChildren)
{
bool filterAll = true;
foreach (IHierarchyNode child in hierarchyNode.Children)
{
if (!Filter(child))
{
filterAll = false;
break;
}
}
if (!filterAll)
{
TreeNode firstChildNode = new TreeNode();
firstChildNode.Tag = childrenTag;
node.Nodes.Add(firstChildNode);
}
}
parentCollection.Add(node);
return node;
}
public void SetRootHierarchyNode(IHierarchyNode value)
{
RootHierarchyNode = value;
}
private bool SelectFilter(IHierarchyNode node)
{
if (onSelectFilter != null & onSelectFilter.Filter(node))
{
return true;
}
return false;
}
public VsProjectReferences(IServiceProvider serviceProvider, IHierarchyNode node)
: base(serviceProvider, node)
{
}
public bool Filter(IHierarchyNode node)
{
return(!(node.ExtObject is Project) ||
node.TypeGuid == VSConstants.GUID_ItemType_VirtualFolder);
}
public VsProjectReferences(IServiceProvider serviceProvider, IHierarchyNode node)
: base(serviceProvider, node)
{ }
/// <summary>
/// Initializes the control receiving the root value and a filter
/// to customize the behavior of the control.
/// </summary>
/// <param name="root"></param>
/// <param name="filter"></param>
public SolutionPickerControl(IHierarchyNode root, ISolutionPickerFilter filter = null)
{
Initialize(root, filter);
}
/// <summary>
/// Initializes the control receiving the root value and a filter
/// to customize the behavior of the control.
/// </summary>
/// <param name="root"></param>
/// <param name="filter"></param>
public SolutionPickerControl(IHierarchyNode root, ISolutionPickerFilter filter)
{
Initialize(root, filter);
}
public VsUnknownItem(IServiceProvider serviceProvider, IHierarchyNode node)
: base(serviceProvider, node)
{ }
