Display_D_HP/TeamAAS-VM/Controls/FeederSequence.xaml.cs

using Prism.Commands;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using Team.FFFeederService.Enums;
using Team.FFFeederService.Interfaces;
using Team.FFFeederService.Models;
using TeamAAS_VP;
using TouchSocket.Core;

namespace TeamAAS_VP.Controls
{
    /// <summary>
    /// FeederSequence.xaml 的交互逻辑
    /// </summary>
    public partial class FeederSequence : UserControl, INotifyPropertyChanged
    {
        private bool _manualStop = false;
        public FeederSequence()
        {
            InitializeComponent();
            this.DataContext = this;
            SequenceCollection.Clear();
            for (int i = 1; i <= 26; i++)
            {
                SequenceCollection.Add(i);
                char chn = (char)('A' + i);
            }
        }

        #region 属性
        public IVoiceCoilMotorFeeder Feeder { get; set; }

        private ObservableCollection<int> _SequenceCollection = new ObservableCollection<int>();

        /// <summary>
        /// 序列集
        /// </summary>
        public ObservableCollection<int> SequenceCollection
        {
            get { return _SequenceCollection; }
            set { SetProperty(ref _SequenceCollection, value); }
        }

        private int _SelectedSequence = -1;
        /// <summary>
        /// 当前选中的序列
        /// </summary>
        public int SelectedSequence
        {
            get { return _SelectedSequence; }
            set { SetProperty(ref _SelectedSequence, value); }
        }

        private int _CurrentSequencePartCntMax;
        /// <summary>
        /// 极限值
        /// </summary>
        public int CurrentSequencePartCntMax
        {
            get { return _CurrentSequencePartCntMax; }
            set { SetProperty(ref _CurrentSequencePartCntMax, value); }
        }

        private int _CycleRunningTimes;

        /// <summary>
        /// 循环次数
        /// </summary>
        public int CycleRunningTimes
        {
            get { return _CycleRunningTimes; }
            set { SetProperty(ref _CycleRunningTimes, value); }
        }

        private SingleSequenceActionGroup _CurrentSequenceActionGroup;

        /// <summary>
        /// 序列集
        /// </summary>
        public SingleSequenceActionGroup CurrentSequenceActionGroup
        {
            get { return _CurrentSequenceActionGroup; }
            set { SetProperty(ref _CurrentSequenceActionGroup, value); }
        }

        private SingleSequenceAction _SingleSequenceAction1;
        /// <summary>
        /// 1
        /// </summary>
        public SingleSequenceAction SingleSequenceAction1
        {
            get { return _SingleSequenceAction1; }
            set { SetProperty(ref _SingleSequenceAction1, value); }
        }
        private SingleSequenceAction _SingleSequenceAction2;
        /// <summary>
        /// 2
        /// </summary>
        public SingleSequenceAction SingleSequenceAction2
        {
            get { return _SingleSequenceAction2; }
            set { SetProperty(ref _SingleSequenceAction2, value); }
        }
        private SingleSequenceAction _SingleSequenceAction3;
        /// <summary>
        /// 3
        /// </summary>
        public SingleSequenceAction SingleSequenceAction3
        {
            get { return _SingleSequenceAction3; }
            set { SetProperty(ref _SingleSequenceAction3, value); }
        }
        private SingleSequenceAction _SingleSequenceAction4;
        /// <summary>
        /// 4
        /// </summary>
        public SingleSequenceAction SingleSequenceAction4
        {
            get { return _SingleSequenceAction4; }
            set { SetProperty(ref _SingleSequenceAction4, value); }
        }
        private SingleSequenceAction _SingleSequenceAction5;
        /// <summary>
        /// 5
        /// </summary>
        public SingleSequenceAction SingleSequenceAction5
        {
            get { return _SingleSequenceAction5; }
            set { SetProperty(ref _SingleSequenceAction5, value); }
        }
        private SingleSequenceAction _SingleSequenceAction6;
        /// <summary>
        /// 6
        /// </summary>
        public SingleSequenceAction SingleSequenceAction6
        {
            get { return _SingleSequenceAction6; }
            set { SetProperty(ref _SingleSequenceAction6, value); }
        }
        private SingleSequenceAction _SingleSequenceAction7;
        /// <summary>
        /// 7
        /// </summary>
        public SingleSequenceAction SingleSequenceAction7
        {
            get { return _SingleSequenceAction7; }
            set { SetProperty(ref _SingleSequenceAction7, value); }
        }
        #region 属性视图显示
        private Visibility _IsVisibility1 = Visibility.Collapsed;

        public Visibility IsVisibility1
        {
            get { return _IsVisibility1; }
            set { SetProperty(ref _IsVisibility1, value); }
        }

        private Visibility _IsVisibility1_2 = Visibility.Collapsed;

        public Visibility IsVisibility1_2
        {
            get { return _IsVisibility1_2; }
            set { SetProperty(ref _IsVisibility1_2, value); }
        }

        private Visibility _IsVisibility2 = Visibility.Collapsed;

        public Visibility IsVisibility2
        {
            get { return _IsVisibility2; }
            set { SetProperty(ref _IsVisibility2, value); }
        }

        private Visibility _IsVisibility2_2 = Visibility.Collapsed;

        public Visibility IsVisibility2_2
        {
            get { return _IsVisibility2_2; }
            set { SetProperty(ref _IsVisibility2_2, value); }
        }
        private Visibility _IsVisibility3 = Visibility.Collapsed;

        public Visibility IsVisibility3
        {
            get { return _IsVisibility3; }
            set { SetProperty(ref _IsVisibility3, value); }
        }

        private Visibility _IsVisibility3_2 = Visibility.Collapsed;

        public Visibility IsVisibility3_2
        {
            get { return _IsVisibility3_2; }
            set { SetProperty(ref _IsVisibility3_2, value); }
        }

        private Visibility _IsVisibility4 = Visibility.Collapsed;

        public Visibility IsVisibility4
        {
            get { return _IsVisibility4; }
            set { SetProperty(ref _IsVisibility4, value); }
        }

        private Visibility _IsVisibility4_2 = Visibility.Collapsed;

        public Visibility IsVisibility4_2
        {
            get { return _IsVisibility4_2; }
            set { SetProperty(ref _IsVisibility4_2, value); }
        }
        private Visibility _IsVisibility5 = Visibility.Collapsed;

        public Visibility IsVisibility5
        {
            get { return _IsVisibility5; }
            set { SetProperty(ref _IsVisibility5, value); }
        }

        private Visibility _IsVisibility5_2 = Visibility.Collapsed;

        public Visibility IsVisibility5_2
        {
            get { return _IsVisibility5_2; }
            set { SetProperty(ref _IsVisibility5_2, value); }
        }
        private Visibility _IsVisibility6 = Visibility.Collapsed;

        public Visibility IsVisibility6
        {
            get { return _IsVisibility6; }
            set { SetProperty(ref _IsVisibility6, value); }
        }

        private Visibility _IsVisibility6_2 = Visibility.Collapsed;

        public Visibility IsVisibility6_2
        {
            get { return _IsVisibility6_2; }
            set { SetProperty(ref _IsVisibility6_2, value); }
        }
        private Visibility _IsVisibility7 = Visibility.Collapsed;

        public Visibility IsVisibility7
        {
            get { return _IsVisibility7; }
            set { SetProperty(ref _IsVisibility7, value); }
        }

        private Visibility _IsVisibility7_2 = Visibility.Collapsed;

        public Visibility IsVisibility7_2
        {
            get { return _IsVisibility7_2; }
            set { SetProperty(ref _IsVisibility7_2, value); }
        }
        #endregion
        #endregion

        #region 命令
        private DelegateCommand _SelectSequenceCommand;
        public DelegateCommand SelectSequenceCommand =>
            _SelectSequenceCommand ?? (_SelectSequenceCommand = new DelegateCommand(ExecuteSelectSequenceCommand));

        private DelegateCommand _StartCommand;
        public DelegateCommand StartCommand =>
            _StartCommand ?? (_StartCommand = new DelegateCommand(ExecuteStartCommand));

        private DelegateCommand _StopCommand;
        public DelegateCommand StopCommand =>
            _StopCommand ?? (_StopCommand = new DelegateCommand(ExecuteStopCommand));

        private DelegateCommand _WriteParamCommand;
        public DelegateCommand WriteParamCommand =>
            _WriteParamCommand ?? (_WriteParamCommand = new DelegateCommand(ExecuteWriteParamCommand));

        private DelegateCommand<int?> _SelectActionCommand1;
        public DelegateCommand<int?> SelectActionCommand1 =>
            _SelectActionCommand1 ?? (_SelectActionCommand1 = new DelegateCommand<int?>(ExecuteSelectActionCommand1));

        private DelegateCommand<int?> _SelectActionCommand2;
        public DelegateCommand<int?> SelectActionCommand2 =>
            _SelectActionCommand2 ?? (_SelectActionCommand2 = new DelegateCommand<int?>(ExecuteSelectActionCommand2));

        private DelegateCommand<int?> _SelectActionCommand3;
        public DelegateCommand<int?> SelectActionCommand3 =>
            _SelectActionCommand3 ?? (_SelectActionCommand3 = new DelegateCommand<int?>(ExecuteSelectActionCommand3));
        private DelegateCommand<int?> _SelectActionCommand4;
        public DelegateCommand<int?> SelectActionCommand4 =>
            _SelectActionCommand4 ?? (_SelectActionCommand4 = new DelegateCommand<int?>(ExecuteSelectActionCommand4));
        private DelegateCommand<int?> _SelectActionCommand5;
        public DelegateCommand<int?> SelectActionCommand5 =>
            _SelectActionCommand5 ?? (_SelectActionCommand5 = new DelegateCommand<int?>(ExecuteSelectActionCommand5));
        private DelegateCommand<int?> _SelectActionCommand6;
        public DelegateCommand<int?> SelectActionCommand6 =>
            _SelectActionCommand6 ?? (_SelectActionCommand6 = new DelegateCommand<int?>(ExecuteSelectActionCommand6));
        private DelegateCommand<int?> _SelectActionCommand7;
        public DelegateCommand<int?> SelectActionCommand7 =>
            _SelectActionCommand7 ?? (_SelectActionCommand7 = new DelegateCommand<int?>(ExecuteSelectActionCommand7));
        #endregion

        #region 方法
        /// <summary>
        /// 选中序列时
        /// </summary>
        async void ExecuteSelectSequenceCommand()
        {
            if (SelectedSequence == -1)
            {
                return;
            }
            if (Feeder == null || !Feeder.IsConnected)
            {
                return;
            }
            try
            {
                var id = SelectedSequence;
                CurrentSequenceActionGroup = await Feeder.GetSequenceGroupAsync(id);
                CurrentSequencePartCntMax = CurrentSequenceActionGroup.PartCntMax;

                SingleSequenceAction1 = CurrentSequenceActionGroup.SingleSequenceActions[0];
                SingleSequenceAction2 = CurrentSequenceActionGroup.SingleSequenceActions[1];
                SingleSequenceAction3 = CurrentSequenceActionGroup.SingleSequenceActions[2];
                SingleSequenceAction4 = CurrentSequenceActionGroup.SingleSequenceActions[3];
                SingleSequenceAction5 = CurrentSequenceActionGroup.SingleSequenceActions[4];
                SingleSequenceAction6 = CurrentSequenceActionGroup.SingleSequenceActions[5];
                SingleSequenceAction7 = CurrentSequenceActionGroup.SingleSequenceActions[6];

            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("选中Feeder序列时时出错！", ex);
            }
        }

        /// <summary>
        /// 开始执行序列
        /// </summary>
        async void ExecuteStartCommand()
        {
            if (Feeder == null)
            {
                return;
            }
            if (SelectedSequence == -1)
            {
                return;
            }
            try
            {
                var needToExecute = CycleRunningTimes;
                while (true)
                {
                    var value = await Feeder.StartOneSequenceAsync(SelectedSequence + 1);
                    await Task.Delay(value);
                    needToExecute--;
                    if (needToExecute != 0 && !_manualStop) continue;
                    _manualStop = !_manualStop;
                    break;
                }

            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("执行Feeder序列时出错！", ex);
            }
        }

        /// <summary>
        /// 停止执行序列
        /// </summary>
        async void ExecuteStopCommand()
        {
            try
            {
                if (Feeder == null)
                {
                    return;
                }

                await Feeder.StopOneSequenceAsync();
                _manualStop = true;
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("停止Feeder序列时出错！", ex);
            }
        }

        /// <summary>
        /// 下载
        /// </summary>
        async void ExecuteWriteParamCommand()
        {
            try
            {
                var singleSequenceActions = new[]
            {
                SingleSequenceAction1,SingleSequenceAction2,SingleSequenceAction3,
                SingleSequenceAction4,SingleSequenceAction5,SingleSequenceAction6,
                SingleSequenceAction7
            };
                for (var i = 0; i < singleSequenceActions.Length; i++)
                {
                    await Feeder.SetSequenceAsync(SelectedSequence, i, singleSequenceActions[i]);
                }
                await Feeder.SaveSequenceAsync();
            }
            catch (Exception ex)
            {
                LogHelper.WriteLogError("保存Feeder序列时出错！", ex);
            }
        }

        /// <summary>
        /// 选择动作1时触发
        /// </summary>
        void ExecuteSelectActionCommand1(int? index)
        {
            switch (index)
            {
                case null:
                    return;
                case 1:
                    IsVisibility1 = Visibility.Visible;
                    IsVisibility1_2 = Visibility.Visible;
                    break;
                case 2:
                    IsVisibility1 = Visibility.Visible;
                    IsVisibility1_2 = Visibility.Visible;
                    break;
                case 3:
                    IsVisibility1 = Visibility.Collapsed;
                    IsVisibility1_2 = Visibility.Visible;
                    break;
                default:
                    IsVisibility1 = Visibility.Collapsed;
                    IsVisibility1_2 = Visibility.Collapsed;
                    break;
            }
        }
        /// <summary>
        /// 选择动作2时触发
        /// </summary>
        void ExecuteSelectActionCommand2(int? index)
        {
            switch (index)
            {
                case null:
                    return;
                case 1:
                    IsVisibility2 = Visibility.Visible;
                    IsVisibility2_2 = Visibility.Visible;
                    break;
                case 2:
                    IsVisibility2 = Visibility.Visible;
                    IsVisibility2_2 = Visibility.Visible;
                    break;
                case 3:
                    IsVisibility2 = Visibility.Collapsed;
                    IsVisibility2_2 = Visibility.Visible;
                    break;
                default:
                    IsVisibility2 = Visibility.Collapsed;
                    IsVisibility2_2 = Visibility.Collapsed;
                    break;
            }
        }

        /// <summary>
        /// 选择动作3时触发
        /// </summary>
        void ExecuteSelectActionCommand3(int? index)
        {
            switch (index)
            {
                case null:
                    return;
                case 1:
                    IsVisibility3 = Visibility.Visible;
                    IsVisibility3_2 = Visibility.Visible;
                    break;
                case 2:
                    IsVisibility3 = Visibility.Visible;
                    IsVisibility3_2 = Visibility.Visible;
                    break;
                case 3:
                    IsVisibility3 = Visibility.Collapsed;
                    IsVisibility3_2 = Visibility.Visible;
                    break;
                default:
                    IsVisibility3 = Visibility.Collapsed;
                    IsVisibility3_2 = Visibility.Collapsed;
                    break;
            }
        }
        /// <summary>
        /// 选择动作4时触发
        /// </summary>
        void ExecuteSelectActionCommand4(int? index)
        {
            switch (index)
            {
                case null:
                    return;
                case 1:
                    IsVisibility4 = Visibility.Visible;
                    IsVisibility4_2 = Visibility.Visible;
                    break;
                case 2:
                    IsVisibility4 = Visibility.Visible;
                    IsVisibility4_2 = Visibility.Visible;
                    break;
                case 3:
                    IsVisibility4 = Visibility.Collapsed;
                    IsVisibility4_2 = Visibility.Visible;
                    break;
                default:
                    IsVisibility4 = Visibility.Collapsed;
                    IsVisibility4_2 = Visibility.Collapsed;
                    break;
            }
        }
        /// <summary>
        /// 选择动作5时触发
        /// </summary>
        void ExecuteSelectActionCommand5(int? index)
        {
            switch (index)
            {
                case null:
                    return;
                case 1:
                    IsVisibility5 = Visibility.Visible;
                    IsVisibility5_2 = Visibility.Visible;
                    break;
                case 2:
                    IsVisibility5 = Visibility.Visible;
                    IsVisibility5_2 = Visibility.Visible;
                    break;
                case 3:
                    IsVisibility5 = Visibility.Collapsed;
                    IsVisibility5_2 = Visibility.Visible;
                    break;
                default:
                    IsVisibility5 = Visibility.Collapsed;
                    IsVisibility5_2 = Visibility.Collapsed;
                    break;
            }
        }
        /// <summary>
        /// 选择动作6时触发
        /// </summary>
        void ExecuteSelectActionCommand6(int? index)
        {
            switch (index)
            {
                case null:
                    return;
                case 1:
                    IsVisibility6 = Visibility.Visible;
                    IsVisibility6_2 = Visibility.Visible;
                    break;
                case 2:
                    IsVisibility6 = Visibility.Visible;
                    IsVisibility6_2 = Visibility.Visible;
                    break;
                case 3:
                    IsVisibility6 = Visibility.Collapsed;
                    IsVisibility6_2 = Visibility.Visible;
                    break;
                default:
                    IsVisibility6 = Visibility.Collapsed;
                    IsVisibility6_2 = Visibility.Collapsed;
                    break;
            }
        }
        /// <summary>
        /// 选择动作7时触发
        /// </summary>
        void ExecuteSelectActionCommand7(int? index)
        {
            switch (index)
            {
                case null:
                    return;
                case 1:
                    IsVisibility7 = Visibility.Visible;
                    IsVisibility7_2 = Visibility.Visible;
                    break;
                case 2:
                    IsVisibility7 = Visibility.Visible;
                    IsVisibility7_2 = Visibility.Visible;
                    break;
                case 3:
                    IsVisibility7 = Visibility.Collapsed;
                    IsVisibility7_2 = Visibility.Visible;
                    break;
                default:
                    IsVisibility7 = Visibility.Collapsed;
                    IsVisibility7_2 = Visibility.Collapsed;
                    break;
            }
        }
        #endregion

        #region 属性更改通知
        /// <summary>
        /// Occurs when a property value changes.
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// Checks if a property already matches a desired value. Sets the property and
        /// notifies listeners only when necessary.
        /// </summary>
        /// <typeparam name="T">Type of the property.</typeparam>
        /// <param name="storage">Reference to a property with both getter and setter.</param>
        /// <param name="value">Desired value for the property.</param>
        /// <param name="propertyName">Name of the property used to notify listeners. This
        /// value is optional and can be provided automatically when invoked from compilers that
        /// support CallerMemberName.</param>
        /// <returns>True if the value was changed, false if the existing value matched the
        /// desired value.</returns>
        protected virtual bool SetProperty<T>(ref T storage, T value, [CallerMemberName] string propertyName = null)
        {
            if (EqualityComparer<T>.Default.Equals(storage, value)) return false;

            storage = value;
            RaisePropertyChanged(propertyName);

            return true;
        }

        /// <summary>
        /// Checks if a property already matches a desired value. Sets the property and
        /// notifies listeners only when necessary.
        /// </summary>
        /// <typeparam name="T">Type of the property.</typeparam>
        /// <param name="storage">Reference to a property with both getter and setter.</param>
        /// <param name="value">Desired value for the property.</param>
        /// <param name="propertyName">Name of the property used to notify listeners. This
        /// value is optional and can be provided automatically when invoked from compilers that
        /// support CallerMemberName.</param>
        /// <param name="onChanged">Action that is called after the property value has been changed.</param>
        /// <returns>True if the value was changed, false if the existing value matched the
        /// desired value.</returns>
        protected virtual bool SetProperty<T>(ref T storage, T value, Action onChanged, [CallerMemberName] string propertyName = null)
        {
            if (EqualityComparer<T>.Default.Equals(storage, value)) return false;

            storage = value;
            onChanged?.Invoke();
            RaisePropertyChanged(propertyName);

            return true;
        }

        /// <summary>
        /// Raises this object's PropertyChanged event.
        /// </summary>
        /// <param name="propertyName">Name of the property used to notify listeners. This
        /// value is optional and can be provided automatically when invoked from compilers
        /// that support <see cref="CallerMemberNameAttribute"/>.</param>
        protected void RaisePropertyChanged([CallerMemberName] string propertyName = null)
        {
            OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
        }

        /// <summary>
        /// Raises this object's PropertyChanged event.
        /// </summary>
        /// <param name="args">The PropertyChangedEventArgs</param>
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs args)
        {
            PropertyChanged?.Invoke(this, args);
        }
        #endregion
    }
}