MainWindow.xaml.cs

using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Threading;
using System.Collections.ObjectModel;
using System.Diagnostics;

namespace WindowThumbWall;

public partial class MainWindow : Window
{
    private const int AutoAddMaintenanceIntervalTicks = 4;
    private const string SlotDragFormat = "WindowThumbWall.SlotIndex";
    private const double DeadspaceWeight = 1.0;
    private const double DistortionWeight = 0.9;
    private const double SlotTitleFontSize = 12;
    private static readonly Thickness CellMargin = new(2);
    private static readonly Thickness CellBorderThickness = new(1);
    private static readonly Thickness SlotLabelPadding = new(6, 3, 6, 3);
    private static readonly TimeSpan ThumbnailUpdateMinInterval = TimeSpan.FromMilliseconds(50);
    private static readonly TimeSpan ThumbnailRefreshDebounce = TimeSpan.FromMilliseconds(160);
    private static readonly TimeSpan ThumbnailRefreshMinInterval = TimeSpan.FromMilliseconds(1500);

    private IntPtr _mainHwnd;

    private readonly List<Border> _cellBorders = [];
    private readonly List<TextBlock> _cellLabels = [];
    private readonly List<Border> _cellHitLayers = [];
    private readonly List<ThumbHost> _cellHosts = [];
    private readonly List<ThumbnailSlot> _slots = [];

    private Point _dragStartPoint;
    private int _dragSourceIndex = -1;
    private bool _dragMoved;
    private Border? _dropPreviewLayer;
    private Window? _dragGhost;
    private ShortcutGuideWindow? _shortcutGuideWindow;

    private bool _isFullScreen;
    private WindowStyle _savedWindowStyle;
    private WindowState _savedWindowState;
    private GridLength _savedLeftColWidth;
    private GridLength _savedSplitterColWidth;

    private readonly DispatcherTimer _timer = new() { Interval = TimeSpan.FromMilliseconds(1000) };
    private readonly DispatcherTimer _stateSaveTimer = new() { Interval = TimeSpan.FromMilliseconds(400) };
    private readonly DispatcherTimer _thumbnailSettleTimer = new() { Interval = TimeSpan.FromMilliseconds(120) };
    private readonly DispatcherTimer _thumbnailThrottleTimer = new();
    private readonly DispatcherTimer _thumbnailRefreshTimer = new() { Interval = ThumbnailRefreshDebounce };
    private readonly List<WindowInfo> _windowCache = [];
    private readonly ObservableCollection<AutoAddAppEntry> _autoAddApps = [];
    private readonly HashSet<string> _autoAddAppSet = new(StringComparer.OrdinalIgnoreCase);
    private readonly Dictionary<string, string> _appDisplayNameCache = new(StringComparer.OrdinalIgnoreCase);
    private Point _appListDragStartPoint;
    private string? _appListDragSourceProcessName;
    private int _autoAddMaintenanceTick;
    private bool _notificationAttentionRequested;
    private bool _notificationAttentionEnabled;

    private uint _shellHookMsgId;
    private readonly HashSet<IntPtr> _flashingWindows = [];
    private readonly List<AttentionVisualState> _slotAttentionVisualStates = [];
    private IntPtr _activeSourceHwnd;
    private static readonly SolidColorBrush NormalBorderBrush =
        new(Color.FromRgb(0x55, 0x55, 0x55));
    private static readonly SolidColorBrush ActiveBorderBrush = new(Colors.White);
    private static readonly Thickness ActiveBorderThickness = new(2);
    private static readonly Thickness AttentionBorderThickness = new(3);
    static MainWindow()
    {
        NormalBorderBrush.Freeze();
        ActiveBorderBrush.Freeze();
    }

    private AppState? _pendingRestore;
    private bool _stateTrackingEnabled;
    private bool _gridRebuildPending;
    private bool _thumbnailUpdatePending;
    private bool _thumbnailUpdateRequestedWhilePending;
    private int _lastGridItemCount = -1;
    private int _lastGridRows = -1;
    private int _lastGridCols = -1;
    private long _lastThumbnailUpdateTicks;
    private readonly HashSet<IntPtr> _thumbnailRefreshPendingWindows = [];
    private readonly Dictionary<IntPtr, long> _lastThumbnailRefreshTicks = [];

    public MainWindow()
    {
        InitializeComponent();
        ApplyLocalization();

        // Restore window geometry before the window is shown.
        _pendingRestore = AppState.Load();
        _notificationAttentionRequested = _pendingRestore.EnableOsNotificationAttention;
        _notificationAttentionEnabled = _notificationAttentionRequested && SupportsNotificationAttentionRuntime();
        if (_pendingRestore.Geometry is { Width: > 0, Height: > 0 } geo)
        {
            WindowStartupLocation = WindowStartupLocation.Manual;
            Left = geo.Left;
            Top = geo.Top;
            Width = geo.Width;
            Height = geo.Height;
            if (geo.IsMaximized)
                WindowState = WindowState.Maximized;
        }

        _timer.Tick += Timer_Tick;
        InitializeNotificationFollowUpTimer();
        _stateSaveTimer.Tick += StateSaveTimer_Tick;
        _thumbnailSettleTimer.Tick += ThumbnailSettleTimer_Tick;
        _thumbnailThrottleTimer.Tick += ThumbnailThrottleTimer_Tick;
        _thumbnailRefreshTimer.Tick += ThumbnailRefreshTimer_Tick;
        Loaded += OnLoaded;
        Closed += OnClosed;
        LocationChanged += OnLocationChanged;
        SizeChanged += OnSizeChanged;
        LeftPanel.SizeChanged += OnPanelSizeChanged;
        AppList.SizeChanged += OnPanelSizeChanged;
        ThumbGrid.SizeChanged += OnThumbGridSizeChanged;
        WindowList.MouseDoubleClick += WindowList_DoubleClick;
        WindowList.PreviewMouseRightButtonDown += WindowList_RightClick;
        AppList.PreviewMouseRightButtonDown += AppList_RightClick;
        AppList.PreviewMouseLeftButtonDown += AppList_PreviewMouseLeftButtonDown;
        AppList.PreviewMouseMove += AppList_PreviewMouseMove;
        AppList.DragOver += AppList_DragOver;
        AppList.Drop += AppList_Drop;
        FilterBox.TextChanged += FilterBox_TextChanged;
        AppList.ItemsSource = _autoAddApps;
    }

    // Lifecycle

    private void OnLoaded(object sender, RoutedEventArgs e)
    {
        _mainHwnd = new WindowInteropHelper(this).Handle;

        // Register for shell hook messages (flash / activation).
        _shellHookMsgId = NativeMethods.RegisterWindowMessage("SHELLHOOK");
        NativeMethods.RegisterShellHookWindow(_mainHwnd);
        HwndSource.FromHwnd(_mainHwnd)?.AddHook(WndProc);

        RestorePanelLayout();
        RestoreAutoAddApps();
        RestoreSlots();
        SyncActiveSourceWindow(forceRefresh: true);
        if (_notificationAttentionEnabled)
            InitializeNotificationListenerAsync();
        _timer.Start();
        _stateTrackingEnabled = true;
    }

    private void OnClosed(object? sender, EventArgs e)
    {
        _timer.Stop();
        _notificationFollowUpTimer.Stop();
        _stateSaveTimer.Stop();
        _thumbnailSettleTimer.Stop();
        _thumbnailThrottleTimer.Stop();
        _thumbnailRefreshTimer.Stop();
        _stateTrackingEnabled = false;
        DisposeNotificationListener();
        NativeMethods.DeregisterShellHookWindow(_mainHwnd);
        SaveState();
        foreach (var slot in _slots) slot.Clear();
    }

    private void OnSizeChanged(object sender, SizeChangedEventArgs e)
    {
        RequestStateSave();
        RequestGridRebuild();
    }

    private void OnLocationChanged(object? sender, EventArgs e) => RequestStateSave();

    private void OnPanelSizeChanged(object sender, SizeChangedEventArgs e)
    {
        if (e.WidthChanged || e.HeightChanged)
        {
            RequestStateSave();
            RequestGridRebuild();
        }
    }

    private void OnThumbGridSizeChanged(object sender, SizeChangedEventArgs e)
    {
        if (!e.WidthChanged && !e.HeightChanged)
            return;

        RequestGridRebuild();
        ScheduleThumbnailSettle();
    }

    // State persistence

    private void SaveState()
    {
        var bounds = (WindowState == WindowState.Maximized || _isFullScreen)
            ? RestoreBounds
            : new Rect(Left, Top, Width, Height);

        var state = new AppState
        {
            IsFullScreen = _isFullScreen,
            Geometry = new WindowGeometry
            {
                Left = bounds.Left,
                Top = bounds.Top,
                Width = bounds.Width,
                Height = bounds.Height,
                IsMaximized = !_isFullScreen && WindowState == WindowState.Maximized
            },
            LeftPanelWidth = GetPersistedLength(
                _isFullScreen ? _savedLeftColWidth : LeftColumnDefinition.Width,
                LeftPanel.ActualWidth),
            AppListHeight = GetPersistedLength(AppListRowDefinition.Height, AppList.ActualHeight),
            EnableOsNotificationAttention = _notificationAttentionRequested
        };

        foreach (var slot in _slots)
        {
            if (!slot.IsOccupied) continue;
            state.Slots.Add(new SlotState
            {
                ProcessName = slot.SourceProcessName,
                Title = slot.SourceTitle
            });
        }

        foreach (var app in _autoAddApps)
            state.AutoAddApps.Add(app.ProcessName);

        state.Save();
    }

    private void RequestStateSave()
    {
        if (!_stateTrackingEnabled) return;
        _stateSaveTimer.Stop();
        _stateSaveTimer.Start();
    }

    private void StateSaveTimer_Tick(object? sender, EventArgs e)
    {
        _stateSaveTimer.Stop();
        SaveState();
    }

    private void RestorePanelLayout()
    {
        if (_pendingRestore == null) return;

        if (_pendingRestore.LeftPanelWidth > 120)
            LeftColumnDefinition.Width = new GridLength(_pendingRestore.LeftPanelWidth);

        if (_pendingRestore.AppListHeight > 80)
            AppListRowDefinition.Height = new GridLength(_pendingRestore.AppListHeight);
    }

    private static double GetPersistedLength(GridLength gridLength, double actualFallback)
    {
        if (gridLength.IsAbsolute && gridLength.Value > 0)
            return gridLength.Value;
        return actualFallback > 0 ? actualFallback : 0;
    }

    private void RestoreAutoAddApps()
    {
        if (_pendingRestore is not { AutoAddApps.Count: > 0 } state) return;

        foreach (var app in state.AutoAddApps)
            AddAppToAutoList(app);
    }

    private void RestoreSlots()
    {
        if (_pendingRestore is not { Slots.Count: > 0 } state)
        {
            _pendingRestore = null;
            return;
        }

        // Enumerate all current windows.
        var allWindows = new List<(IntPtr Handle, string Title, string ProcessName)>();
        NativeMethods.EnumWindows((hWnd, _) =>
        {
            if (hWnd == _mainHwnd) return true;
            if (!NativeMethods.IsAltTabWindow(hWnd)) return true;
            allWindows.Add((hWnd, NativeMethods.GetWindowTitle(hWnd), NativeMethods.GetProcessName(hWnd)));
            return true;
        }, IntPtr.Zero);

        var usedHandles = new HashSet<IntPtr>();

        foreach (var saved in state.Slots)
        {
            // 1. Exact match: same process + same title.
            var match = allWindows.FirstOrDefault(w =>
                !usedHandles.Contains(w.Handle) &&
                w.ProcessName.Equals(saved.ProcessName, StringComparison.OrdinalIgnoreCase) &&
                w.Title == saved.Title);

            // 2. Fallback: same process name, any title.
            if (match.Handle == IntPtr.Zero)
            {
                match = allWindows.FirstOrDefault(w =>
                    !usedHandles.Contains(w.Handle) &&
                    w.ProcessName.Equals(saved.ProcessName, StringComparison.OrdinalIgnoreCase));
            }

            if (match.Handle == IntPtr.Zero) continue;

            usedHandles.Add(match.Handle);
            int idx = AddSlot();
            AssignSlot(idx, match.Handle, match.Title, match.ProcessName);
        }

        if (state.IsFullScreen && _slots.Count > 0)
            ToggleFullScreen();

        _pendingRestore = null;
    }

    // Keyboard

    protected override void OnPreviewKeyDown(KeyEventArgs e)
    {
        switch (e.Key)
        {
            case Key.Enter when _isFullScreen || !FilterBox.IsFocused:
                ToggleFullScreen();
                e.Handled = true;
                break;
            case Key.Escape when _isFullScreen:
                ToggleFullScreen();
                e.Handled = true;
                break;
        }
        base.OnPreviewKeyDown(e);
    }

    // Dynamic grid

    private (int rows, int cols) CalcGridSize(int count)
    {
        if (count <= 0) return (1, 1);

        double width = Math.Max(ThumbGrid.ActualWidth, 1);
        double height = Math.Max(ThumbGrid.ActualHeight, 1);

        if (width <= 1 || height <= 1)
        {
            int fallbackCols = (int)Math.Ceiling(Math.Sqrt(count));
            int fallbackRows = (int)Math.Ceiling((double)count / fallbackCols);
            return (fallbackRows, fallbackCols);
        }

        double titleBarHeight = EstimateTitleBarHeight();
        double horizontalChrome = CellMargin.Left + CellMargin.Right + CellBorderThickness.Left + CellBorderThickness.Right;
        double verticalChrome = CellMargin.Top + CellMargin.Bottom + CellBorderThickness.Top + CellBorderThickness.Bottom;
        double fallbackAspectRatio =
            Math.Max(width - horizontalChrome, 0.01) /
            Math.Max(height - verticalChrome - titleBarHeight, 0.01);
        var aspectRatios = CollectActiveAspectRatios(fallbackAspectRatio);

        return GridLayoutScorer.ChooseGrid(
            count,
            width,
            height,
            aspectRatios,
            titleBarHeight,
            horizontalChrome,
            verticalChrome,
            DeadspaceWeight,
            DistortionWeight);
    }

    private List<double> CollectActiveAspectRatios(double fallback)
    {
        var ratios = new List<double>();
        for (int i = 0; i < _slots.Count; i++)
        {
            if (!_slots[i].IsOccupied) continue;
            double ratio = NativeMethods.GetWindowAspectRatio(_slots[i].SourceHwnd, fallback);
            if (ratio > 0.01)
                ratios.Add(ratio);
        }

        if (ratios.Count == 0)
            ratios.Add(Math.Max(fallback, 0.01));

        return ratios;
    }

    private double EstimateTitleBarHeight()
    {
        double measuredHeight = 0;
        for (int i = 0; i < _cellLabels.Count; i++)
        {
            measuredHeight = Math.Max(measuredHeight, _cellLabels[i].ActualHeight);
        }

        if (measuredHeight > 0)
            return measuredHeight;

        var probe = new TextBlock
        {
            Text = LocalizedText.Get("slot.empty"),
            Padding = SlotLabelPadding,
            FontSize = SlotTitleFontSize,
            TextTrimming = TextTrimming.CharacterEllipsis
        };
        probe.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
        return Math.Max(probe.DesiredSize.Height, 0.01);
    }

    private int AddSlot()
    {
        int idx = _cellBorders.Count;

        var label = new TextBlock
        {
            Text = LocalizedText.Get("slot.empty"),
            Foreground = Brushes.LightGray,
            Padding = SlotLabelPadding,
            FontSize = SlotTitleFontSize,
            TextTrimming = TextTrimming.CharacterEllipsis
        };

        var titleBar = new Border
        {
            Background = new SolidColorBrush(Color.FromRgb(0x33, 0x33, 0x33)),
            Child = label,
            Cursor = Cursors.Arrow
        };
        DockPanel.SetDock(titleBar, Dock.Top);

        var host = new ThumbHost();

        var panel = new DockPanel();
        panel.Children.Add(titleBar);
        panel.Children.Add(host);

        var hitLayer = new Border
        {
            Background = new SolidColorBrush(Color.FromArgb(1, 255, 255, 255)),
            Tag = idx,
            Cursor = Cursors.Hand,
            AllowDrop = true
        };
        hitLayer.PreviewMouseLeftButtonDown += Cell_PreviewMouseLeftButtonDown;
        hitLayer.PreviewMouseMove += Cell_PreviewMouseMove;
        hitLayer.PreviewMouseLeftButtonUp += Cell_PreviewMouseLeftButtonUp;
        hitLayer.MouseRightButtonDown += Cell_RightClick;
        hitLayer.DragOver += Cell_DragOver;
        hitLayer.Drop += Cell_Drop;
        hitLayer.DragLeave += Cell_DragLeave;
        hitLayer.SizeChanged += CellLayout_SizeChanged;

        var cellRoot = new Grid();
        cellRoot.Children.Add(panel);
        cellRoot.Children.Add(hitLayer);

        var border = new Border
        {
            BorderBrush = new SolidColorBrush(Color.FromRgb(0x55, 0x55, 0x55)),
            BorderThickness = CellBorderThickness,
            Margin = CellMargin,
            Background = Brushes.Black,
            Child = cellRoot,
            Tag = idx,
            Cursor = Cursors.Arrow
        };
        border.SizeChanged += CellLayout_SizeChanged;
        host.SizeChanged += CellLayout_SizeChanged;
        ThumbGrid.Children.Add(border);
        _cellBorders.Add(border);
        _cellLabels.Add(label);
        _cellHitLayers.Add(hitLayer);
        _cellHosts.Add(host);
        _slotAttentionVisualStates.Add(AttentionVisualState.None);

        RebuildGrid();

        // Force layout so BuildWindowCore runs and the HWND is ready.
        ThumbGrid.UpdateLayout();

        _slots.Add(new ThumbnailSlot(host, _mainHwnd));
        return idx;
    }

    private void RemoveSlot(int idx)
    {
        IntPtr sourceHwnd = _slots[idx].SourceHwnd;
        ClearNotificationAttentionGroupsForWindow(sourceHwnd);
        _flashingWindows.Remove(sourceHwnd);
        _thumbnailRefreshPendingWindows.Remove(sourceHwnd);
        _lastThumbnailRefreshTicks.Remove(sourceHwnd);
        _slots[idx].Clear();
        _cellBorders[idx].SizeChanged -= CellLayout_SizeChanged;
        _cellHitLayers[idx].SizeChanged -= CellLayout_SizeChanged;
        _cellHosts[idx].SizeChanged -= CellLayout_SizeChanged;
        ThumbGrid.Children.Remove(_cellBorders[idx]);
        _cellHosts[idx].Dispose();

        _cellBorders.RemoveAt(idx);
        _cellLabels.RemoveAt(idx);
        _cellHitLayers.RemoveAt(idx);
        _cellHosts.RemoveAt(idx);
        _slots.RemoveAt(idx);
        _slotAttentionVisualStates.RemoveAt(idx);
        SyncActiveSourceWindow(forceRefresh: true);

        for (int i = 0; i < _cellBorders.Count; i++)
        {
            _cellBorders[i].Tag = i;
            _cellHitLayers[i].Tag = i;
        }

        RebuildGrid();
        RequestStateSave();
        QueueNotificationAttentionSync();
    }

    private void RebuildGrid()
    {
        int count = _cellBorders.Count;
        if (count == 0)
        {
            if (_lastGridItemCount != 0 || _lastGridRows != 0 || _lastGridCols != 0)
            {
                ThumbGrid.RowDefinitions.Clear();
                ThumbGrid.ColumnDefinitions.Clear();
                _lastGridItemCount = 0;
                _lastGridRows = 0;
                _lastGridCols = 0;
            }
            return;
        }

        var (rows, cols) = CalcGridSize(count);

        bool gridShapeChanged = _lastGridItemCount != count || _lastGridRows != rows || _lastGridCols != cols;
        if (gridShapeChanged)
        {
            ThumbGrid.RowDefinitions.Clear();
            ThumbGrid.ColumnDefinitions.Clear();

            for (int r = 0; r < rows; r++)
                ThumbGrid.RowDefinitions.Add(new RowDefinition());
            for (int c = 0; c < cols; c++)
                ThumbGrid.ColumnDefinitions.Add(new ColumnDefinition());

            _lastGridItemCount = count;
            _lastGridRows = rows;
            _lastGridCols = cols;
        }

        for (int i = 0; i < count; i++)
        {
            Grid.SetRow(_cellBorders[i], i / cols);
            Grid.SetColumn(_cellBorders[i], i % cols);
            Grid.SetRowSpan(_cellBorders[i], 1);
            Grid.SetColumnSpan(_cellBorders[i], 1);
        }

        RequestThumbnailUpdate();
        ScheduleThumbnailSettle();
    }

    private void RequestGridRebuild()
    {
        if (_gridRebuildPending || _cellBorders.Count == 0) return;
        _gridRebuildPending = true;
        Dispatcher.BeginInvoke(DispatcherPriority.Render, () =>
        {
            _gridRebuildPending = false;
            RebuildGrid();
        });
    }

    // Timer

    private void Timer_Tick(object? sender, EventArgs e)
    {
        RefreshWindowList();
        SyncMonitoredSlotTitles();

        _autoAddMaintenanceTick++;
        if (_autoAddMaintenanceTick >= AutoAddMaintenanceIntervalTicks)
        {
            _autoAddMaintenanceTick = 0;
            RefreshAutoAddAppDisplayNames();
            AutoAddWindowsForRegisteredApps();
        }
        ValidateSlots();
        RecoverMissingThumbnailRegistrations();
        SyncActiveSourceWindow();
        CheckFlashState();
    }

    // Window list

    private void RefreshWindowList()
    {
        _windowCache.Clear();
        NativeMethods.EnumWindows((hWnd, _) =>
        {
            if (hWnd == _mainHwnd) return true;
            if (!NativeMethods.IsAltTabWindow(hWnd)) return true;
            _windowCache.Add(new WindowInfo
            {
                Handle = hWnd,
                Title = NativeMethods.GetWindowTitle(hWnd),
                ProcessName = NativeMethods.GetProcessName(hWnd)
            });
            return true;
        }, IntPtr.Zero);
        ApplyFilter();
    }

    private void SyncMonitoredSlotTitles()
    {
        if (_slots.Count == 0) return;

        var titleByHandle = new Dictionary<IntPtr, string>();
        foreach (var item in _windowCache)
            titleByHandle[item.Handle] = item.Title;

        bool changed = false;
        for (int i = 0; i < _slots.Count; i++)
        {
            if (!_slots[i].IsOccupied) continue;

            string latestTitle = titleByHandle.TryGetValue(_slots[i].SourceHwnd, out string? titleFromList)
                ? titleFromList
                : NativeMethods.GetWindowTitle(_slots[i].SourceHwnd);

            if (string.IsNullOrWhiteSpace(latestTitle)) continue;
            if (string.Equals(_slots[i].SourceTitle, latestTitle, StringComparison.Ordinal)) continue;

            _slots[i].UpdateSourceTitle(latestTitle);
            _cellLabels[i].Text = latestTitle;
            changed = true;
        }

        if (changed)
            RequestStateSave();
    }

    private void FilterBox_TextChanged(object sender, TextChangedEventArgs e) => ApplyFilter();

    private void ApplyFilter()
    {
        string filter = FilterBox.Text.Trim();
        var items = string.IsNullOrEmpty(filter)
            ? _windowCache.ToList()
            : _windowCache
                .Where(w =>
                    w.Title.Contains(filter, StringComparison.OrdinalIgnoreCase) ||
                    w.ProcessName.Contains(filter, StringComparison.OrdinalIgnoreCase))
                .ToList();

        var sel = WindowList.SelectedItem as WindowInfo;
        WindowList.ItemsSource = items;
        if (sel != null)
            WindowList.SelectedItem = items.FirstOrDefault(w => w.Handle == sel.Handle);
    }

    private void WindowList_DoubleClick(object sender, MouseButtonEventArgs e)
    {
        if (WindowList.SelectedItem is not WindowInfo info) return;
        AddWindowToMonitor(info);
    }

    private void AddWindowToMonitor(WindowInfo info, int? insertIndex = null)
    {
        // Skip if already assigned.
        foreach (var slot in _slots)
            if (slot.IsOccupied && slot.SourceHwnd == info.Handle) return;

        if (insertIndex is int targetIndex)
        {
            targetIndex = Math.Clamp(targetIndex, 0, _slots.Count);

            int sourceIndex = -1;
            for (int i = 0; i < _slots.Count; i++)
            {
                if (!_slots[i].IsOccupied)
                {
                    sourceIndex = i;
                    break;
                }
            }

            bool createdNew = false;
            if (sourceIndex == -1)
            {
                sourceIndex = AddSlot();
                createdNew = true;
            }

            if (!AssignSlot(sourceIndex, info.Handle, info.Title, info.ProcessName))
            {
                if (createdNew)
                    RemoveSlot(sourceIndex);
                return;
            }

            if (sourceIndex != targetIndex)
                InsertSlot(sourceIndex, targetIndex);
            else
                RequestStateSave();
            return;
        }

        // First free slot.
        int target = -1;
        for (int i = 0; i < _slots.Count; i++)
        {
            if (!_slots[i].IsOccupied)
            {
                target = i;
                break;
            }
        }

        // No free slot -> add a new one.
        if (target == -1)
            target = AddSlot();

        if (AssignSlot(target, info.Handle, info.Title, info.ProcessName))
        {
            RequestStateSave();
        }
    }

    private static T? FindVisualParent<T>(DependencyObject? source) where T : DependencyObject
    {
        while (source != null && source is not T)
            source = VisualTreeHelper.GetParent(source);

        return source as T;
    }

    private void WindowList_RightClick(object sender, MouseButtonEventArgs e)
    {
        if (sender is not ListBox list) return;
        var item = FindVisualParent<ListBoxItem>(e.OriginalSource as DependencyObject);
        if (item == null) return;

        item.IsSelected = true;
        if (list.SelectedItem is not WindowInfo info) return;

        var menu = new ContextMenu();
        var addToMonitorItem = new MenuItem { Header = LocalizedText.Get("menu.addToMonitor") };
        addToMonitorItem.Click += (_, _) => AddWindowToMonitor(info);

        var addAppItem = new MenuItem { Header = LocalizedText.Get("menu.addApp") };
        addAppItem.Click += (_, _) =>
            AddAppToAutoList(info.ProcessName, ResolveDisplayNameFromWindow(info.Handle, info.ProcessName));

        menu.Items.Add(addToMonitorItem);
        menu.Items.Add(addAppItem);
        menu.PlacementTarget = item;
        menu.IsOpen = true;
        e.Handled = true;
    }

    private void AppList_RightClick(object sender, MouseButtonEventArgs e)
    {
        if (sender is not ListBox list) return;
        var item = FindVisualParent<ListBoxItem>(e.OriginalSource as DependencyObject);
        if (item == null) return;

        item.IsSelected = true;
        if (list.SelectedItem is not AutoAddAppEntry app) return;
        int index = _autoAddApps.IndexOf(app);

        var menu = new ContextMenu();
        var moveUpItem = new MenuItem { Header = LocalizedText.Get("menu.moveUp"), IsEnabled = index > 0 };
        moveUpItem.Click += (_, _) => MoveAutoApp(index, index - 1);

        var moveDownItem = new MenuItem
        {
            Header = LocalizedText.Get("menu.moveDown"),
            IsEnabled = index >= 0 && index < _autoAddApps.Count - 1
        };
        moveDownItem.Click += (_, _) => MoveAutoApp(index, index + 1);

        var removeItem = new MenuItem { Header = LocalizedText.Get("menu.removeAutoAdd") };
        removeItem.Click += (_, _) => RemoveAppFromAutoList(app.ProcessName);
        menu.Items.Add(moveUpItem);
        menu.Items.Add(moveDownItem);
        menu.Items.Add(removeItem);
        menu.PlacementTarget = item;
        menu.IsOpen = true;
        e.Handled = true;
    }

    private void AddAppToAutoList(string processName, string? displayName = null)
    {
        if (string.IsNullOrWhiteSpace(processName)) return;

        if (!string.IsNullOrWhiteSpace(displayName))
            _appDisplayNameCache[processName] = displayName;

        if (!_autoAddAppSet.Add(processName))
        {
            if (!string.IsNullOrWhiteSpace(displayName))
            {
                int existingIndex = _autoAddApps
                    .Select((app, idx) => new { app, idx })
                    .FirstOrDefault(x => x.app.ProcessName.Equals(processName, StringComparison.OrdinalIgnoreCase))
                    ?.idx ?? -1;
                if (existingIndex >= 0 && _autoAddApps[existingIndex].DisplayName != displayName)
                {
                    _autoAddApps[existingIndex].DisplayName = displayName;
                    RequestStateSave();
                }
            }
            return;
        }

        _autoAddApps.Add(new AutoAddAppEntry
        {
            ProcessName = processName,
            DisplayName = string.IsNullOrWhiteSpace(displayName) ? processName : displayName
        });
        RequestStateSave();
    }

    private void RemoveAppFromAutoList(string processName)
    {
        if (!_autoAddAppSet.Remove(processName)) return;

        _appDisplayNameCache.Remove(processName);

        AutoAddAppEntry? existing = _autoAddApps.FirstOrDefault(a =>
            a.ProcessName.Equals(processName, StringComparison.OrdinalIgnoreCase));
        if (existing != null)
        {
            _autoAddApps.Remove(existing);
            RequestStateSave();
        }
    }

    private void MoveAutoApp(int sourceIndex, int targetIndex)
    {
        if (sourceIndex < 0 || sourceIndex >= _autoAddApps.Count) return;
        if (targetIndex < 0 || targetIndex >= _autoAddApps.Count) return;
        if (sourceIndex == targetIndex) return;

        AutoAddAppEntry item = _autoAddApps[sourceIndex];
        _autoAddApps.RemoveAt(sourceIndex);
        _autoAddApps.Insert(targetIndex, item);
        RequestStateSave();
    }

    private void AppList_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
    {
        _appListDragStartPoint = e.GetPosition(AppList);
        var item = FindVisualParent<ListBoxItem>(e.OriginalSource as DependencyObject);
        _appListDragSourceProcessName = (item?.DataContext as AutoAddAppEntry)?.ProcessName;
    }

    private void AppList_PreviewMouseMove(object sender, MouseEventArgs e)
    {
        if (e.LeftButton != MouseButtonState.Pressed) return;
        if (_appListDragSourceProcessName == null) return;

        Point current = e.GetPosition(AppList);
        Vector delta = current - _appListDragStartPoint;
        if (Math.Abs(delta.X) < SystemParameters.MinimumHorizontalDragDistance &&
            Math.Abs(delta.Y) < SystemParameters.MinimumVerticalDragDistance)
            return;

        string dragSource = _appListDragSourceProcessName;
        _appListDragSourceProcessName = null;
        DragDrop.DoDragDrop(AppList, new DataObject("WindowThumbWall.AppListItem", dragSource), DragDropEffects.Move);
    }

    private void AppList_DragOver(object sender, DragEventArgs e)
    {
        if (e.Data.GetDataPresent("WindowThumbWall.AppListItem"))
            e.Effects = DragDropEffects.Move;
        else
            e.Effects = DragDropEffects.None;

        e.Handled = true;
    }

    private void AppList_Drop(object sender, DragEventArgs e)
    {
        if (!e.Data.GetDataPresent("WindowThumbWall.AppListItem")) return;
        if (e.Data.GetData("WindowThumbWall.AppListItem") is not string sourceApp) return;

        int sourceIndex = _autoAddApps
            .Select((app, idx) => new { app.ProcessName, idx })
            .FirstOrDefault(x => x.ProcessName.Equals(sourceApp, StringComparison.OrdinalIgnoreCase))
            ?.idx ?? -1;
        if (sourceIndex < 0) return;

        int targetIndex = _autoAddApps.Count - 1;
        var targetItem = FindVisualParent<ListBoxItem>(e.OriginalSource as DependencyObject);
        if (targetItem != null)
        {
            int targetItemIndex = AppList.ItemContainerGenerator.IndexFromContainer(targetItem);
            Point pos = e.GetPosition(targetItem);
            targetIndex = pos.Y <= targetItem.ActualHeight / 2 ? targetItemIndex : targetItemIndex + 1;
            if (sourceIndex < targetIndex)
                targetIndex--;
            targetIndex = Math.Clamp(targetIndex, 0, _autoAddApps.Count - 1);
        }

        MoveAutoApp(sourceIndex, targetIndex);
    }

    private void AutoAddWindowsForRegisteredApps()
    {
        if (_autoAddAppSet.Count == 0) return;

        Dictionary<string, int> nextInsertIndexByProcess = BuildAutoAddInsertIndexes();

        foreach (var info in _windowCache)
        {
            if (!_autoAddAppSet.Contains(info.ProcessName)) continue;

            if (!nextInsertIndexByProcess.TryGetValue(info.ProcessName, out int insertIndex))
                continue;

            AddWindowToMonitor(info, insertIndex);
            nextInsertIndexByProcess[info.ProcessName] = Math.Min(insertIndex + 1, _slots.Count);
        }
    }

    private Dictionary<string, int> BuildAutoAddInsertIndexes()
    {
        var hwndToProcess = _windowCache
            .GroupBy(window => window.Handle)
            .ToDictionary(group => group.Key, group => group.First().ProcessName);
        var nextInsertIndexByProcess = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
        int lastMatchingSlotIndex = -1;

        foreach (var app in _autoAddApps)
        {
            for (int i = lastMatchingSlotIndex + 1; i < _slots.Count; i++)
            {
                var slot = _slots[i];
                if (!slot.IsOccupied)
                    continue;

                string? slotProcess = slot.SourceProcessName;
                if (string.IsNullOrWhiteSpace(slotProcess) &&
                    !hwndToProcess.TryGetValue(slot.SourceHwnd, out slotProcess))
                {
                    continue;
                }

                if (slotProcess!.Equals(app.ProcessName, StringComparison.OrdinalIgnoreCase))
                    lastMatchingSlotIndex = i;
            }

            nextInsertIndexByProcess[app.ProcessName] = lastMatchingSlotIndex + 1;
        }

        return nextInsertIndexByProcess;
    }

    private void RefreshAutoAddAppDisplayNames()
    {
        var representativeWindows = new Dictionary<string, IntPtr>(StringComparer.OrdinalIgnoreCase);
        foreach (var window in _windowCache)
        {
            if (string.IsNullOrWhiteSpace(window.ProcessName) || representativeWindows.ContainsKey(window.ProcessName))
                continue;

            representativeWindows[window.ProcessName] = window.Handle;
        }

        for (int i = 0; i < _autoAddApps.Count; i++)
        {
            AutoAddAppEntry entry = _autoAddApps[i];
            if (!representativeWindows.TryGetValue(entry.ProcessName, out IntPtr hWnd))
                continue;

            if (!_appDisplayNameCache.TryGetValue(entry.ProcessName, out string? displayName) ||
                string.IsNullOrWhiteSpace(displayName))
            {
                displayName = ResolveDisplayNameFromWindow(hWnd, entry.ProcessName);
                _appDisplayNameCache[entry.ProcessName] = displayName;
            }

            if (displayName == entry.DisplayName) continue;

            entry.DisplayName = displayName;
        }
    }

    private string ResolveDisplayNameFromWindow(IntPtr hWnd, string fallbackProcessName)
    {
        string displayName = NativeMethods.GetAppDisplayName(hWnd);
        return string.IsNullOrWhiteSpace(displayName) ? fallbackProcessName : displayName;
    }

    // Slot validation

    private void ValidateSlots()
    {
        for (int i = _slots.Count - 1; i >= 0; i--)
        {
            if (!_slots[i].CheckValid())
                RemoveSlot(i);
        }
    }

    private void UpdateAllThumbnails()
    {
        foreach (var slot in _slots)
            slot.UpdateThumbnail();
    }

    private bool AssignSlot(int idx, IntPtr sourceHwnd, string title, string processName)
    {
        IntPtr previousSource = _slots[idx].SourceHwnd;
        if (previousSource != IntPtr.Zero && previousSource != sourceHwnd)
        {
            ClearNotificationAttentionGroupsForWindow(previousSource);
            _flashingWindows.Remove(previousSource);
            _thumbnailRefreshPendingWindows.Remove(previousSource);
            _lastThumbnailRefreshTicks.Remove(previousSource);
        }

        if (!_slots[idx].Assign(sourceHwnd, title, processName))
            return false;

        _cellLabels[idx].Text = title;
        RequestThumbnailRegistrationRefresh(sourceHwnd, bypassCooldown: true);
        SyncActiveSourceWindow(forceRefresh: true);
        UpdateSlotAttentionVisual(idx);
        QueueNotificationAttentionSync();
        return true;
    }

    private void RecoverMissingThumbnailRegistrations()
    {
        foreach (var slot in _slots)
        {
            if (!slot.IsOccupied || slot.HasRegistration)
                continue;

            RequestThumbnailRegistrationRefresh(slot.SourceHwnd, bypassCooldown: true);
        }
    }

    private int FindSlotIndexBySourceHwnd(IntPtr sourceHwnd)
    {
        for (int i = 0; i < _slots.Count; i++)
        {
            if (_slots[i].IsOccupied && _slots[i].SourceHwnd == sourceHwnd)
                return i;
        }

        return -1;
    }

    private void RequestThumbnailRegistrationRefresh(IntPtr sourceHwnd, bool bypassCooldown = false)
    {
        if (sourceHwnd == IntPtr.Zero)
            return;

        if (FindSlotIndexBySourceHwnd(sourceHwnd) < 0)
            return;

        if (!bypassCooldown &&
            _lastThumbnailRefreshTicks.TryGetValue(sourceHwnd, out long lastRefreshTicks))
        {
            long nowTicks = Stopwatch.GetTimestamp();
            long minIntervalTicks = (long)(ThumbnailRefreshMinInterval.TotalSeconds * Stopwatch.Frequency);
            if (nowTicks - lastRefreshTicks < minIntervalTicks)
                return;
        }

        if (!_thumbnailRefreshPendingWindows.Add(sourceHwnd))
            return;

        _thumbnailRefreshTimer.Stop();
        _thumbnailRefreshTimer.Start();
    }

    private void ThumbnailRefreshTimer_Tick(object? sender, EventArgs e)
    {
        _thumbnailRefreshTimer.Stop();
        if (_thumbnailRefreshPendingWindows.Count == 0)
            return;

        IntPtr[] pendingWindows = _thumbnailRefreshPendingWindows.ToArray();
        _thumbnailRefreshPendingWindows.Clear();

        bool refreshedAny = false;
        long refreshTicks = Stopwatch.GetTimestamp();
        foreach (IntPtr sourceHwnd in pendingWindows)
        {
            int idx = FindSlotIndexBySourceHwnd(sourceHwnd);
            if (idx < 0)
                continue;

            _lastThumbnailRefreshTicks[sourceHwnd] = refreshTicks;
            if (_slots[idx].RefreshRegistration())
                refreshedAny = true;
        }

        if (refreshedAny)
            ScheduleThumbnailSettle();
    }

    private void RequestThumbnailUpdate()
    {
        if (_thumbnailUpdatePending)
        {
            _thumbnailUpdateRequestedWhilePending = true;
            return;
        }

        long nowTicks = Stopwatch.GetTimestamp();
        long elapsedTicks = nowTicks - _lastThumbnailUpdateTicks;
        long minIntervalTicks = (long)(ThumbnailUpdateMinInterval.TotalSeconds * Stopwatch.Frequency);

        if (_lastThumbnailUpdateTicks != 0 && elapsedTicks < minIntervalTicks)
        {
            _thumbnailUpdateRequestedWhilePending = true;
            ScheduleThumbnailThrottle(minIntervalTicks - elapsedTicks);
            return;
        }

        _thumbnailUpdatePending = true;
        Dispatcher.BeginInvoke(DispatcherPriority.Render, () =>
        {
            _thumbnailUpdatePending = false;
            _thumbnailThrottleTimer.Stop();
            UpdateAllThumbnails();
            _lastThumbnailUpdateTicks = Stopwatch.GetTimestamp();

            if (_thumbnailUpdateRequestedWhilePending)
            {
                _thumbnailUpdateRequestedWhilePending = false;
                RequestThumbnailUpdate();
            }
        });
    }

    private void ScheduleThumbnailThrottle(long remainingTicks)
    {
        double remainingMs = remainingTicks * 1000.0 / Stopwatch.Frequency;
        if (remainingMs < 1)
            remainingMs = 1;

        _thumbnailThrottleTimer.Stop();
        _thumbnailThrottleTimer.Interval = TimeSpan.FromMilliseconds(remainingMs);
        _thumbnailThrottleTimer.Start();
    }

    private void ScheduleThumbnailSettle()
    {
        _thumbnailSettleTimer.Stop();
        _thumbnailSettleTimer.Start();
    }

    private void ThumbnailSettleTimer_Tick(object? sender, EventArgs e)
    {
        _thumbnailSettleTimer.Stop();
        RequestThumbnailUpdate();
    }

    private void ThumbnailThrottleTimer_Tick(object? sender, EventArgs e)
    {
        _thumbnailThrottleTimer.Stop();
        if (!_thumbnailUpdateRequestedWhilePending)
            return;

        _thumbnailUpdateRequestedWhilePending = false;
        RequestThumbnailUpdate();
    }

    private void CellLayout_SizeChanged(object sender, SizeChangedEventArgs e)
    {
        if (!e.WidthChanged && !e.HeightChanged)
            return;

        ScheduleThumbnailSettle();
    }

    // Cell interaction (click / menu / drag reorder)

    private void ActivateSlotWindow(int idx)
    {
        if (idx >= _slots.Count || !_slots[idx].IsOccupied) return;
        IntPtr hwnd = _slots[idx].SourceHwnd;
        if (NativeMethods.IsIconic(hwnd))
            NativeMethods.ShowWindow(hwnd, NativeMethods.SW_RESTORE);
        NativeMethods.SetForegroundWindow(hwnd);
    }

    private void Cell_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
    {
        if (sender is not Border { Tag: int idx }) return;
        _dragSourceIndex = idx;
        _dragStartPoint = e.GetPosition(this);
        _dragMoved = false;
        ((UIElement)sender).CaptureMouse();
        e.Handled = true;
    }

    private void Cell_PreviewMouseMove(object sender, MouseEventArgs e)
    {
        if (_dragSourceIndex < 0 || sender is not UIElement element) return;
        if (e.LeftButton != MouseButtonState.Pressed) return;

        Point current = e.GetPosition(this);
        Vector delta = current - _dragStartPoint;
        if (!_dragMoved &&
            Math.Abs(delta.X) < SystemParameters.MinimumHorizontalDragDistance &&
            Math.Abs(delta.Y) < SystemParameters.MinimumVerticalDragDistance)
            return;

        _dragMoved = true;
        int sourceIndex = _dragSourceIndex;
        _dragSourceIndex = -1;
        element.ReleaseMouseCapture();

        ShowDragGhost(sourceIndex, current);
        SetDropPreviewLayer(null);

        DragDrop.DoDragDrop(element, new DataObject(SlotDragFormat, sourceIndex), DragDropEffects.Move);

        HideDragGhost();
        SetDropPreviewLayer(null);
    }

    private void Cell_PreviewMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
    {
        if (sender is not Border { Tag: int idx }) return;
        ((UIElement)sender).ReleaseMouseCapture();

        if (!_dragMoved)
            ActivateSlotWindow(idx);

        _dragSourceIndex = -1;
        _dragMoved = false;
        e.Handled = true;
    }

    private void Cell_RightClick(object sender, MouseButtonEventArgs e)
    {
        if (sender is not Border { Tag: int idx }) return;

        var menu = new ContextMenu();

        var clearItem = new MenuItem { Header = LocalizedText.Get("menu.unassign"), IsEnabled = idx < _slots.Count };
        clearItem.Click += (_, _) => { if (idx < _slots.Count) RemoveSlot(idx); };

        var exitFullScreenItem = new MenuItem { Header = LocalizedText.Get("menu.exitFullscreen"), IsEnabled = _isFullScreen };
        exitFullScreenItem.Click += (_, _) => { if (_isFullScreen) ToggleFullScreen(); };

        menu.Items.Add(clearItem);
        menu.Items.Add(exitFullScreenItem);
        menu.PlacementTarget = (FrameworkElement)sender;
        menu.IsOpen = true;
        e.Handled = true;
    }

    private void Cell_DragOver(object sender, DragEventArgs e)
    {
        if (!e.Data.GetDataPresent(SlotDragFormat) || sender is not Border targetLayer)
        {
            e.Effects = DragDropEffects.None;
            return;
        }

        e.Effects = DragDropEffects.Move;
        SetDropPreviewLayer(targetLayer);
        UpdateDragGhostPosition(e.GetPosition(this));
        e.Handled = true;
    }

    private void Cell_DragLeave(object sender, DragEventArgs e)
    {
        if (sender == _dropPreviewLayer)
            SetDropPreviewLayer(null);
    }

    private void Cell_Drop(object sender, DragEventArgs e)
    {
        if (!e.Data.GetDataPresent(SlotDragFormat) || sender is not Border { Tag: int targetIndex })
            return;

        int sourceIndex = (int)e.Data.GetData(SlotDragFormat)!;
        if (sourceIndex >= 0 && sourceIndex < _slots.Count &&
            targetIndex >= 0 && targetIndex < _slots.Count &&
            sourceIndex != targetIndex)
        {
            InsertSlot(sourceIndex, targetIndex);
        }

        SetDropPreviewLayer(null);
        e.Handled = true;
    }

    private static void MoveItem<T>(List<T> list, int sourceIndex, int targetIndex)
    {
        var item = list[sourceIndex];
        list.RemoveAt(sourceIndex);
        list.Insert(targetIndex, item);
    }

    private void InsertSlot(int sourceIndex, int targetIndex)
    {
        if (sourceIndex < targetIndex)
            targetIndex--;

        MoveItem(_cellBorders, sourceIndex, targetIndex);
        MoveItem(_cellLabels, sourceIndex, targetIndex);
        MoveItem(_cellHitLayers, sourceIndex, targetIndex);
        MoveItem(_cellHosts, sourceIndex, targetIndex);
        MoveItem(_slots, sourceIndex, targetIndex);
        MoveItem(_slotAttentionVisualStates, sourceIndex, targetIndex);

        for (int idx = 0; idx < _cellBorders.Count; idx++)
        {
            _cellBorders[idx].Tag = idx;
            _cellHitLayers[idx].Tag = idx;
        }

        RebuildGrid();
        RequestStateSave();
    }

    private static readonly Brush DefaultHitLayerBrush =
        new SolidColorBrush(Color.FromArgb(1, 255, 255, 255));

    private static readonly Brush PreviewHitLayerBrush =
        new SolidColorBrush(Color.FromArgb(70, 80, 160, 255));

    private void SetDropPreviewLayer(Border? layer)
    {
        if (_dropPreviewLayer != null)
            _dropPreviewLayer.Background = DefaultHitLayerBrush;

        _dropPreviewLayer = layer;

        if (_dropPreviewLayer != null)
            _dropPreviewLayer.Background = PreviewHitLayerBrush;
    }

    private void ShowDragGhost(int sourceIndex, Point windowPoint)
    {
        HideDragGhost();

        var ghostBorder = new Border
        {
            Background = new SolidColorBrush(Color.FromArgb(180, 20, 20, 20)),
            BorderBrush = Brushes.DodgerBlue,
            BorderThickness = new Thickness(2),
            CornerRadius = new CornerRadius(4),
            Padding = new Thickness(10),
            Child = new TextBlock
            {
                Text = _cellLabels[sourceIndex].Text,
                Foreground = Brushes.White,
                FontSize = 12,
                TextTrimming = TextTrimming.CharacterEllipsis,
                Width = 240
            }
        };

        _dragGhost = new Window
        {
            Width = 270,
            Height = 48,
            WindowStyle = WindowStyle.None,
            AllowsTransparency = true,
            Background = Brushes.Transparent,
            ShowInTaskbar = false,
            Topmost = true,
            IsHitTestVisible = false,
            Content = ghostBorder,
            Opacity = 0.85
        };

        UpdateDragGhostPosition(windowPoint);
        _dragGhost.Show();
    }

    private void UpdateDragGhostPosition(Point windowPoint)
    {
        if (_dragGhost == null) return;
        Point screen = PointToScreen(windowPoint);
        _dragGhost.Left = screen.X + 12;
        _dragGhost.Top = screen.Y + 12;
    }

    private void HideDragGhost()
    {
        if (_dragGhost == null) return;
        _dragGhost.Close();
        _dragGhost = null;
    }

    // Flash detection (shell hook)

    private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
    {
        if (msg == (int)_shellHookMsgId)
        {
            int shellEvent = wParam.ToInt32();
            IntPtr targetHwnd = lParam;

            if (shellEvent == NativeMethods.HSHELL_FLASH)
            {
                OnWindowFlash(targetHwnd);
            }
            else if (shellEvent == NativeMethods.HSHELL_REDRAW)
            {
                OnWindowRedraw(targetHwnd);
            }
            else if ((shellEvent & 0x7FFF) == NativeMethods.HSHELL_WINDOWACTIVATED)
            {
                OnWindowActivated(targetHwnd);
            }
        }
        return IntPtr.Zero;
    }

    private void OnWindowFlash(IntPtr hwnd)
    {
        for (int i = 0; i < _slots.Count; i++)
        {
            if (!_slots[i].IsOccupied || _slots[i].SourceHwnd != hwnd)
                continue;

            if (_flashingWindows.Add(hwnd))
                UpdateSlotAttentionVisual(i);

            return;
        }
    }

    private void OnWindowActivated(IntPtr hwnd)
    {
        SetActiveSourceWindow(hwnd);
        ClearNotificationAttentionGroupsForWindow(hwnd);
        if (_flashingWindows.Remove(hwnd))
        {
            int slotIndex = FindSlotIndexBySourceHwnd(hwnd);
            if (slotIndex >= 0)
                UpdateSlotAttentionVisual(slotIndex);
        }

        RequestThumbnailRegistrationRefresh(hwnd);
    }

    private void OnWindowRedraw(IntPtr hwnd) => RequestThumbnailRegistrationRefresh(hwnd);

    private void CheckFlashState()
    {
        if (_flashingWindows.Count == 0)
            return;

        IntPtr fg = NativeMethods.GetForegroundWindow();
        if (!_flashingWindows.Remove(fg))
            return;

        int slotIndex = FindSlotIndexBySourceHwnd(fg);
        if (slotIndex >= 0)
            UpdateSlotAttentionVisual(slotIndex);
    }

    private static void StartFlashBorder(Border border, Color color)
    {
        var brush = new SolidColorBrush(color);
        var anim = new ColorAnimation
        {
            From = color,
            To = Color.FromArgb(0x40, color.R, color.G, color.B),
            Duration = TimeSpan.FromMilliseconds(400),
            AutoReverse = true,
            RepeatBehavior = RepeatBehavior.Forever
        };
        brush.BeginAnimation(SolidColorBrush.ColorProperty, anim);
        border.BorderBrush = brush;
        border.BorderThickness = AttentionBorderThickness;
    }

    private void StartFlashBorder(int idx, Color color) => StartFlashBorder(_cellBorders[idx], color);

    private void ShowActiveBorder(int idx)
    {
        _cellBorders[idx].BorderBrush = ActiveBorderBrush;
        _cellBorders[idx].BorderThickness = ActiveBorderThickness;
    }

    private void StopFlashBorder(int idx)
    {
        _cellBorders[idx].BorderBrush = NormalBorderBrush;
        _cellBorders[idx].BorderThickness = CellBorderThickness;
    }

    private void SyncActiveSourceWindow(bool forceRefresh = false) =>
        SetActiveSourceWindow(NativeMethods.GetForegroundWindow(), forceRefresh);

    private void SetActiveSourceWindow(IntPtr hwnd, bool forceRefresh = false)
    {
        IntPtr nextActiveSource = FindSlotIndexBySourceHwnd(hwnd) >= 0
            ? hwnd
            : IntPtr.Zero;

        if (!forceRefresh && nextActiveSource == _activeSourceHwnd)
            return;

        IntPtr previousActiveSource = _activeSourceHwnd;
        _activeSourceHwnd = nextActiveSource;

        if (previousActiveSource != IntPtr.Zero)
        {
            int previousIndex = FindSlotIndexBySourceHwnd(previousActiveSource);
            if (previousIndex >= 0)
                UpdateSlotAttentionVisual(previousIndex);
        }

        if (nextActiveSource != IntPtr.Zero && nextActiveSource != previousActiveSource)
        {
            int nextIndex = FindSlotIndexBySourceHwnd(nextActiveSource);
            if (nextIndex >= 0)
                UpdateSlotAttentionVisual(nextIndex);
        }
    }

    // Fullscreen

    private void FullScreenButton_Click(object sender, RoutedEventArgs e) => ToggleFullScreen();

    private void ToggleFullScreen()
    {
        if (_isFullScreen)
        {
            WindowStyle = _savedWindowStyle;
            WindowState = _savedWindowState;
            LeftPanel.Visibility = Visibility.Visible;
            Splitter.Visibility = Visibility.Visible;
            RootGrid.ColumnDefinitions[0].Width = _savedLeftColWidth;
            RootGrid.ColumnDefinitions[1].Width = _savedSplitterColWidth;
            _isFullScreen = false;
        }
        else
        {
            _savedWindowStyle = WindowStyle;
            _savedWindowState = WindowState;
            _savedLeftColWidth = RootGrid.ColumnDefinitions[0].Width;
            _savedSplitterColWidth = RootGrid.ColumnDefinitions[1].Width;

            LeftPanel.Visibility = Visibility.Collapsed;
            Splitter.Visibility = Visibility.Collapsed;
            RootGrid.ColumnDefinitions[0].Width = new GridLength(0);
            RootGrid.ColumnDefinitions[1].Width = new GridLength(0);

            if (WindowState == WindowState.Maximized)
                WindowState = WindowState.Normal;
            WindowStyle = WindowStyle.None;
            WindowState = WindowState.Maximized;
            _isFullScreen = true;
        }
        RequestThumbnailUpdate();
        ScheduleThumbnailSettle();
        RequestStateSave();
    }
}