DreamineTextBox.cs

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

// =====================================================================
// \file DreamineTextBox.cs
// \brief VsLibrary용 커스텀 TextBox. Hint/Error + CommandTrigger + Enter Focus UX 지원.
// =====================================================================
 
using System;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;
 
namespace Dreamine.UI.Wpf.Controls
{
    public class DreamineTextBox : TextBox
    {
        private IInputElement? _previousFocusedElement;

        static DreamineTextBox()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(DreamineTextBox),
                new FrameworkPropertyMetadata(typeof(DreamineTextBox)));
 
            var uri = new Uri("/Dreamine.UI.Wpf.Themes;component/DreamineTextBoxStyle.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 DreamineTextBox()
        {
            // \brief Enter 복귀를 위해 이전 포커스 저장
            GotKeyboardFocus += OnGotKeyboardFocus_StorePreviousFocus;
        }

        private void OnGotKeyboardFocus_StorePreviousFocus(object sender, KeyboardFocusChangedEventArgs e)
        {
            // \brief OldFocus가 Window/ContentControl로 들어오는 경우가 있으므로 교정
            var old = e.OldFocus;
 
            if (old is null)
            {
                _previousFocusedElement = null;
                return;
            }
 
            if (ReferenceEquals(old, this))
            {
                // \brief 자기 자신이면 의미 없음
                return;
            }
 
            if (old is DependencyObject dobj)
            {
                if (old is Window || old is ContentControl)
                {
                    var child = FindFirstFocusableChild(dobj);
                    _previousFocusedElement = child ?? old;
                    return;
                }
            }
 
            _previousFocusedElement = old;
        }

        protected override void OnPreviewKeyDown(KeyEventArgs e)
        {
            base.OnPreviewKeyDown(e);
 
            if (e.Key != Key.Enter)
                return;
 
            var target = _previousFocusedElement;
 
            if (target == null || ReferenceEquals(target, this))
                return;
 
            // \brief Enter 키 입력은 여기서 소비
            e.Handled = true;
 
            // \brief 이벤트 파이프라인/내부 TextBox 처리 후 포커스 이동
            Dispatcher.BeginInvoke(new Action(() =>
            {
                try
                {
                    // \brief UIElement이면 Focus()가 더 잘 먹는 경우가 많음
                    if (target is UIElement uie)
                    {
                        uie.Focus();
                        Keyboard.Focus(uie);
                        return;
                    }
 
                    Keyboard.Focus(target);
                }
                catch
                {
                    // \brief 포커스 실패는 치명적이지 않으므로 무시(정책에 맞게 로그로 바꿔도 됨)
                }
            }), System.Windows.Threading.DispatcherPriority.Input);
        }

        private UIElement? FindFirstFocusableChild(DependencyObject parent)
        {
            for (int i = 0; i < VisualTreeHelper.GetChildrenCount(parent); i++)
            {
                var child = VisualTreeHelper.GetChild(parent, i);
 
                if (child is UIElement uie && uie.Focusable && uie.IsVisible && uie.IsEnabled)
                    return uie;
 
                var result = FindFirstFocusableChild(child);
                if (result != null)
                    return result;
            }
            return null;
        }
 
        // =====================================================================
        // Attached Command: Command / CommandParameter / CommandTriggerName
        // =====================================================================

        public static readonly DependencyProperty CommandProperty =
            DependencyProperty.RegisterAttached(
                "Command",
                typeof(ICommand),
                typeof(DreamineTextBox),
                new PropertyMetadata(null, OnCommandChanged));

        public static readonly DependencyProperty CommandParameterProperty =
            DependencyProperty.RegisterAttached(
                "CommandParameter",
                typeof(object),
                typeof(DreamineTextBox),
                new PropertyMetadata(null));

        public static readonly DependencyProperty CommandTriggerNameProperty =
            DependencyProperty.RegisterAttached(
                "CommandTriggerName",
                typeof(string),
                typeof(DreamineTextBox),
                new PropertyMetadata(null));

        public static void SetCommandTriggerName(DependencyObject obj, string value)
            => obj.SetValue(CommandTriggerNameProperty, value);

        public static string GetCommandTriggerName(DependencyObject obj)
            => (string)obj.GetValue(CommandTriggerNameProperty);

        public static void SetCommand(DependencyObject obj, ICommand value)
            => obj.SetValue(CommandProperty, value);

        public static ICommand GetCommand(DependencyObject obj)
            => (ICommand)obj.GetValue(CommandProperty);

        public static void SetCommandParameter(DependencyObject obj, object value)
            => obj.SetValue(CommandParameterProperty, value);

        public static object GetCommandParameter(DependencyObject obj)
            => obj.GetValue(CommandParameterProperty);

        private static void OnCommandChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is not UIElement element)
                return;
 
            element.AddHandler(UIElement.PreviewMouseUpEvent, new MouseButtonEventHandler((s, args) =>
            {
                TryExecuteCommand(d, "PreviewMouseUp", args);
            }), true);
 
            element.AddHandler(Control.MouseDoubleClickEvent, new MouseButtonEventHandler((s, args) =>
            {
                TryExecuteCommand(d, "MouseDoubleClick", args);
            }), true);
 
            element.AddHandler(UIElement.PreviewKeyDownEvent, new KeyEventHandler((s, args) =>
            {
                // \brief 기존 규칙 유지: PreviewKeyDown 훅이지만 이름은 "PreviewKeyUp"
                TryExecuteCommand(d, "PreviewKeyUp", args);
            }), true);
 
            element.AddHandler(UIElement.TouchUpEvent, new EventHandler<TouchEventArgs>((s, args) =>
            {
                TryExecuteCommand(d, "TouchUp", args);
            }));
 
            element.AddHandler(ButtonBase.ClickEvent, new RoutedEventHandler((s, args) =>
            {
                TryExecuteCommand(d, "Click", args);
            }));
 
            element.AddHandler(TextBox.TextChangedEvent, new TextChangedEventHandler((s, args) =>
            {
                TryExecuteCommand(d, "TextChanged", args);
            }));
        }

        private static void TryExecuteCommand(DependencyObject d, string eventName, RoutedEventArgs eventArgs)
        {
            var rawTrigger = GetCommandTriggerName(d);
            if (string.IsNullOrEmpty(rawTrigger))
                return;
 
            var triggerList = rawTrigger.Split(',')
                .Select(x => x.Trim())
                .Where(x => !string.IsNullOrEmpty(x));
 
            if (!triggerList.Contains(eventName, StringComparer.OrdinalIgnoreCase))
                return;
 
            var command = GetCommand(d);
            var parameter = GetCommandParameter(d) ?? eventArgs;
 
            if (command?.CanExecute(parameter) == true)
                command.Execute(parameter);
        }
 
        // =====================================================================
        // Hint / Error
        // =====================================================================

        public static readonly DependencyProperty HintProperty =
            DependencyProperty.Register(nameof(Hint), typeof(string), typeof(DreamineTextBox), new PropertyMetadata(string.Empty));

        public string Hint
        {
            get => (string)GetValue(HintProperty);
            set => SetValue(HintProperty, value);
        }

        public static readonly DependencyProperty ErrorProperty =
            DependencyProperty.Register(nameof(Error), typeof(string), typeof(DreamineTextBox), new PropertyMetadata(string.Empty));

        public string Error
        {
            get => (string)GetValue(ErrorProperty);
            set => SetValue(ErrorProperty, value);
        }
    }
}