Completed
Last Updated: 19 Feb 2015 09:12 by Jesse Dyck
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.
Completed
Last Updated: 05 Jun 2014 07:07 by Jesse Dyck
ADMIN
Created by: Nikolay
Comments: 2
Category: Editors
Type: Feature Request
16
One should be able to pick and type only the time portion of a datetime value.
Completed
Last Updated: 05 Jun 2014 07:07 by ADMIN
ADMIN
Created by: Nikolay
Comments: 0
Category: Editors
Type: Feature Request
16
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.
Completed
Last Updated: 10 Jun 2014 18:54 by Jesse Dyck
Add a new wrapping mode that breaks the text per whole words
Completed
Last Updated: 10 Jun 2014 10:35 by Ruth Goldberg
ADMIN
Created by: Telerik Admin
Comments: 3
Category: Editors
Type: Feature Request
13
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 
Completed
Last Updated: 13 Feb 2014 13:19 by Jesse Dyck
Created by: Svetlin
Comments: 1
Category: Editors
Type: Feature Request
11
Improve the RadTextBoxControl to allow different text alignment as Microsoft TextBox.
Completed
Last Updated: 29 May 2014 08:57 by ADMIN
ADMIN
Created by: Stefan
Comments: 0
Category: Editors
Type: Feature Request
10
One should be able to show a desired time range i.e. from 8 am to 6 pm
Completed
Last Updated: 30 May 2014 14:37 by Jesse Dyck
Add functionality to be able to pick up the time together with the date and to pick the time only.
Completed
Last Updated: 06 Jun 2014 10:36 by Jesse Dyck
ADMIN
Created by: Martin Vasilev
Comments: 2
Category: Editors
Type: Feature Request
9
Hide or disable the dates that are not pick-able (for example greater than max date) in drop-down calendar.
Completed
Last Updated: 04 Jun 2012 01:33 by Jesse Dyck
ADMIN
Created by: Stefan
Comments: 2
Category: Editors
Type: Feature Request
6
ADD. RadDateTimePicker - add support for nullable types
Completed
Last Updated: 29 Nov 2017 07:03 by Svetlin
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.
Completed
Last Updated: 11 Nov 2016 08:07 by ADMIN
ADMIN
Created by: Dess | Tech Support Engineer, Sr.
Comments: 4
Category: Editors
Type: Feature Request
6
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);
        }
    }
}


Completed
Last Updated: 13 Jun 2014 09:09 by ADMIN
In ReadOnle mode no other keys do anything on the document, but the delete key deletes text/images just as it normally works.
Completed
Last Updated: 22 Apr 2014 15:41 by ADMIN
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);             
    }
}
Completed
Last Updated: 18 Apr 2013 02:40 by ADMIN
To reproduce:
radDateTimePicker1.ShowUpDown = true;

WORKAROUND:
            radDateTimePicker1.ShowUpDown = true;
            radDateTimePicker1.Enabled = false;
            radDateTimePicker1.Enabled = true;
Completed
Last Updated: 14 Dec 2012 10:53 by Jesse Dyck
ADMIN
Created by: Boryana
Comments: 1
Category: Editors
Type: Feature Request
5
Add PasswordChar property.
Completed
Last Updated: 06 Jun 2014 12:40 by ADMIN
ADMIN
Created by: Ivan Petrov
Comments: 0
Category: Editors
Type: Feature Request
5
There should be a mean to restrict the possible values a user can input.
Completed
Last Updated: 03 Jul 2013 13:52 by ADMIN
ADMIN
Created by: Telerik Admin
Comments: 0
Category: Editors
Type: Bug Report
4
Put couple text boxes on a form in design time and you will have to press Shift+TAB twice to get the focus to the previously focused text box.
Completed
Last Updated: 25 May 2010 06:30 by Deyan
Created by: Deyan
Comments: 0
Category: Editors
Type: Feature Request
4
Extend the functionality of the RadMaskedEditBox to support continuous user input, i.e. no navigation keys are required to move the cursor between the separate editable parts of the current mask.
Completed
Last Updated: 05 Jun 2014 07:08 by ADMIN
When the ReadOnly property of RadTimePicker is true, setting the Value property in code does not cause any effect on the UI of RadTimePicker.
1 2 3 4 5 6