public NemerleFileNode(ProjectNode root, ProjectElement element, bool isNonMemberItem)
: base(root, element)
{
IsNonMemberItem = isNonMemberItem;
_selectionChangedListener =
new SelectionElementValueChangedListener(
new ServiceProvider((IOleServiceProvider)root.GetService(typeof(IOleServiceProvider))), root);
_selectionChangedListener.Init();
//((FileNodeProperties)NodeProperties).OnCustomToolChanged += OnCustomToolChanged;
//((FileNodeProperties)NodeProperties).OnCustomToolNameSpaceChanged += OnCustomToolNameSpaceChanged;
// HasDesigner property is not virtual, so we have to set it up in the ctor.
InferHasDesignerFromSubType();
var url = this.Url;
var ext = Path.GetExtension(url);
//if (ext.Equals(".resx", StringComparison.InvariantCultureIgnoreCase))
//{
// // TODO: ”далить это дело, так как теперь оповещени¤ должны быть реализованы в Engine.
// url = Path.GetFullPath(this.Url);
// var path = Path.GetDirectoryName(url);
// var name = Path.GetFileName(url);
// _watcher = new FileSystemWatcher(path, name);
// _watcher.NotifyFilter = NotifyFilters.LastWrite;
// _watcher.Changed += watcher_Changed;
// _watcher.EnableRaisingEvents = true;
//}
}
/// <summary>
/// Initializes a new instance of the <see cref="XSharpFileNode"/> class.
/// </summary>
/// <param name="root">The project node.</param>
/// <param name="e">The project element node.</param>
internal XSharpFileNode(ProjectNode root, ProjectElement e)
: base(root, e)
{
//
this.UpdateHasDesigner();
this.UpdateItemType();
}
public BooFileNode(ProjectNode root, ProjectElement e)
: base(root, e)
{
results = new CompileResults(() => Url, GetCompilerInput, ()=>GlobalServices.LanguageService.GetLanguagePreferences().TabSize);
languageService = (BooLanguageService)GetService(typeof(BooLanguageService));
hidden = true;
}
/// <summary>
/// Creates an assembly reference node from a project element.
/// </summary>
/// <returns>An assembly reference node</returns>
protected override AssemblyReferenceNode CreateAssemblyReferenceNode(ProjectElement element)
{
SandcastleBuilderAssemblyReferenceNode node = null;
try
{
node = new SandcastleBuilderAssemblyReferenceNode(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>
/// Creates a file reference from the project configuration data.
/// </summary>
/// <param name="element">Project configuration element</param>
/// <returns>Application reference node</returns>
protected ApplicationReferenceNode CreateApplicationReferenceNode(ProjectElement element)
{
try
{
return new ApplicationReferenceNode( 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 null;
}
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);
}
}
public BaseSearchPathNode(CommonProjectNode project, string path, ProjectElement element)
: base(project, path, element)
{
_project = project;
this.VirtualNodeName = path;
this.ExcludeNodeFromScc = true;
}
public NemerleFolderNode(ProjectNode root, string directoryPath, ProjectElement element, bool isNonMemberItem)
: base(root, directoryPath, element)
{
IsNonMemberItem = isNonMemberItem;
// Folders do not participate in SCC.
ExcludeNodeFromScc = true;
}
/// <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 element)
: base(root, element)
{
if(this.ProjectMgr.NodeHasDesigner(this.ItemNode.GetMetadata(ProjectFileConstants.Include)))
{
this.HasDesigner = true;
}
}
/// <summary>
/// Create a folder node based on absolute folder path.
/// </summary>
public new virtual FolderNode CreateFolderNode(string absFolderPath)
{
//This code builds folder node in such a way that it won't be added to the
//project as build item and the project won't be go dirty.
var prjItem = GetExistingItem(absFolderPath) ?? BuildProject.AddItem("None", absFolderPath)[0];
ProjectElement prjElem = new ProjectElement(this, prjItem, false);
return new CommonFolderNode(this, absFolderPath, prjElem);
}
public JarReferenceNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
Contract.Requires<ArgumentNullException>(root != null, "root");
Contract.Requires<ArgumentNullException>(element != null, "element");
_projectRelativeFilePath = element.Item.EvaluatedInclude;
ProjectManager.ItemIdMap.UpdateCanonicalName(this);
}
/// <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, ProjectElement outputAssembly)
{
if(projectManager == null)
throw new ArgumentNullException("projectManager");
if(outputAssembly == null)
throw new ArgumentNullException("outputAssembly");
project = projectManager;
output = outputAssembly;
}
/// <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)
{
if (relativePath == null)
{
throw new ArgumentNullException("relativePath");
}
this.VirtualNodeName = relativePath.TrimEnd('\\');
}
public override FileNode CreateFileNode(ProjectElement item)
{
var node = new Mac65ProjectFileNode(this, item);
node.OleServiceProvider.AddService(typeof(EnvDTE.Project), new OleServiceProvider.ServiceCreatorCallback(CreateServices), false);
node.OleServiceProvider.AddService(typeof(ProjectItem), node.ServiceCreator, false);
node.OleServiceProvider.AddService(typeof(VSProject), new OleServiceProvider.ServiceCreatorCallback(CreateServices), false);
return node;
}
public JarReferenceNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
if (root == null)
throw new ArgumentNullException("root");
if (element == null)
throw new ArgumentNullException("element");
_projectRelativeFilePath = element.Item.EvaluatedInclude;
ProjectManager.ItemIdMap.UpdateCanonicalName(this);
}
public override FileNode CreateFileNode(ProjectElement item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
var newNode = new ProjectionFileNode(this, item);
return newNode;
}
/// <summary>
/// Constructor for the ReferenceNode
/// </summary>
public AssemblyReferenceNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
this.GetPathNameFromProjectFile();
this.InitializeFileChangeEvents();
string include = this.ItemNode.GetMetadata(ProjectFileConstants.Include);
this.CreateFromAssemblyName(new System.Reflection.AssemblyName(include));
}
public AssembleFileNode(ProjectNode root, ProjectElement e)
: base(root, e)
{
ExcludeNodeFromScc = true;
// Give it a guid if it does not already have one.
if (string.IsNullOrEmpty(ItemNode.GetMetadata(Constants.Project.Item.Assemble.Guid.Name)))
{
ItemNode.SetMetadata(Constants.Project.Item.Assemble.Guid.Name, System.Guid.NewGuid().ToString("B"));
}
}
public JavaFolderNode(ProjectNode root, string relativePath, ProjectElement element)
: base(root, relativePath, element)
{
Contract.Requires(root != null);
Contract.Requires(relativePath != null);
Contract.Requires(element != null);
if (element.IsVirtual)
{
string buildAction = element.GetMetadata(ProjectFileConstants.BuildAction);
if (buildAction == ProjectFileConstants.Folder)
this.IsNonmemberItem = false;
}
}
/// <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 override ReferenceNode CreateReferenceNode(string referenceType, ProjectElement element)
{
switch (referenceType)
{
case ProjectFileConstants.ProjectReference:
return CreateProjectReferenceNode(element);
case JavaProjectFileConstants.JarReference:
return CreateJarReferenceNode(element);
case JavaProjectFileConstants.MavenReference:
return CreateMavenReferenceNode(element);
default:
return null;
}
}
public DartFolderNode(ProjectNode root, string relativePath, ProjectElement element)
: base(root, relativePath, element)
{
if (root == null)
throw new ArgumentNullException("root");
if (relativePath == null)
throw new ArgumentNullException("relativePath");
if (element == null)
throw new ArgumentNullException("element");
if (element.IsVirtual)
{
string buildAction = element.GetMetadata(ProjectFileConstants.BuildAction);
if (buildAction == ProjectFileConstants.Folder)
this.IsNonmemberItem = false;
}
}
public SimResultsNode(BlenXProjectNode root, ProjectElement element)
: base(root, element)
{
simResultsFileName = root.ProjectFolder + Path.DirectorySeparatorChar + "Results.sim";
package = root.BlenXPackage;
bool simFilePresent = false;
if (File.Exists(simResultsFileName))
{
try
{
simResults = BetaSimResults.LoadFromFile(simResultsFileName);
if (simResults != null)
simFilePresent = true;
}
catch
{
simFilePresent = false;
}
}
if (!simFilePresent)
{
// create a new, empty one
simResults = new BetaSimResults();
BetaSimResults.SaveToFile(simResultsFileName, simResults);
}
Debug.Assert(simResults != null);
// Refresh window
var window = package.FindToolWindow(typeof(BetaSimToolWindow), 0, true) as BetaSimToolWindow;
if (window != null)
{
// Add
window.Update(simResults.ResultList);
}
}
/// <summary>
/// Links a reference node to the project and hierarchy.
/// </summary>
protected override void BindReferenceData()
{
Debug.Assert(AssemblyName != null, "The AssemblyName field has not been initialized");
// If the item has not been set correctly like in case of a new reference added it now.
// The constructor for the AssemblyReference node will create a default project item. In that case the Item is null.
// We need to specify here the correct project element.
if (ItemNode == null || ItemNode.Item == null)
ItemNode = new ProjectElement(ProjectMgr, AssemblyName.FullName, NemerleConstants.MacroReference);
// Set the basic information we know about
ItemNode.SetMetadata(ProjectFileConstants.Name, AssemblyName.Name);
ItemNode.SetMetadata(ProjectFileConstants.AssemblyName, Path.GetFileName(Url));
var fullFilePath = Path.GetFullPath(Url);
var fullProjectPath = Path.GetFullPath(ProjectMgr.ProjectFolder);
var relativePath = Utils.GetRelativePath(fullProjectPath, fullFilePath);
// Set a default HintPath for msbuild to be able to resolve the reference.
ItemNode.SetMetadata(ProjectFileConstants.HintPath, relativePath);
// Предотвращаем копирование макро-сборки в каталог собираемого проекта
ItemNode.SetMetadata(ProjectFileConstants.Private, "False");
}
/// <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);
}
/// <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("/\\", StringComparison.Ordinal))
{
relativePath += Path.DirectorySeparatorChar;
}
relativePath = new Url(relativePath).MakeRelative(new Url(node.Url));
}
elementToUse.Rename(relativePath);
}
this.AddChild(node);
return node;
}
// =========================================================================================
// Constructors
// =========================================================================================
/// <summary>
/// Initializes a new instance of the <see cref="XSharpFileNode"/> class.
/// </summary>
/// <param name="root">The project node.</param>
/// <param name="e">The project element node.</param>
internal XFileNode(XProjectNode root, ProjectElement element)
: this(root, element, false)
{
}
/// <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>
public 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("/\\", StringComparison.Ordinal))
{
relativePath += Path.DirectorySeparatorChar;
}
relativePath = new Url(relativePath).MakeRelative(new Url(node.Url));
}
elementToUse.Rename(relativePath);
}
this.AddChild(node);
return node;
}
public XFileNode(XProjectNode root, ProjectElement element, bool isNonMemberItem)
: base(root, element)
{
this.isNonMemberItem = isNonMemberItem;
}
/// <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, CultureInfo.CurrentUICulture) : e.Message;
string title = string.Empty;
OLEMSGICON icon = OLEMSGICON.OLEMSGICON_CRITICAL;
OLEMSGBUTTON buttons = OLEMSGBUTTON.OLEMSGBUTTON_OK;
OLEMSGDEFBUTTON defaultButton = OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST;
Utilities.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;
}
#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>
/// Let the wizard code execute and provide us the information we need.
/// Our SolutionFolder automation object should be called back with the
/// details at which point it will call back one of our method to add
/// a nested project.
/// If you are trying to add a new subproject this is probably the
/// method you want to call. If you are just trying to clone a template
/// project file, then AddNestedProjectFromTemplate is what you want.
/// </summary>
/// <param name="element">The project item to use as the base of the nested project.</param>
/// <param name="silent">true if the wizard should run silently, otherwise false.</param>
public void RunVSTemplateWizard(ProjectElement element, bool silent)
{
ProjectElement elementToUse = (element == null) ? this.nestedProjectElement : element;
if(elementToUse == null)
{
throw new ArgumentNullException("element");
}
this.nestedProjectElement = elementToUse;
Automation.OAProject oaProject = GetAutomationObject() as Automation.OAProject;
if(oaProject == null || oaProject.ProjectItems == null)
throw new System.InvalidOperationException(SR.GetString(SR.InvalidAutomationObject, CultureInfo.CurrentUICulture));
Debug.Assert(oaProject.Object != null, "The project automation object should have set the Object to the SolutionFolder");
Automation.OASolutionFolder<ProjectContainerNode> folder = oaProject.Object as Automation.OASolutionFolder<ProjectContainerNode>;
// Prepare the parameters to pass to RunWizardFile
string destination = elementToUse.GetFullPathForElement();
string template = this.GetProjectTemplatePath(elementToUse);
object[] wizParams = new object[7];
wizParams[0] = EnvDTE.Constants.vsWizardAddSubProject;
wizParams[1] = Path.GetFileNameWithoutExtension(destination);
wizParams[2] = oaProject.ProjectItems;
wizParams[3] = Path.GetDirectoryName(destination);
wizParams[4] = Path.GetFileNameWithoutExtension(destination);
wizParams[5] = Path.GetDirectoryName(folder.DTE.FullName); //VS install dir
wizParams[6] = silent;
IVsDetermineWizardTrust wizardTrust = this.GetService(typeof(SVsDetermineWizardTrust)) as IVsDetermineWizardTrust;
if(wizardTrust != null)
{
Guid guidProjectAdding = Guid.Empty;
// In case of a project template an empty guid should be added as the guid parameter. See env\msenv\core\newtree.h IsTrustedTemplate method definition.
ErrorHandler.ThrowOnFailure(wizardTrust.OnWizardInitiated(template, ref guidProjectAdding));
}
try
{
// Make the call to execute the wizard. This should cause AddNestedProjectFromTemplate to be
// called back with the correct set of parameters.
EnvDTE.IVsExtensibility extensibilityService = (EnvDTE.IVsExtensibility)GetService(typeof(EnvDTE.IVsExtensibility));
EnvDTE.wizardResult result = extensibilityService.RunWizardFile(template, 0, ref wizParams);
if(result == EnvDTE.wizardResult.wizardResultFailure)
ErrorHandler.ThrowOnFailure(VSConstants.E_FAIL);
}
finally
{
if(wizardTrust != null)
{
ErrorHandler.ThrowOnFailure(wizardTrust.OnWizardCompleted());
}
}
}
public PackageFileNode(ProjectNode root, ProjectElement e)
: base(root, e)
{
ExcludeNodeFromScc = true;
}
/// <summary>
/// Based on the Template and TypeGuid properties of the
/// element, generate the full template path.
///
/// TypeGuid should be the Guid of a registered project factory.
/// Template can be a full path, a project template (for projects
/// that support VsTemplates) or a relative path (for other projects).
/// </summary>
protected virtual string GetProjectTemplatePath(ProjectElement element)
{
ProjectElement elementToUse = (element == null) ? this.nestedProjectElement : element;
if(elementToUse == null)
{
throw new ArgumentNullException("element");
}
string templateFile = elementToUse.GetMetadata(ProjectFileConstants.Template);
Debug.Assert(!String.IsNullOrEmpty(templateFile), "No template file has been specified in the template attribute in the project file");
string fullPath = templateFile;
if(!Path.IsPathRooted(templateFile))
{
RegisteredProjectType registeredProjectType = this.GetRegisteredProject(elementToUse);
// This is not a full path
Debug.Assert(registeredProjectType != null && (!String.IsNullOrEmpty(registeredProjectType.DefaultProjectExtensionValue) || !String.IsNullOrEmpty(registeredProjectType.WizardTemplatesDirValue)), " Registered wizard directory value not set in the registry.");
// See if this specify a VsTemplate file
fullPath = registeredProjectType.GetVSTemplateFile(templateFile);
if(String.IsNullOrEmpty(fullPath))
{
// Default to using the WizardTemplateDir to calculate the absolute path
fullPath = Path.Combine(registeredProjectType.WizardTemplatesDirValue, templateFile);
}
}
return fullPath;
}
// =========================================================================================
// Constructors
// =========================================================================================
/// <summary>
/// Initializes a new instance of the <see cref="XFolderNode"/> class.
/// </summary>
/// <param name="root">The root <see cref="XProjectNode"/> that contains this node.</param>
/// <param name="directoryPath">Root of the hierarchy.</param>
/// <param name="element">The element that contains MSBuild properties.</param>
public XFolderNode(XProjectNode root, string directoryPath, ProjectElement element)
: this(root, directoryPath, element, false)
{
}
public NestedProjectNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
this.IsExpanded = true;
}
/// <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>
/// 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="element">Associated project element</param>
public DependentFileNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
this.HasParentNodeNameRelation = false;
}
/// <summary>
/// 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>
public virtual NestedProjectNode AddNestedProjectFromTemplate(ProjectElement element, __VSCREATEPROJFLAGS creationFlags)
{
ProjectElement elementToUse = (element == null) ? this.nestedProjectElement : element;
if(elementToUse == null)
{
throw new ArgumentNullException("element");
}
string destination = elementToUse.GetFullPathForElement();
string template = this.GetProjectTemplatePath(elementToUse);
return this.AddNestedProjectFromTemplate(template, Path.GetDirectoryName(destination), Path.GetFileName(destination), elementToUse, creationFlags);
}
/// <summary>
/// Constructor for the ReferenceNode
/// </summary>
public ApplicationReferenceNode(ProjectNode root, ProjectElement element)
: base(root, element)
{
this.path = element.GetFullPathForElement();
this.filename = Path.GetFileName(this.path);
}
/// <summary>
/// This is used when loading the project to loop through all the items
/// and for each SubProject it finds, it create the project and a node
/// in our Hierarchy to hold the project.
/// </summary>
public virtual void CreateNestedProjectNodes()
{
// 1. Create a ProjectElement with the found item and then Instantiate a new Nested project with this ProjectElement.
// 2. Link into the hierarchy.
// Read subprojects from from msbuildmodel
__VSCREATEPROJFLAGS creationFlags = __VSCREATEPROJFLAGS.CPF_NOTINSLNEXPLR | __VSCREATEPROJFLAGS.CPF_SILENT;
if(this.IsNewProject)
{
creationFlags |= __VSCREATEPROJFLAGS.CPF_CLONEFILE;
}
else
{
creationFlags |= __VSCREATEPROJFLAGS.CPF_OPENFILE;
}
foreach (MSBuild.ProjectItem item in this.BuildProject.Items)
{
if(String.Equals(item.ItemType, ProjectFileConstants.SubProject, StringComparison.OrdinalIgnoreCase))
{
this.nestedProjectElement = new ProjectElement(this, item, false);
if(!this.IsNewProject)
{
AddExistingNestedProject(null, creationFlags);
}
else
{
// If we are creating the subproject from a vstemplate/vsz file
bool isVsTemplate = Utilities.IsTemplateFile(GetProjectTemplatePath(null));
if(isVsTemplate)
{
RunVSTemplateWizard(null, true);
}
else
{
// We are cloning the specified project file
AddNestedProjectFromTemplate(null, creationFlags);
}
}
}
}
this.nestedProjectElement = null;
}
/// <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);
}
}
}
}
/// <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);
}
/// <summary>
/// Creates a project reference node given an existing project element.
/// </summary>
protected virtual ProjectReferenceNode CreateProjectReferenceNode(ProjectElement element)
{
return(new ProjectReferenceNode(this.ProjectMgr, element));
}
/// <summary>
/// Get information from the registry based for the project
/// factory corresponding to the TypeGuid of the element
/// </summary>
protected virtual 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 Exception());
Guid projectFactoryGuid = new Guid(typeGuidString);
EnvDTE.DTE dte = this.ProjectManager.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(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 a com reference node from the project element.
/// </summary>
protected virtual ComReferenceNode CreateComReferenceNode(ProjectElement reference)
{
return(new ComReferenceNode(this.ProjectMgr, reference));
}
