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: 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: 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: 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: 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: 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: 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: 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: 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.
Approved
Last Updated: 15 Aug 2017 09:38 by ADMIN
ADMIN
Created by: Peter
Comments: 0
Category: Editors
Type: Feature Request
4
RadMaskedEditBox does not support G mask
Approved
Last Updated: 15 Aug 2017 09:33 by ADMIN
Currently, this can be achieve with this code:
  TextInfo textInfo = new CultureInfo("en-US", false).TextInfo;
        bool updating = false;
        void radTextBox1_TextChanging(object sender, TextChangingEventArgs e)
        {
            if (!updating)
            {
                int pos = radTextBox1.TextBoxElement.TextBoxItem.SelectionStart;
                updating = true;
                radTextBox1.Text = textInfo.ToTitleCase(radTextBox1.Text);
                radTextBox1.TextBoxElement.TextBoxItem.SelectionStart = pos;
                updating = false;
            }
        }
Completed
Last Updated: 19 Jan 2011 10:21 by ADMIN
RadDateTimePicker - allow entering date, month and year without using space key to navigate between the date, month and the year, just like in RadMaskedEditBox
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.
Declined
Last Updated: 20 Feb 2014 14:52 by ADMIN
ADMIN
Created by: Jack
Comments: 0
Category: Editors
Type: Feature Request
3
Currently it is not possible to represent time as 24:00 in time picker control as it uses the .NET DateType type, which does not support "24:00" as valid time.
Completed
Last Updated: 06 Feb 2012 04:17 by ADMIN
IMPROVE. RadTextBox - add option to choose whether the NullText should be wrapped or not, when used in MultiLine text box
COMMENT: This functionality is supported by RadTextBoxControl. Please use it instead.
Approved
Last Updated: 15 Aug 2017 09:36 by ADMIN
Currently there can only be one delimiter in the autocomplete box. Different users might be accustomed to using different delimiters, even one user using several delimiters.
1 2 3 4 5