Completed
Last Updated: 21 Jun 2018 14:06 by ADMIN
To reproduce:
this.radDateTimePicker1.DateTimePickerElement.TextBoxElement.MaskType = MaskType.FreeFormDateTime;

And try pasting a date, or some free text.

 
Completed
Last Updated: 13 Jun 2018 08:23 by Dimitar
https://msdn.microsoft.com/en-us/library/system.windows.forms.maskedtextbox.maskcompleted(v=vs.110).aspx
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: 09 Feb 2017 10:59 by ADMIN
Workaround: use simple data binding with the editor and its Text property

this.radCalculatorDropDown1.CalculatorElement.EditorContentElement.TextBoxItem.DataBindings.Add("Text", testObject, "TestValue", false, DataSourceUpdateMode.OnPropertyChanged);
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 Oct 2015 12:28 by ADMIN
Completed
Last Updated: 26 May 2015 14:42 by ADMIN
ADD. Popup control which can host controls and be associated with a button or opened on request.
Completed
Last Updated: 03 Feb 2015 12:25 by ADMIN
One should be able to disable the saving of the custom colors. In addition one should be able to override the color dialog FormClosing method.
Completed
Last Updated: 22 Jan 2015 17:13 by ADMIN
ADMIN
Created by: Stefan
Comments: 0
Category: Editors
Type: Feature Request
1

			
Completed
Last Updated: 26 Dec 2014 13:44 by ADMIN
Completed
Last Updated: 03 Dec 2014 12:04 by Svetlin
Created by: Svetlin
Comments: 0
Category: Editors
Type: Feature Request
1
Add IME support to RadTextBoxControl and RadAutoCompleteBox.
Completed
Last Updated: 26 Nov 2014 13:36 by ADMIN
When the IP is set like this:
this.radMaskedEditBox1.Value = "89.111.222.123";
the value in the box is not correct:
891.112.221.23

In addition the user should be able to insert digits not just replace them. 
Completed
Last Updated: 24 Nov 2014 07:29 by ADMIN
When the user is typing before already typed text, the text is overridden. Add the ability to insert characters instead of replacing them like in the .Net MaskedTextBox.
Completed
Last Updated: 10 Oct 2014 11:48 by ADMIN
ADMIN
Created by: Dess | Tech Support Engineer, Sr.
Comments: 0
Category: Editors
Type: Feature Request
0

			
Completed
Last Updated: 31 Jul 2014 08:11 by ADMIN
IMPROVE. RadSpellChecker - add ability to modify the €œThe spelling check is completed€ text in the message box.
Completed
Last Updated: 03 Jul 2014 16:35 by ADMIN
1. limitation of the time that can be chosen (e.g. 8 AM to 5 PM)
2. set the interval of increasing and decreasing the Minutes part to 30 instead of 1

NO WORKAROUND

Resolution: 
In release Q2 2014 we are introducing logic that allow to set time range by MinValue and MaxValue properties of RadTimePicker. To set the interval of increasing and decreasing of the minute’s part you can use the MinutesStep property of the MaskDateTimeProvider. 

For example for RadTimePicker:
(this.radTimePicker1.TimePickerElement.MaskedEditBox.Provider as MaskDateTimeProvider).MinutesStep = 30;

For example for RadDateTimePicker:
RadMaskedEditBoxElement mask = (RadMaskedEditBoxElement)this.radDateTimePicker1.DateTimePickerElement.TextBoxElement;
MaskDateTimeProvider provider = mask.Provider as MaskDateTimeProvider;
provider.MinutesStep = 30;
1 2 3 4