/Dependencies/MPFProjectBase/ProjectNode.cs

/// Copyright (c) Microsoft Corporation.  All rights reserved.



using System;

using System.CodeDom.Compiler;

using System.Collections.Generic;

using System.Collections.Specialized;

using System.Diagnostics;

using System.Diagnostics.CodeAnalysis;

using System.Globalization;

using System.IO;

using System.Runtime.InteropServices;

using System.Windows.Forms;

using System.Xml;

using EnvDTE;

using Microsoft.VisualStudio.OLE.Interop;

using Microsoft.VisualStudio.Shell;

using Microsoft.VisualStudio.Shell.Interop;

using IOleServiceProvider = Microsoft.VisualStudio.OLE.Interop.IServiceProvider;

using IServiceProvider = System.IServiceProvider;

using MSBuild = Microsoft.Build.BuildEngine;

using OleConstants = Microsoft.VisualStudio.OLE.Interop.Constants;

using VsCommands = Microsoft.VisualStudio.VSConstants.VSStd97CmdID;

using VsCommands2K = Microsoft.VisualStudio.VSConstants.VSStd2KCmdID;



namespace Microsoft.VisualStudio.Project

{

	/// <summary>

	/// Manages the persistent state of the project (References, options, files, etc.) and deals with user interaction via a GUI in the form a hierarchy.

	/// </summary>

	[CLSCompliant(false)]

	[ComVisible(true)]

	public abstract partial class ProjectNode : HierarchyNode,

		IVsGetCfgProvider,

		IVsProject3,

		IVsAggregatableProject,

		IVsProjectFlavorCfgProvider,

		IPersistFileFormat,

		IVsProjectBuildSystem,

		IVsBuildPropertyStorage,

		IVsComponentUser,

		IVsDependencyProvider,

		IVsSccProject2,

		IBuildDependencyUpdate,

		IProjectEventsListener,

		IProjectEventsProvider,

		IReferenceContainerProvider,

		IVsProjectSpecialFiles

	{

		#region nested types



		public enum ImageName

		{

			OfflineWebApp = 0,

			WebReferencesFolder = 1,

			OpenReferenceFolder = 2,

			ReferenceFolder = 3,

			Reference = 4,

			[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "SDL")]

			SDLWebReference = 5,

			[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "DISCO")]

			DISCOWebReference = 6,

			Folder = 7,

			OpenFolder = 8,

			ExcludedFolder = 9,

			OpenExcludedFolder = 10,

			ExcludedFile = 11,

			DependentFile = 12,

			MissingFile = 13,

			WindowsForm = 14,

			WindowsUserControl = 15,

			WindowsComponent = 16,

			[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "XML")]

			XMLSchema = 17,

			[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "XML")]

			XMLFile = 18,

			WebForm = 19,

			WebService = 20,

			WebUserControl = 21,

			WebCustomUserControl = 22,

			[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "ASP")]

			ASPPage = 23,

			GlobalApplicationClass = 24,

			WebConfig = 25,

			[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "HTML")]

			HTMLPage = 26,

			StyleSheet = 27,

			ScriptFile = 28,

			TextFile = 29,

			SettingsFile = 30,

			Resources = 31,

			Bitmap = 32,

			Icon = 33,

			Image = 34,

			ImageMap = 35,

			XWorld = 36,

			Audio = 37,

			Video = 38,

			[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "CAB")]

			CAB = 39,

			[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "JAR")]

			JAR = 40,

			DataEnvironment = 41,

			PreviewFile = 42,

			DanglingReference = 43,

			[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "XSLT")]

			XSLTFile = 44,

			Cursor = 45,

			AppDesignerFolder = 46,

			Data = 47,

			Application = 48,

			DataSet = 49,

			[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "PFX")]

			PFX = 50,

			[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "SNK")]

			SNK = 51,



			ImageLast = 51

		}



		/// <summary>

		/// Flags for specifying which events to stop triggering.

		/// </summary>

		[Flags]

		internal enum EventTriggering

		{

			TriggerAll = 0,

			DoNotTriggerHierarchyEvents = 1,

			DoNotTriggerTrackerEvents = 2

		}



		#endregion



		#region constants

		/// <summary>

		/// The user file extension.

		/// </summary>

		internal const string PerUserFileExtension = ".user";

		#endregion



		#region fields

		/// <summary>

		/// List of output groups names and their associated target

		/// </summary>

		private static KeyValuePair<string, string>[] outputGroupNames =

        {                                      // Name                    Target (MSBuild)

            new KeyValuePair<string, string>("Built",                 "BuiltProjectOutputGroup"),

            new KeyValuePair<string, string>("ContentFiles",          "ContentFilesProjectOutputGroup"),

            new KeyValuePair<string, string>("LocalizedResourceDlls", "SatelliteDllsProjectOutputGroup"),

            new KeyValuePair<string, string>("Documentation",         "DocumentationProjectOutputGroup"),

            new KeyValuePair<string, string>("Symbols",               "DebugSymbolsProjectOutputGroup"),

            new KeyValuePair<string, string>("SourceFiles",           "SourceFilesProjectOutputGroup"),

            new KeyValuePair<string, string>("XmlSerializer",         "SGenFilesOutputGroup"),

        };



		/// <summary>A project will only try to build if it can obtain a lock on this object</summary>

		private volatile static object BuildLock = new object();



		/// <summary>Maps integer ids to project item instances</summary>

		private EventSinkCollection itemIdMap = new EventSinkCollection();



		/// <summary>A service provider call back object provided by the IDE hosting the project manager</summary>

		private IServiceProvider site;



		private TrackDocumentsHelper tracker;



		/// <summary>

		/// This property returns the time of the last change made to this project.

		/// It is not the time of the last change on the project file, but actually of

		/// the in memory project settings.  In other words, it is the last time that 

		/// SetProjectDirty was called.

		/// </summary>

		private DateTime lastModifiedTime;



		/// <summary>

		/// MSBuild engine we are going to use 

		/// </summary>

		private MSBuild.Engine buildEngine;



		private Microsoft.Build.Utilities.Logger buildLogger;



		private bool useProvidedLogger;



		private MSBuild.Project buildProject;



		private MSBuild.BuildPropertyGroup currentConfig;



		private ConfigProvider configProvider;



		private TaskProvider taskProvider;



		private string filename;



		private Microsoft.VisualStudio.Shell.Url baseUri;



		private bool isDirty;



		private bool isNewProject;



		private bool projectOpened;



		private bool buildIsPrepared;



		private ImageHandler imageHandler;



		private string errorString;



		private string warningString;



		private Guid projectIdGuid;



		private ProjectOptions options;





		private bool isClosed;



		private EventTriggering eventTriggeringFlag = EventTriggering.TriggerAll;



		private bool invokeMSBuildWhenResumed;



		private uint suspendMSBuildCounter;



		private bool canFileNodesHaveChilds;



		private bool isProjectEventsListener = true;



		/// <summary>

		/// The build dependency list passed to IVsDependencyProvider::EnumDependencies 

		/// </summary>

		private List<IVsBuildDependency> buildDependencyList = new List<IVsBuildDependency>();



		/// <summary>

		/// Defines if Project System supports Project Designer

		/// </summary>

		private bool supportsProjectDesigner;



		private bool showProjectInSolutionPage = true;



		private bool buildInProcess;



		/// <summary>

		/// Field for determining whether sourcecontrol should be disabled.

		/// </summary>

		private bool disableScc;



		private string sccProjectName;



		private string sccLocalPath;



		private string sccAuxPath;



		private string sccProvider;



		/// <summary>

		/// Flag for controling how many times we register with the Scc manager.

		/// </summary>

		private bool isRegisteredWithScc;



		/// <summary>

		/// Flag for controling query edit should communicate with the scc manager.

		/// </summary>

		private bool disableQueryEdit;



		/// <summary>

		/// Control if command with potential destructive behavior such as delete should

		/// be enabled for nodes of this project.

		/// </summary>

		private bool canProjectDeleteItems;



		/// <summary>

		/// Token processor used by the project sample.

		/// </summary>

		private TokenProcessor tokenProcessor;



		/// <summary>

		/// Member to store output base relative path. Used by OutputBaseRelativePath property

		/// </summary>

		private string outputBaseRelativePath = "bin";



		private IProjectEvents projectEventsProvider;



		/// <summary>

		/// Used for flavoring to hold the XML fragments

		/// </summary>

		private XmlDocument xmlFragments;



		/// <summary>

		/// Used to map types to CATID. This provide a generic way for us to do this

		/// and make it simpler for a project to provide it's CATIDs for the different type of objects

		/// for which it wants to support extensibility. This also enables us to have multiple

		/// type mapping to the same CATID if we choose to.

		/// </summary>

		private Dictionary<Type, Guid> catidMapping = new Dictionary<Type, Guid>();



		/// <summary>

		/// The globalProperty handler object in charge of maintaining global properties for this project.

		/// </summary>

		private GlobalPropertyHandler globalPropertyHandler;



		/// <summary>

		/// Flag for specifying that the project has passed security checks.

		/// </summary>

		private bool hasPassedSecurityChecks;



		/// <summary>

		/// The internal package implementation.

		/// </summary>

		private ProjectPackage package;



		// Has the object been disposed.

		private bool isDisposed;

		#endregion



		#region abstract properties

		/// <summary>

		/// This Guid must match the Guid you registered under

		/// HKLM\Software\Microsoft\VisualStudio\%version%\Projects.

		/// Among other things, the Project framework uses this 

		/// guid to find your project and item templates.

		/// </summary>

		public abstract Guid ProjectGuid

		{

			get;

		}



		/// <summary>

		/// Returns a caption for VSHPROPID_TypeName.

		/// </summary>

		/// <returns></returns>

		public abstract string ProjectType

		{

			get;

		}

		#endregion



		#region virtual properties

		/// <summary>

		/// This is the project instance guid that is peristed in the project file

		/// </summary>

		[System.ComponentModel.BrowsableAttribute(false)]

		[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "ID")]

		public virtual Guid ProjectIDGuid

		{

			get

			{

				return this.projectIdGuid;

			}

			set

			{

				if(this.projectIdGuid != value)

				{

					this.projectIdGuid = value;

					if(this.buildProject != null)

					{

						this.SetProjectProperty("ProjectGuid", this.projectIdGuid.ToString("B"));

					}

				}

			}

		}

		#endregion



		#region properties





		#region overridden properties

		public override int MenuCommandId

		{

			get

			{

				return VsMenus.IDM_VS_CTXT_PROJNODE;

			}

		}



		public override string Url

		{

			get

			{

				return this.GetMkDocument();

			}

		}



		public override string Caption

		{

			get

			{

				// Default to file name

				string caption = this.buildProject.FullFileName;

				if(String.IsNullOrEmpty(caption))

				{

					if(this.buildProject.EvaluatedProperties[ProjectFileConstants.Name] != null)

					{

						caption = this.buildProject.EvaluatedProperties[ProjectFileConstants.Name].Value;

						if(caption == null || caption.Length == 0)

						{

							caption = this.ItemNode.GetMetadata(ProjectFileConstants.Include);

						}

					}

				}

				else

				{

					caption = Path.GetFileNameWithoutExtension(caption);

				}



				return caption;

			}

		}



		public override Guid ItemTypeGuid

		{

			get

			{

				return this.ProjectGuid;

			}

		}



		public override int ImageIndex

		{

			get

			{

				return (int)ProjectNode.ImageName.Application;

			}

		}





		#endregion



		#region virtual properties



		public virtual string ErrorString

		{

			get

			{

				if(this.errorString == null)

				{

					this.errorString = SR.GetString(SR.Error, CultureInfo.CurrentUICulture);

				}



				return this.errorString;

			}

		}



		public virtual string WarningString

		{

			get

			{

				if(this.warningString == null)

				{

					this.warningString = SR.GetString(SR.Warning, CultureInfo.CurrentUICulture);

				}



				return this.warningString;

			}

		}



		/// <summary>

		/// The target name that will be used for evaluating the project file (i.e., pseudo-builds).

		/// This target is used to trigger a build with when the project system changes. 

		/// Example: The language projrcts are triggering a build with the Compile target whenever 

		/// the project system changes.

		/// </summary>

		[SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "ReEvaluate")]

		[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Re")]

		protected internal virtual string ReEvaluateProjectFileTargetName

		{

			get

			{

				return null;

			}

		}



		/// <summary>

		/// This is the object that will be returned by EnvDTE.Project.Object for this project

		/// </summary>

		protected internal virtual object ProjectObject

		{

			get

			{

				return null;

			}

		}



		/// <summary>

		/// Override this property to specify when the project file is dirty.

		/// </summary>

		protected virtual bool IsProjectFileDirty

		{

			get

			{

				string document = this.GetMkDocument();



				if(String.IsNullOrEmpty(document))

				{

					return this.isDirty;

				}



				return (this.isDirty || !File.Exists(document));

			}

		}



		/// <summary>

		/// True if the project uses the Project Designer Editor instead of the property page frame to edit project properties.

		/// </summary>

		protected virtual bool SupportsProjectDesigner

		{

			get

			{

				return this.supportsProjectDesigner;

			}

			set

			{

				this.supportsProjectDesigner = value;

			}



		}



		protected virtual Guid ProjectDesignerEditor

		{

			get

			{

				return VSConstants.GUID_ProjectDesignerEditor;

			}

		}



		/// <summary>

		/// Defines the flag that supports the VSHPROPID.ShowProjInSolutionPage

		/// </summary>

		protected virtual bool ShowProjectInSolutionPage

		{

			get

			{

				return this.showProjectInSolutionPage;

			}

			set

			{

				this.showProjectInSolutionPage = value;

			}

		}



		#endregion



		/// <summary>

		/// Gets or sets the ability of a project filenode to have child nodes (sub items).

		/// Example would be C#/VB forms having resx and designer files.

		/// </summary>

		protected internal bool CanFileNodesHaveChilds

		{

			get

			{

				return canFileNodesHaveChilds;

			}

			set

			{

				canFileNodesHaveChilds = value;

			}

		}



		/// <summary>

		/// Get and set the Token processor.

		/// </summary>

		public TokenProcessor FileTemplateProcessor

		{

			get

			{

				if(tokenProcessor == null)

					tokenProcessor = new TokenProcessor();

				return tokenProcessor;

			}

			set

			{

				tokenProcessor = value;

			}

		}



		/// <summary>

		/// Gets a service provider object provided by the IDE hosting the project

		/// </summary>

		[SuppressMessage("Microsoft.Naming", "CA1721:PropertyNamesShouldNotMatchGetMethods")]

		public IServiceProvider Site

		{

			get

			{

				return this.site;

			}

		}



		/// <summary>

		/// Gets an ImageHandler for the project node.

		/// </summary>

		public ImageHandler ImageHandler

		{

			get

			{

				if(null == imageHandler)

				{

					imageHandler = new ImageHandler(typeof(ProjectNode).Assembly.GetManifestResourceStream("Microsoft.VisualStudio.Project.Resources.imagelis.bmp"));

				}

				return imageHandler;

			}

		}



		/// <summary>

		/// This property returns the time of the last change made to this project.

		/// It is not the time of the last change on the project file, but actually of

		/// the in memory project settings.  In other words, it is the last time that 

		/// SetProjectDirty was called.

		/// </summary>

		public DateTime LastModifiedTime

		{

			get

			{

				return this.lastModifiedTime;

			}

		}



		/// <summary>

		/// Determines whether this project is a new project.

		/// </summary>

		public bool IsNewProject

		{

			get

			{

				return this.isNewProject;

			}

		}



		/// <summary>

		/// Gets the path to the folder containing the project.

		/// </summary>

		public string ProjectFolder

		{

			get

			{

				return Path.GetDirectoryName(this.filename);

			}

		}



		/// <summary>

		/// Gets or sets the project filename.

		/// </summary>

		public string ProjectFile

		{

			get

			{

				return Path.GetFileName(this.filename);

			}

			set

			{

				this.SetEditLabel(value);

			}

		}



		/// <summary>

		/// Gets the Base Uniform Resource Identifier (URI).

		/// </summary>

		[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "URI")]

		public Microsoft.VisualStudio.Shell.Url BaseURI

		{

			get

			{

				if(baseUri == null && this.buildProject != null)

				{

					string path = System.IO.Path.GetDirectoryName(this.buildProject.FullFileName);

					// Uri/Url behave differently when you have trailing slash and when you dont

					if(!path.EndsWith("\\", StringComparison.Ordinal) && !path.EndsWith("/", StringComparison.Ordinal))

						path += "\\";

					baseUri = new Url(path);

				}



				Debug.Assert(baseUri != null, "Base URL should not be null. Did you call BaseURI before loading the project?");

				return baseUri;

			}

		}



		/// <summary>

		/// Gets whether or not the project is closed.

		/// </summary>

		public bool IsClosed

		{

			get

			{

				return this.isClosed;

			}

		}



		/// <summary>

		/// Gets whether or not the project is being built.

		/// </summary>

		public bool BuildInProgress

		{

			get

			{

				return buildInProcess;

			}

		}



		/// <summary>

		/// Gets or set the relative path to the folder containing the project ouput. 

		/// </summary>

		public virtual string OutputBaseRelativePath

		{

			get

			{

				return this.outputBaseRelativePath;

			}

			set

			{

				if(Path.IsPathRooted(value))

				{

					throw new ArgumentException("Path must not be rooted.");

				}



				this.outputBaseRelativePath = value;

			}

		}



		/// <summary>

		/// Gets or sets the flag whether query edit should communicate with the scc manager.

		/// </summary>

		protected bool DisableQueryEdit

		{

			get

			{

				return this.disableQueryEdit;

			}

			set

			{

				this.disableQueryEdit = value;

			}

		}



		/// <summary>

		/// Gets a collection of integer ids that maps to project item instances

		/// </summary>

		internal EventSinkCollection ItemIdMap

		{

			get

			{

				return this.itemIdMap;

			}

		}



		/// <summary>

		/// Get the helper object that track document changes.

		/// </summary>

		internal TrackDocumentsHelper Tracker

		{

			get

			{

				return this.tracker;

			}

		}



		/// <summary>

		/// Gets or sets the build logger.

		/// </summary>

		protected Microsoft.Build.Utilities.Logger BuildLogger

		{

			get

			{

				return this.buildLogger;

			}

			set

			{

				this.buildLogger = value;

				this.useProvidedLogger = true;

			}

		}



		/// <summary>

		/// Gets the taskprovider.

		/// </summary>

		protected TaskProvider TaskProvider

		{

			get

			{

				return this.taskProvider;

			}

		}



		/// <summary>

		/// Gets the project file name.

		/// </summary>

		protected string FileName

		{

			get

			{

				return this.filename;

			}

		}





		/// <summary>

		/// Gets the configuration provider.

		/// </summary>

		protected ConfigProvider ConfigProvider

		{

			get

			{

				if(this.configProvider == null)

				{

					this.configProvider = CreateConfigProvider();

				}



				return this.configProvider;

			}

		}



		/// <summary>

		/// Gets or sets whether or not source code control is disabled for this project.

		/// </summary>

		[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Scc")]

		protected bool IsSccDisabled

		{

			get

			{

				return this.disableScc;

			}

			set

			{

				this.disableScc = value;

			}

		}



		/// <summary>

		/// Gets or set whether items can be deleted for this project.

		/// Enabling this feature can have the potential destructive behavior such as deleting files from disk.

		/// </summary>

		protected internal bool CanProjectDeleteItems

		{

			get

			{

				return canProjectDeleteItems;

			}

			set

			{

				canProjectDeleteItems = value;

			}

		}



		/// <summary>

		/// Determines whether the project was fully opened. This is set when the OnAfterOpenProject has triggered.

		/// </summary>

		protected internal bool HasProjectOpened

		{

			get

			{

				return this.projectOpened;

			}

		}



		/// <summary>

		/// Gets or sets event triggering flags.

		/// </summary>

		internal EventTriggering EventTriggeringFlag

		{

			get

			{

				return this.eventTriggeringFlag;

			}

			set

			{

				this.eventTriggeringFlag = value;

			}

		}



		/// <summary>

		/// Defines the build project that has loaded the project file.

		/// </summary>

		protected internal Microsoft.Build.BuildEngine.Project BuildProject

		{

			get

			{

				return this.buildProject;

			}

			set

			{

				this.buildProject = value;

			}

		}



		/// <summary>

		/// Defines the build engine that is used to build the project file.

		/// </summary>

		internal Microsoft.Build.BuildEngine.Engine BuildEngine

		{

			get

			{

				return this.buildEngine;

			}

			set

			{

				this.buildEngine = value;

			}

		}



		/// <summary>

		/// The object in charge of maintaining global properties for this project.

		/// </summary>

		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]

		internal GlobalPropertyHandler GlobalPropetyHandler

		{

			get

			{

				return this.globalPropertyHandler;

			}



			set

			{

				this.globalPropertyHandler = value;

			}

		}



		/// <summary>

		/// Has the project passed security checks?

		/// </summary>

		internal bool HasPassedSecurityChecks

		{

			get

			{

				return this.hasPassedSecurityChecks;

			}

			set

			{

				this.hasPassedSecurityChecks = value;

			}

		}



		/// <summary>

		/// The internal package implementation.

		/// </summary>

		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]

		internal ProjectPackage Package

		{

			get

			{

				return this.package;

			}

			set

			{

				this.package = value;

			}

		}

		#endregion



		#region ctor



		protected ProjectNode()

		{

			this.Initialize();

		}

		#endregion



		#region overridden methods

		protected override NodeProperties CreatePropertiesObject()

		{

			return new ProjectNodeProperties(this);

		}



		/// <summary>

		/// Sets the properties for the project node.

		/// </summary>

		/// <param name="propid">Identifier of the hierarchy property. For a list of propid values, <see cref="__VSHPROPID"/> </param>

		/// <param name="value">The value to set. </param>

		/// <returns>A success or failure value.</returns>

		public override int SetProperty(int propid, object value)

		{

			__VSHPROPID id = (__VSHPROPID)propid;



			switch(id)

			{

				case __VSHPROPID.VSHPROPID_ShowProjInSolutionPage:

					this.ShowProjectInSolutionPage = (bool)value;

					return VSConstants.S_OK;

			}



			return base.SetProperty(propid, value);

		}



		/// <summary>

		/// Renames the project node.

		/// </summary>

		/// <param name="label">The new name</param>

		/// <returns>A success or failure value.</returns>

		public override int SetEditLabel(string label)

		{

			// Validate the filename. 

			if(String.IsNullOrEmpty(label))

			{

				throw new InvalidOperationException(SR.GetString(SR.ErrorInvalidFileName, CultureInfo.CurrentUICulture));

			}

			else if(this.ProjectFolder.Length + label.Length + 1 > NativeMethods.MAX_PATH)

			{

				throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.PathTooLong, CultureInfo.CurrentUICulture), label));

			}

			else if(Utilities.IsFileNameInvalid(label))

			{

				throw new InvalidOperationException(SR.GetString(SR.ErrorInvalidFileName, CultureInfo.CurrentUICulture));

			}



			string fileName = Path.GetFileNameWithoutExtension(label);



			// if there is no filename or it starts with a leading dot issue an error message and quit.

			if(String.IsNullOrEmpty(fileName) || fileName[0] == '.')

			{

				throw new InvalidOperationException(SR.GetString(SR.FileNameCannotContainALeadingPeriod, CultureInfo.CurrentUICulture));

			}



			// Nothing to do if the name is the same

			string oldFileName = Path.GetFileNameWithoutExtension(this.Url);

			if(String.Compare(oldFileName, label, StringComparison.Ordinal) == 0)

			{

				return VSConstants.S_FALSE;

			}



			// Now check whether the original file is still there. It could have been renamed.

			if(!File.Exists(this.Url))

			{

				throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.FileOrFolderCannotBeFound, CultureInfo.CurrentUICulture), this.ProjectFile));

			}



			// Get the full file name and then rename the project file.

			string newFile = Path.Combine(this.ProjectFolder, label);

			string extension = Path.GetExtension(this.Url);



			// Make sure it has the correct extension

			if(String.Compare(Path.GetExtension(newFile), extension, StringComparison.OrdinalIgnoreCase) != 0)

			{

				newFile += extension;

			}



			this.RenameProjectFile(newFile);

			return VSConstants.S_OK;

		}



		/// <summary>

		/// Gets the automation object for the project node.

		/// </summary>

		/// <returns>An instance of an EnvDTE.Project implementation object representing the automation object for the project.</returns>

		public override object GetAutomationObject()

		{

			return new Automation.OAProject(this);

		}



		/// <summary>

		/// Closes the project node.

		/// </summary>

		/// <returns>A success or failure value.</returns>

		public override int Close()

		{

			int hr = VSConstants.S_OK;

			try

			{

				// Walk the tree and close all nodes.

				// This has to be done before the project closes, since we want still state available for the ProjectMgr on the nodes 

				// when nodes are closing.

				try

				{

					CloseAllNodes(this);

				}

				finally

				{

					this.Dispose(true);

				}

			}

			catch(COMException e)

			{

				hr = e.ErrorCode;

			}

			finally

			{

				ErrorHandler.ThrowOnFailure(base.Close());

			}



			this.isClosed = true;



			return hr;

		}



		/// <summary>

		/// Sets the service provider from which to access the services. 

		/// </summary>

		/// <param name="site">An instance to an Microsoft.VisualStudio.OLE.Interop object</param>

		/// <returns>A success or failure value.</returns>

		public override int SetSite(Microsoft.VisualStudio.OLE.Interop.IServiceProvider site)

		{

			CCITracing.TraceCall();

			this.site = new ServiceProvider(site);



			if(taskProvider != null)

			{

				taskProvider.Dispose();

			}

			taskProvider = new TaskProvider(this.site);



			return VSConstants.S_OK;

		}



		/// <summary>

		/// Gets the properties of the project node. 

		/// </summary>

		/// <param name="propId">The __VSHPROPID of the property.</param>

		/// <returns>A property dependent value. See: <see cref="__VSHPROPID"/> for details.</returns>

		public override object GetProperty(int propId)

		{

			switch((__VSHPROPID)propId)

			{

				case __VSHPROPID.VSHPROPID_ConfigurationProvider:

					return this.ConfigProvider;



				case __VSHPROPID.VSHPROPID_ProjectName:

					return this.Caption;



				case __VSHPROPID.VSHPROPID_ProjectDir:

					return this.ProjectFolder;



				case __VSHPROPID.VSHPROPID_TypeName:

					return this.ProjectType;



				case __VSHPROPID.VSHPROPID_ShowProjInSolutionPage:

					return this.ShowProjectInSolutionPage;



				case __VSHPROPID.VSHPROPID_ExpandByDefault:

					return true;



				// Use the same icon as if the folder was closed

				case __VSHPROPID.VSHPROPID_OpenFolderIconIndex:

					return GetProperty((int)__VSHPROPID.VSHPROPID_IconIndex);

			}



			switch((__VSHPROPID2)propId)

			{

				case __VSHPROPID2.VSHPROPID_SupportsProjectDesigner:

					return this.SupportsProjectDesigner;



				case __VSHPROPID2.VSHPROPID_PropertyPagesCLSIDList:

					return Utilities.CreateSemicolonDelimitedListOfStringFromGuids(this.GetConfigurationIndependentPropertyPages());



				case __VSHPROPID2.VSHPROPID_CfgPropertyPagesCLSIDList:

					return Utilities.CreateSemicolonDelimitedListOfStringFromGuids(this.GetConfigurationDependentPropertyPages());



				case __VSHPROPID2.VSHPROPID_PriorityPropertyPagesCLSIDList:

					return Utilities.CreateSemicolonDelimitedListOfStringFromGuids(this.GetPriorityProjectDesignerPages());



				case __VSHPROPID2.VSHPROPID_Container:

					return true;

				default:

					break;

			}



			return base.GetProperty(propId);

		}



		/// <summary>

		/// Gets the GUID value of the node. 

		/// </summary>

		/// <param name="propid">A __VSHPROPID or __VSHPROPID2 value of the guid property</param>

		/// <param name="guid">The guid to return for the property.</param>

		/// <returns>A success or failure value.</returns>

		public override int GetGuidProperty(int propid, out Guid guid)

		{

			guid = Guid.Empty;

			if((__VSHPROPID)propid == __VSHPROPID.VSHPROPID_ProjectIDGuid)

			{

				guid = this.ProjectIDGuid;

			}

			else if(propid == (int)__VSHPROPID.VSHPROPID_CmdUIGuid)

			{

				guid = this.ProjectGuid;

			}

			else if((__VSHPROPID2)propid == __VSHPROPID2.VSHPROPID_ProjectDesignerEditor && this.SupportsProjectDesigner)

			{

				guid = this.ProjectDesignerEditor;

			}

			else

			{

				base.GetGuidProperty(propid, out guid);

			}



			if(guid.CompareTo(Guid.Empty) == 0)

			{

				return VSConstants.DISP_E_MEMBERNOTFOUND;

			}



			return VSConstants.S_OK;

		}



		/// <summary>

		/// Sets Guid properties for the project node.

		/// </summary>

		/// <param name="propid">A __VSHPROPID or __VSHPROPID2 value of the guid property</param>

		/// <param name="guid">The guid value to set.</param>

		/// <returns>A success or failure value.</returns>

		public override int SetGuidProperty(int propid, ref Guid guid)

		{

			switch((__VSHPROPID)propid)

			{

				case __VSHPROPID.VSHPROPID_ProjectIDGuid:

					this.ProjectIDGuid = guid;

					return VSConstants.S_OK;

			}

			CCITracing.TraceCall(String.Format(CultureInfo.CurrentCulture, "Property {0} not found", propid));

			return VSConstants.DISP_E_MEMBERNOTFOUND;

		}



		/// <summary>

		/// Removes items from the hierarchy. 

		/// </summary>

		/// <devdoc>Project overwrites this.</devdoc>

		public override void Remove(bool removeFromStorage)

		{

			// the project will not be deleted from disk, just removed      

			if(removeFromStorage)

			{

				return;

			}



			// Remove the entire project from the solution

			IVsSolution solution = this.Site.GetService(typeof(SVsSolution)) as IVsSolution;

			uint iOption = 1; // SLNSAVEOPT_PromptSave

			ErrorHandler.ThrowOnFailure(solution.CloseSolutionElement(iOption, this, 0));

		}



		/// <summary>

		/// Gets the moniker for the project node. That is the full path of the project file.

		/// </summary>

		/// <returns>The moniker for the project file.</returns>

		public override string GetMkDocument()

		{

			Debug.Assert(!String.IsNullOrEmpty(this.filename));

			Debug.Assert(this.BaseURI != null && !String.IsNullOrEmpty(this.BaseURI.AbsoluteUrl));

			return Path.Combine(this.BaseURI.AbsoluteUrl, this.filename);

		}



		/// <summary>

		/// Disposes the project node object.

		/// </summary>

		/// <param name="disposing">Flag determining ehether it was deterministic or non deterministic clean up.</param>

		protected override void Dispose(bool disposing)

		{

			if(this.isDisposed)

			{

				return;

			}



			try

			{

				try

				{

					this.UnRegisterProject();

				}

				finally

				{

					try

					{

						this.RegisterClipboardNotifications(false);

					}

					finally

					{

						try

						{

							if(this.globalPropertyHandler != null)

							{

								this.globalPropertyHandler.ActiveConfigurationChanged -= new EventHandler<ActiveConfigurationChangedEventArgs>(this.OnHandleConfigurationRelatedGlobalProperties);



								this.globalPropertyHandler.Dispose();

							}



							if(this.projectEventsProvider != null)

							{

								this.projectEventsProvider.AfterProjectFileOpened -= this.OnAfterProjectOpen;

							}

							if(this.taskProvider != null)

							{

								taskProvider.Tasks.Clear();

								this.taskProvider.Dispose();

								this.taskProvider = null;

							}

							if(buildLogger != null)

							{

								buildLogger = null;

							}

							this.site = null;

						}

						finally

						{

							if(this.buildEngine != null)

							{

								this.buildEngine.UnregisterAllLoggers();

								this.buildEngine = null;

							}

						}

					}

				}



				if(this.buildProject != null)

				{

					this.buildProject.ParentEngine.UnloadProject(this.buildProject);

					this.buildProject = null;

				}



				if(null != imageHandler)

				{

					imageHandler.Close();

					imageHandler = null;

				}

			}

			finally

			{

				base.Dispose(disposing);

				this.isDisposed = true;

			}

		}



		/// <summary>

		/// Handles command status on the project node. If a command cannot be handled then the base should be called.

		/// </summary>

		/// <param name="cmdGroup">A unique identifier of the command group. The pguidCmdGroup parameter can be NULL to specify the standard group.</param>

		/// <param name="cmd">The command to query status for.</param>

		/// <param name="pCmdText">Pointer to an OLECMDTEXT structure in which to return the name and/or status information of a single command. Can be NULL to indicate that the caller does not require this information.</param>

		/// <param name="result">An out parameter specifying the QueryStatusResult of the command.</param>

		/// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns>

		protected override int QueryStatusOnNode(Guid cmdGroup, uint cmd, IntPtr pCmdText, ref QueryStatusResult result)

		{

			if(cmdGroup == VsMenus.guidStandardCommandSet97)

			{

				switch((VsCommands)cmd)

				{

					case VsCommands.Copy:

					case VsCommands.Paste:

					case VsCommands.Cut:

					case VsCommands.Rename:

					case VsCommands.Exit:

					case VsCommands.ProjectSettings:

					case VsCommands.BuildSln:

					case VsCommands.UnloadProject:

						result |= QueryStatusResult.SUPPORTED | QueryStatusResult.ENABLED;

						return VSConstants.S_OK;



					case VsCommands.ViewForm:

						if(this.HasDesigner)

						{

							result |= QueryStatusResult.SUPPORTED | QueryStatusResult.ENABLED;

							return VSConstants.S_OK;

						}

						break;



					case VsCommands.CancelBuild:

						result |= QueryStatusResult.SUPPORTED;

						if(this.buildInProcess)

							result |= QueryStatusResult.ENABLED;

						else

							result |= QueryStatusResult.INVISIBLE;

						return VSConstants.S_OK;



					case VsCommands.NewFolder:

					case VsCommands.AddNewItem:

					case VsCommands.AddExistingItem:

						result |= QueryStatusResult.SUPPORTED | QueryStatusResult.ENABLED;

						return VSConstants.S_OK;



					case VsCommands.SetStartupProject:

						result |= QueryStatusResult.SUPPORTED | QueryStatusResult.ENABLED;

						return VSConstants.S_OK;

				}

			}

			else if(cmdGroup == VsMenus.guidStandardCommandSet2K)

			{



				switch((VsCommands2K)cmd)

				{

					case VsCommands2K.ADDREFERENCE:

						result |= QueryStatusResult.SUPPORTED | QueryStatusResult.ENABLED;

						return VSConstants.S_OK;



					case VsCommands2K.EXCLUDEFROMPROJECT:

						result |= QueryStatusResult.SUPPORTED | QueryStatusResult.INVISIBLE;

						return VSConstants.S_OK;

				}

			}

			else

			{

				return (int)OleConstants.OLECMDERR_E_UNKNOWNGROUP;

			}



			return base.QueryStatusOnNode(cmdGroup, cmd, pCmdText, ref result);

		}



		/// <summary>

		/// Handles command execution.

		/// </summary>

		/// <param name="cmdGroup">Unique identifier of the command group</param>

		/// <param name="cmd">The command to be executed.</param>

		/// <param name="nCmdexecopt">Values describe how the object should execute the command.</param>

		/// <param name="pvaIn">Pointer to a VARIANTARG structure containing input arguments. Can be NULL</param>

		/// <param name="pvaOut">VARIANTARG structure to receive command output. Can be NULL.</param>

		/// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns>

		protected override int ExecCommandOnNode(Guid cmdGroup, uint cmd, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)

		{

			if(cmdGroup == VsMenus.guidStandardCommandSet97)

			{

				switch((VsCommands)cmd)

				{



					case VsCommands.UnloadProject:

						return this.UnloadProject();

					case VsCommands.CleanSel:

					case VsCommands.CleanCtx:

						return this.CleanProject();

				}

			}

			else if(cmdGroup == VsMenus.guidStandardCommandSet2K)

			{

				switch((VsCommands2K)cmd)

				{

					case VsCommands2K.ADDREFERENCE:

						return this.AddProjectReference();



					case VsCommands2K.ADDWEBREFERENCE:

					case VsCommands2K.ADDWEBREFERENCECTX:

						return this.AddWebReference();

				}

			}



			return base.ExecCommandOnNode(cmdGroup, cmd, nCmdexecopt, pvaIn, pvaOut);

		}



		/// <summary>

		/// Get the boolean value for the deletion of a project item

		/// </summary>

		/// <param name="deleteOperation">A flag that specifies the type of delete operation (delete from storage or remove from project)</param>

		/// <returns>true if item can be deleted from project</returns>

		protected override bool CanDeleteItem(__VSDELETEITEMOPERATION deleteOperation)

		{

			if(deleteOperation == __VSDELETEITEMOPERATION.DELITEMOP_RemoveFromProject)

			{

				return true;

			}

			return false;

		}



		/// <summary>

		/// Returns a specific Document manager to handle opening and closing of the Project(Application) Designer if projectdesigner is supported.

		/// </summary>

		/// <returns>Document manager object</returns>

		protected internal override DocumentManager GetDocumentManager()

		{

			if(this.SupportsProjectDesigner)

			{

				return new ProjectDesignerDocumentManager(this);

			}

			return null;

		}



		#endregion



		#region virtual methods



		/// <summary>

		/// Executes a wizard.

		/// </summary>

		/// <param name="parentNode">The node to which the wizard should add item(s).</param>

		/// <param name="itemName">The name of the file that the user typed in.</param>

		/// <param name="wizardToRun">The name of the wizard to run.</param>

		/// <param name="dlgOwner">The owner of the dialog box.</param>

		/// <returns>A VSADDRESULT enum value describing success or failure.</returns>

		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily"), SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "dlg")]

		public virtual VSADDRESULT RunWizard(HierarchyNode parentNode, string itemName, string wizardToRun, IntPtr dlgOwner)

		{

			Debug.Assert(!String.IsNullOrEmpty(itemName), "The Add item dialog was passing in a null or empty item to be added to the hierrachy.");

			Debug.Assert(!String.IsNullOrEmpty(this.ProjectFolder), "The Project Folder is not specified for this project.");



			// We just validate for length, since we assume other validation has been performed by the dlgOwner.

			if(this.ProjectFolder.Length + itemName.Length + 1 > NativeMethods.MAX_PATH)

			{

				string errorMessage = String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.PathTooLong, CultureInfo.CurrentUICulture), itemName);

				if(!Utilities.IsInAutomationFunction(this.Site))

				{

					string title = null;

					OLEMSGICON icon = OLEMSGICON.OLEMSGICON_CRITICAL;

					OLEMSGBUTTON buttons = OLEMSGBUTTON.OLEMSGBUTTON_OK;

					OLEMSGDEFBUTTON defaultButton = OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST;

					VsShellUtilities.ShowMessageBox(this.Site, title, errorMessage, icon, buttons, defaultButton);

					return VSADDRESULT.ADDRESULT_Failure;

				}

				else

				{

					throw new InvalidOperationException(errorMessage);

				}

			}





			// Build up the ContextParams safearray

			//  [0] = Wizard type guid  (bstr)

			//  [1] = Project name  (bstr)

			//  [2] = ProjectItems collection (bstr)

			//  [3] = Local Directory (bstr)

			//  [4] = Filename the user typed (bstr)

			//  [5] = Product install Directory (bstr)

			//  [6] = Run silent (bool)



			object[] contextParams = new object[7];

			contextParams[0] = EnvDTE.Constants.vsWizardAddItem;

			contextParams[1] = this.Caption;

			object automationObject = parentNode.GetAutomationObject();

			if(automationObject is EnvDTE.Project)

			{

				EnvDTE.Project project = (EnvDTE.Project)automationObject;

				contextParams[2] = project.ProjectItems;

			}

			else

			{

				// This would normally be a folder unless it is an item with subitems

				ProjectItem item = (ProjectItem)automationObject;

				contextParams[2] = item.ProjectItems;

			}



			contextParams[3] = this.ProjectFolder;



			contextParams[4] = itemName;



			object objInstallationDir = null;

			IVsShell shell = (IVsShell)this.GetService(typeof(IVsShell));

			ErrorHandler.ThrowOnFailure(shell.GetProperty((int)__VSSPROPID.VSSPROPID_InstallDirectory, out objInstallationDir));

			string installDir = (string)objInstallationDir;



			// append a '\' to the install dir to mimic what the shell does (though it doesn't add one to destination dir)

			if(!installDir.EndsWith("\\", StringComparison.Ordinal))

			{

				installDir += "\\";

			}



			contextParams[5] = installDir;



			contextParams[6] = true;



			IVsExtensibility3 ivsExtensibility = this.GetService(typeof(IVsExtensibility)) as IVsExtensibility3;

			Debug.Assert(ivsExtensibility != null, "Failed to get IVsExtensibility3 service");

			if(ivsExtensibility == null)

			{

				return VSADDRESULT.ADDRESULT_Failure;

			}



			// Determine if we have the trust to run this wizard.

			IVsDetermineWizardTrust wizardTrust = this.GetService(typeof(SVsDetermineWizardTrust)) as IVsDetermineWizardTrust;

			if(wizardTrust != null)

			{

				Guid guidProjectAdding = Guid.Empty;

				ErrorHandler.ThrowOnFailure(wizardTrust.OnWizardInitiated(wizardToRun, ref guidProjectAdding));

			}



			int wizResultAsInt;

			try

			{

				Array contextParamsAsArray = contextParams;



				int result = ivsExtensibility.RunWizardFile(wizardToRun, (int)dlgOwner, ref contextParamsAsArray, out wizResultAsInt);



				if(!ErrorHandler.Succeeded(result) && result != VSConstants.OLE_E_PROMPTSAVECANCELLED)

				{

					ErrorHandler.ThrowOnFailure(result);

				}

			}

			finally

			{

				if(wizardTrust != null)

				{

					ErrorHandler.ThrowOnFailure(wizardTrust.OnWizardCompleted());

				}

			}



			EnvDTE.wizardResult wizardResult = (EnvDTE.wizardResult)wizResultAsInt;



			switch(wizardResult)

			{

				default:

					return VSADDRESULT.ADDRESULT_Cancel;

				case wizardResult.wizardResultSuccess:

					return VSADDRESULT.ADDRESULT_Success;

				case wizardResult.wizardResultFailure:

					return VSADDRESULT.ADDRESULT_Failure;

			}

		}



		/// <summary>

		/// Override this method if you want to modify the behavior of the Add Reference dialog

		/// By example you could change which pages are visible and which is visible by default.

		/// </summary>

		/// <returns></returns>

		public virtual int AddProjectReference()

		{

			CCITracing.TraceCall();



			IVsComponentSelectorDlg componentDialog;

			Guid guidEmpty = Guid.Empty;

			VSCOMPONENTSELECTORTABINIT[] tabInit = new VSCOMPONENTSELECTORTABINIT[2];

			string strBrowseLocations = Path.GetDirectoryName(this.BaseURI.Uri.LocalPath);



			tabInit[0].dwSize = (uint)Marshal.SizeOf(typeof(VSCOMPONENTSELECTORTABINIT));

			// Tell the Add Reference dialog to call hierarchies GetProperty with the following

			// propID to enablefiltering out ourself from the Project to Project reference

			tabInit[0].varTabInitInfo = (int)__VSHPROPID.VSHPROPID_ShowProjInSolutionPage;

			tabInit[0].guidTab = VSConstants.GUID_SolutionPage;



			// Add the Browse for file page            

			tabInit[1].dwSize = (uint)Marshal.SizeOf(typeof(VSCOMPONENTSELECTORTABINIT));

			tabInit[1].guidTab = VSConstants.GUID_BrowseFilePage;

			tabInit[1].varTabInitInfo = 0;





			componentDialog = this.GetService(typeof(IVsComponentSelectorDlg)) as IVsComponentSelectorDlg;

			try

			{

				// call the container to open the add reference dialog.

				if(componentDialog != null)

				{

					// Let the project know not to show itself in the Add Project Reference Dialog page

					this.ShowProjectInSolutionPage = false;



					// call the container to open the add reference dialog.

					string browseFilters = "Component files (*.dll)" + "\0*.dll\0";

					ErrorHandler.ThrowOnFailure(componentDialog.ComponentSelectorDlg(

						(System.UInt32)(__VSCOMPSELFLAGS.VSCOMSEL_MultiSelectMode | __VSCOMPSELFLAGS.VSCOMSEL_IgnoreMachineName),

						(IVsComponentUser)this,

						SR.GetString(SR.AddReferenceDialogTitle, CultureInfo.CurrentUICulture),   // Title

						"VS.AddReference",                          // Help topic

						ref guidEmpty,

						ref guidEmpty,

						String.Empty,                                // Machine Name

						(uint)tabInit.Length,

						tabInit,

						browseFilters,

						ref strBrowseLocations));

				}

			}

			catch(COMException e)

			{

				Trace.WriteLine("Exception : " + e.Message);

				return e.ErrorCode;

			}

			finally

			{

				// Let the project know it can show itself in the Add Project Reference Dialog page

				this.ShowProjectInSolutionPage = true;

			}

			return VSConstants.S_OK;

		}



		/// <summary>

		/// Returns the Compiler associated to the project 

		/// </summary>

		/// <returns>Null</returns>

		public virtual ICodeCompiler GetCompiler()

		{



			return null;

		}



		/// <summary>

		/// Override this method if you have your own project specific

		/// subclass of ProjectOptions

		/// </summary>

		/// <returns>This method returns a new instance of the ProjectOptions base class.</returns>

		public virtual ProjectOptions CreateProjectOptions()

		{

			return new ProjectOptions();

		}



		/// <summary>

		/// Loads a project file. Called from the factory CreateProject to load the project.

		/// </summary>

		/// <param name="fileName">File name of the project that will be created. </param>

		/// <param name="location">Location where the project will be created.</param>

		/// <param name="name">If applicable, the name of the template to use when cloning a new project.</param>

		/// <param name="flags">Set of flag values taken from the VSCREATEPROJFLAGS enumeration.</param>

		/// <param name="iidProject">Identifier of the interface that the caller wants returned. </param>

		/// <param name="canceled">An out parameter specifying if the project creation was canceled</param>

		[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "iid")]

		public virtual void Load(string fileName, string location, string name, uint flags, ref Guid iidProject, out int canceled)

		{

			try

			{

				this.disableQueryEdit = true;



				// set up internal members and icons

				canceled = 0;



				this.ProjectMgr = this;

				this.isNewProject = false;



				// We need to set the project guid before we check the project for security.

				if((flags & (uint)__VSCREATEPROJFLAGS.CPF_CLONEFILE) == (uint)__VSCREATEPROJFLAGS.CPF_CLONEFILE)

				{

					// we need to generate a new guid for the project

					this.projectIdGuid = Guid.NewGuid();

				}

				else

				{

					this.SetProjectGuidFromProjectFile();

				}



				ProjectLoadOption loadOption = this.IsProjectSecure();

				if(loadOption == ProjectLoadOption.DonNotLoad)

				{

					canceled = 1;

					return;

				}

				else if(loadOption == ProjectLoadOption.LoadNormally)

				{

					this.hasPassedSecurityChecks = true;

				}



				// This is almost a No op if the engine has already been instantiated in the factory.

				this.buildEngine = Utilities.InitializeMsBuildEngine(this.buildEngine, this.Site);



				Debug.Assert(this.globalPropertyHandler != null, "The global property handler should have been initialized at this point");



				// Now register with the configuration change event.

				this.globalPropertyHandler.ActiveConfigurationChanged += new EventHandler<ActiveConfigurationChangedEventArgs>(this.OnHandleConfigurationRelatedGlobalProperties);



				// based on the passed in flags, this either reloads/loads a project, or tries to create a new one

				// now we create a new project... we do that by loading the template and then saving under a new name

				// we also need to copy all the associated files with it.					

				if((flags & (uint)__VSCREATEPROJFLAGS.CPF_CLONEFILE) == (uint)__VSCREATEPROJFLAGS.CPF_CLONEFILE)

				{

					Debug.Assert(!String.IsNullOrEmpty(fileName) && File.Exists(fileName), "Invalid filename passed to load the project. A valid filename is expected");



					this.isNewProject = true;



					// This should be a very fast operation if the build project is already initialized by the Factory.

					this.buildProject = Utilities.ReinitializeMsBuildProject(this.buildEngine, fileName, this.buildProject);





					// Compute the file name

					// We try to solve two problems here. When input comes from a wizzard in case of zipped based projects 

					// the parameters are different.

					// In that case the filename has the new filename in a temporay path.



					// First get the extension from the template.

					// Then get the filename from the name.

					// Then create the new full path of the project.

					string extension = Path.GetExtension(fileName);



					string tempName = String.Empty;



					// We have to be sure that we are not going to loose data here. If the project name is a.b.c then for a project that was based on a zipped template(the wizzard calls us) GetFileNameWithoutExtension will suppress "c".

					// We are going to check if the parameter "name" is extension based and the extension is the same as the one from the "filename" parameter.

					string tempExtension = Path.GetExtension(name);

					if(!String.IsNullOrEmpty(tempExtension))

					{

						bool isSameExtension = (String.Compare(tempExtension, extension, StringComparison.OrdinalIgnoreCase) == 0);



						if(isSameExtension)

						{

							tempName = Path.GetFileNameWithoutExtension(name);

						}

						// If the tempExtension is not the same as the extension that the project name comes from then assume that the project name is a dotted name.

						else

						{

							tempName = Path.GetFileName(name);

						}

					}

					else

					{

						tempName = Path.GetFileName(name);

					}



					Debug.Assert(!String.IsNullOrEmpty(tempName), "Could not compute project name");

					string tempProjectFileName = tempName + extension;

					this.filename = Path.Combine(location, tempProjectFileName);



					// Initialize the common project properties.

					this.InitializeProjectProperties();



					ErrorHandler.ThrowOnFailure(this.Save(this.filename, 1, 0));



					// now we do have the project file saved. we need to create embedded files.

					MSBuild.BuildItemGroup projectFiles = this.buildProject.EvaluatedItems;

					foreach(MSBuild.BuildItem item in projectFiles)

					{

						// Ignore the item if it is a reference or folder

						if(this.FilterItemTypeToBeAddedToHierarchy(item.Name))

						{

							continue;

						}



						// MSBuilds tasks/targets can create items (such as object files),

						// such items are not part of the project per say, and should not be displayed.

						// so ignore those items.

						if(!this.IsItemTypeFileType(item.Name))

						{

							continue;

						}



						string strRelFilePath = item.FinalItemSpec;

						string basePath = Path.GetDirectoryName(fileName);

						string strPathToFile;

						string newFileName;

						// taking the base name from the project template + the relative pathname,

						// and you get the filename

						strPathToFile = Path.Combine(basePath, strRelFilePath);

						// the new path should be the base dir of the new project (location) + the rel path of the file

						newFileName = Path.Combine(location, strRelFilePath);

						// now the copy file

						AddFileFromTemplate(strPathToFile, newFileName);

					}

				}

				else

				{

					this.filename = fileName;

				}



				// now reload to fix up references

				this.Reload();

			}

			finally

			{

				this.disableQueryEdit = false;

			}

		}



		/// <summary>

		/// Called to add a file to the project from a template.

		/// Override to do it yourself if you want to customize the file

		/// </summary>

		/// <param name="source">Full path of template file</param>

		/// <param name="target">Full path of file once added to the project</param>

		public virtual void AddFileFromTemplate(string source, string target)

		{

			if(String.IsNullOrEmpty(source))

			{

				throw new ArgumentNullException("source");

			}

			if(String.IsNullOrEmpty(target))

			{

				throw new ArgumentNullException("target");

			}



			try

			{

				string directory = Path.GetDirectoryName(target);

				if(!String.IsNullOrEmpty(directory) && !Directory.Exists(directory))

				{

					Directory.CreateDirectory(directory);

				}



				FileInfo fiOrg = new FileInfo(source);

				FileInfo fiNew = fiOrg.CopyTo(target, true);



				fiNew.Attributes = FileAttributes.Normal; // remove any read only attributes.

			}

			catch(IOException e)

			{

				Trace.WriteLine("Exception : " + e.Message);

			}

			catch(UnauthorizedAccessException e)

			{

				Trace.WriteLine("Exception : " + e.Message);

			}

			catch(ArgumentException e)

			{

				Trace.WriteLine("Exception : " + e.Message);

			}

			catch(NotSupportedException e)

			{

				Trace.WriteLine("Exception : " + e.Message);

			}

		}



		/// <summary>

		/// Called when the project opens an editor window for the given file

		/// </summary>

		public virtual void OnOpenItem(string fullPathToSourceFile)

		{

		}



		/// <summary>

		/// This add methos adds the "key" item to the hierarchy, potentially adding other subitems in the process

		/// This method may recurse if the parent is an other subitem

		/// 

		/// </summary>

		/// <param name="subitems">List of subitems not yet added to the hierarchy</param>

		/// <param name="key">Key to retrieve the target item from the subitems list</param>

		/// <returns>Newly added node</returns>

		/// <remarks>If the parent node was found we add the dependent item to it otherwise we add the item ignoring the "DependentUpon" metatdata</remarks>

		protected virtual HierarchyNode AddDependentFileNode(IDictionary<String, MSBuild.BuildItem> subitems, string key)

		{

			MSBuild.BuildItem item = subitems[key];

			subitems.Remove(key);



			HierarchyNode newNode;

			HierarchyNode parent = null;



			string dependentOf = item.GetMetadata(ProjectFileConstants.DependentUpon);

			Debug.Assert(String.Compare(dependentOf, key, StringComparison.OrdinalIgnoreCase) != 0, "File dependent upon itself is not valid. Ignoring the DependentUpon metadata");

			if(subitems.ContainsKey(dependentOf))

			{

				// The parent item is an other subitem, so recurse into this method to add the parent first

				parent = AddDependentFileNode(subitems, dependentOf);

			}

			else

			{

				// See if the parent node already exist in the hierarchy

				uint parentItemID;

				string path = Path.Combine(this.ProjectFolder, dependentOf);

				ErrorHandler.ThrowOnFailure(this.ParseCanonicalName(path, out parentItemID));

				if(parentItemID != 0)

					parent = this.NodeFromItemId(parentItemID);

				Debug.Assert(parent != null, "File dependent upon a non existing item or circular dependency. Ignoring the DependentUpon metadata");

			}



			// If the parent node was found we add the dependent item to it otherwise we add the item ignoring the "DependentUpon" metatdata

			if(parent != null)

				newNode = this.AddDependentFileNodeToNode(item, parent);

			else

				newNode = this.AddIndependentFileNode(item);



			return newNode;

		}



		/// <summary>

		/// This is called from the main thread before the background build starts.

		///  cleanBuild is not part of the vsopts, but passed down as the callpath is differently

		///  PrepareBuild mainly creates directories and cleans house if cleanBuild is true

		/// </summary>

		/// <param name="config"></param>

		/// <param name="cleanBuild"></param>

		public virtual void PrepareBuild(string config, bool cleanBuild)

		{

			if(this.buildIsPrepared && !cleanBuild) return;



			ProjectOptions options = this.GetProjectOptions(config);

			string outputPath = Path.GetDirectoryName(options.OutputAssembly);



			if(cleanBuild && this.buildProject.Targets.Exists(MsBuildTarget.Clean))

			{

				this.InvokeMsBuild(MsBuildTarget.Clean);

			}



			PackageUtilities.EnsureOutputPath(outputPath);

			if(!String.IsNullOrEmpty(options.XmlDocFileName))

			{

				PackageUtilities.EnsureOutputPath(Path.GetDirectoryName(options.XmlDocFileName));

			}



			this.buildIsPrepared = true;

		}



		/// <summary>

		/// Do the build by invoking msbuild

		/// </summary>

		[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "vsopts")]

		public virtual MSBuildResult Build(uint vsopts, string config, IVsOutputWindowPane output, string target)

		{

			lock(ProjectNode.BuildLock)

			{

				bool engineLogOnlyCritical = false;

				// If there is some output, then we can ask the build engine to log more than

				// just the critical events.

				if(null != output)

				{

					engineLogOnlyCritical = BuildEngine.OnlyLogCriticalEvents;

					BuildEngine.OnlyLogCriticalEvents = false;

				}

				this.SetOutputLogger(output);

				MSBuildResult result = MSBuildResult.Failed;



				try

				{

					this.SetBuildConfigurationProperties(config);

					result = this.InvokeMsBuild(target);

				}

				finally

				{

					// Unless someone specifically request to use an output window pane, we should not output to it

					if(null != output)

					{

						this.SetOutputLogger(null);

						BuildEngine.OnlyLogCriticalEvents = engineLogOnlyCritical;

					}

				}



				return result;

			}

		}



		/// <summary>

		/// Return the value of a project property

		/// </summary>

		/// <param name="propertyName">Name of the property to get</param>

		/// <param name="resetCache">True to avoid using the cache</param>

		/// <returns>null if property does not exist, otherwise value of the property</returns>

		public virtual string GetProjectProperty(string propertyName, bool resetCache)

		{

			MSBuild.BuildProperty property = GetMsBuildProperty(propertyName, resetCache);

			if(property == null)

				return null;



			return property.FinalValue;

		}



		/// <summary>

		/// Set value of project property

		/// </summary>

		/// <param name="propertyName">Name of property</param>

		/// <param name="propertyValue">Value of property</param>

		public virtual void SetProjectProperty(string propertyName, string propertyValue)

		{

			if(propertyName == null)

				throw new ArgumentNullException("propertyName", "Cannot set a null project property");



			string oldValue = (string)GetMsBuildProperty(propertyName, true);

			if(propertyValue == null)

			{

				// if property already null, do nothing

				if(oldValue == null)

					return;

				// otherwise, set it to empty

				propertyValue = String.Empty;

			}



			// Only do the work if this is different to what we had before

			if(String.Compare(oldValue, propertyValue, StringComparison.Ordinal) != 0)

			{

				// Check out the project file.

				if(!this.ProjectMgr.QueryEditProjectFile(false))

				{

					throw Marshal.GetExceptionForHR(VSConstants.OLE_E_PROMPTSAVECANCELLED);

				}



				this.buildProject.SetProperty(propertyName, propertyValue, null);

				RaiseProjectPropertyChanged(propertyName, oldValue, propertyValue);



				// property cache will need to be updated

				this.currentConfig = null;

				this.SetProjectFileDirty(true);

			}

			return;

		}



		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase")]

		public virtual ProjectOptions GetProjectOptions(string config)

		{

			if(this.options != null)

				return this.options;



			ProjectOptions options = this.options = CreateProjectOptions();



			if(config == null)

				return options;



			options.GenerateExecutable = true;



			this.SetConfiguration(config);



			string outputPath = this.GetOutputPath(this.currentConfig);

			if(!String.IsNullOrEmpty(outputPath))

			{

				// absolutize relative to project folder location

				outputPath = Path.Combine(this.ProjectFolder, outputPath);

			}



			// Set some default values

			options.OutputAssembly = outputPath + this.Caption + ".exe";

			options.ModuleKind = ModuleKindFlags.ConsoleApplication;



			options.RootNamespace = GetProjectProperty(ProjectFileConstants.RootNamespace, false);

			options.OutputAssembly = outputPath + this.GetAssemblyName(config);



			string outputtype = GetProjectProperty(ProjectFileConstants.OutputType, false);

			if(!string.IsNullOrEmpty(outputtype))

			{

				outputtype = outputtype.ToLower(CultureInfo.InvariantCulture);

			}



			if(outputtype == "library")

			{

				options.ModuleKind = ModuleKindFlags.DynamicallyLinkedLibrary;

				options.GenerateExecutable = false; // DLL's have no entry point.

			}

			else if(outputtype == "winexe")

				options.ModuleKind = ModuleKindFlags.WindowsApplication;

			else

				options.ModuleKind = ModuleKindFlags.ConsoleApplication;



			options.Win32Icon = GetProjectProperty("ApplicationIcon", false);

			options.MainClass = GetProjectProperty("StartupObject", false);



			string targetPlatform = GetProjectProperty("TargetPlatform", false);



			if(targetPlatform != null && targetPlatform.Length > 0)

			{

				try

				{

					options.TargetPlatform = (PlatformType)Enum.Parse(typeof(PlatformType), targetPlatform);

				}

				catch(ArgumentException e)

				{

					Trace.WriteLine("Exception : " + e.Message);

				}

				options.TargetPlatformLocation = GetProjectProperty("TargetPlatformLocation", false);

				this.SetTargetPlatform(options);

			}



			//    other settings from CSharp we may want to adopt at some point...

			//    AssemblyKeyContainerName = ""  //This is the key file used to sign the interop assembly generated when importing a com object via add reference

			//    AssemblyOriginatorKeyFile = ""

			//    DelaySign = "false"

			//    DefaultClientScript = "JScript"

			//    DefaultHTMLPageLayout = "Grid"

			//    DefaultTargetSchema = "IE50"

			//    PreBuildEvent = ""

			//    PostBuildEvent = ""

			//    RunPostBuildEvent = "OnBuildSuccess"



			// transfer all config build options...

			if(GetBoolAttr(this.currentConfig, "AllowUnsafeBlocks"))

			{

				options.AllowUnsafeCode = true;

			}



			if(GetProjectProperty("BaseAddress", false) != null)

			{

				try

				{

					options.BaseAddress = Int64.Parse(GetProjectProperty("BaseAddress", false), CultureInfo.InvariantCulture);

				}

				catch(ArgumentNullException e)

				{

					Trace.WriteLine("Exception : " + e.Message);

				}

				catch(ArgumentException e)

				{

					Trace.WriteLine("Exception : " + e.Message);

				}

				catch(FormatException e)

				{

					Trace.WriteLine("Exception : " + e.Message);

				}

				catch(OverflowException e)

				{

					Trace.WriteLine("Exception : " + e.Message);

				}

			}



			if(GetBoolAttr(this.currentConfig, "CheckForOverflowUnderflow"))

			{

				options.CheckedArithmetic = true;

			}



			if(GetProjectProperty("DefineConstants", false) != null)

			{

				options.DefinedPreprocessorSymbols = new StringCollection();

				foreach(string s in GetProjectProperty("DefineConstants", false).Replace(" \t\r\n", "").Split(';'))

				{

					options.DefinedPreprocessorSymbols.Add(s);

				}

			}



			string docFile = GetProjectProperty("DocumentationFile", false);

			if(!String.IsNullOrEmpty(docFile))

			{

				options.XmlDocFileName = Path.Combine(this.ProjectFolder, docFile);

			}



			if(GetBoolAttr(this.currentConfig, "DebugSymbols"))

			{

				options.IncludeDebugInformation = true;

			}



			if(GetProjectProperty("FileAlignment", false) != null)

			{

				try

				{

					options.FileAlignment = Int32.Parse(GetProjectProperty("FileAlignment", false), CultureInfo.InvariantCulture);

				}

				catch(ArgumentNullException e)

				{

					Trace.WriteLine("Exception : " + e.Message);

				}

				catch(ArgumentException e)

				{

					Trace.WriteLine("Exception : " + e.Message);

				}

				catch(FormatException e)

				{

					Trace.WriteLine("Exception : " + e.Message);

				}

				catch(OverflowException e)

				{

					Trace.WriteLine("Exception : " + e.Message);

				}

			}



			if(GetBoolAttr(this.currentConfig, "IncrementalBuild"))

			{

				options.IncrementalCompile = true;

			}



			if(GetBoolAttr(this.currentConfig, "Optimize"))

			{

				options.Optimize = true;

			}



			if(GetBoolAttr(this.currentConfig, "RegisterForComInterop"))

			{

			}



			if(GetBoolAttr(this.currentConfig, "RemoveIntegerChecks"))

			{

			}



			if(GetBoolAttr(this.currentConfig, "TreatWarningsAsErrors"))

			{

				options.TreatWarningsAsErrors = true;

			}



			if(GetProjectProperty("WarningLevel", false) != null)

			{

				try

				{

					options.WarningLevel = Int32.Parse(GetProjectProperty("WarningLevel", false), CultureInfo.InvariantCulture);

				}

				catch(ArgumentNullException e)

				{

					Trace.WriteLine("Exception : " + e.Message);

				}

				catch(ArgumentException e)

				{

					Trace.WriteLine("Exception : " + e.Message);

				}

				catch(FormatException e)

				{

					Trace.WriteLine("Exception : " + e.Message);

				}

				catch(OverflowException e)

				{

					Trace.WriteLine("Exception : " + e.Message);

				}

			}



			return options;

		}



		public virtual void SetTargetPlatform(ProjectOptions options)

		{

		}



		[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Attr")]

		[SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "bool")]

		public virtual bool GetBoolAttr(string config, string name)

		{

			this.SetConfiguration(config);

			MSBuild.BuildPropertyGroup properties = this.buildProject.EvaluatedProperties;



			return this.GetBoolAttr(properties, name);

		}



		/// <summary>

		/// Get the assembly name for a give configuration

		/// </summary>

		/// <param name="config">the matching configuration in the msbuild file</param>

		/// <returns>assembly name</returns>

		public virtual string GetAssemblyName(string config)

		{

			this.SetConfiguration(config);

			MSBuild.BuildPropertyGroup properties = this.buildProject.EvaluatedProperties;



			return GetAssemblyName(properties);

		}



		/// <summary>

		/// Determines whether a file is a code file.

		/// </summary>

		/// <param name="fileName">Name of the file to be evaluated</param>

		/// <returns>false by default for any fileName</returns>

		public virtual bool IsCodeFile(string fileName)

		{

			return false;

		}



		/// <summary>

		/// Determines whether the given file is a resource file (resx file).

		/// </summary>

		/// <param name="fileName">Name of the file to be evaluated.</param>

		/// <returns>true if the file is a resx file, otherwise false.</returns>

		public virtual bool IsEmbeddedResource(string fileName)

		{

			if(String.Compare(Path.GetExtension(fileName), ".ResX", StringComparison.OrdinalIgnoreCase) == 0)

				return true;

			return false;

		}



		/// <summary>

		/// Create a file node based on an msbuild item.

		/// </summary>

		/// <param name="item">msbuild item</param>

		/// <returns>FileNode added</returns>

		public virtual FileNode CreateFileNode(ProjectElement item)

		{

			return new FileNode(this, item);

		}



		/// <summary>

		/// Create a file node based on a string.

		/// </summary>

		/// <param name="file">filename of the new filenode</param>

		/// <returns>File node added</returns>

		public virtual FileNode CreateFileNode(string file)

		{

			ProjectElement item = this.AddFileToMsBuild(file);

			return this.CreateFileNode(item);

		}



		/// <summary>

		/// Create dependent file node based on an msbuild item

		/// </summary>

		/// <param name="item">msbuild item</param>

		/// <returns>dependent file node</returns>

		public virtual DependentFileNode CreateDependentFileNode(ProjectElement item)

		{

			return new DependentFileNode(this, item);

		}



		/// <summary>

		/// Create a dependent file node based on a string.

		/// </summary>

		/// <param name="file">filename of the new dependent file node</param>

		/// <returns>Dependent node added</returns>

		public virtual DependentFileNode CreateDependentFileNode(string file)

		{

			ProjectElement item = this.AddFileToMsBuild(file);

			return this.CreateDependentFileNode(item);

		}



		/// <summary>

		/// Walks the subpaths of a project relative path and checks if the folder nodes hierarchy is already there, if not creates it.

		/// </summary>

		/// <param name="strPath">Path of the folder, can be relative to project or absolute</param>

		public virtual HierarchyNode CreateFolderNodes(string path)

		{

			if(String.IsNullOrEmpty(path))

			{

				throw new ArgumentNullException("path");

			}



			if(Path.IsPathRooted(path))

			{

				// Ensure we are using a relative path

				if(String.Compare(this.ProjectFolder, 0, path, 0, this.ProjectFolder.Length, StringComparison.OrdinalIgnoreCase) != 0)

					throw new ArgumentException("The path is not relative", "path");



				path = path.Substring(this.ProjectFolder.Length);

			}



			string[] parts;

			HierarchyNode curParent;



			parts = path.Split(Path.DirectorySeparatorChar);

			path = String.Empty;

			curParent = this;



			// now we have an array of subparts....

			for(int i = 0; i < parts.Length; i++)

			{

				if(parts[i].Length > 0)

				{

					path += parts[i] + "\\";

					curParent = VerifySubFolderExists(path, curParent);

				}

			}

			return curParent;

		}



		/// <summary>

		/// Defines if Node has Designer. By default we do not support designers for nodes

		/// </summary>

		/// <param name="itemPath">Path to item to query for designer support</param>

		/// <returns>true if node has designer</returns>

		public virtual bool NodeHasDesigner(string itemPath)

		{

			return false;

		}



		/// <summary>

		/// Checks if project is save to load

		/// </summary>

		/// <returns></returns>

		protected virtual ProjectLoadOption IsProjectSecure()

		{

			// If we are in command line mode then we do no security checks and assume it is trusted.

			if(Utilities.IsShellInCommandLineMode(this.Site))

			{

				return ProjectLoadOption.LoadNormally;

			}



			// Make sure we've first read the project trust information out of the .SUO, if we haven't already.

			this.package.ReadProjectTrustInformation();



			// If the project is trusted because it has been checked previously and marked as such in

			// the .SUO file, then no need to go through all this.

			ProjectTrustLevel projectTrustLevel = this.package.GetProjectTrustLevel(this.projectIdGuid);

			if(projectTrustLevel == ProjectTrustLevel.Trusted)

			{

				return ProjectLoadOption.LoadNormally;

			}



			// Instantiate the project security checker and do the security checking

			ProjectSecurityChecker securityChecker = this.CreateProjectSecurityChecker(this.buildProject.FullFileName);

			ProjectSecurityChecker userProjecSecurityChecker = null;

			string perUserFile = this.buildProject.FullFileName + ProjectNode.PerUserFileExtension;



			if(File.Exists(perUserFile))

			{

				userProjecSecurityChecker = this.CreateUserProjectSecurityChecker(perUserFile);

				((UserProjectSecurityChecker)userProjecSecurityChecker).MainProjectShim = securityChecker.ProjectShim;

			}



			return this.CheckProjectForSecurity(securityChecker, userProjecSecurityChecker);

		}



		/// <summary>

		/// Creates an instance of a ProjectSecurityChecker object that is in charge of checking the project fier for security defects.

		/// </summary>

		/// <returns>An instance of a ProjectSecurityChecker</returns>

		protected virtual ProjectSecurityChecker CreateProjectSecurityChecker(string projectFileName)

		{

			return new ProjectSecurityChecker(this.Site, projectFileName);

		}



		/// <summary>

		/// Creates an instance of a ProjectSecurityChecker object that is in charge of checking the user project file for security defects.

		/// </summary>

		/// <returns>An instance of a ProjectSecurityChecker</returns>

		protected virtual ProjectSecurityChecker CreateUserProjectSecurityChecker(string projectFileName)

		{

			return new UserProjectSecurityChecker(this.Site, projectFileName);

		}



		/// <summary>

		/// Checks the project for security. If there is a security violation a dialog box will be popped asking the user for

		/// either open the project for browsing, or open it normally, or cancel project loading.

		/// </summary>

		/// <param name="projectSecurityChecker">An instance of the project security object.</param>

		/// <param name="userProjectSecurityChecker">An instance of the user project security object.</param>

		/// <returns>Either a flag specifying to load the project normally, or not to load the project</returns>

		protected virtual ProjectLoadOption CheckProjectForSecurity(ProjectSecurityChecker projectSecurityChecker, ProjectSecurityChecker userProjectSecurityChecker)

		{

			// We will first test on the project file and then if that is not loaded for browsing we are going to test on the user file.            

			ProjectLoadOption projectLoadOption = ProjectLoadOption.DonNotLoad;

			string securityMessage = String.Empty;

			bool isProjectSafe = projectSecurityChecker.IsProjectSafeAtLoadTime(out securityMessage);

			if(!isProjectSafe)

			{

				projectLoadOption = this.ShowSecurityDialogBox(securityMessage);



				if(projectLoadOption == ProjectLoadOption.LoadNormally)

				{

					if(userProjectSecurityChecker == null)

					{

						// The project was unsafe, and the user has opted to treat it as safe.

						// Mark the project as "Trusted" in the .SUO file, so we never have to

						// go through all this again.

						this.package.SetProjectTrustLevel(this.projectIdGuid, ProjectTrustLevel.Trusted);

					}

					else

					{

						// If we have a user project we will have to redo all this, since that Load Normally was meant only for the project file.

						projectLoadOption = this.CheckProjectForSecurity(userProjectSecurityChecker, null);



						if(projectLoadOption == ProjectLoadOption.LoadNormally)

						{

							this.package.SetProjectTrustLevel(this.projectIdGuid, ProjectTrustLevel.Trusted);

						}

					}

				}

			}

			else

			{

				// If we have a user file do teh check there too.

				if(userProjectSecurityChecker != null)

				{

					projectLoadOption = this.CheckProjectForSecurity(userProjectSecurityChecker, null);

				}

				else

				{

					projectLoadOption = ProjectLoadOption.LoadNormally;

				}

			}



			return projectLoadOption;

		}



		/// <summary>

		/// Informs the user of the security situation, and gives an opportunity to treat the project

		/// as trusted (safe) despite the risk.

		/// This method is called during project load time, thus no state is yet available on the project.

		/// </summary>

		/// <param name="messageBox">The messageBox string to be shown to the user.</param>

		/// <returns>A ProjectLoadOption</returns>

		protected virtual ProjectLoadOption ShowSecurityDialogBox(string messageBox)

		{

			// If we're under automation right now, don't pop up a dialog... just assume the

			// more secure option which is to load the project for Browsing.

			if(Utilities.IsInAutomationFunction(this.Site))

			{

				return ProjectLoadOption.LoadOnlyForBrowsing;

			}



			IVsSolution solution = this.Site.GetService(typeof(SVsSolution)) as IVsSolution;



			if(solution == null)

			{

				throw new InvalidOperationException();

			}



			ProjectLoadOption projectLoadOption = ProjectLoadOption.DonNotLoad;



			object dialogStateAsObject;

			ErrorHandler.ThrowOnFailure(solution.GetProperty((int)__VSPROPID2.VSPROPID_ProjectLoadSecurityDialogState, out dialogStateAsObject));



			_ProjectLoadSecurityDialogState dialogState = (_ProjectLoadSecurityDialogState)dialogStateAsObject;



			//  If the user had the "Ask me always" box checked ...

			if(dialogState != _ProjectLoadSecurityDialogState.PLSDS_DontShowAgainBrowse &&

				dialogState != _ProjectLoadSecurityDialogState.PLSDS_DontShowAgainUnload &&

				dialogState != _ProjectLoadSecurityDialogState.PLSDS_DontShowAgainFullLoad)

			{

				// ... then we need to actually show the dialog and get a response from the user.

				SecurityWarningDialog dialog = new SecurityWarningDialog(this.Site, messageBox, this.buildProject.FullFileName);



				DialogResult result = dialog.ShowDialog();

				if(result != DialogResult.Cancel)

				{

					projectLoadOption = dialog.ProjectLoadOption;



					if(!dialog.AskAgainCheckBoxValue)

					{

						// The user unchecked the "Ask me always" checkbox.  So save his response in the

						// solution (not the solution file) so that we can re-use the same response later.

						switch(projectLoadOption)

						{

							case ProjectLoadOption.LoadNormally:

								Utilities.SaveDialogStateInSolution(this.Site, _ProjectLoadSecurityDialogState.PLSDS_DontShowAgainFullLoad);

								break;



							case ProjectLoadOption.DonNotLoad:

								Utilities.SaveDialogStateInSolution(this.Site, _ProjectLoadSecurityDialogState.PLSDS_DontShowAgainUnload);

								break;



							case ProjectLoadOption.LoadOnlyForBrowsing:

								Utilities.SaveDialogStateInSolution(this.Site, _ProjectLoadSecurityDialogState.PLSDS_DontShowAgainBrowse);

								break;



							default:

								throw new InvalidOperationException();

						}

					}

				}

			}

			else

			{

				switch(dialogState)

				{

					case _ProjectLoadSecurityDialogState.PLSDS_DontShowAgainBrowse:

						projectLoadOption = ProjectLoadOption.LoadOnlyForBrowsing;

						break;



					case _ProjectLoadSecurityDialogState.PLSDS_DontShowAgainFullLoad:

						projectLoadOption = ProjectLoadOption.LoadNormally;

						break;



					case _ProjectLoadSecurityDialogState.PLSDS_DontShowAgainUnload:

						projectLoadOption = ProjectLoadOption.DonNotLoad;

						break;



					default:

						throw new InvalidOperationException();

				}

			}



			return projectLoadOption;

		}



		/// <summary>

		/// List of Guids of the config independent property pages. It is called by the GetProperty for VSHPROPID_PropertyPagesCLSIDList property.

		/// </summary>

		/// <returns></returns>

		protected virtual Guid[] GetConfigurationIndependentPropertyPages()

		{

			return new Guid[] { Guid.Empty };

		}



		/// <summary>

		/// Returns a list of Guids of the configuration dependent property pages. It is called by the GetProperty for VSHPROPID_CfgPropertyPagesCLSIDList property.

		/// </summary>

		/// <returns></returns>

		protected virtual Guid[] GetConfigurationDependentPropertyPages()

		{

			return new Guid[0];

		}



		/// <summary>

		/// An ordered list of guids of the prefered property pages. See <see cref="__VSHPROPID.VSHPROPID_PriorityPropertyPagesCLSIDList"/>

		/// </summary>

		/// <returns>An array of guids.</returns>

		protected virtual Guid[] GetPriorityProjectDesignerPages()

		{

			return new Guid[] { Guid.Empty };

		}



		/// <summary>

		/// Takes a path and verifies that we have a node with that name.

		/// It is meant to be a helper method for CreateFolderNodes().

		/// For some scenario it may be useful to override.

		/// </summary>

		/// <param name="path">full path to the subfolder we want to verify.</param>

		/// <param name="parent">the parent node where to add the subfolder if it does not exist.</param>

		/// <returns>the foldernode correcsponding to the path.</returns>

		[SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "SubFolder")]

		protected virtual FolderNode VerifySubFolderExists(string path, HierarchyNode parent)

		{

			FolderNode folderNode = null;

			uint uiItemId;

			Url url = new Url(this.BaseURI, path);

			string strFullPath = url.AbsoluteUrl;

			// Folders end in our storage with a backslash, so add one...

			ErrorHandler.ThrowOnFailure(this.ParseCanonicalName(strFullPath, out uiItemId));

			if(uiItemId != 0)

			{

				Debug.Assert(this.NodeFromItemId(uiItemId) is FolderNode, "Not a FolderNode");

				folderNode = (FolderNode)this.NodeFromItemId(uiItemId);

			}



			if(folderNode == null)

			{

				// folder does not exist yet...

				// We could be in the process of loading so see if msbuild knows about it

				MSBuild.BuildItemGroup folders = buildProject.GetEvaluatedItemsByName(ProjectFileConstants.Folder);

				ProjectElement item = null;

				foreach(MSBuild.BuildItem folder in folders)

				{

					if(String.Compare(folder.FinalItemSpec.TrimEnd('\\'), path.TrimEnd('\\'), StringComparison.OrdinalIgnoreCase) == 0)

					{

						item = new ProjectElement(this, folder, false);

						break;

					}

				}

				// If MSBuild did not know about it, create a new one

				if(item == null)

					item = this.AddFolderToMsBuild(path);

				folderNode = this.CreateFolderNode(path, item);

				parent.AddChild(folderNode);

			}



			return folderNode;

		}



		/// <summary>

		/// To support virtual folders, override this method to return your own folder nodes

		/// </summary>

		/// <param name="path">Path to store for this folder</param>

		/// <param name="element">Element corresponding to the folder</param>

		/// <returns>A FolderNode that can then be added to the hierarchy</returns>

		protected internal virtual FolderNode CreateFolderNode(string path, ProjectElement element)

		{

			FolderNode folderNode = new FolderNode(this, path, element);

			return folderNode;

		}



		/// <summary>

		/// Gets the list of selected HierarchyNode objects

		/// </summary>

		/// <returns>A list of HierarchyNode objects</returns>

		protected internal virtual IList<HierarchyNode> GetSelectedNodes()

		{

			// Retrieve shell interface in order to get current selection

			IVsMonitorSelection monitorSelection = this.GetService(typeof(IVsMonitorSelection)) as IVsMonitorSelection;



			if(monitorSelection == null)

			{

				throw new InvalidOperationException();

			}



			List<HierarchyNode> selectedNodes = new List<HierarchyNode>();

			IntPtr hierarchyPtr = IntPtr.Zero;

			IntPtr selectionContainer = IntPtr.Zero;

			try

			{

				// Get the current project hierarchy, project item, and selection container for the current selection

				// If the selection spans multiple hierachies, hierarchyPtr is Zero

				uint itemid;

				IVsMultiItemSelect multiItemSelect = null;

				ErrorHandler.ThrowOnFailure(monitorSelection.GetCurrentSelection(out hierarchyPtr, out itemid, out multiItemSelect, out selectionContainer));



				// We only care if there are one ore more nodes selected in the tree

				if(itemid != VSConstants.VSITEMID_NIL && hierarchyPtr != IntPtr.Zero)

				{

					IVsHierarchy hierarchy = Marshal.GetObjectForIUnknown(hierarchyPtr) as IVsHierarchy;



					if(itemid != VSConstants.VSITEMID_SELECTION)

					{

						// This is a single selection. Compare hirarchy with our hierarchy and get node from itemid

						if(Utilities.IsSameComObject(this, hierarchy))

						{

							HierarchyNode node = this.NodeFromItemId(itemid);

							if(node != null)

							{

								selectedNodes.Add(node);

							}

						}

						else

						{

							NestedProjectNode node = this.GetNestedProjectForHierarchy(hierarchy);

							if(node != null)

							{

								selectedNodes.Add(node);

							}

						}

					}

					else if(multiItemSelect != null)

					{

						// This is a multiple item selection.



						//Get number of items selected and also determine if the items are located in more than one hierarchy

						uint numberOfSelectedItems;

						int isSingleHierarchyInt;

						ErrorHandler.ThrowOnFailure(multiItemSelect.GetSelectionInfo(out numberOfSelectedItems, out isSingleHierarchyInt));

						bool isSingleHierarchy = (isSingleHierarchyInt != 0);



						// Now loop all selected items and add to the list only those that are selected within this hierarchy

						if(!isSingleHierarchy || (isSingleHierarchy && Utilities.IsSameComObject(this, hierarchy)))

						{

							Debug.Assert(numberOfSelectedItems > 0, "Bad number of selected itemd");

							VSITEMSELECTION[] vsItemSelections = new VSITEMSELECTION[numberOfSelectedItems];

							uint flags = (isSingleHierarchy) ? (uint)__VSGSIFLAGS.GSI_fOmitHierPtrs : 0;

							ErrorHandler.ThrowOnFailure(multiItemSelect.GetSelectedItems(flags, numberOfSelectedItems, vsItemSelections));

							foreach(VSITEMSELECTION vsItemSelection in vsItemSelections)

							{

								if(isSingleHierarchy || Utilities.IsSameComObject(this, vsItemSelection.pHier))

								{

									HierarchyNode node = this.NodeFromItemId(vsItemSelection.itemid);

									if(node != null)

									{

										selectedNodes.Add(node);

									}

								}

							}

						}

					}

				}

			}

			finally

			{

				if(hierarchyPtr != IntPtr.Zero)

				{

					Marshal.Release(hierarchyPtr);

				}

				if(selectionContainer != IntPtr.Zero)

				{

					Marshal.Release(selectionContainer);

				}

			}



			return selectedNodes;

		}



		/// <summary>

		/// Recursevily walks the hierarchy nodes and redraws the state icons

		/// </summary>

		protected internal override void UpdateSccStateIcons()

		{

			if(this.FirstChild == null)

			{

				return;

			}



			for(HierarchyNode n = this.FirstChild; n != null; n = n.NextSibling)

			{

				n.UpdateSccStateIcons();

			}

		}





		/// <summary>

		/// Handles the shows all objects command.

		/// </summary>

		/// <returns></returns>

		protected internal virtual int ShowAllFiles()

		{

			return (int)OleConstants.OLECMDERR_E_NOTSUPPORTED;

		}



		/// <summary>

		/// Handles the Add web reference command.

		/// </summary>

		/// <returns></returns>

		protected internal virtual int AddWebReference()

		{

			return (int)OleConstants.OLECMDERR_E_NOTSUPPORTED;

		}



		/// <summary>

		/// Unloads the project.

		/// </summary>

		/// <returns></returns>

		protected internal virtual int UnloadProject()

		{

			return (int)OleConstants.OLECMDERR_E_NOTSUPPORTED;

		}



		/// <summary>

		/// Handles the clean project command.

		/// </summary>

		/// <returns></returns>

		protected virtual int CleanProject()

		{

			return (int)OleConstants.OLECMDERR_E_NOTSUPPORTED;

		}



		/// <summary>

		/// Reload project from project file

		/// </summary>

		protected virtual void Reload()

		{

			Debug.Assert(this.buildEngine != null, "There is no build engine defined for this project");



			try

			{

				this.disableQueryEdit = true;



				this.isClosed = false;

				this.eventTriggeringFlag = ProjectNode.EventTriggering.DoNotTriggerHierarchyEvents | ProjectNode.EventTriggering.DoNotTriggerTrackerEvents;



				this.buildProject = Utilities.ReinitializeMsBuildProject(this.buildEngine, this.filename, this.buildProject);

				MSBuild.BuildPropertyGroup projectProperties = buildProject.EvaluatedProperties;



				// Load the guid

				if(projectProperties != null)

				{

					this.SetProjectGuidFromProjectFile();

				}



				this.ProcessReferences();



				this.ProcessFiles();



				this.ProcessFolders();



				this.LoadNonBuildInformation();



				this.InitSccInfo();



				this.RegisterSccProject();

			}

			finally

			{

				this.SetProjectFileDirty(false);

				this.eventTriggeringFlag = ProjectNode.EventTriggering.TriggerAll;

				this.disableQueryEdit = false;

			}

		}



		/// <summary>

		/// Renames the project file

		/// </summary>

		/// <param name="newFile">The full path of the new project file.</param>

		protected virtual void RenameProjectFile(string newFile)

		{

			IVsUIShell shell = this.Site.GetService(typeof(SVsUIShell)) as IVsUIShell;

			Debug.Assert(shell != null, "Could not get the ui shell from the project");

			if(shell == null)

			{

				throw new InvalidOperationException();

			}



			// Do some name validation

			if(Microsoft.VisualStudio.Project.Utilities.ContainsInvalidFileNameChars(newFile))

			{

				throw new InvalidOperationException(SR.GetString(SR.ErrorInvalidProjectName, CultureInfo.CurrentUICulture));

			}



			// Figure out what the new full name is

			string oldFile = this.Url;



			int canContinue = 0;

			IVsSolution vsSolution = (IVsSolution)this.GetService(typeof(SVsSolution));

			if(ErrorHandler.Succeeded(vsSolution.QueryRenameProject(this, oldFile, newFile, 0, out canContinue))

				&& canContinue != 0)

			{

				bool isFileSame = NativeMethods.IsSamePath(oldFile, newFile);



				// If file already exist and is not the same file with different casing

				if(!isFileSame && File.Exists(newFile))

				{

					// Prompt the user for replace

					string message = SR.GetString(SR.FileAlreadyExists, newFile);



					if(!Utilities.IsInAutomationFunction(this.Site))

					{

						if(!VsShellUtilities.PromptYesNo(message, null, OLEMSGICON.OLEMSGICON_WARNING, shell))

						{

							throw Marshal.GetExceptionForHR(VSConstants.OLE_E_PROMPTSAVECANCELLED);

						}

					}

					else

					{

						throw new InvalidOperationException(message);

					}



					// Delete the destination file after making sure it is not read only

					File.SetAttributes(newFile, FileAttributes.Normal);

					File.Delete(newFile);

				}



				SuspendFileChanges fileChanges = new SuspendFileChanges(this.Site, this.filename);

				fileChanges.Suspend();

				try

				{

					// Actual file rename

					this.SaveMSBuildProjectFileAs(newFile);



					this.SetProjectFileDirty(false);



					if(!isFileSame)

					{

						// Now that the new file name has been created delete the old one.

						// TODO: Handle source control issues.

						File.SetAttributes(oldFile, FileAttributes.Normal);

						File.Delete(oldFile);

					}



					this.OnPropertyChanged(this, (int)__VSHPROPID.VSHPROPID_Caption, 0);



					// Update solution

					ErrorHandler.ThrowOnFailure(vsSolution.OnAfterRenameProject((IVsProject)this, oldFile, newFile, 0));



					ErrorHandler.ThrowOnFailure(shell.RefreshPropertyBrowser(0));

				}

				finally

				{

					fileChanges.Resume();

				}

			}

			else

			{

				throw Marshal.GetExceptionForHR(VSConstants.OLE_E_PROMPTSAVECANCELLED);

			}

		}



		/// <summary>

		/// Called by the project to know if the item is a file (that is part of the project)

		/// or an intermediate file used by the MSBuild tasks/targets

		/// Override this method if your project has more types or different ones

		/// </summary>

		/// <param name="type">Type name</param>

		/// <returns>True = items of this type should be included in the project</returns>

		protected virtual bool IsItemTypeFileType(string type)

		{

			if(String.Compare(type, BuildAction.Compile.ToString(), StringComparison.OrdinalIgnoreCase) == 0

				|| String.Compare(type, BuildAction.Content.ToString(), StringComparison.OrdinalIgnoreCase) == 0

				|| String.Compare(type, BuildAction.EmbeddedResource.ToString(), StringComparison.OrdinalIgnoreCase) == 0

				|| String.Compare(type, BuildAction.None.ToString(), StringComparison.OrdinalIgnoreCase) == 0)

				return true;



			// we don't know about this type, so ignore it.

			return false;

		}



		/// <summary>

		/// Filter items that should not be processed as file items. Example: Folders and References.

		/// </summary>

		protected virtual bool FilterItemTypeToBeAddedToHierarchy(string itemType)

		{

			return (String.Compare(itemType, ProjectFileConstants.Reference, StringComparison.OrdinalIgnoreCase) == 0

					|| String.Compare(itemType, ProjectFileConstants.ProjectReference, StringComparison.OrdinalIgnoreCase) == 0

					|| String.Compare(itemType, ProjectFileConstants.COMReference, StringComparison.OrdinalIgnoreCase) == 0

					|| String.Compare(itemType, ProjectFileConstants.Folder, StringComparison.OrdinalIgnoreCase) == 0

					|| String.Compare(itemType, ProjectFileConstants.WebReference, StringComparison.OrdinalIgnoreCase) == 0

					|| String.Compare(itemType, ProjectFileConstants.WebReferenceFolder, StringComparison.OrdinalIgnoreCase) == 0);

		}



		/// <summary>

		/// Associate window output pane to the build logger

		/// </summary>

		/// <param name="output"></param>

		protected virtual void SetOutputLogger(IVsOutputWindowPane output)

		{

			// Create our logger, if it was not specified

			if(!this.useProvidedLogger || this.buildLogger == null)

			{

				// Because we may be aggregated, we need to make sure to get the outer IVsHierarchy

				IntPtr unknown = IntPtr.Zero;

				IVsHierarchy hierarchy = null;

				try

				{

					unknown = Marshal.GetIUnknownForObject(this);

					hierarchy = Marshal.GetTypedObjectForIUnknown(unknown, typeof(IVsHierarchy)) as IVsHierarchy;

				}

				finally

				{

					if(unknown != IntPtr.Zero)

						Marshal.Release(unknown);

				}

				// Create the logger

				this.buildLogger = new IDEBuildLogger(output, this.TaskProvider, hierarchy);



				// To retrive the verbosity level, the build logger depends on the registry root 

				// (otherwise it will used an hardcoded default)

				ILocalRegistry2 registry = this.GetService(typeof(SLocalRegistry)) as ILocalRegistry2;

				if(null != registry)

				{

					string registryRoot;

					ErrorHandler.ThrowOnFailure(registry.GetLocalRegistryRoot(out registryRoot));

					IDEBuildLogger logger = this.BuildLogger as IDEBuildLogger;

					if(!String.IsNullOrEmpty(registryRoot) && (null != logger))

					{

						logger.BuildVerbosityRegistryRoot = registryRoot;

						logger.ErrorString = this.ErrorString;

						logger.WarningString = this.WarningString;

					}

				}

			}

			else

			{

				((IDEBuildLogger)this.BuildLogger).OutputWindowPane = output;

			}



			if(this.buildEngine != null)

			{

				this.buildEngine.UnregisterAllLoggers();

				this.buildEngine.RegisterLogger(this.buildLogger);

			}

		}



		/// <summary>

		/// Set configuration properties for a specific configuration

		/// </summary>

		/// <param name="config">configuration name</param>

		protected virtual void SetBuildConfigurationProperties(string config)

		{

			ProjectOptions options = null;



			if(!String.IsNullOrEmpty(config))

			{

				options = this.GetProjectOptions(config);

			}



			if(options != null && this.buildProject != null)

			{

				// Make sure the project configuration is set properly

				this.SetConfiguration(config);

			}

		}



		/// <summary>

		/// This execute an MSBuild target.

		/// If you depend on the items/properties generated by the target

		/// you should be aware that any call to BuildTarget on any project

		/// will reset the list of generated items/properties

		/// </summary>

		/// <param name="target">Name of the MSBuild target to execute</param>

		/// <returns>Result from executing the target (success/failure)</returns>

		[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Ms")]

		protected virtual MSBuildResult InvokeMsBuild(string target)

		{

			MSBuildResult result = MSBuildResult.Failed;



			if(!this.hasPassedSecurityChecks)

			{

				return result;

			}



			try

			{

				this.buildInProcess = true;



				// Enable build if all security checks have been passed.

				this.buildEngine.BuildEnabled = true;

				// Do the actual Build

				if(this.buildProject != null)

				{

					result = this.buildProject.Build(target) ? MSBuildResult.Successful : MSBuildResult.Failed;

				}

			}

			finally

			{

				// Comment from VSCore. We might be in the same scenario:

				// For security purposes, restore the engine back to the original state where

				// build is not enabled except for projects explicitly marked as safe by the

				// project system.  This is so that in case the user now does an Add Existing

				// Project of a project that seems safe to us but contains a P2P reference to 

				// a random unsafe project on disk, the user is still protected from the potential

				// harm of resolving that P2P reference (thereby running targets in the malicious

				// project).

				this.buildEngine.BuildEnabled = false;

				this.buildInProcess = false;

				this.buildEngine.UnregisterAllLoggers();

			}



			return result;

		}



		/// <summary>

		/// Initialize common project properties with default value if they are empty

		/// </summary>

		/// <remarks>The following common project properties are defaulted to projectName (if empty):

		///    AssemblyName, Name and RootNamespace.

		/// If the project filename is not set then no properties are set</remarks>

		protected virtual void InitializeProjectProperties()

		{

			// Get projectName from project filename. Return if not set

			string projectName = Path.GetFileNameWithoutExtension(this.filename);

			if(String.IsNullOrEmpty(projectName))

			{

				return;

			}



			if(String.IsNullOrEmpty(GetProjectProperty(ProjectFileConstants.AssemblyName)))

			{

				SetProjectProperty(ProjectFileConstants.AssemblyName, projectName);

			}

			if(String.IsNullOrEmpty(GetProjectProperty(ProjectFileConstants.Name)))

			{

				SetProjectProperty(ProjectFileConstants.Name, projectName);

			}

			if(String.IsNullOrEmpty(GetProjectProperty(ProjectFileConstants.RootNamespace)))

			{

				SetProjectProperty(ProjectFileConstants.RootNamespace, projectName);

			}

		}



		/// <summary>

		/// Factory method for configuration provider

		/// </summary>

		/// <returns>Configuration provider created</returns>

		protected virtual ConfigProvider CreateConfigProvider()

		{

			return new ConfigProvider(this);

		}



		/// <summary>

		/// Factory method for reference container node

		/// </summary>

		/// <returns>ReferenceContainerNode created</returns>

		protected virtual ReferenceContainerNode CreateReferenceContainerNode()

		{

			return new ReferenceContainerNode(this);

		}



		/// <summary>

		/// Saves the project file on a new name.

		/// </summary>

		/// <param name="newFileName">The new name of the project file.</param>

		/// <returns>Success value or an error code.</returns>

		protected virtual int SaveAs(string newFileName)

		{

			Debug.Assert(!String.IsNullOrEmpty(newFileName), "Cannot save project file for an empty or null file name");



			newFileName = newFileName.Trim();



			string errorMessage = String.Empty;



			if(newFileName.Length > NativeMethods.MAX_PATH)

			{

				errorMessage = String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.PathTooLong, CultureInfo.CurrentUICulture), newFileName);

			}

			else

			{

				string fileName = String.Empty;



				try

				{

					fileName = Path.GetFileNameWithoutExtension(newFileName);

				}

				// We want to be consistent in the error message and exception we throw. fileName could be for example #¤&%"¤&"%  and that would trigger an ArgumentException on Path.IsRooted.

				catch(ArgumentException)

				{

					errorMessage = SR.GetString(SR.ErrorInvalidFileName, CultureInfo.CurrentUICulture);

				}



				if(errorMessage.Length == 0)

				{

					// If there is no filename or it starts with a leading dot issue an error message and quit.

					// For some reason the save as dialog box allows to save files like "......ext"

					if(String.IsNullOrEmpty(fileName) || fileName[0] == '.')

					{

						errorMessage = SR.GetString(SR.FileNameCannotContainALeadingPeriod, CultureInfo.CurrentUICulture);

					}

					else if(Utilities.ContainsInvalidFileNameChars(newFileName))

					{

						errorMessage = SR.GetString(SR.ErrorInvalidFileName, CultureInfo.CurrentUICulture);

					}

					else

					{

						string url = Path.GetDirectoryName(newFileName);

						string oldUrl = Path.GetDirectoryName(this.Url);



						if(!NativeMethods.IsSamePath(oldUrl, url))

						{

							errorMessage = String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.SaveOfProjectFileOutsideCurrentDirectory, CultureInfo.CurrentUICulture), this.ProjectFolder);

						}

					}

				}

			}

			if(errorMessage.Length > 0)

			{

				// If it is not called from an automation method show a dialog box.

				if(!Utilities.IsInAutomationFunction(this.Site))

				{

					string title = null;

					OLEMSGICON icon = OLEMSGICON.OLEMSGICON_CRITICAL;

					OLEMSGBUTTON buttons = OLEMSGBUTTON.OLEMSGBUTTON_OK;

					OLEMSGDEFBUTTON defaultButton = OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST;

					VsShellUtilities.ShowMessageBox(this.Site, title, errorMessage, icon, buttons, defaultButton);

					return VSConstants.OLE_E_PROMPTSAVECANCELLED;

				}



				throw new InvalidOperationException(errorMessage);

			}



			string oldName = this.filename;



			IVsSolution solution = this.Site.GetService(typeof(IVsSolution)) as IVsSolution;

			Debug.Assert(solution != null, "Could not retrieve the solution form the service provider");

			if(solution == null)

			{

				throw new InvalidOperationException();

			}



			int canRenameContinue = 0;

			ErrorHandler.ThrowOnFailure(solution.QueryRenameProject(this, this.filename, newFileName, 0, out canRenameContinue));



			if(canRenameContinue == 0)

			{

				return VSConstants.OLE_E_PROMPTSAVECANCELLED;

			}



			SuspendFileChanges fileChanges = new SuspendFileChanges(this.Site, oldName);

			fileChanges.Suspend();

			try

			{

				// Save the project file and project file related properties.

				this.SaveMSBuildProjectFileAs(newFileName);



				this.SetProjectFileDirty(false);





				// TODO: If source control is enabled check out the project file.



				//Redraw.

				this.OnPropertyChanged(this, (int)__VSHPROPID.VSHPROPID_Caption, 0);



				ErrorHandler.ThrowOnFailure(solution.OnAfterRenameProject(this, oldName, this.filename, 0));



				IVsUIShell shell = this.Site.GetService(typeof(SVsUIShell)) as IVsUIShell;

				Debug.Assert(shell != null, "Could not get the ui shell from the project");

				if(shell == null)

				{

					throw new InvalidOperationException();

				}

				ErrorHandler.ThrowOnFailure(shell.RefreshPropertyBrowser(0));

			}

			finally

			{

				fileChanges.Resume();

			}



			return VSConstants.S_OK;

		}



		/// <summary>

		/// Saves project file related information to the new file name. It also calls msbuild API to save the project file.

		/// It is called by the SaveAs method and the SetEditLabel before the project file rename related events are triggered. 

		/// An implementer can override this method to provide specialized semantics on how the project file is renamed in the msbuild file.

		/// </summary>

		/// <param name="newFileName">The new full path of the project file</param>

		protected virtual void SaveMSBuildProjectFileAs(string newFileName)

		{

			Debug.Assert(!String.IsNullOrEmpty(newFileName), "Cannot save project file for an empty or null file name");



			this.buildProject.FullFileName = newFileName;



			this.filename = newFileName;



			string newFileNameWithoutExtension = Path.GetFileNameWithoutExtension(newFileName);



			// Refresh solution explorer

			this.SetProjectProperty(ProjectFileConstants.Name, newFileNameWithoutExtension);



			// Saves the project file on disk.

			this.buildProject.Save(newFileName);



		}



		/// <summary>

		/// Adds a file to the msbuild project.

		/// </summary>

		/// <param name="file">The file to be added.</param>

		/// <returns>A Projectelement describing the newly added file.</returns>

		[SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "ToMs")]

		[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Ms")]

		protected virtual ProjectElement AddFileToMsBuild(string file)

		{

			ProjectElement newItem;



			string itemPath = PackageUtilities.MakeRelativeIfRooted(file, this.BaseURI);

			Debug.Assert(!Path.IsPathRooted(itemPath), "Cannot add item with full path.");



			if(this.IsCodeFile(itemPath))

			{

				newItem = this.CreateMsBuildFileItem(itemPath, ProjectFileConstants.Compile);

				newItem.SetMetadata(ProjectFileConstants.SubType, ProjectFileAttributeValue.Code);

			}

			else if(this.IsEmbeddedResource(itemPath))

			{

				newItem = this.CreateMsBuildFileItem(itemPath, ProjectFileConstants.EmbeddedResource);

			}

			else

			{

				newItem = this.CreateMsBuildFileItem(itemPath, ProjectFileConstants.Content);

				newItem.SetMetadata(ProjectFileConstants.SubType, ProjectFileConstants.Content);

			}



			return newItem;

		}



		/// <summary>

		/// Adds a folder to the msbuild project.

		/// </summary>

		/// <param name="folder">The folder to be added.</param>

		/// <returns>A Projectelement describing the newly added folder.</returns>

		[SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "ToMs")]

		[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Ms")]

		protected virtual ProjectElement AddFolderToMsBuild(string folder)

		{

			ProjectElement newItem;



			string itemPath = PackageUtilities.MakeRelativeIfRooted(folder, this.BaseURI);

			Debug.Assert(!Path.IsPathRooted(itemPath), "Cannot add item with full path.");



			newItem = this.CreateMsBuildFileItem(itemPath, ProjectFileConstants.Folder);



			return newItem;

		}



		/// <summary>

		/// Determines whether an item can be owerwritten in the hierarchy.

		/// </summary>

		/// <param name="originalFileName">The orginal filname.</param>

		/// <param name="computedNewFileName">The computed new file name, that will be copied to the project directory or into the folder .</param>

		/// <returns>S_OK for success, or an error message</returns>

		protected virtual int CanOverwriteExistingItem(string originalFileName, string computedNewFileName)

		{

			if(String.IsNullOrEmpty(originalFileName) || String.IsNullOrEmpty(computedNewFileName))

			{

				return VSConstants.E_INVALIDARG;

			}



			string message = String.Empty;

			string title = String.Empty;

			OLEMSGICON icon = OLEMSGICON.OLEMSGICON_CRITICAL;

			OLEMSGBUTTON buttons = OLEMSGBUTTON.OLEMSGBUTTON_OK;

			OLEMSGDEFBUTTON defaultButton = OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST;



			// If the document is open then return error message.

			IVsUIHierarchy hier;

			IVsWindowFrame windowFrame;

			uint itemid = VSConstants.VSITEMID_NIL;



			bool isOpen = VsShellUtilities.IsDocumentOpen(this.Site, computedNewFileName, Guid.Empty, out hier, out itemid, out windowFrame);



			if(isOpen)

			{

				message = String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.CannotAddFileThatIsOpenInEditor, CultureInfo.CurrentUICulture), Path.GetFileName(computedNewFileName));

				VsShellUtilities.ShowMessageBox(this.Site, title, message, icon, buttons, defaultButton);

				return VSConstants.E_ABORT;

			}





			// File already exists in project... message box

			message = SR.GetString(SR.FileAlreadyInProject, CultureInfo.CurrentUICulture);

			icon = OLEMSGICON.OLEMSGICON_QUERY;

			buttons = OLEMSGBUTTON.OLEMSGBUTTON_YESNO;

			int msgboxResult = VsShellUtilities.ShowMessageBox(this.Site, title, message, icon, buttons, defaultButton);

			if(msgboxResult != NativeMethods.IDYES)

			{

				return (int)OleConstants.OLECMDERR_E_CANCELED;

			}



			return VSConstants.S_OK;

		}



		/// <summary>

		/// Handle owerwriting of an existing item in the hierarchy.

		/// </summary>

		/// <param name="existingNode">The node that exists.</param>

		protected virtual void OverwriteExistingItem(HierarchyNode existingNode)

		{



		}



		/// <summary>

		/// Adds a new file node to the hierarchy.

		/// </summary>

		/// <param name="parentNode">The parent of the new fileNode</param>

		/// <param name="fileName">The file name</param>

		protected virtual void AddNewFileNodeToHierarchy(HierarchyNode parentNode, string fileName)

		{

			HierarchyNode child;



			// In the case of subitem, we want to create dependent file node

			// and set the DependentUpon property

			if(this.canFileNodesHaveChilds && (parentNode is FileNode || parentNode is DependentFileNode))

			{

				child = this.CreateDependentFileNode(fileName);

				child.ItemNode.SetMetadata(ProjectFileConstants.DependentUpon, parentNode.ItemNode.GetMetadata(ProjectFileConstants.Include));



				// Make sure to set the HasNameRelation flag on the dependent node if it is related to the parent by name

				if(!child.HasParentNodeNameRelation && string.Compare(child.GetRelationalName(), parentNode.GetRelationalName(), StringComparison.OrdinalIgnoreCase) == 0)

				{

					child.HasParentNodeNameRelation = true;

				}

			}

			else

			{

				//Create and add new filenode to the project

				child = this.CreateFileNode(fileName);

			}



			parentNode.AddChild(child);



			// TODO : Revisit the VSADDFILEFLAGS here. Can it be a nested project?

			this.tracker.OnItemAdded(fileName, VSADDFILEFLAGS.VSADDFILEFLAGS_NoFlags);

		}



		/// <summary>

		/// Defines whther the current mode of the project is in a supress command mode.

		/// </summary>

		/// <returns></returns>

		protected internal virtual bool IsCurrentStateASuppressCommandsMode()

		{

			if(VsShellUtilities.IsSolutionBuilding(this.Site))

			{

				return true;

			}



			DBGMODE dbgMode = VsShellUtilities.GetDebugMode(this.Site) & ~DBGMODE.DBGMODE_EncMask;

			if(dbgMode == DBGMODE.DBGMODE_Run || dbgMode == DBGMODE.DBGMODE_Break)

			{

				return true;

			}



			return false;



		}





		/// <summary>

		/// This is the list of output groups that the configuration object should

		/// provide.

		/// The first string is the name of the group.

		/// The second string is the target name (MSBuild) for that group.

		/// 

		/// To add/remove OutputGroups, simply override this method and edit the list.

		/// 

		/// To get nice display names and description for your groups, override:

		///        - GetOutputGroupDisplayName

		///        - GetOutputGroupDescription

		/// </summary>

		/// <returns>List of output group name and corresponding MSBuild target</returns>

		protected internal virtual IList<KeyValuePair<string, string>> GetOutputGroupNames()

		{

			return new List<KeyValuePair<string, string>>(outputGroupNames);

		}



		/// <summary>

		/// Get the display name of the given output group.

		/// </summary>

		/// <param name="canonicalName">Canonical name of the output group</param>

		/// <returns>Display name</returns>

		protected internal virtual string GetOutputGroupDisplayName(string canonicalName)

		{

			string result = SR.GetString(String.Format(CultureInfo.InvariantCulture, "Output{0}", canonicalName), CultureInfo.CurrentUICulture);

			if(String.IsNullOrEmpty(result))

				result = canonicalName;

			return result;

		}



		/// <summary>

		/// Get the description of the given output group.

		/// </summary>

		/// <param name="canonicalName">Canonical name of the output group</param>

		/// <returns>Description</returns>

		protected internal virtual string GetOutputGroupDescription(string canonicalName)

		{

			string result = SR.GetString(String.Format(CultureInfo.InvariantCulture, "Output{0}Description", canonicalName), CultureInfo.CurrentUICulture);

			if(String.IsNullOrEmpty(result))

				result = canonicalName;

			return result;

		}



		/// <summary>

		/// Set the configuration in MSBuild.

		/// This does not get persisted and is used to evaluate msbuild conditions

		/// which are based on the $(Configuration) property.

		/// </summary>

		protected internal virtual void SetCurrentConfiguration()

		{

			if(this.BuildInProgress)

			{

				// we are building so this should already be the current configuration

				return;

			}



			// Can't ask for the active config until the project is opened, so do nothing in that scenario

			if(!this.projectOpened)

				return;



			EnvDTE.Project automationObject = this.GetAutomationObject() as EnvDTE.Project;



			this.SetConfiguration(Utilities.GetActiveConfigurationName(automationObject));

		}



		/// <summary>

		/// Set the configuration property in MSBuild.

		/// This does not get persisted and is used to evaluate msbuild conditions

		/// which are based on the $(Configuration) property.

		/// </summary>

		/// <param name="config">Configuration name</param>

		protected internal virtual void SetConfiguration(string config)

		{

			if(config == null)

			{

				throw new ArgumentNullException("config");

			}



			// Can't ask for the active config until the project is opened, so do nothing in that scenario

			if(!projectOpened)

				return;



			// We cannot change properties during the build so if the config

			// we want to se is the current, we do nothing otherwise we fail.

			if(this.BuildInProgress)

			{

				EnvDTE.Project automationObject = this.GetAutomationObject() as EnvDTE.Project;

				string currentConfigName = Utilities.GetActiveConfigurationName(automationObject);

				bool configsAreEqual = String.Compare(currentConfigName, config, StringComparison.OrdinalIgnoreCase) == 0;



				if(configsAreEqual)

				{

					return;

				}

				throw new InvalidOperationException(); ;

			}



			this.buildProject.GlobalProperties.SetProperty(ProjectFileConstants.Configuration, config);

			this.currentConfig = this.buildProject.EvaluatedProperties;

		}



		/// <summary>

		/// Loads reference items from the project file into the hierarchy.

		/// </summary>

		protected internal virtual void ProcessReferences()

		{

			IReferenceContainer container = GetReferenceContainer();

			if(null == container)

			{

				// Process References

				ReferenceContainerNode referencesFolder = CreateReferenceContainerNode();

				if(null == referencesFolder)

				{

					// This project type does not support references or there is a problem

					// creating the reference container node.

					// In both cases there is no point to try to process references, so exit.

					return;

				}

				this.AddChild(referencesFolder);

				container = referencesFolder;

			}



			// Load the referernces.

			container.LoadReferencesFromBuildProject(buildProject);

		}



		/// <summary>

		/// Loads folders from the project file into the hierarchy.

		/// </summary>

		protected internal virtual void ProcessFolders()

		{

			// Process Folders (useful to persist empty folder)

			MSBuild.BuildItemGroup folders = this.buildProject.GetEvaluatedItemsByName(ProjectFileConstants.Folder);

			foreach(MSBuild.BuildItem folder in folders)

			{

				string strPath = folder.FinalItemSpec;



				// We do not need any special logic for assuring that a folder is only added once to the ui hierarchy.

				// The below method will only add once the folder to the ui hierarchy

				this.CreateFolderNodes(strPath);

			}

		}



		/// <summary>

		/// Loads file items from the project file into the hierarchy.

		/// </summary>

		protected internal virtual void ProcessFiles()

		{

			List<String> subitemsKeys = new List<String>();

			Dictionary<String, MSBuild.BuildItem> subitems = new Dictionary<String, MSBuild.BuildItem>();



			// Define a set for our build items. The value does not really matter here.

			Dictionary<String, MSBuild.BuildItem> items = new Dictionary<String, MSBuild.BuildItem>();



			// Process Files

			MSBuild.BuildItemGroup projectFiles = this.buildProject.EvaluatedItems;

			foreach(MSBuild.BuildItem item in projectFiles)

			{

				// Ignore the item if it is a reference or folder

				if(this.FilterItemTypeToBeAddedToHierarchy(item.Name))

					continue;



				// MSBuilds tasks/targets can create items (such as object files),

				// such items are not part of the project per say, and should not be displayed.

				// so ignore those items.

				if(!this.IsItemTypeFileType(item.Name))

					continue;



				// If the item is already contained do nothing.

				// TODO: possibly report in the error list that the the item is already contained in the project file similar to Language projects.

				if(items.ContainsKey(item.FinalItemSpec.ToUpperInvariant()))

					continue;



				// Make sure that we do not want to add the item, dependent, or independent twice to the ui hierarchy

				items.Add(item.FinalItemSpec.ToUpperInvariant(), item);



				string dependentOf = item.GetMetadata(ProjectFileConstants.DependentUpon);



				if(!this.CanFileNodesHaveChilds || String.IsNullOrEmpty(dependentOf))

				{

					AddIndependentFileNode(item);

				}

				else

				{

					// We will process dependent items later.

					// Note that we use 2 lists as we want to remove elements from

					// the collection as we loop through it

					subitemsKeys.Add(item.FinalItemSpec);

					subitems.Add(item.FinalItemSpec, item);

				}

			}



			// Now process the dependent items.

			if(this.CanFileNodesHaveChilds)

			{

				ProcessDependentFileNodes(subitemsKeys, subitems);

			}



		}



		/// <summary>

		/// Processes dependent filenodes from list of subitems. Multi level supported, but not circular dependencies.

		/// </summary>

		/// <param name="subitemsKeys">List of sub item keys </param>

		/// <param name="subitems"></param>

		protected internal virtual void ProcessDependentFileNodes(IList<String> subitemsKeys, Dictionary<String, MSBuild.BuildItem> subitems)

		{

			foreach(string key in subitemsKeys)

			{

				// A previous pass could have removed the key so make sure it still needs to be added

				if(!subitems.ContainsKey(key))

					continue;



				AddDependentFileNode(subitems, key);

			}

		}



		/// <summary>

		/// For flavored projects which implement IPersistXMLFragment, load the information now

		/// </summary>

		protected internal virtual void LoadNonBuildInformation()

		{

			IPersistXMLFragment outerHierarchy = HierarchyNode.GetOuterHierarchy(this) as IPersistXMLFragment;

			if(outerHierarchy != null)

			{

				this.LoadXmlFragment(outerHierarchy, null);

			}

		}



		/// <summary>

		/// Used to sort nodes in the hierarchy.

		/// </summary>

		protected internal virtual int CompareNodes(HierarchyNode node1, HierarchyNode node2)

		{

			Debug.Assert(node1 != null && node2 != null);



			if(node1.SortPriority == node2.SortPriority)

			{

				return String.Compare(node2.Caption, node1.Caption, true, CultureInfo.CurrentCulture);

			}

			else

			{

				return node2.SortPriority - node1.SortPriority;

			}

		}



		/// <summary>

		/// Handles global properties related to configuration and platform changes invoked by a change in the active configuration.

		/// </summary>

		/// <param name="sender">The sender of the event.</param>

		/// <param name="eventArgs">The event args</param>

		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers",

			Justification = "This method will give the opportunity to update global properties based on active configuration change. " +

			"There is no security threat that could otherwise not be reached by listening to configuration chnage events.")]

		protected virtual void OnHandleConfigurationRelatedGlobalProperties(object sender, ActiveConfigurationChangedEventArgs eventArgs)

		{

			Debug.Assert(eventArgs != null, "Wrong hierarchy passed as event arg for the configuration change listener.");



			// If (eventArgs.Hierarchy == NULL) then we received this event because the solution configuration

			// was changed.

			// If it is not null we got the event because a project in teh configuration manager has changed its active configuration.

			// We care only about our project in the default implementation.

			if(eventArgs.Hierarchy == null || !Utilities.IsSameComObject(eventArgs.Hierarchy, this))

			{

				return;

			}



			string name, platform;

			if(!Utilities.TryGetActiveConfigurationAndPlatform(this.Site, this, out name, out platform))

			{

				throw new InvalidOperationException();

			}



			this.buildProject.GlobalProperties.SetProperty(GlobalProperty.Configuration.ToString(), name);



			// If the platform is "Any CPU" then it should be set to AnyCPU, since that is the property value in MsBuild terms.

			if(String.Compare(platform, ConfigProvider.AnyCPUPlatform, StringComparison.Ordinal) == 0)

			{

				platform = ProjectFileValues.AnyCPU;

			}



			this.buildProject.GlobalProperties.SetProperty(GlobalProperty.Platform.ToString(), platform);

		}



		#endregion



		#region non-virtual methods



		/// <summary>

		/// Suspends MSBuild

		/// </summary>

		public void SuspendMSBuild()

		{

			this.suspendMSBuildCounter++;

		}



		/// <summary>

		/// Resumes MSBuild.

		/// </summary>

		public void ResumeMSBuild(string config, IVsOutputWindowPane output, string target)

		{

			this.suspendMSBuildCounter--;



			if(this.suspendMSBuildCounter == 0 && this.invokeMSBuildWhenResumed)

			{

				try

				{

					this.Build(config, output, target);

				}

				finally

				{

					this.invokeMSBuildWhenResumed = false;

				}

			}

		}



		/// <summary>

		/// Resumes MSBuild.

		/// </summary>

		public void ResumeMSBuild(string config, string target)

		{

			this.ResumeMSBuild(config, null, target);

		}



		/// <summary>

		/// Resumes MSBuild.

		/// </summary>

		public void ResumeMSBuild(string target)

		{

			this.ResumeMSBuild(String.Empty, null, target);

		}



		/// <summary>

		/// Calls MSBuild if it is not suspended. If it is suspended then it will remeber to call when msbuild is resumed.

		/// </summary>

		public MSBuildResult CallMSBuild(string config, IVsOutputWindowPane output, string target)

		{

			if(this.suspendMSBuildCounter > 0)

			{

				// remember to invoke MSBuild

				this.invokeMSBuildWhenResumed = true;

				return MSBuildResult.Suspended;

			}

			else

			{

				return this.Build(config, output, target);

			}

		}



		/// <summary>

		/// Overloaded method. Calls MSBuild if it is not suspended. Does not log on the outputwindow. If it is suspended then it will remeber to call when msbuild is resumed.

		/// </summary>

		public MSBuildResult CallMSBuild(string config, string target)

		{

			return this.CallMSBuild(config, null, target);

		}



		/// <summary>

		/// Calls MSBuild if it is not suspended. Does not log and uses current configuration. If it is suspended then it will remeber to call when msbuild is resumed.

		/// </summary>

		public MSBuildResult CallMSBuild(string target)

		{

			return this.CallMSBuild(String.Empty, null, target);

		}



		/// <summary>

		/// Calls MSBuild if it is not suspended. Uses current configuration. If it is suspended then it will remeber to call when msbuild is resumed.

		/// </summary>

		public MSBuildResult CallMSBuild(string target, IVsOutputWindowPane output)

		{

			return this.CallMSBuild(String.Empty, output, target);

		}



		/// <summary>

		/// Overloaded method to invoke MSBuild

		/// </summary>

		public MSBuildResult Build(string config, IVsOutputWindowPane output, string target)

		{

			return this.Build(0, config, output, target);

		}



		/// <summary>

		/// Overloaded method to invoke MSBuild. Does not log build results to the output window pane.

		/// </summary>

		public MSBuildResult Build(string config, string target)

		{

			return this.Build(0, config, null, target);

		}



		/// <summary>

		/// Overloaded method. Invokes MSBuild using the default configuration and does without logging on the output window pane.

		/// </summary>

		public MSBuildResult Build(string target)

		{

			return this.Build(0, String.Empty, null, target);

		}



		/// <summary>

		/// Overloaded method. Invokes MSBuild using the default configuration.

		/// </summary>

		public MSBuildResult Build(string target, IVsOutputWindowPane output)

		{

			return this.Build(0, String.Empty, output, target);

		}



		/// <summary>

		/// Get the output path for a specific configuration name

		/// </summary>

		/// <param name="config">name of configuration</param>

		/// <returns>Output path</returns>

		public string GetOutputPath(string config)

		{

			this.SetConfiguration(config);

			MSBuild.BuildPropertyGroup properties = this.buildProject.EvaluatedProperties;



			return this.GetOutputPath(properties);

		}



		/// <summary>

		/// Get value of Project property

		/// </summary>

		/// <param name="propertyName">Name of Property to retrieve</param>

		/// <returns>Value of property</returns>

		public string GetProjectProperty(string propertyName)

		{

			return this.GetProjectProperty(propertyName, true);

		}



		/// <summary>

		/// Set dirty state of project

		/// </summary>

		/// <param name="value">boolean value indicating dirty state</param>

		public void SetProjectFileDirty(bool value)

		{

			this.options = null;

			this.isDirty = value;

			if(this.isDirty)

			{

				this.lastModifiedTime = DateTime.Now;

				this.buildIsPrepared = false;

			}

		}



		/// <summary>

		/// Get output assembly for a specific configuration name

		/// </summary>

		/// <param name="config">Name of configuration</param>

		/// <returns>Name of output assembly</returns>

		public string GetOutputAssembly(string config)

		{

			ProjectOptions options = this.GetProjectOptions(config);



			return options.OutputAssembly;

		}



		/// <summary>

		/// Get Node from ItemID.

		/// </summary>

		/// <param name="itemId">ItemID for the requested node</param>

		/// <returns>Node if found</returns>

		public HierarchyNode NodeFromItemId(uint itemId)

		{

			if(VSConstants.VSITEMID_ROOT == itemId)

			{

				return this;

			}

			else if(VSConstants.VSITEMID_NIL == itemId)

			{

				return null;

			}

			else if(VSConstants.VSITEMID_SELECTION == itemId)

			{

				throw new NotImplementedException();

			}



			return (HierarchyNode)this.ItemIdMap[itemId];

		}



		/// <summary>

		/// This method return new project element, and add new MSBuild item to the project/build hierarchy

		/// </summary>

		/// <param name="file">file name</param>

		/// <param name="itemType">MSBuild item type</param>

		/// <returns>new project element</returns>

		[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Ms")]

		public ProjectElement CreateMsBuildFileItem(string file, string itemType)

		{

			return new ProjectElement(this, file, itemType);

		}



		/// <summary>

		/// This method returns new project element based on existing MSBuild item. It does not modify/add project/build hierarchy at all.

		/// </summary>

		/// <param name="item">MSBuild item instance</param>

		/// <returns>wrapping project element</returns>

		public ProjectElement GetProjectElement(MSBuild.BuildItem item)

		{

			return new ProjectElement(this, item, false);

		}



		/// <summary>

		/// Create FolderNode from Path

		/// </summary>

		/// <param name="path">Path to folder</param>

		/// <returns>FolderNode created that can be added to the hierarchy</returns>

		protected internal FolderNode CreateFolderNode(string path)

		{

			ProjectElement item = this.AddFolderToMsBuild(path);

			FolderNode folderNode = CreateFolderNode(path, item);

			return folderNode;

		}



		/// <summary>

		/// Verify if the file can be written to.

		/// Return false if the file is read only and/or not checked out

		/// and the user did not give permission to change it.

		/// Note that exact behavior can also be affected based on the SCC

		/// settings under Tools->Options.

		/// </summary>

		internal bool QueryEditProjectFile(bool suppressUI)

		{

			bool result = true;

			if(this.site == null)

			{

				// We're already zombied. Better return FALSE.

				result = false;

			}

			else if(this.disableQueryEdit)

			{

				return true;

			}

			else

			{

				IVsQueryEditQuerySave2 queryEditQuerySave = this.GetService(typeof(SVsQueryEditQuerySave)) as IVsQueryEditQuerySave2;

				if(queryEditQuerySave != null)

				{   // Project path dependends on server/client project

					string path = this.filename;



					tagVSQueryEditFlags qef = tagVSQueryEditFlags.QEF_AllowInMemoryEdits;

					if(suppressUI)

						qef |= tagVSQueryEditFlags.QEF_SilentMode;



					// If we are debugging, we want to prevent our project from being reloaded. To 

					// do this, we pass the QEF_NoReload flag

					if(!Utilities.IsVisualStudioInDesignMode(this.Site))

						qef |= tagVSQueryEditFlags.QEF_NoReload;



					uint verdict;

					uint moreInfo;

					string[] files = new string[1];

					files[0] = path;

					uint[] flags = new uint[1];

					VSQEQS_FILE_ATTRIBUTE_DATA[] attributes = new VSQEQS_FILE_ATTRIBUTE_DATA[1];

					int hr = queryEditQuerySave.QueryEditFiles(

									(uint)qef,

									1, // 1 file

									files, // array of files

									flags, // no per file flags

									attributes, // no per file file attributes

									out verdict,

									out moreInfo /* ignore additional results */);



					tagVSQueryEditResult qer = (tagVSQueryEditResult)verdict;

					if(ErrorHandler.Failed(hr) || (qer != tagVSQueryEditResult.QER_EditOK))

					{

						if(!suppressUI && !Utilities.IsInAutomationFunction(this.Site))

						{

							string message = SR.GetString(SR.CancelQueryEdit, path);

							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);

						}

						result = false;

					}

				}

			}

			return result;

		}



		/// <summary>

		/// Checks whether a hierarchy is a nested project.

		/// </summary>

		/// <param name="hierarchy"></param>

		/// <returns></returns>

		internal NestedProjectNode GetNestedProjectForHierarchy(IVsHierarchy hierarchy)

		{

			IVsProject3 project = hierarchy as IVsProject3;



			if(project != null)

			{

				string mkDocument = String.Empty;

				ErrorHandler.ThrowOnFailure(project.GetMkDocument(VSConstants.VSITEMID_ROOT, out mkDocument));



				if(!String.IsNullOrEmpty(mkDocument))

				{

					HierarchyNode node = this.FindChild(mkDocument);



					return node as NestedProjectNode;

				}

			}



			return null;

		}



		/// <summary>

		/// Given a node determines what is the directory that can accept files.

		/// If the node is a FoldeNode than it is the Url of the Folder.

		/// If the node is a ProjectNode it is the project folder.

		/// Otherwise (such as FileNode subitem) it delegate the resolution to the parent node.

		/// </summary>

		internal string GetBaseDirectoryForAddingFiles(HierarchyNode nodeToAddFile)

		{

			string baseDir = String.Empty;



			if(nodeToAddFile is FolderNode)

			{

				baseDir = nodeToAddFile.Url;

			}

			else if(nodeToAddFile is ProjectNode)

			{

				baseDir = this.ProjectFolder;

			}

			else if(nodeToAddFile != null)

			{

				baseDir = GetBaseDirectoryForAddingFiles(nodeToAddFile.Parent);

			}



			return baseDir;

		}



		/// <summary>

		/// For internal use only.

		/// This creates a copy of an existing configuration and add it to the project.

		/// Caller should change the condition on the PropertyGroup.

		/// If derived class want to accomplish this, they should call ConfigProvider.AddCfgsOfCfgName()

		/// It is expected that in the future MSBuild will have support for this so we don't have to

		/// do it manually.

		/// </summary>

		/// <param name="group">PropertyGroup to clone</param>

		/// <returns></returns>

		internal MSBuild.BuildPropertyGroup ClonePropertyGroup(MSBuild.BuildPropertyGroup group)

		{

			// Create a new (empty) PropertyGroup

			MSBuild.BuildPropertyGroup newPropertyGroup = this.buildProject.AddNewPropertyGroup(false);



			// Now copy everything from the group we are trying to clone to the group we are creating

			if(!String.IsNullOrEmpty(group.Condition))

				newPropertyGroup.Condition = group.Condition;

			foreach(MSBuild.BuildProperty prop in group)

			{

				MSBuild.BuildProperty newProperty = newPropertyGroup.AddNewProperty(prop.Name, prop.Value);

				if(!String.IsNullOrEmpty(prop.Condition))

					newProperty.Condition = prop.Condition;

			}



			return newPropertyGroup;

		}



		/// <summary>

		/// Register the project with the Scc manager.

		/// </summary>

		[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Scc")]

		protected void RegisterSccProject()

		{



			if(this.IsSccDisabled || this.isRegisteredWithScc || String.IsNullOrEmpty(this.sccProjectName))

			{

				return;

			}



			IVsSccManager2 sccManager = this.Site.GetService(typeof(SVsSccManager)) as IVsSccManager2;



			if(sccManager != null)

			{

				ErrorHandler.ThrowOnFailure(sccManager.RegisterSccProject(this, this.sccProjectName, this.sccAuxPath, this.sccLocalPath, this.sccProvider));



				this.isRegisteredWithScc = true;

			}

		}



		/// <summary>

		///  Unregisters us from the SCC manager

		/// </summary>

		[SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "UnRegister")]

		[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Un")]

		protected void UnRegisterProject()

		{

			if(this.IsSccDisabled || !this.isRegisteredWithScc)

			{

				return;

			}



			IVsSccManager2 sccManager = this.Site.GetService(typeof(SVsSccManager)) as IVsSccManager2;



			if(sccManager != null)

			{

				ErrorHandler.ThrowOnFailure(sccManager.UnregisterSccProject(this));

				this.isRegisteredWithScc = false;

			}

		}



		/// <summary>

		/// Get the CATID corresponding to the specified type.

		/// </summary>

		/// <param name="type">Type of the object for which you want the CATID</param>

		/// <returns>CATID</returns>

		[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "CATID")]

		protected internal Guid GetCATIDForType(Type type)

		{

			if(type == null)

				throw new ArgumentNullException("type");



			if(catidMapping.ContainsKey(type))

				return catidMapping[type];

			// If you get here and you want your object to be extensible, then add a call to AddCATIDMapping() in your project constructor

			return Guid.Empty;

		}



		/// <summary>

		/// This is used to specify a CATID corresponding to a BrowseObject or an ExtObject.

		/// The CATID can be any GUID you choose. For types which are your owns, you could use

		/// their type GUID, while for other types (such as those provided in the MPF) you should

		/// provide a different GUID.

		/// </summary>

		/// <param name="type">Type of the extensible object</param>

		/// <param name="catid">GUID that extender can use to uniquely identify your object type</param>

		[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "catid")]

		[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "CATID")]

		protected void AddCATIDMapping(Type type, Guid catid)

		{

			catidMapping.Add(type, catid);

		}



		/// <summary>

		/// Initialize an object with an XML fragment.

		/// </summary>

		/// <param name="iPersistXMLFragment">Object that support being initialized with an XML fragment</param>

		/// <param name="configName">Name of the configuration being initialized, null if it is the project</param>

		protected internal void LoadXmlFragment(IPersistXMLFragment persistXmlFragment, string configName)

		{

			if(xmlFragments == null)

			{

				// Retrieve the xml fragments from MSBuild

				xmlFragments = new XmlDocument();

				string fragments = this.BuildProject.GetProjectExtensions(ProjectFileConstants.VisualStudio);

				fragments = String.Format(CultureInfo.InvariantCulture, "<root>{0}</root>", fragments);

				xmlFragments.LoadXml(fragments);

			}



			// We need to loop through all the flavors

			string flavorsGuid;

			ErrorHandler.ThrowOnFailure(((IVsAggregatableProject)this).GetAggregateProjectTypeGuids(out flavorsGuid));

			foreach(Guid flavor in Utilities.GuidsArrayFromSemicolonDelimitedStringOfGuids(flavorsGuid))

			{

				// Look for a matching fragment

				string flavorGuidString = flavor.ToString("B");

				string fragment = null;

				XmlNode node = null;

				foreach(XmlNode child in xmlFragments.FirstChild.ChildNodes)

				{

					if(child.Attributes.Count > 0)

					{

						string guid = String.Empty;

						string configuration = String.Empty;

						if(child.Attributes[ProjectFileConstants.Guid] != null)

							guid = child.Attributes[ProjectFileConstants.Guid].Value;

						if(child.Attributes[ProjectFileConstants.Configuration] != null)

							configuration = child.Attributes[ProjectFileConstants.Configuration].Value;



						if(String.Compare(child.Name, ProjectFileConstants.FlavorProperties, StringComparison.OrdinalIgnoreCase) == 0

								&& String.Compare(guid, flavorGuidString, StringComparison.OrdinalIgnoreCase) == 0

								&& ((String.IsNullOrEmpty(configName) && String.IsNullOrEmpty(configuration))

									|| (String.Compare(configuration, configName, StringComparison.OrdinalIgnoreCase) == 0)))

						{

							// we found the matching fragment

							fragment = child.InnerXml;

							node = child;

							break;

						}

					}

				}



				Guid flavorGuid = flavor;

				if(String.IsNullOrEmpty(fragment))

				{

					// the fragment was not found so init with default values

					ErrorHandler.ThrowOnFailure(persistXmlFragment.InitNew(ref flavorGuid, (uint)_PersistStorageType.PST_PROJECT_FILE));

					// While we don't yet support user files, our flavors might, so we will store that in the project file until then

					// TODO: Refactor this code when we support user files

					ErrorHandler.ThrowOnFailure(persistXmlFragment.InitNew(ref flavorGuid, (uint)_PersistStorageType.PST_USER_FILE));

				}

				else

				{

					ErrorHandler.ThrowOnFailure(persistXmlFragment.Load(ref flavorGuid, (uint)_PersistStorageType.PST_PROJECT_FILE, fragment));

					// While we don't yet support user files, our flavors might, so we will store that in the project file until then

					// TODO: Refactor this code when we support user files

					if(node.NextSibling != null && node.NextSibling.Attributes[ProjectFileConstants.User] != null)

						ErrorHandler.ThrowOnFailure(persistXmlFragment.Load(ref flavorGuid, (uint)_PersistStorageType.PST_USER_FILE, node.NextSibling.InnerXml));

				}

			}

		}



		/// <summary>

		/// Retrieve all XML fragments that need to be saved from the flavors and store the information in msbuild.

		/// </summary>

		[SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "XML")]

		protected void PersistXMLFragments()

		{

			if(this.IsFlavorDirty() != 0)

			{

				XmlDocument doc = new XmlDocument();

				XmlElement root = doc.CreateElement("ROOT");



				// We will need the list of configuration inside the loop, so get it before entering the loop

				uint[] count = new uint[1];

				IVsCfg[] configs = null;

				int hr = this.ConfigProvider.GetCfgs(0, null, count, null);

				if(ErrorHandler.Succeeded(hr) && count[0] > 0)

				{

					configs = new IVsCfg[count[0]];

					hr = this.ConfigProvider.GetCfgs((uint)configs.Length, configs, count, null);

					if(ErrorHandler.Failed(hr))

						count[0] = 0;

				}

				if(count[0] == 0)

					configs = new IVsCfg[0];



				// We need to loop through all the flavors

				string flavorsGuid;

				ErrorHandler.ThrowOnFailure(((IVsAggregatableProject)this).GetAggregateProjectTypeGuids(out flavorsGuid));

				foreach(Guid flavor in Utilities.GuidsArrayFromSemicolonDelimitedStringOfGuids(flavorsGuid))

				{

					IPersistXMLFragment outerHierarchy = HierarchyNode.GetOuterHierarchy(this) as IPersistXMLFragment;

					// First check the project

					if(outerHierarchy != null)

					{

						// Retrieve the XML fragment

						string fragment = string.Empty;

						Guid flavorGuid = flavor;

						ErrorHandler.ThrowOnFailure((outerHierarchy).Save(ref flavorGuid, (uint)_PersistStorageType.PST_PROJECT_FILE, out fragment, 1));

						if(!String.IsNullOrEmpty(fragment))

						{

							// Add the fragment to our XML

							WrapXmlFragment(doc, root, flavor, null, fragment);

						}

						// While we don't yet support user files, our flavors might, so we will store that in the project file until then

						// TODO: Refactor this code when we support user files

						fragment = String.Empty;

						ErrorHandler.ThrowOnFailure((outerHierarchy).Save(ref flavorGuid, (uint)_PersistStorageType.PST_USER_FILE, out fragment, 1));

						if(!String.IsNullOrEmpty(fragment))

						{

							// Add the fragment to our XML

							XmlElement node = WrapXmlFragment(doc, root, flavor, null, fragment);

							node.Attributes.Append(doc.CreateAttribute(ProjectFileConstants.User));

						}

					}



					// Then look at the configurations

					foreach(IVsCfg config in configs)

					{

						// Get the fragment for this flavor/config pair

						string fragment;

						ErrorHandler.ThrowOnFailure(((ProjectConfig)config).GetXmlFragment(flavor, _PersistStorageType.PST_PROJECT_FILE, out fragment));

						if(!String.IsNullOrEmpty(fragment))

						{

							string configName;

							ErrorHandler.ThrowOnFailure(config.get_DisplayName(out configName));

							WrapXmlFragment(doc, root, flavor, configName, fragment);

						}

					}

				}

				if(root.ChildNodes != null && root.ChildNodes.Count > 0)

				{

					// Save our XML (this is only the non-build information for each flavor) in msbuild

					this.BuildProject.SetProjectExtensions(ProjectFileConstants.VisualStudio, root.InnerXml.ToString());

				}

			}

		}



		#endregion



		#region IVsGetCfgProvider Members

		//=================================================================================



		public virtual int GetCfgProvider(out IVsCfgProvider p)

		{

			CCITracing.TraceCall();

			// Be sure to call the property here since that is doing a polymorhic ProjectConfig creation.

			p = this.ConfigProvider;

			return (p == null ? VSConstants.E_NOTIMPL : VSConstants.S_OK);

		}

		#endregion



		#region IPersist Members



		public int GetClassID(out Guid clsid)

		{

			clsid = this.ProjectGuid;

			return VSConstants.S_OK;

		}

		#endregion



		#region IPersistFileFormat Members



		int IPersistFileFormat.GetClassID(out Guid clsid)

		{

			clsid = this.ProjectGuid;

			return VSConstants.S_OK;

		}



		public virtual int GetCurFile(out string name, out uint formatIndex)

		{

			name = this.filename;

			formatIndex = 0;

			return VSConstants.S_OK;

		}



		public virtual int GetFormatList(out string formatlist)

		{

			formatlist = String.Empty;

			return VSConstants.S_OK;

		}



		public virtual int InitNew(uint formatIndex)

		{

			return VSConstants.S_OK;

		}



		public virtual int IsDirty(out int isDirty)

		{

			isDirty = 0;

			if(this.buildProject.IsDirty || this.IsProjectFileDirty)

			{

				isDirty = 1;

				return VSConstants.S_OK;

			}



			isDirty = IsFlavorDirty();



			return VSConstants.S_OK;

		}



		protected int IsFlavorDirty()

		{

			int isDirty = 0;

			// See if one of our flavor consider us dirty

			IPersistXMLFragment outerHierarchy = HierarchyNode.GetOuterHierarchy(this) as IPersistXMLFragment;

			if(outerHierarchy != null)

			{

				// First check the project

				ErrorHandler.ThrowOnFailure(outerHierarchy.IsFragmentDirty((uint)_PersistStorageType.PST_PROJECT_FILE, out isDirty));

				// While we don't yet support user files, our flavors might, so we will store that in the project file until then

				// TODO: Refactor this code when we support user files

				if(isDirty == 0)

					ErrorHandler.ThrowOnFailure(outerHierarchy.IsFragmentDirty((uint)_PersistStorageType.PST_USER_FILE, out isDirty));

			}

			if(isDirty == 0)

			{

				// Then look at the configurations

				uint[] count = new uint[1];

				int hr = this.ConfigProvider.GetCfgs(0, null, count, null);

				if(ErrorHandler.Succeeded(hr) && count[0] > 0)

				{

					// We need to loop through the configurations

					IVsCfg[] configs = new IVsCfg[count[0]];

					hr = this.ConfigProvider.GetCfgs((uint)configs.Length, configs, count, null);

					Debug.Assert(ErrorHandler.Succeeded(hr), "failed to retrieve configurations");

					foreach(IVsCfg config in configs)

					{

						isDirty = ((ProjectConfig)config).IsFlavorDirty(_PersistStorageType.PST_PROJECT_FILE);

						if(isDirty != 0)

							break;

					}

				}

			}

			return isDirty;

		}



		public virtual int Load(string fileName, uint mode, int readOnly)

		{

			this.filename = fileName;

			this.Reload();

			return VSConstants.S_OK;

		}



		public virtual int Save(string fileToBeSaved, int remember, uint formatIndex)

		{



			// The file name can be null. Then try to use the Url.

			string tempFileToBeSaved = fileToBeSaved;

			if(String.IsNullOrEmpty(tempFileToBeSaved) && !String.IsNullOrEmpty(this.Url))

			{

				tempFileToBeSaved = this.Url;

			}



			if(String.IsNullOrEmpty(tempFileToBeSaved))

			{

				throw new ArgumentException(SR.GetString(SR.InvalidParameter, CultureInfo.CurrentUICulture), "fileToBeSaved");

			}



			bool setProjectFileDirtyAfterSave = false;

			if(remember == 0)

			{

				setProjectFileDirtyAfterSave = this.IsProjectFileDirty;

			}



			// Update the project with the latest flavor data (if needed)

			PersistXMLFragments();



			int result = VSConstants.S_OK;

			bool saveAs = true;

			if(NativeMethods.IsSamePath(tempFileToBeSaved, this.filename))

			{

				saveAs = false;

			}

			if(!saveAs)

			{

				SuspendFileChanges fileChanges = new SuspendFileChanges(this.Site, this.filename);

				fileChanges.Suspend();

				try

				{

					this.buildProject.Save(tempFileToBeSaved);

					this.SetProjectFileDirty(false);

				}

				finally

				{

					fileChanges.Resume();

				}

			}

			else

			{

				result = this.SaveAs(tempFileToBeSaved);

				if(result != VSConstants.OLE_E_PROMPTSAVECANCELLED)

				{

					ErrorHandler.ThrowOnFailure(result);

				}



			}



			if(setProjectFileDirtyAfterSave)

			{

				this.SetProjectFileDirty(true);

			}



			return result;

		}



		public virtual int SaveCompleted(string filename)

		{

			// TODO: turn file watcher back on.

			return VSConstants.S_OK;

		}

		#endregion



		#region IVsProject3 Members



		/// <summary>

		/// Callback from the additem dialog. Deals with adding new and existing items

		/// </summary>

		public virtual int GetMkDocument(uint itemId, out string mkDoc)

		{

			mkDoc = null;

			if(itemId == VSConstants.VSITEMID_SELECTION)

			{

				return VSConstants.E_UNEXPECTED;

			}



			HierarchyNode n = this.NodeFromItemId(itemId);

			if(n == null)

			{

				return VSConstants.E_INVALIDARG;

			}



			mkDoc = n.GetMkDocument();



			if(String.IsNullOrEmpty(mkDoc))

			{

				return VSConstants.E_FAIL;

			}



			return VSConstants.S_OK;

		}





		public virtual int AddItem(uint itemIdLoc, VSADDITEMOPERATION op, string itemName, uint filesToOpen, string[] files, IntPtr dlgOwner, VSADDRESULT[] result)

		{

			Guid empty = Guid.Empty;



			return AddItemWithSpecific(itemIdLoc, op, itemName, filesToOpen, files, dlgOwner, 0, ref empty, null, ref empty, result);

		}



		/// <summary>

		/// Creates new items in a project, adds existing files to a project, or causes Add Item wizards to be run

		/// </summary>

		/// <param name="itemIdLoc"></param>

		/// <param name="op"></param>

		/// <param name="itemName"></param>

		/// <param name="filesToOpen"></param>

		/// <param name="files">Array of file names. 

		/// If dwAddItemOperation is VSADDITEMOP_CLONEFILE the first item in the array is the name of the file to clone. 

		/// If dwAddItemOperation is VSADDITEMOP_OPENDIRECTORY, the first item in the array is the directory to open. 

		/// If dwAddItemOperation is VSADDITEMOP_RUNWIZARD, the first item is the name of the wizard to run, 

		/// and the second item is the file name the user supplied (same as itemName).</param>

		/// <param name="dlgOwner"></param>

		/// <param name="editorFlags"></param>

		/// <param name="editorType"></param>

		/// <param name="physicalView"></param>

		/// <param name="logicalView"></param>

		/// <param name="result"></param>

		/// <returns>S_OK if it succeeds </returns>

		/// <remarks>The result array is initalized to failure.</remarks>

		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling"), System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")]

		public virtual int AddItemWithSpecific(uint itemIdLoc, VSADDITEMOPERATION op, string itemName, uint filesToOpen, string[] files, IntPtr dlgOwner, uint editorFlags, ref Guid editorType, string physicalView, ref Guid logicalView, VSADDRESULT[] result)

		{

			if(files == null || result == null || files.Length == 0 || result.Length == 0)

			{

				return VSConstants.E_INVALIDARG;

			}



			// Locate the node to be the container node for the file(s) being added

			// only projectnode or foldernode and file nodes are valid container nodes

			// We need to locate the parent since the item wizard expects the parent to be passed.

			HierarchyNode n = this.NodeFromItemId(itemIdLoc);

			if(n == null)

			{

				return VSConstants.E_INVALIDARG;

			}



			while((!(n is ProjectNode)) && (!(n is FolderNode)) && (!this.CanFileNodesHaveChilds || !(n is FileNode)))

			{

				n = n.Parent;

			}

			Debug.Assert(n != null, "We should at this point have either a ProjectNode or FolderNode or a FileNode as a container for the new filenodes");



			// handle link and runwizard operations at this point

			switch(op)

			{

				case VSADDITEMOPERATION.VSADDITEMOP_LINKTOFILE:

					// we do not support this right now

					throw new NotImplementedException("VSADDITEMOP_LINKTOFILE");



				case VSADDITEMOPERATION.VSADDITEMOP_RUNWIZARD:

					result[0] = this.RunWizard(n, itemName, files[0], dlgOwner);

					return VSConstants.S_OK;

			}



			string[] actualFiles = new string[files.Length];





			VSQUERYADDFILEFLAGS[] flags = this.GetQueryAddFileFlags(files);



			string baseDir = this.GetBaseDirectoryForAddingFiles(n);

			// If we did not get a directory for node that is the parent of the item then fail.

			if(String.IsNullOrEmpty(baseDir))

			{

				return VSConstants.E_FAIL;

			}



			// Pre-calculates some paths that we can use when calling CanAddItems

			List<string> filesToAdd = new List<string>();

			for(int index = 0; index < files.Length; index++)

			{

				string newFileName = String.Empty;



				string file = files[index];



				switch(op)

				{

					case VSADDITEMOPERATION.VSADDITEMOP_CLONEFILE:

						// New item added. Need to copy template to new location and then add new location 

						newFileName = Path.Combine(baseDir, itemName);

						break;



					case VSADDITEMOPERATION.VSADDITEMOP_OPENFILE:

						{

							string fileName = Path.GetFileName(file);

							newFileName = Path.Combine(baseDir, fileName);

						}

						break;

				}

				filesToAdd.Add(newFileName);

			}



			// Ask tracker objects if we can add files

			if(!this.tracker.CanAddItems(filesToAdd.ToArray(), flags))

			{

				// We were not allowed to add the files

				return VSConstants.E_FAIL;

			}



			if(!this.ProjectMgr.QueryEditProjectFile(false))

			{

				throw Marshal.GetExceptionForHR(VSConstants.OLE_E_PROMPTSAVECANCELLED);

			}



			// Add the files to the hierarchy

			int actualFilesAddedIndex = 0;

			for(int index = 0; index < filesToAdd.Count; index++)

			{

				HierarchyNode child;

				bool overwrite = false;

				string newFileName = filesToAdd[index];



				string file = files[index];

				result[0] = VSADDRESULT.ADDRESULT_Failure;



				child = this.FindChild(newFileName);

				if(child != null)

				{

					// If the file to be added is an existing file part of the hierarchy then continue.

					if(NativeMethods.IsSamePath(file, newFileName))

					{

						result[0] = VSADDRESULT.ADDRESULT_Cancel;

						continue;

					}



					int canOverWriteExistingItem = this.CanOverwriteExistingItem(file, newFileName);



					if(canOverWriteExistingItem == (int)OleConstants.OLECMDERR_E_CANCELED)

					{

						result[0] = VSADDRESULT.ADDRESULT_Cancel;

						return canOverWriteExistingItem;

					}

					else if(canOverWriteExistingItem == VSConstants.S_OK)

					{

						overwrite = true;

					}

					else

					{

						return canOverWriteExistingItem;

					}

				}



				// If the file to be added is not in the same path copy it.

				if(NativeMethods.IsSamePath(file, newFileName) == false)

				{

					if(!overwrite && File.Exists(newFileName))

					{

						string message = String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.FileAlreadyExists, CultureInfo.CurrentUICulture), newFileName);

						string title = string.Empty;

						OLEMSGICON icon = OLEMSGICON.OLEMSGICON_QUERY;

						OLEMSGBUTTON buttons = OLEMSGBUTTON.OLEMSGBUTTON_YESNO;

						OLEMSGDEFBUTTON defaultButton = OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST;

						int messageboxResult = VsShellUtilities.ShowMessageBox(this.Site, title, message, icon, buttons, defaultButton);

						if(messageboxResult == NativeMethods.IDNO)

						{

							result[0] = VSADDRESULT.ADDRESULT_Cancel;

							return (int)OleConstants.OLECMDERR_E_CANCELED;

						}

					}



					// Copy the file to the correct location.

					// We will suppress the file change events to be triggered to this item, since we are going to copy over the existing file and thus we will trigger a file change event. 

					// We do not want the filechange event to ocur in this case, similar that we do not want a file change event to occur when saving a file.

					IVsFileChangeEx fileChange = this.site.GetService(typeof(SVsFileChangeEx)) as IVsFileChangeEx;

					if(fileChange == null)

					{

						throw new InvalidOperationException();

					}



					try

					{

						ErrorHandler.ThrowOnFailure(fileChange.IgnoreFile(VSConstants.VSCOOKIE_NIL, newFileName, 1));

						if(op == VSADDITEMOPERATION.VSADDITEMOP_CLONEFILE)

						{

							this.AddFileFromTemplate(file, newFileName);

						}

						else

						{

							PackageUtilities.CopyUrlToLocal(new Uri(file), newFileName);

						}

					}

					finally

					{

						ErrorHandler.ThrowOnFailure(fileChange.IgnoreFile(VSConstants.VSCOOKIE_NIL, newFileName, 0));

					}

				}



				if(overwrite)

				{

					this.OverwriteExistingItem(child);

				}

				else

				{

					//Add new filenode/dependentfilenode

					this.AddNewFileNodeToHierarchy(n, newFileName);

				}



				result[0] = VSADDRESULT.ADDRESULT_Success;

				actualFiles[actualFilesAddedIndex++] = newFileName;

			}



			// Notify listeners that items were appended.

			if(actualFilesAddedIndex > 0)

				n.OnItemsAppended(n);



			//Open files if this was requested through the editorFlags

			bool openFiles = (editorFlags & (uint)__VSSPECIFICEDITORFLAGS.VSSPECIFICEDITOR_DoOpen) != 0;

			if(openFiles && actualFiles.Length <= filesToOpen)

			{

				for(int i = 0; i < filesToOpen; i++)

				{

					if(!String.IsNullOrEmpty(actualFiles[i]))

					{

						string name = actualFiles[i];

						HierarchyNode child = this.FindChild(name);

						Debug.Assert(child != null, "We should have been able to find the new element in the hierarchy");

						if(child != null)

						{

							IVsWindowFrame frame;

							if(editorType == Guid.Empty)

							{

								Guid view = Guid.Empty;

								ErrorHandler.ThrowOnFailure(this.OpenItem(child.ID, ref view, IntPtr.Zero, out frame));

							}

							else

							{

								ErrorHandler.ThrowOnFailure(this.OpenItemWithSpecific(child.ID, editorFlags, ref editorType, physicalView, ref logicalView, IntPtr.Zero, out frame));

							}



							// Show the window frame in the UI and make it the active window

							if(frame != null)

							{

								ErrorHandler.ThrowOnFailure(frame.Show());

							}

						}

					}

				}

			}



			return VSConstants.S_OK;

		}



		/// <summary>

		/// for now used by add folder. Called on the ROOT, as only the project should need

		/// to implement this.

		/// for folders, called with parent folder, blank extension and blank suggested root

		/// </summary>

		public virtual int GenerateUniqueItemName(uint itemIdLoc, string ext, string suggestedRoot, out string itemName)

		{

			string rootName = "";

			string extToUse;

			int cb = 1;//force new items to have a number

			bool found = false;

			bool fFolderCase = false;

			HierarchyNode parent = this.NodeFromItemId(itemIdLoc);



			extToUse = ext.Trim();

			suggestedRoot = suggestedRoot.Trim();

			if(suggestedRoot.Length == 0)

			{

				// foldercase, we assume... 

				suggestedRoot = "NewFolder";

				fFolderCase = true;

			}



			while(!found)

			{

				rootName = suggestedRoot;

				if(cb > 0)

					rootName += cb.ToString(CultureInfo.CurrentCulture);



				if(extToUse.Length > 0)

				{

					rootName += extToUse;

				}



				cb++;

				found = true;

				for(HierarchyNode n = parent.FirstChild; n != null; n = n.NextSibling)

				{

					if(rootName == n.GetEditLabel())

					{

						found = false;

						break;

					}



					//if parent is a folder, we need the whole url

					string parentFolder = parent.Url;

					if(parent is ProjectNode)

						parentFolder = Path.GetDirectoryName(parent.Url);



					string checkFile = Path.Combine(parentFolder, rootName);



					if(fFolderCase)

					{

						if(Directory.Exists(checkFile))

						{

							found = false;

							break;

						}

					}

					else

					{

						if(File.Exists(checkFile))

						{

							found = false;

							break;

						}

					}

				}

			}



			itemName = rootName;

			return VSConstants.S_OK;

		}





		public virtual int GetItemContext(uint itemId, out Microsoft.VisualStudio.OLE.Interop.IServiceProvider psp)

		{

			CCITracing.TraceCall();

			psp = null;

			HierarchyNode child = this.NodeFromItemId(itemId);

			if(child != null)

			{

				psp = child.OleServiceProvider as IOleServiceProvider;

			}

			return VSConstants.S_OK;

		}





		public virtual int IsDocumentInProject(string mkDoc, out int found, VSDOCUMENTPRIORITY[] pri, out uint itemId)

		{

			CCITracing.TraceCall();

			if(pri != null && pri.Length >= 1)

			{

				pri[0] = VSDOCUMENTPRIORITY.DP_Unsupported;

			}

			found = 0;

			itemId = 0;



			// If it is the project file just return.

			if(NativeMethods.IsSamePath(mkDoc, this.GetMkDocument()))

			{

				found = 1;

				itemId = VSConstants.VSITEMID_ROOT;

			}

			else

			{

				HierarchyNode child = this.FindChild(mkDoc);

				if(child != null)

				{

					found = 1;

					itemId = child.ID;

				}

			}



			if(found == 1)

			{

				if(pri != null && pri.Length >= 1)

				{

					pri[0] = VSDOCUMENTPRIORITY.DP_Standard;

				}

			}



			return VSConstants.S_OK;



		}





		public virtual int OpenItem(uint itemId, ref Guid logicalView, IntPtr punkDocDataExisting, out IVsWindowFrame frame)

		{

			// Init output params

			frame = null;



			HierarchyNode n = this.NodeFromItemId(itemId);

			if(n == null)

			{

				throw new ArgumentException(SR.GetString(SR.ParameterMustBeAValidItemId, CultureInfo.CurrentUICulture), "itemId");

			}



			// Delegate to the document manager object that knows how to open the item

			DocumentManager documentManager = n.GetDocumentManager();

			if(documentManager != null)

			{

				return documentManager.Open(ref logicalView, punkDocDataExisting, out frame, WindowFrameShowAction.DoNotShow);

			}



			// This node does not have an associated document manager and we must fail

			return VSConstants.E_FAIL;

		}





		public virtual int OpenItemWithSpecific(uint itemId, uint editorFlags, ref Guid editorType, string physicalView, ref Guid logicalView, IntPtr docDataExisting, out IVsWindowFrame frame)

		{

			// Init output params

			frame = null;



			HierarchyNode n = this.NodeFromItemId(itemId);

			if(n == null)

			{

				throw new ArgumentException(SR.GetString(SR.ParameterMustBeAValidItemId, CultureInfo.CurrentUICulture), "itemId");

			}



			// Delegate to the document manager object that knows how to open the item

			DocumentManager documentManager = n.GetDocumentManager();

			if(documentManager != null)

			{

				return documentManager.OpenWithSpecific(editorFlags, ref editorType, physicalView, ref logicalView, docDataExisting, out frame, WindowFrameShowAction.DoNotShow);

			}



			// This node does not have an associated document manager and we must fail

			return VSConstants.E_FAIL;

		}





		public virtual int RemoveItem(uint reserved, uint itemId, out int result)

		{

			HierarchyNode n = this.NodeFromItemId(itemId);

			if(n == null)

			{

				throw new ArgumentException(SR.GetString(SR.ParameterMustBeAValidItemId, CultureInfo.CurrentUICulture), "itemId");

			}

			n.Remove(true);

			result = 1;

			return VSConstants.S_OK;

		}





		public virtual int ReopenItem(uint itemId, ref Guid editorType, string physicalView, ref Guid logicalView, IntPtr docDataExisting, out IVsWindowFrame frame)

		{

			// Init output params

			frame = null;



			HierarchyNode n = this.NodeFromItemId(itemId);

			if(n == null)

			{

				throw new ArgumentException(SR.GetString(SR.ParameterMustBeAValidItemId, CultureInfo.CurrentUICulture), "itemId");

			}



			// Delegate to the document manager object that knows how to open the item

			DocumentManager documentManager = n.GetDocumentManager();

			if(documentManager != null)

			{

				return documentManager.OpenWithSpecific(0, ref editorType, physicalView, ref logicalView, docDataExisting, out frame, WindowFrameShowAction.DoNotShow);

			}



			// This node does not have an associated document manager and we must fail

			return VSConstants.E_FAIL;

		}





		/// <summary>

		/// Implements IVsProject3::TransferItem

		/// This function is called when an open miscellaneous file is being transferred

		/// to our project. The sequence is for the shell to call AddItemWithSpecific and

		/// then use TransferItem to transfer the open document to our project.

		/// </summary>

		/// <param name="oldMkDoc">Old document name</param>

		/// <param name="newMkDoc">New document name</param>

		/// <param name="frame">Optional frame if the document is open</param>

		/// <returns></returns>

		public virtual int TransferItem(string oldMkDoc, string newMkDoc, IVsWindowFrame frame)

		{

			// Fail if hierarchy already closed

			if(this.ProjectMgr == null || this.ProjectMgr.IsClosed)

			{

				return VSConstants.E_FAIL;

			}

			//Fail if the document names passed are null.

			if(oldMkDoc == null || newMkDoc == null)

				return VSConstants.E_INVALIDARG;



			int hr = VSConstants.S_OK;

			VSDOCUMENTPRIORITY[] priority = new VSDOCUMENTPRIORITY[1];

			uint itemid = VSConstants.VSITEMID_NIL;

			uint cookie = 0;

			uint grfFlags = 0;



			IVsRunningDocumentTable pRdt = GetService(typeof(IVsRunningDocumentTable)) as IVsRunningDocumentTable;

			if(pRdt == null)

				return VSConstants.E_ABORT;



			string doc;

			int found;

			IVsHierarchy pHier;

			uint id, readLocks, editLocks;

			IntPtr docdataForCookiePtr = IntPtr.Zero;

			IntPtr docDataPtr = IntPtr.Zero;

			IntPtr hierPtr = IntPtr.Zero;



			// We get the document from the running doc table so that we can see if it is transient

			try

			{

				ErrorHandler.ThrowOnFailure(pRdt.FindAndLockDocument((uint)_VSRDTFLAGS.RDT_NoLock, oldMkDoc, out pHier, out id, out docdataForCookiePtr, out cookie));

			}

			finally

			{

				if(docdataForCookiePtr != IntPtr.Zero)

					Marshal.Release(docdataForCookiePtr);

			}



			//Get the document info

			try

			{

				ErrorHandler.ThrowOnFailure(pRdt.GetDocumentInfo(cookie, out grfFlags, out readLocks, out editLocks, out doc, out pHier, out id, out docDataPtr));

			}

			finally

			{

				if(docDataPtr != IntPtr.Zero)

					Marshal.Release(docDataPtr);

			}



			// Now see if the document is in the project. If not, we fail

			try

			{

				ErrorHandler.ThrowOnFailure(IsDocumentInProject(newMkDoc, out found, priority, out itemid));

				Debug.Assert(itemid != VSConstants.VSITEMID_NIL && itemid != VSConstants.VSITEMID_ROOT);

				hierPtr = Marshal.GetComInterfaceForObject(this, typeof(IVsUIHierarchy));

				// Now rename the document

				ErrorHandler.ThrowOnFailure(pRdt.RenameDocument(oldMkDoc, newMkDoc, hierPtr, itemid));

			}

			finally

			{

				if(hierPtr != IntPtr.Zero)

					Marshal.Release(hierPtr);

			}



			//Change the caption if we are passed a window frame

			if(frame != null)

			{

				string caption = "%2";

				hr = frame.SetProperty((int)(__VSFPROPID.VSFPROPID_OwnerCaption), caption);

			}

			return hr;

		}



		#endregion



		#region IVsProjectBuidSystem Members

		public virtual int SetHostObject(string targetName, string taskName, object hostObject)

		{

			Debug.Assert(targetName != null && taskName != null && this.buildProject != null && this.buildProject.Targets != null);



			if(targetName == null || taskName == null || this.buildProject == null || this.buildProject.Targets == null)

			{

				return VSConstants.E_INVALIDARG;

			}





			foreach(MSBuild.Target target in this.buildProject.Targets)

			{

				if(String.Compare(target.Name, targetName, StringComparison.OrdinalIgnoreCase) == 0)

				{

					System.Collections.IEnumerator enumerator = target.GetEnumerator();

					Debug.Assert(enumerator != null);



					if(enumerator == null)

					{

						return VSConstants.E_FAIL;

					}



					while(enumerator.MoveNext())

					{

						MSBuild.BuildTask buildTask = (MSBuild.BuildTask)enumerator.Current;

						if(String.Compare(buildTask.Name, taskName, true, CultureInfo.CurrentCulture) == 0)

						{

							buildTask.HostObject = (Microsoft.Build.Framework.ITaskHost)hostObject;

							return VSConstants.S_OK;

						}

					}

				}

			}

			return VSConstants.E_FAIL;

		}



		public int BuildTarget(string targetName, out bool success)

		{

			success = false;



			MSBuildResult result = this.Build(targetName);



			if(result == MSBuildResult.Successful)

			{

				success = true;

			}



			return VSConstants.S_OK;

		}



		public virtual int CancelBatchEdit()

		{

			return VSConstants.E_NOTIMPL;

		}



		public virtual int EndBatchEdit()

		{

			return VSConstants.E_NOTIMPL;

		}



		public virtual int StartBatchEdit()

		{

			return VSConstants.E_NOTIMPL;

		}



		/// <summary>

		/// Used to determine the kind of build system, in VS 2005 there's only one defined kind: MSBuild 

		/// </summary>

		/// <param name="kind"></param>

		/// <returns></returns>

		public virtual int GetBuildSystemKind(out uint kind)

		{

			kind = (uint)_BuildSystemKindFlags.BSK_MSBUILD;

			return VSConstants.S_OK;

		}



		#endregion



		#region IVsComponentUser methods



		/// <summary>

		/// Add Components to the Project.

		/// Used by the environment to add components specified by the user in the Component Selector dialog 

		/// to the specified project

		/// </summary>

		/// <param name="dwAddCompOperation">The component operation to be performed.</param>

		/// <param name="cComponents">Number of components to be added</param>

		/// <param name="rgpcsdComponents">array of component selector data</param>

		/// <param name="hwndDialog">Handle to the component picker dialog</param>

		/// <param name="pResult">Result to be returned to the caller</param>

		public virtual int AddComponent(VSADDCOMPOPERATION dwAddCompOperation, uint cComponents, System.IntPtr[] rgpcsdComponents, System.IntPtr hwndDialog, VSADDCOMPRESULT[] pResult)

		{

			//initalize the out parameter

			pResult[0] = VSADDCOMPRESULT.ADDCOMPRESULT_Success;



			IReferenceContainer references = GetReferenceContainer();

			if(null == references)

			{

				// This project does not support references or the reference container was not created.

				// In both cases this operation is not supported.

				return VSConstants.E_NOTIMPL;

			}

			for(int cCount = 0; cCount < cComponents; cCount++)

			{

				VSCOMPONENTSELECTORDATA selectorData = new VSCOMPONENTSELECTORDATA();

				IntPtr ptr = rgpcsdComponents[cCount];

				selectorData = (VSCOMPONENTSELECTORDATA)Marshal.PtrToStructure(ptr, typeof(VSCOMPONENTSELECTORDATA));

				if(null == references.AddReferenceFromSelectorData(selectorData))

				{

					//Skip further proccessing since a reference has to be added

					pResult[0] = VSADDCOMPRESULT.ADDCOMPRESULT_Failure;

					return VSConstants.S_OK;

				}

			}

			return VSConstants.S_OK;

		}

		#endregion



		#region IVsDependencyProvider Members

		public int EnumDependencies(out IVsEnumDependencies enumDependencies)

		{

			enumDependencies = new EnumDependencies(this.buildDependencyList);

			return VSConstants.S_OK;

		}



		public int OpenDependency(string szDependencyCanonicalName, out IVsDependency dependency)

		{

			dependency = null;

			return VSConstants.S_OK;

		}



		#endregion



		#region IVsSccProject2 Members

		/// <summary>

		/// This method is called to determine which files should be placed under source control for a given VSITEMID within this hierarchy.

		/// </summary>

		/// <param name="itemid">Identifier for the VSITEMID being queried.</param>

		/// <param name="stringsOut">Pointer to an array of CALPOLESTR strings containing the file names for this item.</param>

		/// <param name="flagsOut">Pointer to a CADWORD array of flags stored in DWORDs indicating that some of the files have special behaviors.</param>

		/// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code. </returns>

		public virtual int GetSccFiles(uint itemid, CALPOLESTR[] stringsOut, CADWORD[] flagsOut)

		{

			if(itemid == VSConstants.VSITEMID_SELECTION)

			{

				throw new ArgumentException(SR.GetString(SR.InvalidParameter, CultureInfo.CurrentUICulture), "itemid");

			}



			HierarchyNode n = this.NodeFromItemId(itemid);

			if(n == null)

			{

				throw new ArgumentException(SR.GetString(SR.InvalidParameter, CultureInfo.CurrentUICulture), "itemid");

			}



			List<string> files = new List<string>();

			List<tagVsSccFilesFlags> flags = new List<tagVsSccFilesFlags>();



			n.GetSccFiles(files, flags);



			if(stringsOut != null && stringsOut.Length > 0)

			{

				stringsOut[0] = Utilities.CreateCALPOLESTR(files);

			}



			if(flagsOut != null && flagsOut.Length > 0)

			{

				flagsOut[0] = Utilities.CreateCADWORD(flags);

			}



			return VSConstants.S_OK;

		}



		/// <summary>

		/// This method is called to discover special (hidden files) associated with a given VSITEMID within this hierarchy. 

		/// </summary>

		/// <param name="itemid">Identifier for the VSITEMID being queried.</param>

		/// <param name="sccFile">One of the files associated with the node</param>

		/// <param name="stringsOut">Pointer to an array of CALPOLESTR strings containing the file names for this item.</param>

		/// <param name="flagsOut">Pointer to a CADWORD array of flags stored in DWORDs indicating that some of the files have special behaviors.</param>

		/// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code. </returns>

		/// <remarks>This method is called to discover any special or hidden files associated with an item in the project hierarchy. It is called when GetSccFiles returns with the SFF_HasSpecialFiles flag set for any of the files associated with the node.</remarks>

		public virtual int GetSccSpecialFiles(uint itemid, string sccFile, CALPOLESTR[] stringsOut, CADWORD[] flagsOut)

		{

			if(itemid == VSConstants.VSITEMID_SELECTION)

			{

				throw new ArgumentException(SR.GetString(SR.InvalidParameter, CultureInfo.CurrentUICulture), "itemid");

			}



			HierarchyNode n = this.NodeFromItemId(itemid);

			if(n == null)

			{

				throw new ArgumentException(SR.GetString(SR.InvalidParameter, CultureInfo.CurrentUICulture), "itemid");

			}



			List<string> files = new List<string>();



			List<tagVsSccFilesFlags> flags = new List<tagVsSccFilesFlags>();



			n.GetSccSpecialFiles(sccFile, files, flags);



			if(stringsOut != null && stringsOut.Length > 0)

			{

				stringsOut[0] = Utilities.CreateCALPOLESTR(files);

			}



			if(flagsOut != null && flagsOut.Length > 0)

			{

				flagsOut[0] = Utilities.CreateCADWORD(flags);

			}



			return VSConstants.S_OK;



		}



		/// <summary>

		/// This method is called by the source control portion of the environment to inform the project of changes to the source control glyph on various nodes. 

		/// </summary>

		/// <param name="affectedNodes">Count of changed nodes.</param>

		/// <param name="itemidAffectedNodes">An array of VSITEMID identifiers of the changed nodes.</param>

		/// <param name="newGlyphs">An array of VsStateIcon glyphs representing the new state of the corresponding item in rgitemidAffectedNodes.</param>

		/// <param name="newSccStatus">An array of status flags from SccStatus corresponding to rgitemidAffectedNodes. </param>

		/// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code. </returns>

		public virtual int SccGlyphChanged(int affectedNodes, uint[] itemidAffectedNodes, VsStateIcon[] newGlyphs, uint[] newSccStatus)

		{

			// if all the paramaters are null adn the count is 0, it means scc wants us to updated everything

			if(affectedNodes == 0 && itemidAffectedNodes == null && newGlyphs == null && newSccStatus == null)

			{

				this.ReDraw(UIHierarchyElement.SccState);

				this.UpdateSccStateIcons();

			}

			else if(affectedNodes > 0 && itemidAffectedNodes != null && newGlyphs != null && newSccStatus != null)

			{

				for(int i = 0; i < affectedNodes; i++)

				{

					HierarchyNode n = this.NodeFromItemId(itemidAffectedNodes[i]);

					if(n == null)

					{

						throw new ArgumentException(SR.GetString(SR.InvalidParameter, CultureInfo.CurrentUICulture), "itemidAffectedNodes");

					}



					n.ReDraw(UIHierarchyElement.SccState);

				}

			}

			return VSConstants.S_OK;

		}



		/// <summary>

		/// This method is called by the source control portion of the environment when a project is initially added to source control, or to change some of the project's settings.

		/// </summary>

		/// <param name="sccProjectName">String, opaque to the project, that identifies the project location on the server. Persist this string in the project file. </param>

		/// <param name="sccLocalPath">String, opaque to the project, that identifies the path to the server. Persist this string in the project file.</param>

		/// <param name="sccAuxPath">String, opaque to the project, that identifies the local path to the project. Persist this string in the project file.</param>

		/// <param name="sccProvider">String, opaque to the project, that identifies the source control package. Persist this string in the project file.</param>

		/// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns>

		public virtual int SetSccLocation(string sccProjectName, string sccAuxPath, string sccLocalPath, string sccProvider)

		{

			if(this.IsSccDisabled)

			{

				throw new NotImplementedException();

			}



			if(sccProjectName == null)

			{

				throw new ArgumentNullException("sccProjectName");

			}



			if(sccAuxPath == null)

			{

				throw new ArgumentNullException("sccAuxPath");

			}



			if(sccLocalPath == null)

			{

				throw new ArgumentNullException("sccLocalPath");

			}



			if(sccProvider == null)

			{

				throw new ArgumentNullException("sccProvider");

			}



			// Save our settings (returns true if something changed)

			if(!this.SetSccSettings(sccProjectName, sccLocalPath, sccAuxPath, sccProvider))

			{

				return VSConstants.S_OK;

			}



			bool unbinding = (sccProjectName.Length == 0 && sccProvider.Length == 0);



			if(unbinding || this.QueryEditProjectFile(false))

			{

				this.buildProject.SetProperty(ProjectFileConstants.SccProjectName, sccProjectName);

				this.buildProject.SetProperty(ProjectFileConstants.SccProvider, sccProvider);

				this.buildProject.SetProperty(ProjectFileConstants.SccAuxPath, sccAuxPath);

				this.buildProject.SetProperty(ProjectFileConstants.SccLocalPath, sccLocalPath);

			}



			this.isRegisteredWithScc = true;



			return VSConstants.S_OK;

		}

		#endregion



		#region IVsProjectSpecialFiles Members

		/// <summary>

		/// Allows you to query the project for special files and optionally create them. 

		/// </summary>

		/// <param name="fileId">__PSFFILEID of the file</param>

		/// <param name="flags">__PSFFLAGS flags for the file</param>

		/// <param name="itemid">The itemid of the node in the hierarchy</param>

		/// <param name="fileName">The file name of the special file.</param>

		/// <returns></returns>

		public virtual int GetFile(int fileId, uint flags, out uint itemid, out string fileName)

		{

			itemid = VSConstants.VSITEMID_NIL;

			fileName = String.Empty;



			// We need to return S_OK, otherwise the property page tabs will not be shown.

			return VSConstants.E_NOTIMPL;

		}

		#endregion



		#region IAggregatedHierarchy Members



		/// <summary>

		/// Get the inner object of an aggregated hierarchy

		/// </summary>

		/// <returns>A HierarchyNode</returns>

		public virtual HierarchyNode GetInner()

		{

			return this;

		}



		#endregion



		#region IBuildDependencyUpdate Members



		public virtual IVsBuildDependency[] BuildDependencies

		{

			get

			{

				return this.buildDependencyList.ToArray();

			}

		}



		public virtual void AddBuildDependency(IVsBuildDependency dependency)

		{

			if(this.isClosed || dependency == null)

			{

				return;

			}



			if(!this.buildDependencyList.Contains(dependency))

			{

				this.buildDependencyList.Add(dependency);

			}

		}



		public virtual void RemoveBuildDependency(IVsBuildDependency dependency)

		{

			if(this.isClosed || dependency == null)

			{

				return;

			}



			if(this.buildDependencyList.Contains(dependency))

			{

				this.buildDependencyList.Remove(dependency);

			}

		}



		#endregion



		#region IReferenceDataProvider Members

		/// <summary>

		/// Returns the reference container node.

		/// </summary>

		/// <returns></returns>

		public IReferenceContainer GetReferenceContainer()

		{

			return this.FindChild(ReferenceContainerNode.ReferencesNodeVirtualName) as IReferenceContainer;

		}



		#endregion



		#region IProjectEventsListener Members

		public bool IsProjectEventsListener

		{

			get { return this.isProjectEventsListener; }

			set { this.isProjectEventsListener = value; }

		}

		#endregion



		#region IProjectEventsProvider Members



		/// <summary>

		/// Defines the provider for the project events

		/// </summary>

		IProjectEvents IProjectEventsProvider.ProjectEventsProvider

		{

			get

			{

				return this.projectEventsProvider;

			}

			set

			{

				if(null != this.projectEventsProvider)

				{

					this.projectEventsProvider.AfterProjectFileOpened -= this.OnAfterProjectOpen;

				}

				this.projectEventsProvider = value;

				if(null != this.projectEventsProvider)

				{

					this.projectEventsProvider.AfterProjectFileOpened += this.OnAfterProjectOpen;

				}

			}

		}



		#endregion



		#region IVsAggregatableProject Members



		/// <summary>

		/// Retrieve the list of project GUIDs that are aggregated together to make this project.

		/// </summary>

		/// <param name="projectTypeGuids">Semi colon separated list of Guids. Typically, the last GUID would be the GUID of the base project factory</param>

		/// <returns>HResult</returns>

		public int GetAggregateProjectTypeGuids(out string projectTypeGuids)

		{

			projectTypeGuids = this.GetProjectProperty(ProjectFileConstants.ProjectTypeGuids);

			// In case someone manually removed this from our project file, default to our project without flavors

			if(String.IsNullOrEmpty(projectTypeGuids))

				projectTypeGuids = this.ProjectGuid.ToString("B");

			return VSConstants.S_OK;

		}



		/// <summary>

		/// This is where the initialization occurs.

		/// </summary>

		public virtual int InitializeForOuter(string filename, string location, string name, uint flags, ref Guid iid, out IntPtr projectPointer, out int canceled)

		{

			canceled = 0;

			projectPointer = IntPtr.Zero;



			// Initialize the project

			this.Load(filename, location, name, flags, ref iid, out canceled);



			if(canceled != 1)

			{

				// Set ourself as the project

				return Marshal.QueryInterface(Marshal.GetIUnknownForObject(this), ref iid, out projectPointer);

			}



			return VSConstants.OLE_E_PROMPTSAVECANCELLED;

		}



		/// <summary>

		/// This is called after the project is done initializing the different layer of the aggregations

		/// </summary>

		/// <returns>HResult</returns>

		public virtual int OnAggregationComplete()

		{

			return VSConstants.S_OK;

		}



		/// <summary>

		/// Set the list of GUIDs that are aggregated together to create this project.

		/// </summary>

		/// <param name="projectTypeGuids">Semi-colon separated list of GUIDs, the last one is usually the project factory of the base project factory</param>

		/// <returns>HResult</returns>

		public int SetAggregateProjectTypeGuids(string projectTypeGuids)

		{

			this.SetProjectProperty(ProjectFileConstants.ProjectTypeGuids, projectTypeGuids);

			return VSConstants.S_OK;

		}



		/// <summary>

		/// We are always the inner most part of the aggregation

		/// and as such we don't support setting an inner project

		/// </summary>

		public int SetInnerProject(object innerProject)

		{

			return VSConstants.E_NOTIMPL;

		}



		#endregion



		#region IVsProjectFlavorCfgProvider Members



		int IVsProjectFlavorCfgProvider.CreateProjectFlavorCfg(IVsCfg pBaseProjectCfg, out IVsProjectFlavorCfg ppFlavorCfg)

		{

			// Our config object is also our IVsProjectFlavorCfg object

			ppFlavorCfg = pBaseProjectCfg as IVsProjectFlavorCfg;



			return VSConstants.S_OK;

		}



		#endregion



		#region IVsBuildPropertyStorage Members



		/// <summary>

		/// Get the property of an item

		/// </summary>

		/// <param name="item">ItemID</param>

		/// <param name="attributeName">Name of the property</param>

		/// <param name="attributeValue">Value of the property (out parameter)</param>

		/// <returns>HRESULT</returns>

		int IVsBuildPropertyStorage.GetItemAttribute(uint item, string attributeName, out string attributeValue)

		{

			attributeValue = null;



			HierarchyNode node = NodeFromItemId(item);

			if(node == null)

				throw new ArgumentException("Invalid item id", "item");



			attributeValue = node.ItemNode.GetMetadata(attributeName);

			return VSConstants.S_OK;

		}



		/// <summary>

		/// Get the value of the property in the project file

		/// </summary>

		/// <param name="propertyName">Name of the property to remove</param>

		/// <param name="configName">Configuration for which to remove the property</param>

		/// <param name="storage">Project or user file (_PersistStorageType)</param>

		/// <param name="propertyValue">Value of the property (out parameter)</param>

		/// <returns>HRESULT</returns>

		int IVsBuildPropertyStorage.GetPropertyValue(string propertyName, string configName, uint storage, out string propertyValue)

		{

			// TODO: when adding support for User files, we need to update this method

			propertyValue = null;

			if(string.IsNullOrEmpty(configName))

			{

				propertyValue = this.GetProjectProperty(propertyName);

			}

			else

			{

				IVsCfg configurationInterface;

				ErrorHandler.ThrowOnFailure(this.ConfigProvider.GetCfgOfName(configName, string.Empty, out configurationInterface));

				ProjectConfig config = (ProjectConfig)configurationInterface;

				propertyValue = config.GetConfigurationProperty(propertyName, true);

			}

			return VSConstants.S_OK;

		}



		/// <summary>

		/// Delete a property

		/// In our case this simply mean defining it as null

		/// </summary>

		/// <param name="propertyName">Name of the property to remove</param>

		/// <param name="configName">Configuration for which to remove the property</param>

		/// <param name="storage">Project or user file (_PersistStorageType)</param>

		/// <returns>HRESULT</returns>

		int IVsBuildPropertyStorage.RemoveProperty(string propertyName, string configName, uint storage)

		{

			return ((IVsBuildPropertyStorage)this).SetPropertyValue(propertyName, configName, storage, null);

		}



		/// <summary>

		/// Set a property on an item

		/// </summary>

		/// <param name="item">ItemID</param>

		/// <param name="attributeName">Name of the property</param>

		/// <param name="attributeValue">New value for the property</param>

		/// <returns>HRESULT</returns>

		int IVsBuildPropertyStorage.SetItemAttribute(uint item, string attributeName, string attributeValue)

		{

			HierarchyNode node = NodeFromItemId(item);



			if(node == null)

				throw new ArgumentException("Invalid item id", "item");



			node.ItemNode.SetMetadata(attributeName, attributeValue);

			return VSConstants.S_OK;

		}



		/// <summary>

		/// Set a project property

		/// </summary>

		/// <param name="propertyName">Name of the property to set</param>

		/// <param name="configName">Configuration for which to set the property</param>

		/// <param name="storage">Project file or user file (_PersistStorageType)</param>

		/// <param name="propertyValue">New value for that property</param>

		/// <returns>HRESULT</returns>

		int IVsBuildPropertyStorage.SetPropertyValue(string propertyName, string configName, uint storage, string propertyValue)

		{

			// TODO: when adding support for User files, we need to update this method

			if(string.IsNullOrEmpty(configName))

			{

				this.SetProjectProperty(propertyName, propertyValue);

			}

			else

			{

				IVsCfg configurationInterface;

				ErrorHandler.ThrowOnFailure(this.ConfigProvider.GetCfgOfName(configName, string.Empty, out configurationInterface));

				ProjectConfig config = (ProjectConfig)configurationInterface;

				config.SetConfigurationProperty(propertyName, propertyValue);

			}

			return VSConstants.S_OK;

		}



		#endregion



		#region private helper methods



		/// <summary>

		/// Initialize projectNode

		/// </summary>

		private void Initialize()

		{

			this.ID = VSConstants.VSITEMID_ROOT;

			this.tracker = new TrackDocumentsHelper(this);

		}



		/// <summary>

		/// Add an item to the hierarchy based on the item path

		/// </summary>

		/// <param name="item">Item to add</param>

		/// <returns>Added node</returns>

		private HierarchyNode AddIndependentFileNode(MSBuild.BuildItem item)

		{

			HierarchyNode currentParent = GetItemParentNode(item);

			return AddFileNodeToNode(item, currentParent);

		}



		/// <summary>

		/// Add a dependent file node to the hierarchy

		/// </summary>

		/// <param name="item">msbuild item to add</param>

		/// <param name="parentNode">Parent Node</param>

		/// <returns>Added node</returns>

		private HierarchyNode AddDependentFileNodeToNode(MSBuild.BuildItem item, HierarchyNode parentNode)

		{

			FileNode node = this.CreateDependentFileNode(new ProjectElement(this, item, false));

			parentNode.AddChild(node);



			// Make sure to set the HasNameRelation flag on the dependent node if it is related to the parent by name

			if(!node.HasParentNodeNameRelation && string.Compare(node.GetRelationalName(), parentNode.GetRelationalName(), StringComparison.OrdinalIgnoreCase) == 0)

			{

				node.HasParentNodeNameRelation = true;

			}



			return node;

		}



		/// <summary>

		/// Add a file node to the hierarchy

		/// </summary>

		/// <param name="item">msbuild item to add</param>

		/// <param name="parentNode">Parent Node</param>

		/// <returns>Added node</returns>

		private HierarchyNode AddFileNodeToNode(MSBuild.BuildItem item, HierarchyNode parentNode)

		{

			FileNode node = this.CreateFileNode(new ProjectElement(this, item, false));

			parentNode.AddChild(node);

			return node;

		}



		/// <summary>

		/// Get the parent node of an msbuild item

		/// </summary>

		/// <param name="item">msbuild item</param>

		/// <returns>parent node</returns>

		private HierarchyNode GetItemParentNode(MSBuild.BuildItem item)

		{

			HierarchyNode currentParent = this;

			string strPath = item.FinalItemSpec;



			strPath = Path.GetDirectoryName(strPath);

			if(strPath.Length > 0)

			{

				// Use the relative to verify the folders...

				currentParent = this.CreateFolderNodes(strPath);

			}

			return currentParent;

		}



		private MSBuild.BuildProperty GetMsBuildProperty(string propertyName, bool resetCache)

		{

			if(resetCache || this.currentConfig == null)

			{

				// Get properties from project file and cache it

				this.SetCurrentConfiguration();

				this.currentConfig = this.buildProject.EvaluatedProperties;

			}



			if(this.currentConfig == null)

				throw new Exception(String.Format(CultureInfo.CurrentCulture, SR.GetString(SR.FailedToRetrieveProperties, CultureInfo.CurrentUICulture), propertyName));



			// return property asked for

			return this.currentConfig[propertyName];

		}



		private string GetOutputPath(MSBuild.BuildPropertyGroup properties)

		{

			this.currentConfig = properties;

			string outputPath = GetProjectProperty("OutputPath");



			if(!String.IsNullOrEmpty(outputPath))

			{

				outputPath = outputPath.Replace('/', Path.DirectorySeparatorChar);

				if(outputPath[outputPath.Length - 1] != Path.DirectorySeparatorChar)

					outputPath += Path.DirectorySeparatorChar;

			}



			return outputPath;

		}



		private bool GetBoolAttr(MSBuild.BuildPropertyGroup properties, string name)

		{

			this.currentConfig = properties;

			string s = GetProjectProperty(name);



			return (s != null && s.ToUpperInvariant().Trim() == "TRUE");

		}



		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase")]

		private string GetAssemblyName(MSBuild.BuildPropertyGroup properties)

		{

			this.currentConfig = properties;

			string name = null;



			name = GetProjectProperty(ProjectFileConstants.AssemblyName);

			if(name == null)

				name = this.Caption;



			string outputtype = GetProjectProperty(ProjectFileConstants.OutputType, false);



			if(outputtype == "library")

			{

				outputtype = outputtype.ToLowerInvariant();

				name += ".dll";

			}

			else

			{

				name += ".exe";

			}



			return name;

		}



		/// <summary>

		/// Updates our scc project settings. 

		/// </summary>

		/// <param name="sccProjectName">String, opaque to the project, that identifies the project location on the server. Persist this string in the project file. </param>

		/// <param name="sccLocalPath">String, opaque to the project, that identifies the path to the server. Persist this string in the project file.</param>

		/// <param name="sccAuxPath">String, opaque to the project, that identifies the local path to the project. Persist this string in the project file.</param>

		/// <param name="sccProvider">String, opaque to the project, that identifies the source control package. Persist this string in the project file.</param>

		/// <returns>Returns true if something changed.</returns>

		private bool SetSccSettings(string sccProjectName, string sccLocalPath, string sccAuxPath, string sccProvider)

		{

			bool changed = false;

			Debug.Assert(sccProjectName != null && sccLocalPath != null && sccAuxPath != null && sccProvider != null);

			if(String.Compare(sccProjectName, this.sccProjectName, StringComparison.OrdinalIgnoreCase) != 0 ||

				String.Compare(sccLocalPath, this.sccLocalPath, StringComparison.OrdinalIgnoreCase) != 0 ||

				String.Compare(sccAuxPath, this.sccAuxPath, StringComparison.OrdinalIgnoreCase) != 0 ||

				String.Compare(sccProvider, this.sccProvider, StringComparison.OrdinalIgnoreCase) != 0)

			{

				changed = true;

				this.sccProjectName = sccProjectName;

				this.sccLocalPath = sccLocalPath;

				this.sccAuxPath = sccAuxPath;

				this.sccProvider = sccProvider;

			}





			return changed;

		}



		/// <summary>

		/// Sets the scc info from the project file.

		/// </summary>

		private void InitSccInfo()

		{

			this.sccProjectName = this.GetProjectProperty(ProjectFileConstants.SccProjectName);

			this.sccLocalPath = this.GetProjectProperty(ProjectFileConstants.SccLocalPath);

			this.sccProvider = this.GetProjectProperty(ProjectFileConstants.SccProvider);

			this.sccAuxPath = this.GetProjectProperty(ProjectFileConstants.SccAuxPath);

		}



		private void OnAfterProjectOpen(object sender, AfterProjectFileOpenedEventArgs e)

		{

			this.projectOpened = true;

		}



		private static XmlElement WrapXmlFragment(XmlDocument document, XmlElement root, Guid flavor, string configuration, string fragment)

		{

			XmlElement node = document.CreateElement(ProjectFileConstants.FlavorProperties);

			XmlAttribute attribute = document.CreateAttribute(ProjectFileConstants.Guid);

			attribute.Value = flavor.ToString("B");

			node.Attributes.Append(attribute);

			if(!String.IsNullOrEmpty(configuration))

			{

				attribute = document.CreateAttribute(ProjectFileConstants.Configuration);

				attribute.Value = configuration;

				node.Attributes.Append(attribute);

			}

			node.InnerXml = fragment;

			root.AppendChild(node);

			return node;

		}



		/// <summary>

		/// Sets the project guid from the project file. If no guid is found a new one is created and assigne for the instance project guid.

		/// </summary>

		private void SetProjectGuidFromProjectFile()

		{

			string projectGuid = this.GetProjectProperty(ProjectFileConstants.ProjectGuid);

			if(String.IsNullOrEmpty(projectGuid))

			{

				this.projectIdGuid = Guid.NewGuid();

			}

			else

			{

				Guid guid = new Guid(projectGuid);

				if(guid != this.projectIdGuid)

				{

					this.projectIdGuid = guid;

				}

			}

		}



		/// <summary>

		/// Recusively parses the tree and closes all nodes.

		/// </summary>

		/// <param name="node">The subtree to close.</param>

		private static void CloseAllNodes(HierarchyNode node)

		{

			for(HierarchyNode n = node.FirstChild; n != null; n = n.NextSibling)

			{

				if(n.FirstChild != null)

				{

					CloseAllNodes(n);

				}



				n.Close();

			}

		}

		#endregion

	}

}