DreamineComboBox.cs

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

// =====================================================================
// \file DreamineComboBox.cs
// \brief MVVM-style attached command trigger ComboBox
// \details
//  - Supports triggers: PreviewMouseUp, MouseDoubleClick, PreviewKeyDown, PreviewKeyUp, TouchUp,
//    Click, SelectionChanged, DropDownClosed
//  - Prevents duplicated handler hookup by using attached flags
//  - Unhooks DropDownClosed on Unloaded to avoid leaks / duplicates
//  - If CommandParameter is null, it passes a rich context object including Sender + EventArgs
// \date 2026-02-10
// =====================================================================
 
using System;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
 
namespace Dreamine.UI.Wpf.Controls
{
    public class DreamineComboBox : ComboBox
    {
        #region Command Context

        public sealed class DreamineComboBoxCommandContext
        {
            public string EventName { get; }

            public object? Sender { get; }

            public object? EventArgs { get; }

            public ComboBox? ComboBox { get; }

            public object? SelectedItem { get; }

            public object? SelectedValue { get; }

            public int SelectedIndex { get; }

            public DreamineComboBoxCommandContext(string eventName, object? sender, object? args, ComboBox? combo)
            {
                EventName = eventName ?? string.Empty;
                Sender = sender;
                EventArgs = args;
                ComboBox = combo;
 
                if (combo != null)
                {
                    SelectedItem = combo.SelectedItem;
                    SelectedValue = combo.SelectedValue;
                    SelectedIndex = combo.SelectedIndex;
                }
                else
                {
                    SelectedItem = null;
                    SelectedValue = null;
                    SelectedIndex = -1;
                }
            }

            public override string ToString()
                => $"Event={EventName}, SelectedItem={SelectedItem ?? "(null)"}, SelectedIndex={SelectedIndex}";
        }
 
        #endregion
 
        #region Attached Flags (Private)

        private static readonly DependencyProperty IsHandlersHookedProperty =
            DependencyProperty.RegisterAttached(
                "IsHandlersHooked",
                typeof(bool),
                typeof(DreamineComboBox),
                new PropertyMetadata(false));

        private static readonly DependencyProperty IsDropDownClosedHookedProperty =
            DependencyProperty.RegisterAttached(
                "IsDropDownClosedHooked",
                typeof(bool),
                typeof(DreamineComboBox),
                new PropertyMetadata(false));

        private static readonly DependencyProperty IsUnloadedHookedProperty =
            DependencyProperty.RegisterAttached(
                "IsUnloadedHooked",
                typeof(bool),
                typeof(DreamineComboBox),
                new PropertyMetadata(false));

        private static readonly DependencyProperty DropDownClosedHandlerProperty =
            DependencyProperty.RegisterAttached(
                "DropDownClosedHandler",
                typeof(EventHandler),
                typeof(DreamineComboBox),
                new PropertyMetadata(null));

        private static readonly DependencyProperty UnloadedHandlerProperty =
            DependencyProperty.RegisterAttached(
                "UnloadedHandler",
                typeof(RoutedEventHandler),
                typeof(DreamineComboBox),
                new PropertyMetadata(null));

        private static bool GetIsHandlersHooked(DependencyObject o) => (bool)o.GetValue(IsHandlersHookedProperty);
        private static void SetIsHandlersHooked(DependencyObject o, bool v) => o.SetValue(IsHandlersHookedProperty, v);

        private static bool GetIsDropDownClosedHooked(DependencyObject o) => (bool)o.GetValue(IsDropDownClosedHookedProperty);
        private static void SetIsDropDownClosedHooked(DependencyObject o, bool v) => o.SetValue(IsDropDownClosedHookedProperty, v);

        private static bool GetIsUnloadedHooked(DependencyObject o) => (bool)o.GetValue(IsUnloadedHookedProperty);
        private static void SetIsUnloadedHooked(DependencyObject o, bool v) => o.SetValue(IsUnloadedHookedProperty, v);

        private static void SetDropDownClosedHandler(DependencyObject o, EventHandler? h) => o.SetValue(DropDownClosedHandlerProperty, h);
        private static EventHandler? GetDropDownClosedHandler(DependencyObject o) => (EventHandler?)o.GetValue(DropDownClosedHandlerProperty);

        private static void SetUnloadedHandler(DependencyObject o, RoutedEventHandler? h) => o.SetValue(UnloadedHandlerProperty, h);
        private static RoutedEventHandler? GetUnloadedHandler(DependencyObject o) => (RoutedEventHandler?)o.GetValue(UnloadedHandlerProperty);
 
        #endregion
 
        #region Attached DPs (Public)

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

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

        public static readonly DependencyProperty CommandTriggerNameProperty =
            DependencyProperty.RegisterAttached(
                "CommandTriggerName",
                typeof(string),
                typeof(DreamineComboBox),
                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);
 
        #endregion
 
        #region Hook Logic

        private static void OnCommandChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is not UIElement element)
                return;
 
            // \brief Routed 이벤트 훅은 1회만
            if (!GetIsHandlersHooked(d))
            {
                // \brief Mouse
                element.AddHandler(UIElement.PreviewMouseUpEvent, new MouseButtonEventHandler((s, ev) =>
                {
                    TryExecuteCommand(d, s, "PreviewMouseUp", ev);
                }), true);
 
                element.AddHandler(Control.MouseDoubleClickEvent, new MouseButtonEventHandler((s, ev) =>
                {
                    TryExecuteCommand(d, s, "MouseDoubleClick", ev);
                }), true);
 
                // \brief Keyboard (Down/Up)
                element.AddHandler(UIElement.PreviewKeyDownEvent, new KeyEventHandler((s, ev) =>
                {
                    TryExecuteCommand(d, s, "PreviewKeyDown", ev);
                }), true);
 
                element.AddHandler(UIElement.PreviewKeyUpEvent, new KeyEventHandler((s, ev) =>
                {
                    TryExecuteCommand(d, s, "PreviewKeyUp", ev);
                }), true);
 
                // \brief Touch
                element.AddHandler(UIElement.TouchUpEvent, new EventHandler<TouchEventArgs>((s, ev) =>
                {
                    TryExecuteCommand(d, s, "TouchUp", ev);
                }), true);
 
                // \brief Click (경로 유지)
                element.AddHandler(ButtonBase.ClickEvent, new RoutedEventHandler((s, ev) =>
                {
                    TryExecuteCommand(d, s, "Click", ev);
                }), true);
 
                // \brief SelectionChanged
                element.AddHandler(Selector.SelectionChangedEvent, new SelectionChangedEventHandler((s, ev) =>
                {
                    TryExecuteCommand(d, s, "SelectionChanged", ev);
                }), true);
 
                SetIsHandlersHooked(d, true);
            }
 
            // \brief Unloaded 훅도 1회만 (DropDownClosed 해제용)
            if (d is FrameworkElement fe && !GetIsUnloadedHooked(d))
            {
                RoutedEventHandler unloadedHandler = (_, __) =>
                {
                    // \brief DropDownClosed 구독 해제
                    if (d is ComboBox combo)
                    {
                        var h = GetDropDownClosedHandler(d);
                        if (h != null)
                        {
                            combo.DropDownClosed -= h;
                            SetDropDownClosedHandler(d, null);
                        }
                    }
 
                    SetIsDropDownClosedHooked(d, false);
                };
 
                fe.Unloaded += unloadedHandler;
                SetUnloadedHandler(d, unloadedHandler);
                SetIsUnloadedHooked(d, true);
            }
 
            // \brief DropDownClosed는 ComboBox 이벤트 -> 중복 구독 방지 + 해제 가능하게 저장
            if (d is ComboBox comboBox && !GetIsDropDownClosedHooked(d))
            {
                EventHandler handler = (s, ev) =>
                {
                    TryExecuteCommand(d, s, "DropDownClosed", ev);
                };
 
                comboBox.DropDownClosed += handler;
                SetDropDownClosedHandler(d, handler);
                SetIsDropDownClosedHooked(d, true);
            }
        }
 
        #endregion
 
        #region Execute Logic

        private static void TryExecuteCommand(DependencyObject d, object? sender, string eventName, RoutedEventArgs eventArgs)
        {
            // \brief 키 반복 입력 방지 (원하면 옵션화 가능)
            if (eventName.Equals("PreviewKeyDown", StringComparison.OrdinalIgnoreCase) &&
                eventArgs is KeyEventArgs ke && ke.IsRepeat)
            {
                return;
            }
 
            var rawTrigger = GetCommandTriggerName(d);
            if (string.IsNullOrWhiteSpace(rawTrigger))
                return;
 
            var triggerList = rawTrigger.Split(',')
                .Select(x => x.Trim())
                .Where(x => !string.IsNullOrWhiteSpace(x));
 
            if (!triggerList.Contains(eventName, StringComparer.OrdinalIgnoreCase))
                return;
 
            var command = GetCommand(d);
            if (command == null)
                return;
 
            var explicitParam = GetCommandParameter(d);
            var combo = (sender as ComboBox) ?? (d as ComboBox);
 
            var parameter = explicitParam ?? new DreamineComboBoxCommandContext(eventName, sender, eventArgs, combo);
 
            if (command.CanExecute(parameter))
                command.Execute(parameter);
        }

        private static void TryExecuteCommand(DependencyObject d, object? sender, string eventName, EventArgs eventArgs)
        {
            var rawTrigger = GetCommandTriggerName(d);
            if (string.IsNullOrWhiteSpace(rawTrigger))
                return;
 
            var triggerList = rawTrigger.Split(',')
                .Select(x => x.Trim())
                .Where(x => !string.IsNullOrWhiteSpace(x));
 
            if (!triggerList.Contains(eventName, StringComparer.OrdinalIgnoreCase))
                return;
 
            var command = GetCommand(d);
            if (command == null)
                return;
 
            var explicitParam = GetCommandParameter(d);
            var combo = (sender as ComboBox) ?? (d as ComboBox);
 
            var parameter = explicitParam ?? new DreamineComboBoxCommandContext(eventName, sender, eventArgs, combo);
 
            if (command.CanExecute(parameter))
                command.Execute(parameter);
        }
 
        #endregion
    }
}