FurnaceELK/FrameworkLocal/UICore/Control/AnalogControl4Jet.xaml.cs

using Aitex.Core.UI.ControlDataContext;
using MECF.Framework.UI.Core.ExtendedControls;
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;

namespace Aitex.Core.UI.Control
{
    /// <summary>
    /// Interaction logic for AnalogControl.xaml
    /// </summary>
    public partial class AnalogControl4Jet : UserControl
    {
        public AnalogControl4Jet()
        {
            InitializeComponent();
        }
        public string ViewName
        {
            get { return (string)this.GetValue(ViewNameProperty); }
            set { this.SetValue(ViewNameProperty, value); }
        }

        // Using a DependencyProperty as the backing store for MenuVisibility.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ViewNameProperty =
            DependencyProperty.Register("ViewName", typeof(string), typeof(AnalogControl4Jet),
                new FrameworkPropertyMetadata(""));


        public bool IsExecute
        {
            get { return (bool)this.GetValue(IsExecuteProperty); }
            set { this.SetValue(IsExecuteProperty, value); }
        }

        // Using a DependencyProperty as the backing store for MenuVisibility.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty IsExecuteProperty =
            DependencyProperty.Register("IsExecute", typeof(bool), typeof(AnalogControl4Jet),
                new FrameworkPropertyMetadata(true));

        // define dependency properties
        public static readonly DependencyProperty CommandProperty = DependencyProperty.Register(
                        "Command", typeof(ICommand), typeof(AnalogControl4Jet),
                        new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender));

        public static readonly DependencyProperty DeviceDataProperty = DependencyProperty.Register(
                      "DeviceData", typeof(AnalogDeviceDataItem), typeof(AnalogControl4Jet),
                      new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender,
                      new PropertyChangedCallback(OnDeviceDataChanged)));

        public static readonly DependencyProperty TagNameProperty = DependencyProperty.Register(
                  "TagName", typeof(string), typeof(AnalogControl4Jet),
                  new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.AffectsRender));

        public static readonly DependencyProperty OperationNameProperty = DependencyProperty.Register(
                "OperationName", typeof(string), typeof(AnalogControl4Jet),
                new FrameworkPropertyMetadata(AnalogDeviceOperation.Ramp, FrameworkPropertyMetadataOptions.AffectsRender));

        public static readonly DependencyProperty BackColorProperty = DependencyProperty.Register(
                        "BackColor", typeof(Brush), typeof(AnalogControl4Jet),
                         new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender));

        public static readonly DependencyProperty HideDialogProperty = DependencyProperty.Register(
                    "HideDialog", typeof(bool), typeof(AnalogControl4Jet),
                    new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.AffectsRender));

        private double oldFeedBack;

        public static readonly DependencyProperty GasStateTypeProperty = DependencyProperty.Register(
          "GasStateType", typeof(GasPanelStateType), typeof(AnalogControl4Jet),
          new FrameworkPropertyMetadata(GasPanelStateType.Manual, FrameworkPropertyMetadataOptions.AffectsRender, new PropertyChangedCallback(OnDeviceStateTypeChanged)));
        public GasPanelStateType GasStateType
        {
            get
            {
                return (GasPanelStateType)this.GetValue(GasStateTypeProperty);
            }
            set
            {
                this.SetValue(GasStateTypeProperty, value);
            }
        }


        public static readonly DependencyProperty ShowValueProperty = DependencyProperty.Register(
        "ShowValue", typeof(string), typeof(AnalogControl4Jet),
        new FrameworkPropertyMetadata(0.ToString("f3"), FrameworkPropertyMetadataOptions.AffectsArrange));

        public string ShowValue
        {
            get
            {
                return (string)this.GetValue(ShowValueProperty);
            }
            set
            {
                this.SetValue(ShowValueProperty, value);
            }
        }

        public string TagName
        {
            get
            {
                return (string)this.GetValue(TagNameProperty);
            }
            set
            {
                this.SetValue(TagNameProperty, value);
            }
        }


        /// <summary>
        /// 虚拟状态--应对需要显示其他状态的值
        /// </summary>
        public string VirtualGasStateType
        {
            get { return (string)GetValue(VirtualGasStateTypeProperty); }
            set { SetValue(VirtualGasStateTypeProperty, value); }
        }

        // Using a DependencyProperty as the backing store for VirtualGasStateType.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty VirtualGasStateTypeProperty =
            DependencyProperty.Register("VirtualGasStateType", typeof(string), typeof(AnalogControl4Jet), new PropertyMetadata(""));


        private static void OnDeviceStateTypeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            SetDataChanged(d);
        }


        private static void OnDeviceDataChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            SetDataChanged(d);
        }
        private static void SetDataChanged(DependencyObject d)
        {
            var self = (AnalogControl4Jet)d;
            var data = self.DeviceData;
            var gasStateType = self.GasStateType;
            if (data != null)
            {
                switch (gasStateType)
                {
                    case GasPanelStateType.Manual:
                        self.ShowValue = data.SetPoint.ToString("f3");
                        break;
                    case GasPanelStateType.Monitor:
                        self.ShowValue = data.FeedBack.ToString("f3");
                        break;
                    case GasPanelStateType.Recipe:
                        self.ShowValue = data.VirtualFeedBack.ToString("f3");
                        break;
                    default:
                        self.ShowValue = 0.ToString("f3");
                        break;
                }
                self.oldFeedBack = data.FeedBack;

                if (data.DeviceId.Contains("MFM"))
                {
                    self.ViewName = data.DeviceId;
                }
                else
                {
                    self.ViewName = data.DeviceId.Replace("MFC", "");
                }
                ChangedBackground(self);
            }
        }
  
        /// <summary>
        /// 输入值是否百分比，默认否
        /// </summary>
        public bool IsPercent { get; set; }

        public Visibility RampVisibility { get; set; } = Visibility.Collapsed;

        public ICommand Command
        {
            get
            {
                return (ICommand)this.GetValue(CommandProperty);
            }
            set
            {
                this.SetValue(CommandProperty, value);
            }
        }

        /// <summary>
        /// set, get current progress value AnalogDeviceData
        /// </summary>
        public AnalogDeviceDataItem DeviceData
        {
            get
            {

                return (AnalogDeviceDataItem)this.GetValue(DeviceDataProperty);
            }
            set
            {
                this.SetValue(DeviceDataProperty, value);
            }
        }

        public Brush BackColor
        {
            get
            {
                return (Brush)this.GetValue(BackColorProperty);
            }
            set
            {
                this.SetValue(BackColorProperty, value);
            }
        }

        public bool HideDialog
        {
            get
            {
                return (bool)this.GetValue(HideDialogProperty);
            }
            set
            {
                this.SetValue(HideDialogProperty, value);
            }
        }
        private bool _isEdit=false;

        protected override void OnRender(DrawingContext drawingContext)
        {
            base.OnRender(drawingContext);

            //draw background color
            RefreshMFCData();
        }

        private static void ChangedBackground(AnalogControl4Jet analog4Jet)
        {
            BrushConverter brushConverter = new BrushConverter();
            analog4Jet.topBorder.Background = Math.Abs(float.Parse(analog4Jet.ShowValue)) > 0.00001 ? (Brush)brushConverter.ConvertFromString("#FFFFD2") : (Brush)brushConverter.ConvertFromString("#B0D1F1");
            analog4Jet.downBorder.Background = Math.Abs(float.Parse(analog4Jet.ShowValue)) > 0.00001 ? (Brush)brushConverter.ConvertFromString("#FFFFD2") : (Brush)brushConverter.ConvertFromString("#B0D1F1");
            analog4Jet.UpdateLayout();
        }
        public void RefreshMFCData()
        {
            #region FeedBack
            if (DeviceData == null) return;
            //draw red board if mfc meets a warning

            //draw reading value
            //if (IsPercent)
            //    labelValue.Content = (DeviceData.FeedBack * 100).ToString("F1");
            //else
            //    labelValue.Content = DeviceData.FeedBack.ToString("F1");

            labelValue1.Foreground = DeviceData.IsWarning ? Brushes.Pink : Brushes.Black;

            //if (dialogBox != null)
            //{
            //    if (IsPercent)
            //        dialogBox.RealValue = (DeviceData.FeedBack * 100).ToString("F1") + "%";
            //    else
            //        dialogBox.RealValue = DeviceData.FeedBack.ToString("F1");
            //}
            //draw red board if mfc meets a warning
            //draw reading value
            //if (IsPercent)
            //    labelSetPoint.Content = (DeviceData.SetPoint * 100).ToString("F1");
            //else
            //    labelSetPoint.Content = DeviceData.SetPoint.ToString("F1");
            if (DeviceData.DeviceId.Contains("MFM"))
            {
                labelSetPoint.Content = DeviceData.DeviceId;
            }
            else
            {
                labelSetPoint.Content = DeviceData.DeviceId.Replace("MFC", "");
            }

            labelSetPoint.Foreground = DeviceData.IsWarning ? Brushes.Pink : Brushes.Black;
            if (DeviceData != null)
            {
                BrushConverter brushConverter = new BrushConverter();
                var type = GasStateType;
                if(!_isEdit&&Enum.TryParse(VirtualGasStateType,out GasPanelStateType result))
                {
                    type = result;
                }
                switch (type)
                {
                    case GasPanelStateType.Manual:
                        ShowValue = DeviceData.SetPoint.ToString("f3");
                        if (DeviceData.IsCharge)
                        {
                            topBorder.Background = (Brush)brushConverter.ConvertFromString("#FFFFD2");
                            downBorder.Background = (Brush)brushConverter.ConvertFromString("#FFFFD2");
                        }
                        else
                        {
                            topBorder.Background = (Brush)brushConverter.ConvertFromString("#B0D1F1");
                            downBorder.Background = (Brush)brushConverter.ConvertFromString("#B0D1F1");
                        }
                        break;
                    case GasPanelStateType.Monitor:
                        ShowValue = DeviceData.FeedBack.ToString("f3");
                        topBorder.Background = (Brush)brushConverter.ConvertFromString("#B0D1F1");
                        downBorder.Background = (Brush)brushConverter.ConvertFromString("#B0D1F1");
                        break;
                    case GasPanelStateType.Recipe:
                        ShowValue = DeviceData.VirtualFeedBack.ToString("f3");

                        if ("RecipeView".Equals(ViewName))
                        {
                            if (DeviceData.IsCharge || (float.Parse(ShowValue) > 0))
                            {
                                topBorder.Background = (Brush)brushConverter.ConvertFromString("#FFFFD2");
                                downBorder.Background = (Brush)brushConverter.ConvertFromString("#FFFFD2");
                            }
                            else
                            {
                                topBorder.Background = (Brush)brushConverter.ConvertFromString("#B0D1F1");
                                downBorder.Background = (Brush)brushConverter.ConvertFromString("#B0D1F1");
                            }
                        }

                        break;
                    default:
                        ShowValue = 0.ToString("f3");
                        break;
                }
            }


            #endregion
        }

        private void RefreshMFCData(AnalogDeviceDataItem data)
        {
            #region FeedBack
            if (data == null) return;
            //draw red board if mfc meets a warning

            //draw reading value
            //if (IsPercent)
            //    labelValue.Content = (data.FeedBack * 100).ToString("F1");
            //else
            //    labelValue.Content = data.FeedBack.ToString("F1");

            labelValue1.Foreground = data.IsWarning ? Brushes.Pink : Brushes.Black;

            //if (dialogBox != null)
            //{
            //    if (IsPercent)
            //        dialogBox.RealValue = (data.FeedBack * 100).ToString("F1") + "%";
            //    else
            //        dialogBox.RealValue = data.FeedBack.ToString("F1");
            //}
            //draw red board if mfc meets a warning
            //draw reading value
            //if (IsPercent)
            //    labelSetPoint.Content = (DeviceData.SetPoint * 100).ToString("F1");
            //else
            //    labelSetPoint.Content = DeviceData.SetPoint.ToString("F1");
            if (data.DeviceId.Contains("MFM"))
            {
                labelSetPoint.Content = data.DeviceId.Replace("MFM", "");
            }
            else
            {
                labelSetPoint.Content = data.DeviceId.Replace("MFC", "");
            }
            if (DeviceData != null)
            {
                switch (GasStateType)
                {
                    case GasPanelStateType.Manual:
                    case GasPanelStateType.Monitor:
                        ShowValue = data.FeedBack.ToString("f3");
                        break;
                    case GasPanelStateType.Recipe:
                        ShowValue = data.VirtualFeedBack.ToString("f3");
                        break;
                    default:
                        ShowValue = 0.ToString("f3");
                        break;
                }
            }
            labelSetPoint.Foreground = data.IsWarning ? Brushes.Pink : Brushes.Black;
            #endregion
        }

        ///// <summary>   
        ///// 设置鼠标的坐标   
        ///// </summary>   
        ///// <param name="x">横坐标</param>   
        ///// <param name="y">纵坐标</param>   
        //[DllImport("User32")]
        //public extern static void SetCursorPos(int x, int y);

        //  private InputDialogBox dialogBox;

        public Window AnalogOwner { get; set; }

        private void Grid_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            if (e.StylusDevice != null) e.Handled = true;//认为误触
            else Grid_TouchUp(sender, null);
        }


        private void ExecuteOrNull(double value, double? ramp)
        {
           
                Execute(value, ramp);

        }
        private void Execute(double value, double? ramp)
        {
            if (!IsExecute)
            {
                return;
            }
            switch (GasStateType)
            {
                case GasPanelStateType.Manual:
                    if (ramp != null)
                    {
                        Command.Execute(new object[] { DeviceData.DeviceName, DeviceData.Type.Equals("MFC") ? "SetMfcValue" : "SetMfmValue", value, ramp });
                    }
                    else
                    {
                        Command.Execute(new object[] { DeviceData.DeviceName, DeviceData.Type.Equals("MFC") ? "SetMfcValue" : "SetMfmValue", value });
                    }
                    break;
                case GasPanelStateType.Monitor:
                    break;
                case GasPanelStateType.Recipe:
                    Command.Execute(new object[] { DeviceData.DeviceName, DeviceData.Type.Equals("MFC") ? "SetMfcVirtualValue" : "SetMfmValue", value });
                    break;
                default:
                    break;
            }

        }


        private void Grid_MouseEnter(object sender, MouseEventArgs e)
        {
            if (DeviceData != null)
            {
                string tooltipValue =
                    string.Format("{0}：{1}\r\n\r\nID：{2}\r\nScale：{3} {4}\r\nSetPoint：{5} {4} \r\nFeedback：{6} {4}\r\nTolerance：{7}%\r\nStatus：{8}",
                        DeviceData.Type,
                        DeviceData.DisplayName,
                        DeviceData.DeviceId,
                        DeviceData.Scale,
                        DeviceData.Unit,
                        IsPercent ? (DeviceData.SetPoint * 100).ToString("F1") + "%" : DeviceData.SetPoint.ToString("F1"),
                        IsPercent ? (DeviceData.FeedBack * 100).ToString("F1") + "%" : DeviceData.FeedBack.ToString("F1"),
                        DeviceData.Scale > 0 ? ((DeviceData.FeedBack - DeviceData.SetPoint) / DeviceData.Scale * 100).ToString("F1") : "0",
                        DeviceData.IsWarning ? "Tolerance Warning" : "Normal");

                ToolTip = tooltipValue;
            }
        }

        private void Grid_TouchUp(object sender, TouchEventArgs e)
        {
            _isEdit = true;
            if (DeviceData == null|| GasStateType == GasPanelStateType.Monitor|| HideDialog)
            {
                _isEdit = false; 
                return;
            }
            BrushConverter brushConverter = new BrushConverter();
            InputDialogBox dialogBox = new InputDialogBox
            {
                CommandDelegate = ExecuteOrNull,
                DeviceName = string.Format("{0}: {1}", DeviceData.Type, DeviceData.DisplayName),
                DeviceId = DeviceData.DeviceId,
                DefaultValue = DeviceData.DefaultValue,
                RealValue = DeviceData.FeedBack.ToString("F1"),
                SetPoint = Math.Round(DeviceData.SetPoint, 1),
                MaxValue = DeviceData.Scale,
                Unit = DeviceData.Unit,
                TagName = TagName,
                RampValue = DeviceData.RampValue,
                RampMaxValue = DeviceData.RampMaxValue,
                RampMinValue = DeviceData.RampMinValue,
                RampVisibility = (GasStateType == GasPanelStateType.Manual && RampVisibility == Visibility.Visible) ? Visibility.Visible : Visibility.Collapsed
            };

            dialogBox.IsPercent = IsPercent;
            if (IsPercent)
                dialogBox.SetPoint = Math.Round(DeviceData.SetPoint * 100.0, 1);
            if (AnalogOwner != null)
                dialogBox.Owner = AnalogOwner;
            dialogBox.Topmost = false;
            dialogBox.WindowStartupLocation = WindowStartupLocation.CenterScreen;
            //dialogBox.FocasAll();
            if ((bool)dialogBox.ShowDialog())
            {
                if (!string.IsNullOrEmpty(dialogBox.inputBox.Text))
                {
                    ShowValue = dialogBox.inputBox.Text;

                    if (double.Parse(dialogBox.inputBox.Text) != DeviceData.FeedBack)
                    {
                        DeviceData.IsCharge = true;
                    }
                    else
                    {
                        DeviceData.IsCharge = false;
                    }

                    DeviceData.SetValue = double.Parse(dialogBox.inputBox.Text);
                }
                if (RampVisibility == Visibility.Visible && GasStateType == GasPanelStateType.Manual)
                {
                    if (!string.IsNullOrEmpty(dialogBox.inputRampBox.Text))
                    {
                        if (double.Parse(dialogBox.inputRampBox.Text) != DeviceData.RampValue)
                        {
                            DeviceData.IsRampCharge = true;
                        }
                        else
                        {
                            DeviceData.IsRampCharge = false;
                        }
                        DeviceData.SetRampValue = double.Parse(dialogBox.inputRampBox.Text);
                    }
                }
            }
            //SetCursorPos(0, 0);
            dialogBox.Close();
            dialogBox.Dispose();
            RefreshMFCData();
            _isEdit = false;
        }
    }
}