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

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.

Pressing Ctrl + Enter should create a new row in the editor instead of closing it.

WORKAROUND:
Replace the default editor with the following one in the EditorRequired event:

 class MyPropertyGridTextBoxEditor : PropertyGridTextBoxEditor
    {
        protected override void OnKeyDown(System.Windows.Forms.KeyEventArgs e)
        {
            if (e.Modifiers == System.Windows.Forms.Keys.Control && e.KeyCode == System.Windows.Forms.Keys.Enter)
            {
                return;
            }

            base.OnKeyDown(e);
        }
    }

To reproduce
 - create a form with a RadPropertyGrid.
 - set ToolbarVisible to true
 - add some properties, but not enough to cause the scrollbar to appear.
 - start and click on the sort button: the sort is changed, but the scroll bar became visible even if it is not needed.
Workaround:
public class MyPropGrid : RadPropertyGrid
{
    protected override PropertyGridElement CreatePropertyGridElement()
    {
        return new MyPropGridElement();
    }

    public override string ThemeClassName
    {
        get { return typeof(RadPropertyGrid).FullName; }
        set { }
    }
}

public class MyPropGridElement : PropertyGridElement
{
    protected override PropertyGridSplitElement CreateSplitElement()
    {
        return new MyPropGridSplitElement();
    }

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

public class MyPropGridSplitElement : PropertyGridSplitElement
{ 
    protected override PropertyGridTableElement CreateTableElement()
    {
        return new MyPropGridTableElemnet();
    }

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

public class MyPropGridTableElemnet : PropertyGridTableElement
{
    protected override void UpdateScrollers(UpdateActions updateAction)
    {
        this.Scroller.UpdateScrollRange();
    }

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

To reproduce:
List<PropertyStoreItem> propertyStoreItems = new List<PropertyStoreItem>();
propertyStoreItems.Add(modelItem);
RadPropertyStore store = new RadPropertyStore();
store.AddRange(propertyStoreItems);
Workaround:
Iterate the collection and use the Add method
foreach (var item in propertyStoreItems)
{
    store.Add(item);
}

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.

When you change the CurrentUICulture the string "(none)" in the PropertyGridItemElement is localized but when you open the editor, the text is still "(none)".

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

To reproduce:
- Create a PropertyGrid and initialize it like this:
PropertyStoreItem checkboxItem = new PropertyStoreItem(typeof(bool), "Checkbox", true);
_store = new RadPropertyStore();
_store.Add(checkboxItem);
this.radPropertyGrid1.SelectedObject = _store;

-change the store item first to null then to false

Workaround:
-Before you set the item value to false set it to true first like this:
item.Value = null;

//set first to true then to false
item.Value = true;
item.Value = false;

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; 

When editing a DateTime? property the property grid shows a text box editor instead of calendar.

RadPropertyGrid calls the TypeConverter methods GetStandardValuesSupported and GetStandardValues passing null as parameter when it should pass the property item.
Code to reproduce:

this.radPropertyGrid1.SelectedObject = new SomeClass();

public class SomeClass
{
    [TypeConverter(typeof(CustomValueConverter))]
    public string CustomValue
    {
        get;
        set;
    }
}

public class CustomValueConverter : TypeConverter    
{
    public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
    {
        return true;
    }

    public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
    {
        return base.GetStandardValues(context);
    }
}

In some cases when the selected object is changed while a bool property is selected an InvalidCastExceptions is thrown.
Check ticket for reproduction steps and project.

Currently when one filters properties through the Search bar they are filtered based on their Name instead of the display name or label.

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.

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.