To reproduce: use the following code:

this.radSpinEditor1.ScreenTipNeeded += screenTipNeeded;

 private void screenTipNeeded(object sender, Telerik.WinControls.ScreenTipNeededEventArgs e)
 {
     Console.WriteLine(e.Item);
     RadOffice2007ScreenTipElement screenTip = e.Item.ScreenTip as RadOffice2007ScreenTipElement;
     if (screenTip == null)
     {
         e.Item.ScreenTip = new RadOffice2007ScreenTipElement();
         screenTip = e.Item.ScreenTip as RadOffice2007ScreenTipElement;
     }
     screenTip.CaptionLabel.Text = "Title of tooltip";
     screenTip.MainTextLabel.Text = "Text of tooltip";
 }


Workaround:

this.radSpinEditor1.SpinElement.TextBoxItem.HostedControl.MouseLeave += radSpinEditor1_MouseLeave;

 private void radSpinEditor1_MouseLeave(object sender, EventArgs e)
 {
     if (this.radSpinEditor1.SpinElement.TextBoxItem.ScreenTip != null)
     {
         this.radSpinEditor1.ElementTree.ComponentTreeHandler.Behavior.HideScreenTip();
     }
 }

When you have a GridViewDateTimeColumn in the RadGridView and enter in edit mode, you are allowed to clear the current date (set it to null) pressing the Clear button in the popup calendar. However, this functionality is not available in the RadDateTimePicker control.

Workaround:

 public Form1()
 {
     InitializeComponent();
     this.radDateTimePicker1.NullText = "Empty";

     RadDateTimePickerCalendar calendarBehavior = this.radDateTimePicker1.DateTimePickerElement.GetCurrentBehavior() as RadDateTimePickerCalendar;
     calendarBehavior.Calendar.ShowFooter = true;
     calendarBehavior.Calendar.ClearButton.Click += ClearButton_Click;
 }

 private void ClearButton_Click(object sender, EventArgs e)
 {
     this.radDateTimePicker1.DateTimePickerElement.SetToNullValue();
 }

To reproduce:
- Select the time from the drop down and press close button.
- Notice that the form is deactivated.

Workaround:
void radTimePicker1_LostFocus(object sender, EventArgs e)
{
    this.Activate();
}

To reproduce: add a RadTreeView and a timer. Use the following code:

BindingList<Item> list = new BindingList<Item>();

public Form1()
{
    InitializeComponent();
    this.radTreeView1.TreeViewElement.CreateNodeElement += TreeViewElement_CreateNodeElement;
   
    for (int i = 0; i < 10; i++)
    {
        list.Add(new Item(Guid.NewGuid().ToString(), "Node" + i));
    }

    this.radTreeView1.DataSource = list;
    this.radTreeView1.DisplayMember = "Title";
    this.radTreeView1.ValueMember = "UniqueIdentifier";

    this.radTreeView1.TreeViewElement.AutoSizeItems = true;
    this.timer1.Start();
}

void TreeViewElement_CreateNodeElement(object sender, Telerik.WinControls.UI.CreateTreeNodeElementEventArgs e)
{
    e.NodeElement = new CustomTreeNodeElement();
}

public class Item: System.ComponentModel.INotifyPropertyChanged
{
    public Item(string uniqueIdentifier, string title)
            {
                this._uniqueIdentifier = uniqueIdentifier;
                this._title = title;
            }

    public string UniqueIdentifier
            {
                get
                {
                    return this._uniqueIdentifier;
                }
                set
                {
                    this._uniqueIdentifier = value;
                    OnPropertyChanged("UniqueIdentifier");
                }
            }

    public string Title
            {
                get
                {
                    return this._title;
                }
                set
                {
                    this._title = value;
                    OnPropertyChanged("Title");
                }
            }

    public event PropertyChangedEventHandler PropertyChanged;

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

    private string _uniqueIdentifier;
    private string _title;
}

public class CustomContentElement : TreeNodeContentElement
{
    StackLayoutElement nodeContentContainer;
    LinePrimitive lineElement;
    LightVisualElement idElement;
    RadTextBoxControlElement textBoxElement;

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

    protected override void InitializeFields()
            {
                base.InitializeFields();
                this.Margin = new Padding(5, 5, 5, 5);

                this.StretchHorizontally = true;
            }

    public override void Synchronize()
    {
        this.DrawFill = true;

        TreeNodeElement treeNodeElement = this.NodeElement;
        RadTreeNode node = treeNodeElement.Data;
        Item dataItem = (Item)node.DataBoundItem;
        if (dataItem != null)
        {
            this.idElement.Text = string.Empty + dataItem.UniqueIdentifier;

            this.textBoxElement.Text = string.Empty + dataItem.Title;
        }
    }

    protected override void CreateChildElements()
            {
                nodeContentContainer = new StackLayoutElement();
                nodeContentContainer.Orientation = Orientation.Vertical;
                nodeContentContainer.StretchHorizontally = true;
                nodeContentContainer.StretchVertically = false;

                idElement = new LightVisualElement();
                idElement.ShouldHandleMouseInput = false;
                idElement.NotifyParentOnMouseInput = true;
                idElement.StretchVertically = false;
                this.nodeContentContainer.Children.Add(idElement);

                lineElement = new LinePrimitive();
                lineElement.BackColor = Color.Black;
                lineElement.Margin = new Padding(10, 0, 10, 0);
                lineElement.StretchVertically = false;
                this.nodeContentContainer.Children.Add(lineElement);

                textBoxElement = new RadTextBoxControlElement();
                textBoxElement.TextChanged += textBoxElement_TextChanged;
                textBoxElement.Margin = new Padding(20, 3, 20, 3);
                textBoxElement.StretchVertically = false;
                this.nodeContentContainer.Children.Add(textBoxElement);

                this.Children.Add(nodeContentContainer);
            }

    private void textBoxElement_TextChanged(object sender, EventArgs e)
    {
        RadTextBoxControlElement tb = sender as RadTextBoxControlElement;
        CustomContentElement contentElement = tb.Parent.Parent as CustomContentElement;
        Item item = contentElement.NodeElement.Data.DataBoundItem as Item;
        if (item.Title != tb.Text)
        {
            item.Title = tb.Text;
        }
    }
}

public class CustomTreeNodeElement : TreeNodeElement
{
    protected override TreeNodeContentElement CreateContentElement()
    {
        return new CustomContentElement();
    }

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

private void timer1_Tick(object sender, EventArgs e)
{
    foreach (Item item in list)
    {
        item.Title = "Node " + DateTime.Now.ToLongTimeString();
    }
}

To reproduce:

Create a Form, add a RadDateTimePicker and set the ShowUpDown property to true. Create another Form with one button. One click of the button create a new instance of the first form, show it and close it. You will notice that the memory usage will increase as you click more and more.

All controls (i.e. RadGridView, RadPropertyGrid, etc.), which use textbox editor, containing HostedTextBoxBase descendant, can be spelled by the RadSpellChecker. But the red underline is not displayed entirely. The inside hosted text box should have a bigger height.

To reproduce:

Add a RadDateTimePicker to a form,  set your DPI settings to 150% (you will need to re-log from windows), open the form and click the arrow of the RadDateTimePicker to show the dropdown. You will notice that the dropdown is not being scaled accordingly.

Workaround:

Subscribe to the PropertyChanged event of RadDateTimePicker and scale the dropdown manually:

Size initialPopupSize;
RadDateTimePicker dateTimePicker;
void DateTimePickerElement_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
    if (e.PropertyName == "IsDropDownShown")
    {
        RadDateTimePickerCalendar calendar = dateTimePicker.DateTimePickerElement.GetCurrentBehavior() as RadDateTimePickerCalendar;
        if (calendar.PopupControl.MinimumSize != initialPopupSize && initialPopupSize != Size.Empty)
        {
            return;
        }

        float scale = 0;
        float dpi = this.CreateGraphics().DpiX;

        if (dpi == 96)
        {
            scale = 1f;
        }
        else if (dpi == 120)
        {
            scale = 1.25f;
        }
        else if (dpi == 144)
        {
            scale = 1.5f;
        }
        else if (dpi == 192)
        {
            scale = 2f;
        }

        Size popupSize = calendar.PopupControl.Size;
        Size newSize = new Size((int)(popupSize.Width * scale), (int)(popupSize.Height * scale));
        calendar.PopupControl.MinimumSize = newSize;
        initialPopupSize = popupSize;
    }
}

Expose the AutoCompleteDropDown so it's behavior can be customized and the user can subscribe to its events for example.

To reproduce:
- Set the ShowCheckBox property to true and Checked property to false at design-time.
- When the application is started the checkbox is checked.

Workaround:
- Set the state in code:
 radDateTimePicker1.Checked = false;

To reproduce: 
1. Add RadDateTimePicker and set these properties: 
this.radDateTimePicker1.ReadOnly = true;
this.radDateTimePicker1.ShowCheckBox = true;
2. When run the project you will see that the checkbox is not read only. 

Workaround: 
RadCheckBoxElement checkboxelement = this.radDateTimePicker1.DateTimePickerElement.CheckBox;
checkboxelement.ReadOnly = true;

To reproduce:
- Add two RadTextBoxControls to a blank form.
- Double click the one that does not contain the focus with the right mouse button.

Workaround:

radTextBoxControl1.CaretIndex = 0;

To reproduce:
- add a RadButton and a RadTimePicker;
- on RadButton.Click dispose the existing RadTimePicker and create a new one;
- continue clicking for a while and notice that memory consumption is rising.

You guys expose most of the properties from the "HostedControl" on your custom controls.  One that seems to be missing, and requires an unintuitive line of code is the "UseSystemPasswordChar" boolean property from the TextBox.  I think it makes a lot of sense to expose this.

See: http://www.telerik.com/forums/usesystempasswordchar-property-for-radtextbox

To reproduce:
1.Add a RadAutoCompleteBox to a form. 
2.Add AutoCompleteItems.
3.Start the project.
4.AutoComplete a word and write some normal text.
5.Change few themes (mainly office themes) you will notice that the text's position shifts down.

Workaround:
Clear each TokenizedTextBlockElement's bottom Margin from the themes using VisualStyleBuilder.

Add the ability to gain focus and change the toggle state upon keypress.
Add the ability to show the calendar with a key combination like Alt + DownArrow.

To reproduce:
Add a RadSpinEditor and set its Hexadecimal property to true. Set its maximum to 0xFFFFFFFF(4294967295). Try to enter value larger than 7FFFFFFF(Int.MaxValue). You will notice that the value cannot be set.

Workaround:
public class MySpinEditor : RadSpinEditor
        {
            public new MySpinElement SpinElement
            {
                get
                {
                    return base.SpinElement as MySpinElement;
                }
                private set
                {
                    typeof(RadSpinEditor).GetField("spinElement", BindingFlags.Instance |  BindingFlags.NonPublic).SetValue(this, value);
                }
            }

            protected override void CreateChildItems(RadElement parent)
            {
                this.SpinElement = new MySpinElement();
                this.SpinElement.RightToLeft = this.RightToLeft == System.Windows.Forms.RightToLeft.Yes;
                this.RootElement.Children.Add(this.SpinElement);

                this.SpinElement.ValueChanging += SpinElement_ValueChanging;
                this.SpinElement.ValueChanged += SpinElement_ValueChanged;
                this.SpinElement.TextChanging += SpinElement_TextChanging;

                this.SpinElement.KeyDown += SpinElement_KeyDown;
                this.SpinElement.KeyPress += SpinElement_KeyPress;
                this.SpinElement.KeyUp += SpinElement_KeyUp;
            }

            void SpinElement_KeyUp(object sender, KeyEventArgs e)
            {
                this.CallBaseOnKeyUp(e);
            }

            void SpinElement_KeyPress(object sender, KeyPressEventArgs e)
            {
                this.CallBaseOnKeyPress(e);
            }

            void SpinElement_KeyDown(object sender, KeyEventArgs e)
            {
                this.CallBaseOnKeyDown(e);
            }

            void SpinElement_TextChanging(object sender, TextChangingEventArgs e)
            {
                this.OnTextChanged(e);
            }

            void SpinElement_ValueChanged(object sender, EventArgs e)
            {
                this.OnValueChanged(e);
            }

            void SpinElement_ValueChanging(object sender, ValueChangingEventArgs e)
            {
                this.OnValueChanging(e);
            }


        }

public class MySpinElement : RadSpinElement
{
    protected override decimal GetValueFromText()
    {
        try
        {
            if (!string.IsNullOrEmpty(this.Text) && ((this.Text.Length != 1) || (this.Text != "-")))
            {
                decimal resultValue = 0m;

                if (this.Hexadecimal)
                {
                    resultValue = this.Constrain(Convert.ToDecimal(Convert.ToInt64(this.Text, 16)));
                }
                else
                {
                    resultValue = this.Constrain(decimal.Parse(this.Text, CultureInfo.CurrentCulture));
                }

                return resultValue;
            }
            else
            {
                return this.internalValue;
            }
        }
        catch
        {
            return this.internalValue;
        }
    }

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