PicView/src/PicView.Avalonia/Views/MainView.axaml.cs

using System.Runtime.InteropServices;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Input;
using Avalonia.Media;
using Avalonia.Threading;
using PicView.Avalonia.Converters;
using PicView.Avalonia.Crop;
using PicView.Avalonia.DragAndDrop;
using PicView.Avalonia.Functions;
using PicView.Avalonia.Input;
using PicView.Avalonia.UI;
using PicView.Avalonia.UI.FileHistory;
using PicView.Avalonia.ViewModels;
using PicView.Avalonia.WindowBehavior;
using PicView.Core.FileHistory;

namespace PicView.Avalonia.Views;

public partial class MainView : UserControl
{
    public FileHistoryMenuController? FileHistoryMenuController;
    
    public MainView()
    {
        InitializeComponent();

        if (!Settings.Theme.Dark && !Settings.Theme.GlassTheme)
        {
            if (!Application.Current.TryGetResource("MainTextColor",
                    Application.Current.RequestedThemeVariant, out var mainTextColor) ||
                !Application.Current.TryGetResource("SecondaryTextColor", Application.Current.RequestedThemeVariant, out var secondaryTextColor))
            {
                return;
            }

            if (mainTextColor is not Color color || secondaryTextColor is not Color secondaryColor)
            {
                return;
            }

            var brush = new SolidColorBrush(color);
            var secondaryBrush = new SolidColorBrush(secondaryColor);
            HistoryClearButton.PointerEntered += delegate       
            {
                HistoryClearTextBlock.Foreground = secondaryBrush;
                HistoryClearPath.Fill = secondaryBrush;
            };
            HistoryClearButton.PointerExited += delegate       
            {
                HistoryClearTextBlock.Foreground = brush;
                HistoryClearPath.Fill = brush;
            };
            HistoryFileButton.PointerEntered += delegate       
            {
                HistoryFileNameTextBlock.Foreground = secondaryBrush;
                HistoryFileButtonPath.Fill = secondaryBrush;
            };
            HistoryFileButton.PointerExited += delegate       
            {
                HistoryFileNameTextBlock.Foreground = brush;
                HistoryFileButtonPath.Fill = brush;
            };
        }

        Loaded += delegate
        {
            AddHandler(DragDrop.DragEnterEvent, DragEnter);
            AddHandler(DragDrop.DragLeaveEvent, DragLeave);
            AddHandler(DragDrop.DropEvent, Drop);

            GotFocus += CloseTitlebarIfOpen;
            LostFocus += HandleLostFocus;
            PointerPressed += PointerPressedBehavior;

            MainContextMenu.Opened += async (sender, args) =>  await OnMainContextMenuOpened(sender, args);

            if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
            {
                WallpaperMenuItem.IsVisible = false;
                OpenWithMenuItem.IsVisible = false;
            }
            else
            {
                MacOSWallpaperMenuItem.IsVisible = false;
            }
            
            if (!FileHistoryManager.IsSortingDescending)
            {
                if (Application.Current.TryGetResource("SortAscImage",
                        Application.Current.RequestedThemeVariant, out var sortAscImage))
                {
                    HistorySortButton.Icon = sortAscImage as DrawingImage;
                }
            }
            
            if (DataContext is not MainViewModel vm)
            {
                return;
            }
            // Initialize the history menu controller
            // TODO: rewrite FileHistory to MVVM
            FileHistoryMenuController = new FileHistoryMenuController(RecentFilesCM, HistorySortButton, HistoryClearButton, vm);
            HistoryFileButton.Click += async delegate
            {
                await FunctionsMapper.ShowRecentHistoryFile();
            };

            HideInterfaceLogic.AddHoverButtonEvents(AltButtonsPanel, vm);
            PointerWheelChanged += async (_, e) => await vm.ImageViewer.PreviewOnPointerWheelChanged(this, e);
        };
    }

    private void PointerPressedBehavior(object? sender, PointerPressedEventArgs e)
    {
        CloseTitlebarIfOpen(sender, e);
        if (MainKeyboardShortcuts.ShiftDown && !CropFunctions.IsCropping)
        {
            var hostWindow = (Window)VisualRoot!;
            WindowFunctions.WindowDragBehavior(hostWindow, e);
        }
        
        DragAndDropHelper.RemoveDragDropView();
    }
    
    private void CloseTitlebarIfOpen(object? sender, EventArgs e)
    {
        if (DataContext is not MainViewModel vm)
        {
            return;
        }

        if (!vm.IsEditableTitlebarOpen)
        {
            return;
        }

        vm.IsEditableTitlebarOpen = false;
        MainKeyboardShortcuts.IsKeysEnabled = true;
        Focus();
    }
    
    private static void HandleLostFocus(object? sender, EventArgs e)
    {
        DragAndDropHelper.RemoveDragDropView();
    }

    private async Task OnMainContextMenuOpened(object? sender, EventArgs e)
    {
        if (DataContext is not MainViewModel vm)
        {
            return;
        }
        
        await Dispatcher.UIThread.InvokeAsync(() =>
        {
            CropMenuItem.IsEnabled = CropFunctions.DetermineIfShouldBeEnabled(vm);
            ConversionHelper.DetermineIfOptimizeImageShouldBeEnabled(vm);

            // Set source for ChangeCtrlZoomImage
            if (!Application.Current.TryGetResource("ScanEyeImage", Application.Current.RequestedThemeVariant, out var scanEyeImage))
            {
                return;
            }
            if (!Application.Current.TryGetResource("LeftRightArrowsImage", Application.Current.RequestedThemeVariant, out var leftRightArrowsImage))
            {
                return;
            }
            var isNavigatingWithCtrl = Settings.Zoom.CtrlZoom;
            vm.ChangeCtrlZoomImage = isNavigatingWithCtrl ? leftRightArrowsImage as DrawingImage : scanEyeImage as DrawingImage;
        });
        
        // Update file history menu items in Dispatcher with low priority to avoid slowdown
        await Dispatcher.UIThread.InvokeAsync(() => FileHistoryMenuController?.UpdateFileHistoryMenu());
    }

    private async Task Drop(object? sender, DragEventArgs e)
    {
        if (DataContext is not MainViewModel vm)
        {
            return;
        }
        await DragAndDropHelper.Drop(e, vm);
    }
    
    private async Task DragEnter(object? sender, DragEventArgs e)
    {
        if (DataContext is not MainViewModel vm)
            return;

        await DragAndDropHelper.DragEnter(e, vm, this);
    }
    
    private void DragLeave(object? sender, DragEventArgs e)
    {
        DragAndDropHelper.DragLeave(e, this);
    }
}