/// <summary>
/// Checks if an assembly is already added. The method parses all references and compares the full assemblynames, or the location of the assemblies to decide whether two assemblies are the same.
/// </summary>
/// <returns>true if the assembly has already been added.</returns>
protected internal override bool IsAlreadyAdded(out ReferenceNode existingReference)
{
ReferenceContainerNode referencesFolder = this.ProjectMgr.FindChild(ReferenceContainerNode.ReferencesNodeVirtualName) as ReferenceContainerNode;
Debug.Assert(referencesFolder != null, "Could not find the References node");
for(HierarchyNode n = referencesFolder.FirstChild; n != null; n = n.NextSibling)
{
ApplicationReferenceNode referenceNode = n as ApplicationReferenceNode;
if(null != referenceNode)
{
// If the reference url (path) is the same, they are equal.
if(String.Compare(referenceNode.Url, this.Url, StringComparison.OrdinalIgnoreCase) == 0)
{
existingReference = referenceNode;
return true;
}
}
}
existingReference = null;
return false;
}
protected virtual ReferenceNode CreateReferenceNode(VSCOMPONENTSELECTORDATA selectorData, string wrapperTool)
{
ReferenceNode node = null;
switch (selectorData.type)
{
case VSCOMPONENTTYPE.VSCOMPONENTTYPE_Project:
node = this.CreateProjectReferenceNode(selectorData);
break;
case VSCOMPONENTTYPE.VSCOMPONENTTYPE_File:
// This is the case for managed assembly
case VSCOMPONENTTYPE.VSCOMPONENTTYPE_ComPlus:
node = this.CreateFileComponent(selectorData, wrapperTool);
break;
case VSCOMPONENTTYPE.VSCOMPONENTTYPE_Com2:
node = this.CreateComReferenceNode(selectorData, wrapperTool);
break;
}
return(node);
}
/// <summary>
/// Checks if a reference is already added. The method parses all references and compares the Url.
/// </summary>
/// <param name="existingEquivalentNode">The existing reference, if one is found.</param>
/// <returns>true if the assembly has already been added.</returns>
protected internal virtual bool IsAlreadyAdded(out ReferenceNode existingEquivalentNode)
{
ReferenceContainerNode referencesFolder = this.ProjectMgr.FindChild(ReferenceContainerNode.ReferencesNodeVirtualName) as ReferenceContainerNode;
Debug.Assert(referencesFolder != null, "Could not find the References node");
for (HierarchyNode n = referencesFolder.FirstChild; n != null; n = n.NextSibling)
{
ReferenceNode referenceNode = n as ReferenceNode;
if (null != referenceNode)
{
// We check if the Url of the assemblies is the same.
if (NativeMethods.IsSamePath(referenceNode.Url, this.Url))
{
existingEquivalentNode = referenceNode;
return(true);
}
}
}
existingEquivalentNode = null;
return(false);
}
/// <summary>
/// Checks if an assembly is already added. The method parses all references and compares the full assemblynames, or the location of the assemblies to decide whether two assemblies are the same.
/// </summary>
/// <returns>true if the assembly has already been added.</returns>
protected internal override bool IsAlreadyAdded(out ReferenceNode existingReference)
{
ReferenceContainerNode referencesFolder = this.ProjectMgr.FindChild(ReferenceContainerNode.ReferencesNodeVirtualName) as ReferenceContainerNode;
Debug.Assert(referencesFolder != null, "Could not find the References node");
for (HierarchyNode n = referencesFolder.FirstChild; n != null; n = n.NextSibling)
{
ApplicationReferenceNode referenceNode = n as ApplicationReferenceNode;
if (null != referenceNode)
{
// If the reference url (path) is the same, they are equal.
if (String.Compare(referenceNode.Url, this.Url, StringComparison.OrdinalIgnoreCase) == 0)
{
existingReference = referenceNode;
return(true);
}
}
}
existingReference = null;
return(false);
}
/// <summary>
/// Checks if a reference is already added. The method parses all references and compares the the FinalItemSpec and the Guid.
/// </summary>
/// <returns>true if the assembly has already been added.</returns>
protected internal override bool IsAlreadyAdded(out ReferenceNode existingReference)
{
ReferenceContainerNode referencesFolder = this.ProjectMgr.FindChild(ReferenceContainerNode.ReferencesNodeVirtualName) as ReferenceContainerNode;
Debug.Assert(referencesFolder != null, "Could not find the References node");
for (HierarchyNode n = referencesFolder.FirstChild; n != null; n = n.NextSibling)
{
ComReferenceNode referenceNode = n as ComReferenceNode;
if (referenceNode != null)
{
// We check if the name and guids are the same
if (referenceNode.TypeGuid == this.TypeGuid && String.Compare(referenceNode.Caption, this.Caption, StringComparison.OrdinalIgnoreCase) == 0)
{
existingReference = referenceNode;
return(true);
}
}
}
existingReference = null;
return(false);
}
/// <summary>
/// Adds a reference to this container using the selector data structure to identify it.
/// </summary>
/// <param name="selectorData">data describing selected component</param>
/// <returns>Reference in case of a valid reference node has been created. Otherwise null</returns>
public ReferenceNode AddReferenceFromSelectorData(VSCOMPONENTSELECTORDATA selectorData)
{
//Make sure we can edit the project file
if (!this.ProjectMgr.QueryEditProjectFile(false))
{
throw Marshal.GetExceptionForHR(VSConstants.OLE_E_PROMPTSAVECANCELLED);
}
//Create the reference node
ReferenceNode node = null;
try
{
node = CreateReferenceNode(selectorData);
}
catch (ArgumentException)
{
// Some selector data was not valid.
}
//Add the reference node to the project if we have a valid reference node
if (node != null)
{
// This call will find if the reference is in the project and, in this case
// will not add it again, so the parent node will not be set.
node.AddReference();
if (null == node.Parent)
{
// The reference was not added, so we can not return this item because it
// is not inside the project.
return(null);
}
}
return(node);
}
/// <summary>
/// Creates an assemby or com reference node given a selector data.
/// </summary>
protected virtual ReferenceNode CreateFileComponent(VSCOMPONENTSELECTORDATA selectorData, string wrapperTool)
{
if (null == selectorData.bstrFile)
{
throw new ArgumentNullException("selectorData");
}
// We have a path to a file, it could be anything
// First see if it is a managed assembly
bool tryToCreateAnAssemblyReference = true;
if (File.Exists(selectorData.bstrFile))
{
try
{
// We should not load the assembly in the current appdomain.
// If we do not do it like that and we load the assembly in the current appdomain then the assembly cannot be unloaded again.
// The following problems might arose in that case.
// 1. Assume that a user is extending the MPF and his project is creating a managed assembly dll.
// 2. The user opens VS and creates a project and builds it.
// 3. Then the user opens VS creates another project and adds a reference to the previously built assembly. This will load the assembly in the appdomain had we been using Assembly.ReflectionOnlyLoadFrom.
// 4. Then he goes back to the first project modifies it an builds it. A build error is issued that the assembly is used.
// GetAssemblyName is assured not to load the assembly.
tryToCreateAnAssemblyReference = (AssemblyName.GetAssemblyName(selectorData.bstrFile) != null);
}
catch (BadImageFormatException)
{
// We have found the file and it is not a .NET assembly; no need to try to
// load it again.
tryToCreateAnAssemblyReference = false;
}
catch (FileLoadException)
{
// We must still try to load from here because this exception is thrown if we want
// to add the same assembly refererence from different locations.
tryToCreateAnAssemblyReference = true;
}
}
ReferenceNode node = null;
if (tryToCreateAnAssemblyReference)
{
// This might be a candidate for an assembly reference node. Try to load it.
// CreateAssemblyReferenceNode will suppress BadImageFormatException if the node cannot be created.
node = this.CreateAssemblyReferenceNode(selectorData.bstrFile);
}
// If no node has been created try to create a com reference node.
if (node == null)
{
if (!File.Exists(selectorData.bstrFile))
{
return(null);
}
node = this.CreateComReferenceNode(selectorData, wrapperTool);
}
return(node);
}
/// <summary>
/// Checks if a reference is already added. The method parses all references and compares the the FinalItemSpec and the Guid.
/// </summary>
/// <returns>true if the assembly has already been added.</returns>
protected internal override bool IsAlreadyAdded(out ReferenceNode existingReference)
{
ReferenceContainerNode referencesFolder = this.ProjectMgr.FindChild(ReferenceContainerNode.ReferencesNodeVirtualName) as ReferenceContainerNode;
Debug.Assert(referencesFolder != null, "Could not find the References node");
for(HierarchyNode n = referencesFolder.FirstChild; n != null; n = n.NextSibling)
{
ComReferenceNode referenceNode = n as ComReferenceNode;
if(referenceNode != null)
{
// We check if the name and guids are the same
if(referenceNode.TypeGuid == this.TypeGuid && String.Compare(referenceNode.Caption, this.Caption, StringComparison.OrdinalIgnoreCase) == 0)
{
existingReference = referenceNode;
return true;
}
}
}
existingReference = null;
return false;
}
/// <summary>
/// Checks if a reference is already added. The method parses all references and compares the Url.
/// </summary>
/// <param name="existingEquivalentNode">The existing reference, if one is found.</param>
/// <returns>true if the assembly has already been added.</returns>
protected internal virtual bool IsAlreadyAdded(out ReferenceNode existingEquivalentNode)
{
ReferenceContainerNode referencesFolder = this.ProjectMgr.FindChild(ReferenceContainerNode.ReferencesNodeVirtualName) as ReferenceContainerNode;
Debug.Assert(referencesFolder != null, "Could not find the References node");
for(HierarchyNode n = referencesFolder.FirstChild; n != null; n = n.NextSibling)
{
ReferenceNode referenceNode = n as ReferenceNode;
if(null != referenceNode)
{
// We check if the Url of the assemblies is the same.
if(NativeMethods.IsSamePath(referenceNode.Url, this.Url))
{
existingEquivalentNode = referenceNode;
return true;
}
}
}
existingEquivalentNode = null;
return false;
}
protected override bool CanAddReference(out CannotAddReferenceErrorMessage errorHandler, out ReferenceNode existingNode)
{
// When this method is called this refererence has not yet been added to the hierarchy, only instantiated.
if (!base.CanAddReference(out errorHandler, out existingNode))
{
return(false);
}
errorHandler = null;
if (this.IsThisProjectReferenceInCycle())
{
errorHandler = new CannotAddReferenceErrorMessage(ShowCircularReferenceErrorMessage);
return(false);
}
return(true);
}
/// <summary>
/// Checks if an assembly is already added. The method parses all references and compares the full assemblynames, or the location of the assemblies to decide whether two assemblies are the same.
/// </summary>
/// <returns>true if the assembly has already been added.</returns>
protected internal override bool IsAlreadyAdded(out ReferenceNode existingReference)
{
ReferenceContainerNode referencesFolder = this.ProjectMgr.FindChild(ReferenceContainerNode.ReferencesNodeVirtualName) as ReferenceContainerNode;
Debug.Assert(referencesFolder != null, "Could not find the References node");
bool shouldCheckPath = !string.IsNullOrEmpty(this.Url);
for(HierarchyNode n = referencesFolder.FirstChild; n != null; n = n.NextSibling)
{
AssemblyReferenceNode assemblyReferenceNode = n as AssemblyReferenceNode;
if(null != assemblyReferenceNode)
{
// We will check if the full assemblynames are the same or if the Url of the assemblies is the same.
if(String.Compare(assemblyReferenceNode.AssemblyName.FullName, this.assemblyName.FullName, StringComparison.OrdinalIgnoreCase) == 0 ||
(shouldCheckPath && NativeMethods.IsSamePath(assemblyReferenceNode.Url, this.Url)))
{
existingReference = assemblyReferenceNode;
return true;
}
}
}
existingReference = null;
return false;
}
/// <summary>
/// Validates that a reference can be added.
/// </summary>
/// <param name="errorHandler">A CannotAddReferenceErrorMessage delegate to show the error message.</param>
/// <returns>true if the reference can be added.</returns>
protected virtual bool CanAddReference(out CannotAddReferenceErrorMessage errorHandler, out ReferenceNode existingNode)
{
// When this method is called this reference has not yet been added to the hierarchy, only instantiated.
errorHandler = null;
if (this.IsAlreadyAdded(out existingNode))
{
errorHandler = null;
return(false);
}
return(true);
}
/// <summary>
/// Adds references to this container from a MSBuild project.
/// </summary>
public void LoadReferencesFromBuildProject(MSBuild.Project buildProject)
{
XSharpProjectPackage.Instance.UIThread.MustBeCalledFromUIThread();
List <ReferenceNode> duplicatedNode = new List <ReferenceNode>();
BuildResult buildResult = this.ProjectMgr.Build(MsBuildTarget.ResolveAssemblyReferences);
var children = new List <ReferenceNode>();
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;
break;
}
}
if (!found)
{
this.AddChild(node);
children.Add(node);
}
else
{
duplicatedNode.Add(node);
}
}
}
}
// Now manage duplicates
if (duplicatedNode.Count > 0)
{
// Make a backup first
string original = buildProject.FullPath;
string backupName = Path.ChangeExtension(original, ".backup");
if (Utilities.DeleteFileSafe(backupName))
{
File.Copy(original, backupName);
}
foreach (ReferenceNode node in duplicatedNode)
{
//this.RemoveChild( node );
node.Remove(false);
}
buildProject.Save(original);
}
var references = buildResult.ProjectInstance.GetItems(ProjectFileConstants.ReferencePath);
//var references = MSBuildProjectInstance.GetItems(buildResult.ProjectInstance, ProjectFileConstants.ReferencePath);
foreach (var reference in references)
{
string fullName = MSBuildItem.GetEvaluatedInclude(reference);
string name = Path.GetFileNameWithoutExtension(fullName);
foreach (var child in children)
{
if (child is XSharpAssemblyReferenceNode && child.Caption == name)
{
var xChild = child as XSharpAssemblyReferenceNode;
xChild.AssemblyPath = fullName;
xChild.SetHintPathAndPrivateValue(buildResult.ProjectInstance, reference);
}
}
}
}
public override bool IsAlreadyAdded(out ReferenceNode existingEquivalentNode)
{
string fullPath = Path.GetFullPath(InstalledFilePath).Replace('\\', '/');
ReferenceContainerNode referencesFolder = this.ProjectManager.FindChild(ReferenceContainerNode.ReferencesNodeVirtualName) as ReferenceContainerNode;
for (HierarchyNode node = referencesFolder.FirstChild; node != null; node = node.NextSibling)
{
JarReferenceNode referenceNode = node as JarReferenceNode;
if (referenceNode != null)
{
string otherFullPath = Path.GetFullPath(referenceNode.InstalledFilePath).Replace('\\', '/');
if (string.Equals(fullPath, otherFullPath, StringComparison.OrdinalIgnoreCase))
{
existingEquivalentNode = referenceNode;
return true;
}
}
}
existingEquivalentNode = null;
return false;
}
public NemerleOAReferenceItem(OAProject project, ReferenceNode node)
: base(project, node)
{
}
