/// <summary>
/// Constructor for the ReferenceNode. It is called when the project is reloaded, when the project element representing the refernce exists.
/// </summary>
public ProjectReferenceNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
this.referencedProjectRelativePath = this.ItemNode.GetMetadata(ProjectFileConstants.Include);
Debug.Assert(!String.IsNullOrEmpty(this.referencedProjectRelativePath), "Could not retrive 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");
}
Uri uri = new Uri(this.ProjectMgr.BaseURI.Uri, this.referencedProjectRelativePath);
if (uri != null)
{
this.referencedProjectFullPath = Microsoft.VisualStudio.Shell.Url.Unescape(uri.LocalPath, true);
}
}
// =========================================================================================
// Constructors
// =========================================================================================
/// <summary>
/// Initializes a new instance of the <see cref="WixReferenceNode"/> class.
/// </summary>
/// <param name="root">The root <see cref="WixProjectNode"/> that contains this node.</param>
/// <param name="element">The element that contains MSBuild properties.</param>
protected WixReferenceNode(WixProjectNode root, ProjectElement element)
: base(root, element)
{
string includeValue = this.ItemNode.GetMetadata(ProjectFileConstants.Include);
bool referenceNameNotPresent = String.IsNullOrEmpty(this.ItemNode.GetMetadata(ProjectFileConstants.Name));
string newReferenceName = includeValue;
if (String.IsNullOrEmpty(this.ItemNode.GetMetadata(ProjectFileConstants.HintPath)))
{
this.ItemNode.SetMetadata(ProjectFileConstants.HintPath, includeValue);
}
if (includeValue.Contains(Path.DirectorySeparatorChar.ToString()))
{
this.ItemNode.Rename(Path.GetFileNameWithoutExtension(includeValue));
newReferenceName = Path.GetFileNameWithoutExtension(includeValue);
}
if (referenceNameNotPresent)
{
// this will fail if the node was included from a targets file
try
{
this.ItemNode.SetMetadata(ProjectFileConstants.Name, newReferenceName);
}
catch
{
}
}
}
/// <include file='doc\HierarchyItem.uex' path='docs/doc[@for="HierarchyItemNode.HierarchyItemNode"]/*' />
/// <summary>
/// constructor for the HierarchyItemNode
/// </summary>
/// <param name="root"></param>
/// <param name="type"></param>
/// <param name="strDirectoryPath"></param>
public HierarchyItemNode(Project root, HierarchyNodeType type, ProjectElement e)
{
this.projectMgr = root;
this.nodeType = type;
this.itemNode = e;
this.hierarchyId = this.projectMgr.ItemIdMap.Add(this);
}
public WixFolderNode(WixProjectNode root, string directoryPath, ProjectElement element, bool isNonMemberItem)
: base(root, directoryPath, element)
{
this.isNonMemberItem = isNonMemberItem;
// Folders do not participate in SCC.
base.ExcludeNodeFromScc = true;
}
/// <summary>
/// Constructor for the ReferenceNode
/// </summary>
public AssemblyReferenceNode(ProjectNode root, ProjectElement e)
: base(root, e)
{
this.GetPathNameFromProjectFile();
string include = this.ItemNode.GetMetadata(ProjectFileConstants.Include);
CreateFromAssemblyName(new System.Reflection.AssemblyName(include));
}
/// <summary>
/// Constructor for IVSOutput2 implementation
/// </summary>
/// <param name="projectManager">Project that produce this output</param>
/// <param name="configuration">Configuration 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, ProjectConfig configuration, ProjectElement outputAssembly)
{
if (projectManager == null)
throw new ArgumentNullException("projectManager");
if (configuration == null)
throw new ArgumentNullException("configuration");
if (outputAssembly == null)
throw new ArgumentNullException("outputAssembly");
project = projectManager;
projectCfg = configuration;
output = outputAssembly;
}
/// <summary>
/// Constructor for the ComReferenceNode.
/// </summary>
public ComReferenceNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
this.typeName = this.ItemNode.GetMetadata(ProjectFileConstants.Include);
string typeGuidAsString = this.ItemNode.GetMetadata(ProjectFileConstants.Guid);
if (typeGuidAsString != null)
{
this.typeGuid = new Guid(typeGuidAsString);
}
this.majorVersionNumber = this.ItemNode.GetMetadata(ProjectFileConstants.VersionMajor);
this.minorVersionNumber = this.ItemNode.GetMetadata(ProjectFileConstants.VersionMinor);
this.lcid = this.ItemNode.GetMetadata(ProjectFileConstants.Lcid);
this.SetProjectItemsThatRelyOnReferencesToBeResolved(false);
this.SetInstalledFilePath();
}
protected virtual ReferenceNode CreateReferenceNode(string referenceType, ProjectElement element)
{
ReferenceNode node = null;
if (referenceType == ProjectFileConstants.COMReference)
{
node = this.CreateComReferenceNode(element);
}
else if (referenceType == ProjectFileConstants.Reference)
{
node = this.CreateAssemblyReferenceNode(element);
}
else if (referenceType == ProjectFileConstants.ProjectReference)
{
node = this.CreateProjectReferenceNode(element);
}
return node;
}
/// <summary>
/// Creates a com reference node from the project element.
/// </summary>
protected virtual ComReferenceNode CreateComReferenceNode(ProjectElement reference)
{
return new ComReferenceNode(this.ProjectMgr, reference);
}
/// <summary>
/// Adds references to this container from a MSBuild project.
/// </summary>
public void LoadReferencesFromBuildProject(MSBuild.Project buildProject)
{
foreach (string referenceType in SupportedReferenceTypes)
{
MSBuild.BuildItemGroup refererncesGroup = buildProject.GetEvaluatedItemsByName(referenceType);
bool isAssemblyReference = referenceType == ProjectFileConstants.Reference;
// If the project was loaded for browsing we should still create the nodes but as not resolved.
if (this.ProjectMgr.HasPassedSecurityChecks && isAssemblyReference && this.ProjectMgr.Build(MsBuildTarget.ResolveAssemblyReferences) != MSBuildResult.Successful)
{
continue;
}
foreach (MSBuild.BuildItem item in refererncesGroup)
{
ProjectElement element = new ProjectElement(this.ProjectMgr, item, false);
ReferenceNode node = CreateReferenceNode(referenceType, element);
if (node != null)
{
// Make sure that we do not want to add the item twice to the ui hierarchy
// We are using here the UI representation of the Node namely the Caption to find that out, in order to
// avoid different representation problems.
// Example :<Reference Include="EnvDTE80, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
// <Reference Include="EnvDTE80" />
bool found = false;
for (HierarchyNode n = this.FirstChild; n != null && !found; n = n.NextSibling)
{
if (String.Compare(n.Caption, node.Caption, StringComparison.OrdinalIgnoreCase) == 0)
{
found = true;
}
}
if (!found)
{
this.AddChild(node);
}
}
}
}
}
// =========================================================================================
// Constructors
// =========================================================================================
/// <summary>
/// Initializes a new instance of the <see cref="WixExtensionReferenceNode"/> class.
/// </summary>
/// <param name="root">The root <see cref="WixProjectNode"/> that contains this node.</param>
/// <param name="element">The element that contains MSBuild properties.</param>
public WixExtensionReferenceNode(WixProjectNode root, ProjectElement element)
: base(root, element)
{
this.InitializeFileChangeEvents();
}
/// <summary>
/// constructor for the ReferenceNode
/// </summary>
protected ReferenceNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
this.ExcludeNodeFromScc = true;
}
/// <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, ProjectElement e)
: base(root, e)
{
this.HasParentNodeNameRelation = false;
}
/// <summary>
/// Creates a com reference node from the project element.
/// </summary>
protected virtual ComReferenceNode CreateComReferenceNode(ProjectElement reference)
{
return(new ComReferenceNode(this.ProjectMgr, reference));
}
/// <summary>
/// Creates a project reference node given an existing project element.
/// </summary>
protected virtual ProjectReferenceNode CreateProjectReferenceNode(ProjectElement element)
{
return(new ProjectReferenceNode(this.ProjectMgr, element));
}
public NestedProjectNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
this.IsExpanded = true;
}
/// <summary>
/// constructor for the ReferenceNode
/// </summary>
protected TEntryPointFileNode(ProjectNode root, ProjectElement e) : base(root, e)
{
this.ExcludeNodeFromScc = true;
}
public NestedProjectNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
this.IsExpanded = true;
}
/// <summary>
/// constructor for the ReferenceNode
/// </summary>
protected ReferenceNode(ProjectNode root, ProjectElement e)
: base(root,e)
{
this.ExcludeNodeFromScc = true;
}
/// <summary>
/// This can be called directly or through RunVsTemplateWizard.
/// This will clone a template project file and add it as a
/// subproject to our hierarchy.
/// If you want to create a project for which there exist a
/// vstemplate, consider using RunVsTemplateWizard instead.
/// </summary>
protected internal virtual NestedProjectNode AddNestedProjectFromTemplate(string fileName, string destination, string projectName, ProjectElement element, __VSCREATEPROJFLAGS creationFlags)
{
// If this is project creation and the template specified a subproject in its project file, this.nestedProjectElement will be used
ProjectElement elementToUse = (element == null) ? this.nestedProjectElement : element;
if (elementToUse == null)
{
// If this is null, this means MSBuild does not know anything about our subproject so add an MSBuild item for it
elementToUse = new ProjectElement(this, fileName, ProjectFileConstants.SubProject);
}
NestedProjectNode node = CreateNestedProjectNode(elementToUse);
node.Init(fileName, destination, projectName, creationFlags);
// In case that with did not have an existing element, or the nestedProjectelement was null
// and since Init computes the final path, set the MSBuild item to that path
if (this.nestedProjectElement == null)
{
string relativePath = node.Url;
if (Path.IsPathRooted(relativePath))
{
relativePath = this.ProjectFolder;
if (!relativePath.EndsWith("/\\"))
{
relativePath += Path.DirectorySeparatorChar;
}
relativePath = new Url(relativePath).MakeRelative(new Url(node.Url));
}
elementToUse.Rename(relativePath);
}
this.AddChild(node);
return(node);
}
// JRock: Added
/// <summary>
/// Creates a project-specific reference node that isn't an assembly reference, COM reference, or project reference.
/// </summary>
protected virtual ReferenceNode CreateOtherReferenceNode(ProjectElement reference)
{
return(null);
}
/// <summary>
/// Override this method if you want to provide your own type of nodes.
/// This would be the case if you derive a class from NestedProjectNode
/// </summary>
protected virtual NestedProjectNode CreateNestedProjectNode(ProjectElement element)
{
return(new NestedProjectNode(this, element));
}
// =========================================================================================
// Constructors
// =========================================================================================
/// <summary>
/// Initializes a new instance of the <see cref="WixFolderNode"/> class.
/// </summary>
/// <param name="root">The root <see cref="WixProjectNode"/> that contains this node.</param>
/// <param name="directoryPath">Root of the hierarchy.</param>
/// <param name="element">The element that contains MSBuild properties.</param>
public WixFolderNode(WixProjectNode root, string directoryPath, ProjectElement element)
: this(root, directoryPath, element, false)
{
}
/// <summary>
/// Reloads a nested project node by deleting it and readding it.
/// </summary>
/// <param name="node">The node to reload.</param>
protected virtual void ReloadNestedProjectNode(NestedProjectNode node)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
IVsSolution solution = this.GetService(typeof(IVsSolution)) as IVsSolution;
if (solution == null)
{
throw new InvalidOperationException();
}
NestedProjectNode newNode = null;
try
{
// (VS 2005 UPDATE) When deleting and re-adding the nested project,
// we do not want SCC to see this as a delete and add operation.
this.EventTriggeringFlag = ProjectNode.EventTriggering.DoNotTriggerTrackerEvents;
// notify SolutionEvents listeners that we are about to add children
IVsFireSolutionEvents fireSolutionEvents = solution as IVsFireSolutionEvents;
if (fireSolutionEvents == null)
{
throw new InvalidOperationException();
}
ErrorHandler.ThrowOnFailure(fireSolutionEvents.FireOnBeforeUnloadProject(node.NestedHierarchy));
int isDirtyAsInt = 0;
this.IsDirty(out isDirtyAsInt);
bool isDirty = (isDirtyAsInt == 0) ? false : true;
ProjectElement element = node.ItemNode;
node.CloseNestedProjectNode();
// Remove from the solution
this.RemoveChild(node);
// Now readd it
try
{
__VSCREATEPROJFLAGS flags = __VSCREATEPROJFLAGS.CPF_NOTINSLNEXPLR | __VSCREATEPROJFLAGS.CPF_SILENT | __VSCREATEPROJFLAGS.CPF_OPENFILE;
newNode = this.AddExistingNestedProject(element, flags);
newNode.AddVirtualProject();
}
catch (Exception e)
{
// We get a System.Exception if anything failed, thus we have no choice but catch it.
// Exceptions are digested by VS. Show the error if not in automation.
if (!Utilities.IsInAutomationFunction(this.Site))
{
string message = (String.IsNullOrEmpty(e.Message)) ? SR.GetString(SR.NestedProjectFailedToReload) : e.Message;
string title = string.Empty;
OLEMSGICON icon = OLEMSGICON.OLEMSGICON_CRITICAL;
OLEMSGBUTTON buttons = OLEMSGBUTTON.OLEMSGBUTTON_OK;
OLEMSGDEFBUTTON defaultButton = OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST;
VsShellUtilities.ShowMessageBox(this.Site, title, message, icon, buttons, defaultButton);
}
// Do not digest exception. let the caller handle it. If in a later stage this exception is not digested then the above messagebox is not needed.
throw e;
}
#if DEBUG
IVsHierarchy nestedHierarchy;
solution.GetProjectOfUniqueName(newNode.GetMkDocument(), out nestedHierarchy);
Debug.Assert(nestedHierarchy != null && Utilities.IsSameComObject(nestedHierarchy, newNode.NestedHierarchy), "The nested hierrachy was not reloaded correctly.");
#endif
this.SetProjectFileDirty(isDirty);
fireSolutionEvents.FireOnAfterLoadProject(newNode.NestedHierarchy);
}
finally
{
// In this scenario the nested project failed to unload or reload the nested project. We will unload the whole project, otherwise the nested project is lost.
// This is similar to the scenario when one wants to open a project and the nested project cannot be loaded because for example the project file has xml errors.
// We should note that we rely here that if the unload fails then exceptions are not digested and are shown to the user.
if (newNode == null || newNode.NestedHierarchy == null)
{
solution.CloseSolutionElement((uint)__VSSLNCLOSEOPTIONS.SLNCLOSEOPT_UnloadProject | (uint)__VSSLNSAVEOPTIONS.SLNSAVEOPT_ForceSave, this, 0);
}
else
{
this.EventTriggeringFlag = ProjectNode.EventTriggering.TriggerAll;
}
}
}
/// <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, ProjectElement e)
: base(root, e)
{
if (this.ProjectMgr.NodeHasDesigner(this.ItemNode.GetMetadata(ProjectFileConstants.Include)))
{
this.HasDesigner = true;
}
}
private static void AddNonMemberFolderItems(WixProjectNode project, IList<string> folderList)
{
if (folderList == null)
{
throw new ArgumentNullException("folderList");
}
foreach (string folderKey in folderList)
{
HierarchyNode parentNode = project;
string[] folders = folderKey.Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
WixFolderNode topFolderNode = null;
foreach (string folder in folders)
{
string childNodeId = Path.Combine(parentNode.VirtualNodeName, folder);
FileInfo folderInfo = new FileInfo(Path.Combine(project.ProjectFolder, childNodeId));
if ((folderInfo.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden)
{
break;
}
HierarchyNode childNode = parentNode.FindChild(childNodeId);
if (childNode == null)
{
if (topFolderNode == null)
{
topFolderNode = parentNode as WixFolderNode;
if (topFolderNode != null && (!topFolderNode.IsNonMemberItem) && topFolderNode.IsExpanded)
{
topFolderNode = null;
}
}
ProjectElement element = new ProjectElement(project, null, true);
childNode = project.CreateFolderNode(childNodeId, element);
parentNode.AddChild(childNode);
}
parentNode = childNode;
}
if (topFolderNode != null)
{
topFolderNode.CollapseFolder();
}
}
}
/// <summary>
/// Adds references to this container from a MSBuild project.
/// </summary>
public void LoadReferencesFromBuildProject(MSBuild.Project buildProject)
{
BuildResult buildResult = this.ProjectMgr.Build(MsBuildTarget.ResolveAssemblyReferences);
foreach (string referenceType in SupportedReferenceTypes)
{
bool isAssemblyReference = referenceType == ProjectFileConstants.Reference;
if (isAssemblyReference && !buildResult.IsSuccessful)
{
continue;
}
foreach (var item in MSBuildProject.GetItems(buildProject, referenceType))
{
ProjectElement element = new ProjectElement(this.ProjectMgr, item, false);
ReferenceNode node = CreateReferenceNode(referenceType, element);
if (node != null)
{
// Make sure that we do not want to add the item twice to the ui hierarchy
// We are using here the UI representation of the Node namely the Caption to find that out, in order to
// avoid different representation problems.
// Example :<Reference Include="EnvDTE80, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
// <Reference Include="EnvDTE80" />
bool found = false;
for (HierarchyNode n = this.FirstChild; n != null && !found; n = n.NextSibling)
{
if (String.Compare(n.Caption, node.Caption, StringComparison.OrdinalIgnoreCase) == 0)
{
found = true;
}
}
if (!found)
{
this.AddChild(node);
}
}
}
}
}
/// <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)
{
this.VirtualNodeName = relativePath.TrimEnd('\\');
}
private static void AddNonMemberFileItems(WixProjectNode project, IList<string> fileList)
{
if (fileList == null)
{
throw new ArgumentNullException("fileList");
}
foreach (string fileKey in fileList)
{
HierarchyNode parentNode = project;
string[] pathItems = fileKey.Split(new char[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar });
if (String.Equals(fileKey, project.ProjectFile, StringComparison.OrdinalIgnoreCase))
{
continue;
}
WixFolderNode topFolderNode = null;
foreach (string fileOrDir in pathItems)
{
string childNodeId = Path.Combine(parentNode.VirtualNodeName, fileOrDir);
FileInfo fileOrDirInfo = new FileInfo(Path.Combine(project.ProjectFolder, childNodeId));
if ((fileOrDirInfo.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden)
{
break;
}
HierarchyNode childNode = parentNode.FindChild(childNodeId);
if (childNode == null)
{
if (topFolderNode == null)
{
topFolderNode = parentNode as WixFolderNode;
if (topFolderNode != null && (!topFolderNode.IsNonMemberItem) && topFolderNode.IsExpanded)
{
topFolderNode = null;
}
}
ProjectElement element = new ProjectElement(project, null, true);
element.Rename(childNodeId);
element.SetMetadata(ProjectFileConstants.Name, childNodeId);
childNode = project.CreateFileNode(element);
parentNode.AddChild(childNode);
break;
}
parentNode = childNode;
}
if (topFolderNode != null)
{
topFolderNode.CollapseFolder();
}
}
}
/// <summary>
/// Get information from the registry based for the project
/// factory corresponding to the TypeGuid of the element
/// </summary>
private RegisteredProjectType GetRegisteredProject(ProjectElement element)
{
ProjectElement elementToUse = (element == null) ? this.nestedProjectElement : element;
if (elementToUse == null)
{
throw new ArgumentNullException("element");
}
// Get the project type guid from project elementToUse
string typeGuidString = elementToUse.GetMetadataAndThrow(ProjectFileConstants.TypeGuid, new ApplicationException());
Guid projectFactoryGuid = new Guid(typeGuidString);
EnvDTE.DTE dte = this.ProjectMgr.Site.GetService(typeof(EnvDTE.DTE)) as EnvDTE.DTE;
Debug.Assert(dte != null, "Could not get the automation object from the services exposed by this project");
if (dte == null)
throw new InvalidOperationException();
RegisteredProjectType registeredProjectType = RegisteredProjectType.CreateRegisteredProjectType(dte, projectFactoryGuid);
Debug.Assert(registeredProjectType != null, "Could not read the registry setting associated to this project.");
if (registeredProjectType == null)
{
throw new InvalidOperationException();
}
return registeredProjectType;
}
/// <summary>
/// Creates an assembly refernce node from a project element.
/// </summary>
protected virtual AssemblyReferenceNode CreateAssemblyReferenceNode(ProjectElement element)
{
AssemblyReferenceNode node = null;
try
{
node = new AssemblyReferenceNode(this.ProjectMgr, element);
}
catch (ArgumentNullException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
catch (FileNotFoundException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
catch (BadImageFormatException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
catch (FileLoadException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
catch (System.Security.SecurityException e)
{
Trace.WriteLine("Exception : " + e.Message);
}
return node;
}
/// <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)
{
this.VirtualNodeName = relativePath.TrimEnd('\\');
}
/// <summary>
/// Creates a project reference node given an existing project element.
/// </summary>
protected virtual ProjectReferenceNode CreateProjectReferenceNode(ProjectElement element)
{
return new ProjectReferenceNode(this.ProjectMgr, element);
}
// =========================================================================================
// Constructors
// =========================================================================================
/// <summary>
/// Initializes a new instance of the <see cref="WixFileNode"/> class.
/// </summary>
/// <param name="root">The root <see cref="WixProjectNode"/> that contains this node.</param>
/// <param name="element">The element that contains MSBuild properties.</param>
public WixFileNode(WixProjectNode root, ProjectElement element)
: this(root, element, false)
{
}
// =========================================================================================
// Constructors
// =========================================================================================
/// <summary>
/// Initializes a new instance of the <see cref="WixProjectReferenceNode"/> class.
/// </summary>
/// <param name="root">The root <see cref="WixProjectNode"/> that contains this node.</param>
/// <param name="element">The element that contains MSBuild properties.</param>
public WixProjectReferenceNode(WixProjectNode root, ProjectElement element)
: base(root, element)
{
}
public WixFileNode(WixProjectNode root, ProjectElement element, bool isNonMemberItem)
: base(root, element)
{
this.isNonMemberItem = isNonMemberItem;
}
public RubyFileNode(ProjectNode root, ProjectElement e)
: base(root, e)
{
}
/// <summary>
/// Creates a project reference node given an existing project element.
/// </summary>
/// <param name="element">MSBuild properties for the project.</param>
/// <returns>A <see cref="WixProjectReferenceNode"/> instance.</returns>
protected override ProjectReferenceNode CreateProjectReferenceNode(ProjectElement element)
{
return new WixProjectReferenceNode(this.ProjectMgr as WixProjectNode, element);
}
private ProjectElement GetProjectElementBasedOnInputFromComponentSelectorData()
{
ProjectElement element = new ProjectElement(this.ProjectMgr, this.typeName, ProjectFileConstants.COMReference);
// Set the basic information regarding this COM component
element.SetMetadata(ProjectFileConstants.Guid, this.typeGuid.ToString("B"));
element.SetMetadata(ProjectFileConstants.VersionMajor, this.majorVersionNumber);
element.SetMetadata(ProjectFileConstants.VersionMinor, this.minorVersionNumber);
element.SetMetadata(ProjectFileConstants.Lcid, this.lcid);
element.SetMetadata(ProjectFileConstants.Isolated, false.ToString());
// See if a PIA exist for this component
TypeLibConverter typelib = new TypeLibConverter();
string assemblyName;
string assemblyCodeBase;
if (typelib.GetPrimaryInteropAssembly(this.typeGuid, Int32.Parse(this.majorVersionNumber, CultureInfo.InvariantCulture), Int32.Parse(this.minorVersionNumber, CultureInfo.InvariantCulture), Int32.Parse(this.lcid, CultureInfo.InvariantCulture), out assemblyName, out assemblyCodeBase))
{
element.SetMetadata(ProjectFileConstants.WrapperTool, WrapperToolAttributeValue.Primary.ToString().ToLowerInvariant());
}
else
{
// MSBuild will have to generate an interop assembly
element.SetMetadata(ProjectFileConstants.WrapperTool, WrapperToolAttributeValue.TlbImp.ToString().ToLowerInvariant());
element.SetMetadata(ProjectFileConstants.Private, true.ToString());
}
return element;
}
/// <summary>
/// Creates a new <see cref="WixLibraryReferenceNode"/> if the element is a "WixLibraryReference",
/// a new <see cref="WixExtensionReferenceNode"/> if the element is a "WixExtensionReference",
/// or a new <see cref="WixProjectReferenceNode"/> if the element is a "ProjectReference".
/// </summary>
/// <param name="referenceType">The type of reference to be created.</param>
/// <param name="element">The MSBuild element pertaining to the reference.</param>
/// <returns>A <see cref="WixLibraryReferenceNode"/>, <see cref="WixExtensionReferenceNode"/>,
/// or a <see cref="WixProjectReferenceNode"/>.</returns>
protected override ReferenceNode CreateReferenceNode(string referenceType, ProjectElement element)
{
switch (element.ItemName)
{
case WixProjectFileConstants.WixLibrary:
return new WixLibraryReferenceNode(this.ProjectMgr as WixProjectNode, element);
case WixProjectFileConstants.WixExtension:
return new WixExtensionReferenceNode(this.ProjectMgr as WixProjectNode, element);
}
return base.CreateReferenceNode(referenceType, element);
}
internal MultiverseInterfacePythonFileNode(ProjectNode root, ProjectElement e)
: base(root, e)
{
}
/// <summary>
/// Constructor for the FolderNode
/// </summary>
/// <param name="root">Root of the hierarchy</param>
/// <param name="strDirectoryPath">Root of the hierarchy</param>
/// <param name="e">Associated project element</param>
public FolderNode(ProjectNode root, string strDirectoryPath, ProjectElement e)
: base(root, e)
{
this.VirtualNodeName = strDirectoryPath.TrimEnd('\\'); //complete path from root project i.e.: "NewFolder1\\NewFolder2\\NewFolder3
}