OHV/Dev/OHV/OHV.Vehicle/Concept/D_MainWindowViewModel.cs

using CommonServiceLocator;
using GSG.NET.Extensions;
using GSG.NET.Logging;
using GSG.NET.Utils;
using OHV.Common.Events;
using OHV.Common.Model;
using OHV.Common.Shareds;
using OHV.LanguageHelper;
using OHV.Module.Interactivity;
using OHV.SqliteDAL;
using Prism.Commands;
using Prism.Events;
using Prism.Mvvm;
using Prism.Regions;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Threading;
using VehicleControlSystem;

namespace OHV.Vehicle.Concept
{
    public enum eBatteryState
    {
        DisConnect,
        Connect,
        Charge,
    }
    class D_MainWindowViewModel : BindableBase
    {
        #region Properties
        private string _title = "Prism Unity Application";
        public string Title
        {
            get { return _title; }
            set { SetProperty( ref _title, value ); }
        }

        private double _cpu;
        public double CPU
        {
            get { return this._cpu; }
            set { this.SetProperty( ref this._cpu, value ); }
        }

        private double _totalCPU;
        public double TotalCPU
        {
            get { return this._totalCPU; }
            set
            {
                //this._totalCPU = dti.cpuResult.ToString();
                this.SetProperty( ref this._totalCPU, value );
            }
        }

        public int UsageCPU { get; set; }
        private double _ram;
        public double RAM
        {
            get { return this._ram; }
            set { this.SetProperty( ref this._ram, value ); }
        }

        private double _cDrive;
        public double CDrive
        {
            get { return this._cDrive; }
            set { this.SetProperty( ref this._cDrive, value ); }
        }

        DateTime _dateTime;
        public DateTime DateTime
        {
            get { return _dateTime; }
            set
            {
                this.SetProperty( ref _dateTime, value );
            }
        }

        private string _vehicleID;
        public string VehicleID
        {
            get { return this._vehicleID; }
            set { this.SetProperty( ref this._vehicleID, value ); }
        }

        private string _vehicleIP = "127.0.0.1";
        public string VehicleIP
        {
            get { return this._vehicleIP; }
            set { this.SetProperty( ref this._vehicleIP, value ); }
        }
        private string _ocsIP;
        public string OcsIP
        {
            get { return this._ocsIP; }
            set { this.SetProperty( ref this._ocsIP, value ); }
        }

        private string _swVersion;
        public string SwVersion
        {
            get { return this._swVersion; }
            set { this.SetProperty( ref this._swVersion, value ); }
        }

        bool _startEnable = true;
        public bool StartEnable
        {
            get { return this._startEnable; }
            set { this.SetProperty( ref this._startEnable, value ); }
        }

        bool _stopEnable = false;
        public bool StopEnable
        {
            get { return this._stopEnable; }
            set { this.SetProperty( ref this._stopEnable, value ); }
        }

        private DateTime _lastBuildedTime;
        public DateTime LastBuildedTime
        {
            get { return this._lastBuildedTime; }
            set { this.SetProperty( ref this._lastBuildedTime, value ); }
        }

        private bool isManualMode = true;
        public bool IsManualMode
        {
            get { return isManualMode; }
            set { SetProperty( ref isManualMode, value ); }
        }

        private bool isVehicleAlarm = false;
        public bool IsVehicleAlarm
        {
            get { return isVehicleAlarm; }
            set { SetProperty( ref this.isVehicleAlarm, value ); }
        }

        private eMachineMode machineMode = eMachineMode.LocalMode;
        public eMachineMode MachineMode
        {
            get { return machineMode; }
            set { SetProperty( ref this.machineMode, value ); }
        }

        eOcsState ocsState = eOcsState.DisConnect;
        public eOcsState OcsState
        {
            get { return this.ocsState; }
            set { this.SetProperty( ref this.ocsState, value ); }
        }

        eBatteryState batteryState = eBatteryState.DisConnect;
        public eBatteryState BatteryState
        {
            get { return this.batteryState; }
            set { this.SetProperty( ref this.batteryState, value ); }
        }

        string currentTag = "None";
        public string CurrentTag
        {
            get { return this.currentTag; }
            set { this.SetProperty( ref this.currentTag, value ); }
        }

        private bool isDryRun;

        public bool IsDryRun
        {
            get { return isDryRun; }
            set { SetProperty( ref this.isDryRun, value ); }
        }

        private string currentMCR = "None";

        public string CurrentMCR
        {
            get { return currentMCR; }
            set { SetProperty( ref this.currentMCR, value ); }
        }

        private bool isDriveConnected = false;
        public bool IsDriveConnected
        {
            get { return isDriveConnected; }
            set { SetProperty( ref this.isDriveConnected, value ); }
        }

        private bool isOnRoute;
        public bool IsOnRoute
        {
            get { return isOnRoute; }
            set { SetProperty(ref this.isOnRoute, value); }
        }

        private bool isBusy;

        public bool IsBusy
        {
            get { return isBusy; }
            set { SetProperty( ref this.isBusy, value ); }
        }

        private int timeOutLimit;

        public int TimeOutLimit
        {
            get { return timeOutLimit; }
            set { SetProperty( ref this.timeOutLimit, value ); }
        }

        private string busyText;

        public string BusyText
        {
            get { return busyText; }
            set { SetProperty( ref this.busyText, value ); }
        }

        eVehicleOnRailState vehicleOnRailState = eVehicleOnRailState.None;
        public eVehicleOnRailState VehicleOnRailState
        {
            get => this.vehicleOnRailState;
            set => SetProperty(ref this.vehicleOnRailState, value);
        }

        #endregion

        #region Brushes
        private Brush _ocsBrush;

        public Brush OcsBrush
        {
            get { return _ocsBrush; }
            set
            {
                SetProperty( ref _ocsBrush, value );
            }
        }

        private Brush batteryBrush;

        public Brush BatteryBrush
        {
            get { return batteryBrush; }
            set
            {
                SetProperty( ref batteryBrush, value );
            }
        }

        double soc;
        public double SOC
        {
            get { return this.soc; }
            set { this.SetProperty( ref this.soc, value ); }
        }

        #endregion

        #region Commands
        public ICommand TestCommand { get; set; }
        public ICommand NavigateCommand { get; set; }
        public ICommand SystemOffCommand { get; set; }
        public ICommand BuzzerStopCommand { get; set; }
        public ICommand EmergencyStopCommand { get; set; }
        public ICommand StartCommand { get; set; }
        public ICommand StopCommand { get; set; }
        public ICommand AlarmResetCommand { get; set; }
        public ICommand ChangeLanguage { get; set; }
        public ICommand MachineModeChgCommand { get; set; }
        public ICommand BatteryPopup { get; set; }
        public ICommand VehicleRailOnStateChgCommand { get; set; }
        public ICommand SelectLanguageCommand { get; set; }

        #endregion

        static Logger logger = Logger.GetLogger();
        private AutoResetEvent eventBusy = new AutoResetEvent( false );

        IEventAggregator eventAggregator = null;
        IRegionManager regionManager;
        VCSystem VCSystem = null;
        MessageController messageController;
        VCSMessagePubSubEvent vcsMessagePublisher;
        SqliteManager sql;

        public D_MainWindowViewModel( IEventAggregator _ea, VCSystem cSystem, IRegionManager _regionManager, MessageController _msgController, SqliteManager _sql )
        {
            this.regionManager = _regionManager;

            this.eventAggregator = _ea;
            this.eventAggregator.GetEvent<GUIMessagePubSubEvent>().Subscribe( UICallbackCommunication, ThreadOption.UIThread );
            this.eventAggregator.GetEvent<HostConnectedPubSubEvent>().Subscribe( OcsConnectCallBack, ThreadOption.UIThread, false );

            vcsMessagePublisher = this.eventAggregator.GetEvent<VCSMessagePubSubEvent>();

            this.VCSystem = cSystem;

            this.messageController = _msgController;
            this.sql = _sql;

            this.VehicleID = sql.ConfigDal.GetById( ConstString.VehicleID ).Value;
            this.OcsIP = sql.ConfigDal.GetById( ConstString.Addr ).Value;

            this.TestCommand = new DelegateCommand( ExecuteTextCommand );
            this.NavigateCommand = new DelegateCommand<object>( this.Navigate );
            this.SystemOffCommand = new DelegateCommand( ExecuteSystemOffCommand );
            this.ChangeLanguage = new DelegateCommand( Execte_ChangeLanguage );
            this.StartCommand = new DelegateCommand( ExecuteStartCommand );
            this.StopCommand = new DelegateCommand( ExecuteStopCommand );
            this.AlarmResetCommand = new DelegateCommand( ExecuteAlarmResetCommand );
            this.EmergencyStopCommand = new DelegateCommand( ExecuteEStop );
            this.BuzzerStopCommand = new DelegateCommand( ExecuteBuzzerStop );
            this.MachineModeChgCommand = new DelegateCommand<string>( ExecuteMachineModeChgCommand );
            this.BatteryPopup = new DelegateCommand( ExecuteBatteryPopup );
            this.VehicleRailOnStateChgCommand = new DelegateCommand(ExecuteVehicleRailOnStateChgCommand);
            this.SelectLanguageCommand = new DelegateCommand(ExecuteSelectLanguageCommand);

            DispatcherTimer dateTimer = new DispatcherTimer();
            dateTimer.Tick += ( object sender, EventArgs e ) =>
            {
                this.DateTime = DateTime.Now;
            };
            dateTimer.Interval = TimeSpan.FromMilliseconds( 500 );
            dateTimer.Start();

            this.SwVersion = AssemblyUtils.GetVersion();
            this.LastBuildedTime = new Helpler.AssemblyInfo().Get_BuildDateTime();

            GSG.NET.Quartz.QuartzUtils.Invoke( "RESOURCE_CHECK", GSG.NET.Quartz.QuartzUtils.GetExpnSecond( 1 ), QuzOnResourceUsage );

            this.IsDryRun = false;
        }

        private void ExecuteSelectLanguageCommand()
        {
            this.messageController.ShowPopupView(ePopupType.SelectLanguageView);
        }

        private void ZmqManager_PropertyChanged( object sender, System.ComponentModel.PropertyChangedEventArgs e )
        {
            var property = sender.GetType().GetProperty( e.PropertyName );
            var newValue = property.GetValue( sender, null );

            switch ( e.PropertyName )
            {
                case "CurrentMCR":
                    this.CurrentMCR = CastTo<string>.From<object>( newValue );
                    break;

                case "CurrentPointNo":
                    this.CurrentTag = CastTo<int>.From<object>( newValue ).ToString();
                    break;

                case "IsReqConnected":
                    this.IsDriveConnected = CastTo<bool>.From<object>( newValue );
                    break;

                case "IsCanStanbyLocation":
                    this.IsOnRoute = CastTo<bool>.From<object>(newValue);
                    break;

                default:
                    break;
            }
        }

        private void ExecuteBatteryPopup()
        {
            this.messageController.ShowPopupView( Common.Shareds.ePopupType.BatteryConfigView );
        }

        void QuzOnResourceUsage()
        {
            try
            {
                this.CPU = GSG.NET.OSView.Mgnt.CpuUseRate();
                this.RAM = GSG.NET.OSView.Mgnt.MemPhysicalUseRate();

                var ll = GSG.NET.OSView.Mgnt.HddList();
                this.CDrive = ll.FirstOrDefault().AvailableFreeSpace / ConstUtils.ONE_GIGA_BYTES;
            }
            catch (Exception ex)
            {
                logger.E(ex);
            }        
        }

        private void ExecuteVehicleRailOnStateChgCommand()
        {
            var msg = new VCSMessageEventArgs
            {
                Kind = VCSMessageEventArgs.eVCSMessageKind.ReqVehicleOnRailStateChg,
            };

            if (this.VehicleOnRailState == eVehicleOnRailState.Removed)
                msg.Arg = eVehicleOnRailState.Install;
            else
                msg.Arg = eVehicleOnRailState.Removed;

            var question = string.Format(LanguageHalper.LanguagesSelecter.GetStringFromResourceDic(Question.VehicleOnRailStateChange) + $" {msg.Arg} ?");
            this.messageController.ShowConfirmationPopupView(question, r =>
            {
                if (r.Result == ButtonResult.OK)
                    vcsMessagePublisher.Publish(msg);
            });
        }

        private void ExecuteMachineModeChgCommand( string obj )
        {
            var msg = new VCSMessageEventArgs
            {
                Kind = VCSMessageEventArgs.eVCSMessageKind.ReqMachineModeChg,
            };

            if ( this.MachineMode == eMachineMode.LocalMode )
                msg.Arg = eMachineMode.HostMode;
            else
                msg.Arg = eMachineMode.LocalMode;

            var question = string.Format(LanguageHalper.LanguagesSelecter.GetStringFromResourceDic(Question.VehicleModeChange) + $" {msg.Arg} ?");
            this.messageController.ShowConfirmationPopupView( question, r =>
            {
                if ( r.Result == ButtonResult.OK )
                    vcsMessagePublisher.Publish( msg );
            } );

        }

        private void ExecuteBuzzerStop()
        {
            var msg = new VCSMessageEventArgs
            {
                Kind = VCSMessageEventArgs.eVCSMessageKind.ReqBuzzerStop,
                Args = new Dictionary<string, object>(),
            };

            vcsMessagePublisher.Publish( msg );

            //this.ExecuteTextCommand();
        }

        private void Execte_ChangeLanguage()
        {
            //LanguageHalper.LanguagesSelcter.ChangLanguage(LanguageHalper.eLanguageType.Chinese);
        }

        private void ExecuteEStop()
        {
            this.IsDryRun = !this.IsDryRun;

            var msg = new VCSMessageEventArgs
            {
                Kind = VCSMessageEventArgs.eVCSMessageKind.ReqEStop,
            };
            vcsMessagePublisher.Publish( msg );
        }

        private void ExecuteAlarmResetCommand()
        {
            this.messageController.ShowConfirmationPopupView( " Alarm Reset ? ", r =>
             {
                 if ( r.Result == ButtonResult.OK )
                 {
                     var msg = new VCSMessageEventArgs
                     {
                         Kind = VCSMessageEventArgs.eVCSMessageKind.ReqAlarmReset,
                     };

                     vcsMessagePublisher.Publish( msg );
                 }
             } );
        }

        private void ExecuteStopCommand()
        {
            this.messageController.ShowConfirmationPopupView( LanguageHalper.LanguagesSelecter.GetStringFromResourceDic(Question.VehicleManualMode), r =>
             {
                 if ( r.Result == ButtonResult.OK )
                 {
                     var msg = new VCSMessageEventArgs
                     {
                         Kind = VCSMessageEventArgs.eVCSMessageKind.ReqVehicleModeChange,
                         MessageKey = MessageKey.ManualMode,
                     };
                     vcsMessagePublisher.Publish( msg );

                     this.SetBusy( 5, "Wait for Vehicle Mode Change ..." );

                     this.VCSystem.ZmqManager.GetCurrentMCR();
                 }
             } );
        }

        private void ExecuteStartCommand()
        {
            //this.TimeOutLimit = 5000;
            //this.IsBusy = true;
            if (this.VehicleOnRailState != eVehicleOnRailState.Install)
            {
                this.messageController.ShowNotificationView(LanguageHalper.LanguagesSelecter.GetStringFromResourceDic(Notification.AutoModeChangeWranOnRailState), false);
                return;
            }

            this.messageController.ShowConfirmationPopupView( LanguageHalper.LanguagesSelecter.GetStringFromResourceDic(Question.VehicleAutoMode), r =>
             {
                 if ( r.Result == ButtonResult.OK )
                 {
                     var msg = new VCSMessageEventArgs
                     {
                         Kind = VCSMessageEventArgs.eVCSMessageKind.ReqVehicleModeChange,
                         MessageKey = MessageKey.AutoMode,
                     };
                     vcsMessagePublisher.Publish( msg );
                     this.SetBusy( 15, "Wait for Vehicle Mode Change ...");
                 }
             } );
        }

        private void OcsConnectCallBack( HostConnectedEventArgs obj )
        {
            var state = obj.State;

            switch ( state )
            {
                case HostConnectedEventArgs.eConnectedState.Disconnected:
                    this.OcsState = eOcsState.DisConnect;
                    break;
                case HostConnectedEventArgs.eConnectedState.Connected:
                    this.OcsState = eOcsState.Connect;
                    break;
            }
        }

        private void ExecuteSystemOffCommand()
        {
            this.messageController.ShowConfirmationPopupView( LanguageHalper.LanguagesSelecter.GetStringFromResourceDic(Question.ProgramExit), r =>
               {
                   if ( r.Result == ButtonResult.OK )
                       App.Current.Shutdown();
               } );
        }

        private void Navigate( object obj )
        {
            var selectItem = obj.ToString();
            if ( !string.IsNullOrEmpty( selectItem ) )
                regionManager.RequestNavigate( "MainView", selectItem );
        }

        void VehicleModeChange( bool isAutoMode )
        {
            if ( isAutoMode )
            {
                this.StartEnable = false;
                this.StopEnable = true;
                this.IsManualMode = false;
                regionManager.RequestNavigate( RegionNames.MainView, "AutoView" );
            }
            else
            {
                this.StartEnable = true;
                this.StopEnable = false;
                this.IsManualMode = true;
            }
        }

        private void UICallbackCommunication( GUIMessageEventArgs obj )
        {
            switch ( obj.Kind )
            {
                case GUIMessageEventArgs.eGUIMessageKind.ModelPropertyChange:
                    this.UICallBackModelPropertyChange( obj );
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspIOObject:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspIOMapList:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspCommandList:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspAutoModeChange:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspManualModeChange:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspAlarmReset:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspVehicleModeChange:
                    this.RspVehicleModeChange( obj );
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspEStop:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspVihicleState:
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspMachineModeChg:
                    RspMachineModeChg( obj );
                    break;
                case GUIMessageEventArgs.eGUIMessageKind.RspVehicleOnRailStateChg:
                    RspVehicleOnRailStateChg(obj);
                    break;
                default:
                    break;
            }
        }

        private void RspVehicleOnRailStateChg(GUIMessageEventArgs obj)
        {
            string reason = string.Empty;
            FluentResults.Result result = obj.Result;
            if (obj.Result.IsFailed)
            {
                reason = result.Errors.FirstOrDefault().Message;
            }
            else
            {
                var mode = CastTo<eVehicleOnRailState>.From<object>(obj.Args);
                reason = $"Change To {mode} Successes";
            }

            this.messageController.ShowNotificationView(reason);
        }

        void RspBatteryConnected( GUIMessageEventArgs obj )
        {
            var connected = CastTo<bool>.From<object>( obj.Args );
            if ( connected )
            {
                this.BatteryBrush = Brushes.LimeGreen;
                BatteryState = eBatteryState.Connect;
            }
            else
            {
                this.BatteryBrush = Brushes.Gray;
                BatteryState = eBatteryState.DisConnect;
            }
        }

        private void RspMachineModeChg( GUIMessageEventArgs obj )
        {
            string reason = string.Empty;

            FluentResults.Result result = obj.Result;
            if ( obj.Result.IsFailed )
            {
                reason = result.Errors.FirstOrDefault().Message;
            }
            else
            {
                var mode = CastTo<eMachineMode>.From<object>( obj.Args );
                reason = $"Change To {mode} Successes";
            }

            this.messageController.ShowNotificationView( reason );
        }

        private void RspVehicleModeChange( GUIMessageEventArgs obj )
        {
            //this.IsBusy = false;
            this.ResetBusy();

            if ( obj.Result.IsSuccess )
            {
                if ( obj.MessageKey.Equals( MessageKey.AutoMode ) ) { this.VehicleModeChange( true ); }
                if ( obj.MessageKey.Equals( MessageKey.ManualMode ) ) { this.VehicleModeChange( false ); }
            }
            else
            {
                var msg = obj.Result.Errors.FirstOrDefault().Message;
                if (msg.Equals("NotOnRoute"))
                {
                    var hisAlarm = new HisAlarm()
                    {
                        AlarmId = 999,
                        Text = "Vehicle is not On Route! (自动驾驶无法变更的位置)",
                        Solution = "Use a Jog to Move the Vehicle Onto the OnRoute(Jog Menu = Contol -> Drive ) \n" +
                                   "利用小号移动车辆移动到 OnRoute 变成绿色为止. 如果Servo Off，请先做Servo On \n" +
                                   "移动时,请给我位置的直线",
                    };
                    this.messageController.ShowNotificationAlarmView(hisAlarm);
                    return;
                }

                this.messageController.ShowNotificationView( msg, false );
            }
        }

        void UICallBackModelPropertyChange( GUIMessageEventArgs args )
        {
            if ( args.MessageKey.Equals( MessageKey.Alarm ) )
            {
                var hisAlarm = args.Args as HisAlarm;
                this.VehicleModeChange( false );//알람이 발생하면 자동으로 Manual Mode 로 변경됨
                this.IsVehicleAlarm = true;
                this.ResetBusy(); // 자동모드 진행 중 알람이 생기면 자동으로 Busy 상태를 빠져 나온다. UI
                this.messageController.ShowNotificationAlarmView( CastTo<HisAlarm>.From<object>(args.Args));
            }

            if ( args.MessageKey.Equals( MessageKey.Vehicle ) )
            {
                switch ( args.ModelPropertyName )
                {
                    case "VehicleStateProperty":
                        {
                            var vehicleState = CastTo<eVehicleState>.From<object>( args.Args );
                            if ( vehicleState == eVehicleState.Abnormal )
                                this.IsVehicleAlarm = true;
                            else
                                this.IsVehicleAlarm = false;
                        }
                        break;

                    case "IsErrorProcessing":
                        {
                            var ll = CastTo<bool>.From<object>( args.Args );
                        }
                        break;

                    case "MachineMode":
                        this.MachineMode = CastTo<eMachineMode>.From<object>( args.Args );
                        break;

                    case "VehicleOnRailState":
                        this.VehicleOnRailState = CastTo<eVehicleOnRailState>.From<object>(args.Args);
                        break;

                    case "BatteryIsConnect":
                        this.RspBatteryConnected( args );
                        break;

                    case "BatteryStateOfCharge":
                        this.SOC = CastTo<double>.From<object>( args.Args );
                        break;

                    case "BatteryChargeTime":
                        {
                            var cTime = CastTo<double>.From<object>( args.Args );
                            //if ( cTime > 0 )
                            //    this.BatteryState = eBatteryState.Charge;
                            //else
                            //    this.BatteryState = eBatteryState.Connect;
                        }
                        break;

                    case "BatteryChargeState":
                        {
                            var isCharge = CastTo<bool>.From<object>( args.Args );
                            if ( isCharge )
                                this.BatteryState = eBatteryState.Charge;
                            else
                                this.BatteryState = eBatteryState.Connect;
                        }
                        break;

                    case "BatteryDisChargeTime":
                        {
                            var dTime = CastTo<double>.From<object>( args.Args );
                        }
                        break;

                    default:
                        break;
                }
            }
        }

        private void ExecuteTextCommand()
        {
            var m = new VCSMessageEventArgs();
            m.MessageKey = "";
            m.MessageText = "Test Message";
            m.Kind = VCSMessageEventArgs.eVCSMessageKind.ReqTest;
            m.Command = new Common.Model.Command() { CommandID = "TestCommand123", Type = Common.Shareds.eCommandType.Move };

            this.eventAggregator.GetEvent<VCSMessagePubSubEvent>().Publish( m );
        }

        public void InitViewModel()
        {
            //VCSystem.Instance.Init();
            //var containerRegistry = ServiceLocator.Current.GetInstance<VCSystem>();
            //if ( containerRegistry.Equals( this.VCSystem ) )
            //{
            //    Console.WriteLine( "==" );
            //}
            //var vsys = containerRegistry.GetContainer().Resolve<IContainerProvider>();

            regionManager.RequestNavigate( RegionNames.MainView, "AutoView" );

            //var msg = new DriveControlEventArgs
            //{
            //    EventDir = DriveControlEventArgs.eEventDir.ToBack,
            //    ControlKind = DriveControlEventArgs.eControlKind.Steering,
            //};
            //msg.MoveDir = DriveControlEventArgs.eMoveDir.LEFT;
            //this.eventAggregator.GetEvent<DriveControlPubSubEvent>().Publish( msg );

            this.VCSystem.ZmqManager.PropertyChanged += ZmqManager_PropertyChanged;

            this.IsDriveConnected = this.VCSystem.ZmqManager.IsReqConnected;
            this.CurrentMCR = this.VCSystem.ZmqManager.CurrentMCR;
            this.CurrentTag = this.VCSystem.ZmqManager.CurrentPointNo.ToString();
            this.IsOnRoute = this.VCSystem.ZmqManager.IsCanStanbyLocation;

            LanguageHalper.LanguagesSelecter.ChangLanguage(LanguageHalper.eLanguageType.English);
        }

        public void Dispose()
        {
            //VCSystem.Instance.Dispose();
        }

        void SetBusy( int timeLimit = 5, string info = "Wait for Few Minute" )
        {
            this.IsBusy = true;
            this.BusyText = info;
            Task.Run( () =>
            {
                if ( eventBusy.WaitOne( timeLimit * ConstUtils.ONE_SECOND ) == false )
                {
                    Application.Current.Dispatcher.Invoke( () =>
                    {
                        this.IsBusy = false;
                        this.messageController.ShowNotificationView( "Response Time Out", false );
                    } );
                }
            } );
        }

        void ResetBusy()
        {
            eventBusy.Set();
            this.IsBusy = false;
        }

        public static void SelectCulture( string culture )
        {
            if ( String.IsNullOrEmpty( culture ) )
                return;

            //Copy all MergedDictionarys into a auxiliar list.
            var dictionaryList = Application.Current.Resources.MergedDictionaries.ToList();

            //Search for the specified culture.     
            string requestedCulture = string.Format( "StringResources.{0}.xaml", culture );
            var resourceDictionary = dictionaryList.FirstOrDefault( d => d.Source.OriginalString 
            == "/OHV.ResourceDic;component/Resources/StringResource.en-US.xaml" );

            if ( resourceDictionary == null )
            {
                //If not found, select our default language.             
                requestedCulture = "StringResources.xaml";
                resourceDictionary = dictionaryList.FirstOrDefault( d => d.Source.OriginalString == requestedCulture );
            }

            //If we have the requested resource, remove it from the list and place at the end.     
            //Then this language will be our string table to use.      
            if ( resourceDictionary != null )
            {
                Application.Current.Resources.MergedDictionaries.Remove( resourceDictionary );
                Application.Current.Resources.MergedDictionaries.Add( resourceDictionary );
            }

            //Inform the threads of the new culture.     
            Thread.CurrentThread.CurrentCulture = new CultureInfo( culture );
            Thread.CurrentThread.CurrentUICulture = new CultureInfo( culture );
        }
    }
}