/// <summary>
/// Constructor for the AssemblyReferenceNode
/// </summary>
public AssemblyReferenceNode(ProjectNode root, string assemblyPath)
: base(root)
{
// Validate the input parameters.
if (null == root)
{
throw new ArgumentNullException("root");
}
if (string.IsNullOrEmpty(assemblyPath))
{
throw new ArgumentNullException("assemblyPath");
}
this.InitializeFileChangeEvents();
// The assemblyPath variable can be an actual path on disk or a generic assembly name.
if (File.Exists(assemblyPath))
{
// The assemblyPath parameter is an actual file on disk; try to load it.
this.assemblyName = System.Reflection.AssemblyName.GetAssemblyName(assemblyPath);
this.assemblyPath = assemblyPath;
// We register with listeningto chnages onteh path here. The rest of teh cases will call into resolving the assembly and registration is done there.
this.fileChangeListener.ObserveItem(this.assemblyPath);
}
else
{
// The file does not exist on disk. This can be because the file / path is not
// correct or because this is not a path, but an assembly name.
// Try to resolve the reference as an assembly name.
this.CreateFromAssemblyName(new System.Reflection.AssemblyName(assemblyPath));
}
}
internal WebPiReferenceNode(ProjectNode root, ProjectElement element, string filename, string productId, string friendlyName)
: base(root, element)
{
_feed = filename;
_productId = productId;
_friendlyName = friendlyName;
}
public ProjectReferenceNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
this.referencedProjectRelativePath = this.ItemNode.GetMetadata(ProjectFileConstants.Include);
Debug.Assert(!String.IsNullOrEmpty(this.referencedProjectRelativePath), "Could not retrieve referenced project path form project file");
string guidString = this.ItemNode.GetMetadata(ProjectFileConstants.Project);
// Continue even if project setttings cannot be read.
try
{
this.referencedProjectGuid = new Guid(guidString);
this.buildDependency = new BuildDependency(this.ProjectMgr, this.referencedProjectGuid);
this.ProjectMgr.AddBuildDependency(this.buildDependency);
}
finally
{
Debug.Assert(this.referencedProjectGuid != Guid.Empty, "Could not retrive referenced project guidproject file");
this.referencedProjectName = this.ItemNode.GetMetadata(ProjectFileConstants.Name);
Debug.Assert(!String.IsNullOrEmpty(this.referencedProjectName), "Could not retrive referenced project name form project file");
}
// TODO: Maybe referenced projects should be relative to ProjectDir?
this.referencedProjectFullPath = CommonUtils.GetAbsoluteFilePath(this.ProjectMgr.ProjectHome, this.referencedProjectRelativePath);
}
/// <summary>
/// Constructor for IVSOutput2 implementation
/// </summary>
/// <param name="projectManager">Project that produce this output</param>
/// <param name="outputAssembly">MSBuild generated item corresponding to the output assembly (by default, these would be of type MainAssembly</param>
public Output(ProjectNode projectManager, ProjectItemInstance outputAssembly)
{
Utilities.ArgumentNotNull("projectManager", projectManager);
project = projectManager;
output = outputAssembly;
}
/// <summary>
/// Constructor to Wrap an existing MSBuild.ProjectItem
/// Only have internal constructors as the only one who should be creating
/// such object is the project itself (see Project.CreateFileNode()).
/// </summary>
/// <param name="project">Project that owns this item</param>
/// <param name="existingItem">an MSBuild.ProjectItem; can be null if virtualFolder is true</param>
/// <param name="virtualFolder">Is this item virtual (such as reference folder)</param>
internal MsBuildProjectElement(ProjectNode project, MSBuild.ProjectItem existingItem)
: base(project)
{
Utilities.ArgumentNotNull("existingItem", existingItem);
// Keep a reference to project and item
_item = existingItem;
}
/// <summary>
/// Constructor for the FolderNode
/// </summary>
/// <param name="root">Root node of the hierarchy</param>
/// <param name="relativePath">relative path from root i.e.: "NewFolder1\\NewFolder2\\NewFolder3</param>
/// <param name="element">Associated project element</param>
public FolderNode(ProjectNode root, string relativePath, ProjectElement element)
: base(root, element)
{
Utilities.ArgumentNotNull("relativePath", relativePath);
if (Path.IsPathRooted(relativePath))
{
relativePath = CommonUtils.GetRelativeDirectoryPath(root.ProjectHome, relativePath);
}
this.VirtualNodeName = CommonUtils.TrimEndSeparator(relativePath);
}
/// <summary>
/// Constructor to create a new MSBuild.ProjectItem and add it to the project
/// Only have internal constructors as the only one who should be creating
/// such object is the project itself (see Project.CreateFileNode()).
/// </summary>
internal MsBuildProjectElement(ProjectNode project, string itemPath, string itemType)
: base(project)
{
Utilities.ArgumentNotNullOrEmpty("itemPath", itemPath);
Utilities.ArgumentNotNullOrEmpty("itemType", itemType);
// create and add the item to the project
_item = project.BuildProject.AddItem(itemType, Microsoft.Build.Evaluation.ProjectCollection.Escape(itemPath))[0];
ItemProject.SetProjectFileDirty(true);
RefreshProperties();
}
/// <summary>
/// Constructor for IVSOutputGroup2 implementation
/// </summary>
/// <param name="outputName">Name of the output group. See VS_OUTPUTGROUP_CNAME_Build in vsshell.idl for the list of standard values</param>
/// <param name="msBuildTargetName">MSBuild target name</param>
/// <param name="projectManager">Project that produce this output</param>
/// <param name="configuration">Configuration that produce this output</param>
public OutputGroup(string outputName, string msBuildTargetName, ProjectNode projectManager, ProjectConfig configuration)
{
Utilities.ArgumentNotNull("outputName", outputName);
Utilities.ArgumentNotNull("msBuildTargetName", msBuildTargetName);
Utilities.ArgumentNotNull("projectManager", projectManager);
Utilities.ArgumentNotNull("configuration", configuration);
_name = outputName;
_targetName = msBuildTargetName;
_project = projectManager;
_projectCfg = configuration;
}
/// <summary>
/// Constructor for the ReferenceNode
/// </summary>
public AssemblyReferenceNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
this.GetPathNameFromProjectFile();
this.InitializeFileChangeEvents();
if (File.Exists(assemblyPath))
{
this.fileChangeListener.ObserveItem(this.assemblyPath);
}
string include = this.ItemNode.GetMetadata(ProjectFileConstants.Include);
this.CreateFromAssemblyName(new System.Reflection.AssemblyName(include));
}
internal ProjectElement(ProjectNode project)
{
Utilities.ArgumentNotNull("project", project);
_itemProject = project;
}
public CommonProjectNodeProperties(ProjectNode node)
: base(node)
{
}
/// <summary>
/// Constructor to Wrap an existing MSBuild.ProjectItem
/// Only have internal constructors as the only one who should be creating
/// such object is the project itself (see Project.CreateFileNode()).
/// </summary>
/// <param name="project">Project that owns this item</param>
/// <param name="existingItem">an MSBuild.ProjectItem; can be null if virtualFolder is true</param>
/// <param name="virtualFolder">Is this item virtual (such as reference folder)</param>
internal VirtualProjectElement(ProjectNode project)
: base(project)
{
_virtualProperties = new Dictionary<string, string>();
}
public JProjectReferenceNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
_fileChangeListener = new FileChangeManager(ProjectMgr.Site);
Initialize();
}
protected virtual OutputGroup CreateOutputGroup(ProjectNode project, KeyValuePair<string, string> group)
{
OutputGroup outputGroup = new OutputGroup(group.Key, group.Value, project, this);
return outputGroup;
}
public ProjectNodeProperties(ProjectNode node)
: base(node)
{
}
internal WebPiReferenceNode(ProjectNode root, string filename, string productId, string friendlyName)
: this(root, null, filename, productId, friendlyName)
{
}
public ReferenceContainerNode(ProjectNode root)
: base(root)
{
this.VirtualNodeName = ReferencesNodeVirtualName;
this.ExcludeNodeFromScc = true;
}
/// <summary>
/// constructor for the ReferenceNode
/// </summary>
protected ReferenceNode(ProjectNode root)
: base(root)
{
this.ExcludeNodeFromScc = true;
}
public CommonReferenceContainerNode(ProjectNode project)
: base(project)
{
}
public ProjectDesignerDocumentManager(ProjectNode node)
: base(node)
{
}
/// <summary>
/// Constructor for the FileNode
/// </summary>
/// <param name="root">Root of the hierarchy</param>
/// <param name="e">Associated project element</param>
public FileNode(ProjectNode root, MsBuildProjectElement element)
: base(root, element)
{
if (this.ProjectMgr.NodeHasDesigner(this.ItemNode.GetMetadata(ProjectFileConstants.Include)))
{
this.HasDesigner = true;
}
}
public BuildDependency(ProjectNode projectMgr, Guid projectReference)
{
this.referencedProjectGuid = projectReference;
this.projectMgr = projectMgr;
}
public ProjectConfig(ProjectNode project, string configuration)
{
this.project = project;
this.configName = configuration;
var flavoredCfgProvider = ProjectMgr.GetOuterInterface<IVsProjectFlavorCfgProvider>();
Utilities.ArgumentNotNull("flavoredCfgProvider", flavoredCfgProvider);
ErrorHandler.ThrowOnFailure(flavoredCfgProvider.CreateProjectFlavorCfg(this, out flavoredCfg));
Utilities.ArgumentNotNull("flavoredCfg", flavoredCfg);
// if the flavored object support XML fragment, initialize it
IPersistXMLFragment persistXML = flavoredCfg as IPersistXMLFragment;
if (null != persistXML)
{
this.project.LoadXmlFragment(persistXML, configName);
}
}
public ConfigProvider(ProjectNode manager)
{
this.project = manager;
}
/// <summary>
/// Constructor for the DependentFileNode
/// </summary>
/// <param name="root">Root of the hierarchy</param>
/// <param name="e">Associated project element</param>
public DependentFileNode(ProjectNode root, MsBuildProjectElement element)
: base(root, element)
{
this.HasParentNodeNameRelation = false;
}
/// <summary>
/// constructor for the ProjectReferenceNode
/// </summary>
public ProjectReferenceNode(ProjectNode root, string referencedProjectName, string projectPath, string projectReference)
: base(root)
{
Debug.Assert(root != null && !String.IsNullOrEmpty(referencedProjectName) && !String.IsNullOrEmpty(projectReference)
&& !String.IsNullOrEmpty(projectPath), "Can not add a reference because the input for adding one is invalid.");
if (projectReference == null)
{
throw new ArgumentNullException("projectReference");
}
this.referencedProjectName = referencedProjectName;
int indexOfSeparator = projectReference.IndexOf('|');
string fileName = String.Empty;
// Unfortunately we cannot use the path part of the projectReference string since it is not resolving correctly relative pathes.
if (indexOfSeparator != -1)
{
string projectGuid = projectReference.Substring(0, indexOfSeparator);
this.referencedProjectGuid = new Guid(projectGuid);
if (indexOfSeparator + 1 < projectReference.Length)
{
string remaining = projectReference.Substring(indexOfSeparator + 1);
indexOfSeparator = remaining.IndexOf('|');
if (indexOfSeparator == -1)
{
fileName = remaining;
}
else
{
fileName = remaining.Substring(0, indexOfSeparator);
}
}
}
Debug.Assert(!String.IsNullOrEmpty(fileName), "Can not add a project reference because the input for adding one is invalid.");
string justTheFileName = Path.GetFileName(fileName);
this.referencedProjectFullPath = CommonUtils.GetAbsoluteFilePath(projectPath, justTheFileName);
// TODO: Maybe referenced projects should be relative to ProjectDir?
this.referencedProjectRelativePath = CommonUtils.GetRelativeFilePath(this.ProjectMgr.ProjectHome, this.referencedProjectFullPath);
this.buildDependency = new BuildDependency(this.ProjectMgr, this.referencedProjectGuid);
}
public JProjectReferenceNode(ProjectNode project, string referencedProjectName, string projectPath, string projectReference)
: base(project, referencedProjectName, projectPath, projectReference)
{
_fileChangeListener = new FileChangeManager(ProjectMgr.Site);
Initialize();
}
internal TrackDocumentsHelper(ProjectNode project)
{
this.projectMgr = project;
}