Virgo_D_SLN/Virgo_DUI/Controls/Parts/SingleArmRobot.xaml.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using Bolt.Toolkit.Wpf.Data;

namespace Virgo_DUI.Client.Controls.Parts
{
	/// <summary>
	/// SingleArmRobot.xaml 的交互逻辑
	/// </summary>
	public partial class SingleArmRobot : UserControl, INotifyPropertyChanged
	{
		protected int moveTime = 300;

		private const int AnimationTimeout = 3000;

		private string CurrentPosition
		{
			get; set;
		}

		public int MoveTime
		{
			get => moveTime;
			set
			{
				moveTime = value;
			}
		}

		public int RotateAngle
		{
			get { return (int)GetValue(RotateAngleProperty); }
			set { SetValue(RotateAngleProperty, value); }
		}

		// Using a DependencyProperty as the backing store for RotateAngel.  This enables animation, styling, binding, etc...
		public static readonly DependencyProperty RotateAngleProperty =
			DependencyProperty.Register("RotateAngel", typeof(int), typeof(SingleArmRobot), new PropertyMetadata(0));

		public Dictionary<string, StationPosition> StationPosition
		{
			get { return (Dictionary<string, StationPosition>)GetValue(StationPositionProperty); }
			set { SetValue(StationPositionProperty, value); }
		}

		// Using a DependencyProperty as the backing store for StationPosition.  This enables animation, styling, binding, etc...
		public static readonly DependencyProperty StationPositionProperty =
			DependencyProperty.Register("StationPosition", typeof(Dictionary<string, StationPosition>), typeof(SingleArmRobot), new PropertyMetadata(null, StationPositionChangedCallback));

		public RobotMoveInfo RobotMoveInfo
		{
			get { return (RobotMoveInfo)GetValue(RobotMoveInfoProperty); }
			set { SetValue(RobotMoveInfoProperty, value); }
		}

		public static readonly DependencyProperty RobotMoveInfoProperty =
			DependencyProperty.Register("RobotMoveInfo", typeof(RobotMoveInfo), typeof(SingleArmRobot), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender));

		public WaferData Wafer
		{
			get { return (WaferData)GetValue(WaferProperty); }
			set { SetValue(WaferProperty, value); }
		}

		// Using a DependencyProperty as the backing store for Wafer.  This enables animation, styling, binding, etc...
		public static readonly DependencyProperty WaferProperty =
			DependencyProperty.Register("Wafer", typeof(WaferData), typeof(SingleArmRobot), new PropertyMetadata(null));

		public string Station
		{
			get { return (string)GetValue(StationProperty); }
			set { SetValue(StationProperty, value); }
		}

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

		public ICommand CreateDeleteWaferCommand
		{
			get { return (ICommand)GetValue(CreateDeleteWaferCommandProperty); }
			set { SetValue(CreateDeleteWaferCommandProperty, value); }
		}

		// Using a DependencyProperty as the backing store for CreateDeleteWaferCommand.  This enables animation, styling, binding, etc...
		public static readonly DependencyProperty CreateDeleteWaferCommandProperty =
			DependencyProperty.Register("CreateDeleteWaferCommand", typeof(ICommand), typeof(SingleArmRobot), new PropertyMetadata(null));

		public ICommand MoveWaferCommand
		{
			get { return (ICommand)GetValue(MoveWaferCommandProperty); }
			set { SetValue(MoveWaferCommandProperty, value); }
		}

		// Using a DependencyProperty as the backing store for MoveWaferCommand.  This enables animation, styling, binding, etc...
		public static readonly DependencyProperty MoveWaferCommandProperty =
			DependencyProperty.Register("MoveWaferCommand", typeof(ICommand), typeof(SingleArmRobot), new PropertyMetadata(null));

		public bool WaferPresent
		{
			get { return (bool)GetValue(WaferPresentProperty); }
			set { SetValue(WaferPresentProperty, value); }
		}

		// Using a DependencyProperty as the backing store for WaferPresent.  This enables animation, styling, binding, etc...
		public static readonly DependencyProperty WaferPresentProperty =
			DependencyProperty.Register("WaferPresent", typeof(bool), typeof(SingleArmRobot), new PropertyMetadata(false));

		private List<MenuItem> menu;

		public event PropertyChangedEventHandler PropertyChanged;

		public List<MenuItem> Menu
		{
			get
			{
				return menu;
			}
			set
			{
				menu = value;
				PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Menu"));
			}
		}

		private ICommand MoveCommand
		{
			get; set;
		}

        public Dictionary<string, StationPosition> EfemStationPosition
        {
            get
            {
                return new Dictionary<string, StationPosition>()
                {
                    { "System", new StationPosition() {
                        StartPosition = new RobotPosition() {Root = 160, Arm = 191, Hand = 99 }
                        ,EndPosition = new RobotPosition() {Root = 160, Arm = 191, Hand = 99 }}
                    }
                    ,{ "EfemRobot", new StationPosition() {
                        StartPosition = new RobotPosition() {Root = 160, Arm = 191, Hand = 99 }
                        ,EndPosition = new RobotPosition() {Root = 160, Arm = 191, Hand = 99 }}
                    }
                    ,{ "LP1", new StationPosition() {
                        StartPosition = new RobotPosition() {X=19, Root = 160, Arm = 191, Hand = 99 }
                        ,EndPosition = new RobotPosition() { Root = 96, Arm = 347, Hand = 11 }}
                    }
                    ,{ "LP2", new StationPosition() {
                        StartPosition = new RobotPosition() {X=-20, Root = 160, Arm = 191, Hand = 99 }
                        ,EndPosition = new RobotPosition() { Root = 96, Arm = 347, Hand = 11 }}
                    }
                    ,{ "Aligner1", new StationPosition() {
                        StartPosition = new RobotPosition() {X=73, Root = 160, Arm = 191, Hand = 99 }
                        ,EndPosition = new RobotPosition() { Root = 96, Arm = 347, Hand = 11 }}
                    }
                    ,{ "Aligner2", new StationPosition() {
                        StartPosition = new RobotPosition() {X=100, Root = 160, Arm = 191, Hand = 99 }
                        ,EndPosition = new RobotPosition() { Root = 96, Arm = 347, Hand = 11 }}
                    }
                    ,{ "PMA", new StationPosition() {
                        StartPosition = new RobotPosition() {X=152, Root = 160, Arm = 191, Hand = 99 }
                        ,EndPosition = new RobotPosition() { Root = 96, Arm = 347, Hand = 11 }}
                    }
                    ,{ "PMB", new StationPosition() {
                        StartPosition = new RobotPosition() {X=201, Root = 160, Arm = 191, Hand = 99 }
                        ,EndPosition = new RobotPosition() { Root = 96, Arm = 347, Hand = 11 }}
                    }
                };
            }
        }
        public SingleArmRobot()
		{
			InitializeComponent();
			//root.DataContext = this;

			//MoveCommand = new RelayCommand(MoveTo);

			canvas1.Rotate(90);
			canvas2.Rotate(180);
			canvas3.Rotate(180);

			CurrentPosition = "System";

		    StationPosition = EfemStationPosition;

		}

		static void StationPositionChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
		{
		    return;
		    //following is for test purpose
			//var self = (SingleArmRobot)d;
			//var positions = (Dictionary<string, StationPosition>)e.NewValue;
			//var menus = new List<MenuItem>();
			//foreach (var position in positions)
			//{
			//	var m = new MenuItem() { Header = position.Key };
			//	m.Items.Add(new MenuItem() { Header = "Pick", Command = self.MoveCommand, CommandParameter = new RobotMoveInfo() { BladeTarget = position.Key, Action = Bolt.Toolkit.Wpf.Data.Enum.RobotAction.Picking } });
			//	m.Items.Add(new MenuItem() { Header = "Place", Command = self.MoveCommand, CommandParameter = new RobotMoveInfo() { BladeTarget = position.Key, Action = Bolt.Toolkit.Wpf.Data.Enum.RobotAction.Placing } });
			//	m.Items.Add(new MenuItem() { Header = "Move", Command = self.MoveCommand, CommandParameter = new RobotMoveInfo() { BladeTarget = position.Key, Action = Bolt.Toolkit.Wpf.Data.Enum.RobotAction.None } });
			//	menus.Add(m);
			//}
			//self.Menu = menus;
			//self.MoveTo(new RobotMoveInfo() { BladeTarget = "System", Action = Bolt.Toolkit.Wpf.Data.Enum.RobotAction.None });
		}

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

			if (DesignerProperties.GetIsInDesignMode(this))
			{
				return;
			}

			if (RobotMoveInfo != null)
			{
				

				var needMove = CurrentPosition != RobotMoveInfo.BladeTarget;

				if (needMove)
				{
				    LogMsg(string.Format("Target: {0} - {1}", CurrentPosition, RobotMoveInfo.BladeTarget));
                    Invoke(() => MoveRobot(RobotMoveInfo));
				}
			}
		}

		private void MoveRobot(RobotMoveInfo moveInfo, Action onComplete = null)
		{
			canvas1.Stop();
			canvas2.Stop();
			canvas3.Stop();

			var target = moveInfo.BladeTarget;

		    if (string.IsNullOrEmpty(target))
		        return;

			MoveToStart(CurrentPosition
				, () => MoveToStart(CurrentPosition
				, () => RotateTo(target
				, () => MoveToEnd(target
				, () => UpdateWafer(moveInfo, onComplete)))));
		}

		private void RotateTo(string station, Action onComplete = null)
		{
			var position = StationPosition[station];
			root.Rotate(position.StartPosition.X, true, MoveTime, 0, 0, onComplete);
		}

		private void MoveToStart(string station, Action onComplete = null)
		{
			var position = StationPosition[station];
			canvas1.Rotate(position.StartPosition.Root, true, MoveTime, 0, 0, onComplete);
			canvas2.Rotate(position.StartPosition.Arm, true, MoveTime);
			canvas3.Rotate(position.StartPosition.Hand, true, MoveTime);
			CurrentPosition = station;
		}

		private void MoveToEnd(string station, Action onComplete = null)
		{
			var position = StationPosition[station];
			canvas1.Rotate(position.EndPosition.Root, true, MoveTime, 0, 0, onComplete);
			canvas2.Rotate(position.EndPosition.Arm, true, MoveTime);
			canvas3.Rotate(position.EndPosition.Hand, true, MoveTime);
			CurrentPosition = station;
		}

		private void UpdateWafer(RobotMoveInfo moveInfo, Action onComplete = null)
		{
			switch (moveInfo.Action)
			{
				case Bolt.Toolkit.Wpf.Data.Enum.RobotAction.None:
					break;
				case Bolt.Toolkit.Wpf.Data.Enum.RobotAction.Picking:
					WaferPresent = true;
					break;
				case Bolt.Toolkit.Wpf.Data.Enum.RobotAction.Placing:
					WaferPresent = false;
					break;
				default:
					break;
			}
		}

		private void Invoke(Action action)
		{
			Dispatcher.Invoke(action);
		}

		private void LogMsg(string msg)
		{
			var source = "Robot";
			Console.WriteLine("{0} {1}", source, msg);
		}

		private void MoveTo(object target)
		{
			MoveRobot((RobotMoveInfo)target);
		}
	}
}