MainWindow.xaml.cs

using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Input;
using Microsoft.UI.Xaml.Media;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using ElectronicCorrectionNotebook.Services;
using System.Threading;
using Microsoft.UI.Xaml.Documents;
using Microsoft.UI.Xaml.Media.Imaging;
using Windows.ApplicationModel.Core;
using Microsoft.UI;           
using System.Runtime.InteropServices;
using WinRT;
using PInvoke;
using ElectronicCorrectionNotebook.DataStructure;
using Microsoft.UI.Xaml.Data;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Linq;


namespace ElectronicCorrectionNotebook
{
    public sealed partial class MainWindow : Window
    {
        public ObservableCollection<ErrorItem> ErrorItems { get; set; } = new ObservableCollection<ErrorItem>();

        // Suggested Tags 只存在一次的
        private ObservableCollection<TagItem> suggestedTagList { get; set; } = new ObservableCollection<TagItem>();
        public ObservableCollection<TagItem> SuggestedTagList
        {
            get => suggestedTagList;
            set
            {
                if (suggestedTagList != value)
                {
                    suggestedTagList = value;
                    OnPropertyChanged();
                }
            }
        }

        private CancellationTokenSource cts;

        private const int MinWidth = 1250;  // 设置最小宽度
        private const int MinHeight = 1250; // 设置最小高度

        private Microsoft.UI.Windowing.AppWindow appWindow;

        public MainWindow()
        {
            InitializeComponent();

            var micaBackdrop = new Microsoft.UI.Xaml.Media.MicaBackdrop();
            micaBackdrop.Kind = Microsoft.UI.Composition.SystemBackdrops.MicaKind.BaseAlt;

            // var acry = new Microsoft.UI.Xaml.Media.DesktopAcrylicBackdrop();
            
            this.SystemBackdrop = micaBackdrop;

            SubClassing();
            Closed += MainWindow_Closed;
            CoreApplication.Exiting += OnExiting;

            var hWnd = WinRT.Interop.WindowNative.GetWindowHandle(this);
            var windowId = Microsoft.UI.Win32Interop.GetWindowIdFromWindow(hWnd);
            appWindow = Microsoft.UI.Windowing.AppWindow.GetFromWindowId(windowId);

            appWindow.SetIcon("Assets/im.ico");
            cts = new CancellationTokenSource();
            _ = LoadDataAsync(cts.Token);

            ExtendsContentIntoTitleBar = true;
            SetTitleBar(AppTitleBar);
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        // 临时解决方案
        /*public void UpdateSuggestedTagList()
        {
            SuggestedTagList.Clear();
            foreach (var item in ErrorItems)
            {
                foreach (var tag in item.TagItems)
                {
                    if (!SuggestedTagList.Contains(tag))
                    {
                        SuggestedTagList.Add(tag);
                    }
                }
            }
        }*/

        // 加载数据-从json中读取数据+制作suggestedTagList
        public async Task LoadDataAsync(CancellationToken token)
        {
            try
            {
                var items = await DataService.LoadDataAsync(token);
                foreach (var item in items)
                {
                    ErrorItems.Add(item);
                    foreach (var tagItem in item.TagItems)
                    {
                        // 会有重复
                        /*if (!SuggestedTagList.Contains(tag))
                        {
                            SuggestedTagList.Add(tag);
                        }*/

                        if (!SuggestedTagList.Any(tag => string.Equals(tag.Name, tagItem.Name, StringComparison.Ordinal)))
                        {
                            SuggestedTagList.Add(tagItem);
                        }
                    }
                    
                }


            }
            catch (OperationCanceledException)
            {

            }
            catch (Exception ex)
            {
                await ShowErrorMessageAsync(ex);
            }
        }

        // 存储数据-把数据存储到json-调用DataServie
        public async Task SaveDataAsync(CancellationToken token)
        {
            try
            {
                await DataService.SaveDataAsync(ErrorItems, token);
            }
            catch (OperationCanceledException)
            {
                // Handle cancellation
            }
            catch (Exception ex)
            {
                await ShowErrorMessageAsync(ex);
            }
        }

        // 添加新错题-总步骤
        private async void Add_Tapped(object sender, TappedRoutedEventArgs e)
        {
            var newErrorItem = new ErrorItem
            {
                Title = "New Error",
                Date = DateTime.Now,
                FilePaths = new List<string>(),
                Rating = -1,
            };
            ErrorItems.Add(newErrorItem);
            await SaveDataAsync(cts.Token);
        }

        // 关于
        private async void About_Tapped(object sender, TappedRoutedEventArgs e)
        {
            
            PublicEvents.PlaySystemSound();
            StackPanel contentPanel = new StackPanel();

            TextBlock aboutInfo = new TextBlock()
            {
                TextWrapping = TextWrapping.Wrap,
                Margin = new Thickness(0, 10, 0, 0)
            };

            aboutInfo.Inlines.Add(new Run { Text = "Created by " });

            Hyperlink hyperlink = new Hyperlink();
            hyperlink.Inlines.Add(new Run { Text = "@QuincyZhao😀" });
            hyperlink.NavigateUri = new Uri("https://github.com/zhaoqianbiao");
            hyperlink.Foreground = new SolidColorBrush(Microsoft.UI.Colors.OrangeRed);

            aboutInfo.Inlines.Add(hyperlink);
            aboutInfo.Inlines.Add(new Run { Text = " in GCGS" });
            aboutInfo.FontFamily = (FontFamily)Application.Current.Resources["FontRegular"];

            Image aboutImage = new Image()
            {
                Source = new BitmapImage(new Uri("ms-appx:///Assets/peter.png")),
                Width = 100,
                Height = 100,
                Margin = new Thickness(0, 10, 0, 0)
            };

            contentPanel.Children.Add(aboutInfo);
            contentPanel.Children.Add(aboutImage);

            ContentDialog about = new ContentDialog()
            {
                XamlRoot = this.Content.XamlRoot,
                Title = "About",
                FontFamily = (FontFamily)Application.Current.Resources["FontBold"],
                Content = contentPanel,
                CloseButtonText = "Ok",
                // RequestedTheme = (ElementTheme)Application.Current.RequestedTheme // 设置主题与应用程序一致
                Style = Application.Current.Resources["DefaultContentDialogStyle"] as Style
            };
            await about.ShowAsync();
            
        }

        // 导航视图选择更改时
        public async void NavigationView_SelectionChanged(NavigationView sender, NavigationViewSelectionChangedEventArgs args)
        {
            if (contentFrame.Content is ErrorDetailPage currentPage)
            {
                await currentPage.SaveCurrentContentAsync();
            }

            if (args.IsSettingsSelected)
            {
                contentFrame.Navigate(typeof(SettingsPage));
            }
            else if (args.SelectedItem != null)
            {
                var selectedErrorItem = args.SelectedItem as ErrorItem;
                if (selectedErrorItem != null)
                {
                    contentFrame.Navigate(typeof(ErrorDetailPage), selectedErrorItem);
                }
            }
        }

        // 窗口关闭时
        public async void MainWindow_Closed(object sender, WindowEventArgs args)
        {
            await SaveCurrentStateAsync();
            this.Closed -= MainWindow_Closed;
            Application.Current.Exit();
        }

        // 应用程序退出时
        private async void OnExiting(object sender, object e)
        {
            await SaveCurrentStateAsync();
        }

        // 保存当前状态
        private async Task SaveCurrentStateAsync()
        {
            if (contentFrame.Content is ErrorDetailPage currentPage)
            {
                await currentPage.SaveCurrentContentAsync();
            }
            await SaveDataAsync(cts.Token);
            cts.Cancel();
        }

        // 删除项-不用改
        public async void RemoveNavigationViewItem(ErrorItem errorItem)
        {
            ErrorItems.Remove(errorItem);
            await SaveDataAsync(cts.Token);
            contentFrame.Content = null;
        }

        // 跳转的时候 自动选中对应的item
        private void SelectNavigationViewItem(ErrorItem errorItem)
        {
            nvSample.SelectedItem = errorItem;
        }

        // 显示错误消息
        private async Task ShowErrorMessageAsync(Exception ex)
        {
            var errorDialog = new ContentDialog()
            {
                XamlRoot = this.Content.XamlRoot,
                Title = "Error!",
                Content = ex.Message,
                CloseButtonText = "Ok 确定",
                FontFamily = (FontFamily)Application.Current.Resources["FontRegular"],
                // RequestedTheme = (ElementTheme)Application.Current.RequestedTheme // 设置主题与应用程序一致
                Style = Application.Current.Resources["DefaultContentDialogStyle"] as Style
            };
            await errorDialog.ShowAsync();
        }

        #region AutoSuggestBoxCodeRegion

        // 在搜索框中输入的时候更改建议列表
        public void AutoSuggestBox_TextChanged(AutoSuggestBox sender, AutoSuggestBoxTextChangedEventArgs args)
        {
            if (args.Reason == AutoSuggestionBoxTextChangeReason.UserInput)
            {
                var suggestions = new List<string>();
                foreach (var item in ErrorItems)
                {
                    if (item.Title.Contains(sender.Text, StringComparison.OrdinalIgnoreCase))
                    {
                        suggestions.Add(item.Title);
                    }
                }
                sender.ItemsSource = suggestions;
                sender.FontFamily = (FontFamily)Application.Current.Resources["FontRegular"];
            }
        }

        // 点击某一项后，跳转到某一个页面
        public void AutoSuggestBox_QuerySubmitted(AutoSuggestBox sender, AutoSuggestBoxQuerySubmittedEventArgs args)
        {
            if (args.ChosenSuggestion != null)
            {
                foreach (var item in ErrorItems)
                {
                    if (item.Title == (string)args.ChosenSuggestion)
                    {
                        SelectNavigationViewItem(item); // 自动选中对应的item
                        break;
                    }
                }
            }
            else if (!string.IsNullOrEmpty(args.QueryText))
            {
                foreach (var item in ErrorItems)
                {
                    if (item.Title == args.QueryText)
                    {
                        SelectNavigationViewItem(item); // 自动选中对应的item
                        break;
                    }
                }
            }
        }

        // 确认点击某一项后，搜索栏中显示那一项的名称
        public void AutoSuggestBox_SuggestionChosen(AutoSuggestBox sender, AutoSuggestBoxSuggestionChosenEventArgs args)
        {
            sender.Text = args.SelectedItem.ToString();
        }

        #endregion

        #region MinMaxCodeRegion
        private delegate IntPtr WinProc(IntPtr hWnd, User32.WindowMessage Msg, IntPtr wParam, IntPtr lParam);
        private WinProc newWndProc = null;
        private IntPtr oldWndProc = IntPtr.Zero;
        [DllImport("user32.dll", SetLastError = true)]
        private static extern IntPtr SetWindowLongPtr(IntPtr hWnd, User32.WindowLongIndexFlags nIndex, WinProc newProc);
        [DllImport("user32.dll")]
        private static extern IntPtr CallWindowProc(IntPtr lpPrevWndFunc, IntPtr hWnd, User32.WindowMessage Msg, IntPtr wParam, IntPtr lParam);

        private void SubClassing()
        {
            // Get the Window's HWND
            var hwnd = this.As<IWindowNative>().WindowHandle;

            newWndProc = new WinProc(NewWindowProc);
            oldWndProc = SetWindowLongPtr(hwnd, User32.WindowLongIndexFlags.GWL_WNDPROC, newWndProc);
        }

        [StructLayout(LayoutKind.Sequential)]
        struct MINMAXINFO
        {
            public POINT ptReserved;
            public POINT ptMaxSize;
            public POINT ptMaxPosition;
            public POINT ptMinTrackSize;
            public POINT ptMaxTrackSize;
        }

        private IntPtr NewWindowProc(IntPtr hWnd, User32.WindowMessage Msg, IntPtr wParam, IntPtr lParam)
        {
            switch (Msg)
            {
                case User32.WindowMessage.WM_GETMINMAXINFO:
                    var dpi = User32.GetDpiForWindow(hWnd);
                    // float scalingFactor = (float)dpi / 96;

                    MINMAXINFO minMaxInfo = Marshal.PtrToStructure<MINMAXINFO>(lParam);
                    minMaxInfo.ptMinTrackSize.x = (int)(MinWidth);
                    minMaxInfo.ptMinTrackSize.y = (int)(MinHeight);
                    Marshal.StructureToPtr(minMaxInfo, lParam, true);
                    break;
            }
            return CallWindowProc(oldWndProc, hWnd, Msg, wParam, lParam);
        }

        [ComImport]
        [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
        [Guid("EECDBF0E-BAE9-4CB6-A68E-9598E1CB57BB")]
        internal interface IWindowNative
        {
            IntPtr WindowHandle { get; }
        }

        #endregion
    }
}