/// <summary>
 /// Constructor to Wrap an existing MSBuild.ProjectItem
 /// Only have internal constructors as the only one who should be creating
 /// such object is the project itself (see Project.CreateFileNode()).
 /// </summary>
 /// <param name="project">Project that owns this item</param>
 /// <param name="existingItem">an MSBuild.ProjectItem; can be null if virtualFolder is true</param>
 /// <param name="virtualFolder">Is this item virtual (such as reference folder)</param>
 internal VirtualProjectElement(ProjectNode project, string path = null)
     : base(project)
 {
     _virtualProperties = new Dictionary<string, string>();
     if(path != null)
         Rename(path);
 }

 internal WebPiReferenceNode(ProjectNode root, ProjectElement element, string filename, string productId, string friendlyName)
     : base(root, element) {
     Utilities.ArgumentNotNullOrEmpty("filename", filename);
     _feed = filename;
     _productId = productId;
     _friendlyName = friendlyName;
 }

        /// <summary>
        /// Constructor for IVSOutput2 implementation
        /// </summary>
        /// <param name="projectManager">Project that produce this output</param>
        /// <param name="outputAssembly">MSBuild generated item corresponding to the output assembly (by default, these would be of type MainAssembly</param>
        public Output(ProjectNode projectManager, ProjectItemInstance outputAssembly)
        {
            Utilities.ArgumentNotNull("projectManager", projectManager);

            project = projectManager;
            output = outputAssembly;
        }

        /// <summary>
        /// Constructor to Wrap an existing MSBuild.ProjectItem
        /// Only have internal constructors as the only one who should be creating
        /// such object is the project itself (see Project.CreateFileNode()).
        /// </summary>
        /// <param name="project">Project that owns this item</param>
        /// <param name="existingItem">an MSBuild.ProjectItem; can be null if virtualFolder is true</param>
        /// <param name="virtualFolder">Is this item virtual (such as reference folder)</param>
        internal MsBuildProjectElement(ProjectNode project, MSBuild.ProjectItem existingItem)
            : base(project) {
            Utilities.ArgumentNotNull("existingItem", existingItem);

            // Keep a reference to project and item
            _item = existingItem;
        }

        private string _url; // cached Url

        /// <summary>
        /// Constructor to create a new MSBuild.ProjectItem and add it to the project
        /// Only have internal constructors as the only one who should be creating
        /// such object is the project itself (see Project.CreateFileNode()).
        /// </summary>
        internal MsBuildProjectElement(ProjectNode project, string itemPath, string itemType)
            : base(project) {
            Utilities.ArgumentNotNullOrEmpty("itemPath", itemPath);
            Utilities.ArgumentNotNullOrEmpty("itemType", itemType);

            // create and add the item to the project

            _item = project.BuildProject.AddItem(itemType, Microsoft.Build.Evaluation.ProjectCollection.Escape(itemPath))[0];
            _url = base.Url;
        }

        /// <summary>
        /// Constructor for IVSOutputGroup2 implementation
        /// </summary>
        /// <param name="outputName">Name of the output group. See VS_OUTPUTGROUP_CNAME_Build in vsshell.idl for the list of standard values</param>
        /// <param name="msBuildTargetName">MSBuild target name</param>
        /// <param name="projectManager">Project that produce this output</param>
        /// <param name="configuration">Configuration that produce this output</param>
        public OutputGroup(string outputName, string msBuildTargetName, ProjectNode projectManager, ProjectConfig configuration) {
            Utilities.ArgumentNotNull("outputName", outputName);
            Utilities.ArgumentNotNull("msBuildTargetName", msBuildTargetName);
            Utilities.ArgumentNotNull("projectManager", projectManager);
            Utilities.ArgumentNotNull("configuration", configuration);

            _name = outputName;
            _targetName = msBuildTargetName;
            _project = projectManager;
            _projectCfg = configuration;
        }

 public UserProjectConfig(ProjectNode node)
 {
     string userConfigPath = node.Url + ".user";
     try
     {
         LoadMsBuildProject(userConfigPath);
     }
     catch (InvalidProjectFileException)
     {
         File.WriteAllText(userConfigPath, emptyUserConfig);
         LoadMsBuildProject(userConfigPath);
     }
     this.proj = node;
 }

 /// <summary>
 /// constructor for the ReferenceNode
 /// </summary>
 protected ReferenceNode(ProjectNode root, ProjectElement element)
     : base(root, element) {
     this.ExcludeNodeFromScc = true;
 }

 public FolderAddition(ProjectNode project, string newFolderPath, string sourceFolder, DropEffect dropEffect, Addition[] additions) {
     Project = project;
     NewFolderPath = newFolderPath;
     SourceFolder = sourceFolder;
     Additions = additions;
     DropEffect = dropEffect;
 }

            public ProjectReferenceFileAdder(ProjectNode project, HierarchyNode targetNode, string[] projectReferences, bool mouseDropping, DropEffect dropEffect) {
                Utilities.ArgumentNotNull("targetNode", targetNode);
                Utilities.ArgumentNotNull("project", project);
                Utilities.ArgumentNotNull("projectReferences", projectReferences);

                TargetNode = targetNode;
                Project = project;
                ProjectReferences = projectReferences;
                MouseDropping = mouseDropping;
                DropEffect = dropEffect;
            }

 public OverwriteFileAddition(ProjectNode project, string targetFolder, DropEffect dropEffect, string sourceMoniker, string newFileName, IVsProject sourceHierarchy)
     : base(project, targetFolder, dropEffect, sourceMoniker, newFileName, sourceHierarchy) {
 }

 public ProjectDesignerDocumentManager(ProjectNode node)
     : base(node) {
 }

 internal ReferenceContainerNode(ProjectNode root)
     : base(root) {
     this.ExcludeNodeFromScc = true;
 }

 /// <summary>
 /// Constructor for the FileNode
 /// </summary>
 /// <param name="root">Root of the hierarchy</param>
 /// <param name="e">Associated project element</param>
 public FileNode(ProjectNode root, ProjectElement element)
     : base(root, element) {
     UpdateCaption();
 }

        internal ProjectConfig(ProjectNode project, string configuration) {
            this.project = project;
            
            if (configuration.Contains("|")) { // If configuration is in the form "<Configuration>|<Platform>"
                string[] configStrArray = configuration.Split('|');
                if (2 == configStrArray.Length) {
                    this.configName = configStrArray[0];
                    this.platformName = configStrArray[1];
                }
                else {
                    throw new Exception(string.Format(CultureInfo.InvariantCulture, "Invalid configuration format: {0}", configuration));
                }
            }
            else { // If configuration is in the form "<Configuration>"          
                this.configName = configuration;
            }

            var flavoredCfgProvider = ProjectMgr.GetOuterInterface<IVsProjectFlavorCfgProvider>();
            Utilities.ArgumentNotNull("flavoredCfgProvider", flavoredCfgProvider);
            ErrorHandler.ThrowOnFailure(flavoredCfgProvider.CreateProjectFlavorCfg(this, out flavoredCfg));
            Utilities.ArgumentNotNull("flavoredCfg", flavoredCfg);

            // if the flavored object support XML fragment, initialize it
            IPersistXMLFragment persistXML = flavoredCfg as IPersistXMLFragment;
            if (null != persistXML) {
                this.project.LoadXmlFragment(persistXML, configName, platformName);
            }
        }

        public ExtensibilityEventsDispatcher(ProjectNode/*!*/ project) {
            Utilities.ArgumentNotNull("project", project);

            this._project = project;
        }

 internal BuildDependency(ProjectNode projectMgr, Guid projectReference) {
     this.referencedProjectGuid = projectReference;
     this.projectMgr = projectMgr;
 }

 /// <summary>
 /// Constructor to Wrap an existing MSBuild.ProjectItem
 /// Only have internal constructors as the only one who should be creating
 /// such object is the project itself (see Project.CreateFileNode()).
 /// </summary>
 /// <param name="project">Project that owns this item</param>
 /// <param name="existingItem">an MSBuild.ProjectItem; can be null if virtualFolder is true</param>
 /// <param name="virtualFolder">Is this item virtual (such as reference folder)</param>
 internal VirtualProjectElement(ProjectNode project)
     : base(project) {
     _virtualProperties = new Dictionary<string, string>();
 }

        /// <summary>
        /// Defines if the node has a name relation to its parent node
        /// e.g. Form1.ext and Form1.resx are name related (until first occurence of extention separator)
        /// </summary>
        #endregion

        #region ctor
        /// <summary>
        /// Constructor for the DependentFileNode
        /// </summary>
        /// <param name="root">Root of the hierarchy</param>
        /// <param name="e">Associated project element</param>
        internal DependentFileNode(ProjectNode root, MsBuildProjectElement element)
            : base(root, element) {
            this.HasParentNodeNameRelation = false;
        }

 internal virtual OutputGroup CreateOutputGroup(ProjectNode project, KeyValuePair<string, string> group) {
     OutputGroup outputGroup = new OutputGroup(group.Key, group.Value, project, this);
     return outputGroup;
 }