by Jim Lavin

Sometimes when defining a property for a domain model element you may need to use a complex type that has more than one property or can’t easily be displayed using a single text field or drop down in the property editor. A good example might be a class that holds a list of strings for a GUI interface or a Rich Text editor for a custom text field required by your framework.

To resolve this you can create a custom editor and hook it into your domain model that will provide a proper user interface to specify information for your property.

There are three steps you need to take in order to wire your domain property to display a custom editor:

1. Create a class derived from System.Drawing.Design.UITypeEditor that will launch the custom dialog box as below:

using System;

using System.Collections.Generic;

using System.Text;

// Need to add a reference to System.Drawing DLL.

using System.Drawing.Design;

using System.Security.Permissions;

using Microsoft.VisualStudio.Modeling;

using Microsoft.VisualStudio.Modeling.Design;

namespace XXX.UIProcessDesigner.UIEditors

{

    // FxCop rule: must have same security demands as parent class

    [PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust"),

    PermissionSet(SecurityAction.InheritanceDemand, Name = "FullTrust")]

    public class FormPromptUITypeEditor :

    System.Drawing.Design.UITypeEditor

    {

        /// <summary>

        /// Overridden to specify that our editor is a modal form

        /// </summary>

        /// <param name="context"></param>

        /// <returns></returns>

        public override UITypeEditorEditStyle

        GetEditStyle(System.ComponentModel.ITypeDescriptorContext context)

        {

            return UITypeEditorEditStyle.Modal;

        }

        /// <summary>

        /// Called by VS whenever the user clicks on the ellipsis in the 

        /// properties window for a property to which this editor is linked.

        /// </summary>

        /// <param name="context"></param>

        /// <param name="provider"></param>

        /// <param name="value"></param>

        /// <returns></returns>

        public override object EditValue(

            System.ComponentModel.ITypeDescriptorContext context,

            IServiceProvider provider,

            object value)

        {

            // Get a reference to the underlying property element

            ElementPropertyDescriptor descriptor = context.PropertyDescriptor as

            	ElementPropertyDescriptor;

            ModelElement underlyingModelElent = descriptor.ModelElement;

            // context.Instance also returns a model element, but this will either

            // be the shape representing the underlying element (if you selected

            // the element via the design surface), or the underlying element 

            // itself (if you selected the element via the model explorer)

            ModelElement element = context.Instance as ModelElement;

            FormPromptUITypeEditorForm theForm = new FormPromptUITypeEditorForm();

            theForm.Value = (string)value;

            if (theForm.ShowDialog() == System.Windows.Forms.DialogResult.OK)

            {

                value = theForm.Value;

            }

            return value;

        }

    }

}

2. Create a Windows Form dialog that will be displayed when the editor is invoked, such as the one below:

3. Set the Custom Attributes for the Domain Property to reference the UITypeEditor class you have created.

The text is as follows:

[System.ComponentModel.Editor(typeof(XXX.UIProcessDesigner.UIEditors.FormActionTypeUITypeEditor),typeof(System.Drawing.Design.UITypeEditor))]

The bold faced text is the full namespace of your class that derives from UITypeEditor.

I normally store all code that I add to a DSL Designer in various folders such as; CustomCode, UIEditors, Validators, etc. That way it is easy to find when I am trying to reference it.

Also, you can debug the UITypeEditor and Dialog by setting breakpoints in the code before you start debugging.