Extender Provider and Complex Types, Design Mode

Question

5.00/5 (1 vote)

See more:

Hi All

Suppose you created an extender provider for controls as follows:

C#

[ProvideProperty("Information", typeof(Control))]
public class TestExtender:Component, IExtenderProvider
{
    public Information GetInformation(Control extendee) {
       // retrieves information object from a Dictionary<control,> list
    }

    public Information SetInformation(Control extendee, Information information) {
       // adds information to Dictionary<control,> 
    }
}

(other details omitted to focus on the Information object)

The information object would have numerous properties (Title, Text, etc).

When compiled, I add the extender provider to the form, and it adds an Information property to the PropertyGrid as expected.

My question - how do you get the PropertyGrid to add the subproperties of Information to the PropertyGrid?

So, in the PropertyGrid of a Control, say TextBox1, there would be a property Information, and when you click the +, it would display the properties of class Information.

I can't figure out how to do this.

Posted 8-Sep-11 4:54am

Ryan Minor

Updated 8-Sep-11 6:33am

v2

Add a Solution

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

OriginalGriff · Answer 1 · 2011-09-08T06:26:00

This works for a normal UserControl, so it should work for you:
Define the base field, and create a public property for it, with the name of the display property you wish. Include the property Properties as shown below:

C#

private ThumbDisplay thumb = new ThumbDisplay();
[Category("Appearance"),
DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public ThumbDisplay Thumbnails
    {
    get { return thumb; }
    set { thumb = value; }
    }

Create your class for the property, with Properties as shown:

C#

[TypeConverter(typeof(ThumbInfoConverter))]
public class ThumbDisplay
    {
    private int minWidth = 25;

    [NotifyParentProperty(true),
    RefreshProperties(RefreshProperties.Repaint)]
    public int MinWidth
        {
        get { return minWidth; }
        set { minWidth = value; }
        }

    private int initialWidth = 100;

    [NotifyParentProperty(true),
    RefreshProperties(RefreshProperties.Repaint)]
    public int InitialWidth
        {
        get { return initialWidth; }
        set { initialWidth = value; }
        }
    private int maxWidth = 255;

    [NotifyParentProperty(true),
    RefreshProperties(RefreshProperties.Repaint)]
    public int MaxWidth
        {
        get { return maxWidth; }
        set { maxWidth = value; }
        }
    }
}

Create the InfoConverter class for your class:

C#

class ThumbInfoConverter : ExpandableObjectConverter
    {
    /// <summary>
    /// CanConvertFrom specifies data types the converter can convert from.
    /// </summary>
    /// <param name="context"></param>
    /// <param name="t"></param>
    /// <returns></returns>
    public override bool CanConvertFrom(ITypeDescriptorContext context,
                                        Type t)
        {
        if (t == typeof(string))
            {
            return true;
            }
        return base.CanConvertFrom(context, t);
        }
    /// <summary>
    ///ConvertFrom actually implements the conversion.
    /// </summary>
    /// <param name="context"></param>
    /// <param name="info"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    public override object ConvertFrom(ITypeDescriptorContext context,
                                       CultureInfo info,
                                       object value)
        {
        if (value is string)
            {
            try
                {
                string s = (string)value;
                //Parse the format "min, initial, max"
                Regex r = new Regex(@"\s*(?<min>\d+),\s*(?<initial>\d+),\s*(?<max>\s*\d+)");
                Match m = r.Match(s);
                if (m.Groups.Count == 4)
                    {
                    // All ok
                    int min = Convert.ToInt32(m.Groups[1].Value);
                    int initial = Convert.ToInt32(m.Groups[2].Value);
                    int max = Convert.ToInt32(m.Groups[3].Value);
                    ThumbDisplay t = new ThumbDisplay();
                    t.MinWidth = min;
                    t.InitialWidth = initial;
                    t.MaxWidth = max;
                    return t;
                    }
                }
            catch { }
            // If you got this far, complain that you
            // could not parse the string.
            throw new ArgumentException("Cannot convert '" + (string)value +
                    "' to type ThumbDisplay \"minimumWidth, initialWidth, "+
                    "maximumWidth\"");
            }
        return base.ConvertFrom(context, info, value);
        }
    /// <summary>
    ///CanConvertTo specifies which data types the converter can convert to.
    /// </summary>
    /// <param name="context"></param>
    /// <param name="culture"></param>
    /// <param name="value"></param>
    /// <param name="destType"></param>
    /// <returns></returns>
    public override object ConvertTo(ITypeDescriptorContext context,
                                     CultureInfo culture,
                                     object value,
                                     Type destType)
        {
        if (destType == typeof(string))
            {
            ThumbDisplay t = (ThumbDisplay)value;
            return string.Format("{0}, {1}, {2}",
                                 t.MinWidth,
                                 t.InitialWidth,
                                 t.MaxWidth);
            }
        return base.ConvertTo(context, culture, value, destType);
        }
    }

In order to provide the sort order for the subproperties yourself, overide the ExpandableObjectConverter GetProperties method:

C#

public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context,
    object value,
    Attribute[] attributes)
    {
    return TypeDescriptor.GetProperties(typeof(ThumbDisplay), attributes).Sort(new string[] { "MinWidth", "InitialWidth", "MaxWidth" });
    }