XplorePlane/XplorePlane/ViewModels/Main/ViewportPanelViewModel.cs

using Prism.Commands;
using Prism.Events;
using Prism.Mvvm;
using System;
using System.Windows;
using System.Windows.Media;
using XP.Common.Logging.Interfaces;
using XplorePlane.Events;
using XplorePlane.Services.MainViewport;

namespace XplorePlane.ViewModels
{
    /// <summary>
    /// 主界面实时图像 ViewModel，统一承接显示状态和测量状态。
    /// </summary>
    public class ViewportPanelViewModel : BindableBase
    {
        private readonly ILoggerService _logger;
        private readonly IMainViewportService _mainViewportService;
        private readonly IEventAggregator _eventAggregator;

        private ImageSource _imageSource;
        private string _imageInfo = "等待探测器图像...";
        private MeasurementToolMode _currentMeasurementMode = MeasurementToolMode.None;
        private Point? _measurePoint1;
        private Point? _measurePoint2;
        private string _measurementResult;

        public ViewportPanelViewModel(
            IMainViewportService mainViewportService,
            IEventAggregator eventAggregator,
            ILoggerService logger)
        {
            _mainViewportService = mainViewportService ?? throw new ArgumentNullException(nameof(mainViewportService));
            _eventAggregator = eventAggregator ?? throw new ArgumentNullException(nameof(eventAggregator));
            _logger = logger?.ForModule<ViewportPanelViewModel>() ?? throw new ArgumentNullException(nameof(logger));

            CancelMeasurementCommand = new DelegateCommand(ExecuteCancelMeasurement);

            _mainViewportService.StateChanged += OnMainViewportStateChanged;
            _eventAggregator.GetEvent<MeasurementToolEvent>()
                .Subscribe(OnMeasurementToolActivated, ThreadOption.UIThread);

            UpdateFromState(updateInfo: true);
        }

        public ImageSource ImageSource
        {
            get => _imageSource;
            set => SetProperty(ref _imageSource, value);
        }

        public string ImageInfo
        {
            get => _imageInfo;
            set => SetProperty(ref _imageInfo, value);
        }

        public MeasurementToolMode CurrentMeasurementMode
        {
            get => _currentMeasurementMode;
            set
            {
                if (SetProperty(ref _currentMeasurementMode, value))
                {
                    RaisePropertyChanged(nameof(IsMeasuring));
                    RaisePropertyChanged(nameof(MeasurementModeText));
                }
            }
        }

        public bool IsMeasuring => CurrentMeasurementMode != MeasurementToolMode.None;

        public string MeasurementModeText => CurrentMeasurementMode switch
        {
            MeasurementToolMode.PointDistance => "点点距测量 - 请在图像上点击第一个点",
            MeasurementToolMode.PointLineDistance => "点线距测量 - 请按工具提示继续操作",
            MeasurementToolMode.Angle => "角度测量 - 功能待接入",
            MeasurementToolMode.ThroughHoleFillRate => "通孔填锡率测量 - 功能待接入",
            _ => string.Empty
        };

        public Point? MeasurePoint1
        {
            get => _measurePoint1;
            set => SetProperty(ref _measurePoint1, value);
        }

        public Point? MeasurePoint2
        {
            get => _measurePoint2;
            set => SetProperty(ref _measurePoint2, value);
        }

        public string MeasurementResult
        {
            get => _measurementResult;
            set => SetProperty(ref _measurementResult, value);
        }

        public DelegateCommand CancelMeasurementCommand { get; }

        public void ResetMeasurementState()
        {
            MeasurePoint1 = null;
            MeasurePoint2 = null;
            MeasurementResult = null;

            if (CurrentMeasurementMode == MeasurementToolMode.None)
            {
                ImageInfo = _mainViewportService.CurrentDisplayInfo;
            }
        }

        private void ExecuteCancelMeasurement()
        {
            _eventAggregator.GetEvent<MeasurementToolEvent>().Publish(MeasurementToolMode.None);
            ImageInfo = "测量已取消";
        }

        private void OnMeasurementToolActivated(MeasurementToolMode mode)
        {
            CurrentMeasurementMode = mode;
            ResetMeasurementState();

            if (mode == MeasurementToolMode.None)
            {
                ImageInfo = _mainViewportService.CurrentDisplayInfo;
            }
            else
            {
                ImageInfo = MeasurementModeText;
            }

            _logger.Info("测量工具模式切换: {Mode}", mode);
        }

        private void OnMainViewportStateChanged(object sender, EventArgs e)
        {
            try
            {
                Application.Current?.Dispatcher?.BeginInvoke(new Action(() => UpdateFromState(updateInfo: CurrentMeasurementMode == MeasurementToolMode.None)));
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "刷新主界面实时图像失败");
            }
        }

        private void UpdateFromState(bool updateInfo)
        {
            ImageSource = _mainViewportService.CurrentDisplayImage;

            if (updateInfo)
            {
                ImageInfo = _mainViewportService.CurrentDisplayInfo;
            }
        }
    }
}