FIX. RadDropDownList- when the form is started the textbox shows the end of the text instead of the begging of it, when the used text is longer than the control length.

A nice addition to our RadTextBox will be the ability to add an autocomplete mode supporting multiple choinces, just like in the "To" textbox in Outlook.

One should be able to pick and type only the time portion of a datetime value.

Add a new wrapping mode that breaks the text per whole words

RadDateTimePicker should be able to parse custom predefined strings coverting them to a valid datetime value. The feature should be similar to the feature of the Telerik Extentions for ASP.NET MVC: http://demos.telerik.com/aspnet-mvc-beta/datepicker/dateparsing?theme=sunset 

Improve the RadTextBoxControl to allow different text alignment as Microsoft TextBox.

Add functionality to be able to pick up the time together with the date and to pick the time only.

One should be able to show a desired time range i.e. from 8 am to 6 pm

Hide or disable the dates that are not pick-able (for example greater than max date) in drop-down calendar.

Description: When binding to a null value, the RadSpinEditor throws an exception. This missing functionality is also noticed with the standard Windows Numeric Up Down control.

How to reproduce:
- add a RadSpinEditor and two RadButtons;
- use the following code:

public partial class Form1 : Form
{
    private BindingSource _bindActiveObject = new BindingSource { DataSource = typeof(MyBindingObject) };

    public Form1()
    {
        InitializeComponent();

        this.radSpinEditor1.DataBindings.Add(new Binding("Value", _bindActiveObject, "MyValue"));
    }

    private void radButton1_Click(object sender, EventArgs e)
    {
        _bindActiveObject.DataSource = new MyBindingObject { MyValue = Convert.ToDouble(100) };
    }

    private void radButton2_Click(object sender, EventArgs e)
    {
        _bindActiveObject.DataSource = new MyBindingObject { MyValue = null };
    }
}

public class MyBindingObject
{
    private decimal? _myValue;

    public decimal? MyValue
    {
        get
        {
            return _myValue;
        }
        set
        {
            _myValue = value;
        }
    }
}

Workaround:

Use the following custom RadSpinEditor:

private BindingSource _bindActiveObject = new BindingSource { DataSource = typeof(MyBindingObject) };

public Form1()
{
    InitializeComponent();
    this.radSpinEditor1.NullableValueChanged += Form1_NullableValueChanged;
    this.radSpinEditor1.DecimalPlaces = 2;
    this.radSpinEditor1.DataBindings.Add(new Binding("NullableValue", _bindActiveObject,
        "MyValue", true, DataSourceUpdateMode.OnPropertyChanged));
}

private void Form1_NullableValueChanged(object sender, EventArgs e)
{
    Console.WriteLine("NullableValue = " + this.radSpinEditor1.NullableValue + "");
}

private void radButton1_Click(object sender, EventArgs e)
{
    MyBindingObject obj = new MyBindingObject { MyValue = 65.45m };
    _bindActiveObject.DataSource = obj; 
}

private void radButton2_Click(object sender, EventArgs e)
{
    _bindActiveObject.DataSource = new MyBindingObject { MyValue = null };
}

public class MyBindingObject
{
    private decimal? _myValue;

    public decimal? MyValue
    {
        get
        {
            return _myValue;
        }
        set
        {
            _myValue = value;
        }
    }
}

public class MySpinEditor : RadSpinEditor
{
    public event EventHandler NullableValueChanged;

    public decimal? NullableValue
    {
        get
        {
            return (this.SpinElement as MySpinEditorElement).NullableValue;
        }
        set
        {
            (this.SpinElement as MySpinEditorElement).NullableValue = value;
        }
    }

    public MySpinEditor()
    {
        this.AutoSize = true;
        this.TabStop = false;
        base.SetStyle(ControlStyles.Selectable, true);
    }

    protected override void CreateChildItems(RadElement parent)
    {
        Type baseType = typeof(RadSpinEditor);
        MySpinEditorElement element = new MySpinEditorElement();
        element.RightToLeft = this.RightToLeft == System.Windows.Forms.RightToLeft.Yes;
        this.RootElement.Children.Add(element);

        element.ValueChanging += spinElement_ValueChanging;
        element.ValueChanged += spinElement_ValueChanged;
        element.TextChanging += spinElement_TextChanging;
        element.NullableValueChanged += element_NullableValueChanged;

        element.KeyDown += OnSpinElementKeyDown;
        element.KeyPress += OnSpinElementKeyPress;
        element.KeyUp += OnSpinElementKeyUp;

        baseType.GetField("spinElement", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(this, element);
    }

    void element_NullableValueChanged(object sender, EventArgs e)
    {
        if (this.NullableValueChanged != null)
        {
            this.NullableValueChanged(this, EventArgs.Empty);
        }
    }

    private Dictionary<string, MethodInfo> cache = new Dictionary<string, MethodInfo>();

    private void InvokeBaseMethod(string name, params object[] parameters)
    {
        if (!cache.ContainsKey(name))
        {
            cache[name] = typeof(RadSpinEditor).GetMethod(name, BindingFlags.Instance | BindingFlags.NonPublic);
        }

        cache[name].Invoke(this, parameters);
    }

    private void OnSpinElementKeyUp(object sender, KeyEventArgs e)
    {
        this.InvokeBaseMethod("OnSpinElementKeyUp", sender, e);
    }

    private void OnSpinElementKeyPress(object sender, KeyPressEventArgs e)
    {
        this.InvokeBaseMethod("OnSpinElementKeyPress", sender, e);
    }

    private void OnSpinElementKeyDown(object sender, KeyEventArgs e)
    {
        this.InvokeBaseMethod("OnSpinElementKeyDown", sender, e);
    }

    private void spinElement_TextChanging(object sender, TextChangingEventArgs e)
    {
        this.InvokeBaseMethod("spinElement_TextChanging", sender, e);
    }

    private void spinElement_ValueChanged(object sender, EventArgs e)
    {
        this.InvokeBaseMethod("spinElement_ValueChanged", sender, e);
        this.NullableValue = this.Value;
    }

    private void spinElement_ValueChanging(object sender, ValueChangingEventArgs e)
    {
        this.InvokeBaseMethod("spinElement_ValueChanging", sender, e);
    }

    protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
    {
        if (keyData == Keys.Tab)
        {
            (this.SpinElement as MySpinEditorElement).CommitText();
        }
       else if (keyData== Keys.Delete)
       {
           (this.SpinElement as MySpinEditorElement).NullableValue = null;
        } 
        return base.ProcessCmdKey(ref msg, keyData);
    }

    protected override Size DefaultSize
    {
        get
        {
            return GetDpiScaledSize(new Size(100, 20));
        }
    }
}

public class MySpinEditorElement : RadSpinElement
{
    private bool validating;
    private decimal? nullableValue;
    private RadButtonElement nullButton;

    public decimal? NullableValue
    {
        get
        {
            return this.nullableValue;
        }
        set
        {
            this.nullableValue = value;
            if (value.HasValue)
            {
                this.internalValue = value.Value;
            }
            else
            {
                this.internalValue = 0m;
            }

            this.Validate();
            this.OnNullableValueChanged();
        }
    }

    protected override void OnKeyDown(KeyEventArgs e)
    {
        if (e.KeyCode == Keys.Enter)
        {
            this.CommitText();
            e.Handled = true;
            return;
        }

        base.OnKeyDown(e);
    }

    void nullButton_Click(object sender, EventArgs e)
    {
        this.NullableValue = null;
    }

    public virtual void CommitText()
    {
        this.NullableValue = this.GetValueFromText();
    }

    protected override decimal GetValueFromText()
    {
        if (this.TextBoxItem.Text == "")
        {
            return 0m;
        }

        return base.GetValueFromText();
    }

    public override bool Validate()
    {
        if (!this.NullableValue.HasValue)
        {
            this.TextBoxItem.Text = "";
            return true;
        }

        this.TextBoxItem.Text = this.GetTextFromNumber(this.NullableValue.HasValue ? this.internalValue : 0m, this.Hexadecimal,
            this.ThousandsSeparator, this.DecimalPlaces);

        return true;
    }

    private string GetTextFromNumber(decimal num, bool hex, bool thousands, int decimalPlaces)
    {
        if (hex)
        {
            return string.Format("{0:X}", (long)num);
        }

        return num.ToString((thousands ? "N" : "F") + decimalPlaces.ToString(CultureInfo.CurrentCulture), CultureInfo.CurrentCulture);
    }

    public override void PerformStep(decimal step)
    {
        decimal value = this.GetValueFromText();

        try
        {
            decimal incValue = value + step;
            value = incValue;
        }
        catch (OverflowException)
        {
        }

        this.NullableValue = this.Constrain(value);
        this.Validate();
    }

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

    public event EventHandler NullableValueChanged;

    protected virtual void OnNullableValueChanged()
    {
        if (this.NullableValueChanged != null)
        {
            this.NullableValueChanged(this, EventArgs.Empty);
        }
    }
}

1. Provide the 'Ignore' button above the 'Ignore All' button 

2. If no text is entered in the 'Change To' text field and the 'Change' button is clicked, the highlighted suggestion should be used instead.

3. After the 'Change' button is clicked, the 'Change To' text box should be cleared so that users don't have to delete the text string before entering something else.

ADD. RadDateTimePicker - add support for nullable types

To reproduce:
Add RadAutoCompleteBox
Add AutoCompleteItems
Change the theme to Office2010BlueTheme, Office2010BlackTheme, Office2007SilverTheme or Office2010SilverTheme.
Write something - looks good
Autocomplete a word and now write something - text is a few pixels lower.

Workaround:

void radAutoCompleteBox2_TextBlockFormatting(object sender, TextBlockFormattingEventArgs e)
{
    TokenizedTextBlockElement token = e.TextBlock as TokenizedTextBlockElement;
    if (token != null)
    {
        token.Margin = new Padding(0, 1, 1, 1);             
    }
}

There should be a mean to restrict the possible values a user can input.

In ReadOnle mode no other keys do anything on the document, but the delete key deletes text/images just as it normally works.

To reproduce:
radDateTimePicker1.ShowUpDown = true;

WORKAROUND:
            radDateTimePicker1.ShowUpDown = true;
            radDateTimePicker1.Enabled = false;
            radDateTimePicker1.Enabled = true;

Add PasswordChar property.

When the ReadOnly property of RadTimePicker is true, setting the Value property in code does not cause any effect on the UI of RadTimePicker.

The TabStop property set via the property builder of VS should be able to set the determine the tabbing behavior of RadTextBox and more specifically, the behavior of its inner TextBoxItem. Right now, the developer has to use a line of code to determine this behavior:
this.radTextBox1.TextBoxElement.TextBoxItem.TabStop = false;
while the TabStop of RadTextBox is always false, so that the focused can be always transferred to the inner TextBoxItem.