[WiX-commits] wix/src/votive/sdk_vs2008/common/source/csharp/project/automation/vsproject oaassemblyreference.cs, NONE, 1.1 oabuildmanager.cs, NONE, 1.1 oacomreference.cs, NONE, 1.1 oaprojectreference.cs, NONE, 1.1 oareferencebase.cs, NONE, 1.1 oareferences.cs, NONE, 1.1 oavsproject.cs, NONE, 1.1 oavsprojectitem.cs, NONE, 1.1

[Rob M. <ro...@us...>]

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

Added Files:
	oaassemblyreference.cs oabuildmanager.cs oacomreference.cs 
	oaprojectreference.cs oareferencebase.cs oareferences.cs 
	oavsproject.cs oavsprojectitem.cs 
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: oavsproject.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 Microsoft.VisualStudio.Shell.Interop;
using Microsoft.VisualStudio.Shell;
using System.Runtime.InteropServices;
using System.Collections.Generic;
using System.Collections;
using System.Diagnostics;
using System.IO;
using IServiceProvider = System.IServiceProvider;
using Microsoft.VisualStudio.OLE.Interop;
using Microsoft.VisualStudio.Package;
using EnvDTE;
using VSLangProj;

namespace Microsoft.VisualStudio.Package.Automation
{
	[ComVisible(true), CLSCompliant(false)]
	public class OAVSProject : VSProject
	{
		#region fields
		private ProjectNode project;
		private OAVSProjectEvents events;
		#endregion

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

		#region VSProject Members

		public ProjectItem AddWebReference(string bstrUrl)
		{
			Debug.Fail("VSProject.AddWebReference not implemented");
			throw new Exception("The method or operation is not implemented.");
		}

		public BuildManager BuildManager
		{
			get
			{
				return new OABuildManager(this.project);
			}
		}

		public void CopyProject(string bstrDestFolder, string bstrDestUNCPath, prjCopyProjectOption copyProjectOption, string bstrUsername, string bstrPassword)
		{
			Debug.Fail("VSProject.References not implemented");
			throw new Exception("The method or operation is not implemented.");
		}

		public ProjectItem CreateWebReferencesFolder()
		{
			Debug.Fail("VSProject.CreateWebReferencesFolder not implemented");
			throw new Exception("The method or operation is not implemented.");
		}

		public DTE DTE
		{
			get
			{
				return (EnvDTE.DTE)this.project.Site.GetService(typeof(EnvDTE.DTE));
			}
		}

		public VSProjectEvents Events
		{
			get
			{
				if (events == null)
					events = new OAVSProjectEvents(this);
				return events;
			}
		}

		public void Exec(prjExecCommand command, int bSuppressUI, object varIn, out object pVarOut)
		{
			Debug.Fail("VSProject.Exec not implemented");
			throw new Exception("The method or operation is not implemented.");
		}

		public void GenerateKeyPairFiles(string strPublicPrivateFile, string strPublicOnlyFile)
		{
			Debug.Fail("VSProject.GenerateKeyPairFiles not implemented");
			throw new Exception("The method or operation is not implemented.");
		}

		public string GetUniqueFilename(object pDispatch, string bstrRoot, string bstrDesiredExt)
		{
			Debug.Fail("VSProject.GetUniqueFilename not implemented");
			throw new Exception("The method or operation is not implemented.");
		}

		public Imports Imports
		{
			get
			{
				Debug.Fail("VSProject.Imports not implemented");
				throw new Exception("The method or operation is not implemented.");
			}
		}

		public Project Project
		{
			get
			{
				return this.project.GetAutomationObject() as Project;
			}
		}

		public References References
		{
			get
			{
				ReferenceContainerNode references = project.GetReferenceContainer() as ReferenceContainerNode;
				if (null == references)
				{
					return null;
				}
				return references.Object as References;
			}
		}

		public void Refresh()
		{
			Debug.Fail("VSProject.Refresh not implemented");
			throw new Exception("The method or operation is not implemented.");
		}

		public string TemplatePath
		{
			get
			{
				Debug.Fail("VSProject.TemplatePath not implemented");
				throw new Exception("The method or operation is not implemented.");
			}
		}

		public ProjectItem WebReferencesFolder
		{
			get
			{
				Debug.Fail("VSProject.WebReferencesFolder not implemented");
				throw new Exception("The method or operation is not implemented.");
			}
		}

		public bool WorkOffline
		{
			get
			{
				Debug.Fail("VSProject.WorkOffLine not implemented");
				throw new Exception("The method or operation is not implemented.");
			}
			set
			{
				Debug.Fail("VSProject.Set_WorkOffLine not implemented");
				throw new Exception("The method or operation is not implemented.");
			}
		}

		#endregion
	}

	[ComVisible(true), CLSCompliant(false)]
	public class OAVSProjectEvents : VSProjectEvents
	{
		#region fields
		private OAVSProject vsProject;
		#endregion

		#region ctors
		public OAVSProjectEvents(OAVSProject vsProject)
		{
			this.vsProject = vsProject;
		}
		#endregion

		#region VSProjectEvents Members

		public BuildManagerEvents BuildManagerEvents
		{
			get
			{
				return vsProject.BuildManager as BuildManagerEvents;
			}
		}

		public ImportsEvents ImportsEvents
		{
			get
			{
				Debug.Fail("VSProjectEvents.ImportsEvents not implemented");
				throw new Exception("The method or operation is not implemented.");
			}
		}

		public ReferencesEvents ReferencesEvents
		{
			get
			{
				return vsProject.References as ReferencesEvents;
			}
		}

		#endregion
	}

}

--- NEW FILE: oareferencebase.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.Runtime.InteropServices;

using Microsoft.VisualStudio.Package;
using VSLangProj;

namespace Microsoft.VisualStudio.Package.Automation
{
    [ComVisible(true)]
	public class OAReferenceBase<RefType> : Reference
		where RefType : ReferenceNode
	{
		private RefType referenceNode;
		public OAReferenceBase(RefType referenceNode)
		{
			this.referenceNode = referenceNode;
		}

		protected RefType BaseReferenceNode
		{
			get { return referenceNode; }
		}

		#region Reference Members
		public virtual int BuildNumber
		{
			get { return 0; }
		}

		public virtual References Collection
		{
			get
			{
				return BaseReferenceNode.Parent.Object as References;
			}
		}

		public virtual EnvDTE.Project ContainingProject
		{
			get
			{
				return BaseReferenceNode.ProjectMgr.GetAutomationObject() as EnvDTE.Project;
			}
		}

		public virtual bool CopyLocal
		{
			get
			{
				throw new Exception("The method or operation is not implemented.");
			}
			set
			{
				throw new Exception("The method or operation is not implemented.");
			}
		}

		public virtual string Culture
		{
			get { throw new Exception("The method or operation is not implemented."); }
		}

		public virtual EnvDTE.DTE DTE
		{
			get
			{
				return BaseReferenceNode.ProjectMgr.Site.GetService(typeof(EnvDTE.DTE)) as EnvDTE.DTE;
			}
		}

		public virtual string Description
		{
			get
			{
				return this.Name;
			}
		}

		public virtual string ExtenderCATID
		{
			get { throw new Exception("The method or operation is not implemented."); }
		}

		public virtual object ExtenderNames
		{
			get { throw new Exception("The method or operation is not implemented."); }
		}

		public virtual string Identity
		{
			get { throw new Exception("The method or operation is not implemented."); }
		}

		public virtual int MajorVersion
		{
			get { return 0; }
		}

		public virtual int MinorVersion
		{
			get { return 0; }
		}

		public virtual string Name
		{
			get { throw new Exception("The method or operation is not implemented."); }
		}

		public virtual string Path
		{
			get
			{
				return BaseReferenceNode.Url;
			}
		}

		public virtual string PublicKeyToken
		{
			get { throw new Exception("The method or operation is not implemented."); }
		}

		public virtual void Remove()
		{
			BaseReferenceNode.Remove(false);
		}

		public virtual int RevisionNumber
		{
			get { return 0; }
		}

		public virtual EnvDTE.Project SourceProject
		{
			get { return null; }
		}

		public virtual bool StrongName
		{
			get { return false; }
		}

		public virtual prjReferenceType Type
		{
			get { throw new Exception("The method or operation is not implemented."); }
		}

		public virtual string Version
		{
			get { return new Version().ToString(); }
		}

		public virtual object get_Extender(string ExtenderName)
		{
			throw new Exception("The method or operation is not implemented.");
		}
		#endregion
	}
}

--- NEW FILE: oavsprojectitem.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 Microsoft.VisualStudio.Shell.Interop;
using Microsoft.VisualStudio.Shell;
using Microsoft.VisualStudio.TextManager.Interop;
using System.Runtime.InteropServices;
using System.Collections.Generic;
using System.Collections;
using System.Diagnostics;
using System.IO;
using IServiceProvider = System.IServiceProvider;
using Microsoft.VisualStudio.OLE.Interop;
using Microsoft.VisualStudio.Package;
using EnvDTE;
using VSLangProj;

namespace Microsoft.VisualStudio.Package.Automation
{
    [ComVisible(true), CLSCompliant(false)]
    public class OAVSProjectItem : VSProjectItem
    {
        #region fields
        private FileNode fileNode;
        #endregion

        #region ctors
        public OAVSProjectItem(FileNode fileNode)
        {
            this.FileNode = fileNode;
        }
        #endregion

        #region VSProjectItem Members

        public virtual Project ContainingProject
        {
            get { return fileNode.ProjectMgr.GetAutomationObject() as Project; }
        }

        public virtual ProjectItem ProjectItem
        {
            get { return fileNode.GetAutomationObject() as ProjectItem; }
        }

        public virtual DTE DTE
        {
            get { return (DTE)this.fileNode.ProjectMgr.Site.GetService(typeof(DTE)); }
        }

        public virtual void RunCustomTool()
        {
			this.FileNode.RunGenerator();
        }

        #endregion

        #region public properties
        /// <summary>
        /// File Node property
        /// </summary>
        public FileNode FileNode
        {
            get
            {
                return fileNode;
            }
            set
            {
                fileNode = value;
            }
        }
        #endregion

    }
}

--- NEW FILE: oacomreference.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.Globalization;
using System.Runtime.InteropServices;

using Microsoft.VisualStudio.Package;
using VSLangProj;

namespace Microsoft.VisualStudio.Package.Automation
{
    [ComVisible(true)]
	public class OAComReference : OAReferenceBase<ComReferenceNode>
	{
		public OAComReference(ComReferenceNode comReference) :
			base(comReference)
		{
		}

		#region Reference override
		public override string Culture
		{
			get
			{
				int locale = 0;
				try
				{
					locale = int.Parse(BaseReferenceNode.LCID);
				}
				catch (System.FormatException)
				{
					// Do Nothing
				}
				if (0 == locale)
				{
					return string.Empty;
				}
				CultureInfo culture = new CultureInfo(locale);
				return culture.Name;
			}
		}
		public override string Identity
		{
			get
			{
				return string.Format(CultureInfo.InvariantCulture, "{0}\\{1}", BaseReferenceNode.TypeGuid.ToString("B"), this.Version);
			}
		}
		public override int MajorVersion
		{
			get { return BaseReferenceNode.MajorVersionNumber; }
		}
		public override int MinorVersion
		{
			get { return BaseReferenceNode.MinorVersionNumber; }
		}
		public override string Name
		{
			get { return BaseReferenceNode.Caption; }
		}
		public override VSLangProj.prjReferenceType Type
		{
			get
			{
				return VSLangProj.prjReferenceType.prjReferenceTypeActiveX;
			}
		}
		public override string Version
		{
			get
			{
				Version version = new Version(BaseReferenceNode.MajorVersionNumber, BaseReferenceNode.MinorVersionNumber);
				return version.ToString();
			}
		}
		#endregion
	}
}

--- NEW FILE: oareferences.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.Collections.Generic;
using System.Runtime.InteropServices;

using Microsoft.VisualStudio.Shell.Interop;
using Microsoft.VisualStudio.Package;
using ErrorHandler = Microsoft.VisualStudio.ErrorHandler;

using VSLangProj;
using System.Collections;

namespace Microsoft.VisualStudio.Package.Automation
{
    [ComVisible(true)]
    public class OAReferences : ConnectionPointContainer,
                                IEventSource<_dispReferencesEvents>,
                                References,
                                ReferencesEvents
    {
        private ReferenceContainerNode container;
        public OAReferences(ReferenceContainerNode containerNode)
        {
            container = containerNode;
            AddEventSource<_dispReferencesEvents>(this as IEventSource<_dispReferencesEvents>);
            container.OnChildAdded += new EventHandler<HierarchyNodeEventArgs>(OnReferenceAdded);
            container.OnChildRemoved += new EventHandler<HierarchyNodeEventArgs>(OnReferenceRemoved);
        }

        #region Private Members
        private Reference AddFromSelectorData(VSCOMPONENTSELECTORDATA selector)
        {
            ReferenceNode refNode = container.AddReferenceFromSelectorData(selector);
            if (null == refNode)
            {
                return null;
            }

            return refNode.Object as Reference;
        }

        private Reference FindByName(string stringIndex)
        {
            foreach (Reference refNode in this)
            {
                if (0 == string.Compare(refNode.Name, stringIndex, StringComparison.Ordinal))
                {
                    return refNode;
                }
            }
            return null;
        }
        #endregion

        #region References Members

        public Reference Add(string bstrPath)
        {
            if (string.IsNullOrEmpty(bstrPath))
            {
                return null;
            }
            VSCOMPONENTSELECTORDATA selector = new VSCOMPONENTSELECTORDATA();
            selector.type = VSCOMPONENTTYPE.VSCOMPONENTTYPE_File;
            selector.bstrFile = bstrPath;

            return AddFromSelectorData(selector);
        }

        public Reference AddActiveX(string bstrTypeLibGuid, int lMajorVer, int lMinorVer, int lLocaleId, string bstrWrapperTool)
        {
            VSCOMPONENTSELECTORDATA selector = new VSCOMPONENTSELECTORDATA();
            selector.type = VSCOMPONENTTYPE.VSCOMPONENTTYPE_Com2;
            selector.guidTypeLibrary = new Guid(bstrTypeLibGuid);
            selector.lcidTypeLibrary = (uint)lLocaleId;
            selector.wTypeLibraryMajorVersion = (ushort)lMajorVer;
            selector.wTypeLibraryMinorVersion = (ushort)lMinorVer;

            return AddFromSelectorData(selector);
        }

        public Reference AddProject(EnvDTE.Project pProject)
        {
            if (null == pProject)
            {
                return null;
            }
            // Get the soulution.
            IVsSolution solution = container.ProjectMgr.Site.GetService(typeof(SVsSolution)) as IVsSolution;
            if (null == solution)
            {
                return null;
            }

            // Get the hierarchy for this project.
            IVsHierarchy projectHierarchy;
            ErrorHandler.ThrowOnFailure(solution.GetProjectOfUniqueName(pProject.UniqueName, out projectHierarchy));

            // Create the selector data.
            VSCOMPONENTSELECTORDATA selector = new VSCOMPONENTSELECTORDATA();
            selector.type = VSCOMPONENTTYPE.VSCOMPONENTTYPE_Project;

            // Get the project reference string.
            ErrorHandler.ThrowOnFailure(solution.GetProjrefOfProject(projectHierarchy, out selector.bstrProjRef));

            selector.bstrTitle = pProject.Name;
            selector.bstrFile = System.IO.Path.GetDirectoryName(pProject.FullName);

            return AddFromSelectorData(selector);
        }

        public EnvDTE.Project ContainingProject
        {
            get
            {
                return container.ProjectMgr.GetAutomationObject() as EnvDTE.Project;
            }
        }

        public int Count
        {
            get
            {
                return container.EnumReferences().Count;
            }
        }

        public EnvDTE.DTE DTE
        {
            get
            {
                return container.ProjectMgr.Site.GetService(typeof(EnvDTE.DTE)) as EnvDTE.DTE;
            }
        }

        public Reference Find(string bstrIdentity)
        {
            if (string.IsNullOrEmpty(bstrIdentity))
            {
                return null;
            }
            foreach (Reference refNode in this)
            {
                if (null != refNode)
                {
                    if (0 == string.Compare(bstrIdentity, refNode.Identity, StringComparison.Ordinal))
                    {
                        return refNode;
                    }
                }
            }
            return null;
        }

        public IEnumerator GetEnumerator()
        {
            List<Reference> references = new List<Reference>();
            IEnumerator baseEnum = container.EnumReferences().GetEnumerator();
            if (null == baseEnum)
            {
                return references.GetEnumerator();
            }
            while (baseEnum.MoveNext())
            {
                ReferenceNode refNode = baseEnum.Current as ReferenceNode;
                if (null == refNode)
                {
                    continue;
                }
                Reference reference = refNode.Object as Reference;
                if (null != reference)
                {
                    references.Add(reference);
                }
            }
            return references.GetEnumerator();
        }

        public Reference Item(object index)
        {
            string stringIndex = index as string;
            if (null != stringIndex)
            {
                return FindByName(stringIndex);
            }
            // Note that this cast will throw if the index is not convertible to int.
            int intIndex = (int)index;
            IList<ReferenceNode> refs = container.EnumReferences();
            if (null == refs)
            {
                throw new ArgumentOutOfRangeException();
            }
            if ((intIndex <= 0) || (intIndex > refs.Count))
            {
                throw new ArgumentOutOfRangeException();
            }
            // Let the implementation of IList<> throw in case of index not correct.
            return refs[intIndex-1].Object as Reference;
        }

        public object Parent
        {
            get
            {
                return container.Parent.Object;
            }
        }

        #endregion

        #region _dispReferencesEvents_Event Members
        public event _dispReferencesEvents_ReferenceAddedEventHandler ReferenceAdded;
        public event _dispReferencesEvents_ReferenceChangedEventHandler ReferenceChanged;
        public event _dispReferencesEvents_ReferenceRemovedEventHandler ReferenceRemoved;
        #endregion

        #region Callbacks for the HierarchyNode events
        private void OnReferenceAdded(object sender, HierarchyNodeEventArgs args)
        {
            // Validate the parameters.
            if ((container != sender as ReferenceContainerNode) || 
                (null == args) || (null == args.Child))
            {
                return;
            }

            // Check if there is any sink for this event.
            if (null == ReferenceAdded)
            {
                return;
            }

            // Check that the removed item implements the Reference interface.
            Reference reference = args.Child.Object as Reference;
            if (null != reference)
            {
                ReferenceAdded(reference);
            }
        }

        private void OnReferenceChanged(object sender, HierarchyNodeEventArgs args)
        {
            // Check if there is any sink for this event.
            if (null == ReferenceChanged)
            {
                return;
            }

            // The sender of this event should be the reference node that was changed
            ReferenceNode refNode = sender as ReferenceNode;
            if (null == refNode)
            {
                return;
            }


            // Check that the removed item implements the Reference interface.
            Reference reference = refNode.Object as Reference;
            if (null != reference)
            {
                ReferenceChanged(reference);
            }
        }

        private void OnReferenceRemoved(object sender, HierarchyNodeEventArgs args)
        {
            // Validate the parameters.
            if ((container != sender as ReferenceContainerNode) ||
                (null == args) || (null == args.Child))
            {
                return;
            }

            // Check if there is any sink for this event.
            if (null == ReferenceRemoved)
            {
                return;
            }

            // Check that the removed item implements the Reference interface.
            Reference reference = args.Child.Object as Reference;
            if (null != reference)
            {
                ReferenceRemoved(reference);
            }
        }
        #endregion

        #region IEventSource<_dispReferencesEvents> Members
        void IEventSource<_dispReferencesEvents>.OnSinkAdded(_dispReferencesEvents sink)
        {
            ReferenceAdded += new _dispReferencesEvents_ReferenceAddedEventHandler(sink.ReferenceAdded);
            ReferenceChanged += new _dispReferencesEvents_ReferenceChangedEventHandler(sink.ReferenceChanged);
            ReferenceRemoved += new _dispReferencesEvents_ReferenceRemovedEventHandler(sink.ReferenceRemoved);
        }

        void IEventSource<_dispReferencesEvents>.OnSinkRemoved(_dispReferencesEvents sink)
        {
            ReferenceAdded -= new _dispReferencesEvents_ReferenceAddedEventHandler(sink.ReferenceAdded);
            ReferenceChanged -= new _dispReferencesEvents_ReferenceChangedEventHandler(sink.ReferenceChanged);
            ReferenceRemoved -= new _dispReferencesEvents_ReferenceRemovedEventHandler(sink.ReferenceRemoved);
        }
        #endregion
    }
}

--- NEW FILE: oabuildmanager.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.Collections.Generic;
using System.Runtime.InteropServices;

using Microsoft.VisualStudio.Shell.Interop;
using Microsoft.VisualStudio.Package;
using VSLangProj;

namespace Microsoft.VisualStudio.Package.Automation
{
    public class OABuildManager : ConnectionPointContainer,
                                    IEventSource<_dispBuildManagerEvents>,
                                    BuildManager, 
                                    BuildManagerEvents
	{
		private ProjectNode projectManager;

		public OABuildManager(ProjectNode project)
		{
			projectManager = project;
			AddEventSource<_dispBuildManagerEvents>(this as IEventSource<_dispBuildManagerEvents>);
		}


		#region BuildManager Members

		public string BuildDesignTimeOutput(string bstrOutputMoniker)
		{
			throw new Exception("The method or operation is not implemented.");
		}

		public EnvDTE.Project ContainingProject
		{
			get { return projectManager.GetAutomationObject() as EnvDTE.Project; }
		}

		public EnvDTE.DTE DTE
		{
			get { return projectManager.Site.GetService(typeof(EnvDTE.DTE)) as EnvDTE.DTE; }
		}

		public object DesignTimeOutputMonikers
		{
			get { throw new Exception("The method or operation is not implemented."); }
		}

		public object Parent
		{
			get { throw new Exception("The method or operation is not implemented."); }
		}

		#endregion

		#region _dispBuildManagerEvents_Event Members

		public event _dispBuildManagerEvents_DesignTimeOutputDeletedEventHandler DesignTimeOutputDeleted;

		public event _dispBuildManagerEvents_DesignTimeOutputDirtyEventHandler DesignTimeOutputDirty;

		#endregion

		private void OnDesignTimeOutputDeleted(object sender, EventArgs args)
		{
			if (DesignTimeOutputDeleted == null)
				return;

			string moniker = GetOutputMoniker(sender);
			if (!String.IsNullOrEmpty(moniker))
				DesignTimeOutputDeleted(moniker);
		}
		private void OnDesignTimeOutputDirty(object sender, EventArgs args)
		{
			if (DesignTimeOutputDeleted == null)
				return;

			string moniker = GetOutputMoniker(sender);
			if (!String.IsNullOrEmpty(moniker))
				DesignTimeOutputDirty(moniker);
		}
		private static string GetOutputMoniker(object sender)
		{
			IVsOutput2 output = sender as IVsOutput2;
			if (output == null)
				return null;
			string moniker;
			output.get_CanonicalName(out moniker);
			return moniker;
		}

        #region IEventSource<_dispBuildManagerEvents> Members

        void IEventSource<_dispBuildManagerEvents>.OnSinkAdded(_dispBuildManagerEvents sink)
        {
            DesignTimeOutputDeleted += new _dispBuildManagerEvents_DesignTimeOutputDeletedEventHandler(sink.DesignTimeOutputDeleted);
            DesignTimeOutputDirty += new _dispBuildManagerEvents_DesignTimeOutputDirtyEventHandler(sink.DesignTimeOutputDirty);
        }

        void IEventSource<_dispBuildManagerEvents>.OnSinkRemoved(_dispBuildManagerEvents sink)
        {
            DesignTimeOutputDeleted -= new _dispBuildManagerEvents_DesignTimeOutputDeletedEventHandler(sink.DesignTimeOutputDeleted);
            DesignTimeOutputDirty -= new _dispBuildManagerEvents_DesignTimeOutputDirtyEventHandler(sink.DesignTimeOutputDirty);
        }

        #endregion
    }
}

--- NEW FILE: oaprojectreference.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.Runtime.InteropServices;

using Microsoft.VisualStudio.Shell.Interop;
using Microsoft.VisualStudio.Shell;
using Microsoft.VisualStudio.Package;
using VSLangProj;

namespace Microsoft.VisualStudio.Package.Automation
{
    [ComVisible(true)]
	public class OAProjectReference : OAReferenceBase<ProjectReferenceNode>
	{
		public OAProjectReference(ProjectReferenceNode projectReference) : 
			base(projectReference)
		{
		}

		#region Reference override
		public override string Culture
		{
            get { return string.Empty; }
		}
		public override string Name
		{
			get { return BaseReferenceNode.ReferencedProjectName; }
		}
		public override string Identity
		{
			get
			{
				return BaseReferenceNode.Caption;
			}
		}
		public override string Path
		{
			get
			{
				return BaseReferenceNode.ReferencedProjectOutputPath;
			}
		}
		public override EnvDTE.Project SourceProject
		{
			get
			{
				if (Guid.Empty == BaseReferenceNode.ReferencedProjectGuid)
				{
					return null;
				}
				IVsHierarchy hierarchy = VsShellUtilities.GetHierarchy(BaseReferenceNode.ProjectMgr.Site, BaseReferenceNode.ReferencedProjectGuid);
				if (null == hierarchy)
				{
					return null;
				}
				object extObject;
				if (Microsoft.VisualStudio.ErrorHandler.Succeeded(
						hierarchy.GetProperty(VSConstants.VSITEMID_ROOT, (int)__VSHPROPID.VSHPROPID_ExtObject, out extObject)))
				{
					return extObject as EnvDTE.Project;
				}
				return null;
			}
		}
		public override prjReferenceType Type
		{
			// TODO: Write the code that finds out the type of the output of the source project.
			get { return prjReferenceType.prjReferenceTypeAssembly; }
		}
		public override string Version
		{
			get { return string.Empty; }
		}
		#endregion
	}
}

--- NEW FILE: oaassemblyreference.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.Reflection;
using System.Runtime.InteropServices;

using Microsoft.VisualStudio.Package;
using VSLangProj;
using System.Text;

namespace Microsoft.VisualStudio.Package.Automation
{
    [ComVisible(true)]
	public class OAAssemblyReference : OAReferenceBase<AssemblyReferenceNode>
	{
		public OAAssemblyReference(AssemblyReferenceNode assemblyReference) :
			base(assemblyReference)
		{
		}

		#region Reference override
		public override int BuildNumber
		{
			get
			{
				if ((null == BaseReferenceNode.ResolvedAssembly) || 
					(null == BaseReferenceNode.ResolvedAssembly.Version))
				{
					return 0;
				}
				return BaseReferenceNode.ResolvedAssembly.Version.Build;
			}
		}
		public override string Culture
		{
			get
			{
				if ((null == BaseReferenceNode.ResolvedAssembly) || 
					(null == BaseReferenceNode.ResolvedAssembly.CultureInfo))
				{
                    return string.Empty;
				}
				return BaseReferenceNode.ResolvedAssembly.CultureInfo.Name;
			}
		}
		public override string Identity
		{
			get
			{
				// Note that in this function we use the assembly name instead of the resolved one
				// because the identity of this reference is the assembly name needed by the project,
				// not the specific instance found in this machine / environment.
				if (null == BaseReferenceNode.AssemblyName)
				{
					return null;
				}
				return BaseReferenceNode.AssemblyName.FullName;
			}
		}
		public override int MajorVersion
		{
			get
			{
				if ((null == BaseReferenceNode.ResolvedAssembly) || 
					(null == BaseReferenceNode.ResolvedAssembly.Version))
				{
					return 0;
				}
				return BaseReferenceNode.ResolvedAssembly.Version.Major;
			}
		}
		public override int MinorVersion
		{
			get
			{
				if ((null == BaseReferenceNode.ResolvedAssembly) ||
					(null == BaseReferenceNode.ResolvedAssembly.Version))
				{
					return 0;
				}
				return BaseReferenceNode.ResolvedAssembly.Version.Minor;
			}
		}

		public override string PublicKeyToken
		{
			get
			{
				if ((null == BaseReferenceNode.ResolvedAssembly) ||
				(null == BaseReferenceNode.ResolvedAssembly.GetPublicKeyToken()))
				{
					return null;
				}
				StringBuilder builder = new StringBuilder();
				byte[] publicKeyToken = BaseReferenceNode.ResolvedAssembly.GetPublicKeyToken();
				for (int i = 0; i < publicKeyToken.Length; i++)
				{
					builder.AppendFormat("{0:x}", publicKeyToken[i]);
				}
				return builder.ToString();
			}
		}

		public override string Name
		{
			get
			{
                if (null != BaseReferenceNode.ResolvedAssembly)
                {
                    return BaseReferenceNode.ResolvedAssembly.Name;
                }
                if (null != BaseReferenceNode.AssemblyName)
                {
                    return BaseReferenceNode.AssemblyName.Name;
                }
                return null;
			}
		}
		public override int RevisionNumber
		{
			get
			{
				if ((null == BaseReferenceNode.ResolvedAssembly) ||
					(null == BaseReferenceNode.ResolvedAssembly.Version))
				{
					return 0;
				}
				return BaseReferenceNode.ResolvedAssembly.Version.Revision;
			}
		}
		public override bool StrongName
		{
			get
			{
				if ((null == BaseReferenceNode.ResolvedAssembly) ||
					(0 == (BaseReferenceNode.ResolvedAssembly.Flags & AssemblyNameFlags.PublicKey)))
				{
					return false;
				}
				return true;
			}
		}
		public override prjReferenceType Type
		{
			get
			{
				return prjReferenceType.prjReferenceTypeAssembly;
			}
		}
		public override string Version
		{
			get
			{
				if ((null == BaseReferenceNode.ResolvedAssembly) ||
					(null == BaseReferenceNode.ResolvedAssembly.Version))
				{
					return string.Empty;
				}
				return BaseReferenceNode.ResolvedAssembly.Version.ToString();
			}
		}
		#endregion
	}
}