<configuration>
    <ajaxDoc url="http://localhost:/AjaxDoc/" project="MicrosoftAjax" regenerate="true" />
    <userCredentials useDefault="true" userName="" password="" />
    <proxyCredentials useProxy="false" proxyServer="">
        <userCredentials useDefault="true" userName="" password="" />
    </proxyCredentials>
</configuration>

//=============================================================================
// System  : <Your Plug-In Project>
// File    : <YourFileName.cs>
// Author  : <Your Name Here>
// Updated : <--Date-->
// Compiler: Microsoft Visual C#
// 
// <A description of the plug-in.>
// 
// Version     Date     Who  Comments
// ============================================================================
// 1.0.0.0  <--Date-->  <->  Created the code
//=============================================================================

using System;
using System.Diagnostics;
using System.Reflection;
using System.Windows.Forms;
using System.Xml.XPath;

using SandcastleBuilder.Utils;
using SandcastleBuilder.Utils.BuildEngine;
using SandcastleBuilder.Utils.PlugIn;

// TODO: Use your namespace
namespace Test.PlugIns
{
    /// <summary>
    /// TODO: Set your plug-in's class name
    /// </summary>
    public class TestPlugIn : SandcastleBuilder.Utils.PlugIn.IPlugIn
    {
+Private data members-        #region Private data members
         //=====================================================================
 
         private ExecutionPointCollection executionPoints;
 
         private BuildProcess builder;
         #endregion

+IPlugIn implementation-        #region IPlugIn implementation
         //=====================================================================
 
         /// <summary>
         /// This read-only property returns a friendly name for the plug-in
         /// </summary>
         public string Name
         {
             get { return "TODO: Add your plug-in name here"; }
         }
 
         /// <summary>
         /// This read-only property returns the version of the plug-in
         /// </summary>
         public Version Version
         {
             get
             {
                 // TODO: Edit AssemblyInfo.cs to set your plug-in's version
 
                 // Use the assembly version
                 Assembly asm = Assembly.GetExecutingAssembly();
                 FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(
                     asm.Location);
 
                 return new Version(fvi.ProductVersion);
             }
         }
 
         /// <summary>
         /// This read-only property returns the copyright information for the
         /// plug-in.
         /// </summary>
         public string Copyright
         {
             get
             {
                 // TODO: Edit AssemblyInfo.cs to set your plug-in's copyright
 
                 // Use the assembly copyright
                 Assembly asm = Assembly.GetExecutingAssembly();
                 AssemblyCopyrightAttribute copyright =
                     (AssemblyCopyrightAttribute)Attribute.GetCustomAttribute(
                         asm, typeof(AssemblyCopyrightAttribute));
 
                 return copyright.Copyright;
             }
         }
 
         /// <summary>
         /// This read-only property returns a brief description of the plug-in
         /// </summary>
         public string Description
         {
             get
             {
                 return "TODO: Add your plug-in description here";
             }
         }
 
         /// <summary>
         /// This read-only property returns true if the plug-in should run in
         /// a partial build or false if it should not.
         /// </summary>
         /// <value>If this returns false, the plug-in will not be loaded when
         /// a partial build is performed.</value>
         public bool RunsInPartialBuild
         {
             // TODO: Set this to true if necessary
             get { return false; }
         }
 
         /// <summary>
         /// This read-only property returns a collection of execution points
         /// that define when the plug-in should be invoked during the build
         /// process.
         /// </summary>
         public ExecutionPointCollection ExecutionPoints
         {
             get
             {
                 if(executionPoints == null)
                     executionPoints = new ExecutionPointCollection
                     {
                         // TODO: Modify this to set your execution points
                         new ExecutionPoint(
                             BuildStep.ValidatingDocumentationSources,
                             ExecutionBehaviors.Before),
                         new ExecutionPoint(
                             BuildStep.GenerateReflectionInfo,
                             ExecutionBehaviors.Before)
                     };
 
                 return executionPoints;
             }
         }
 
         /// <summary>
         /// This method is used by the Sandcastle Help File Builder to let the
         /// plug-in perform its own configuration.
         /// </summary>
         /// <param name="project">A reference to the active project</param>
         /// <param name="currentConfig">The current configuration XML fragment</param>
         /// <returns>A string containing the new configuration XML fragment</returns>
         /// <remarks>The configuration data will be stored in the help file
         /// builder project.</remarks>
         public string ConfigurePlugIn(SandcastleProject project,
           string currentConfig)
         {
             // TODO: Add and invoke a configuration dialog if you need one.
             MessageBox.Show("This plug-in has no configurable settings",
                 "Build Process Plug-In", MessageBoxButtons.OK,
                 MessageBoxIcon.Information);
 
             return currentConfig;
         }
 
         /// <summary>
         /// This method is used to initialize the plug-in at the start of the
         /// build process.
         /// </summary>
         /// <param name="buildProcess">A reference to the current build
         /// process.</param>
         /// <param name="configuration">The configuration data that the plug-in
         /// should use to initialize itself.</param>
         public void Initialize(BuildProcess buildProcess,
           XPathNavigator configuration)
         {
             builder = buildProcess;
 
             builder.ReportProgress("{0} Version {1}\r\n{2}\r\n",
                 this.Name, this.Version, this.Copyright);
 
             // TODO: Add your initialization code here such as reading the
             // configuration data.
         }
 
         /// <summary>
         /// This method is used to execute the plug-in during the build process
         /// </summary>
         /// <param name="context">The current execution context</param>
         public void Execute(ExecutionContext context)
         {
             // TODO: Add your execution code here
         }
         #endregion

+IDisposable implementation-        #region IDisposable implementation
         //=====================================================================
 
         /// <summary>
         /// This handles garbage collection to ensure proper disposal of the
         /// plug-in if not done explicity with <see cref="Dispose()"/>.
         /// </summary>
         ~TestPlugIn()
         {
             // TODO: Change the name of this method to your plug-in name
             this.Dispose(false);
         }
 
         /// <summary>
         /// This implements the Dispose() interface to properly dispose of
         /// the plug-in object.
         /// </summary>
         /// <overloads>There are two overloads for this method.</overloads>
         public void Dispose()
         {
             this.Dispose(true);
             GC.SuppressFinalize(this);
         }
 
         /// <summary>
         /// This can be overridden by derived classes to add their own
         /// disposal code if necessary.
         /// </summary>
         /// <param name="disposing">Pass true to dispose of the managed
         /// and unmanaged resources or false to just dispose of the
         /// unmanaged resources.</param>
         protected virtual void Dispose(bool disposing)
         {
             // TODO: Dispose of any resources here if necessary
         }
         #endregion
    }
}