using System;

using System.Collections.Generic;

using System.Text;

using Microsoft.Practices.EnterpriseLibrary.Configuration.Design;

using MS.Services.Configuration.Design.DefinitionGenerators;

using MS.Services.Configuration.Design.Properties;

using System.Windows.Forms;





namespace MS.Services.Configuration.Design

{

    public class MSServicesCommandRegistrar : CommandRegistrar

    {



        public MSServicesCommandRegistrar(IServiceProvider serviceProvider)

			: base(serviceProvider)

		{

		}



        public override void Register()

        {

            AddMSServicesSettingsCommand();

            AddDefaultCommands(typeof(MSServicesSettingsNode));



            AddServiceCommand();

            AddDefaultCommands(typeof(ServiceProviderNode));



            AddCategoryCommand();

            AddMoveUpDownCommands(typeof(CategoryNode));

            AddDefaultCommands(typeof(CategoryNode));



            AddAtomCommand();

            AddDefaultCommands(typeof(AtomNode));

            AddDefaultCommands(typeof(AtomCachingNode));



            AddDatabaseExecutorWizardCommand();

            AddAssemblyExecutorWizardCommand();

            AddRefreshParametersCommand();

            AddDatabaseExecutorCommand();

            AddSQLExecutorCommand();

            AddGeneratorsCommand();

            AddDefaultCommands(typeof(DatabaseExecutorNode));

            AddDefaultCommands(typeof(SQLExecutorNode));



            AddWebServiceGeneratorCommand();

            AddDefaultCommands(typeof(WebServiceGeneratorNode));



            AddRESTGeneratorCommand();

            AddDefaultCommands(typeof(RESTGeneratorNode));



            AddXMLRPCGeneratorCommand();

            AddDefaultCommands(typeof(XMLRPCGeneratorNode));



            AddExcelGeneratorCommand();

            AddDefaultCommands(typeof(ExcelGeneratorNode));



            AddJSONGeneratorCommand();

            AddDefaultCommands(typeof(JSONGeneratorNode));



            AddRSSGeneratorCommand();

            AddDefaultCommands(typeof(RSSGeneratorNode));



            AddTextGeneratorCommand();

            AddDefaultCommands(typeof(TextGeneratorNode));



            AddCustomGeneratorCommand();

            AddDefaultCommands(typeof(CustomGeneratorNode));



            AddRSSFieldMappingCommand();

            AddDefaultCommands(typeof(NameValueNode));



            AddAssemblyExecutorCommand();

            AddDefaultCommands(typeof(AssemblyExecutorNode));



            AddIronPythonExecutorCommand();

            AddDefaultCommands(typeof(IronPythonExecutorNode));



            AddDotNetScriptExecutorCommand();

            AddDefaultCommands(typeof(DotNetScriptExecutorNode));



            AddFileExecutorCommand();

            AddDefaultCommands(typeof(FileExecutorNode));



            AddXMLExecutorCommand();

            AddDefaultCommands(typeof(XMLExecutorNode));



            AddMSMQExecutorCommand();

            AddDefaultCommands(typeof(MSMQExecutorNode));



            AddParametersCommand();

            AddDefaultCommands(typeof(ParameterCollectionNode));



            AddParameterCommand();

            AddMoveUpDownCommands(typeof(ParameterNode));

            AddDefaultCommands(typeof(ParameterNode));



            AddValidatorsCommand();

            AddMoveUpDownCommands(typeof(MinMaxValidatorNode));

            AddMoveUpDownCommands(typeof(ListValidatorNode));

            AddMoveUpDownCommands(typeof(RegExpValidatorNode));

            AddMoveUpDownCommands(typeof(DatabaseValidatorNode));

            AddMoveUpDownCommands(typeof(SQLValidatorNode));

            AddMoveUpDownCommands(typeof(XMLValidatorNode));

            AddMoveUpDownCommands(typeof(DotNetScriptValidatorNode));

            AddDefaultCommands(typeof(MinMaxValidatorNode));

            AddDefaultCommands(typeof(ListValidatorNode));

            AddDefaultCommands(typeof(RegExpValidatorNode));

            AddDefaultCommands(typeof(DatabaseValidatorNode));

            AddDefaultCommands(typeof(SQLValidatorNode));

            AddDefaultCommands(typeof(XMLValidatorNode));

            AddDefaultCommands(typeof(DotNetScriptValidatorNode));



            AddDefaultCommands(typeof(GeneratorCollectionNode));



            AddShieldsCommand();

            AddDefaultCommands(typeof(ShieldsNode));



            AddDatabaseShieldCommand();

            AddDefaultCommands(typeof(DatabaseShieldNode));



            AddSQLShieldCommand();

            AddDefaultCommands(typeof(SQLShieldNode));



            AddDotNetScriptShieldCommand();

            AddDefaultCommands(typeof(DotNetScriptShieldNode));



            AddShieldParametersCommand();

            AddDefaultCommands(typeof(ShieldParametersNode));



            AddShieldParameterCommand();

            AddMoveUpDownCommands(typeof(ShieldParameterNode));

            AddDefaultCommands(typeof(ShieldParameterNode));



            AddShieldLinksCommand();

            AddDefaultCommands(typeof(ShieldLinkCollectionNode));



            AddShieldLinkCommand();

            //AddDefaultCommands(typeof(ShieldLinkNode)); /Should not remove, any parameter...

            AddMoveUpDownCommands(typeof(ShieldLinkNode));

            AddDefaultCommands(typeof(ShieldLinkNode));

            //AddShieldLinkParameterCommand();



            AddDefinitionGeneratorsCommand();

            AddDefaultCommands(typeof(DefinitionGeneratorsNode));



            AddASDLDefinitionGeneratorCommand();

            AddDefaultCommands(typeof(ASDLDefinitionGeneratorNode));

            AddJSDLDefinitionGeneratorCommand();

            AddDefaultCommands(typeof(JSDLDefinitionGeneratorNode));

            AddXSLTDefinitionGeneratorCommand();

            AddDefaultCommands(typeof(XSLTDefinitionGeneratorNode));

            AddWSDLDefinitionGeneratorCommand();

            AddDefaultCommands(typeof(WSDLDefinitionGeneratorNode));

            AddHELPDefinitionGeneratorCommand();

            AddDefaultCommands(typeof(HELPDefinitionGeneratorNode));

        }



        private void AddRSSFieldMappingCommand()

        {

            AddRSSFieldMappingItemCommand(Resources.RSSTitleCommandText, RSSItemField.title.ToString());

            AddRSSFieldMappingItemCommand(Resources.RSSLinkCommandText, RSSItemField.link.ToString());

            AddRSSFieldMappingItemCommand(Resources.RSSGuidCommandText, RSSItemField.guid.ToString());

            AddRSSFieldMappingItemCommand(Resources.RSSDescriptionCommandText, RSSItemField.description.ToString());

            AddRSSFieldMappingItemCommand(Resources.RSSDateCommandText, RSSItemField.date.ToString());

            AddRSSFieldMappingItemCommand(Resources.RSSCategoryCommandText, RSSItemField.category.ToString());

            AddRSSFieldMappingItemCommand(Resources.RSSAuthorCommandText, RSSItemField.author.ToString());

        }



        private void AddRSSFieldMappingItemCommand(string commandText, string title)

        {

            RSSNameValueUICommand item = new RSSNameValueUICommand(ServiceProvider, commandText, title);

            AddUICommand(item, typeof(RSSGeneratorNode));

        }



        private void AddRefreshParametersCommand()

        {

            ConfigurationUICommand item = ConfigurationUICommand.CreateMultipleUICommand(ServiceProvider,

                Resources.RefreshParametersCommandText,

                Resources.RefreshParametersCommandLongText,

                new RefreshParametersCommand(ServiceProvider),

                null);

            AddUICommand(item, typeof(AtomNode));

            item = ConfigurationUICommand.CreateMultipleUICommand(ServiceProvider,

                 Resources.RefreshParametersCommandText,

                 Resources.RefreshParametersCommandLongText,

                 new RefreshParametersCommand(ServiceProvider),

                 null);

            AddUICommand(item, typeof(DatabaseShieldNode));

        }



        private void AddMSServicesSettingsCommand()

        {

            ConfigurationUICommand item = ConfigurationUICommand.CreateSingleUICommand(ServiceProvider,

                Resources.MSServicesSettingsCommandText,

                Resources.MSServicesSettingsCommandLongText,

                new MSServicesSettingsNodeCommand(ServiceProvider),

                typeof(MSServicesSettingsNode));

            AddUICommand(item, typeof(ConfigurationApplicationNode));

        }



        private void AddServiceCommand()

        {

            ConfigurationUICommand item = ConfigurationUICommand.CreateMultipleUICommand(ServiceProvider,

                Resources.ServiceCommandText,

                Resources.GenericCommandLongText,

                new ServiceCommand(ServiceProvider),

                typeof(ServiceProviderNode));

            AddUICommand(item, typeof(MSServicesSettingsNode));



            //item = ConfigurationUICommand.CreateSingleUICommand(ServiceProvider,

            //    Resources.ServiceCommandText,

            //    Resources.GenericCommandLongText,

            //    new ServiceCommand(ServiceProvider),

            //    typeof(ServiceProviderNode));

            PublishServiceCommand();

            CollapseCommand(typeof(MSServicesSettingsNode));

        }



        private void AddAtomCommand()

        {

            ConfigurationUICommand item = ConfigurationUICommand.CreateMultipleUICommand(ServiceProvider,

                Resources.AtomCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.AtomCommandText),

                new AtomCommand(ServiceProvider),

                null);

            AddUICommand(item, typeof(ServiceProviderNode));



            item = new ManageUsersUICommand(ServiceProvider, Resources.ManageUserAuthenticationCommandText);

            AddUICommand(item, typeof(ServiceProviderNode));



            item = new ManageRolesUICommand(ServiceProvider, Resources.ManageUserRolesCommandText);

            AddUICommand(item, typeof(ServiceProviderNode));



            AddMultipleChildNodeCommand(Resources.CategoryCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.CategoryCommandText),

                typeof(CategoryNode),

                typeof(ServiceProviderNode));



            AddSingleChildNodeCommand(Resources.AtomCachingNodeDisplayName,

                string.Format(Resources.GenericCommandLongText, Resources.AtomCachingNodeDisplayName),

                typeof(AtomCachingNode),

                typeof(AtomNode));

            item = new ConfigurationUICommand(ServiceProvider,

                Resources.MoveToCategoryNodeCommandText,

                Resources.MoveToCategoryNodeCommandLongText,

                CommandState.Enabled,

                new MoveToCategoryNodeCommand(ServiceProvider),

                Shortcut.CtrlM, InsertionPoint.Action, null);

            AddUICommand(item, typeof(AtomNode));



            CollapseCommand(typeof(ServiceProviderNode));

        }





        private void AddCategoryCommand()

        {

            AddMultipleChildNodeCommand(Resources.CategoryCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.CategoryCommandText),

                typeof(CategoryNode),

                typeof(CategoryNode));

            ConfigurationUICommand item = ConfigurationUICommand.CreateMultipleUICommand(ServiceProvider,

                Resources.AtomCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.AtomCommandText),

                new AtomCommand(ServiceProvider),

                null);

            AddUICommand(item, typeof(CategoryNode));

            item = new ConfigurationUICommand(ServiceProvider,

                Resources.MoveToCategoryNodeCommandText,

                Resources.MoveToCategoryNodeCommandLongText,

                CommandState.Enabled,

                new MoveToCategoryNodeCommand(ServiceProvider),

                Shortcut.CtrlM, InsertionPoint.Action, null);

            AddUICommand(item, typeof(CategoryNode));

            CollapseCommand(typeof(CategoryNode));

        }



        private void CollapseCommand(Type type)

        {

            ConfigurationUICommand item = new ConfigurationUICommand(ServiceProvider,

                Resources.CollapseAtomCommandText,

                Resources.CollapseAtomCommandText,

                CommandState.Enabled,

                NodeMultiplicity.Allow,

                new CollapseNodesCommand(ServiceProvider),

                null, Shortcut.CtrlN, InsertionPoint.Action, null);

            AddUICommand(item, type);

        }



        private void PublishServiceCommand()

        {

            ConfigurationUICommand item = new ConfigurationUICommand(ServiceProvider,

                Resources.PublishServiceCommandText,

                Resources.PublishServiceCommandText,

                CommandState.Enabled,

                NodeMultiplicity.Allow,

                new PublishServiceCommand(ServiceProvider),

                null, Shortcut.CtrlP, InsertionPoint.Action, null);

            AddUICommand(item, typeof(ServiceProviderNode));

        }



        private void AddGeneratorsCommand()

        {

            AddSingleChildNodeCommand(Resources.GeneratorCollectionNodeName,

                string.Format(Resources.GenericCommandLongText, Resources.GeneratorCollectionNodeName),

                typeof(GeneratorCollectionNode),

                typeof(AtomNode));

        }



        private void AddWebServiceGeneratorCommand()

        {

            AddSingleChildNodeCommand(Resources.WebServiceGeneratorCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.WebServiceGeneratorCommandText),

                typeof(WebServiceGeneratorNode),

                typeof(GeneratorCollectionNode));

        }



        private void AddRESTGeneratorCommand()

        {

            AddSingleChildNodeCommand(Resources.RESTGeneratorCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.RESTGeneratorCommandText),

                typeof(RESTGeneratorNode),

                typeof(GeneratorCollectionNode));

        }



        private void AddXMLRPCGeneratorCommand()

        {

            AddSingleChildNodeCommand(Resources.XMLRPCGeneratorCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.XMLRPCGeneratorCommandText),

                typeof(XMLRPCGeneratorNode),

                typeof(GeneratorCollectionNode));

        }



        private void AddExcelGeneratorCommand()

        {

            AddSingleChildNodeCommand(Resources.ExcelGeneratorCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.ExcelGeneratorCommandText),

                typeof(ExcelGeneratorNode),

                typeof(GeneratorCollectionNode));

        }



        private void AddRSSGeneratorCommand()

        {

            AddSingleChildNodeCommand(Resources.RSSGeneratorCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.RSSGeneratorCommandText),

                typeof(RSSGeneratorNode),

                typeof(GeneratorCollectionNode));

            CollapseCommand(typeof(RSSGeneratorNode));



        }



        private void AddTextGeneratorCommand()

        {

            AddSingleChildNodeCommand(Resources.TextGeneratorCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.TextGeneratorCommandText),

                typeof(TextGeneratorNode),

                typeof(GeneratorCollectionNode));

        }



        private void AddCustomGeneratorCommand()

        {

            AddMultipleChildNodeCommand(Resources.CustomGeneratorCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.CustomGeneratorCommandText),

                typeof(CustomGeneratorNode),

                typeof(GeneratorCollectionNode));

        }



        private void AddJSONGeneratorCommand()

        {

            AddSingleChildNodeCommand(Resources.JSONGeneratorCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.JSONGeneratorCommandText),

                typeof(JSONGeneratorNode),

                typeof(GeneratorCollectionNode));

        }



        private void AddDatabaseExecutorCommand()

        {

            ExecutorUICommand item = new ExecutorUICommand(ServiceProvider, Resources.DatabaseExecutorCommandText, typeof(DatabaseExecutorNode));

            AddUICommand(item, typeof(AtomNode));

        }



        private void AddSQLExecutorCommand()

        {

            ExecutorUICommand item = new ExecutorUICommand(ServiceProvider, Resources.SQLExecutorCommandText, typeof(SQLExecutorNode));

            AddUICommand(item, typeof(AtomNode));

        }



        private void AddMSMQExecutorCommand()

        {

            ExecutorUICommand item = new ExecutorUICommand(ServiceProvider, Resources.MSMQExecutorCommandText, typeof(MSMQExecutorNode));

            AddUICommand(item, typeof(AtomNode));

        }



        private void AddAssemblyExecutorCommand()

        {

            ExecutorUICommand item = new ExecutorUICommand(ServiceProvider, Resources.AssemblyExecutorCommandText, typeof(AssemblyExecutorNode));

            AddUICommand(item, typeof(AtomNode));

        }



        private void AddIronPythonExecutorCommand()

        {

            ExecutorUICommand item = new ExecutorUICommand(ServiceProvider, Resources.IronPythonExecutorCommandText, typeof(IronPythonExecutorNode));

            AddUICommand(item, typeof(AtomNode));

        }



        private void AddDotNetScriptExecutorCommand()

        {

            ExecutorUICommand item = new ExecutorUICommand(ServiceProvider, Resources.DotNetScriptExecutorCommandText, typeof(DotNetScriptExecutorNode));

            AddUICommand(item, typeof(AtomNode));

        }



        private void AddFileExecutorCommand()

        {

            ExecutorUICommand item = new ExecutorUICommand(ServiceProvider, Resources.FileExecutorCommandText, typeof(FileExecutorNode));

            AddUICommand(item, typeof(AtomNode));

        }



        private void AddXMLExecutorCommand()

        {

            ExecutorUICommand item = new ExecutorUICommand(ServiceProvider, Resources.XMLExecutorCommandText, typeof(XMLExecutorNode));

            AddUICommand(item, typeof(AtomNode));

        }

        

        private void AddParametersCommand()

        {

            AddSingleChildNodeCommand(Resources.ParametersCommandText,

                Resources.ParametersCommandLongText,

                typeof(ParameterCollectionNode),

                typeof(AtomNode));

            CollapseCommand(typeof(AtomNode));



        }



        private void AddParameterCommand()

        {

            AddMultipleChildNodeCommand(Resources.ParameterCommandText,

                Resources.ParameterCommandLongText,

                typeof(ParameterNode),

                typeof(ParameterCollectionNode));

        }



        private void AddShieldsCommand()

        {

            AddSingleChildNodeCommand(Resources.ShieldsCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.ShieldsCommandText),

                typeof(ShieldsNode),

                typeof(MSServicesSettingsNode));

        }



        private void AddDatabaseShieldCommand()

        {

            AddMultipleChildNodeCommand(Resources.DatabaseShieldCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.DatabaseShieldCommandText),

                typeof(DatabaseShieldNode),

                typeof(ShieldsNode));

        }



        private void AddSQLShieldCommand()

        {

            AddMultipleChildNodeCommand(Resources.SQLShieldCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.SQLShieldCommandText),

                typeof(SQLShieldNode),

                typeof(ShieldsNode));

        }



        private void AddDotNetScriptShieldCommand()

        {

            AddMultipleChildNodeCommand(Resources.DotNetScriptShieldCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.DotNetScriptShieldCommandText),

                typeof(DotNetScriptShieldNode),

                typeof(ShieldsNode));

        }



        private void AddShieldParametersCommand()

        {

            AddSingleChildNodeCommand(Resources.ParametersCommandText,

                Resources.ParametersCommandLongText,

                typeof(ShieldParametersNode),

                typeof(DatabaseShieldNode));

            AddSingleChildNodeCommand(Resources.ParametersCommandText,

                Resources.ParametersCommandLongText,

                typeof(ShieldParametersNode),

                typeof(DotNetScriptShieldNode));

            AddSingleChildNodeCommand(Resources.ParametersCommandText,

                Resources.ParametersCommandLongText,

                typeof(ShieldParametersNode),

                typeof(SQLShieldNode));

        }



        private void AddShieldParameterCommand()

        {

            AddMultipleChildNodeCommand(Resources.ParameterCommandText,

                Resources.ParameterCommandLongText,

                typeof(ShieldParameterNode),

                typeof(ShieldParametersNode));

        }



        private void AddShieldLinksCommand()

        {

            AddSingleChildNodeCommand(Resources.ShieldLinksCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.ShieldLinksCommandText),

                typeof(ShieldLinkCollectionNode),

                typeof(AtomNode));

        }



        private void AddShieldLinkCommand()

        {

            AddMultipleChildNodeCommand(Resources.ShieldLinkCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.ShieldLinkCommandText),

                typeof(ShieldLinkNode),

                typeof(ShieldLinkCollectionNode));

        }



        private void AddShieldLinkParameterCommand()

        {

            AddMultipleChildNodeCommand(Resources.ShieldLinkParameterCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.ShieldLinkParameterCommandText),

                typeof(ShieldLinkParameterNode),

                typeof(ShieldLinkNode));

        }





        private void AddValidatorsCommand()

        {

            AddMultipleChildNodeCommand(Resources.MinMaxValidatorCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.MinMaxValidatorCommandText),

                typeof(MinMaxValidatorNode),

                typeof(ParameterNode));

            AddSingleChildNodeCommand(Resources.ListValidatorCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.ListValidatorCommandText),

                typeof(ListValidatorNode),

                typeof(ParameterNode));

            AddSingleChildNodeCommand(Resources.RegExpValidatorCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.RegExpValidatorCommandText),

                typeof(RegExpValidatorNode),

                typeof(ParameterNode));

            AddMultipleChildNodeCommand(Resources.DatabaseValidatorCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.DatabaseValidatorCommandText),

                typeof(DatabaseValidatorNode),

                typeof(ParameterNode));

            AddMultipleChildNodeCommand(Resources.SQLValidatorCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.SQLValidatorCommandText),

                typeof(SQLValidatorNode),

                typeof(ParameterNode));

            AddMultipleChildNodeCommand(Resources.XMLValidatorCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.XMLValidatorCommandText),

                typeof(XMLValidatorNode),

                typeof(ParameterNode));

            AddMultipleChildNodeCommand(Resources.DotNetScriptValidatorCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.DotNetScriptValidatorCommandText),

                typeof(DotNetScriptValidatorNode),

                typeof(ParameterNode));

        }



        private void AddAssemblyExecutorWizardCommand()

        {

            ConfigurationUICommand item = ConfigurationUICommand.CreateMultipleUICommand(ServiceProvider,

                Resources.AssemblyExecutorWizardCommandText,

                Resources.AssemblyExecutorWizardCommandLongText,

                new AssemblyExecutorWizardCommand(ServiceProvider),

                null);

            AddUICommand(item, typeof(ServiceProviderNode));

        }



        private void AddDatabaseExecutorWizardCommand()

        {

            ConfigurationUICommand item = ConfigurationUICommand.CreateMultipleUICommand(ServiceProvider,

                String.Format(Resources.DatabaseExecutorWizardCommandText, "Atoms"),

                String.Format(Resources.DatabaseExecutorWizardCommandText, "Atoms"),

                new DatabaseExecutorWizardCommand(ServiceProvider),

                null);

            AddUICommand(item, typeof(ServiceProviderNode));

            AddUICommand(item, typeof(CategoryNode));

            item = ConfigurationUICommand.CreateMultipleUICommand(ServiceProvider,

                String.Format(Resources.DatabaseExecutorWizardCommandText, "Shields"),

                String.Format(Resources.DatabaseExecutorWizardCommandText, "Shields"),

                new DatabaseExecutorWizardCommand(ServiceProvider),

                null);

            AddUICommand(item, typeof(ShieldsNode));

        }



        private void AddDefinitionGeneratorsCommand()

        {

            AddSingleChildNodeCommand(Resources.DefinitionGeneratorsCommandText,

                string.Format(Resources.GenericCommandLongText, Resources.DefinitionGeneratorsCommandText),

                typeof(DefinitionGeneratorsNode),

                typeof(ServiceProviderNode));

        }



        private void AddASDLDefinitionGeneratorCommand()

        {

            AddSingleChildNodeCommand(Resources.ASDLDefinitionGeneratorNodeName,

                string.Format(Resources.GenericCommandLongText, Resources.ASDLDefinitionGeneratorNodeName),

                typeof(ASDLDefinitionGeneratorNode),

                typeof(DefinitionGeneratorsNode));

        }



        private void AddJSDLDefinitionGeneratorCommand()

        {

            AddSingleChildNodeCommand(Resources.JSDLDefinitionGeneratorNodeName,

                string.Format(Resources.GenericCommandLongText, Resources.JSDLDefinitionGeneratorNodeName),

                typeof(JSDLDefinitionGeneratorNode),

                typeof(DefinitionGeneratorsNode));

        }



        private void AddWSDLDefinitionGeneratorCommand()

        {

            AddSingleChildNodeCommand(Resources.WSDLDefinitionGeneratorNodeName,

                string.Format(Resources.GenericCommandLongText, Resources.WSDLDefinitionGeneratorNodeName),

                typeof(WSDLDefinitionGeneratorNode),

                typeof(DefinitionGeneratorsNode));

        }



        private void AddHELPDefinitionGeneratorCommand()

        {

            AddSingleChildNodeCommand(Resources.HELPDefinitionGeneratorNodeName,

                string.Format(Resources.GenericCommandLongText, Resources.HELPDefinitionGeneratorNodeName),

                typeof(HELPDefinitionGeneratorNode),

                typeof(DefinitionGeneratorsNode));

        }



        private void AddXSLTDefinitionGeneratorCommand()

        {

            AddMultipleChildNodeCommand(Resources.XSLTDefinitionGeneratorNodeName,

                string.Format(Resources.GenericCommandLongText, Resources.XSLTDefinitionGeneratorNodeName),

                typeof(XSLTDefinitionGeneratorNode),

                typeof(DefinitionGeneratorsNode)); 

        }

    }

}