/* ****************************************************************************

*

* Copyright (c) Microsoft Corporation.

*

* This source code is subject to terms and conditions of the Apache License, Version 2.0. A

* copy of the license can be found in the License.html file at the root of this distribution. If

* you cannot locate the Apache License, Version 2.0, please send an email to

* vspython@microsoft.com. By using this source code in any fashion, you are agreeing to be bound

* by the terms of the Apache License, Version 2.0.

*

* You must not remove this notice, or any other, from this software.

*

* ***************************************************************************/

using System;

using System.CodeDom.Compiler;

using System.Collections.Generic;

using System.Diagnostics;

using System.Diagnostics.CodeAnalysis;

using System.Globalization;

using System.IO;

using System.Linq;

using System.Runtime.InteropServices;

using System.Windows.Forms;

using System.Xml;

using EnvDTE;

using Microsoft.Build.Execution;

using Microsoft.VisualStudio;

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.Evaluation;

using MSBuildConstruction = Microsoft.Build.Construction;

using MSBuildExecution = Microsoft.Build.Execution;

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

using VsCommands = Microsoft.VisualStudio.VSConstants.VSStd97CmdID;

using VsCommands2K = Microsoft.VisualStudio.VSConstants.VSStd2KCmdID;

namespace Microsoft.VisualStudioTools.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>

internal abstract partial class ProjectNode : HierarchyNode,

IVsUIHierarchy,

IVsPersistHierarchyItem2,

IVsHierarchyDeleteHandler,

IVsHierarchyDropDataTarget,

IVsHierarchyDropDataSource,

IVsHierarchyDropDataSource2,

IVsGetCfgProvider,

IVsProject3,

IVsAggregatableProject,

IVsProjectFlavorCfgProvider,

IPersistFileFormat,

IVsBuildPropertyStorage,

IVsComponentUser,

IVsDependencyProvider,

IVsSccProject2,

IBuildDependencyUpdate,

IVsProjectSpecialFiles,

IVsProjectBuildSystem,

IOleCommandTarget

{

#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,

DoNotTriggerTrackerQueryEvents = 4

}

#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"),

};

private EventSinkCollection _hierarchyEventSinks = new EventSinkCollection();

/// <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 ServiceProvider 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.ProjectCollection buildEngine;

private Microsoft.Build.Utilities.Logger buildLogger;

private bool useProvidedLogger;

private MSBuild.Project buildProject;

private MSBuildExecution.ProjectInstance currentConfig;

private ConfigProvider configProvider;

private TaskProvider taskProvider;

private string filename;

private Microsoft.VisualStudio.Shell.Url baseUri;

private string projectHome;

private bool isDirty;

private bool projectOpened;

private bool buildIsPrepared;

private string errorString;

private string warningString;

private ImageHandler imageHandler;

private Guid projectIdGuid;

private bool isClosed;

private EventTriggering eventTriggeringFlag = EventTriggering.TriggerAll;

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;

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>

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

/// </summary>

private string outputBaseRelativePath = "bin";

/// <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 internal package implementation.

/// </summary>

private ProjectPackage package;

/// <summary>

/// Mapping from item names to their hierarchy nodes for all disk-based nodes.

/// </summary>

protected readonly Dictionary<string, HierarchyNode> _diskNodes = new Dictionary<string, HierarchyNode>(StringComparer.OrdinalIgnoreCase);

// Has the object been disposed.

private bool isDisposed;

private IVsHierarchy parentHierarchy;

private int parentHierarchyItemId;

private List<HierarchyNode> itemsDraggedOrCutOrCopied;

/// <summary>

/// Folder node in the process of being created. First the hierarchy node

/// is added, then the label is edited, and when that completes/cancels

/// the folder gets created.

/// </summary>

private FolderNode _folderBeingCreated;

#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>

/// Indicates whether or not the project system supports Show All Files.

///

/// Subclasses will need to return true here, and will need to handle calls

/// </summary>

public virtual bool CanShowAllFiles

{

get

{

return false;

}

}

/// <summary>

/// Indicates whether or not the project is currently in the mode where its showing all files.

/// </summary>

public virtual bool IsShowingAllFiles

{

get

{

return false;

}

}

/// <summary>

/// Represents the command guid for the project system. This enables

/// using CommonConstants.cmdid* commands.

///

/// By default these commands are disabled if this isn't overridden

/// with the packages command guid.

/// </summary>

public virtual Guid SharedCommandGuid {

get {

return CommonConstants.NoSharedCommandsGuid;

}

}

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

}

}

}

}

public override bool CanAddFiles

{

get

{

return true;

}

}

#endregion

#region properties

/// <summary>

/// Gets the folder node which is currently being added to the project via

/// Solution Explorer.

/// </summary>

internal FolderNode FolderBeingCreated {

get {

return _folderBeingCreated;

}

set {

_folderBeingCreated = value;

}

}

internal IList<HierarchyNode> ItemsDraggedOrCutOrCopied {

get {

return this.itemsDraggedOrCutOrCopied;

}

}

public MSBuildExecution.ProjectInstance CurrentConfig

{

get

{

return currentConfig;

}

}

#region overridden properties

internal override string FullPathToChildren {

get {

return ProjectHome;

}

}

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.FullPath;

if (String.IsNullOrEmpty(caption))

{

if (this.buildProject.GetProperty(ProjectFileConstants.Name) != null)

{

caption = this.buildProject.GetProperty(ProjectFileConstants.Name).EvaluatedValue;

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>

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

/// 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(ProjectIconsImageStripStream);

}

return imageHandler;

}

}

protected virtual Stream ProjectIconsImageStripStream {

get {

return typeof(ProjectNode).Assembly.GetManifestResourceStream("Microsoft.VisualStudioTools.Project.Resources.imagelis.bmp");

}

}

/// <summary>

/// Gets the path to the root folder of the project.

/// </summary>

public string ProjectHome

{

get

{

if (projectHome == null)

{

projectHome = CommonUtils.GetAbsoluteDirectoryPath(

this.ProjectFolder,

this.GetProjectProperty(CommonConstants.ProjectHome, true));

}

Debug.Assert(projectHome != null, "ProjectHome should not be null");

return projectHome;

}

}

/// <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 = CommonUtils.NormalizeDirectoryPath(Path.GetDirectoryName(this.buildProject.FullPath));

baseUri = new Url(path);

}

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

return baseUri;

}

}

protected void BuildProjectLocationChanged()

{

baseUri = null;

projectHome = null;

}

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

{

// TODO: Maybe bring the exception back instead of automatically fixing this?

this.outputBaseRelativePath = CommonUtils.GetRelativeDirectoryPath(ProjectHome, value);

}

this.outputBaseRelativePath = 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 internal ConfigProvider ConfigProvider

{

get

{

if (this.configProvider == null)

{

this.configProvider = CreateConfigProvider();

}

return this.configProvider;

}

}

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

/// 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 MSBuild.Project BuildProject

{

get

{

return this.buildProject;

}

set

{

SetBuildProject(value);

}

}

/// <summary>

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

/// </summary>

internal MSBuild.ProjectCollection BuildEngine

{

get

{

return this.buildEngine;

}

set

{

this.buildEngine = 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 internal override void DeleteFromStorage(string path) {

if (File.Exists(path)) {

File.Delete(path);

}

base.DeleteFromStorage(path);

}

/// <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_ParentHierarchy:

parentHierarchy = (IVsHierarchy)value;

break;

case __VSHPROPID.VSHPROPID_ParentHierarchyItemid:

parentHierarchyItemId = (int)value;

break;

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 (Utilities.IsFileNameInvalid(label))

{

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

}

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

}

// TODO: Take file extension into account?

string fileName = Path.GetFileNameWithoutExtension(label);

// Nothing to do if the name is the same

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

if (String.Equals(oldFileName, label, StringComparison.Ordinal))

{

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