TimeSpanControl.xaml.cs

using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
 
namespace Vereinsmeisterschaften.Controls
{
    public partial class TimeSpanControl : UserControl
    {
        public enum TimeSpanControlEditModes
        {
            None,
            EditHours,
            EditMinutes,
            EditSeconds,
            EditMilliseconds
        }

        public const ushort MAX_NUMBER_MILLISECOND_DIGITS = 3;
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

        public TimeSpanControl()
        {
            InitializeComponent();
        }
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        private bool _digitEntry_StartWithFirstDigit = true;        // If this flag is true, the next entered digit is used as 1er digit (rightmost digit)
        private byte _digitEntry_CountEnteredZeroes = 0;            // Number of entered zeroes. This is reset whenever the EditModes changes
        
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Dependency Properties

        public TimeSpanControlEditModes EditMode
        {
            get { return (TimeSpanControlEditModes)GetValue(EditModeProperty); }
            set { SetValue(EditModeProperty, value); }
        }

        public static readonly DependencyProperty EditModeProperty = DependencyProperty.Register(nameof(EditMode), typeof(TimeSpanControlEditModes), typeof(TimeSpanControl), new UIPropertyMetadata(TimeSpanControlEditModes.EditMinutes, new PropertyChangedCallback(OnEditModeChanged)));
 
        private static void OnEditModeChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
        {
            TimeSpanControl control = obj as TimeSpanControl;
            control._digitEntry_StartWithFirstDigit = true;
            control._digitEntry_CountEnteredZeroes = 0;
        }
 
        // ----------------------------------------------------------------------------------------------------------------------------------------------

        public TimeSpan Value
        {
            get { return (TimeSpan)GetValue(ValueProperty); }
            set { SetValue(ValueProperty, value); }
        }

        public static readonly DependencyProperty ValueProperty = DependencyProperty.Register(nameof(Value), typeof(TimeSpan), typeof(TimeSpanControl), new FrameworkPropertyMetadata(TimeSpan.Zero, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, new PropertyChangedCallback(OnValueChanged)));
 
        private static void OnValueChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
        {
            TimeSpanControl control = obj as TimeSpanControl;
            control.Hours = ((TimeSpan)e.NewValue).Hours;
            control.Minutes = ((TimeSpan)e.NewValue).Minutes;
            control.Seconds = ((TimeSpan)e.NewValue).Seconds;
            control.Milliseconds = ((TimeSpan)e.NewValue).Milliseconds;
        }
 
        // ----------------------------------------------------------------------------------------------------------------------------------------------

        public int Hours
        {
            get { return (int)GetValue(HoursProperty); }
            set { SetValue(HoursProperty, value); }
        }

        public static readonly DependencyProperty HoursProperty = DependencyProperty.Register(nameof(Hours), typeof(int), typeof(TimeSpanControl), new UIPropertyMetadata(0, new PropertyChangedCallback(OnTimeChanged)));

        public int Minutes
        {
            get { return (int)GetValue(MinutesProperty); }
            set { SetValue(MinutesProperty, value); }
        }

        public static readonly DependencyProperty MinutesProperty = DependencyProperty.Register(nameof(Minutes), typeof(int), typeof(TimeSpanControl), new UIPropertyMetadata(0, new PropertyChangedCallback(OnTimeChanged)));

        public int Seconds
        {
            get { return (int)GetValue(SecondsProperty); }
            set { SetValue(SecondsProperty, value); }
        }

        public static readonly DependencyProperty SecondsProperty = DependencyProperty.Register(nameof(Seconds), typeof(int), typeof(TimeSpanControl), new UIPropertyMetadata(0, new PropertyChangedCallback(OnTimeChanged)));

        public int Milliseconds
        {
            get { return (int)GetValue(MillisecondsProperty); }
            set { SetValue(MillisecondsProperty, value); }
        }

        public static readonly DependencyProperty MillisecondsProperty = DependencyProperty.Register(nameof(Milliseconds), typeof(int), typeof(TimeSpanControl), new UIPropertyMetadata(0, new PropertyChangedCallback(OnTimeChanged)));
 
        private static void OnTimeChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
        {
            if (obj is TimeSpanControl control)
            {
                control.Value = new TimeSpan(0, control.Hours, control.Minutes, control.Seconds, control.Milliseconds);
                control.updateMillisecondsDisplayed();
            }
        }
 
        // ----------------------------------------------------------------------------------------------------------------------------------------------

        public ushort MillisecondDigits
        {
            get => (ushort)GetValue(MillisecondDigitsProperty);
            set => SetValue(MillisecondDigitsProperty, value);
        }

        public static readonly DependencyProperty MillisecondDigitsProperty = DependencyProperty.Register(nameof(MillisecondDigits), typeof(ushort), typeof(TimeSpanControl), new PropertyMetadata(MAX_NUMBER_MILLISECOND_DIGITS, OnMillisecondDigitsChanged));
 
        private static void OnMillisecondDigitsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is TimeSpanControl control)
            {
                if(control.MillisecondDigits < 1) { control.MillisecondDigits = 1; }
                if (control.MillisecondDigits > MAX_NUMBER_MILLISECOND_DIGITS) { control.MillisecondDigits = MAX_NUMBER_MILLISECOND_DIGITS; }
                control.updateMillisecondsDisplayed();
            }
        }

        public string MillisecondsDisplayed
        {
            get { return (string)GetValue(MillisecondsDisplayedProperty); }
            private set { SetValue(MillisecondsDisplayedProperty, value); }
        }
 
        private static readonly DependencyPropertyKey MillisecondsDisplayedPropertyKey = DependencyProperty.RegisterReadOnly(nameof(MillisecondsDisplayed), typeof(string), typeof(TimeSpanControl), new PropertyMetadata("000"));

        public static readonly DependencyProperty MillisecondsDisplayedProperty = MillisecondsDisplayedPropertyKey.DependencyProperty;
 
        private void updateMillisecondsDisplayed()
        {
            int factor = (int)Math.Pow(10, MAX_NUMBER_MILLISECOND_DIGITS - MillisecondDigits);
            int displayedMilliseconds = Milliseconds / factor;
            string format = new string('0', Math.Max((ushort)1, MillisecondDigits));
            string formattedMilliseconds = displayedMilliseconds.ToString(format);
            SetValue(MillisecondsDisplayedPropertyKey, formattedMilliseconds);
        }
 
        // ----------------------------------------------------------------------------------------------------------------------------------------------

        public bool HoursVisible
        {
            get { return (bool)GetValue(HoursVisibleProperty); }
            set { SetValue(HoursVisibleProperty, value); }
        }

        public static readonly DependencyProperty HoursVisibleProperty = DependencyProperty.Register(nameof(HoursVisible), typeof(bool), typeof(TimeSpanControl), new UIPropertyMetadata(true, new PropertyChangedCallback(OnVisiblePartsChanged)));

        public bool MillisecondsVisible
        {
            get { return (bool)GetValue(MillisecondsVisibleProperty); }
            set { SetValue(MillisecondsVisibleProperty, value); }
        }

        public static readonly DependencyProperty MillisecondsVisibleProperty = DependencyProperty.Register(nameof(MillisecondsVisible), typeof(bool), typeof(TimeSpanControl), new UIPropertyMetadata(true, new PropertyChangedCallback(OnVisiblePartsChanged)));
 
        private static void OnVisiblePartsChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
        {
            TimeSpanControl control = obj as TimeSpanControl;
            if(!control.HoursVisible && control.EditMode == TimeSpanControlEditModes.EditHours)
            {
                control.EditMode = TimeSpanControlEditModes.EditMinutes;
            }
            else if (!control.MillisecondsVisible && control.EditMode == TimeSpanControlEditModes.EditMilliseconds)
            {
                control.EditMode = TimeSpanControlEditModes.EditSeconds;
            }
        }
 
        #endregion
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Digit Update Logic

        private void handleDigitInput(byte digit)
        {
            if(digit > 9) { digit = 9; }
 
            int oldValueMultiplier = _digitEntry_StartWithFirstDigit ? 0 : 10;
            _digitEntry_StartWithFirstDigit = false;
            if(digit == 0) { _digitEntry_CountEnteredZeroes++; }
            switch (EditMode)
            {
                case TimeSpanControlEditModes.EditHours:
                    Hours = (Hours * oldValueMultiplier) + digit;
                    if (Hours > 2 || _digitEntry_CountEnteredZeroes >= (digit == 0 ? 2 : 1)) { EditMode = TimeSpanControlEditModes.EditMinutes; }
                    break;
                case TimeSpanControlEditModes.EditMinutes:
                    Minutes = (Minutes * oldValueMultiplier) + digit;
                    if (Minutes >= 6 || _digitEntry_CountEnteredZeroes >= (digit == 0 ? 2 : 1)) { EditMode = TimeSpanControlEditModes.EditSeconds; }
                    break;
                case TimeSpanControlEditModes.EditSeconds:
                    Seconds = (Seconds * oldValueMultiplier) + digit;
                    if(MillisecondsVisible)
                    {
                        if (Seconds >= 6 || _digitEntry_CountEnteredZeroes >= (digit == 0 ? 2 : 1)) { EditMode = TimeSpanControlEditModes.EditMilliseconds; }
                    }
                    else
                    {
                        if (Seconds * 10 >= 59 || _digitEntry_CountEnteredZeroes >= 2) { _digitEntry_StartWithFirstDigit = true; _digitEntry_CountEnteredZeroes = 0; }
                    }
                    break;
                case TimeSpanControlEditModes.EditMilliseconds:
                    int factor = (int)Math.Pow(10, MAX_NUMBER_MILLISECOND_DIGITS - MillisecondDigits); // 1, 10, 100
                    int maxValue = 1000 - factor; // 900, 990, 999
 
                    int tmpMilliseconds = (((Milliseconds / factor) * oldValueMultiplier) + digit) * factor;
                    Milliseconds = Math.Min(maxValue, tmpMilliseconds);
 
                    if (Milliseconds >= maxValue || Milliseconds * 10 >= maxValue || _digitEntry_CountEnteredZeroes >= MAX_NUMBER_MILLISECOND_DIGITS)
                    {
                        _digitEntry_StartWithFirstDigit = true;
                        _digitEntry_CountEnteredZeroes = 0;
                    }
                    break;
            }
        }

        private void increaseDigit()
        {
            switch (EditMode)
            {
                case TimeSpanControlEditModes.EditHours:
                    if(Hours < 23) { Hours++; }
                    break;
                case TimeSpanControlEditModes.EditMinutes:
                    if(Minutes < 59) { Minutes++; }
                    break;
                case TimeSpanControlEditModes.EditSeconds:
                    if(Seconds < 59) { Seconds++; }
                    break;
                case TimeSpanControlEditModes.EditMilliseconds:
                    int step = (int)Math.Pow(10, MAX_NUMBER_MILLISECOND_DIGITS - MillisecondDigits);
                    int max = 1000 - step; // e.g. 900, 990 oder 999
                    if (Milliseconds + step <= max)
                    {
                        Milliseconds += step;
                    }
                    else
                    {
                        Milliseconds = max;
                    }
                    break;
            }
        }

        private void decreaseDigit()
        {
            switch (EditMode)
            {
                case TimeSpanControlEditModes.EditHours:
                    if (Hours > 0) { Hours--; }
                    break;
                case TimeSpanControlEditModes.EditMinutes:
                    if (Minutes > 0) { Minutes--; }
                    break;
                case TimeSpanControlEditModes.EditSeconds:
                    if (Seconds > 0) { Seconds--; }
                    break;
                case TimeSpanControlEditModes.EditMilliseconds:
                    int step = (int)Math.Pow(10, MAX_NUMBER_MILLISECOND_DIGITS - MillisecondDigits);
                    if (Milliseconds - step >= 0)
                    {
                        Milliseconds -= step;
                    }
                    else
                    {
                        Milliseconds = 0;
                    }
                    break;
            }
        }
 
        #endregion
 
        // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        #region Control Events
 
        private void txt_hours_PreviewMouseDown(object sender, MouseButtonEventArgs e)
        {
            this.Focus();
            EditMode = TimeSpanControlEditModes.EditHours;
            e.Handled = true;   // avoids focus loss by e.g. parent ListViewItem
        }
 
        private void txt_minutes_PreviewMouseDown(object sender, MouseButtonEventArgs e)
        {
            this.Focus();
            EditMode = TimeSpanControlEditModes.EditMinutes;
            e.Handled = true;   // avoids focus loss by e.g. parent ListViewItem
        }
 
        private void txt_seconds_PreviewMouseDown(object sender, MouseButtonEventArgs e)
        {
            this.Focus();
            EditMode = TimeSpanControlEditModes.EditSeconds;
            e.Handled = true;   // avoids focus loss by e.g. parent ListViewItem
        }
 
        private void txt_milliseconds_PreviewMouseDown(object sender, MouseButtonEventArgs e)
        {
            this.Focus();
            EditMode = TimeSpanControlEditModes.EditMilliseconds;
            e.Handled = true;   // avoids focus loss by e.g. parent ListViewItem
        }
 
        private void UserControl_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Tab)
            {
                // Return here to enable the default behavior of the Tab key
                return;
            }
            else if ((e.Key >= Key.D0 && e.Key <= Key.D9) || (e.Key >= Key.NumPad0 && e.Key <= Key.NumPad9))
            {
                string keyString = e.Key.ToString().Replace("NumPad", "").Replace("D", "");
                byte digit;
                if (byte.TryParse(keyString, out digit))
                {
                    handleDigitInput(digit);
                }
            }
            else if (e.Key == Key.Right)
            {
                TimeSpanControlEditModes highestMode = TimeSpanControlEditModes.EditMilliseconds;
                if(!MillisecondsVisible) { highestMode = TimeSpanControlEditModes.EditSeconds; }
                if (EditMode < highestMode)
                {
                    EditMode++;
                }
            }
            else if (e.Key == Key.Left)
            {
                TimeSpanControlEditModes lowestMode = TimeSpanControlEditModes.EditHours;
                if (!HoursVisible) { lowestMode = TimeSpanControlEditModes.EditMinutes; }
                if (EditMode > lowestMode)
                {
                    EditMode--;
                }
            }
            else if(e.Key == Key.Up)
            {
                increaseDigit();
            }
            else if (e.Key == Key.Down)
            {
                decreaseDigit();
            }
            else if (e.Key == Key.Enter)
            {
                EditMode = TimeSpanControlEditModes.None;
                Keyboard.ClearFocus();
            }
            e.Handled = true;
        }
 
        private void btn_Increase_Click(object sender, RoutedEventArgs e)
        {
            increaseDigit();
        }
 
        private void btn_Decrease_Click(object sender, RoutedEventArgs e)
        {
            decreaseDigit();
        }
 
        #endregion
    }
}