/Dependencies/MPFProjectBase/ProjectNode.cs

Large files files are truncated, but you can click here to view the full file

/// 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 und…

Large files files are truncated, but you can click here to view the full file