_0SampleStrategyTypeConverterEtoStr Ninjatrader

#region Using declarations
using NinjaTrader.Cbi;
using NinjaTrader.Core.FloatingPoint;
using NinjaTrader.Data;
using NinjaTrader.Gui.Chart;
using NinjaTrader.Gui.SuperDom;
using NinjaTrader.Gui;
using NinjaTrader.NinjaScript.DrawingTools;
using NinjaTrader.NinjaScript.Indicators;
using NinjaTrader.NinjaScript;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows;
using System.Xml.Serialization;
using System;
#endregion


namespace NinjaTrader.NinjaScript.Strategies
{
    [TypeConverter("NinjaTrader.NinjaScript.Strategies.MyConverterEtoStr")]
    public class _0SampleStrategyTypeConverterEtoStr : Strategy
    {
        protected override void OnStateChange()
        {
            if (State == State.SetDefaults)
            {
                Description = "";
                Name = "_0SampleStrategyTypeConverterEtoStr";
                IsOverlay = true;
   
                ReadOnlyToggle1 	= false;
                ReadOnlyToggle2 	= false;
                ReadOnlyInt 		= 10;
                
                EnumValue 		= MyEnumEtoStr.MyCustom2;
				ReadOnlyString 	= EnumValue.ToString();
				
				Print("EnumValue: " + EnumValue);
				Print("ReadOnlyString: " + ReadOnlyString);
            }
        }

        protected override void OnBarUpdate()
        {
        }
		
        [RefreshProperties(RefreshProperties.All)] 
        [Display(Name = "Toggle read only 1", Order = 1, GroupName = "Use Case #2")]
        public bool ReadOnlyToggle1
        { get; set; }

        [Range(1, int.MaxValue)]
        [Display(Name = "Read only int", Order = 2, GroupName = "Use Case #2")]
        public int ReadOnlyInt
        { get; set; }
		
        [RefreshProperties(RefreshProperties.All)] 
        [Display(Name = "Toggle read only 2", Order = 3, GroupName = "Use Case #2")]
        public bool ReadOnlyToggle2
        { get; set; }

        [NinjaScriptProperty]
        [Display(Name = "Read only string", Order = 4, GroupName = "Use Case #2")]
        public string ReadOnlyString
        { get; set; }

        [TypeConverter(typeof(FriendlyEnumConverterEtoStr))] 
        [PropertyEditor("NinjaTrader.Gui.Tools.StringStandardValuesEditorKey")] 
        [Display(Name = "Friendly Enum", Order = 5, GroupName = "Use Case #4")]
        public MyEnumEtoStr EnumValue
        { get; set; }
    }
    
    public class MyConverterEtoStr : StrategyBaseConverter 
    {
        public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object component, Attribute[] attrs)
        {
            _0SampleStrategyTypeConverterEtoStr strategy = component as _0SampleStrategyTypeConverterEtoStr;

            PropertyDescriptorCollection propertyDescriptorCollection = base.GetPropertiesSupported(context)
                                                                        ? base.GetProperties(context, component, attrs)
                                                                        : TypeDescriptor.GetProperties(component, attrs);

            if (strategy == null || propertyDescriptorCollection == null)
                return propertyDescriptorCollection;
			
            PropertyDescriptor readOnlyInt = propertyDescriptorCollection["ReadOnlyInt"];
            PropertyDescriptor readOnlyString = propertyDescriptorCollection["ReadOnlyString"];

            propertyDescriptorCollection.Remove(readOnlyInt);
            propertyDescriptorCollection.Remove(readOnlyString);

            readOnlyInt = new ReadOnlyDescriptorEtoStr(strategy, readOnlyInt);
            readOnlyString = new EnumConverterDescriptorEtoStr(strategy, readOnlyString);

            propertyDescriptorCollection.Add(readOnlyInt);
            propertyDescriptorCollection.Add(readOnlyString);

            PropertyDescriptor enumValue = propertyDescriptorCollection["EnumValue"];

            propertyDescriptorCollection.Remove(enumValue);

            readOnlyInt = new ReadOnlyDescriptorEtoStr(strategy, enumValue);

            propertyDescriptorCollection.Add(enumValue);

            return propertyDescriptorCollection;
        }

        public override bool GetPropertiesSupported(ITypeDescriptorContext context)
        { return true; }
    }
    
    public class ReadOnlyDescriptorEtoStr : PropertyDescriptor
    {
        private _0SampleStrategyTypeConverterEtoStr strategyInstance;

        private PropertyDescriptor property;

        public ReadOnlyDescriptorEtoStr(_0SampleStrategyTypeConverterEtoStr strategy, PropertyDescriptor propertyDescriptor) : 
                base(propertyDescriptor.Name, propertyDescriptor.Attributes.OfType<Attribute>().ToArray())
        {
            strategyInstance = strategy;
            property = propertyDescriptor;
        }

        public override object GetValue(object component)
        {
            _0SampleStrategyTypeConverterEtoStr targetInstance = component as _0SampleStrategyTypeConverterEtoStr;
            
			if (targetInstance == null)
                return null;
			
            switch (property.Name)
            {
                case "ReadOnlyInt":
                	return targetInstance.EnumValue;
            }
            return null;
        }

        public override void SetValue(object component, object value)
        {
            _0SampleStrategyTypeConverterEtoStr targetInstance = component as _0SampleStrategyTypeConverterEtoStr;
            
			if (targetInstance == null)
                return;

            switch (property.Name)
            {
                case "ReadOnlyInt":
                    targetInstance.ReadOnlyInt = (int) value;
                    break;
            }
        }

        public override bool IsReadOnly
        { get { return strategyInstance.ReadOnlyToggle1; } }

        public override bool CanResetValue(object component)
        { return true; }

        public override Type ComponentType
        { get { return typeof(_0SampleStrategyTypeConverterEtoStr); } }

        public override Type PropertyType
        { get { return typeof(int); } }

        public override void ResetValue(object component)
        { }

        public override bool ShouldSerializeValue(object component)
        { return true; }
    }  
    
	public class EnumConverterDescriptorEtoStr : PropertyDescriptor
	{
	    private _0SampleStrategyTypeConverterEtoStr strategyInstance; 
	    private PropertyDescriptor property;
 
	    public EnumConverterDescriptorEtoStr(_0SampleStrategyTypeConverterEtoStr strategy, PropertyDescriptor propertyDescriptor) 
	        : base(propertyDescriptor.Name, propertyDescriptor.Attributes.OfType<Attribute>().ToArray())
	    {
	        strategyInstance = strategy;
	        property = propertyDescriptor;
	    }

	    public override object GetValue(object component)
	    {
	        return strategyInstance.EnumValue;
	    }

	    public override void SetValue(object component, object value)
	    {
			NinjaTrader.Code.Output.Process("strategyInstance.ReadOnlyString: " + strategyInstance.ReadOnlyString, PrintTo.OutputTab1);
			NinjaTrader.Code.Output.Process("strategyInstance.EnumValue.ToString(): " + strategyInstance.EnumValue.ToString(), PrintTo.OutputTab1);
			NinjaTrader.Code.Output.Process("strategyInstance.EnumValue: " + strategyInstance.EnumValue, PrintTo.OutputTab1);
			NinjaTrader.Code.Output.Process("strategyInstance.ReadOnlyString1: " + strategyInstance.ReadOnlyString, PrintTo.OutputTab1);
			NinjaTrader.Code.Output.Process("value: " + value, PrintTo.OutputTab1);
			
			strategyInstance.ReadOnlyString = strategyInstance.EnumValue.ToString();
			
			if(value.ToString() != strategyInstance.EnumValue.ToString())
			{
				strategyInstance.ReadOnlyString = value.ToString();
			}
	    }  
		
		
	    public override bool IsReadOnly 
	    {  get  { return false; } }

	    public override bool CanResetValue(object component)
	    { return true; }

	    public override Type ComponentType
	    { get { return typeof(_0SampleStrategyTypeConverterEtoStr); } }

	    public override Type PropertyType
	    { get { return typeof(string); } }

	    public override void ResetValue(object component) { }

	    public override bool ShouldSerializeValue(object component)
	    { return true; }
	}

    public enum MyEnumEtoStr
    {
        MyCustom1,
        MyCustom2,
        MyCustom3
    }

    public class FriendlyEnumConverterEtoStr : TypeConverter
    {
	    public string stringVal { get; set; }

        public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
        {
            List<string> values = new List<string>() { "My custom one", "My custom two", "My custom three" };

            return new StandardValuesCollection(values);
        }

        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
        {
            string stringVal = value.ToString();
			
            switch (stringVal)
            {
                case "My custom one":
                return MyEnumEtoStr.MyCustom1;
                case "My custom two":
                return MyEnumEtoStr.MyCustom2;
                case "My custom three":
                return MyEnumEtoStr.MyCustom3;
            }
            return MyEnumEtoStr.MyCustom1;
        }

		public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
		{
			MyEnumEtoStr enumValue = (MyEnumEtoStr)value;
			switch (enumValue)
			{
				case MyEnumEtoStr.MyCustom1:
					stringVal = "My custom one";
					break;
				case MyEnumEtoStr.MyCustom2:
					stringVal = "My custom two";
					break;
				case MyEnumEtoStr.MyCustom3:
					stringVal = "My custom three";
					break;
			}
			return stringVal;
		}

        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
        { return true; }

        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
        { return true; }

        public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
        { return true; }

        public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
        { return true; }
    }

}