DreamineListBox.cs

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

using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
 
namespace Dreamine.UI.Wpf.Controls
{
    public class DreamineListBox : ListBox
    {
        static DreamineListBox()
        {
            // \brief Default style key override (one-time per type)
            DefaultStyleKeyProperty.OverrideMetadata(typeof(DreamineListBox),
                new FrameworkPropertyMetadata(typeof(DreamineListBox)));
 
            // \brief Merge style dictionary once
            var uri = new Uri("/Dreamine.UI.Wpf.Themes;component/DreamineListBoxStyle.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 DreamineListBox()
        {
            TryMergeStyleOnce();
        }

        private static void TryMergeStyleOnce()
        {
            var app = Application.Current;
            if (app == null)
                return;
 
            var uri = new Uri("/Dreamine.UI.Wpf.Themes;component/DreamineListBoxStyle.xaml", UriKind.RelativeOrAbsolute);
 
            bool alreadyAdded =
                app.Resources.MergedDictionaries
                    .OfType<ResourceDictionary>()
                    .Any(x => x.Source != null && x.Source.Equals(uri));
 
            if (!alreadyAdded)
            {
                var dict = new ResourceDictionary { Source = uri };
                app.Resources.MergedDictionaries.Add(dict);
            }
        }
 

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

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

        public static readonly DependencyProperty CommandTriggerNameProperty =
        DependencyProperty.RegisterAttached(
            "CommandTriggerName",
            typeof(string),
            typeof(DreamineListBox),
            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 UIElement element)
            {
                // 마우스 클릭
                element.AddHandler(UIElement.PreviewMouseUpEvent, new MouseButtonEventHandler((s, e) =>
                {
                    TryExecuteCommand(d, "PreviewMouseUp", e);
                }), true);
                element.AddHandler(Control.MouseDoubleClickEvent, new MouseButtonEventHandler((s, e) =>
                {
                    TryExecuteCommand(d, "MouseDoubleClick", e);
                }), true);
 
                // 키보드 입력
                element.AddHandler(UIElement.PreviewKeyDownEvent, new KeyEventHandler((s, e) =>
                {
                    TryExecuteCommand(d, "PreviewKeyUp", e);
                }), true);
 
                element.AddHandler(UIElement.TouchUpEvent, new EventHandler<TouchEventArgs>((s, e) =>
                {
                    TryExecuteCommand(d, "TouchUp", e);
                }));
 
                element.AddHandler(ButtonBase.ClickEvent, new RoutedEventHandler((s, e) =>
                {
                    TryExecuteCommand(d, "Click", e);
                }));
            }
        }

        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);
        }
    }
}