If one sets an empty RadPropertyStore to the SelectedObject property of a RadPropertyGrid and then adds items with a RadSortOrder attribute the items will still be sorted by their name.



WORKAROUNDS:

1. Populate the store before you set it to the property grid.

2. Add a dummy item to the store before you set it to the property grid and then remove it:
RadPropertyStore store = new RadPropertyStore();
store.Add(typeof(bool), "dummy", false);
this.radPropertyGrid1.SelectedObject = store;
store.RemoveAt(0);

3. After you add the first item to the store call the following method:
this.radPropertyGrid1.PropertyGridElement.PropertyTableElement.ListSource.CollectionView.EnsureDescriptors();

To reproduce:
1. Add a RadPropertyGrid and a RadButton.
2. Create custom PropertyGridItemElement with custom PropertyGridValueElement in order to display permanently RadDropDownListElement
3. Use the following code snippet:

public Form1()
{
    InitializeComponent();

    this.radPropertyGrid1.CreateItemElement += radPropertyGrid1_CreateItemElement;
    this.radPropertyGrid1.Editing += radPropertyGrid1_Editing;
}

private void radPropertyGrid1_Editing(object sender,
    PropertyGridItemEditingEventArgs e)
{
    if (e.Item.Name == "Direction")
    {
        e.Cancel = true;
    }
}

private void radPropertyGrid1_CreateItemElement(object sender,
    CreatePropertyGridItemElementEventArgs e)
{
    PropertyGridItem item = (PropertyGridItem)e.Item;
    if (e.Item.Name == "Direction")
    {
        e.ItemElementType = typeof(CustomItemElement);
    }
}

public class CustomItemElement : PropertyGridItemElement
{
    protected override PropertyGridValueElement CreatePropertyGridValueElement()
    {
        return new CustomPropertyGridValueElement();
    }

    protected override Type ThemeEffectiveType
    {
        get
        {
            return typeof(PropertyGridItemElement);
        }
    }
}

public class CustomPropertyGridValueElement : PropertyGridValueElement
{
    RadDropDownListElement dropdown;

    protected override void CreateChildElements()
    {
        base.CreateChildElements();
 
        dropdown = new RadDropDownListElement();
        dropdown.DropDownStyle = Telerik.WinControls.RadDropDownStyle.DropDownList;
        this.Children.Add(dropdown);

        dropdown.DataSource = Enum.GetValues(typeof(Direction));
        dropdown.SelectedIndexChanged += dropdown_SelectedIndexChanged;
    }

    private void dropdown_SelectedIndexChanged(object sender,
        Telerik.WinControls.UI.Data.PositionChangedEventArgs e)
    {
        RadDropDownListElement ddle = sender as RadDropDownListElement;
        if (ddle != null && e.Position > -1)
        {
            PropertyGridItem item = this.VisualItem.Data as PropertyGridItem;
            if (item != null)
            {
                item.Value = ddle.Items[e.Position].DataBoundItem;
            }
        }
    }

    public override void Synchronize()
    {
        PropertyGridItem item = this.VisualItem.Data as PropertyGridItem;
        dropdown.SelectedValue = item.Value;
    }
}

public class Item
{
    public int Id { get; set; }

    public Direction Direction { get; set; }

    public string Title { get; set; }

    public Item(int id, string title, Direction direction)
    {
        this.Id = id;
        this.Title = title;
        this.Direction = direction;
    }
}

public enum Direction
{
    Up,
    Down,
    Left,
    Right
}

private void radButton1_Click(object sender, EventArgs e)
{
    this.radPropertyGrid1.SelectedObject = new Item(123, "Title", Direction.Left);
}

When you click the button once, the RadPropertyGrid displays the desired data. However, if you click the button once again, ArgumentOutOfRangeException occurs.

Workaround:wrap setting the SelectedObject in a SuspendLayout/ResumeLayout block:

this.radPropertyGrid1.SuspendLayout();
this.radPropertyGrid1.SelectedObject = new Item(123, "Title", Direction.Left);
this.radPropertyGrid1.ResumeLayout();

The RadPropertyGrid columns should be able to auto resize according to their cells content.

When the SelectedObject contains sub-properties and a user expands a property the CreateItem event is not fired for sub items.

When a property has a TypeConverter and a UITypeEditor attributes the PropertyGridUITypeEditor calls the TypeConverter methods with the context parameter equal to null.

To reproduce: use a class with more than 100 properties for the RadPropertyGrid.SelectedObject. On RadButton.Click event set the RradPropertyGrid.PropertySort to PropertySort.CategorizedAlphabetical.

To reproduce:
1. Add a RadPropertyGrid and use the following code:


public partial class NewTestWindow : Form
{
    public NewTestWindow()
    {
        InitializeComponent();


        PropertyGridData data = new PropertyGridData();
        (data as INotifyPropertyChanged).PropertyChanged += NewTestWindow_PropertyChanged;


        ppgItems.SelectedObject = data;


        Type type = ppgItems.SelectedObject.GetType();
        MemberInfo[] members = type.GetMembers();
        foreach (MemberInfo m in members)
        {
            Attribute[] attributes = Attribute.GetCustomAttributes(m);
            foreach (Attribute attr in attributes)
            {
                if (attr is BrowsableCondition)
                {
                    BrowsableCondition condition = attr as BrowsableCondition;
                    PropertyGridItem gridItem = ppgItems.Items[m.Name];


                    gridItem.Visible = false;
                }
            }
        }
    }


    private void NewTestWindow_PropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        if (ppgItems.SelectedObject != null)
        {
            PropertyInfo enableProperty = ppgItems.SelectedObject.GetType().GetProperty(e.PropertyName);
            bool? value = enableProperty.GetValue(ppgItems.SelectedObject, null) as bool?;


            if (value.HasValue)
            {
                Type type = ppgItems.SelectedObject.GetType();
                MemberInfo[] members = type.GetMembers();
                foreach (MemberInfo m in members)
                {
                    Attribute[] attributes = Attribute.GetCustomAttributes(m);
                    foreach (Attribute attr in attributes)
                    {
                        if (attr is BrowsableCondition)
                        {
                            BrowsableCondition condition = attr as BrowsableCondition;
                            PropertyGridItem gridItem = ppgItems.Items[m.Name];


                            gridItem.Visible = value.Value;
                        }
                    }
                }
            }
        }


        ppgItems.PropertyGridElement.PropertyTableElement.Update(PropertyGridTableElement.UpdateActions.Resume);
    }
}


public class PropertyGridData : INotifyPropertyChanged
{
    public string Item { get; set; }


    [Browsable(true)]
    [BrowsableCondition("Enable")]
    public bool A0 { get; set; }


    [Browsable(true)]
    [BrowsableCondition("Enable")]
    public bool A1 { get; set; }


    [Browsable(true)]
    [BrowsableCondition("Enable")]
    public bool A2 { get; set; }


    [Browsable(true)]
    [BrowsableCondition("Enable")]
    public bool A3 { get; set; }


    [Browsable(true)]
    [BrowsableCondition("Enable")]
    public bool A4 { get; set; }


    [Browsable(true)]
    [BrowsableCondition("Enable")]
    public bool A5 { get; set; }


    public string Anything { get; set; }


    private bool _enable;


    public bool Enable
    {
        get
        {
            return _enable;
        }


        set
        {
            _enable = value;
            RaisePropertyChanged("Enable");
        }
    }


    public event PropertyChangedEventHandler PropertyChanged;


    public void RaisePropertyChanged(string propertyName)
    {
        if (this.PropertyChanged != null)
            this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}


public class BrowsableCondition : Attribute
{
    public BrowsableCondition(string propertyName)
    {
        this.PropertyName = propertyName;
    }


    public string PropertyName { get; set; }
}


2. Run the application. The RadPropertyGrid has a checkbox with Enable property.
When selected, other properties are displayed (A0, A1, A2, A3, A4, A5). When the user marks some of these checkboxes that were hidden and then uncheck the Enable property, the PropertyGridItemElement component throws a System.NullReferenceException. 

To reproduce: -add a RadPropertyGrid and use the following code: radPropertyGrid.SelectedObject = new MyPropertyGridAdapter(node); PropertyValueChanging += new PropertyGridItemValueChangingEventHandler(OnPropertyValueChanging); private void OnPropertyValueChanging(object sender, PropertyGridItemValueChangingEventArgs e) { var form = new CommentActionForm(); if (form.ShowDialog() == System.Windows.Forms.DialogResult.OK) { var item = e.Item as PropertyGridItem; var pd = item.PropertyDescriptor as MyPropertyDescriptor; if (pd != null) { // Perform value change (affects database). } } else { e.Cancel = true; } } Workaround:when ending edit mode with Enter key you may use the following approach: public Form1() { InitializeComponent(); this.radPropertyGrid1.SelectedObject = new MyObject(10204, "Sample name", "Some descripion"); this.radPropertyGrid1.EditorRequired += radPropertyGrid1_EditorRequired; } private void radPropertyGrid1_EditorRequired(object sender, PropertyGridEditorRequiredEventArgs e) { PropertyGridItem propertyItem = e.Item as PropertyGridItem; e.Editor = new MyEditor(propertyItem); } public class MyObject { public int ID { get; set; } public string Name { get; set; } public string Description { get; set; } public MyObject(int iD, string name, string description) { this.ID = iD; this.Name = name; this.Description = description; } } public class MyEditor : PropertyGridTextBoxEditor { public string InitialValue { get; set; } public PropertyGridItem PropertyItem { get; set; } public MyEditor(PropertyGridItem item) : base() { this.PropertyItem = item; } public override void BeginEdit() { InitialValue = this.TextBoxEditorElement.Text; base.BeginEdit(); } } public class MyPropertyGrid : RadPropertyGrid { protected override bool ProcessDialogKey(Keys keyData) { if (this.ActiveEditor != null && this.ActiveEditor is MyEditor && keyData == Keys.Enter) { MyEditor editor = ((MyEditor)this.ActiveEditor); PropertyGridItem property = editor.PropertyItem; string initialValue = editor.InitialValue; DialogResult ds = RadMessageBox.Show("Are you sure?", "Title", MessageBoxButtons.OKCancel, RadMessageIcon.Question); if (ds == System.Windows.Forms.DialogResult.Cancel) { property.Value = initialValue; return false; } } return base.ProcessDialogKey(keyData); } }

RadPropertyGrid - when default value attribute is Color.Empty, the items is styled with bold font and "Modified" icon. 

Workaround: Use ItemFormatting event to style the item correctly. Code to reproduce: public class TestObj { private Color someColor; public TestObj() { this.someColor = Color.Empty; } [DefaultValue(typeof(Color), "Empty")] public Color SomeColor { get { return someColor; } set { someColor = value; } } } TestObj newObj = new TestObj(); this.radPropertyGrid1.SelectedObject = newObj; 

To reproduce:

Follow this article http://www.telerik.com/help/winforms/propertygrid-features-custom-grouping.html . You will notice that the CustomGrouping event will not fire.

Add the ability for custom sorting in the RadPropertyGrid.

To reproduce:
- Create a property store and add some items to it.
- Start the project and click an item.

Workaround: - 
Add RadSortOrderAttribute to each item:

for (int i = 0; i < propStore.Count; i++)
                {
                    PropertyStoreItem item = propStore[i];
                    item.Attributes.Add(new RadSortOrderAttribute(i));
                }

Steps to reproduce:

1. Create a class A with a boolean property
2. Create a class B with a property of type A and decorate it with [ReadOnly(true)] attribute
3. Set an instance of class B as the SelectedObject of a RadPropertyGrid
4. Try to change the boolean property. You will see you cannot.

When the TypeConverter of a property cannot convert from string the text box editor that opens for this property should be read only.

If the number of sub items for a property depends on the value of the properties and this value is changed the sub items are not invalidated in all cases.

Extend the sorting functionality in order to support custom sort order.

To reproduce:
- Click on a property (with a dropdown editor for example) to start edit.
- Move mouse over vertical center dividing line to get mouse to transition to resize pointer.
- Move mouse to the right back over the combo box that has been activated for edit.
- The mouse pointer will not transition back to the arrow, it will stay on the resize pointer.

To reproduce, use the following class:
public class NullableDummy
{
    public bool? Bool { get; set; }
    public byte? Byte { get; set; }
    public char? Char { get; set; }
    public decimal? Decimal { get; set; }
    public float? Float { get; set; }
    public int? Int { get; set; }
    public long? Long { get; set; }
    public sbyte? Sbyte { get; set; }
    public short? Short { get; set; }
    public string String { get; set; }
    public ulong? Ulong { get; set; }
    public ushort? Ushort{ get; set; }
}

And set it as a selected object of the property grid:
NullableDummy dummy = new NullableDummy();
this.propertyGrid.SelectedObject = dummy;

Change the Byte Property you will see that the value is not being set.

Steps to reproduce: 
1. Add a RadPropertyGrid to a form 
2. Set the SelectedObject property to an object with numeric property 
3. Open the numeric property for edit and click the arrow buttons to change the value.
4. Click on another control that can take focus e.g. the form control box buttons You will see that the editor remains open.