AIPlatform_6787/aipdev/FolderImageBrowser.xaml.cs

using AIPlatform.Protocol.Entities;
using AIPlatform.Protocol.Model;
using AIPlatform.Protocol.Utilities;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace aipdev
{
    public class FolderImageEx
    {
        public LabeledUltrasoundFile LabeledUltrasoundFile { get; set; }

        public DeveloperFolderFile DeveloperFolderFile { get; set; }

        /// <summary>
        /// Gets the preview image.
        /// </summary>
        public BitmapImage PreviewImage { get; }

        /// <summary>
        /// Gets if this image can copy.
        /// </summary>
        public bool CanCopy { get; }

        /// <summary>
        /// Gets if this image can be deleted.
        /// </summary>
        public bool CanDelete { get; }

        /// <summary>
        /// Gets or sets is selected.
        /// </summary>
        public bool Selected { get; set; }

        public LabeledResult LabeledResult { get; }

        public string Conclusions { get; }

        public string TrimmingConclusions { get; }

        public int Page { get; }

        public long SourceFolderId { get; }

        /// <summary>
        /// Gets the value to indicate whether the developer questioned file.
        /// </summary>
        public bool HasQuestioned { get; }

        public FolderImageEx(DeveloperFolderFile image, BitmapImage previewImage, bool canDelete, LabeledResult labeledResult, string conclusions, string trimmingConclusions, int page, long sourceFolderId)
        {
            DeveloperFolderFile = image;
            LabeledUltrasoundFile = null;
            PreviewImage = previewImage;
            CanCopy = true;
            CanDelete = canDelete;
            LabeledResult = labeledResult;
            Conclusions = conclusions;
            TrimmingConclusions = trimmingConclusions;
            Page = page;
            SourceFolderId = sourceFolderId;
            HasQuestioned = image.HasQuestioned;
        }

        public FolderImageEx(LabeledUltrasoundFile image, BitmapImage previewImage, bool canDelete, LabeledResult labeledResult, string conclusions, string trimmingConclusions, int page, long sourceFolderId, bool hasQuestioned)
        {
            LabeledUltrasoundFile = image;
            DeveloperFolderFile = null;
            PreviewImage = previewImage;
            CanCopy = true;
            CanDelete = canDelete;
            LabeledResult = labeledResult;
            Conclusions = conclusions;
            TrimmingConclusions = trimmingConclusions;
            Page = page;
            SourceFolderId = sourceFolderId;
            HasQuestioned = hasQuestioned;
        }
    }

    /// <summary>
    /// Interaction logic for FolderImageViewer.xaml
    /// </summary>
    public partial class FolderImageBrowser : UserControl, IContentPage
    {
        private ScrollViewer _scrollViewer;

        private string _keyword;

        private int _pageSize { get; set; } = 45;

        private int _totalPages { get; set; }

        private int _preloadedPage { get; set; }

        private bool _scrollDown { get; set; }

        private bool _isLoadPreviousImages { get; set; }

        private bool _isLoadNextImages { get; set; }

        private double _oldVerticalOffset { get; set; }

        private int _browseImageIndex { get; set; }

        private int _browsePage { get; set; }

        private int _imageCount { get; set; }

        private ImageFolderExtend _folder;

        private DeveloperFolderExtend _developerFolder;

        private readonly ObservableCollection<FolderImageEx> _images = new ObservableCollection<FolderImageEx>();

        public string PageName { get; set; }

        public bool IsHomePage { get; set; }

        public bool IsModalPage { get; set; }

        private bool _stopLoading { get; set; }

        private bool _isQuestioned { get; set; }

        public FolderImageBrowser()
        {
            InitializeComponent();
            PageName = "FolderImageBrowser";
            IsHomePage = false;
            IsModalPage = true;
            FolderImages.ItemsSource = _images;
        }

        private T FindVisualChild<T>(DependencyObject element) where T : class
        {
            try
            {
                while (element != null)
                {
                    if (element is T)
                        return element as T;
                    element = VisualTreeHelper.GetChild(element, 0);
                }
            }
            catch (Exception)
            {
                //DoNothing
            }

            return null;
        }

        private void OnFolderImagesScrollChanged(object sender, ScrollChangedEventArgs e)
        {
            var scrollViewer = (ScrollViewer)sender;
            if (IsOnScrollViewBottom(scrollViewer))
            {
                if (_preloadedPage < _totalPages)
                {
                    try
                    {
                        Task.Run(async () =>
                        {
                            await LoadImagesAsync(_preloadedPage).ConfigureAwait(false);
                        });
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(Application.Current.MainWindow, $"加载文件夹图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                }
            }
        }

        private bool IsOnScrollViewBottom(ScrollViewer view)
        {
            var onBottom = false;
            var verticalOffset = view.VerticalOffset;
            var scrollableHeight = view.ScrollableHeight;
            var extentHeight = view.ExtentHeight;
            _scrollDown = verticalOffset >= _oldVerticalOffset;

            #region 滚动条从上往下翻看，加载之面页数

            if (_scrollDown && verticalOffset / extentHeight > 0.7 && _stopLoading && _preloadedPage < _totalPages - 1)
            {
                _isLoadNextImages = true;
                _isLoadPreviousImages = false;
                onBottom = true;
                verticalOffset = 2;
                _preloadedPage++;
            }

            #endregion 滚动条从上往下翻看，加载之面页数

            #region 有上一次的浏览记录时，滚动条从下往上翻看，加载之前页数

            else if (_browsePage > 0 && !_scrollDown && verticalOffset / extentHeight < 0.3 && _stopLoading && _preloadedPage > 0)
            {
                _isLoadPreviousImages = true;
                _isLoadNextImages = false;
                onBottom = true;
                verticalOffset = scrollableHeight;
                _preloadedPage--;
            }

            #endregion 有上一次的浏览记录时，滚动条从下往上翻看，加载之前页数

            _oldVerticalOffset = verticalOffset;
            return onBottom;
        }

        public void Close()
        {
            ClearImages();
        }

        private string GetConclusions(List<LabelConclusion> labelConclusions, ref string trimmingConclusions)
        {
            var conclusions = string.Empty;
            for (int i = 0; i < labelConclusions.Count; i++)
            {
                var item = labelConclusions[i];
                conclusions += $"{item.Title} {item.Content}";
                if (i < labelConclusions.Count - 1)
                    conclusions += Environment.NewLine;

                if (i < 5)
                {
                    trimmingConclusions = conclusions;
                }
                else if (i == 5)
                {
                    trimmingConclusions += "......";
                }
            }
            return conclusions;
        }

        private string GetConclusions(LabeledResult labeledResult, ref string trimmingConclusions)
        {
            var i = 0;
            var conclusions = string.Empty;
            var num = 0;
            if (labeledResult.ImageResults.Any(x => x.Index == 0))
            {
                num = 1;
            }
            foreach (var imageResult in labeledResult.ImageResults)
            {
                conclusions = $"[图像结论-{imageResult.Index + num}] {imageResult.Conclusion.Title}";

                if (i < 5)
                {
                    trimmingConclusions = conclusions;
                }
                else if (i == 5)
                {
                    trimmingConclusions += Environment.NewLine + "......";
                }
                i++;
            }
            num = 0;
            if (labeledResult.Rois.Any(x => x.Index == 0))
            {
                num = 1;
            }
            foreach (var roi in labeledResult.Rois)
            {
                if (roi.Conclusion != null)
                {
                    if (!string.IsNullOrEmpty(conclusions))
                    {
                        conclusions += Environment.NewLine;
                    }

                    conclusions += $"[ROI结论-{roi.Index + num}] {roi.Conclusion.Title}";

                    if (i < 5)
                    {
                        trimmingConclusions = conclusions;
                    }
                    else if (i == 5)
                    {
                        trimmingConclusions += Environment.NewLine + "......";
                    }
                    i++;
                }
            }

            return conclusions;
        }

        private async Task LoadImagesAsync(int page = 0)
        {
            try
            {
                Dispatcher.Invoke(() =>
                {
                    ContentManager.ShowLoading();
                });
                _stopLoading = false;
                if (_developerFolder is DeveloperFolder developerImageFolder)
                {
                    var editable = developerImageFolder.DeveloperId == DeveloperManager.Shared.Session.AccountId;
                    var folderImages = await DeveloperManager.Shared.GetDeveloperFolderFileInfosAsync(developerImageFolder.Id, _keyword, _isQuestioned, page, _pageSize).ConfigureAwait(false);
                    if (_isLoadPreviousImages)
                    {
                        folderImages = folderImages.OrderByDescending(x => x.DeveloperFolderFile.Index).ToList();
                    }
                    foreach (var folderImage in folderImages)
                    {
                        if (_images.Any(x => x.DeveloperFolderFile.Index == folderImage.DeveloperFolderFile.Index))
                        {
                            continue;
                        }

                        var imageData = SkiaSharpHelper.GetLabeledImageData(folderImage.FirstFileArchivedImage.ImageData, folderImage.FirstFileArchivedImage.Width, folderImage.FirstFileArchivedImage.Height, folderImage.FirstFileDeveloperLabeledResult.Rois);
                        var previewImage = new BitmapImage();
                        previewImage.BeginInit();
                        previewImage.StreamSource = new MemoryStream(imageData);
                        previewImage.EndInit();
                        previewImage.Freeze();
                        var trimmingConclusions = string.Empty;
                        var conclusions = GetConclusions(folderImage.FirstFileDeveloperLabeledResult, ref trimmingConclusions);
                        var folderImageEx = new FolderImageEx(folderImage.DeveloperFolderFile, previewImage, editable, folderImage.FirstFileDeveloperLabeledResult, conclusions, trimmingConclusions, page, developerImageFolder.Id);
                        if (_stopLoading)
                        {
                            break;
                        }
                        if (_isLoadPreviousImages)
                        {
                            Dispatcher.Invoke(() =>
                            {
                                _images.Insert(0, folderImageEx);
                            });
                        }
                        else
                        {
                            Dispatcher.Invoke(() =>
                            {
                                _images.Add(folderImageEx);
                            });
                        }
                    }
                }
                else if (_folder is ImageFolderExtend imageFolder)
                {
                    var labeledFileInfos = await DeveloperManager.Shared.GetLatestLabeledFileInfosAsync(imageFolder.Id, _keyword, _isQuestioned, false, page, _pageSize);
                    if (_isLoadPreviousImages)
                    {
                        labeledFileInfos = labeledFileInfos.OrderByDescending(x => x).ToList();
                    }
                    foreach (var fileInfo in labeledFileInfos)
                    {
                        var labeledUltrasoundFile = fileInfo.LabeledUltrasoundFile;
                        if (_images.Any(x => x.LabeledUltrasoundFile.Id == labeledUltrasoundFile.Id))
                        {
                            continue;
                        }
                        var previewImage = new BitmapImage();
                        previewImage.BeginInit();
                        previewImage.StreamSource = new MemoryStream(fileInfo.ImageData);
                        previewImage.EndInit();
                        previewImage.Freeze();
                        var trimmingConclusions = string.Empty;
                        var conclusions = GetConclusions(fileInfo.LabelConclusions, ref trimmingConclusions);
                        var folderImageEx = new FolderImageEx(labeledUltrasoundFile, previewImage, false, fileInfo.LabeledResult, conclusions, trimmingConclusions, page, imageFolder.Id, fileInfo.HasQuestioned);
                        if (_stopLoading)
                        {
                            break;
                        }
                        if (_isLoadPreviousImages)
                        {
                            Dispatcher.Invoke(() =>
                            {
                                _images.Insert(0, folderImageEx);
                            });
                        }
                        else
                        {
                            Dispatcher.Invoke(() =>
                            {
                                _images.Add(folderImageEx);
                            });
                        }
                    }
                }
                _stopLoading = true;

                Dispatcher.Invoke(() =>
                {
                    if (_scrollViewer == null)
                    {
                        _scrollViewer = FindVisualChild<ScrollViewer>(FolderImages);
                        if (_scrollViewer != null)
                        {
                            if (_browseImageIndex == 0)
                            {
                                _scrollViewer.ScrollToTop();
                            }
                            else
                            {
                                var rowHeight = _scrollViewer.ExtentHeight / Math.Ceiling((double)_images.Count / 3);
                                var count = _browseImageIndex % _pageSize;
                                var verticalOffset = Math.Floor((double)count / 3) * rowHeight;
                                _scrollViewer.ScrollToVerticalOffset(verticalOffset);
                            }
                            _scrollViewer.ScrollChanged += OnFolderImagesScrollChanged;
                        }
                    }
                    else if (_isLoadPreviousImages)
                    {
                        var rowHeight = _scrollViewer.ExtentHeight / Math.Ceiling((double)_images.Count / 3);
                        var verticalOffset = _pageSize / 3 * rowHeight + _scrollViewer.VerticalOffset;
                        _scrollViewer.ScrollToVerticalOffset(verticalOffset);
                    }
                });
            }
            catch (Exception ex)
            {
                Dispatcher.Invoke(() =>
                {
                    MessageBox.Show(Application.Current.MainWindow, $"加载文件夹图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                });
            }
            finally
            {
                Dispatcher.Invoke(() =>
                {
                    ContentManager.HideLoading();
                });
            }
        }

        private void ClearImages()
        {
            Reset();

            _folder = null;
            _developerFolder = null;
            FolderName.Text = string.Empty;
            FolderName.ToolTip = string.Empty;
            _keyword = txtFileName.Text = string.Empty;
            txtIndex.Text = string.Empty;
            _totalPages = 0;
            _imageCount = 0;
            chbIsQuestioned.IsChecked = false;
            _isQuestioned = false;
        }

        public async void OnShow(object arg)
        {
            try
            {
                if (arg is ImageFolderExtend imageFolder)
                {
                    _folder = imageFolder;
                    FolderName.Text = _folder.Name;
                    FolderName.ToolTip = _folder.Name;
                    _imageCount = _folder.ImageCount;
                    _totalPages = (int)Math.Ceiling((double)_imageCount / _pageSize);
                    JumpIndex.Visibility = Visibility.Collapsed;

                    //#region 加载历史查看位置
                    //if (_folder is DeveloperImageFolder developerImageFolder)
                    //{
                    //    var findBrowseInfo = await DeveloperManager.Shared.GetDeveloperFolderBrowseHistoricalInfo(developerImageFolder.Id);
                    //    if (findBrowseInfo != null)
                    //    {
                    //        _browseImageIndex = findBrowseInfo.BrowseImageIndex;
                    //        _browsePage = findBrowseInfo.BrowsePage;
                    //        _preloadedPage = findBrowseInfo.BrowsePage;
                    //    }
                    //}
                    //#endregion

                    await LoadImagesAsync(_preloadedPage).ConfigureAwait(false);
                }
                else if (arg is DeveloperFolderExtend developerFolder)
                {
                    _developerFolder = developerFolder;
                    FolderName.Text = _developerFolder.Name;
                    FolderName.ToolTip = _developerFolder.Name;
                    _imageCount = _developerFolder.ImageCount;
                    _totalPages = (int)Math.Ceiling((double)_imageCount / _pageSize);
                    JumpIndex.Visibility = Visibility.Visible;
                    await LoadImagesAsync(_preloadedPage).ConfigureAwait(false);
                }
                else
                {
                    throw new InvalidOperationException("无效的文件夹路径。");
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(Application.Current.MainWindow, $"加载文件夹图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        public void OnHide()
        {
            ClearImages();
        }

        private async void OnImageClick(object sender, RoutedEventArgs e)
        {
            FolderImageEx folderImageEx = null;
            if (sender is MenuItem menuItem)
            {
                folderImageEx = (FolderImageEx)menuItem.DataContext;
            }
            else if (sender is Button button)
            {
                folderImageEx = (FolderImageEx)button.DataContext;
            }

            if (folderImageEx != null)
            {
                if (folderImageEx.LabeledUltrasoundFile != null)
                {
                    var lstFileId = _images.Select(x => x.LabeledUltrasoundFile.UltrasoundFileId).ToList();
                    var lstLabeledFileId = _images.Select(x => x.LabeledUltrasoundFile.Id).ToList();
                    var index = lstFileId.IndexOf(folderImageEx.LabeledUltrasoundFile.UltrasoundFileId);
                    var folderImageViewer = new FolderImageViewer(folderImageEx.SourceFolderId, index, folderImageEx.LabeledUltrasoundFile, lstFileId, lstLabeledFileId) { Owner = Application.Current.MainWindow };
                    folderImageViewer.ShowDialog();
                }
                else
                {
                    var developerLabeledUltrasoundFile = await DeveloperManager.Shared.GetDeveloperLabeledUltrasoundFileAsync(folderImageEx.DeveloperFolderFile.DeveloperLabeledUltrasoundInfoList[0].DeveloperLabeledUltrasoundFileId);
                    var lstFileId = _images.Select(x => x.DeveloperFolderFile.UltrasoundFileId).ToList();
                    var lstIndex = _images.Select(x => x.DeveloperFolderFile.Index).ToList();
                    var lstLabeledFileId = _images.Select(x => x.DeveloperFolderFile.DeveloperLabeledUltrasoundInfoList[0].DeveloperLabeledUltrasoundFileId).ToList();
                    var index = lstFileId.IndexOf(folderImageEx.DeveloperFolderFile.UltrasoundFileId);
                    var folderImageViewer = new FolderImageViewer(folderImageEx.SourceFolderId, index, developerLabeledUltrasoundFile, lstFileId, lstLabeledFileId, lstIndex) { Owner = Application.Current.MainWindow };
                    folderImageViewer.ShowDialog();
                }
            }
        }

        private async void OnDeleteFileClick(object sender, RoutedEventArgs e)
        {
            var menuItem = (MenuItem)sender;
            var folderImageEx = (FolderImageEx)menuItem.DataContext;
            var result = MessageBox.Show(Application.Current.MainWindow, "是否删除该图片?", "删除图片", MessageBoxButton.YesNo, MessageBoxImage.Question);
            if (result == MessageBoxResult.Yes)
            {
                try
                {
                    Dispatcher.Invoke(() =>
                    {
                        ContentManager.ShowLoading();
                    });
                    await DeveloperManager.Shared.DeleteDeveloperFolderFileAsync(folderImageEx.DeveloperFolderFile.Id);
                    Dispatcher.Invoke(() =>
                    {
                        var startIndex = _images.IndexOf(folderImageEx);
                        _images.Remove(folderImageEx);
                        for (int i = startIndex; i < _images.Count; i++)
                        {
                            var image = _images[i];
                            image.DeveloperFolderFile.Index--;
                        }
                        _imageCount--;
                    });
                }
                catch (Exception ex)
                {
                    MessageBox.Show(Application.Current.MainWindow, $"删除图片失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                }
                finally
                {
                    Dispatcher.Invoke(() =>
                    {
                        ContentManager.HideLoading();
                    });
                }
            }
        }

        private async void OnCopyFileClick(object sender, RoutedEventArgs e)
        {
            var menuItem = (MenuItem)sender;
            var folderImageEx = (FolderImageEx)menuItem.DataContext;
            try
            {
                CopyImageWindow copyImageWindow;
                if (folderImageEx.DeveloperFolderFile != null)
                {
                    copyImageWindow = new CopyImageWindow(folderImageEx.DeveloperFolderFile.ImageCategoryId) { Owner = Application.Current.MainWindow };
                }
                else
                {
                    copyImageWindow = new CopyImageWindow(folderImageEx.LabeledUltrasoundFile.ImageCategoryId) { Owner = Application.Current.MainWindow };
                }
                copyImageWindow.ShowDialog();
                var selectedFolder = copyImageWindow.SelectedFolder;
                if (selectedFolder != null)
                {
                    Dispatcher.Invoke(() =>
                    {
                        ContentManager.ShowLoading();
                    });
                    try
                    {
                        if (folderImageEx.DeveloperFolderFile != null)
                        {
                            await DeveloperManager.Shared.CopyDeveloperFolderFileAsync(selectedFolder.Id, folderImageEx.SourceFolderId, folderImageEx.DeveloperFolderFile.UltrasoundFileId);
                        }
                        else
                        {
                            await DeveloperManager.Shared.CopyFolderFileAsync(selectedFolder.Id, folderImageEx.SourceFolderId, folderImageEx.LabeledUltrasoundFile.UltrasoundFileId);
                        }
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(Application.Current.MainWindow, $"复制图片失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                    finally
                    {
                        Dispatcher.Invoke(() =>
                        {
                            ContentManager.HideLoading();
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(Application.Current.MainWindow, $"获取文件夹列表失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        private void OnCloseClick(object sender, RoutedEventArgs e)
        {
            ClearImages();
            this.Hide();
        }

        private void OnSearchFiles(object sender, RoutedEventArgs e)
        {
            _keyword = txtFileName.Text;
            Reset();
            Task.Run(async () =>
            {
                await LoadImagesAsync().ConfigureAwait(false);
            });
        }

        private async void txtIndex_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            try
            {
                if (e.Key == Key.Enter)
                {
                    if (int.TryParse(txtIndex.Text, out var imageIndex))
                    {
                        if (imageIndex >= _imageCount || imageIndex < 0)
                        {
                            MessageBox.Show(Application.Current.MainWindow, $"跳转图像超出索引最大值 {_imageCount - 1}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                            return;
                        }

                        #region Clear
                        Reset();

                        #endregion Clear

                        #region 跳转到指定位置

                        _browseImageIndex = imageIndex;
                        _preloadedPage = _browsePage = (int)Math.Ceiling((double)imageIndex / _pageSize) - 1;

                        await LoadImagesAsync(_preloadedPage).ConfigureAwait(false);

                        #endregion 跳转到指定位置
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(Application.Current.MainWindow, $"跳转图像失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        private void Reset()
        {
            _scrollViewer ??= FindVisualChild<ScrollViewer>(FolderImages);
            if (_scrollViewer != null)
            {
                //#region 保存历史查看位置
                //if (_folder is DeveloperImageFolder developerImageFolder)
                //{
                //    try
                //    {
                //        var rowHeight = _scrollViewer.ExtentHeight / Math.Ceiling((double)_images.Count / 3);
                //        var currRows = Math.Ceiling(_scrollViewer.VerticalOffset / rowHeight);
                //        _browseImageIndex = (int)currRows * 3;
                //        _browsePage = _images[_browseImageIndex].Page;
                //        await DeveloperManager.Shared.UpdateDeveloperFolderBrowseHistoricalInfo(_folder.Id, _browseImageIndex, _browsePage);
                //    }
                //    catch (Exception ex)
                //    {
                //        MessageBox.Show(Application.Current.MainWindow, $"保存文件夹浏览记录失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                //    }
                //}
                //#endregion

                _scrollViewer.ScrollChanged -= OnFolderImagesScrollChanged;
            }
            _stopLoading = true;
            _scrollViewer = null;
            _images.Clear();
            _preloadedPage = 0;
            _isLoadPreviousImages = false;
            _isLoadNextImages = false;
            _scrollDown = false;
            _oldVerticalOffset = 0;
            _browseImageIndex = 0;
            _browsePage = 0;
        }

        private void OnClearAndSearchFiles(object sender, RoutedEventArgs e)
        {
            _keyword = txtFileName.Text = string.Empty;
            txtIndex.Text = string.Empty;
            OnSearchFiles(sender, e);
        }

        private void txtFileName_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter)
            {
                OnSearchFiles(sender, e);
            }
        }

        private async void OnSuspectedMislabeledFileClick(object sender, RoutedEventArgs e)
        {
            var menuItem = (MenuItem)sender;
            var folderImageEx = (FolderImageEx)menuItem.DataContext;
            try
            {
                CopyImageWindow copyImageWindow;
                if (folderImageEx.DeveloperFolderFile != null)
                {
                    copyImageWindow = new CopyImageWindow(folderImageEx.DeveloperFolderFile.ImageCategoryId) { Owner = Application.Current.MainWindow };
                }
                else
                {
                    copyImageWindow = new CopyImageWindow(folderImageEx.LabeledUltrasoundFile.ImageCategoryId) { Owner = Application.Current.MainWindow };
                }
                copyImageWindow.ShowDialog();
                var selectedFolder = copyImageWindow.SelectedFolder;
                if (selectedFolder != null)
                {
                    Dispatcher.Invoke(() =>
                    {
                        ContentManager.ShowLoading();
                    });
                    try
                    {
                        if (folderImageEx.DeveloperFolderFile != null)
                        {
                            await DeveloperManager.Shared.CopyDeveloperFolderFileAsync(selectedFolder.Id, folderImageEx.SourceFolderId, folderImageEx.DeveloperFolderFile.UltrasoundFileId);
                        }
                        else
                        {
                            await DeveloperManager.Shared.CopyFolderFileAsync(selectedFolder.Id, folderImageEx.SourceFolderId, folderImageEx.LabeledUltrasoundFile.UltrasoundFileId);
                        }
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(Application.Current.MainWindow, $"复制图片失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                    }
                    finally
                    {
                        Dispatcher.Invoke(() =>
                        {
                            ContentManager.HideLoading();
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(Application.Current.MainWindow, $"获取文件夹列表失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
            }
        }

        private void OnQuestionedFilesClick(object sender, RoutedEventArgs e)
        {
            _isQuestioned = (bool)chbIsQuestioned.IsChecked;
            OnSearchFiles(sender, e);
        }
    }
}