Question

I am writing an extended treeview, just with a few extra properties in my TreeNode class with designtime support.

The code is allmost ready, but at the moment I’m completely stuck with the following code.
Everything I try at this point results in (another) exception…

Maybe anyone has an idea how to go futher? I don’t know it anymore

using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.ComponentModel.Design.Serialization;
using System.Drawing.Design;
using System.Globalization;
using System.Reflection;
using System.Runtime.Serialization;
using System.Windows.Forms;


namespace MyProject.Forms
{
    public class MenuTreeView : TreeView
    {
        public MenuTreeView()
        {
            //
        }

    [Editor(typeof(MenuTreeNodeCollectionEditor), typeof(UITypeEditor))]
    //[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
    public new TreeNodeCollection Nodes
    {
        get
        {
            return base.Nodes;
        }
    }
}

[Serializable]
[DefaultProperty("Text")]
[TypeConverter(typeof(MenuTreeNodeConverter))]
public class MenuTreeNode : TreeNode, ISerializable
{
    private string description = "";

    public MenuTreeNode()
        : base()
    {
        //
    }

    public MenuTreeNode(string text)
        : base(text)
    {
        //
    }

    public MenuTreeNode(string text, string description)
        : base(text)
    {
        this.description = description;
    }

    public MenuTreeNode(string text, MenuTreeNode[] children)
        : base(text, children)
    {
        //
    }

    public override object Clone()
    {
        object clone = base.Clone();
        MenuTreeNode node = clone as MenuTreeNode;
        if (node != null)
        {
            node.Description = Description;
            return node;
        }
        else return clone;
    }

    void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
    {
        Serialize(info, context);
    }

    protected override void Deserialize(SerializationInfo info, StreamingContext context)
    {
        Description = info.GetString("Description");

        base.Deserialize(info, context);
    }

    protected override void Serialize(SerializationInfo info, StreamingContext context)
    {
        info.AddValue("Description", Description);

        base.Serialize(info, context);
    }

    [DefaultValue("")]
    public string Description
    {
        get { return description; }
        set { description = value; }
    }
}

public class MenuTreeNodeConverter : TypeConverter
{
    public override bool CanConvertFrom(ITypeDescriptorContext context, Type type)
    {
        if (type == typeof(string))
        {
            return true;
        }

        return base.CanConvertFrom(context, type);
    }

    public override bool CanConvertTo(ITypeDescriptorContext context, Type type)
    {
        if (type == typeof(InstanceDescriptor) || type == typeof(string))
        {
            return true;
        }

        return base.CanConvertTo(context, type);
    }

    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo info, object value)
    {
        if (value != null && value is string)
        {
            string[] items = ((string)value).Split(',');
            return new MenuTreeNode(items[0], items[1]);
        }

        return base.ConvertFrom(context, info, value);
    }

    public override object ConvertTo(ITypeDescriptorContext context, CultureInfo info, object value, Type type)
    {
        MenuTreeNode node = value as MenuTreeNode;
        if (value != null)
        {
            if (type == typeof(string))
            {
                return node.Text + "," + node.Description;
            }
            else if (type == typeof(InstanceDescriptor))
            {
                ConstructorInfo constructor = typeof(MenuTreeNode).GetConstructor(new Type[] { typeof(string), typeof(string) });
                return new InstanceDescriptor(constructor, new object[] { node.Text, node.Description }, true);
            }
        }

        return base.ConvertTo(context, info, value, type);
    }
}

public class MenuTreeNodeCollectionEditor : CollectionEditor
{
    public MenuTreeNodeCollectionEditor(Type t)
        : base(t)
    {
        //
    }

    protected override Type CreateCollectionItemType()
    {
        return typeof(MenuTreeNode);
    }

    protected override Type[] CreateNewItemTypes()
    {
        return new Type[] { typeof(MenuTreeNode) };
    }

    protected override object CreateInstance(Type itemType)
    {
        if (itemType == typeof(MenuTreeNode))
        {
            return new MenuTreeNode();
        }

        return base.CreateInstance(itemType);
    }

    protected override string GetDisplayText(object value)
    {
        MenuTreeNode node = value as MenuTreeNode;
        if (node != null)
        {
            return "MenuTreeNode: " + node.Text;
        }

        return base.GetDisplayText(value);
    }
}

}

[edit]
After moving the Treeview to another project, all goes fine. Don’t ask me why…

But: only the properties Text and Description are saved, because the designer does not create local variables for each added node. How can I achieve this?

[edit]
Finally, I got it to work! thanks to this: http://netcode.ru/dotnet/?lang=&katID=30&skatID=283&artID=7827

The solution was to remove the typeof(string) from the TypeConvertor, and when the type is InstanceDescriptor, just return the default constructor.

Answer 1

Finally, I got it to work! thanks to this article: http://netcode.ru/dotnet/?lang=&katID=30&skatID=283&artID=7827

The solution was to remove the typeof(string) from the TypeConvertor, and when the type is InstanceDescriptor, just returning the default constructor does the job.