|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Globalization;
using System.Windows.Forms.Layout;
namespace System.Windows.Forms;
/// <summary>
/// Represents a Windows up-down control that displays string values.
/// </summary>
[DefaultProperty(nameof(Items))]
[DefaultEvent(nameof(SelectedItemChanged))]
[DefaultBindingProperty(nameof(SelectedItem))]
[SRDescription(nameof(SR.DescriptionDomainUpDown))]
public partial class DomainUpDown : UpDownBase
{
private static readonly string s_defaultValue = string.Empty;
/// <summary>
/// Allowable strings for the domain updown.
/// </summary>
private DomainUpDownItemCollection? _domainItems;
private string _stringValue = s_defaultValue; // Current string value
private int _domainIndex = -1; // Index in the domain list
private bool _sorted; // Sort the domain values
private EventHandler? _onSelectedItemChanged;
private bool _inSort;
/// <summary>
/// Initializes a new instance of the <see cref="DomainUpDown"/> class.
/// </summary>
public DomainUpDown() : base()
{
// this class overrides GetPreferredSizeCore, let Control automatically cache the result
SetExtendedState(ExtendedStates.UserPreferredSizeCache, true);
Text = string.Empty;
}
// Properties
/// <summary>
/// Gets the collection of objects assigned to the
/// up-down control.
/// </summary>
[SRCategory(nameof(SR.CatData))]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
[SRDescription(nameof(SR.DomainUpDownItemsDescr))]
[Localizable(true)]
[Editor($"System.Windows.Forms.Design.StringCollectionEditor, {AssemblyRef.SystemDesign}", typeof(UITypeEditor))]
public DomainUpDownItemCollection Items => _domainItems ??= new DomainUpDownItemCollection(this);
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public new Padding Padding
{
get => base.Padding;
set => base.Padding = value;
}
[Browsable(false)]
[EditorBrowsable(EditorBrowsableState.Never)]
public new event EventHandler? PaddingChanged
{
add => base.PaddingChanged += value;
remove => base.PaddingChanged -= value;
}
/// <summary>
/// Gets or sets the index value of the selected item.
/// </summary>
[Browsable(false)]
[DefaultValue(-1)]
[SRCategory(nameof(SR.CatAppearance))]
[SRDescription(nameof(SR.DomainUpDownSelectedIndexDescr))]
public int SelectedIndex
{
get
{
if (UserEdit)
{
return -1;
}
else
{
return _domainIndex;
}
}
set
{
ArgumentOutOfRangeException.ThrowIfLessThan(value, -1);
ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(value, Items.Count);
if (value != SelectedIndex)
{
SelectIndex(value);
}
}
}
/// <summary>
/// Gets or sets the selected item based on the index value
/// of the selected item in the
/// collection.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[SRDescription(nameof(SR.DomainUpDownSelectedItemDescr))]
public object? SelectedItem
{
get
{
int index = SelectedIndex;
return (index == -1) ? null : Items[index];
}
set
{
// Treat null as selecting no item
if (value is null)
{
SelectedIndex = -1;
}
else
{
// Attempt to find the given item in the list of items
for (int i = 0; i < Items.Count; i++)
{
if (value.Equals(Items[i]))
{
SelectedIndex = i;
break;
}
}
}
}
}
/// <summary>
/// Gets or sets a value indicating whether the item collection is sorted.
/// </summary>
[SRCategory(nameof(SR.CatBehavior))]
[DefaultValue(false)]
[SRDescription(nameof(SR.DomainUpDownSortedDescr))]
public bool Sorted
{
get
{
return _sorted;
}
set
{
_sorted = value;
if (_sorted)
{
SortDomainItems();
}
}
}
internal override bool SupportsUiaProviders => true;
/// <summary>
/// Gets or sets a value indicating whether the collection of items continues to
/// the first or last item if the user continues past the end of the list.
/// </summary>
[SRCategory(nameof(SR.CatBehavior))]
[Localizable(true)]
[DefaultValue(false)]
[SRDescription(nameof(SR.DomainUpDownWrapDescr))]
public bool Wrap { get; set; }
//////////////////////////////////////////////////////////////
// Methods
//
//////////////////////////////////////////////////////////////
/// <summary>
/// Occurs when the <see cref="SelectedItem"/> property has
/// been changed.
/// </summary>
[SRCategory(nameof(SR.CatBehavior))]
[SRDescription(nameof(SR.DomainUpDownOnSelectedItemChangedDescr))]
public event EventHandler? SelectedItemChanged
{
add => _onSelectedItemChanged += value;
remove => _onSelectedItemChanged -= value;
}
/// <summary>
/// Displays the next item in the object collection.
/// </summary>
public override void DownButton()
{
// Make sure domain values exist, and there are >0 items
if (_domainItems is null)
{
return;
}
if (_domainItems.Count <= 0)
{
return;
}
// If the user has entered text, attempt to match it to the domain list
//
int matchIndex = -1;
if (UserEdit)
{
matchIndex = MatchIndex(Text, false, _domainIndex);
}
if (matchIndex != -1)
{
// Found a match, so select this value
_domainIndex = matchIndex;
SelectIndex(matchIndex);
}
else
{
// Otherwise, get the next string in the domain list
if (_domainIndex < _domainItems.Count - 1)
{
SelectIndex(_domainIndex + 1);
}
else if (Wrap)
{
SelectIndex(0);
}
}
}
/// <summary>
/// Tries to find a match of the supplied text in the domain list.
/// If complete is true, a complete match is required for success
/// (i.e. the supplied text is the same length as the matched domain value)
/// Returns the index in the domain list if the match is successful,
/// returns -1 otherwise.
/// </summary>
internal int MatchIndex(string text, bool complete)
{
return MatchIndex(text, complete, _domainIndex);
}
internal int MatchIndex(string text, bool complete, int startPosition)
{
// Make sure domain values exist
if (_domainItems is null)
{
return -1;
}
// Sanity check of parameters
if (text.Length < 1)
{
return -1;
}
if (_domainItems.Count <= 0)
{
return -1;
}
if (startPosition < 0)
{
startPosition = _domainItems.Count - 1;
}
if (startPosition >= _domainItems.Count)
{
startPosition = 0;
}
// Attempt to match the supplied string text with
// the domain list. Returns the index in the list if successful,
// otherwise returns -1.
int index = startPosition;
int matchIndex = -1;
bool found = false;
if (!complete)
{
text = text.ToUpper(CultureInfo.InvariantCulture);
}
// Attempt to match the string with Items[index]
do
{
if (complete)
{
found = Items[index]!.ToString()!.Equals(text);
}
else
{
found = Items[index]!.ToString()!.ToUpper(CultureInfo.InvariantCulture).StartsWith(text, StringComparison.Ordinal);
}
if (found)
{
matchIndex = index;
}
// Calculate the next index to attempt to match
index++;
if (index >= _domainItems.Count)
{
index = 0;
}
}
while (!found && index != startPosition);
return matchIndex;
}
/// <summary>
/// In the case of a DomainUpDown, the handler for changing
/// values is called OnSelectedItemChanged - so just forward it to that
/// function.
/// </summary>
protected override void OnChanged(object? source, EventArgs e)
{
OnSelectedItemChanged(source, e);
}
/// <summary>
/// Handles the <see cref="Control.KeyPress"/>
/// event, using the input character to find the next matching item in our
/// item collection.
/// </summary>
protected override void OnTextBoxKeyPress(object? source, KeyPressEventArgs e)
{
if (ReadOnly)
{
char[] character = [e.KeyChar];
UnicodeCategory uc = char.GetUnicodeCategory(character[0]);
if (uc is UnicodeCategory.LetterNumber
or UnicodeCategory.LowercaseLetter
or UnicodeCategory.DecimalDigitNumber
or UnicodeCategory.MathSymbol
or UnicodeCategory.OtherLetter
or UnicodeCategory.OtherNumber
or UnicodeCategory.UppercaseLetter)
{
// Attempt to match the character to a domain item
int matchIndex = MatchIndex(new string(character), false, _domainIndex + 1);
if (matchIndex != -1)
{
// Select the matching domain item
SelectIndex(matchIndex);
}
e.Handled = true;
}
}
base.OnTextBoxKeyPress(source, e);
}
/// <summary>
/// Raises the <see cref="SelectedItemChanged"/> event.
/// </summary>
protected void OnSelectedItemChanged(object? source, EventArgs e)
{
// Call the event handler
_onSelectedItemChanged?.Invoke(this, e);
}
/// <summary>
/// Selects the item in the domain list at the given index
/// </summary>
private void SelectIndex(int index)
{
// Sanity check index
Debug.Assert(_domainItems is not null, "Domain values array is null");
Debug.Assert(index < _domainItems.Count && index >= -1, "SelectValue: index out of range");
if (_domainItems is null || index < -1 || index >= _domainItems.Count)
{
// Defensive programming
index = -1;
return;
}
// If the selected index has changed, update the text
_domainIndex = index;
if (_domainIndex >= 0)
{
_stringValue = _domainItems[_domainIndex]!.ToString()!;
UserEdit = false;
UpdateEditText();
}
else
{
UserEdit = true;
}
Debug.Assert(_domainIndex >= 0 || UserEdit, $"UserEdit should be true when domainIndex < 0 {UserEdit}");
}
/// <summary>
/// Sorts the domain values
/// </summary>
private void SortDomainItems()
{
if (_inSort)
{
return;
}
_inSort = true;
try
{
// Sanity check
Debug.Assert(_sorted, "Sorted == false");
if (_domainItems is not null)
{
// Sort the domain values
ArrayList.Adapter(_domainItems).Sort(new DomainUpDownItemCompare());
// Update the domain index
if (!UserEdit)
{
int newIndex = MatchIndex(_stringValue, true);
if (newIndex != -1)
{
SelectIndex(newIndex);
}
}
}
}
finally
{
_inSort = false;
}
}
/// <summary>
/// Provides some interesting info about this control in String form.
/// </summary>
public override string ToString()
{
string s = base.ToString();
if (Items is not null)
{
s = $"{s}, Items.Count: {Items.Count}, SelectedIndex: {SelectedIndex}";
}
return s;
}
/// <summary>
/// Displays the previous item in the collection.
/// </summary>
public override void UpButton()
{
// Make sure domain values exist, and there are >0 items
if (_domainItems is null)
{
return;
}
if (_domainItems.Count <= 0)
{
return;
}
// If the user has entered text, attempt to match it to the domain list
int matchIndex = -1;
if (UserEdit)
{
matchIndex = MatchIndex(Text, false, _domainIndex);
}
if (matchIndex != -1)
{
// Found a match, so set the domain index accordingly
_domainIndex = matchIndex;
SelectIndex(matchIndex);
}
else
{
// Otherwise, get the previous string in the domain list
if (_domainIndex > 0)
{
SelectIndex(_domainIndex - 1);
}
else if (Wrap)
{
SelectIndex(_domainItems.Count - 1);
}
}
}
/// <summary>
/// Updates the text in the up-down control to display the selected item.
/// </summary>
protected override void UpdateEditText()
{
UserEdit = false;
ChangingText = true;
Text = _stringValue;
}
// This is not a breaking change -- Even though this control previously autosized to height,
// it didn't actually have an AutoSize property. The new AutoSize property enables the
// smarter behavior.
internal override Size GetPreferredSizeCore(Size proposedConstraints)
{
int height = PreferredHeight;
int width = LayoutUtils.OldGetLargestStringSizeInCollection(Font, Items).Width;
// AdjustWindowRect with our border, since textbox is borderless.
width = SizeFromClientSizeInternal(new(width, height)).Width + _upDownButtons.Width;
return new Size(width, height) + Padding.Size;
}
}
|