[WiX-commits] wix/src/votive/sdk_vs2008/common/source/csharp/project assemblyreferencenode.cs, NONE

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/wix/wix/src/votive/sdk_vs2008/common/source/csharp/project
In directory sc8-pr-cvs9.sourceforge.net:/tmp/cvs-serv19110/src/votive/sdk_vs2008/common/source/csharp/project

Added Files:
	assemblyreferencenode.cs attributes.cs builddependency.cs 
	buildpropertypage.cs comreferencenode.cs configprovider.cs 
	configurationproperties.cs dataobject.cs dependentfilenode.cs 
	designpropertydescriptor.cs documentmanager.cs 
	dontshowagaindialog.cs dontshowagaindialog.designer.cs 
	dontshowagaindialog.resx enumdependencies.cs 
	filechangemanager.cs filedocumentmanager.cs filenode.cs 
	foldernode.cs globalpropertyhandler.cs globalsuppressions.cs 
	hierarchynode.cs idebuildlogger.cs imagehandler.cs 
	interfaces.cs localizableproperties.cs 
	microsoft.visualstudio.package.project.cs 
	microsoft.visualstudio.package.project.resx 
	mpfprojectall.files nestedprojectbuilddependency.cs 
	nestedprojectnode.cs nodeproperties.cs oleserviceprovider.cs 
	output.cs outputgroup.cs projectbase.files projectconfig.cs 
	projectcontainernode.cs projectdesignerdocumentmanager.cs 
	projectdocumentslistener.cs projectelement.cs 
	projectfactory.cs projectfileconstants.cs 
	projectnode.copypaste.cs projectnode.cs projectnode.events.cs 
	projectoptions.cs projectpackage.cs projectreferencenode.cs 
	projectsecuritychecker.cs propertieseditorlauncher.cs 
	referencecontainernode.cs referencenode.cs 
	registeredprojecttype.cs securitywarningdialog.cs 
	securitywarningdialog.designer.cs securitywarningdialog.resx 
	selectionlistener.cs settingspage.cs singlefilegenerator.cs 
	singlefilegeneratorfactory.cs solutionlistener.cs 
	solutionlistenerforbuilddependencyupdate.cs 
	solutionlistenerforprojectevents.cs 
	solutionlistenerforprojectopen.cs 
	solutionlistenerforprojectreferenceupdate.cs 
	structuresenums.cs suspendfilechanges.cs tokenprocessor.cs 
	tracing.cs trackdocumentshelper.cs typeconverters.cs 
	updatesolutioneventslistener.cs url.cs 
	userprojectsecuritychecker.cs utilities.cs vscommands.cs 
	vsmdcodedomprovider.cs vsregistry.cs vsshellutilities.cs 
	webprojectbase.files 
Log Message:
AaronSte: Creating separate Votive and Sconce DLLs for VS 2005 and VS 2008.
          Adding the VS 2008 SDK source code that is needed to build the VS
          2008 Votive and Sconce dlls.

HeathS: SFBUG:1789825 - CreationTimeUTC documents wrong format
        SFFEATURE:1768845 - Patch element should support MinorUpdateTargetRTM
        attribute
        SFFEATURE:1735295 - Patch build should add PATCHNEW* properties to
        patch transform
        Added support for ignorables to CompareUnit in WixUnit

HeathS: SFBUG:1768842 - PatchProperty does not allow Company

RobMen: Ensure RegistryKey element never ends up as KeyPath because MSI SDK
        says it isn't allowed.

RobMen: Component guid generation.

RobMen: SFBUG:1795309 - respect the rollback flag for the last SQL string like
                        all the other strings.

RobMen: SFBUG:1787888 - correctly handle certificates that are in Components
                        that are conditioned out.

RobMen: SFBUG:1675194 - loop through all server bindings when searching for a
                        match.

--- NEW FILE: solutionlistener.cs ---
/***************************************************************************

Copyright (c) Microsoft Corporation. All rights reserved.
This code is licensed under the Visual Studio SDK license terms.
THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.

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

using Microsoft.VisualStudio.Shell.Interop;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Security;
using System.Windows; 
using Microsoft.VisualStudio.OLE.Interop;
using Microsoft.VisualStudio.Shell;
using System.Drawing;
using System.IO;
using System.Windows.Forms;
using System.Collections;
using System.Text;
using IOleServiceProvider = Microsoft.VisualStudio.OLE.Interop.IServiceProvider;
using IServiceProvider = System.IServiceProvider;
using ShellConstants = Microsoft.VisualStudio.Shell.Interop.Constants;
using OleConstants = Microsoft.VisualStudio.OLE.Interop.Constants;

namespace Microsoft.VisualStudio.Package
{

	[CLSCompliant(false)]
	public abstract class SolutionListener : IVsSolutionEvents3, IVsSolutionEvents4, IDisposable
	{

		#region fields
		private uint eventsCookie = (uint)ShellConstants.VSCOOKIE_NIL;
		private IVsSolution solution = null;
		private IServiceProvider serviceProvider = null;
		private bool isDisposed;
		/// <summary>
		/// Defines an object that will be a mutex for this object for synchronizing thread calls.
		/// </summary>
		private static volatile object Mutex = new object();
		#endregion

		#region ctors
		protected SolutionListener(IServiceProvider serviceProvider)
		{

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

			Debug.Assert(this.solution != null, "Could not get the IVsSolution object from the services exposed by this project");

			if (this.solution == null)
			{
				throw new InvalidOperationException();
			}
		}
		#endregion

		#region properties
		protected uint EventsCookie
		{
			get
			{
				return this.eventsCookie;
			}
		}

		protected IVsSolution Solution
		{
			get
			{
				return this.solution;
			}
		}

		protected IServiceProvider ServiceProvider
		{
			get
			{
				return this.serviceProvider;
			}
		}
		#endregion

		#region IVsSolutionEvents3, IVsSolutionEvents2, IVsSolutionEvents methods
		public virtual int OnAfterCloseSolution(object reserved)
		{
			return VSConstants.E_NOTIMPL;
		}

		public virtual int OnAfterClosingChildren(IVsHierarchy hierarchy)
		{
			return VSConstants.E_NOTIMPL;
		}

		public virtual int OnAfterLoadProject(IVsHierarchy stubHierarchy, IVsHierarchy realHierarchy)
		{
			return VSConstants.E_NOTIMPL;
		}

		public virtual int OnAfterMergeSolution(object pUnkReserved)
		{
			return VSConstants.E_NOTIMPL;
		}

		public virtual int OnAfterOpenProject(IVsHierarchy hierarchy, int added)
		{
			return VSConstants.E_NOTIMPL;
		}

		public virtual int OnAfterOpenSolution(object pUnkReserved, int fNewSolution)
		{
			return VSConstants.E_NOTIMPL;
		}

		public virtual int OnAfterOpeningChildren(IVsHierarchy hierarchy)
		{
			return VSConstants.E_NOTIMPL;
		}

		public virtual int OnBeforeCloseProject(IVsHierarchy hierarchy, int removed)
		{
			return VSConstants.E_NOTIMPL;
		}

		public virtual int OnBeforeCloseSolution(object pUnkReserved)
		{
			return VSConstants.E_NOTIMPL;
		}

		public virtual int OnBeforeClosingChildren(IVsHierarchy hierarchy)
		{
			return VSConstants.E_NOTIMPL;
		}

		public virtual int OnBeforeOpeningChildren(IVsHierarchy hierarchy)
		{
			return VSConstants.E_NOTIMPL;
		}

		public virtual int OnBeforeUnloadProject(IVsHierarchy realHierarchy, IVsHierarchy rtubHierarchy)
		{
			return VSConstants.E_NOTIMPL;
		}

		public virtual int OnQueryCloseProject(IVsHierarchy hierarchy, int removing, ref int cancel)
		{
			return VSConstants.E_NOTIMPL;
		}

		public virtual int OnQueryCloseSolution(object pUnkReserved, ref int cancel)
		{
			return VSConstants.E_NOTIMPL;
		}

		public virtual int OnQueryUnloadProject(IVsHierarchy pRealHierarchy, ref int cancel)
		{
			return VSConstants.E_NOTIMPL;
		}
		#endregion

		#region IVsSolutionEvents4 methods
		public virtual int OnAfterAsynchOpenProject(IVsHierarchy hierarchy, int added)
		{
			return VSConstants.E_NOTIMPL;
		}

		public virtual int OnAfterChangeProjectParent(IVsHierarchy hierarchy)
		{
			return VSConstants.E_NOTIMPL;
		}

		public virtual int OnAfterRenameProject(IVsHierarchy hierarchy)
		{
			return VSConstants.E_NOTIMPL;
		}

		/// <summary>
		/// Fired before a project is moved from one parent to another in the solution explorer
		/// </summary>
		public virtual int OnQueryChangeProjectParent(IVsHierarchy hierarchy, IVsHierarchy newParentHier, ref int cancel)
		{
			return VSConstants.E_NOTIMPL;
		}
		#endregion

		#region Dispose		

		/// <summary>
		/// The IDispose interface Dispose method for disposing the object determinastically.
		/// </summary>
		public void Dispose()
		{
			this.Dispose(true);
			GC.SuppressFinalize(this);
		}

		#endregion

		#region methods
		public void Init()
		{
			if (this.solution != null)
			{
				this.solution.AdviseSolutionEvents(this, out this.eventsCookie);
			}
		}

		/// <summary>
		/// The method that does the cleanup.
		/// </summary>
		/// <param name="disposing"></param>
		protected virtual void Dispose(bool disposing)
		{
			// Everybody can go here.
			if (!this.isDisposed)
			{
				// Synchronize calls to the Dispose simulteniously.
				lock (Mutex)
				{
					if (disposing && this.eventsCookie != (uint)ShellConstants.VSCOOKIE_NIL && this.solution != null)
					{
						this.solution.UnadviseSolutionEvents((uint)this.eventsCookie);
						this.eventsCookie = (uint)ShellConstants.VSCOOKIE_NIL;
					}

					this.isDisposed = true;
				}
			}
		}
		#endregion
	}
}

--- NEW FILE: singlefilegeneratorfactory.cs ---
/***************************************************************************

Copyright (c) Microsoft Corporation. All rights reserved.
This code is licensed under the Visual Studio SDK license terms.
THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.

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

namespace Microsoft.VisualStudio.Package
{
	using System;
	using System.Runtime.InteropServices;
	using System.Collections.Generic;
	using System.IO;
	using System.Diagnostics;
	using System.Globalization;
	using Microsoft.VisualStudio.Shell;
	using Microsoft.VisualStudio.Shell.Interop;
	using Microsoft.VisualStudio.OLE.Interop;
	using Microsoft.VisualStudio.TextManager.Interop;
	using Microsoft.Win32;

	/// <summary>
	/// Provides implementation IVsSingleFileGeneratorFactory for
	/// </summary>
	public class SingleFileGeneratorFactory : IVsSingleFileGeneratorFactory
	{
		#region nested types
		private class GeneratorMetaData
		{
			#region fields
			private Guid generatorClsid = Guid.Empty;
			private int generatesDesignTimeSource = -1;
			private int generatesSharedDesignTimeSource = -1;
			private int useDesignTimeCompilationFlag = -1;
			object generator = null;
			#endregion

			#region ctor
			/// <summary>
			/// Constructor
			/// </summary>
			public GeneratorMetaData()
			{
			}
			#endregion

			#region Public Properties
			/// <summary>
			/// Generator instance
			/// </summary>
			public Object Generator
			{
				get
				{
					return generator;
				}
				set
				{
					generator = value;
				}
			}

			/// <summary>
			/// GeneratesDesignTimeSource reg value name under HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\[VsVer]\Generators\[ProjFacGuid]\[GeneratorProgId]
			/// </summary>
			public int GeneratesDesignTimeSource
			{
				get
				{
					return generatesDesignTimeSource;
				}
				set
				{
					generatesDesignTimeSource = value;
				}
			}

			/// <summary>
			/// GeneratesSharedDesignTimeSource reg value name under HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\[VsVer]\Generators\[ProjFacGuid]\[GeneratorProgId]
			/// </summary>
			public int GeneratesSharedDesignTimeSource
			{
				get
				{
					return generatesSharedDesignTimeSource;
				}
				set
				{
					generatesSharedDesignTimeSource = value;
				}
			}

			/// <summary>
			/// UseDesignTimeCompilationFlag reg value name under HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\[VsVer]\Generators\[ProjFacGuid]\[GeneratorProgId]
			/// </summary>
			public int UseDesignTimeCompilationFlag
			{
				get
				{
					return useDesignTimeCompilationFlag;
				}
				set
				{
					useDesignTimeCompilationFlag = value;
				}
			}

			/// <summary>
			/// Generator Class ID.
			/// </summary>
			public Guid GeneratorClsid
			{
				get
				{
					return generatorClsid;
				}
				set
				{
					generatorClsid = value;
				}
			}
			#endregion
		}
		#endregion

		#region fields
		/// <summary>
		/// Base generator registry key for MPF based project
		/// </summary>
		private RegistryKey baseGeneratorRegistryKey = null;

		/// <summary>
		/// CLSID reg value name under HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\[VsVer]\Generators\[ProjFacGuid]\[GeneratorProgId]
		/// </summary>
		private string GeneratorClsid = "CLSID";

		/// <summary>
		/// GeneratesDesignTimeSource reg value name under HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\[VsVer]\Generators\[ProjFacGuid]\[GeneratorProgId]
		/// </summary>
		private string GeneratesDesignTimeSource = "GeneratesDesignTimeSource";

		/// <summary>
		/// GeneratesSharedDesignTimeSource reg value name under HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\[VsVer]\Generators\[ProjFacGuid]\[GeneratorProgId]
		/// </summary>
		private string GeneratesSharedDesignTimeSource = "GeneratesSharedDesignTimeSource";

		/// <summary>
		/// UseDesignTimeCompilationFlag reg value name under HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\[VsVer]\Generators\[ProjFacGuid]\[GeneratorProgId]
		/// </summary>
		private string UseDesignTimeCompilationFlag = "UseDesignTimeCompilationFlag";

		/// <summary>
		/// Caches all the generators registered for the project type.
		/// </summary>
		private Dictionary<string, GeneratorMetaData> generatorsMap = new Dictionary<string, GeneratorMetaData>();

		/// <summary>
		/// The associated project guid.
		/// </summary>
		private Guid projectGuid;

		/// <summary>
		/// A service provider
		/// </summary>
		private System.IServiceProvider serviceProvider;
		#endregion

		#region ctor
		/// <summary>
		/// Overridden ctor.
		/// </summary>
		/// <param name="projectGuid">The project type guid of the assoiciated project</param>
		/// <param name="serviceProvider">An associated service provider.</param>
		public SingleFileGeneratorFactory(Guid projectGuid, System.IServiceProvider serviceProvider)
		{
			this.projectGuid = projectGuid;
			this.serviceProvider = serviceProvider;
		}

		/// <summary>
		/// Default ctor.
		/// </summary>
		public SingleFileGeneratorFactory()
		{ 
		}

		#endregion

		#region properties
		/// <summary>
		/// Defines the project type guid of the associated project.
		/// </summary>
		public Guid ProjectGuid
		{
			get { return this.projectGuid; }
			set { this.projectGuid = value; }
		}

		/// <summary>
		/// Defines an associated service provider.
		/// </summary>
		public System.IServiceProvider ServiceProvider
		{
			get { return this.serviceProvider; }
			set { this.serviceProvider = value; }
		}
		#endregion
		#region IVsSingleFileGeneratorFactory Helpers
		/// <summary>
		/// Returns the project generator key under HKLM\SOFTWARE\Microsoft\VisualStudio\[version]\Generators
		/// </summary>
		private RegistryKey BaseGeneratorsKey
		{
			get
			{
				if (this.baseGeneratorRegistryKey == null)
				{
					string regRoot;
					ILocalRegistry2 pLocReg = this.LocalRegistry as ILocalRegistry2;
					ErrorHandler.ThrowOnFailure(pLocReg.GetLocalRegistryRoot(out regRoot));
					string regPath = Path.Combine(Path.Combine(regRoot, "Generators"), this.ProjectGuid.ToString("B"));
					baseGeneratorRegistryKey = Registry.LocalMachine.OpenSubKey(regPath);
				}

				return this.baseGeneratorRegistryKey;
			}
		}

		/// <summary>
		/// Returns the local registry instance
		/// </summary>
		private ILocalRegistry LocalRegistry
		{
			get
			{
				return this.serviceProvider.GetService(typeof(SLocalRegistry)) as ILocalRegistry;
			}
		}
		#endregion

		#region IVsSingleFileGeneratorFactory Members
		/// <summary>
		/// Creates an instance of the single file generator requested
		/// </summary>
		/// <param name="progId">prog id of the generator to be created. For e.g HKLM\SOFTWARE\Microsoft\VisualStudio\9.0Exp\Generators\[prjfacguid]\[wszProgId]</param>
		/// <param name="generatesDesignTimeSource">GeneratesDesignTimeSource key value</param>
		/// <param name="generatesSharedDesignTimeSource">GeneratesSharedDesignTimeSource key value</param>
		/// <param name="useTempPEFlag">UseDesignTimeCompilationFlag key value</param>
		/// <param name="generate">IVsSingleFileGenerator interface</param>
		/// <returns>S_OK if succesful</returns>
		public virtual int CreateGeneratorInstance(string progId, out int generatesDesignTimeSource, out int generatesSharedDesignTimeSource, out int useTempPEFlag, out IVsSingleFileGenerator generate)
		{
			Guid genGuid;
			ErrorHandler.ThrowOnFailure(this.GetGeneratorInformation(progId, out generatesDesignTimeSource, out generatesSharedDesignTimeSource, out useTempPEFlag, out genGuid));

			//Create the single file generator and pass it out. Check to see if it is in the cache
			if (!this.generatorsMap.ContainsKey(progId) || ((this.generatorsMap[progId]).Generator == null))
			{
				Guid riid = VSConstants.IID_IUnknown;
				uint dwClsCtx = (uint)CLSCTX.CLSCTX_INPROC_SERVER;
				IntPtr genIUnknown = IntPtr.Zero;
				//create a new one.
				ErrorHandler.ThrowOnFailure(this.LocalRegistry.CreateInstance(genGuid, null, ref riid, dwClsCtx, out genIUnknown));
				if (genIUnknown != IntPtr.Zero)
				{
					try
					{
						object generator = Marshal.GetObjectForIUnknown(genIUnknown);
						//Build the generator meta data object and cache it.
						GeneratorMetaData genData = new GeneratorMetaData();
						genData.GeneratesDesignTimeSource = generatesDesignTimeSource;
						genData.GeneratesSharedDesignTimeSource = generatesSharedDesignTimeSource;
						genData.UseDesignTimeCompilationFlag = useTempPEFlag;
						genData.GeneratorClsid = genGuid;
						genData.Generator = generator;
						this.generatorsMap[progId] = genData;
					}
					finally
					{
						Marshal.Release(genIUnknown);
					}
				}
			}

			generate = (this.generatorsMap[progId]).Generator as IVsSingleFileGenerator;

			return VSConstants.S_OK;
		}

		/// <summary>
		/// Gets the default generator based on the file extension. HKLM\Software\Microsoft\VS\9.0\Generators\[prjfacguid]\.extension
		/// </summary>
		/// <param name="filename">File name with extension</param>
		/// <param name="progID">The generator prog ID</param>
		/// <returns>S_OK if successful</returns>
		public virtual int GetDefaultGenerator(string filename, out string progID)
		{
			progID = "";
			return VSConstants.E_NOTIMPL;
		}

		/// <summary>
		/// Gets the generator information.
		/// </summary>
		/// <param name="progId">prog id of the generator to be created. For e.g HKLM\SOFTWARE\Microsoft\VisualStudio\9.0Exp\Generators\[prjfacguid]\[wszProgId]</param>
		/// <param name="generatesDesignTimeSource">GeneratesDesignTimeSource key value</param>
		/// <param name="generatesSharedDesignTimeSource">GeneratesSharedDesignTimeSource key value</param>
		/// <param name="useTempPEFlag">UseDesignTimeCompilationFlag key value</param>
		/// <param name="guiddGenerator">CLSID key value</param>
		/// <returns>S_OK if succesful</returns>
		public virtual int GetGeneratorInformation(string progId, out int generatesDesignTimeSource, out int generatesSharedDesignTimeSource, out int useTempPEFlag, out Guid guidGenerator)
		{
			RegistryKey genKey;
			generatesDesignTimeSource = -1;
			generatesSharedDesignTimeSource = -1;
			useTempPEFlag = -1;
			guidGenerator = Guid.Empty;
			if (string.IsNullOrEmpty(progId))
				return VSConstants.S_FALSE;

			//Create the single file generator and pass it out.
			if (!this.generatorsMap.ContainsKey(progId))
			{
				// We have to check whether the BaseGeneratorkey returns null.
				RegistryKey tempBaseGeneratorKey = this.BaseGeneratorsKey;
				if (tempBaseGeneratorKey == null || (genKey = tempBaseGeneratorKey.OpenSubKey(progId)) == null)
				{
					return VSConstants.S_FALSE;
				}

				//Get the CLSID
				string guid = (string)genKey.GetValue(GeneratorClsid, "");
				if (string.IsNullOrEmpty(guid))
					return VSConstants.S_FALSE;

				GeneratorMetaData genData = new GeneratorMetaData();

				genData.GeneratorClsid = guidGenerator = new Guid(guid);
				//Get the GeneratesDesignTimeSource flag. Assume 0 if not present.
				genData.GeneratesDesignTimeSource = generatesDesignTimeSource = (int)genKey.GetValue(this.GeneratesDesignTimeSource, 0);
				//Get the GeneratesSharedDesignTimeSource flag. Assume 0 if not present.
				genData.GeneratesSharedDesignTimeSource = generatesSharedDesignTimeSource = (int)genKey.GetValue(GeneratesSharedDesignTimeSource, 0);
				//Get the UseDesignTimeCompilationFlag flag. Assume 0 if not present.
				genData.UseDesignTimeCompilationFlag = useTempPEFlag = (int)genKey.GetValue(UseDesignTimeCompilationFlag, 0);
				this.generatorsMap.Add(progId, genData);
			}
			else
			{
				GeneratorMetaData genData = this.generatorsMap[progId];
				generatesDesignTimeSource = genData.GeneratesDesignTimeSource;
				//Get the GeneratesSharedDesignTimeSource flag. Assume 0 if not present.
				generatesSharedDesignTimeSource = genData.GeneratesSharedDesignTimeSource;
				//Get the UseDesignTimeCompilationFlag flag. Assume 0 if not present.
				useTempPEFlag = genData.UseDesignTimeCompilationFlag;
				//Get the CLSID
				guidGenerator = genData.GeneratorClsid;
			}

			return VSConstants.S_OK;
		}
		#endregion

	}
}

--- NEW FILE: projectnode.cs ---
/***************************************************************************

Copyright (c) Microsoft Corporation. All rights reserved.
This code is licensed under the Visual Studio SDK license terms.
THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.

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

using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Drawing;
using System.IO;
using System.Runtime.InteropServices;
[...5800 lines suppressed...]
        /// </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;
                }
            }
        }
        #endregion
    }
}

--- NEW FILE: securitywarningdialog.designer.cs ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: configprovider.cs ---
/***************************************************************************

Copyright (c) Microsoft Corporation. All rights reserved.
This code is licensed under the Visual Studio SDK license terms.
THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.

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

using Microsoft.VisualStudio.Shell.Interop;
using System;
using System.Runtime.InteropServices;
using Microsoft.VisualStudio.OLE.Interop;
using Microsoft.VisualStudio.Shell;
using System.Diagnostics;
using System.Globalization;
using System.Collections;
using System.IO;
using MSBuild = Microsoft.Build.BuildEngine;
using System.Collections.Generic;
using EnvDTE;

/* This file provides a basefunctionallity for IVsCfgProvider2.
   Instead of using the IVsProjectCfgEventsHelper object we have our own little sink and call our own helper methods
   similiar to the interface. But there is no real benefit in inheriting from the interface in the first place. 
   Using the helper object seems to be:  
    a) undocumented
    b) not really wise in the managed world
*/
namespace Microsoft.VisualStudio.Package
{

    [CLSCompliant(false)]
    [ComVisible(true)]
    public class ConfigProvider : IVsCfgProvider2, IVsProjectCfgProvider, IVsExtensibleObject
    {
        #region fields
        internal const string configString = " '$(Configuration)' == '{0}' ";
        internal const string AnyCPUPlatform = "Any CPU";

        private ProjectNode project;
        private EventSinkCollection cfgEventSinks = new EventSinkCollection();
        private List<KeyValuePair<KeyValuePair<string, string>, string>> newCfgProps = new List<KeyValuePair<KeyValuePair<string, string>, string>>();
        private Dictionary<string, ProjectConfig> configurationsList = new Dictionary<string, ProjectConfig>();
        #endregion

        #region Properties
        /// <summary>
        /// The associated project.
        /// </summary>
        protected ProjectNode ProjectMgr
        {
            get
            {
                return this.project;
            }
        }
        /// <summary>
        /// If the project system wants to add custom properties to the property group then 
        /// they provide us with this data.
        /// Returns/sets the [(<propName, propCondition>) <propValue>] collection
        /// </summary>
        public virtual List<KeyValuePair<KeyValuePair<string, string>, string>> NewConfigProperties
        {
            get
            {
                return newCfgProps;
            }
            set
            {
                newCfgProps = value;
            }
        }

        #endregion

        #region ctors
        public ConfigProvider(ProjectNode manager)
        {
            this.project = manager;
        }
        #endregion

        #region methods
        /// <summary>
        /// Creates new Project Configuartion objects based on the configuration name.
        /// </summary>
        /// <param name="configName">The name of the configuration</param>
        /// <returns>An instance of a ProjectConfig object.</returns>
        protected ProjectConfig GetProjectConfiguration(string configName)
        {
            // if we already created it, return the cached one
            if (configurationsList.ContainsKey(configName))
            {
                return configurationsList[configName];
            }

            ProjectConfig requestedConfiguration = CreateProjectConfiguration(configName);
            configurationsList.Add(configName, requestedConfiguration);

            return requestedConfiguration;
        }

        protected virtual ProjectConfig CreateProjectConfiguration(string configName)
        {
            return new ProjectConfig(this.project, configName);
        }

        #endregion

        #region IVsProjectCfgProvider methods
        /// <summary>
        /// Provides access to the IVsProjectCfg interface implemented on a project's configuration object. 
        /// </summary>
        /// <param name="projectCfgCanonicalName">The canonical name of the configuration to access.</param>
        /// <param name="projectCfg">The IVsProjectCfg interface of the configuration identified by szProjectCfgCanonicalName.</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code. </returns>
        public virtual int OpenProjectCfg(string projectCfgCanonicalName, out IVsProjectCfg projectCfg)
        {
            if (projectCfgCanonicalName == null)
            {
                throw new ArgumentNullException("projectCfgCanonicalName");
            }

            projectCfg = null;

            // Be robust in release
            if (projectCfgCanonicalName == null)
            {
                return VSConstants.E_INVALIDARG;
            }

            Debug.Assert(this.project != null && this.project.BuildProject != null);

            string[] configs = this.project.BuildProject.GetConditionedPropertyValues(ProjectFileConstants.Configuration);

            foreach (string config in configs)
            {
                if (String.Compare(config, projectCfgCanonicalName, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    projectCfg = this.GetProjectConfiguration(config);
                    if (projectCfg != null)
                    {
                        return VSConstants.S_OK;
                    }
                    else
                    {
                        return VSConstants.E_FAIL;
                    }
                }
            }

            return VSConstants.E_INVALIDARG;
        }

        /// <summary>
        /// Checks whether or not this configuration provider uses independent configurations. 
        /// </summary>
        /// <param name="usesIndependentConfigurations">true if independent configurations are used, false if they are not used. By default returns true.</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns>
        public virtual int get_UsesIndependentConfigurations(out int usesIndependentConfigurations)
        {
            usesIndependentConfigurations = 1;
            return VSConstants.S_OK;
        }
        #endregion

        #region IVsCfgProvider2 methods
        /// <summary>
        /// Copies an existing configuration name or creates a new one. 
        /// </summary>
        /// <param name="name">The name of the new configuration.</param>
        /// <param name="cloneName">the name of the configuration to copy, or a null reference, indicating that AddCfgsOfCfgName should create a new configuration.</param>
        /// <param name="fPrivate">Flag indicating whether or not the new configuration is private. If fPrivate is set to true, the configuration is private. If set to false, the configuration is public. This flag can be ignored.</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code. </returns>
        public virtual int AddCfgsOfCfgName(string name, string cloneName, int fPrivate)
        {
            // We need to QE/QS the project file
            if (!this.ProjectMgr.QueryEditProjectFile(false))
            {
                throw Marshal.GetExceptionForHR(VSConstants.OLE_E_PROMPTSAVECANCELLED);
            }

            // First create the condition that represent the configuration we want to clone
            string condition = (cloneName == null ? String.Empty : String.Format(CultureInfo.InvariantCulture, configString, cloneName).Trim());

            // Get all configs
            MSBuild.BuildPropertyGroupCollection configGroup = this.project.BuildProject.PropertyGroups;
            MSBuild.BuildPropertyGroup configToClone = null;

            if (cloneName != null)
            {
                // Find the configuration to clone
                foreach (MSBuild.BuildPropertyGroup currentConfig in configGroup)
                {
                    // Only care about conditional property groups
                    if (currentConfig.Condition == null || currentConfig.Condition.Length == 0)
                        continue;

                    // Skip if it isn't the group we want
                    if (String.Compare(currentConfig.Condition.Trim(), condition, StringComparison.OrdinalIgnoreCase) != 0)
                        continue;

                    configToClone = currentConfig;
                }
            }

            MSBuild.BuildPropertyGroup newConfig = null;
            if (configToClone != null)
            {
                // Clone the configuration settings
                newConfig = this.project.ClonePropertyGroup(configToClone);
                //Will be added later with the new values to the path
                newConfig.RemoveProperty("OutputPath");
            }
            else
            {
                // no source to clone from, lets just create a new empty config
                newConfig = this.project.BuildProject.AddNewPropertyGroup(false);
                // Get the list of property name, condition value from the config provider
                IList<KeyValuePair<KeyValuePair<string, string>, string>> propVals = this.NewConfigProperties;
                foreach (KeyValuePair<KeyValuePair<string, string>, string> data in propVals)
                {
                    KeyValuePair<string, string> propData = data.Key;
                    string value = data.Value;
                    MSBuild.BuildProperty newProperty = newConfig.AddNewProperty(propData.Key, value);
                    if (!String.IsNullOrEmpty(propData.Value))
                        newProperty.Condition = propData.Value;
                }
            }

            //add the output path
            string outputBasePath = this.ProjectMgr.OutputBaseRelativePath;
            if (outputBasePath.EndsWith(Path.DirectorySeparatorChar.ToString()))
                outputBasePath = Path.GetDirectoryName(outputBasePath);
            newConfig.AddNewProperty("OutputPath", Path.Combine(outputBasePath, name) + Path.DirectorySeparatorChar.ToString());

            // Set the condition that will define the new configuration
            string newCondition = String.Format(CultureInfo.InvariantCulture, configString, name);
            newConfig.Condition = newCondition;

            NotifyOnCfgNameAdded(name);
            return VSConstants.S_OK;
        }

        /// <summary>
        /// Copies an existing platform name or creates a new one. 
        /// </summary>
        /// <param name="platformName">The name of the new platform.</param>
        /// <param name="clonePlatformName">The name of the platform to copy, or a null reference, indicating that AddCfgsOfPlatformName should create a new platform.</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns>
        public virtual int AddCfgsOfPlatformName(string platformName, string clonePlatformName)
        {
            return VSConstants.E_NOTIMPL;
        }

        /// <summary>
        /// Deletes a specified configuration name. 
        /// </summary>
        /// <param name="name">The name of the configuration to be deleted.</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code. </returns>
        public virtual int DeleteCfgsOfCfgName(string name)
        {
            // We need to QE/QS the project file
            if (!this.ProjectMgr.QueryEditProjectFile(false))
            {
                throw Marshal.GetExceptionForHR(VSConstants.OLE_E_PROMPTSAVECANCELLED);
            }

            if (name == null)
            {
                Debug.Fail(String.Format(CultureInfo.CurrentCulture, "Name of the configuration should not be null if you want to delete it from project: {0}", this.project.BuildProject.FullFileName));
                // The configuration " '$(Configuration)' ==  " does not exist, so technically the goal
                // is achieved so return S_OK
                return VSConstants.S_OK;
            }
            // Verify that this config exist
            string[] configs = this.project.BuildProject.GetConditionedPropertyValues(ProjectFileConstants.Configuration);
            foreach (string config in configs)
            {
                if (String.Compare(config, name, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    // Create condition of config to remove
                    string condition = String.Format(CultureInfo.InvariantCulture, configString, config);
                    this.project.BuildProject.RemovePropertyGroupsWithMatchingCondition(condition);

                    NotifyOnCfgNameDeleted(name);
                }
            }

            return VSConstants.S_OK;
        }

        /// <summary>
        /// Deletes a specified platform name. 
        /// </summary>
        /// <param name="platName">The platform name to delet.</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns>
        public virtual int DeleteCfgsOfPlatformName(string platName)
        {
            return VSConstants.E_NOTIMPL;
        }

        /// <summary>
        /// Returns the existing configurations stored in the project file.
        /// </summary>
        /// <param name="celt">Specifies the requested number of property names. If this number is unknown, celt can be zero.</param>
        /// <param name="names">On input, an allocated array to hold the number of configuration property names specified by celt. This parameter can also be a null reference if the celt parameter is zero. 
        /// On output, names contains configuration property names.</param>
        /// <param name="actual">The actual number of property names returned.</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns>
        public virtual int GetCfgNames(uint celt, string[] names, uint[] actual)
        {
            // get's called twice, once for allocation, then for retrieval            
            int i = 0;

            string[] configList = this.project.BuildProject.GetConditionedPropertyValues(ProjectFileConstants.Configuration);

            if (names != null)
            {
                foreach (string config in configList)
                {
                    names[i++] = config;
                    if (i == celt)
                        break;
                }
            }
            else
                i = configList.Length;

            if (actual != null)
            {
                actual[0] = (uint)i;
            }

            return VSConstants.S_OK;
        }

        /// <summary>
        /// Returns the configuration associated with a specified configuration or platform name. 
        /// </summary>
        /// <param name="name">The name of the configuration to be returned.</param>
        /// <param name="platName">The name of the platform for the configuration to be returned.</param>
        /// <param name="cfg">The implementation of the IVsCfg interface.</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns>
        public virtual int GetCfgOfName(string name, string platName, out IVsCfg cfg)
        {
            cfg = null;
            cfg = this.GetProjectConfiguration(name);

            return VSConstants.S_OK;
        }

        /// <summary>
        /// Returns a specified configuration property. 
        /// </summary>
        /// <param name="propid">Specifies the property identifier for the property to return. For valid propid values, see __VSCFGPROPID.</param>
        /// <param name="var">The value of the property.</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns>
        public virtual int GetCfgProviderProperty(int propid, out object var)
        {
            var = false;
            switch ((__VSCFGPROPID)propid)
            {
                case __VSCFGPROPID.VSCFGPROPID_SupportsCfgAdd:
                    var = true;
                    break;

                case __VSCFGPROPID.VSCFGPROPID_SupportsCfgDelete:
                    var = true;
                    break;

                case __VSCFGPROPID.VSCFGPROPID_SupportsCfgRename:
                    var = true;
                    break;

                case __VSCFGPROPID.VSCFGPROPID_SupportsPlatformAdd:
                    var = false;
                    break;

                case __VSCFGPROPID.VSCFGPROPID_SupportsPlatformDelete:
                    var = false;
                    break;
            }
            return VSConstants.S_OK;
        }

        /// <summary>
        /// Returns the per-configuration objects for this object. 
        /// </summary>
        /// <param name="celt">Number of configuration objects to be returned or zero, indicating a request for an unknown number of objects.</param>
        /// <param name="a">On input, pointer to an interface array or a null reference. On output, this parameter points to an array of IVsCfg interfaces belonging to the requested configuration objects.</param>
        /// <param name="actual">The number of configuration objects actually returned or a null reference, if this information is not necessary.</param>
        /// <param name="flags">Flags that specify settings for project configurations, or a null reference (Nothing in Visual Basic) if no additional flag settings are required. For valid prgrFlags values, see __VSCFGFLAGS.</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns>
        public virtual int GetCfgs(uint celt, IVsCfg[] a, uint[] actual, uint[] flags)
        {
            if (flags != null)
                flags[0] = 0;

            int i = 0;
            string[] configList = this.project.BuildProject.GetConditionedPropertyValues(ProjectFileConstants.Configuration);

            if (a != null)
            {
                foreach (string configName in configList)
                {
                    a[i] = this.GetProjectConfiguration(configName);

                    i++;
                    if (i == celt)
                        break;
                }
            }
            else
                i = configList.Length;

            if (actual != null)
                actual[0] = (uint)i;

            return VSConstants.S_OK;
        }

        /// <summary>
        /// Returns one or more platform names. 
        /// </summary>
        /// <param name="celt">Specifies the requested number of platform names. If this number is unknown, celt can be zero.</param>
        /// <param name="names">On input, an allocated array to hold the number of platform names specified by celt. This parameter can also be a null reference if the celt parameter is zero. On output, names contains platform names.</param>
        /// <param name="actual">The actual number of platform names returned.</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns>
        public virtual int GetPlatformNames(uint celt, string[] names, uint[] actual)
        {
            string[] platforms = this.GetPlatformsFromProject();
            return GetPlatforms(celt, names, actual, platforms);
        }

        /// <summary>
        /// Returns the set of platforms that are installed on the user's machine. 
        /// </summary>
        /// <param name="celt">Specifies the requested number of supported platform names. If this number is unknown, celt can be zero.</param>
        /// <param name="names">On input, an allocated array to hold the number of names specified by celt. This parameter can also be a null reference (Nothing in Visual Basic)if the celt parameter is zero. On output, names contains the names of supported platforms</param>
        /// <param name="actual">The actual number of platform names returned.</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns>
        public virtual int GetSupportedPlatformNames(uint celt, string[] names, uint[] actual)
        {
            string[] platforms = this.GetSupportedPlatformsFromProject();
            return GetPlatforms(celt, names, actual, platforms);
        }

        /// <summary>
        /// Assigns a new name to a configuration. 
        /// </summary>
        /// <param name="old">The old name of the target configuration.</param>
        /// <param name="newname">The new name of the target configuration.</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns>
        public virtual int RenameCfgsOfCfgName(string old, string newname)
        {
            // First create the condition that represent the configuration we want to rename
            string condition = String.Format(CultureInfo.InvariantCulture, configString, old).Trim();

            foreach (MSBuild.BuildPropertyGroup config in this.project.BuildProject.PropertyGroups)
            {
                // Only care about conditional property groups
                if (config.Condition == null || config.Condition.Length == 0)
                    continue;

                // Skip if it isn't the group we want
                if (String.Compare(config.Condition.Trim(), condition, StringComparison.OrdinalIgnoreCase) != 0)
                    continue;

                // Change the name 
                config.Condition = String.Format(CultureInfo.InvariantCulture, configString, newname);
                // Update the name in our config list
                if (configurationsList.ContainsKey(old))
                {
                    ProjectConfig configuration = configurationsList[old];
                    configurationsList.Remove(old);
                    configurationsList.Add(newname, configuration);
                    // notify the configuration of its new name
                    configuration.ConfigName = newname;
                }

                NotifyOnCfgNameRenamed(old, newname);
            }

            return VSConstants.S_OK;
        }

        /// <summary>
        /// Cancels a registration for configuration event notification. 
        /// </summary>
        /// <param name="cookie">The cookie used for registration.</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns>
        public virtual int UnadviseCfgProviderEvents(uint cookie)
        {
            this.cfgEventSinks.RemoveAt(cookie);
            return VSConstants.S_OK;
        }

        /// <summary>
        /// Registers the caller for configuration event notification. 
        /// </summary>
        /// <param name="sink">Reference to the IVsCfgProviderEvents interface to be called to provide notification of configuration events.</param>
        /// <param name="cookie">Reference to a token representing the completed registration</param>
        /// <returns>If the method succeeds, it returns S_OK. If it fails, it returns an error code.</returns>
        public virtual int AdviseCfgProviderEvents(IVsCfgProviderEvents sink, out uint cookie)
        {
            cookie = this.cfgEventSinks.Add(sink);
            return VSConstants.S_OK;
        }
        #endregion

        #region IVsExtensibleObject Members

        /// <summary>
        /// Proved access to an IDispatchable object being a list of configuration properties
        /// </summary>
        /// <param name="configurationName">Combined Name and Platform for the configuration requested</param>
        /// <param name="configurationProperties">The IDispatchcable object</param>
        /// <returns>S_OK if successful</returns>
        public virtual int GetAutomationObject(string configurationName, out object configurationProperties)
        {
            //Init out param
            configurationProperties = null;

            string name, platform;
            if (!ProjectConfig.TrySplitConfigurationCanonicalName(configurationName, out name, out platform))
            {
                return VSConstants.E_INVALIDARG;
            }

            // Get the configuration
            IVsCfg cfg;
            ErrorHandler.ThrowOnFailure(this.GetCfgOfName(name, platform, out cfg));

            // Get the properties of the configuration
            configurationProperties = ((ProjectConfig)cfg).ConfigurationProperties;

            return VSConstants.S_OK;

        }
        #endregion

        #region helper methods
        /// <summary>
        /// Called when a new config name was added.
        /// </summary>
        /// <param name="strCfgName">The config name.</param>
        private void NotifyOnCfgNameAdded(string strCfgName)
        {
            foreach (IVsCfgProviderEvents sink in this.cfgEventSinks)
                ErrorHandler.ThrowOnFailure(sink.OnCfgNameAdded(strCfgName));
        }

        /// <summary>
        /// Called when a config name was deleted.
        /// </summary>
        /// <param name="strCfgName">The name of the configuration.</param>
        private void NotifyOnCfgNameDeleted(string strCfgName)
        {
            foreach (IVsCfgProviderEvents sink in this.cfgEventSinks)
                ErrorHandler.ThrowOnFailure(sink.OnCfgNameDeleted(strCfgName));
        }
        // Called when a config name was renamed
        private void NotifyOnCfgNameRenamed(string strOldName, string strNewName)
        {
            foreach (IVsCfgProviderEvents sink in this.cfgEventSinks)
                ErrorHandler.ThrowOnFailure(sink.OnCfgNameRenamed(strOldName, strNewName));
        }

        /// <summary>
        /// Called when a platform name was added
        /// </summary>
        /// <param name="strPlatformName">The name of the platform.</param>
        private void NotifyOnPlatformNameAdded(string strPlatformName)
        {
            foreach (IVsCfgProviderEvents sink in this.cfgEventSinks)
                ErrorHandler.ThrowOnFailure(sink.OnPlatformNameAdded(strPlatformName));
        }

        /// <summary>
        /// Called when a platform name was deleted
        /// </summary>
        /// <param name="strPlatformName">The name of the platform.</param>
        private void NotifyOnPlatformNameDeleted(string strPlatformName)
        {
            foreach (IVsCfgProviderEvents sink in this.cfgEventSinks)
                ErrorHandler.ThrowOnFailure(sink.OnPlatformNameDeleted(strPlatformName));
        }

        /// <summary>
        /// Gets all the platforms defined in the project
        /// </summary>
        /// <returns>An array of platform names.</returns>
        private string[] GetPlatformsFromProject()
        {
            string[] platforms = this.ProjectMgr.BuildProject.GetConditionedPropertyValues(ProjectFileConstants.Platform);

            if (platforms == null || platforms.Length == 0)
            {
                return new string[] { AnyCPUPlatform };
            }

            for (int i = 0; i < platforms.Length; i++)
            {
                platforms[i] = ConvertPlatformToVsProject(platforms[i]);
            }

            return platforms;
        }

        /// <summary>
        /// Return the supported platform names.
        /// </summary>
        /// <returns>An array of supported platform names.</returns>
        private string[] GetSupportedPlatformsFromProject()
        {
            string platforms = this.ProjectMgr.BuildProject.GetEvaluatedProperty(ProjectFileConstants.AvailablePlatforms);

            if (platforms == null)
            {
                return new string[] { };
            }

            if (platforms.Contains(","))
            {
                return platforms.Split(',');
            }

            return new string[] { platforms };
        }

        /// <summary>
        /// Helper function to convert AnyCPU to Any CPU.
        /// </summary>
        /// <param name="oldName">The oldname.</param>
        /// <returns>The new name.</returns>
        private static string ConvertPlatformToVsProject(string oldPlatformName)
        {
            if (String.Compare(oldPlatformName, ProjectFileValues.AnyCPU, StringComparison.OrdinalIgnoreCase) == 0)
            {
                return AnyCPUPlatform;
            }

            return oldPlatformName;
        }

        /// <summary>
        /// Common method for handling platform names.
        /// </summary>
        /// <param name="celt">Specifies the requested number of platform names. If this number is unknown, celt can be zero.</param>
        /// <param name="names">On input, an allocated array to hold the number of platform names specified by celt. This parameter can also be null if the celt parameter is zero. On output, names contains platform names</param>
        /// <param name="actual">A count of the actual number of platform names returned.</param>
        /// <param name="platforms">An array of available platform names</param>
        /// <returns>A count of the actual number of platform names returned.</returns>
        /// <devremark>The platforms array is never null. It is assured by the callers.</devremark>
        private static int GetPlatforms(uint celt, string[] names, uint[] actual, string[] platforms)
        {
            Debug.Assert(platforms != null, "The plaforms array should never be null");
            if (names == null)
            {
                if (actual == null || actual.Length == 0)
                {
                    throw new ArgumentException(SR.GetString(SR.InvalidParameter), "actual");
                }

                actual[0] = (uint)platforms.Length;
                return VSConstants.S_OK;
            }

            //Degenarate case
            if (celt == 0)
            {
                if (actual != null && actual.Length != 0)
                {
                    actual[0] = (uint)platforms.Length;
                }

                return VSConstants.S_OK;
            }

            uint returned = 0;
            for (int i = 0; i < platforms.Length && names.Length > returned; i++)
            {
                names[returned] = platforms[i];
                returned++;
            }

            if (actual != null && actual.Length != 0)
            {
                actual[0] = returned;
            }

            if (celt > returned)
            {
                return VSConstants.S_FALSE;
            }

            return VSConstants.S_OK;
        }
        #endregion
    }
}

--- NEW FILE: securitywarningdialog.resx ---
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 

    Version 2.0

    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.

    Example:

    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>

    There are any number of "resheader" rows that contain simple 
    name/value pairs.

    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.

    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:

    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.

    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <assembly alias="System.Drawing" name="System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
  <data name="warningText.Font" type="System.Drawing.Font, System.Drawing">
    <value>Microsoft Sans Serif, 8.25pt</value>
  </data>
  <data name="warningText.Location" type="System.Drawing.Point, System.Drawing">
    <value>7, 7</value>
  </data>
  <data name="warningText.Size" type="System.Drawing.Size, System.Drawing">
    <value>488, 39</value>
  </data>
  <assembly alias="mscorlib" name="mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
  <data name="warningText.TabIndex" type="System.Int32, mscorlib">
    <value>0</value>
  </data>
  <data name="warningText.Text" xml:space="preserve">
    <value>The {0} project file has been customized and could present a security risk by executing custom build steps when opened in {1}. If this project came from an untrustworthy source, it could cause damage to your computer or compromise your priv...

[truncated message content]