NumericRangeBehavior.cs

이 파일의 문서화 페이지로 가기

using System;
using System.Globalization;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
 
namespace Dreamine.UI.Wpf.Behaviors
{
    public enum NumericRangeMode
    {
        Clamp,
        Reject
    }

    public static class NumericRangeBehavior
    {
        public static readonly DependencyProperty IsEnabledProperty =
            DependencyProperty.RegisterAttached(
                "IsEnabled",
                typeof(bool),
                typeof(NumericRangeBehavior),
                new PropertyMetadata(false, OnIsEnabledChanged));

        public static readonly DependencyProperty MinProperty =
            DependencyProperty.RegisterAttached(
                "Min",
                typeof(double?),
                typeof(NumericRangeBehavior),
                new PropertyMetadata(null));

        public static readonly DependencyProperty MaxProperty =
            DependencyProperty.RegisterAttached(
                "Max",
                typeof(double?),
                typeof(NumericRangeBehavior),
                new PropertyMetadata(null));

        public static readonly DependencyProperty ModeProperty =
            DependencyProperty.RegisterAttached(
                "Mode",
                typeof(NumericRangeMode),
                typeof(NumericRangeBehavior),
                new PropertyMetadata(NumericRangeMode.Clamp));

        private static readonly DependencyProperty LastValidTextProperty =
            DependencyProperty.RegisterAttached(
                "LastValidText",
                typeof(string),
                typeof(NumericRangeBehavior),
                new PropertyMetadata(null));

        public static void SetIsEnabled(DependencyObject d, bool value) => d.SetValue(IsEnabledProperty, value);
        public static bool GetIsEnabled(DependencyObject d) => (bool)d.GetValue(IsEnabledProperty);

        public static void SetMin(DependencyObject d, double? value) => d.SetValue(MinProperty, value);
        public static double? GetMin(DependencyObject d) => (double?)d.GetValue(MinProperty);

        public static void SetMax(DependencyObject d, double? value) => d.SetValue(MaxProperty, value);
        public static double? GetMax(DependencyObject d) => (double?)d.GetValue(MaxProperty);

        public static void SetMode(DependencyObject d, NumericRangeMode value) => d.SetValue(ModeProperty, value);
        public static NumericRangeMode GetMode(DependencyObject d) => (NumericRangeMode)d.GetValue(ModeProperty);

        private static void SetLastValidText(DependencyObject d, string value) => d.SetValue(LastValidTextProperty, value);
        private static string GetLastValidText(DependencyObject d) => (string)d.GetValue(LastValidTextProperty);

        private static void OnIsEnabledChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is not TextBox tb) return;
 
            if ((bool)e.NewValue)
            {
                tb.Loaded += Tb_Loaded;
                tb.TextChanged += Tb_TextChanged;
                tb.LostFocus += Tb_LostFocus;
                DataObject.AddPastingHandler(tb, OnPasting);
            }
            else
            {
                tb.Loaded -= Tb_Loaded;
                tb.TextChanged -= Tb_TextChanged;
                tb.LostFocus -= Tb_LostFocus;
                DataObject.RemovePastingHandler(tb, OnPasting);
            }
        }

        private static void Tb_Loaded(object sender, RoutedEventArgs e)
        {
            if (sender is TextBox tb)
                SetLastValidText(tb, tb.Text);
        }

        private static void OnPasting(object sender, DataObjectPastingEventArgs e)
        {
            if (sender is not TextBox tb) return;
 
            if (e.DataObject.GetDataPresent(DataFormats.UnicodeText))
            {
                var pasteText = e.DataObject.GetData(DataFormats.UnicodeText) as string ?? string.Empty;
                var future = GetFutureText(tb, pasteText);
                if (!TryValidate(tb, future, out var corrected))
                {
                    if (GetMode(tb) == NumericRangeMode.Reject)
                    {
                        e.CancelCommand();
                        tb.Text = GetLastValidText(tb) ?? string.Empty;
                        tb.CaretIndex = tb.Text.Length;
                        return;
                    }
                    e.CancelCommand(); // Clamp
                    tb.Text = corrected;
                    tb.CaretIndex = tb.Text.Length;
                }
            }
        }

        private static void Tb_TextChanged(object sender, TextChangedEventArgs e)
        {
            if (sender is not TextBox tb) return;
 
            if (GetMode(tb) == NumericRangeMode.Clamp)
            {
                if (!TryValidate(tb, tb.Text, out var corrected))
                {
                    tb.TextChanged -= Tb_TextChanged;
                    tb.Text = corrected;
                    tb.CaretIndex = tb.Text.Length;
                    tb.TextChanged += Tb_TextChanged;
                }
                else
                {
                    SetLastValidText(tb, tb.Text);
                }
            }
        }

        private static void Tb_LostFocus(object sender, RoutedEventArgs e)
        {
            if (sender is not TextBox tb) return;
 
            var mode = GetMode(tb);
            if (!TryValidate(tb, tb.Text, out var corrected))
            {
                tb.Text = (mode == NumericRangeMode.Reject)
                    ? (GetLastValidText(tb) ?? corrected)
                    : corrected;
            }
            SetLastValidText(tb, tb.Text);
 
            // 바인딩 원본 반영
            var expr = tb.GetBindingExpression(TextBox.TextProperty);
            expr?.UpdateSource();
        }

        private static string GetFutureText(TextBox tb, string insert)
        {
            var text = tb.Text ?? string.Empty;
            var selStart = tb.SelectionStart;
            var selLen = tb.SelectionLength;
            if (selLen > 0) text = text.Remove(selStart, selLen);
            return text.Insert(selStart, insert);
        }

        private static bool TryValidate(TextBox tb, string text, out string corrected)
        {
            corrected = text ?? string.Empty;
            if (string.IsNullOrWhiteSpace(text))
                return true; // 빈값 허용 여부는 별도 정책에서 결정
 
            var style = NumberStyles.Float | NumberStyles.AllowThousands;
            var culture = CultureInfo.CurrentCulture;
 
            if (!double.TryParse(text, style, culture, out var value))
            {
                return false; // 숫자 아님
            }
 
            var min = GetMin(tb);
            var max = GetMax(tb);
 
            if (min.HasValue && value < min.Value)
            {
                corrected = min.Value.ToString(culture);
                return false;
            }
            if (max.HasValue && value > max.Value)
            {
                corrected = max.Value.ToString(culture);
                return false;
            }
 
            return true;
        }
    }
}