To reproduce:

public Form1()
{
    InitializeComponent();

    this.radPropertyGrid1.SelectedObject = new Item(123, "SampleName");
}

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

    public Item(int id, string name)
    {
        this.Id = id;
        this.Name = name;
    }
}

Activate the editor for the "Id" property and click the up arrow of the PropertyGridSpinEditor. Then click on the text box.

Workaround:

private void radPropertyGrid1_EditorInitialized(object sender, PropertyGridItemEditorInitializedEventArgs e)
{
    PropertyGridSpinEditor spinEditor = e.Editor as PropertyGridSpinEditor ;
    if (spinEditor != null)
    {
        BaseSpinEditorElement spinEditorElement = spinEditor.EditorElement as BaseSpinEditorElement;
        var eventInfo = spinEditorElement.TextBoxItem.HostedControl.GetType().GetEvent("MouseEnter");
        var methodInfo = spinEditorElement.TextBoxItem.GetType().GetMethod("TextBoxControl_MouseEnter",
            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
        Delegate handler = Delegate.CreateDelegate(typeof(EventHandler), spinEditorElement.TextBoxItem, methodInfo);
        eventInfo.RemoveEventHandler(spinEditorElement.TextBoxItem.HostedControl, handler);

        var eventInfo2 = spinEditorElement.TextBoxItem.HostedControl.GetType().GetEvent("MouseLeave");
        var methodInfo2 = spinEditorElement.TextBoxItem.GetType().GetMethod("textBoxItem_MouseLeave",
            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
        Delegate handler2 = Delegate.CreateDelegate(typeof(EventHandler), spinEditorElement.TextBoxItem, methodInfo2);
        eventInfo2.RemoveEventHandler(spinEditorElement.TextBoxItem.HostedControl, handler2);
    }
}

To reproduce: use the following code:

Items _items = new Items();

public Form1()
{
    InitializeComponent(); 

    radPropertyGrid1.SelectedObject = _items;
}

class Items
{
    [Description("A Bool Property")]
    public bool IsEnabled
    {
        get
        {
            return _isEnabled;
        }
        set
        {
            _isEnabled = value;
            RadMessageBox.Show("IsEnabled");
        }
    }
    private bool _isEnabled;

    [Description("A String Property")]
    public string Name
    {
        get { return _name; }
        set
        {
            _name = value;
            RadMessageBox.Show("Name");
        }
    }
    private string _name ;

}

Steps to perform:
1. Change the "Name" property and leave the editor active.
2. Click on the check box to change the "IsEnabled" property.

As a result you will notice that the "IsEnabled" setter is called before the "Name" setter.

Workaround:

Items _items = new Items();

public Form1()
{
    InitializeComponent(); 

    this.radPropertyGrid1.CreateItemElement += radPropertyGrid1_CreateItemElement;        
    radPropertyGrid1.SelectedObject = _items;
}

private void radPropertyGrid1_CreateItemElement(object sender, CreatePropertyGridItemElementEventArgs e)
{
    if (e.ItemElementType == typeof(PropertyGridCheckBoxItemElement))
    {
        e.ItemElementType = typeof(CustomPropertyGridCheckBoxItemElement);
    }
}

public class CustomPropertyGridCheckBoxItemElement : PropertyGridCheckBoxItemElement
{
    public CustomPropertyGridCheckBoxItemElement()
    {
        this.CheckBoxElement.ToggleStateChanging += CheckBoxElement_ToggleStateChanging;
    }

    private void CheckBoxElement_ToggleStateChanging(object sender, StateChangingEventArgs args)
    {
        if (this.PropertyTableElement.ActiveEditor != null && this.PropertyTableElement.SelectedGridItem != this.Data)
        {
            this.PropertyTableElement.EndEdit();
        }
    }

    protected override void DisposeManagedResources()
    {
        this.CheckBoxElement.ToggleStateChanging -= CheckBoxElement_ToggleStateChanging;

        base.DisposeManagedResources();
    }
}

Here is the code that should be used for custom sub-properties

private void OnCreateItem(object sender, CreatePropertyGridItemEventArgs e)
{
    e.Item = new MyPropertyGridItem((PropertyGridTableElement)sender, e.Parent);
}

As visual studio would be happy of you only provide a constructor with one argument when you inherit from PropertyGridItem you have no way of knowing that you need a second one where the parent should be the second argument.

The proper way to handle this would be to set the parent internally.

To reproduce:
- Add a property grid to a blank form set the selected object the the same form.
- Group the items and click several times to expand collapse the groups or items.
- you will notice that some of expanded/collapsed groups icon is in wrong state (same applies for the +/- sign of the properties).

To reproduce:
- Add 20 document windows that contain property grid to a dock (use RadTextBox for he grid's selected object).
- Close and dispose the windows.
- The memory is not properly released.

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();

To reproduce:

Set the following object as selected of RadPropertyGrid: 

class TestClass : System.ComponentModel.INotifyPropertyChanged
{
    private string loggingType = "0";

    [TypeConverter(typeof(CustomListConverter)), CategoryAttribute("Logging Settings")]
    public string LoggingType
    {
        get { return loggingType; }
        set
        {
            loggingType = value;
            OnPropertyChanged("LoggingType");
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;

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

}

And use the following converter:

public class CustomListConverter : System.ComponentModel.StringConverter
{
    ArrayList _AllStringValues = new ArrayList();
    Hashtable _Map = new Hashtable();

    public CustomListConverter()
    {
    }

    public override System.ComponentModel.TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext conte
    {
        FillValuesFromContext();
        StandardValuesCollection standardValues = new StandardValuesCollection(_AllStringValues);
        return standardValues;
    }

    private void FillValuesFromContext()
    {
        if (_AllStringValues.Count > 0)
            return;

        _AllStringValues.Clear();
        _Map.Clear();

        string str = "-5,Fatal|-4,Error|-3,Warning|-2, Info|-1,Debug|0,Trace";

        string[] strMapVals = str.Split('|');
        for (int i = 0; i < strMapVals.Length; i++)
        {
            string[] strVals = strMapVals[i].Split(',');
            if (strVals.Length != 2)
                continue;

            _AllStringValues.Add(strVals[0].Trim());
            _Map.Add(strVals[0].Trim(), strVals[1].Trim());
        }
    }

    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
    {
        FillValuesFromContext();

        string displayString = "";

        IEnumerator enumTable = _Map.Keys.GetEnumerator();

        while (enumTable.MoveNext())
        {
            if (_Map[enumTable.Current] as string == value as string)
            {
                displayString = enumTable.Current as string;
                break;
            }
        }

        return displayString;
    }

    public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
    {
        FillValuesFromContext();

        if (null != value && _Map.ContainsKey(value.ToString()))
        {
            return _Map[value];
        }

        return value;
    }

    public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
    {
        return true;
    }

    public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
    {
        return true;
    }
}

When you start the application you will see that the value of the property is set to -1, while it should be converted to 'Debug'

Workaround:

Create a custom PropertyGridItem:

public class MyPropertyGridItem : PropertyGridItem
{
    public MyPropertyGridItem(PropertyGridTableElement element)
        : base(element)
    {
    }

    public override string FormattedValue
    {
        get
        {
            string baseFormattedValue =  base.FormattedValue;
            TypeConverter converter = TypeConverter;

            if (converter != null && converter.CanConvertTo(this, typeof(string)))
            {
                baseFormattedValue = converter.ConvertToString(this, System.Threading.Thread.CurrentThread.CurrentCulture, this.Value);
            }

            return baseFormattedValue;
        }
        set
        {
            base.FormattedValue = value;
        }
    }
}

Use it by subscribing to the CreateItem event:

void radPropertyGrid1_CreateItem(object sender, Telerik.WinControls.UI.CreatePropertyGridItemEventArgs e)
{
    e.Item = new MyPropertyGridItem(this.radPropertyGrid1.PropertyGridElement.PropertyTableElement);
}

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.

Workaround: 

  class MyRadPropertyGrid : RadPropertyGrid
    {
        protected override void WndProc(ref Message m)
        {
            switch (m.Msg)
            {
                case 0x7b:
                    Point point;
                    int x = Telerik.WinControls.NativeMethods.Util.SignedLOWORD(m.LParam);
                    int y = Telerik.WinControls.NativeMethods.Util.SignedHIWORD(m.LParam);
                    if (((int)((long)m.LParam)) == -1)
                    {
                        point = new Point(this.Width / 2, this.Height / 2);
                    }
                    else
                    {
                        point = this.PointToClient(new Point(x, y));
                    }

                    this.PropertyGridElement.PropertyTableElement.ProcessContextMenu(point);
                    return;
            }

            base.WndProc(ref m);
        }
    }

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

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

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 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. 

Workaround:
 Private Sub RadPropertyGrid1_EditorRequired(sender As Object, e As PropertyGridEditorRequiredEventArgs) Handles RadPropertyGrid1.EditorRequired
     Dim te As PropertyGridTableElement = TryCast(sender, PropertyGridTableElement)
     If e.EditorType = GetType(PropertyGridSpinEditor) Then
         Dim editor As New CustomPropertyGridSpinEditor
         If editor IsNot Nothing AndAlso te IsNot Nothing Then
             Dim type As Type = RadPropertyGrid1.SelectedObject.[GetType]().GetProperty(e.Item.Name).PropertyType
             If type = GetType(System.Double) Then
                 DirectCast(editor.EditorElement, BaseSpinEditorElement).DecimalPlaces = 4
                 e.Editor = editor
             End If
         End If
     End If
 End Sub

 Public Class CustomPropertyGridSpinEditor
     Inherits PropertyGridSpinEditor
     Public Overrides Sub Initialize(owner As Object, value As Object)
         Dim decimalPlaces As Integer = Me.DecimalPlaces
         MyBase.Initialize(owner, value)

         Dim element As PropertyGridItemElement = TryCast(owner, PropertyGridItemElement)
         Dim item As PropertyGridItem = TryCast(element.Data, PropertyGridItem)
         Dim editedType As Type = item.PropertyType

        If ((editedType = GetType(Decimal) OrElse editedType = GetType(Double) OrElse editedType = GetType(Single)) AndAlso decimalPlaces <> 0) Then
         DirectCast(Me.EditorElement, BaseSpinEditorElement).DecimalPlaces = decimalPlaces
         Me.Value = value
       End If
     End Sub
 End Class

To reproduce:

Add a RadPropertyGrid to a form.  Use the following code:

this.radPropertyGrid1.SortOrder = System.Windows.Forms.SortOrder.Ascending;
this.radPropertyGrid1.PropertySort = System.Windows.Forms.PropertySort.Categorized;

As a workaround you can manually scroll to the top before performing a filtering operation:

public class MyPropertyGrid : RadPropertyGrid
{
    protected override PropertyGridElement CreatePropertyGridElement()
    {
        return new MyPropertyGridElement();
    }
}
 
public class MyPropertyGridElement : PropertyGridElement
{
    protected override PropertyGridToolbarElement CreateToolbarElement()
    {
        return new MyPropertyGridToolbarElement();
    }
 
    protected override Type ThemeEffectiveType
    {
        get
        {
            return typeof(PropertyGridElement);
        }
    }
}
 
public class MyPropertyGridToolbarElement : PropertyGridToolbarElement
{
    protected override void ExecuteSearch()
    {
        this.PropertyGridElement.PropertyTableElement.Scroller.Scrollbar.Value = 0;
        base.ExecuteSearch();
    }
}

To reproduce:
Open VisualStyleBuilder and navigate to RadGanttView -> RadGanttViewElement and try to edit the Value of the BackgroundImageLayout and ImageLayout properties.


Workaround:
Edit the value manually, as a string

Add a RadPropertyGrid and change its Dock property to Fill. Use the following code:

public partial class Form1 : Form
{
    RadPropertyStore _store;

    public Form1()
    {
        InitializeComponent();
        this.radPropertyGrid1.CreateItemElement += new CreatePropertyGridItemElementEventHandler(this.onCreateItemElement);
        _store = new RadPropertyStore();

        PropertyStoreItem barItem = new PropertyStoreItem(typeof(Int32), "TrackBar", 25);
        _store.Add(barItem);

        PropertyStoreItem sec = new PropertyStoreItem(typeof(bool), "Checkr", true);
        _store.Add(sec);

        this.radPropertyGrid1.SelectedObject = _store;
    }

    private void onCreateItemElement(object sender, CreatePropertyGridItemElementEventArgs e)
    {
        PropertyGridItem item = e.Item as PropertyGridItem;

        if (item != null)
        {
            if (item.Name == "TrackBar")
            {
                e.ItemElementType = typeof(TrackBarPropertyGridItem);
            }
        }
    }
}

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

public class CustomPropertyGridValueElement : PropertyGridValueElement
{
    RadTrackBarElement _trackbar;

    public RadTrackBarElement Trackbar
    {
        get
        {
            return this._trackbar;
        }
    }

    protected override void CreateChildElements()
    {
        base.CreateChildElements();

        _trackbar = new RadTrackBarElement();
        _trackbar.Minimum = 0;
        _trackbar.Maximum = 100;
       
        this.DrawText = false;
        this.Children.Add(_trackbar);
    }
}



When resizing the form, the applications hangs.

Workaround:

/// <summary>
    /// Track bar property grid element
    /// </summary>
    public class TrackBarPropertyGridItem : PropertyGridItemElement
    {
        class MyTrackBarElement : RadTrackBarElement
        {
            protected override void OnNotifyPropertyChanged(string propertyName)
            {
                if (propertyName == "TickOffSet" || propertyName == "ThumbSize")
                {
                    this.BodyElement.ScaleContainerElement.InvalidateMeasure();
                    this.BodyElement.IndicatorContainerElement.InvalidateMeasure();
                    return;
                }

                base.OnNotifyPropertyChanged(propertyName);
            }

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

        /// <summary>
        /// The trackbar element to be displayed in the cell
        /// </summary>
        private RadTrackBarElement _trackbar;

        /// <summary>
        /// Accessor to the track bar element
        /// </summary>
        public RadTrackBarElement Trackbar
        {
            get { return _trackbar; }
        }

        /// <summary>
        /// Create child elements of the propertyGridItem
        /// </summary>
        protected override void CreateChildElements()
        {
            base.CreateChildElements();

            _trackbar = new MyTrackBarElement();
            _trackbar.Minimum = 0;
            _trackbar.Maximum = 100;
            _trackbar.ShowTicks = false;


            this.ValueElement.DrawText = false;
            this.ValueElement.Children.Add(this._trackbar);
        }

        /// <summary>
        /// Synchronise the value with property grid item
        /// </summary>
        public override void Synchronize()
        {
            base.Synchronize();

            PropertyGridItem item = this.Data as PropertyGridItem;

            this._trackbar.Value = (int)item.Value;
        }


        /// <summary>
        /// Add editor override
        /// </summary>
        /// <param name="editor">input editor</param>
        public override void AddEditor(IInputEditor editor)
        { }

        /// <summary>
        /// Remove editor override
        /// </summary>
        /// <param name="editor">input editor</param>
        public override void RemoveEditor(IInputEditor editor)
        { }

        /// <summary>
        /// Check if the item is comptable with trackbar editor
        /// </summary>
        /// <param name="data">item to check</param>
        /// <param name="context">context</param>
        /// <returns>true if compatible, false otherwise</returns>
        public override bool IsCompatible(PropertyGridItemBase data, object context)
        {
            PropertyGridItem item = data as PropertyGridItem;
            return (item != null && item.PropertyType == typeof(int));
        }

        /// <summary>
        /// Get the type of the property grid element
        /// </summary>
        protected override Type ThemeEffectiveType
        {
            get { return typeof(PropertyGridItemElement); }
        }