/// <summary>
/// Includes all files in the Excluded folder in the project
/// </summary>
/// <param name="node">Excluded Node representing the folder</param>
/// <returns></returns>
internal int IncludeFolderItem(ItemNode node)
{
var files = new List <string>();
foreach (var child in node)
{
switch (child.Type)
{
case Constants.ItemNodeType.ExcludedFile:
files.Add(child.Path);
break;
case Constants.ItemNodeType.ExcludedFolder:
IncludeFolderItem(child);
break;
default:
break;
}
}
node.Delete();
uint parent = Project.ProjectProxy.AddFolderItem(node.Path);
foreach (var file in files)
{
ErrorHandler.ThrowOnFailure(Project.ProjectProxy.AddFileItem(parent, file));
}
Project.RefreshSolutionExplorer(new ItemNode[] { node });
return(VSConstants.S_OK);
}
/// <summary>
/// Includes the file represented by the Excluded Node into the project
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
internal int IncludeFileItem(ItemNode node)
{
node.Delete();
int result = Project.ProjectProxy.AddFileItem(node.Parent.ItemId, node.Path);
return(result);
}
/// <summary>
/// Includes all files in the Excluded folder in the project
/// </summary>
/// <param name="node">Excluded Node representing the folder</param>
/// <returns></returns>
internal int IncludeFolderItem(ItemNode node)
{
var path = node.Path;
ensure_included(node);
// It is necessary to re-acquire the node, because the ensure_included recreated it
var folder_node = this[path];
foreach (var child in new List <ItemNode>(folder_node))
{
switch (child.Type)
{
case Constants.ItemNodeType.ExcludedFile:
child.Delete();
ErrorHandler.ThrowOnFailure(Project.ProjectProxy.AddFileItem(folder_node.ItemId, child.Path));
break;
case Constants.ItemNodeType.ExcludedFolder:
IncludeFolderItem(child);
break;
default:
break;
}
}
return(VSConstants.S_OK);
}
/// <summary>
/// Includes the file represented by the Excluded Node into the project
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
internal int IncludeFileItem(ItemNode node)
{
node.Delete();
int result = Project.ProjectProxy.AddFileItem(node.Parent.ItemId, node.Path);
Project.RefreshSolutionExplorer(new ItemNode[] { node });
return(result);
}
/// <summary>
/// Registers the itemNode in the ItemList internal lists/dictionaries
/// </summary>
/// <param name="itemNode"></param>
internal void Register(ItemNode itemNode)
{
itemMap.Add(itemNode.ItemId, itemNode);
// from the standpoint of IVsHierarchy rename is handled by the F# project
// as remove/add, therefore item path is never changed during item lifetime
// and can considered to be immutable
itemKeyMap.Add(itemNode.Path, itemNode);
}
/// <summary>
/// Includes the file represented by the Excluded Node into the project
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
internal int IncludeFileItem(ItemNode node)
{
var path = node.Path;
var parent = ensure_included(node.Parent);
// It is necessary to re-acquire the node, because the ensure_included might'of recreated it
this[path].Delete();
return(Project.ProjectProxy.AddFileItem(parent, path));
}
public ShadowFileNode(ItemList items, ItemNode parent, uint itemId, string path)
: base(items, parent, itemId, Constants.ItemNodeType.PhysicalFile, path)
{
//buildItem.Include for linked files OnAddFile is different from the one after save,
//so it is better to keep canonical names too and associate 'Include' value with unique canonical name
buildItem = Items.Project.ProjectProxy.GetBuildItem(this);
//Admit 'Include' values for files with the same name in different folders are different-there will be no override
Items.Project.ProjectProxy.IncludeToCanonical[buildItem.Include] = path;
}
protected ShadowFolderNode(ItemList items, ItemNode parent, uint itemId, Constants.ItemNodeType type, string path)
: base(items, parent, itemId, type, path)
{
uint child = items.Project.GetNodeChild(itemId);
while (child != VSConstants.VSITEMID_NIL)
{
CreateChildNode(child);
child = items.Project.GetNodeSibling(child);
}
MapChildren();
}
private uint ensure_included(ItemNode node)
{
if (node.Type == Constants.ItemNodeType.ExcludedFolder)
{
// 1. save the path for future use after the node is deleted. The node will still be around
// even though it is deleted, so I could've accessed it as node.Path when I would have needed it
// but it feels weird - accessing object fields after it has been deleted
var path = node.Path;
// 2. make sure the parent is ok
ensure_included(node.Parent);
// 3. delete the node with all its children. It is necessary to re-acquire the node, because
// the ensure_included might'of recreated it
this[path].Delete();
// 4. re-add the node as the 'real' one
var result = Project.ProjectProxy.AddFolderItem(path);
// 5. re-add children nodes
this[path].SetShowAll(true);
return(result);
}
else
{
return(node.ItemId);
}
}
public PhysicalFolderNode(ItemList items, ItemNode parent, uint itemId, string path)
: base(items, parent, itemId, Constants.ItemNodeType.PhysicalFolder, path)
{
}
public SubprojectNode(ItemList items, ItemNode parent, uint itemId, string path)
: base(items, parent, itemId, Constants.ItemNodeType.SubProject, path)
{
}
public ShadowFileNode(ItemList items, ItemNode parent, uint itemId, string path)
: base(items, parent, itemId, Constants.ItemNodeType.PhysicalFile, path)
{
}
/// <summary>
/// Initalizes a new instance of the itemlist
/// </summary>
/// <param name="project"></param>
public ItemList(ProjectManager project)
{
this.Project = project;
root_hierarchy = (IVsHierarchy)project;
root = CreateNode(VSConstants.VSITEMID_ROOT);
}
public ShadowFileNode(ItemList items, ItemNode parent, uint itemId, string path)
: base(items, parent, itemId, Constants.ItemNodeType.PhysicalFile, path)
{
buildItem = Items.Project.ProjectProxy.GetBuildItem(this);
}
public void AddChild(ItemNode itemNode)
{
itemNode.Parent.AddChildNode(itemNode);
}
