A simple configurable plugin

Creating a plugin that registers a configuration and uses the default configuration editor.

The Plugin class.

The first step is to create a class that implements the IPluginService interface. This is the type that will be instantiated by Scene Composer.

 public class SimpleConfigurablePlugin : IPluginService
 {
 }

Implementing IPlugin

Next we must implement the IPluginService interface members.

 public string Name
 {
   get { return return this.GetType().Name; }
 }

 public string Description
 {
    get { return "A plugin that has configuration"; }
 }

 public string Version
 {
   get { return "1.1.1"; }
 }

 public IEnumerable<int> FeatureIds
 {
   get { return null; }
 }

The Initialize method

First we need to register a custom cinfiguration interface and register to recieve an event when the configuration is loaded.

   ...
   var loader = unityContainer.Resolve<IConfigurationManager>().RegisterConfigurationInterface<ISimpleConfiguration>();
   loader.ConfigLoaded += loader_ConfigLoaded;
   ...

Then we need to registter a defualt configuration definition of our custom type with the UI definition manager

 unityContainer.Resolve<UIDefinitionManager>().RegisterUIElement
 (
   new DefaultConfigDefinition<ISimpleConfiguration>(category: OptionCategories.Plugins, name: "Default Config")
 );

The full code for the example with extra info:

SimpleConfigurablePlugin.cs

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using Feat.UIComposition.UIConfiguration;
  using FTC.SDKInterface.Plugins;
  using FTC.SDKInterface.Services;
  using Feat.UIComposition.Config;
  using System.ComponentModel;
  using Feat.UIComposition;
  using Feat.UIComposition.Commanding;
  using Feat.UIComposition.Menus;
  using FTC.SDKInterface.Constants;
  using Feat.Metadata.PropertyGrid;

  namespace UIPlugins
  {

     /// <summary>
     /// This examples demos a simple plugin that registers a configuration with FTC
     /// and uses the default configuration editor in scene composer.
     /// </summary>
     public class SimpleConfigurablePlugin : IPluginService
     {
        public string Description
        {
           get { return "A plugin that has configuration"; }
        }
        public string Name
        {
           get { return this.GetType().Name; }
        }

        public string Version
        {
           get { return "1.1.1"; }
        }

        public IEnumerable<int> FeatureIds
        {
           get { return null; }
        }

        public void Initialize(IUnityContainer unityContainer)
        {
           // We register the configuration interface with the configuration manager.
           // The object that is returned allow access to the config instance, allows the saving and loading of the configuration
           // and allows the registration of events pertinent to the configuration, such as the loading of the config or a property change.
           // Explicit loading or saving of the configuration is not necessary, as FTC will load the config the first time
           // it is accessed, and will save it when the application closes.
           // The plugin developer can however explicitly save the configuration or reload it from disk if necessary.
           var loader = unityContainer.Resolve<IConfigurationManager>().RegisterConfigurationInterface<ISimpleConfiguration>();

           //We register to receive events when the configuration is loaded.
           loader.ConfigLoaded += loader_ConfigLoaded;


           // We register with the ui definition manager a default configuration definition with the type of our custom config interface.
           // We also specify the category in which to place the configuration, and the name to use for the section.
           unityContainer.Resolve<UIDefinitionManager>().RegisterUIElement
           (
              new DefaultConfigDefinition<ISimpleConfiguration>(category: OptionCategories.Plugins, name: "Default Config")
           );
        }

        /// <summary>
        /// Event handler for when the configuarion is loaded.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void loader_ConfigLoaded(object sender, ConfigLoadedEventArgs<ISimpleConfiguration> e)
        {
           // If the configuration was not loaded successfully, either this is the first time it it has been created
           // and there was no configuration to load, or the configuration file was corrupted.
           // Either way we initialize complex configuration properties, that could not be initialized with the DefaultValue attribute.
           if (!e.ConfigLoadedSuccessfully)
           {
              e.Instance.OtherParameters = new List<string>
              {
                 "Param1 "
              };
           }
        }


     }

     /// <summary>
     /// The configuration interface. This interface will be implemented by Scene Composer and offered to the plugin
     /// when it is registered with the Configuration manager service.
     /// </summary>
     /// All properties declared  in the configuration interface must conform to standard .NET XMLSerializer standards.
     ///
     /// If we use the default editor for configurations then we can control how the property grid displays the content.
     ///
     /// The CategoryDisplayInfo attribute specifies that the default category should have no header. \n
     ///
     /// The DefaultValue attribute specifies the default value to be used for the property, either when resetting the value or
     /// when the configuration is first created. \n
     ///
     /// The Category attribute dictates the category in which the property grid will display the property. \n
     ///
     /// The DisplayName attribute specifies what name the property grid should use for this property, if the attribute is not specified,
     /// Scene composer will use the actual property name.\n
     ///
     /// The Browsable attribute allows the hiding of properties in the property grid.
     [CategoryDisplayInfo("", StyleKey = PropertyGridConstants.NoHeaderCategory)]
     public interface ISimpleConfiguration : IConfiguration
     {

        [DefaultValue("format C:")]
        string CommandToExecute { get; set; }

        [DefaultValue(true)]
        [DisplayName("Show confirmations")]
        [Category("Options")]
        bool Confirm { get; set; }

        [DefaultValue(false)]
        [Category("Options")]
        bool Silent { get; set; }

        [Browsable(false)]
        List<string> OtherParameters { get; set; }
     }
  }