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

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

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.

When setting multiple objects or a mix of objects, some of which implement the INotifyPropertyChanged interface changes in these objects should be reflected in the RadPropertyGrid.

The RadPropertyGrid implementation should be improved in a way that will allow users to override the methods that fire events like: OnEditorRequired, OnEditorInitialized, OnCustomGrouping etc.
Resolution:
1. Inherit from PropertyGridTableElement and override the method you want.
2. Inherit from PropertyGridSplitElement and override the CreateTableElement() return your class from 1.
3. Inherit from PropertyGridElement and override the CreateSplitElement() return your class from 2.
4. Inherit from RadPropertyGrid and override the CreatePropertyGridElement() return your class from 3.

RadPropertyGrid should not invalidate the properties when the help bar is resized.

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.

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

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.

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
 - 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, 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 the TypeConverter of a property cannot convert from string the text box editor that opens for this property should be read only.

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

To reproduce: subscribe to the RadPropertyGrid.PropertyValidating event and apply ErrorMessage in some cases. If the validation fails, the error indicator is not visible in Windows8, VisualStudio2012Dark, Aqua. However, the error message is displayed as expected.

Workaround: assign an image for the ErrorIndicator

private void radPropertyGrid1_ItemFormatting(object sender, PropertyGridItemFormattingEventArgs e)
{
    PropertyGridItemElement itemElement = e.VisualElement as PropertyGridItemElement;
    if (itemElement != null)
    {
        ((PropertyGridTextElement)itemElement.TextElement).ErrorIndicator.Image = Properties.Resources.error;
    }
}

To reproduce:

PropertyStoreItem prop1 = new PropertyStoreItem(typeof(DateTime), "Date", DateTime.Now);
PropertyStoreItem prop2 = new PropertyStoreItem(typeof(Nullable<DateTime>), "NullableDate", DateTime.Now);
PropertyStoreItem prop3 = new PropertyStoreItem(typeof(DateTime?), "Date?", DateTime.Now);

RadPropertyStore store = new RadPropertyStore();
store.Add(prop1);
store.Add(prop2);
store.Add(prop3); 
this.radPropertyGrid1.SelectedObject = store;

Open the editor for one of the properties and press the Clear button in the PropertyGridDateTimeEditor's popup. The value is cleared, but the PropertyValueButtonElement is not displayed.

Workaround: specify the initial value as default value for the property:

public Form1()
{
    InitializeComponent();

    DateTime initialValue = DateTime.Now;
    PropertyStoreItem prop1 = new PropertyStoreItem(typeof(DateTime), "Date", initialValue);
    prop1.Attributes.Add(new DefaultValueAttribute(initialValue));
    PropertyStoreItem prop2 = new PropertyStoreItem(typeof(Nullable<DateTime>), "NullableDate", initialValue);
    prop2.Attributes.Add(new DefaultValueAttribute(initialValue));
    PropertyStoreItem prop3 = new PropertyStoreItem(typeof(DateTime?), "Date?", initialValue);
    prop3.Attributes.Add(new DefaultValueAttribute(initialValue));
    
    RadPropertyStore store = new RadPropertyStore();
    store.Add(prop1);
    store.Add(prop2);
    store.Add(prop3); 
    this.radPropertyGrid1.SelectedObject = store;
     
}

Use attached to reproduce. 

Workaround
radPropertyGrid1.ItemSpacing = 1;

To reproduce:

            this.radPropertyGrid1.SelectedObject = this;             
            this.radPropertyGrid1.PropertyGridElement.SplitElement.HelpElement.MinSize = new Size(0, 60);

Please refer to the attached gif file.

Workaround:

            this.radPropertyGrid1.SelectedObject = this;             
            this.radPropertyGrid1.PropertyGridElement.SplitElement.HelpElement.MinSize = new Size(0, 60);
            this.radPropertyGrid1.PropertyGridElement.SplitElement.HelpElement.HelpTitleElement.MinSize = new Size(0,20);

            this.radPropertyGrid1.PropertyGridElement.SplitElement.HelpElement.HelpTitleElement.PropertyChanged += HelpTitleElement_PropertyChanged;

        private void HelpTitleElement_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == "Bounds")
            {
                if (this.radPropertyGrid1.PropertyGridElement.SplitElement.HelpElement.HelpContentElement.Location.Y != 20)
                {
                    this.radPropertyGrid1.PropertyGridElement.SplitElement.HelpElement.HelpContentElement.Location = new Point(0, 20);
                }
            }
        }

Note: the description element may be floating but it doesn't overlap the title.