DreamineNavigationBar.xaml.cs

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

using Dreamine.MVVM.ViewModels;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Threading;
using Dreamine.UI.Wpf.Controls.MessageBox;
using Dreamine.UI.Wpf.Localization;
 
namespace Dreamine.UI.Wpf.Controls.Navigation
{
    public class DesignButtonDatas : ObservableCollection<ButtonData>
    {
        public DesignButtonDatas()
        {
            Add(new ButtonData { Content = "LoginAsync" });
            Add(new ButtonData { Content = "Main" });
            Add(new ButtonData { Content = "Manual" });
            Add(new ButtonData { Content = "Setting" });
            Add(new ButtonData { Content = "Register" });
            Add(new ButtonData { Content = "About", Visibility = Visibility.Hidden });
            Add(new ButtonData { Content = "About", Visibility = Visibility.Hidden });
            Add(new ButtonData { Content = "About", Visibility = Visibility.Hidden });
            Add(new ButtonData { Content = "About", Visibility = Visibility.Hidden });
            Add(new ButtonData { Content = "Exit" });
 
            this[Count - 1].Margin = new Thickness(0);
        }
    }

    public partial class DreamineNavigationBar : UserControl
    {
        public static event EventHandler? AutoLogoutOccurred;

        public int AutoLogoutTimeout
        {
            get => (int)GetValue(AutoLogoutTimeoutProperty);
            set => SetValue(AutoLogoutTimeoutProperty, value);
        }

        public static readonly DependencyProperty AutoLogoutTimeoutProperty =
            DependencyProperty.Register(
                nameof(AutoLogoutTimeout),
                typeof(int),
                typeof(DreamineNavigationBar),
                new PropertyMetadata(0, OnAutoLogoutTimeoutChanged));

        private static void OnAutoLogoutTimeoutChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is DreamineNavigationBar nav)
            {
                nav.ResetLogoutTimerIfNeeded();
            }
        }

        private static readonly HashSet<DreamineNavigationBar> _instances = new();

        private static volatile bool _isInputHooked = false;

        private static void EnsureGlobalInputHook()
        {
            if (_isInputHooked == false)
            {
                InputManager.Current.PreProcessInput += OnGlobalInputStatic;
                _isInputHooked = true;
            }
        }

        private static void OnGlobalInputStatic(object sender, PreProcessInputEventArgs e)
        {
            if (e.StagingItem.Input is MouseEventArgs or KeyboardEventArgs or TouchEventArgs)
            {
                foreach (var nav in _instances)
                {
                    if (nav.AutoLogoutTimeout > 0)
                        nav.InitializeOrResetLogoutTimer();
                }
            }
        }

        private DispatcherTimer? _logoutTimer;

        private void ResetLogoutTimerIfNeeded()
        {
            if (AutoLogoutTimeout > 0)
                InitializeOrResetLogoutTimer();
            else
                StopLogoutTimer();
        }

        public void InitializeOrResetLogoutTimer()
        {
            if (_logoutTimer == null)
            {
                _logoutTimer = new DispatcherTimer
                {
                    Interval = TimeSpan.FromSeconds(AutoLogoutTimeout)
                };
                _logoutTimer.Tick += (s, e) =>
                {
                    _logoutTimer.Stop();
 
                    OnAutoLogout();
                };
            }
 
            _logoutTimer.Stop();
            _logoutTimer.Interval = TimeSpan.FromSeconds(AutoLogoutTimeout);
            _logoutTimer.Start();
        }

        private void StopLogoutTimer()
        {
            _logoutTimer?.Stop();
        }

        private void OnAutoLogout()
        {
            foreach (Window window in Application.Current.Windows)
            {
                if (window.Owner != null && window.IsVisible)
                    window.Hide();
            }
 
            foreach (var btn in ButtonDatas)
                btn.Grade = 0;
 
            AutoLogoutOccurred?.Invoke(this, EventArgs.Empty);
 
            DreamineMessageBox.ShowAsync(
                "You have been automatically logged out due to inactivity.",
                "Auto Logout",
                MessageBoxButton.OK,
                MessageBoxImage.Information,
                autoClick: MessageBoxResult.OK,
                autoClickDelaySeconds: 5);
        }

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

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

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

        public DreamineNavigationBar()
        {
            InitializeComponent();
 
            if (ButtonDatas == null)
                ButtonDatas = new ObservableCollection<ButtonData>();
 
            EnsureGlobalInputHook();
            _instances.Add(this);
            Unloaded += (_, _) => _instances.Remove(this);
 
            // Window.Closed 보장: Unloaded가 발생하지 않을 때도 GC 루트 제거
            Loaded += (_, _) =>
            {
                var parentWindow = Window.GetWindow(this);
                if (parentWindow != null)
                    parentWindow.Closed += (_, _) => _instances.Remove(this);
            };
        }

        public new Language Language
        {
            get => (Language)GetValue(LanguageProperty);
            set => SetValue(LanguageProperty, value);
        }

        public static readonly new DependencyProperty LanguageProperty =
            DependencyProperty.Register(nameof(Language), typeof(Language), typeof(DreamineNavigationBar), new PropertyMetadata(Language.English));

        public ObservableCollection<ButtonData> ButtonDatas
        {
            get => (ObservableCollection<ButtonData>)GetValue(ButtonDatasProperty);
            set => SetValue(ButtonDatasProperty, value);
        }

        public static readonly DependencyProperty ButtonDatasProperty =
            DependencyProperty.Register(
                nameof(ButtonDatas),
                typeof(ObservableCollection<ButtonData>),
                typeof(DreamineNavigationBar),
                new PropertyMetadata(new ObservableCollection<ButtonData>(), OnButtonDatasChanged));

        private static void OnButtonDatasChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is DreamineNavigationBar nav)
            {
                if (e.OldValue is ObservableCollection<ButtonData> oldList)
                    oldList.CollectionChanged -= nav.ButtonDatas_CollectionChanged;
 
                if (e.NewValue is ObservableCollection<ButtonData> newList)
                    newList.CollectionChanged += nav.ButtonDatas_CollectionChanged;
 
                nav.UpdateMarginAndAlignment();
            }
        }

        private void ButtonDatas_CollectionChanged(object? sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            UpdateMarginAndAlignment();
        }

        public NavigationBarPosition Position
        {
            get => (NavigationBarPosition)GetValue(PositionProperty);
            set => SetValue(PositionProperty, value);
        }

        public static readonly DependencyProperty PositionProperty =
            DependencyProperty.Register(
                nameof(Position),
                typeof(NavigationBarPosition),
                typeof(DreamineNavigationBar),
                new PropertyMetadata(NavigationBarPosition.Top, OnPositionChanged));

        private static void OnPositionChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is DreamineNavigationBar nav)
                nav.UpdateMarginAndAlignment();
        }

        private void UpdateMarginAndAlignment()
        {
            Thickness defaultMargin = Position switch
            {
                NavigationBarPosition.Right => new Thickness(0, 0, 0, 4),
                NavigationBarPosition.Left => new Thickness(0, 0, 0, 4),
                _ => new Thickness(0, 0, 4, 0)
            };
            Thickness lastMargin = Position switch
            {
                NavigationBarPosition.Right => new Thickness(0, 0, 0, 4),
                NavigationBarPosition.Left => new Thickness(0, 0, 0, 4),
                _ => new Thickness(0)
            };
 
            ApplyLastButtonMargin(defaultMargin, lastMargin);
        }

        private void ApplyLastButtonMargin(Thickness defaultMargin, Thickness lastMargin)
        {
            if (ButtonDatas == null || ButtonDatas.Count == 0)
                return;
 
            var visibleIndices = ButtonDatas
                .Select((btn, idx) => new { btn, idx })
                .Where(x => x.btn.Visibility == Visibility.Visible)
                .Select(x => x.idx)
                .ToList();
 
            if (visibleIndices.Count == 0)
                return;
 
            foreach (var btn in ButtonDatas)
            {
                btn.Margin = defaultMargin;
            }
            ButtonDatas[visibleIndices.Last()].Margin = lastMargin;
        }

        public static void NotifyButtonClicked(ButtonData clickedButton)
        {
            var navBars = Application.Current.Windows
                .OfType<Window>()
                .SelectMany(w => FindVisualChildren<DreamineNavigationBar>(w))
                .ToList();
 
            ButtonData buttonData = null!;
 
            foreach (var nav in navBars)
            {
                if (!nav.ButtonDatas.Contains(clickedButton))
                    continue;
 
                foreach (var btn in nav.ButtonDatas)
                {
                    if (btn.IsSelected == true && btn.IsFocusableEx == true)
                    {
                        buttonData = btn;
                    }
                    btn.IsSelected = false;
                }
                if (clickedButton.IsFocusableEx)
                {
                    clickedButton.IsSelected = true;
                }
                else
                {
                    foreach (var btn in nav.ButtonDatas)
                    {
                        if (btn == buttonData)
                        {
                            btn.IsSelected = true;
                        }
                    }
                }
            }
        }

        private static IEnumerable<T> FindVisualChildren<T>(DependencyObject depObj) where T : DependencyObject
        {
            if (depObj == null)
                yield break;
 
            for (int i = 0; i < VisualTreeHelper.GetChildrenCount(depObj); i++)
            {
                DependencyObject child = VisualTreeHelper.GetChild(depObj, i);
 
                if (child is T t)
                    yield return t;
 
                foreach (var childOfChild in FindVisualChildren<T>(child))
                    yield return childOfChild;
            }
        }

        private void DreamineButton_Click(object sender, RoutedEventArgs e)
        {
        }
    }

    public enum NavigationBarPosition
    {
        Top,
        Bottom,
        Left,
        Right
    }

    public class ButtonData : ViewModelBase
    {
        private string _content = string.Empty;
        public string Content { get => _content; set { if (SetProperty(ref _content, value)) OnPropertyChanged(nameof(ImageSource)); } }

        private string _imagePath = string.Empty;
        public string ImagePath
        {
            get => _imagePath;
            set { if (SetProperty(ref _imagePath, value)) OnPropertyChanged(nameof(ImageSource)); }
        }

        public ImageSource ImageSource
        {
            get
            {
                if (string.IsNullOrWhiteSpace(ImagePath)) return null!;
                try { return new BitmapImage(new Uri(ImagePath, UriKind.RelativeOrAbsolute)); }
                catch (Exception ex) { Debug.WriteLine($"[ButtonData] ImageSource 로드 실패({ImagePath}): {ex.Message}"); return null!; }
            }
        }

        private Brush _foreground = Brushes.Black;
        public Brush Foreground { get => _foreground; set => SetProperty(ref _foreground, value); }

        private Brush _shineColor = Brushes.LightBlue;
        public Brush ShineColor { get => _shineColor; set => SetProperty(ref _shineColor, value); }

        private Brush _shineColorBottom = Brushes.White;
        public Brush ShineColorBottom { get => _shineColorBottom; set => SetProperty(ref _shineColorBottom, value); }

        private Brush _backgroundTop = Brushes.Wheat;
        public Brush BackgroundTop { get => _backgroundTop; set => SetProperty(ref _backgroundTop, value); }

        private Brush _background = Brushes.DarkBlue;
        public Brush Background { get => _background; set => SetProperty(ref _background, value); }

        public IconPosition ImagePosition { get; set; } = IconPosition.Left;

        private bool _isEnabled = true;
        public bool IsEnabled { get => _isEnabled; set => SetProperty(ref _isEnabled, value); }

        public FontWeight FontWeight { get; set; } = FontWeights.Normal;
        public Visibility Visibility { get; set; } = Visibility.Visible;
        public Thickness Margin { get; set; } = new Thickness(0, 0, 4, 0);
        public object CommandParameter { get; set; } = null!;
        public IInputElement CommandTarget { get; set; } = null!;

        private ICommand? _command;
        public ICommand? Command { get => _command; set => SetProperty(ref _command, value); }

        private bool _isSelected = false;
        public bool IsSelected { get => _isSelected; set => SetProperty(ref _isSelected, value); }

        private bool _isFocusableEx = true;
        public bool IsFocusableEx { get => _isFocusableEx; set => SetProperty(ref _isFocusableEx, value); }

        private int _grade = 0;
        public int Grade { get => _grade; set => SetProperty(ref _grade, value); }

        private int _minimumGrade = 0;
        public int MinimumGrade { get => _minimumGrade; set => SetProperty(ref _minimumGrade, value); }
    }

    public static class VsNavigationHelper
    {
        public static bool IsOnceLoginEnabled { get; set; } = false;

        public static object? CurrentUser { get; set; } = null;

        public static ButtonData Create(
            string content,
            ICommand? command = null,
            int minGrade = 0,
            string? imagePath = null,
            bool isSelected = false,
            bool isFocusable = true,
            Visibility visibility = Visibility.Visible,
            IconPosition imagePosition = IconPosition.Top)
        {
            return new ButtonData
            {
                Content = content,
                Command = command,
                MinimumGrade = minGrade,
                ImagePath = imagePath!,
                ImagePosition = imagePosition,
                FontWeight = FontWeights.Bold,
                Foreground = GetColor("#143a5a"),
                ShineColor = GetColor("#104E8B"),
                ShineColorBottom = Brushes.White,
                BackgroundTop = Brushes.White,
                Background = Brushes.LightGray,
                IsSelected = isSelected,
                IsFocusableEx = isFocusable,
                Visibility = visibility
            };
        }

        private static SolidColorBrush GetColor(string hex)
        {
            return new SolidColorBrush((Color)ColorConverter.ConvertFromString(hex));
        }
    }
}