Context menu for the custom properties in the C# PropertyGrid

• Download demo - 9.99 Kb
• Download source (Visual Studio .NET 2003) - 12.2 Kb

There is another window inside:

Changing the name also, not only the value:

Introduction

I came to a point where I needed to allow the user to reset the values in the property grid, the same way Visual Studio does (using a context menu when right clicking on the property). This is useful for some reasons:

• You don't have to remember the old value of the property. The controls does it all for you.
• The control displays the modified properties using bold, so it's easy to see which properties have been modified.

Background

After searching a great deal on the internet, I still didn't find anything. Then it occurred to me to use the same old friend, the Spy++ tool that comes with Visual Studio. Then I noticed there is another window inside what we think is the property grid. That other window does all the impressive work that makes the property grid so famous.

Since there is no direct way to get our hands on that window, I had to go brute force on it:

propertyGrid1.GetChildAtPoint( new Point(40,40) )

Now, I had the window. All I had to do was to get my hands on the messages the window receives and look for messages that indicate a right click inside.

This is done by adding a filter to all the messages in the application's loop and looking for the messages addressed to our window:

Application.AddMessageFilter( new PropertyGridMessageFilter( 
        propertyGrid1.GetChildAtPoint( new Point(40,40) ), 
        new MouseEventHandler( propGridView_MouseUp )) );

Since doing this in the OnLoad event handler failed (Object reference not set to an instance of an object), I now do it in a timer event handler that lets the entire GUI to instantiate:

private void timerLoad_Tick(object sender, System.EventArgs e)
{
    timerLoad.Stop();

    // this fails if called directly in OnLoad
    // since the control didn't finish creating itself: 
    Application.AddMessageFilter( 
        new PropertyGridMessageFilter( 
            propertyGrid1.GetChildAtPoint( new Point(40,40) ),
        new MouseEventHandler( propGridView_MouseUp )) );
}

The filter looks for WM_?BUTTONUP messages and makes a call to a provided delegate:

public bool PreFilterMessage(ref Message m)
{
    if( ! this.Control.IsDisposed && m.HWnd == 
          this.Control.Handle && MouseUp != null)
    {
        MouseButtons mb = MouseButtons.None;
        
        switch( m.Msg )
        {
            case  0x0202 : /*WM_LBUTTONUP, see winuser.h*/
                mb = MouseButtons.Left;
                break;
            case  0x0205 : /*WM_RBUTTONUP*/
                mb = MouseButtons.Right;
                break;
        }

        if( mb != MouseButtons.None )
        {
            MouseEventArgs e = 
            new MouseEventArgs( mb, 1, m.LParam.ToInt32() & 0xFFff, 
                                m.LParam.ToInt32() >> 16, 0 );
        
            MouseUp( Control, e );
        }
    }
    return false;
}

When the form's method is called by the filter, I just get the propertyGrid1.SelectedGridItem.PropertyDescriptor and display the context menu containing the Reset and ChangeName options.

Here you can see the Reset option displaying the default value so the user has the new and the default value next to each other:

What if the user wants to rename the property itself

First, the program displays an on-site textbox for the user to alter the property name in:

/// <SUMMARY>
/// This is a special feature to allow renaming of the property itself
/// </SUMMARY>
private void menuItemChangeName_Click(object sender, System.EventArgs e)
{
    GenericPropertyDescriptor gpd = 
        propertyGrid1.SelectedGridItem.PropertyDescriptor 
        as GenericPropertyDescriptor;
    if( gpd != null )
    {
        TextBox t = new TextBox();

        t.Text = gpd.Property.PropertyName;
        // so we know what property is about 
        t.Tag = gpd;
        // to capture Enter & Escape 
        t.KeyUp += new KeyEventHandler(textbox_name_KeyUp);
        // to allow hidding of the textbox
        // by clicking somewhere else: 
        t.MouseUp += new MouseEventHandler(textbox_name_MouseUp); 
        // i want all the mouse messages
        // to be sent to the textbox 
        t.Capture = true;

        // placing the textbox in the form,
        // right under the mouse: 
        Point mp = MousePosition; mp.Offset( -3, -3 );
        t.Location = PointToClient( mp );
        Controls.Add( t );
        t.BringToFront();
        t.Focus();

        // clears the initial selection of the text 
        t.Select( t.Text.Length, 0 );
        
        // making the control obvious to the user: 
        t.BackColor = Color.Yellow;
        t.ForeColor = Color.Red;
    }
}

Once the textbox is on the screen, the content can be validated by pressing Enter, or discarded by pressing Escape:

private void textbox_name_KeyUp(object sender, KeyEventArgs e)
{
    switch( e.KeyData )
    {
        case Keys.Enter:
        {// keep the changes: 
            TextBox t = sender as TextBox;
            ( (GenericPropertyDescriptor) 
               t.Tag ).Property.PropertyName = t.Text != "" ? 
               t.Text : "must type something or" + 
               " the control will go berserk" ;

            RemoveTextBox( sender );

            // refresh the grid since it can't
            // possibly know we changed something: 
            propertyGrid1.Refresh(); 
        }break;

        case Keys.Escape:
        {// just "go home" 
            RemoveTextBox( sender );
        }break;
    }
}

Using the code

The properties are stored in a collection that implements ICustomTypeDescriptor (this has been explained in many articles, I'm not explaining it again here). This collection returns the custom properties when asked by the property grid (propertyGrid1.SelectedObject = properties;). Adding properties to this collection is quite easy:

properties = new GenericPropertyCollection_CustomTypeDescriptor();
properties.AddProperty( new GenericProperty( "Integer", 
                       (int) 1, "Custom", "Int32" ) );
properties.AddProperty( new GenericProperty( "Float disabled", 
                        4.5f, "Custom", "Single", 
                        new ReadOnlyAttributeEditor() ) );

Making one of the properties read only (disabled) is also easy, just tag-it with the ReadOnlyAttributeEditor.

The collection can be used as storage for the data, there is no need for a parallel structure. Accessing the data can be done like this:

foreach( GenericProperty gp in properties )
    MessageBox.Show( gp.Value.ToString() );

Points of Interest

Many things can be done by accessing the insides of the operating system or common controls. Platform Invoke and filtering of messages can be used to create new, helpful, and original effects.

I find interesting the on-site editing of the property name, using the small textbox that disappears when the user is done with it. It's something like the Undo control in Visual Studio that is placed over all the controls (toolbars, edit window).

History

• January 29^th, 2006 - first version.

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