DreamineBlinkPopupWindow.xaml.cs

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

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Windows;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Threading;
using Dreamine.UI.Abstractions.Popup;
using Dreamine.UI.Wpf.Controls.MessageBox;
namespace Dreamine.UI.Wpf.Equipment.Popup
{
    internal enum PopupAction
    {
        None,

        Ok,

        Cancel,

        SystemClose
    }

    public partial class DreamineBlinkPopupWindow : Window
    {
        private readonly BlinkPopupOptions _opt;

        private Storyboard? _blinkSb;

        private bool? _requestedResult = null;

        public bool? PopupResult => _requestedResult;

        private bool _inClosing = false;

        private PopupAction _lastAction = PopupAction.None;

        private HwndSource? _hwndSrc;

        private const int WM_SYSCOMMAND = 0x0112;
        private const int SC_CLOSE = 0xF060;

        public DreamineBlinkPopupWindow(BlinkPopupOptions opt)
        {
            InitializeComponent();
            _opt = opt;
 
            // ViewModel 생성 및 닫힘 이벤트 연결
            var vm = new DreamineBlinkPopupWindowViewModel(opt);
            vm.CloseRequested += (_, dr) =>
            {
                _requestedResult = dr;
                _lastAction = dr == true
                    ? PopupAction.Ok
                    : dr == false
                        ? PopupAction.Cancel
                        : PopupAction.SystemClose;
 
                RequestCloseNextTick();
            };
            DataContext = vm;
 
            // TopMost / 기본 타이틀 적용
            Topmost = _opt.TopMost;
            if (!string.IsNullOrEmpty(_opt.Title))
            {
                Title = _opt.Title;
            }
 
            // 윈도우 크기 / 모드 설정
            if (_opt.Fullscreen)
            {
                WindowState = WindowState.Maximized;
            }
            else
            {
                WindowState = WindowState.Normal;
 
                if (_opt.FixedSize is Size sz)
                {
                    Width = sz.Width;
                    Height = sz.Height;
                }
                else
                {
                    SizeToContent = SizeToContent.WidthAndHeight;
                }
            }
        }

        protected override void OnContentRendered(EventArgs e)
        {
            base.OnContentRendered(e);
            if (_opt.UseBlink)
            {
                StartBlink();
            }
        }

        protected override void OnClosing(CancelEventArgs e)
        {
            if (_lastAction == PopupAction.None)
                _lastAction = PopupAction.SystemClose;
 
            if (_inClosing)
            {
                base.OnClosing(e);
                return;
            }
            _inClosing = true;
 
            try
            {
                if (_requestedResult.HasValue)
                {
                    try { DialogResult = _requestedResult; }
                    catch (InvalidOperationException) { }
                }
 
                base.OnClosing(e);
            }
            finally
            {
                _inClosing = false;
            }
        }

        protected override void OnSourceInitialized(EventArgs e)
        {
            base.OnSourceInitialized(e);
            _hwndSrc = PresentationSource.FromVisual(this) as HwndSource;
            _hwndSrc?.AddHook(WndProcHook);
        }

        protected override void OnPreviewKeyDown(KeyEventArgs e)
        {
            if (_opt.BlockAltF4 &&
                e.SystemKey == Key.F4 &&
                (Keyboard.Modifiers & ModifierKeys.Alt) == ModifierKeys.Alt)
            {
                e.Handled = true;
                return;
            }
 
            base.OnPreviewKeyDown(e);
        }

        private IntPtr WndProcHook(
            IntPtr hwnd,
            int msg,
            IntPtr wParam,
            IntPtr lParam,
            ref bool handled)
        {
            if (_opt.BlockAltF4 &&
                msg == WM_SYSCOMMAND &&
                wParam.ToInt32() == SC_CLOSE)
            {
                handled = true;
                return IntPtr.Zero;
            }
 
            return IntPtr.Zero;
        }

        private void RequestCloseNextTick()
        {
            if (!IsLoaded)
            {
                return;
            }
 
            var timer = new DispatcherTimer(DispatcherPriority.ApplicationIdle)
            {
                Interval = TimeSpan.FromMilliseconds(1)
            };
 
            timer.Tick += (_, __) =>
            {
                timer.Stop();
 
                if (!IsLoaded)
                {
                    return;
                }
 
                try
                {
                    Close();
                }
                catch (Exception ex)
                {
                    Debug.WriteLine($"[Popup] Close failed, retrying: {ex.Message}");
                    Dispatcher.BeginInvoke(
                        () =>
                        {
                            try { if (IsLoaded) Close(); }
                            catch (Exception retryEx) { Debug.WriteLine($"[Popup] Close retry failed: {retryEx.Message}"); }
                        },
                        DispatcherPriority.ContextIdle);
                }
            };
 
            timer.Start();
        }

        protected override void OnClosed(EventArgs e)
        {
            base.OnClosed(e);
            StopBlink();
        }

        private void StartBlink()
        {
            var rootBrushObj = Resources["RootBrush"];
            SolidColorBrush brush =
                rootBrushObj is SolidColorBrush scb
                    ? (scb.IsFrozen ? scb.Clone() : scb)
                    : new SolidColorBrush(_opt.Color1);
 
            Resources["RootBrush"] = brush;
 
            var colorAnim = new ColorAnimationUsingKeyFrames();
            colorAnim.KeyFrames.Add(
                new DiscreteColorKeyFrame(
                    _opt.Color1,
                    KeyTime.FromTimeSpan(TimeSpan.Zero)));
            colorAnim.KeyFrames.Add(
                new DiscreteColorKeyFrame(
                    _opt.Color2,
                    KeyTime.FromTimeSpan(TimeSpan.FromMilliseconds(_opt.BlinkIntervalMs))));
            colorAnim.KeyFrames.Add(
                new DiscreteColorKeyFrame(
                    _opt.Color1,
                    KeyTime.FromTimeSpan(TimeSpan.FromMilliseconds(_opt.BlinkIntervalMs * 2))));
 
            Storyboard.SetTarget(colorAnim, brush);
            Storyboard.SetTargetProperty(colorAnim, new PropertyPath(SolidColorBrush.ColorProperty));
 
            var opAnim = new DoubleAnimationUsingKeyFrames();
            opAnim.KeyFrames.Add(
                new DiscreteDoubleKeyFrame(
                    _opt.Opacity1,
                    KeyTime.FromTimeSpan(TimeSpan.Zero)));
            opAnim.KeyFrames.Add(
                new DiscreteDoubleKeyFrame(
                    _opt.Opacity2,
                    KeyTime.FromTimeSpan(TimeSpan.FromMilliseconds(_opt.BlinkIntervalMs))));
            opAnim.KeyFrames.Add(
                new DiscreteDoubleKeyFrame(
                    _opt.Opacity1,
                    KeyTime.FromTimeSpan(TimeSpan.FromMilliseconds(_opt.BlinkIntervalMs * 2))));
 
            Storyboard.SetTarget(opAnim, RootBorder);
            Storyboard.SetTargetProperty(opAnim, new PropertyPath(OpacityProperty));
 
            _blinkSb = new Storyboard
            {
                RepeatBehavior = _opt.BlinkRepeatCount <= 0
                    ? RepeatBehavior.Forever
                    : new RepeatBehavior(_opt.BlinkRepeatCount)
            };
            _blinkSb.Children.Add(colorAnim);
            _blinkSb.Children.Add(opAnim);
            _blinkSb.Begin(this, true);
        }

        private void StopBlink()
        {
            _blinkSb?.Stop(this);
            _blinkSb = null;
 
            _hwndSrc?.RemoveHook(WndProcHook);
            _hwndSrc = null;
        }
    }
}