I am adding some design time support to a class that I need the user to
be able to modify.  There are two class properties that I would like not
to display in the property grid.  I have marked the property with the
browsable attribute as I have done in the past.  But this time, these
properties are still getting displayed.

In this case, I have created a simple type converter for this class.
I'm wondering if I need to do something more elaborate in the
GetProperties method than returning TypeConverter.GetProperties(myType).
Does this mess up the original browsable attributes setting?

Thanks,
Scott

Here's some code:
    [Serializable]
    [TypeConverter(typeof(ResultConverter))]
    public class Result : IResult
    {
        private string m_Name;
        private string m_Units;
        private double m_ToleranceMax;
        private double m_ToleranceMin;
        private bool m_IsUsed;
        private double m_Value;

        public Result(string name, string units)
        {
            m_Name = name;
            m_Units = units;
            m_ToleranceMin = 0;
            m_ToleranceMax = 0;
            // used by default
            m_IsUsed = true;
        }

        public Result(string name, string units, double toleranceMin,
double toleranceMax ) : this(name, units)
        {
            if (toleranceMax >= toleranceMin)
            {
                m_ToleranceMin = toleranceMin;
                m_ToleranceMax = toleranceMax;
            }
            else
            {
                throw new ArgumentException("The maximum tolerance must
be greater than or equal to the minimum tolerance.");
            }
        }

        public Result(string name, string units, double toleranceMin,
double toleranceMax, bool isUsed) :
                this(name, units, toleranceMin, toleranceMax)
        {
            m_IsUsed = isUsed;
        }

        public override string ToString()
        {
            return string.Format("{0} ({1})", m_Name, m_Units);
        }
        #region IResult Members

        [Browsable(false)]
        public string Name
        {
            get
            {
                return m_Name;
            }
        }

        [Browsable(false)]
        public string Units
        {
            get
            {
                return m_Units;
            }
        }


[DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
Description("Tolerance maximum for this result")]
        public double ToleranceMax
        {
            get
            {
                return m_ToleranceMax;
            }
            set
            {
                if (value >= m_ToleranceMin)
                {
                    m_ToleranceMax = value;
                }
                else
                {
                    throw new ArgumentException("The maximum tolerance
must be greater than or equal to the minimum tolerance.");
                }
            }
        }


[DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
Description("Tolerance minimum for this result")]
        public double ToleranceMin
        {
            get
            {
                return m_ToleranceMin;
            }
            set
            {
                if (value <= m_ToleranceMax)
                {
                    m_ToleranceMin = value;
                }
                else
                {
                    throw new ArgumentException("The minimum tolerance
must be less than or equal to the maximum tolerance.");
                }
            }
        }

        [Browsable(false)]
        public double Value
        {
            get
            {
                return m_Value;
            }
            set
            {
                m_Value = value;
            }
        }

        [Description("This flag is used to tell the analysis routine to
calculate and display this result.")]

[DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
DefaultValue(true) ]
        public bool IsUsed
        {
            get
            {
                return m_IsUsed;
            }
            set
            {
                m_IsUsed = value;
            }
        }

        public bool IsWithinTolerances()
        {
            return ((m_Value >= m_ToleranceMin) && (m_Value <=
m_ToleranceMax));
        }

        #endregion
    }

    class ResultConverter : TypeConverter
    {
        public override bool
GetPropertiesSupported(ITypeDescriptorContext context)
        {
            return true;
        }

        public override PropertyDescriptorCollection
GetProperties(ITypeDescriptorContext context, object value, Attribute[]
attributes)
        {
            return TypeDescriptor.GetProperties(typeof(Result));
        }
    }