DreamineTimeSpinner.cs

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

using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
 
namespace Dreamine.UI.Wpf.Controls
{
    public class DreamineTimeSpinner : Control
    {
        private const string PART_HourBox = "PART_HourBox";

        private const string PART_MinBox = "PART_MinBox";

        private const string PART_SecBox = "PART_SecBox";

        private const string PART_UpButton = "PART_UpButton";

        private const string PART_DownButton = "PART_DownButton";

        private TextBox? _hourBox;

        private TextBox? _minBox;

        private TextBox? _secBox;

        private ButtonBase? _upButton;

        private ButtonBase? _downButton;

        private enum eFocusedBox
        {
            Hour,

            Minute,

            Second
        }

        private eFocusedBox _activeBox = eFocusedBox.Minute;

        public TimeSpan Time
        {
            get => (TimeSpan)GetValue(TimeProperty);
            set => SetValue(TimeProperty, value);
        }

        public static readonly DependencyProperty TimeProperty =
            DependencyProperty.Register(
                nameof(Time),
                typeof(TimeSpan),
                typeof(DreamineTimeSpinner),
                new FrameworkPropertyMetadata(default(TimeSpan), FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnTimeChanged));

        private static void OnTimeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var spinner = d as DreamineTimeSpinner;
            spinner?.UpdateTextBoxes();
        }

        public static RoutedCommand UpCommand { get; set; } = new(nameof(UpCommand), typeof(DreamineTimeSpinner));

        public static RoutedCommand DownCommand { get; set; } = new(nameof(DownCommand), typeof(DreamineTimeSpinner));

        static DreamineTimeSpinner()
        {
            DefaultStyleKeyProperty.OverrideMetadata(
                typeof(DreamineTimeSpinner),
                new FrameworkPropertyMetadata(typeof(DreamineTimeSpinner)));
 
            var uri = new Uri("/Dreamine.UI.Wpf.Themes;component/DreamineTimeSpinnerStyle.xaml", UriKind.RelativeOrAbsolute);
 
            if (Application.Current != null)
            {
                bool alreadyAdded = Application.Current.Resources.MergedDictionaries
                    .OfType<ResourceDictionary>()
                    .Any(x => x.Source != null && x.Source.Equals(uri));
 
                if (!alreadyAdded)
                {
                    var dict = new ResourceDictionary { Source = uri };
                    Application.Current.Resources.MergedDictionaries.Add(dict);
                }
            }
        }

        public DreamineTimeSpinner()
        {
            CommandBindings.Add(new CommandBinding(UpCommand, OnUpExecuted));
            CommandBindings.Add(new CommandBinding(DownCommand, OnDownExecuted));
        }

        public override void OnApplyTemplate()
        {
            base.OnApplyTemplate();
 
            _hourBox = GetTemplateChild(PART_HourBox) as TextBox;
            _minBox = GetTemplateChild(PART_MinBox) as TextBox;
            _secBox = GetTemplateChild(PART_SecBox) as TextBox;
            _upButton = GetTemplateChild(PART_UpButton) as ButtonBase;
            _downButton = GetTemplateChild(PART_DownButton) as ButtonBase;
 
            if (_hourBox != null)
            {
                _hourBox.GotFocus += (_, __) => _activeBox = eFocusedBox.Hour;
                _hourBox.LostFocus += HourBox_LostFocus;
                _hourBox.PreviewKeyDown += HourBox_PreviewKeyDown;
            }
            if (_minBox != null)
            {
                _minBox.GotFocus += (_, __) => _activeBox = eFocusedBox.Minute;
                _minBox.LostFocus += MinBox_LostFocus;
                _minBox.PreviewKeyDown += MinBox_PreviewKeyDown;
            }
            if (_secBox != null)
            {
                _secBox.GotFocus += (_, __) => _activeBox = eFocusedBox.Second;
                _secBox.LostFocus += SecBox_LostFocus;
                _secBox.PreviewKeyDown += SecBox_PreviewKeyDown;
            }
 
            if (_upButton != null)
                _upButton.Command = UpCommand;
            if (_downButton != null)
                _downButton.Command = DownCommand;
 
            UpdateTextBoxes();
        }

        private void HourBox_LostFocus(object sender, RoutedEventArgs e) => TryUpdateTimeFromBoxes();

        private void MinBox_LostFocus(object sender, RoutedEventArgs e) => TryUpdateTimeFromBoxes();

        private void SecBox_LostFocus(object sender, RoutedEventArgs e) => TryUpdateTimeFromBoxes();

        private void HourBox_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter) TryUpdateTimeFromBoxes();
        }

        private void MinBox_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter) TryUpdateTimeFromBoxes();
        }

        private void SecBox_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter) TryUpdateTimeFromBoxes();
        }

        private void TryUpdateTimeFromBoxes()
        {
            if (_hourBox == null || _minBox == null || _secBox == null) return;
 
            int h = Clamp(Parse(_hourBox.Text), 0, 23);
            int m = Clamp(Parse(_minBox.Text), 0, 59);
            int s = Clamp(Parse(_secBox.Text), 0, 59);
 
            Time = new TimeSpan(h, m, s);
 
            UpdateTextBoxes();
        }

        private int Parse(string? s)
        {
            return int.TryParse(s, out var v) ? v : 0;
        }

        private int Clamp(int value, int min, int max)
        {
            if (value < min) return min;
            if (value > max) return max;
            return value;
        }

        private void OnUpExecuted(object sender, ExecutedRoutedEventArgs e)
        {
            switch (_activeBox)
            {
                case eFocusedBox.Hour:
                    Time = new TimeSpan((Time.Hours + 1) % 24, Time.Minutes, Time.Seconds);
                    break;
                case eFocusedBox.Minute:
                    if (Time.Minutes == 59)
                    {
                        int newHour = (Time.Hours + 1) % 24;
                        Time = new TimeSpan(newHour, 0, Time.Seconds);
                    }
                    else
                    {
                        Time = new TimeSpan(Time.Hours, Time.Minutes + 1, Time.Seconds);
                    }
                    break;
                case eFocusedBox.Second:
                    if (Time.Seconds == 59)
                    {
                        int newMinute = Time.Minutes + 1;
                        int newHour = Time.Hours;
                        if (newMinute == 60)
                        {
                            newMinute = 0;
                            newHour = (newHour + 1) % 24;
                        }
                        Time = new TimeSpan(newHour, newMinute, 0);
                    }
                    else
                    {
                        Time = new TimeSpan(Time.Hours, Time.Minutes, Time.Seconds + 1);
                    }
                    break;
            }
        }

        private void OnDownExecuted(object sender, ExecutedRoutedEventArgs e)
        {
            switch (_activeBox)
            {
                case eFocusedBox.Hour:
                    Time = new TimeSpan((Time.Hours + 23) % 24, Time.Minutes, Time.Seconds);
                    break;
                case eFocusedBox.Minute:
                    if (Time.Minutes == 0)
                    {
                        int newHour = (Time.Hours + 23) % 24;
                        Time = new TimeSpan(newHour, 59, Time.Seconds);
                    }
                    else
                    {
                        Time = new TimeSpan(Time.Hours, Time.Minutes - 1, Time.Seconds);
                    }
                    break;
                case eFocusedBox.Second:
                    if (Time.Seconds == 0)
                    {
                        int newMinute = Time.Minutes;
                        int newHour = Time.Hours;
                        if (newMinute == 0)
                        {
                            newMinute = 59;
                            newHour = (newHour + 23) % 24;
                        }
                        else
                        {
                            newMinute = newMinute - 1;
                        }
                        Time = new TimeSpan(newHour, newMinute, 59);
                    }
                    else
                    {
                        Time = new TimeSpan(Time.Hours, Time.Minutes, Time.Seconds - 1);
                    }
                    break;
            }
        }

        private void UpdateTextBoxes()
        {
            if (_hourBox != null)
                _hourBox.Text = Time.Hours.ToString("D2");
            if (_minBox != null)
                _minBox.Text = Time.Minutes.ToString("D2");
            if (_secBox != null)
                _secBox.Text = Time.Seconds.ToString("D2");
        }
    }
}