PicView/src/PicView.Avalonia/UI/UIHelper.cs

using Avalonia;
using Avalonia.Controls;
using Avalonia.Controls.ApplicationLifetimes;
using Avalonia.Controls.Primitives;
using Avalonia.Layout;
using Avalonia.Media;
using Avalonia.Threading;
using PicView.Avalonia.Gallery;
using PicView.Avalonia.Navigation;
using PicView.Avalonia.ViewModels;
using PicView.Avalonia.Views;
using PicView.Avalonia.Views.UC;
using PicView.Avalonia.Views.UC.Menus;
using PicView.Core.Config;
using PicView.Core.Gallery;
using PicView.Core.Localization;

namespace PicView.Avalonia.UI
{
    public static class UIHelper
    {
        #region GetControls

        public static MainView? GetMainView { get; private set; }
        public static Control? GetTitlebar { get; private set; }
        public static EditableTitlebar? GetEditableTitlebar { get; private set; }
        public static GalleryAnimationControlView? GetGalleryView { get; private set; }

        public static BottomBar? GetBottomBar { get; private set; }
        
        public static ToolTipMessage? GetToolTipMessage { get; private set; }

        public static void SetControls(IClassicDesktopStyleApplicationLifetime desktop)
        {
            GetMainView = desktop.MainWindow.FindControl<MainView>("MainView");
            GetTitlebar = desktop.MainWindow.FindControl<Control>("Titlebar");
            GetEditableTitlebar = GetTitlebar.FindControl<EditableTitlebar>("EditableTitlebar");
            GetGalleryView = GetMainView.MainGrid.GetControl<GalleryAnimationControlView>("GalleryView");
            GetBottomBar = desktop.MainWindow.FindControl<BottomBar>("BottomBar");
            GetToolTipMessage = GetMainView.MainGrid.FindControl<ToolTipMessage>("ToolTipMessage");
        }

        #endregion

        #region Menus

        public static void AddMenus()
        {
            var mainView = GetMainView;
            var fileMenu = new FileMenu
            {
                VerticalAlignment = VerticalAlignment.Bottom,
                HorizontalAlignment = HorizontalAlignment.Center,
                Margin = new Thickness(0, 0, 120, 0),
                IsVisible = false
            };

            mainView.MainGrid.Children.Add(fileMenu);

            var imageMenu = new ImageMenu
            {
                VerticalAlignment = VerticalAlignment.Bottom,
                HorizontalAlignment = HorizontalAlignment.Center,
                Margin = new Thickness(0, 0, 63, 0),
                IsVisible = false
            };

            mainView.MainGrid.Children.Add(imageMenu);

            var settingsMenu = new SettingsMenu
            {
                VerticalAlignment = VerticalAlignment.Bottom,
                HorizontalAlignment = HorizontalAlignment.Center,
                Margin = new Thickness(0, 0, -75, 0),
                IsVisible = false
            };

            mainView.MainGrid.Children.Add(settingsMenu);

            var toolsMenu = new ToolsMenu
            {
                VerticalAlignment = VerticalAlignment.Bottom,
                HorizontalAlignment = HorizontalAlignment.Center,
                Margin = new Thickness(80, 0, 0, 0),
                IsVisible = false
            };

            mainView.MainGrid.Children.Add(toolsMenu);
        }

        public static void CloseMenus(MainViewModel vm)
        {
            vm.IsFileMenuVisible = false;
            vm.IsImageMenuVisible = false;
            vm.IsSettingsMenuVisible = false;
            vm.IsToolsMenuVisible = false;
        }

        public static bool IsAnyMenuOpen(MainViewModel vm)
        {
            return vm.IsFileMenuVisible || vm.IsImageMenuVisible || vm.IsSettingsMenuVisible || vm.IsToolsMenuVisible;
        }

        public static void ToggleFileMenu(MainViewModel vm)
        {
            vm.IsFileMenuVisible = !vm.IsFileMenuVisible;
            vm.IsImageMenuVisible = false;
            vm.IsSettingsMenuVisible = false;
            vm.IsToolsMenuVisible = false;
        }

        public static void ToggleImageMenu(MainViewModel vm)
        {
            vm.IsFileMenuVisible = false;
            vm.IsImageMenuVisible = !vm.IsImageMenuVisible;
            vm.IsSettingsMenuVisible = false;
            vm.IsToolsMenuVisible = false;
        }

        public static void ToggleSettingsMenu(MainViewModel vm)
        {
            vm.IsFileMenuVisible = false;
            vm.IsImageMenuVisible = false;
            vm.IsSettingsMenuVisible = !vm.IsSettingsMenuVisible;
            vm.IsToolsMenuVisible = false;
        }

        public static void ToggleToolsMenu(MainViewModel vm)
        {
            vm.IsFileMenuVisible = false;
            vm.IsImageMenuVisible = false;
            vm.IsSettingsMenuVisible = false;
            vm.IsToolsMenuVisible = !vm.IsToolsMenuVisible;
        }

        #endregion Menus

        #region Settings

        public static async Task SideBySide(MainViewModel vm)
        {
            if (vm is null)
            {
                return;
            }

            if (SettingsHelper.Settings.ImageScaling.ShowImageSideBySide)
            {
                SettingsHelper.Settings.ImageScaling.ShowImageSideBySide = false;
                vm.IsShowingSideBySide = false;
                vm.SecondaryImageSource = null;
                WindowHelper.SetSize(vm);
            }
            else
            {
                SettingsHelper.Settings.ImageScaling.ShowImageSideBySide = true;
                vm.IsShowingSideBySide = true;
                if (NavigationHelper.CanNavigate(vm))
                {
                    var preloadValue = await vm.ImageIterator?.GetNextPreLoadValueAsync();
                    vm.SecondaryImageSource = preloadValue?.ImageModel.Image;
                    Dispatcher.UIThread.InvokeAsync(() =>
                    {
                        WindowHelper.SetSize(vm.ImageWidth, vm.ImageHeight, preloadValue.ImageModel.PixelWidth,
                                                preloadValue.ImageModel.PixelHeight, vm.RotationAngle, vm);
                    });
                }
            }

            await SettingsHelper.SaveSettingsAsync();
        }

        public static void ToggleScroll(MainViewModel vm)
        {
            if (SettingsHelper.Settings.Zoom.ScrollEnabled)
            {
                vm.ToggleScrollBarVisibility = ScrollBarVisibility.Disabled;
                vm.GetIsScrollingTranslation = TranslationHelper.Translation.ScrollingDisabled;
                vm.IsScrollingEnabled = false;
                SettingsHelper.Settings.Zoom.ScrollEnabled = false;
            }
            else
            {
                vm.ToggleScrollBarVisibility = ScrollBarVisibility.Visible;
                vm.GetIsScrollingTranslation = TranslationHelper.Translation.ScrollingEnabled;
                vm.IsScrollingEnabled = true;
                SettingsHelper.Settings.Zoom.ScrollEnabled = true;
            }

            WindowHelper.SetSize(vm);
        }

        public static async Task Flip(MainViewModel vm)
        {
            if (vm.ScaleX == 1)
            {
                vm.ScaleX = -1;
                vm.GetIsFlippedTranslation = vm.UnFlip;
            }
            else
            {
                vm.ScaleX = 1;
                vm.GetIsFlippedTranslation = vm.Flip;
            }

            await Dispatcher.UIThread.InvokeAsync(() => { vm.ImageViewer.Flip(true); });
        }

        public static async Task ToggleLooping(MainViewModel vm)
        {
            var value = !SettingsHelper.Settings.UIProperties.Looping;
            SettingsHelper.Settings.UIProperties.Looping = value;
            vm.GetIsLoopingTranslation = value
                ? TranslationHelper.Translation.LoopingEnabled
                : TranslationHelper.Translation.LoopingDisabled;
            vm.IsLooping = value;

            var msg = value
                ? TranslationHelper.Translation.LoopingEnabled
                : TranslationHelper.Translation.LoopingDisabled;
            await TooltipHelper.ShowTooltipMessageAsync(msg);

            await SettingsHelper.SaveSettingsAsync();
        }

        public static async Task ChangeCtrlZoom(MainViewModel vm)
        {
            SettingsHelper.Settings.Zoom.CtrlZoom = !SettingsHelper.Settings.Zoom.CtrlZoom;
            vm.GetIsCtrlZoomTranslation = SettingsHelper.Settings.Zoom.CtrlZoom
                ? TranslationHelper.Translation.CtrlToZoom
                : TranslationHelper.Translation.ScrollToZoom;
            
            // 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 = SettingsHelper.Settings.Zoom.CtrlZoom;
            vm.ChangeCtrlZoomImage = isNavigatingWithCtrl ? leftRightArrowsImage as DrawingImage : scanEyeImage as DrawingImage;
            await SettingsHelper.SaveSettingsAsync().ConfigureAwait(false);
        }

        public static async Task ToggleSubdirectories(MainViewModel vm)
        {
            if (SettingsHelper.Settings.Sorting.IncludeSubDirectories)
            {
                vm.IsIncludingSubdirectories = false;
                SettingsHelper.Settings.Sorting.IncludeSubDirectories = false;
            }
            else
            {
                vm.IsIncludingSubdirectories = true;
                SettingsHelper.Settings.Sorting.IncludeSubDirectories = true;
            }

            await vm.ImageIterator.ReloadFileList();
            SetTitleHelper.SetTitle(vm);
            await SettingsHelper.SaveSettingsAsync();
        }

        public static async Task ToggleTaskbarProgress(MainViewModel vm)
        {
            if (SettingsHelper.Settings.UIProperties.IsTaskbarProgressEnabled)
            {
                SettingsHelper.Settings.UIProperties.IsTaskbarProgressEnabled = false;
                await Dispatcher.UIThread.InvokeAsync(() =>
                {
                    vm.PlatformService.StopTaskbarProgress();
                });
            }
            else
            {
                SettingsHelper.Settings.UIProperties.IsTaskbarProgressEnabled = true;
                if (NavigationHelper.CanNavigate(vm))
                {
                    await Dispatcher.UIThread.InvokeAsync(() =>
                    {
                        vm.PlatformService.SetTaskbarProgress((ulong)vm.ImageIterator.CurrentIndex,
                            (ulong)vm.ImageIterator.ImagePaths.Count);
                    });
                }
            }

            await SettingsHelper.SaveSettingsAsync();
        }

        #endregion

        #region Navigation

        public static async Task NavigateUp(MainViewModel? vm)
        {
            if (vm is null)
            {
                return;
            }

            if (GalleryFunctions.IsFullGalleryOpen)
            {
                GalleryNavigation.NavigateGallery(Direction.Up, vm);
                return;
            }

            if (vm.IsScrollingEnabled)
            {
                await Dispatcher.UIThread.InvokeAsync(() => { vm.ImageViewer.ImageScrollViewer.LineUp(); });
            }
            else
            {
                vm.ImageViewer.Rotate(true);
            }
        }

        public static async Task NavigateDown(MainViewModel? vm)
        {
            if (vm is null)
            {
                return;
            }

            if (GalleryFunctions.IsFullGalleryOpen)
            {
                GalleryNavigation.NavigateGallery(Direction.Down, vm);
                return;
            }

            if (vm.IsScrollingEnabled)
            {
                vm.ImageViewer.ImageScrollViewer.LineDown();
            }
            else
            {
                await Dispatcher.UIThread.InvokeAsync(() => { vm.ImageViewer.Rotate(false); });
            }
        }



        #endregion Navigation


    }
}