DreamineRadioButton.cs

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

using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
 
namespace Dreamine.UI.Wpf.Controls
{
    public class DreamineRadioButton : RadioButton
    {
        static DreamineRadioButton()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(DreamineRadioButton),
                new FrameworkPropertyMetadata(typeof(DreamineRadioButton)));
 
            var uri = new Uri("/Dreamine.UI.Wpf.Themes;component/DreamineRadioButtonStyle.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 new static readonly DependencyProperty CommandProperty =
        DependencyProperty.RegisterAttached(
            "Command",
            typeof(ICommand),
            typeof(DreamineRadioButton),
            new PropertyMetadata(null, OnCommandChanged));

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

        public static readonly DependencyProperty CommandTriggerNameProperty =
        DependencyProperty.RegisterAttached(
            "CommandTriggerName",
            typeof(string),
            typeof(DreamineRadioButton),
            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);
        }
    }
}