Extending XtraEditors for fun and profit

One question that I see pop up every now and then in the DevExpress Support Center deals with changing the default behavior of the various controls offered in the XtraEditors suite. Many people are looking for a static property that can override the default settings of the controls so that they don’t need to constantly set the same properties for controls that are used over and over again. While there are some static properties and methods that can control behavior, for the most part you’re on your own when it comes to changing how the editors work on an application-wide basis.

To make things easier, I often find myself extending the DevExpress controls to suit my own requirements. The various controls offered in the XtraEditors suite are for the most part descendants of the standard .NET controls offered in System.Windows.Forms namespace; for instance, the XtraEditors TextEdit is just a descendant of the System.Windows.Forms.TextBox control, albeit with a lot of additional functionality and styling added.

The simplest method of building our own extended control library would be to just create a class that derives from one of the DevExpress controls:

public class MyTextEdit : DevExpress.XtraEditors.TextEdit
{
    public MyTextEdit() : base() { }
}

So with that, we have the beginnings of a basic extension of the TextEdit.

I’ve come to embrace the idea of changing user-input into upper case for the sake of consistency. To handle this, the TextEdit control offers a nifty feature in the form of the CharacterCasing property. You can set this property to CharacterCasing.Upper for each instance of the TextEdit control to automatically change the user’s input to upper case regardless of their CAPS LOCK setting.

Doing this is easy enough, but it kind of violates the principle we’re trying to establish here. If you have a dozen forms, each containing 10 TextEdit controls, do you really want to repetitively change the same property over and over? Instead, let’s build a basic TextEdit descendant that automatically defaults to upper case!

    /// <summary>
    /// A TextEdit control which defaults to upper case text editing
    /// </summary>
    [ToolboxItem(true)]
    [Description("Creates a TextEdit control which defaults to upper case text editing")]
    public class UpperCaseTextEdit : TextEdit
    {

        /// <summary>
        /// Initializes a new instance of the UpperCaseTextEdit class
        /// </summary>
        public UpperCaseTextEdit()
            : base()
        {
        }



        /// <summary>
        /// OnCreateControl event handler
        /// </summary>
        protected override void OnCreateControl()
        {
            base.OnCreateControl();

            Properties.CharacterCasing = System.Windows.Forms.CharacterCasing.Upper;

        }   //End the OnCreateControl() method


    }   //End the UppercaseTextEdit class

Let’s have a look at what’s going on here.

First, we’ve decorated our class with the [ToolboxItem(true)] attribute. This tells Visual Studio that the control should be made available in the toolbox window. Visual Studio is also nice enough to automatically look through your solution for any controls which have this attribute and place them in the toolbox for immediate use.

Aside from that, the most important thing to do is to place your default behavior within the control’s OnCreateControl event handler. If you don’t, you may find that your settings are just overwritten at runtime.

This is all and good, but many times we edit our data within a GridControl. If we want our new UpperCaseTextEdit control to be usable as a GridControl repository item, we’ll need to define our own repository item type.


    /// <summary>
    /// 
    /// </summary>
    [UserRepositoryItem("Register")]
    public class RepositoryItemUpperCaseTextEdit : RepositoryItemTextEdit
    {

        #region Internal members

        /// <summary>
        /// Editor name
        /// </summary>
        internal const string EditorName = "UpperCaseTextEdit";

        #endregion

        #region Public accessors

        /// <summary>
        /// Gets the EditorTypeName of this RepositoryItemTextEdit editor
        /// </summary>
        public override string EditorTypeName
        {
            get { return EditorName; }
        }

        #endregion


        /// <summary>
        /// Static constructor
        /// </summary>
        static RepositoryItemUpperCaseTextEdit()
        {
            Register();
        }


        /// <summary>
        /// Initializes a new instance of the RepositoryItemUpperCaseTextEdit class
        /// </summary>
        public RepositoryItemUpperCaseTextEdit()
            : base()
        {

        }


        public override System.Windows.Forms.CharacterCasing CharacterCasing
        {
            get
            {
                return System.Windows.Forms.CharacterCasing.Upper;
            }
            set
            {
                base.CharacterCasing = value;
            }
        }


        /// <summary>
        /// Registers this editor with the designer
        /// </summary>
        public static void Register()
        {
            EditorRegistrationInfo.Default.Editors.Add
                (
                    new EditorClassInfo(EditorName, typeof(UpperCaseTextEdit),
                    typeof(RepositoryItemUpperCaseTextEdit), typeof(TextEditViewInfo),
                    new TextEditPainter(), true, null)
                );

        }   //End the Register() method

    }   //End the RepositoryItemUpperCaseTextEdit class

Most of this code is going to be pretty boiler-plate as you build your own extended control library. You must provide an EditorTypeName, register it in a static constructor and provide an implementation of the Register method. The Register method is going need to know the name of the editor, the type (this is your control class) and what DevExpress ViewInfo and Painter to use. How do I know which ViewInfo or Painter to use? For the most part, it’s pretty self-explanatory, but there are some caveats. For instance, a LookUpEdit descendant needs to use the ButtonEditPainter. Lucky for us, DevExpress provides a handy chart viewable in the Custom Editors documentation.

One more thing of note: you’ll notice that I’ve overrode the CharacterCasing property in the RepositoryItemUpperCaseTextEdit class to have it return CharacterCasing.Upper by default. This is a better solution than setting the property in the OnCreateControl event.

What if we’d like to create a control with some additional properties? When my users need to enter a location address, I present them with a drop-down list containing the abbreviations of the US and Mexican states as well as Canadian provinces. After all, who can remember that “MI” is Michigan and not Missouri? To simply this data entry, let’s create a ComboBoxEdit descendant which is pre-filled with these abbreviations and has some additional properties to determine if we want to show Mexican states or Canadian provinces.

We’ll start by creating a control that derives from the ComboBoxEdit class and we’ll add in a few new members:


        /// <summary>
        /// Include USA flag
        /// </summary>
        private bool _IncludeUSA;

        /// <summary>
        /// Include Canada flag
        /// </summary>
        private bool _IncludeCanada;

        /// <summary>
        /// Include Mexico flag
        /// </summary>
        private bool _IncludeMexico;

That helps us within the class, but we are going to want those properties to be exposed at design-time via the Visual Studio properties window. Let’s add some public accessors to expose the private members:


        /// <summary>
        /// Gets or sets a value indicating if US states should be included in the ComboBoxEdit
        /// </summary>
        [Browsable(true)]
        [PropertyTab("Geography", PropertyTabScope.Component)]
        [Description("Gets or sets a value indicating if US states should be included in the ComboBoxEdit")]
        public bool IncludeUSA
        {
            get { return _IncludeUSA; }
            set { _IncludeUSA = value; }
        }

        /// <summary>
        /// Gets or sets a value indicating if Canadian provinces should be included in the ComboBoxEdit
        /// </summary>
        [Browsable(true)]
        [PropertyTab("Geography", PropertyTabScope.Component)]
        [Description("Gets or sets a value indicating if Canadian provinces should be included in the ComboBoxEdit")]
        public bool IncludeCanada
        {
            get { return _IncludeCanada; }
            set { _IncludeCanada = value; }
        }

        /// <summary>
        /// Gets or sets a value indicating if Mexican states should be included in the ComboBoxEdit
        /// </summary>
        [Browsable(true)]
        [PropertyTab("Geography", PropertyTabScope.Component)]
        [Description("Gets or sets a value indicating if Mexican states should be included in the ComboBoxEdit")]
        public bool IncludeMexico
        {
            get { return _IncludeMexico; }
            set { _IncludeMexico = value; }
        }

The important take-away from the above snippet is to decorate your properties with the [Browsable(true)] attribute. Without this, Visual Studio will not display these properties in the designer.

If you want to pre-populate a list editor, do so within the OnLoaded event:

        /// <summary>
        /// On loaded event handler
        /// </summary>
        protected override void OnLoaded()
        {
            Properties.TextEditStyle = DevExpress.XtraEditors.Controls.TextEditStyles.DisableTextEditor;
            LoadStates(_IncludeUSA, _IncludeCanada, _IncludeMexico);

            base.OnLoaded();

        }   //End the OnLoaded() method

Here you’ll see that we’re disabling the ability for end-users to enter their own text within the drop-down by default. We certainly don’t want them inventing their own state/province abbreviations! From there, we invoke the LoadStates method and pass in our Boolean flags that indicate what should be contained within the drop-down. I chose to NOT populate the list within this event because I’d like to be able to reload the list at runtime; for instance, if we have another drop down called “Country”, it doesn’t make sense to show Canadian provinces if the user selects “United States”. At runtime, I can call the StateComboBoxEdit’s LoadStates method to change what is visible in the list.

The LoadStates method just builds a basic object array to be assigned to the control’s Items collection:

        /// <summary>
        /// Populates the State ComboBoxEdit with states/provinces
        /// </summary>
        /// <param name="includeCanada">True to include Canadian provinces</param>
        public void LoadStates(bool includeUSA, bool includeCanada, bool includeMexico)
        {
            //Clear existing items
            if (DesignMode == true || Properties.Items.Count > 0)
                Properties.Items.Clear();

            //Add states/provinces
            if (includeUSA == true)
            {
                Properties.Items.AddRange(new object[] 
                { 
                    "AK",
                    "AL",
                    "AP",
                    "AR",
                    "AS",
                    "AZ",
                    "CA",
                    "CO",
                    "CT",
                    "DC",
                    "DE",
                    "FL",
                    "FM",
                    "GA",
                    "GU",
                    "HI",
                    "IA",
                    "ID",
                    "IL",
                    "IN",
                    "KS",
                    "KY",
                    "LA",
                    "MA",
                    "MD",
                    "ME",
                    "MH",
                    "MI",
                    "MN",
                    "MO",
                    "MP",
                    "MS",
                    "MT",
                    "NB",
                    "NC",
                    "ND",
                    "NE",
                    "NF",
                    "NH",
                    "NJ",
                    "NM",
                    "NT",
                    "NU",
                    "NV",
                    "NY",
                    "OH",
                    "OK",
                    "OR",
                    "PA",
                    "PR",
                    "PW",                
                    "RI",
                    "SC",
                    "SD",                
                    "TN",
                    "TX",
                    "UT",
                    "VA",
                    "VI",
                    "VT",
                    "WA",
                    "WI",
                    "WV",
                    "WY"                
                });
            }

            if (includeCanada == true)
            {
                Properties.Items.AddRange(new object[]
                {
                    "AA",
                    "AB",
                    "AE",
                    "BC",
                    "MB",
                    "NS",
                    "ON",
                    "PE",
                    "PQ",
                    "QC",
                    "SK",
                    "YT"
                });
            }

        }   //End the LoadStates() method

The only thing of note in this method is that I first check if we’re in design-mode or if the list already has items in it. If you don’t do this you’ll find that every time the list is opened (or created as you switch from design view to code view and back-and-forth) your items will be added again. This is obviously not ideal, so take care to always perform this check with list editors!

Take some time and look at your application to see what editors are duplicated to perform common tasks and you may find that it’s worthwhile to create your own control assembly. Personally, I’ve built some useful editors such as:

  • CountryComboBoxEdit – a basic drop down with a list of countries
  • DataLayoutControlEx – an extension of the DataLayoutControl which disables end-user manipulation by default, is automatically set to DockStyle.Fill, focuses an editor when its corresponding caption is clicked (similar to a <label> tag in Html) and overrides the default behavior to use my UpperCaseTextEdit in lieu of the TextEdit when an item is bound to a string type.
  • EmailAddressEdit and UrlEdit :  ButtonEdit descendants which have a default button that opens the user’s email editor with the control’s text set as the mail to, or opens a browser with the provided Url.
  • PhoneNumberEdit: a TextEdit control which has a default RegEx mask set for North American phone numbers.

Download the full source code for our examples here and experiment! CustomEditors

Extending XtraEditors for fun and profit

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s