DreamineButton.cs

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

// \file DreamineButton.cs
// \brief Custom button control for VsLibrary framework. Supports Icon/Shadow/Permission/AttachedCommand.
 
using System;
using System.ComponentModel; // \brief DesignerProperties
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Effects;
using Dreamine.UI.Wpf.Controls.MessageBox;
using Dreamine.UI.Wpf.Controls.Navigation;
 
namespace Dreamine.UI.Wpf.Controls
{
    public enum SelectedVisualMode
    {
        BorderOnly = 0,
        BackgroundOnly = 1,
        Both = 2
    }

    public enum IconPosition
    {
        Left,
        Right,
        Top,
        Bottom,
        Full
    }

    public class DreamineButton : Button
    {
 
        #region Template parts

        private const string PART_ShadowHost = "ShadowHost";

        private Border? _shadowHost;
 
        #endregion
 
        #region New DPs : IconSize / IconMargin / IconStretch

        public double IconSize
        {
            get => (double)GetValue(IconSizeProperty);
            set => SetValue(IconSizeProperty, value);
        }

        public static readonly DependencyProperty IconSizeProperty =
            DependencyProperty.Register(
                nameof(IconSize),
                typeof(double),
                typeof(DreamineButton),
                new FrameworkPropertyMetadata(
                    20d,
                    FrameworkPropertyMetadataOptions.AffectsMeasure |
                    FrameworkPropertyMetadataOptions.AffectsArrange |
                    FrameworkPropertyMetadataOptions.AffectsRender));

        public Thickness IconMargin
        {
            get => (Thickness)GetValue(IconMarginProperty);
            set => SetValue(IconMarginProperty, value);
        }

        public static readonly DependencyProperty IconMarginProperty =
            DependencyProperty.Register(
                nameof(IconMargin),
                typeof(Thickness),
                typeof(DreamineButton),
                new FrameworkPropertyMetadata(
                    new Thickness(0, 0, 4, 0),
                    FrameworkPropertyMetadataOptions.AffectsMeasure |
                    FrameworkPropertyMetadataOptions.AffectsArrange));

        public Stretch IconStretch
        {
            get => (Stretch)GetValue(IconStretchProperty);
            set => SetValue(IconStretchProperty, value);
        }

        public static readonly DependencyProperty IconStretchProperty =
            DependencyProperty.Register(
                nameof(IconStretch),
                typeof(Stretch),
                typeof(DreamineButton),
                new FrameworkPropertyMetadata(
                    Stretch.Uniform,
                    FrameworkPropertyMetadataOptions.AffectsRender));
 
        #endregion
 
        #region New DPs : Shadow (Effect)

        public bool UseShadow
        {
            get => (bool)GetValue(UseShadowProperty);
            set => SetValue(UseShadowProperty, value);
        }

        public static readonly DependencyProperty UseShadowProperty =
            DependencyProperty.Register(
                nameof(UseShadow),
                typeof(bool),
                typeof(DreamineButton),
                new FrameworkPropertyMetadata(
                    false,
                    FrameworkPropertyMetadataOptions.AffectsRender,
                    OnShadowPropertyChanged));

        public double ShadowBlurRadius
        {
            get => (double)GetValue(ShadowBlurRadiusProperty);
            set => SetValue(ShadowBlurRadiusProperty, value);
        }

        public static readonly DependencyProperty ShadowBlurRadiusProperty =
            DependencyProperty.Register(
                nameof(ShadowBlurRadius),
                typeof(double),
                typeof(DreamineButton),
                new FrameworkPropertyMetadata(
                    18d,
                    FrameworkPropertyMetadataOptions.AffectsRender,
                    OnShadowPropertyChanged));

        public double ShadowOpacity
        {
            get => (double)GetValue(ShadowOpacityProperty);
            set => SetValue(ShadowOpacityProperty, value);
        }

        public static readonly DependencyProperty ShadowOpacityProperty =
            DependencyProperty.Register(
                nameof(ShadowOpacity),
                typeof(double),
                typeof(DreamineButton),
                new FrameworkPropertyMetadata(
                    0.55d,
                    FrameworkPropertyMetadataOptions.AffectsRender,
                    OnShadowPropertyChanged));

        public double ShadowDepth
        {
            get => (double)GetValue(ShadowDepthProperty);
            set => SetValue(ShadowDepthProperty, value);
        }

        public static readonly DependencyProperty ShadowDepthProperty =
            DependencyProperty.Register(
                nameof(ShadowDepth),
                typeof(double),
                typeof(DreamineButton),
                new FrameworkPropertyMetadata(
                    6d,
                    FrameworkPropertyMetadataOptions.AffectsRender,
                    OnShadowPropertyChanged));

        public double ShadowDirection
        {
            get => (double)GetValue(ShadowDirectionProperty);
            set => SetValue(ShadowDirectionProperty, value);
        }

        public static readonly DependencyProperty ShadowDirectionProperty =
            DependencyProperty.Register(
                nameof(ShadowDirection),
                typeof(double),
                typeof(DreamineButton),
                new FrameworkPropertyMetadata(
                    90d,
                    FrameworkPropertyMetadataOptions.AffectsRender,
                    OnShadowPropertyChanged));

        public Color ShadowColor
        {
            get => (Color)GetValue(ShadowColorProperty);
            set => SetValue(ShadowColorProperty, value);
        }

        public static readonly DependencyProperty ShadowColorProperty =
            DependencyProperty.Register(
                nameof(ShadowColor),
                typeof(Color),
                typeof(DreamineButton),
                new FrameworkPropertyMetadata(
                    Colors.Black,
                    FrameworkPropertyMetadataOptions.AffectsRender,
                    OnShadowPropertyChanged));

        private static void OnShadowPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is DreamineButton btn)
                btn.UpdateShadowEffect();
        }
 
        #endregion
 
        #region Existing : ImagePosition / OnceLogin / Login / IconSource / IconPath / Command etc.

        public SelectedVisualMode SelectedVisualMode
        {
            get => (SelectedVisualMode)GetValue(SelectedVisualModeProperty);
            set => SetValue(SelectedVisualModeProperty, value);
        }

        public static readonly DependencyProperty SelectedVisualModeProperty =
            DependencyProperty.Register(
                nameof(SelectedVisualMode),
                typeof(SelectedVisualMode),
                typeof(DreamineButton),
                new PropertyMetadata(SelectedVisualMode.BorderOnly));

        public Brush SelectedBorderBrush
        {
            get => (Brush)GetValue(SelectedBorderBrushProperty);
            set => SetValue(SelectedBorderBrushProperty, value);
        }

        public static readonly DependencyProperty SelectedBorderBrushProperty =
            DependencyProperty.Register(
                nameof(SelectedBorderBrush),
                typeof(Brush),
                typeof(DreamineButton),
                new PropertyMetadata(Brushes.Blue));

        public Thickness SelectedBorderThickness
        {
            get => (Thickness)GetValue(SelectedBorderThicknessProperty);
            set => SetValue(SelectedBorderThicknessProperty, value);
        }

        public static readonly DependencyProperty SelectedBorderThicknessProperty =
            DependencyProperty.Register(
                nameof(SelectedBorderThickness),
                typeof(Thickness),
                typeof(DreamineButton),
                new PropertyMetadata(new Thickness(3)));

        public Brush SelectedBackgroundOverlay
        {
            get => (Brush)GetValue(SelectedBackgroundOverlayProperty);
            set => SetValue(SelectedBackgroundOverlayProperty, value);
        }

        public static readonly DependencyProperty SelectedBackgroundOverlayProperty =
            DependencyProperty.Register(
                nameof(SelectedBackgroundOverlay),
                typeof(Brush),
                typeof(DreamineButton),
                new PropertyMetadata(new SolidColorBrush(Color.FromArgb(0x30, 0x00, 0x7A, 0xFF))));

        public IconPosition ImagePosition
        {
            get => (IconPosition)GetValue(ImagePositionProperty);
            set => SetValue(ImagePositionProperty, value);
        }

        public static readonly DependencyProperty ImagePositionProperty =
            DependencyProperty.Register(
                nameof(ImagePosition),
                typeof(IconPosition),
                typeof(DreamineButton),
                new FrameworkPropertyMetadata(
                    IconPosition.Left,
                    FrameworkPropertyMetadataOptions.AffectsMeasure |
                    FrameworkPropertyMetadataOptions.AffectsArrange));

        public bool OnceLogin
        {
            get => (bool)GetValue(OnceLoginProperty);
            set => SetValue(OnceLoginProperty, value);
        }

        public static readonly DependencyProperty OnceLoginProperty =
            DependencyProperty.Register(
                nameof(OnceLogin),
                typeof(bool),
                typeof(DreamineButton),
                new PropertyMetadata(false, OnOnceLoginChanged));

        private static void OnOnceLoginChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is DreamineButton)
                VsNavigationHelper.IsOnceLoginEnabled = (bool)e.NewValue;
        }

        static DreamineButton()
        {
            DefaultStyleKeyProperty.OverrideMetadata(
                typeof(DreamineButton),
                new FrameworkPropertyMetadata(typeof(DreamineButton)));
 
            try
            {
                var uri = new Uri("/Dreamine.UI.Wpf.Themes;component/DreamineButtonStyle.xaml",
                                  UriKind.RelativeOrAbsolute);
 
                var app = Application.Current;
                if (app != null)
                {
                    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);
                    }
                }
            }
            catch
            {
                // \brief Guard for design-time / missing resources, etc.
            }
 
        }

        public DreamineButton()
        {
        }

        public override void OnApplyTemplate()
        {
            base.OnApplyTemplate();
 
            _shadowHost = GetTemplateChild(PART_ShadowHost) as Border;
 
            // \brief If template part name mismatches, _shadowHost can be null.
            UpdateShadowEffect();
        }

        private void UpdateShadowEffect()
        {
            if (_shadowHost == null)
                return;
 
            if (!UseShadow)
            {
                _shadowHost.Effect = null;
                return;
            }
 
            // \brief Avoid background/brush interference: use Effect only on transparent host.
            _shadowHost.Effect = new DropShadowEffect
            {
                BlurRadius = ShadowBlurRadius,
                Opacity = ShadowOpacity,
                ShadowDepth = ShadowDepth,
                Direction = ShadowDirection,
                Color = ShadowColor
            };
        }

        public ImageSource ImageSource
        {
            get => (ImageSource)GetValue(ImageSourceProperty);
            set => SetValue(ImageSourceProperty, value);
        }

        public static readonly DependencyProperty ImageSourceProperty =
            DependencyProperty.Register(nameof(ImageSource), typeof(ImageSource), typeof(DreamineButton),
                new PropertyMetadata(null));

        public Geometry IconPath
        {
            get => (Geometry)GetValue(IconPathProperty);
            set => SetValue(IconPathProperty, value);
        }

        public static readonly DependencyProperty IconPathProperty =
            DependencyProperty.Register(nameof(IconPath), typeof(Geometry), typeof(DreamineButton),
                new PropertyMetadata(null));

        public new static readonly DependencyProperty CommandProperty =
            DependencyProperty.Register(
                nameof(Command),
                typeof(ICommand),
                typeof(DreamineButton),
                new PropertyMetadata(null, OnCommandChanged));

        public new ICommand Command
        {
            get => (ICommand)GetValue(CommandProperty);
            set => SetValue(CommandProperty, value);
        }

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

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

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

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

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

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

        private static bool GetIsHandlersHooked(DependencyObject d) => (bool)d.GetValue(IsHandlersHookedProperty);

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

        private static readonly DependencyProperty IsExecutingProperty =
            DependencyProperty.RegisterAttached("IsExecuting", typeof(bool), typeof(DreamineButton),
                new PropertyMetadata(false));

        private static bool GetIsExecuting(DependencyObject d) => (bool)d.GetValue(IsExecutingProperty);

        private static void SetIsExecuting(DependencyObject d, bool v) => d.SetValue(IsExecutingProperty, v);

        private static void OnCommandChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is not UIElement element) return;
            if (GetIsHandlersHooked(d)) return;
 
            element.AddHandler(UIElement.PreviewMouseUpEvent, new MouseButtonEventHandler((s, ev) =>
            {
                TryExecuteCommand(d, "PreviewMouseUp", ev);
            }), true);
 
            element.AddHandler(Control.MouseDoubleClickEvent, new MouseButtonEventHandler((s, ev) =>
            {
                TryExecuteCommand(d, "MouseDoubleClick", ev);
            }), true);
 
            element.AddHandler(UIElement.PreviewKeyUpEvent, new KeyEventHandler((s, ev) =>
            {
                TryExecuteCommand(d, "PreviewKeyUp", ev);
            }), true);
 
            element.AddHandler(UIElement.TouchUpEvent, new EventHandler<TouchEventArgs>((s, ev) =>
            {
                TryExecuteCommand(d, "TouchUp", ev);
            }));
 
            element.AddHandler(ButtonBase.ClickEvent, new RoutedEventHandler((s, ev) =>
            {
                TryExecuteCommand(d, "Click", ev);
            }));
 
            SetIsHandlersHooked(d, true);
        }

        private static async void TryExecuteCommand(DependencyObject d, string eventName, RoutedEventArgs eventArgs)
        {
            await Task.Yield();
 
            var rawTrigger = GetCommandTriggerName(d);
            if (string.IsNullOrWhiteSpace(rawTrigger))
                return;
 
            var triggers = rawTrigger
                .Split(',')
                .Select(s => s.Trim())
                .Where(s => !string.IsNullOrWhiteSpace(s))
                .ToArray();
 
            if (triggers.Length > 0 &&
                !triggers.Contains(eventName, StringComparer.OrdinalIgnoreCase))
                return;
 
            var command = GetCommand(d);
 
            // Resolve command parameter with a clear priority:
            // 1) DreamineButton attached CommandParameter.
            // 2) WPF ButtonBase.CommandParameter.
            // 3) RoutedEventArgs fallback.
            object? parameter = null;
 
            // 1) Attached CommandParameter (DreamineButton).
            parameter = GetCommandParameter(d);
 
            // 2) Standard WPF CommandParameter (ButtonBase).
            if (parameter == null && d is ButtonBase bbForParam)
                parameter = bbForParam.CommandParameter;
 
            // 3) Fallback to event args.
            if (parameter == null)
                parameter = eventArgs;
 
            // Prevent double invocation when ButtonBase.Command is already wired to the same ICommand.
            if (d is ButtonBase bb && command != null && ReferenceEquals(bb.Command, command))
                return;
 
            // Re-entrancy guard.
            if (GetIsExecuting(d))
                return;
 
            SetIsExecuting(d, true);
 
            try
            {
                if (d is DreamineButton btn)
                {
                    if (btn.MinimumGrade > 0 && btn.Grade < btn.MinimumGrade)
                    {
                        DreamineMessageBox.ShowAsync(
                            "권한이 부족합니다.",
                            "Access Denied",
                            autoClick: MessageBoxResult.OK,
                            autoClickDelaySeconds: 3);
                        return;
                    }
 
                    if (btn.DataContext is ButtonData btnData)
                        DreamineNavigationBar.NotifyButtonClicked(btnData);
                }
 
                if (command == null)
                    return;
 
                // Execute the command when the parameter is accepted.
                if (command.CanExecute(parameter))
                {
                    command.Execute(parameter);
                }
 
                eventArgs.Handled = true;
            }
            finally
            {
                SetIsExecuting(d, false);
            }
        }

        public static readonly DependencyProperty BackgroundTopProperty =
            DependencyProperty.Register(nameof(BackgroundTop), typeof(Brush), typeof(DreamineButton), new PropertyMetadata(null));

        public static readonly DependencyProperty ShineColorProperty =
            DependencyProperty.Register(nameof(ShineColor), typeof(Brush), typeof(DreamineButton), new PropertyMetadata(null));

        public static readonly DependencyProperty ShineColorBottomProperty =
            DependencyProperty.Register(nameof(ShineColorBottom), typeof(Brush), typeof(DreamineButton), new PropertyMetadata(null));

        public Brush BackgroundTop
        {
            get => (Brush)GetValue(BackgroundTopProperty);
            set => SetValue(BackgroundTopProperty, value);
        }

        public Brush ShineColor
        {
            get => (Brush)GetValue(ShineColorProperty);
            set => SetValue(ShineColorProperty, value);
        }

        public Brush ShineColorBottom
        {
            get => (Brush)GetValue(ShineColorBottomProperty);
            set => SetValue(ShineColorBottomProperty, value);
        }

        public static readonly DependencyProperty IsSelectedProperty =
            DependencyProperty.Register(nameof(IsSelected), typeof(bool), typeof(DreamineButton), new PropertyMetadata(false));

        public bool IsSelected
        {
            get => (bool)GetValue(IsSelectedProperty);
            set => SetValue(IsSelectedProperty, value);
        }

        public static readonly DependencyProperty IsFocusableExProperty =
            DependencyProperty.Register(nameof(IsFocusableEx), typeof(bool), typeof(DreamineButton), new PropertyMetadata(true));

        public bool IsFocusableEx
        {
            get => (bool)GetValue(IsFocusableExProperty);
            set => SetValue(IsFocusableExProperty, value);
        }

        public static readonly DependencyProperty RestoreFocusTargetProperty =
            DependencyProperty.Register(nameof(RestoreFocusTarget), typeof(IInputElement), typeof(DreamineButton), new PropertyMetadata(null));

        public IInputElement? RestoreFocusTarget
        {
            get => (IInputElement?)GetValue(RestoreFocusTargetProperty);
            set => SetValue(RestoreFocusTargetProperty, value);
        }

        public static readonly DependencyProperty GradeProperty =
            DependencyProperty.Register(nameof(Grade), typeof(int), typeof(DreamineButton), new PropertyMetadata(0));

        public int Grade
        {
            get => (int)GetValue(GradeProperty);
            set => SetValue(GradeProperty, value);
        }

        public static readonly DependencyProperty MinimumGradeProperty =
            DependencyProperty.Register(nameof(MinimumGrade), typeof(int), typeof(DreamineButton), new PropertyMetadata(0));

        public int MinimumGrade
        {
            get => (int)GetValue(MinimumGradeProperty);
            set => SetValue(MinimumGradeProperty, value);
        }

        public static readonly DependencyProperty UseSolidBackgroundProperty =
            DependencyProperty.Register(
                nameof(UseSolidBackground),
                typeof(bool),
                typeof(DreamineButton),
                new PropertyMetadata(false));

        public bool UseSolidBackground
        {
            get => (bool)GetValue(UseSolidBackgroundProperty);
            set => SetValue(UseSolidBackgroundProperty, value);
        }
 
        #endregion
    }
}