MainWindow.xaml.cs | searchcode

/FAFramework/MainWindow.xaml.cs

https://github.com/11firecrackers/VT5061
C# | 526 lines | 448 code | 75 blank | 3 comment | 57 complexity | d7add288656a906afd1d8a546c1fc3d8 MD5 | raw file

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

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 System.Xml.Linq;

using FAFramework.Manager;

using FAFramework.Forms;

using FALibrary.Alarm;

using System.ComponentModel;

using System.Windows.Threading;

using System.Diagnostics;



namespace FAFramework

{

    /// <summary>

    /// MainWindow.xaml에 대한 상호 작용 논리

    /// </summary>

    public partial class MainWindow : Window

    {

        private Frame _alarmFrame = new Frame();

        private Frame _emergencyFrame = new Frame();

        private Grid _mainGrid;



        private DebugView _debugView;

        private WindowUtility _windowUtility;

        private Forms.Main.PageMain _formMain;

        private Forms.Manual.PageManual _formManual;

        private Forms.Config.PageConfig _formConfig;

        private Forms.Log.PageLog _formLog;



        private Button _mainButton;

        private Button _manualButton;

        private Button _configButton;

        private Button _logButton;

        private Button _exitButton;



        private bool _lastAlarmIsRankingAlarm = false;

        private string _lastAlarmLotID = "";

        private string _lastAlarmPartID = "";



        private Forms.PageAlarm _pageAlarm;

        private Forms.PageEmergency _pageEmergency;



        public MainWindow()

        {

            InitializeComponent();

            

            LogManager.Instance.IsEnabledTraceLog = false;

            WindowSplash splash = new WindowSplash();

            CreatePage();

            splash.Show();

            Initialize();

            Manager.StringResourceManager.Instance.Refresh();

            splash.Close();

        }



        #region Private Methods

        private void CreatePage()

        {

            _debugView = new DebugView();

            _windowUtility = new WindowUtility();

            _formMain = new Forms.Main.PageMain();

            _formManual = new Forms.Manual.PageManual();

            _formConfig = new Forms.Config.PageConfig();

            _formLog = new Forms.Log.PageLog();

        }



        private void Initialize()

        {           

            _debugView.ShowInTaskbar = false;

            _windowUtility.ShowInTaskbar = false;

            SetSubWindowKeyBinding(_debugView, Key.F1, ModifierKeys.Control);

            SetSubWindowKeyBinding(_windowUtility, Key.F10, ModifierKeys.Control);



            frameMainView.NavigationUIVisibility = NavigationUIVisibility.Hidden;

            _alarmFrame.NavigationUIVisibility = NavigationUIVisibility.Hidden;

            _emergencyFrame.NavigationUIVisibility = NavigationUIVisibility.Hidden;



            _mainButton = AddBottomMenuButton(GridBottomMenu, "MAIN", _formMain);

            _manualButton = AddBottomMenuButton(GridBottomMenu, "MANUAL", _formManual);

            _configButton = AddBottomMenuButton(GridBottomMenu, "CONFIG", _formConfig);

            _logButton = AddBottomMenuButton(GridBottomMenu, "LOG", _formLog);

            AddBottomMenuColumn(GridBottomMenu, 100);

            _exitButton = AddBottomMenuButton(GridBottomMenu, "EXIT",

                delegate(object sender, RoutedEventArgs e)

                {

                    if (MessageBox.Show(Manager.StringResourceManager.Instance.Resource.System.PGMExit, "", MessageBoxButton.YesNo) == MessageBoxResult.Yes)

                    {                        

                        LogManager.Instance.WriteTraceLog("TERMINATE PGM");

                        Equipment.EquipmentManager.Instance.StopMachine();

                        Close();

                    }

                });



            _logButton.Click +=

                delegate(object sender, RoutedEventArgs e)

                {

                    _formLog.OnShowEvent();

                };



            _mainGrid = (Grid)frameBase.Content;



            _pageAlarm  = new Forms.PageAlarm();       

            _alarmFrame.Content = _pageAlarm;



            _pageEmergency = new Forms.PageEmergency();

            _emergencyFrame.Content = _pageEmergency;

            _pageEmergency.Initialize();

            _pageEmergency.ResetEventHandler +=

                delegate(object sender, EventArgs e)

                {

                    ShowPage(_formMain);

                };



            _pageAlarm.ClickAlarmClear += JamClear;



            FAAlarmManager.Instance.OnRaiseAlarm += EventHandlerOnAlarm;



            try

            {

                Equipment.EquipmentManager.Instance.InitializeMachine();

                Equipment.EquipmentManager.Instance.MainEquip.OnStatusChanged += EventHandlerStatusChanged;

                Equipment.EquipmentManager.Instance.MainEquip.OnUserChanged += EventHandlerUserChanged;

                Equipment.EquipmentManager.Instance.MainEquip.OnJamClear += JamClear;

                Equipment.EquipmentManager.Instance.MainEquip.OnTestModeChanged += EventHandlerTestModeChanged;                

            }

            catch (Exception e)

            {

                MessageBox.Show(e.Message);

                Close();

            }            



            try

            {

                Equipment.EquipmentManager.Instance.OnEmergency +=

                    delegate(object sender, EventArgs e)

                    {

                        ShowEmergency();

                    };

                

                Equipment.EquipmentManager.Instance.OnResetEmergency +=

                    delegate(object sender, EventArgs e)

                    {

                        ShowPage(_formMain);

                    };



                _debugView.AddItem(Equipment.EquipmentManager.Instance, "Main");

                _windowUtility.Initialize();

                _formMain.Initialize();

                _formManual.Initialize();

                _formConfig.Initialize();

                _formLog.Initialize();

                UIUtility.SetFocusEventHandlerToTextBox(this);

            }

            catch (Exception e)

            {

                MessageBox.Show(e.Message);

                Close();

            }            



            try

            {

                Equipment.EquipmentManager.Instance.StartMachine();

            }

            catch (Exception e)

            {

                MessageBox.Show(e.Message);

                Close();

                return;

            }



            _configButton.IsEnabled = false;

            _manualButton.IsEnabled = false;

            

            Equipment.EquipmentManager.Instance.MainEquip.CurrentUser = Equipment.StandardEquipment.UserPermission.OPERATOR;

            LogManager.Instance.IsEnabledTraceLog = true;

            LogManager.Instance.WriteTraceLog("START PGM");



            ShowPage(_formMain);

        }



        private void ProcessAlarmOnInitializing()

        {

            Equipment.MainEquipment mainEquip = Equipment.EquipmentManager.Instance.MainEquip;

            mainEquip.SubSequenceManager.Suspend();

            mainEquip.InitialSequence.ClearState();

            mainEquip.InitializeEquipment.ClearState();

            mainEquip.VirtualAlarmStopSignal = true;

        }



        private void ProcessAlarmOnAutoRunning(FAAlarmEventArgs e)

        {

            Equipment.MainEquipment mainEquip = Equipment.EquipmentManager.Instance.MainEquip;

            mainEquip.SubSequenceManager.Suspend();



            bool autoRunning = false;

            bool rankingData = IsRankingData(e.Alarm);

            if (mainEquip.Status == Equipment.EquipmentStatus.AUTO_RUNNING)

                autoRunning = true;



            _lastAlarmIsRankingAlarm = rankingData;



            if (IsAbleSendAlarm(e.Alarm, rankingData))

                SendAlarmToECServer(e.Alarm);



            mainEquip.LastAlarm = e.Alarm;



            if (Equipment.EquipmentManager.Instance.MainEquip.TestMode == false)

            {

                LogManager.Instance.WriteAlarmLog(e.Alarm.AlarmNo.ToString() + ", " +

                e.Alarm.AlarmName + ", " +

                e.Alarm.Status.ToString() + ", " +

                e.Alarm.Type.ToString() + ", " +

                rankingData.ToString() + ", " +

                autoRunning.ToString() + ", " +

                e.Message + ", " +

                e.DebugInfo);



                Manager.LogManager.Instance.WriteTraceLog("ALARM : " + e.Alarm.AlarmNo.ToString() + ", " + e.Alarm.AlarmName);

            }



            Equipment.EquipmentManager.Instance.MainEquip.VirtualAlarmStopSignal = true;

        }



        private bool IsRankingData(FAAlarm alarm)

        {

            Equipment.MainEquipment mainEquip = Equipment.EquipmentManager.Instance.MainEquip;



            if (mainEquip.LastAlarm != null)

            {

                if (mainEquip.LastAlarm.AlarmNo == alarm.AlarmNo)

                {

                    if ((DateTime.Now - mainEquip.StartedTime).TotalSeconds > Manager.ConfigManager.Instance.Config.JamDelay)

                    {

                        return true;

                    }

                }

                else

                    return true;

            }

            else

            {

                return true;

            }



            return false;

        }



        private void SendAlarmToECServer(FAAlarm alarm)

        {

            Equipment.MainEquipment mainEquip = Equipment.EquipmentManager.Instance.MainEquip;



            string lotID = Manager.ConfigManager.Instance.Config.DefaultLotID;

            string partID = Manager.ConfigManager.Instance.Config.DefaultPartID;



            if (mainEquip.InterfaceUnit.ECPart.ECInfo.LotID != "")

                lotID = mainEquip.InterfaceUnit.ECPart.ECInfo.LotID;



            if (mainEquip.InterfaceUnit.ECPart.ECInfo.PartNo != "")

                partID = mainEquip.InterfaceUnit.ECPart.ECInfo.PartNo;



            try

            {

                mainEquip.InterfaceUnit.ECPart.SendAlarmRaiseInfo(Manager.ConfigManager.Instance.Config.EquipmentID,

                    lotID,

                    partID,

                    alarm.AlarmNo.ToString(),

                    alarm.AlarmName);



                _lastAlarmLotID = lotID;

                _lastAlarmPartID = partID;

            }

            catch

            {

            }

        }



        private bool IsAbleSendAlarm(FAAlarm alarm, bool rankingData)

        {

            Equipment.MainEquipment mainEquip = Equipment.EquipmentManager.Instance.MainEquip;



            bool sendAlarm = false;

            if (ConfigManager.Instance.Config.SendAlarmDataToServer)

                if (alarm.Status == ConfigClasses.GlobalConst.ALARM_STATUS_ALARM)

                    sendAlarm = true;



            if (ConfigManager.Instance.Config.SendWarningDataToServer)

                if (alarm.Status == ConfigClasses.GlobalConst.ALARM_STATUS_WARNING)

                    sendAlarm = true;



            if (rankingData == true && sendAlarm)

                if (mainEquip.InterfaceUnit.ECPart != null)

                    return true;



            return false;

        }



        private void EventHandlerOnAlarm(object sender, FAAlarmEventArgs e)

        {            

            Equipment.MainEquipment mainEquip = Equipment.EquipmentManager.Instance.MainEquip;



            if (mainEquip.RaisedAlarm)

                return;



            mainEquip.RaisedAlarm = true;



            if (mainEquip.Status == Equipment.EquipmentStatus.INITIALIZING)

            {

                ProcessAlarmOnInitializing();

            }

            else if (mainEquip.Status == Equipment.EquipmentStatus.AUTO_RUNNING ||

                mainEquip.Status == Equipment.EquipmentStatus.RUN_DOWN)

            {

                ProcessAlarmOnAutoRunning(e);

            }

            else if (mainEquip.Status != Equipment.EquipmentStatus.AUTO_STOP &&

                mainEquip.Status != Equipment.EquipmentStatus.NONE)

            {

                Equipment.EquipmentManager.Instance.MainEquip.SubSequenceManager.Suspend();

                Equipment.EquipmentManager.Instance.MainEquip.VirtualAlarmStopSignal = true;

                Manager.LogManager.Instance.WriteTraceLog("ALARM : " + e.Alarm.AlarmNo.ToString() + ", " + e.Alarm.AlarmName);

            }



            _pageAlarm.SetAlarm(e.Alarm, e.Message);

            ShowAlarm(_pageAlarm);

        }



        private void JamClear(object sender, EventArgs e)

        {

            Equipment.MainEquipment mainEquip = Equipment.EquipmentManager.Instance.MainEquip;



            if (_lastAlarmIsRankingAlarm)

            {

                try

                {

                    mainEquip.InterfaceUnit.ECPart.SendAlarmReleaseInfo(Manager.ConfigManager.Instance.Config.EquipmentID,

                        _lastAlarmLotID,

                        _lastAlarmPartID,

                        mainEquip.LastAlarm.AlarmNo.ToString(),

                        mainEquip.LastAlarm.AlarmName);

                }

                catch

                {

                }

            }



            mainEquip.Status = Equipment.EquipmentStatus.AUTO_STOP;

            ShowPage(_formMain);

        }



        private void EventHandlerStatusChanged(object sender, EventArgs e)

        {

            Equipment.MainEquipment mainEquip = Equipment.EquipmentManager.Instance.MainEquip;

            if (mainEquip.Status == Equipment.EquipmentStatus.AUTO_STOP ||

                mainEquip.Status == Equipment.EquipmentStatus.NONE)

            {

                mainEquip.RaisedAlarm = false;

                _exitButton.IsEnabled = true;

            }

            else

            {

                if (mainEquip.Status == Equipment.EquipmentStatus.AUTO_RUNNING)

                {

                    mainEquip.CurrentUser = Equipment.StandardEquipment.UserPermission.OPERATOR;                    

                }

                

                _exitButton.IsEnabled = false;

            }

        }



        private void EventHandlerUserChanged(object sender, FALibrary.FAGenericEventArgs<Equipment.StandardEquipment.UserPermission> e)

        {

            if (e.Value == Equipment.StandardEquipment.UserPermission.OPERATOR)

            {

                _manualButton.IsEnabled = false;

                _configButton.IsEnabled = false;

                _exitButton.IsEnabled = false;

            }

            else

            {

                _manualButton.IsEnabled = true;

                _configButton.IsEnabled = true;

                _exitButton.IsEnabled = true;

            }            

        }



        private void EventHandlerTestModeChanged(object sender, FALibrary.FAGenericEventArgs<bool> e)

        {

            if (e.Value == true)

            {                

                Manager.LogManager.Instance.WriteTraceLog("TEST MODE ENABLE");

            }

            else

            {                

                Manager.LogManager.Instance.WriteTraceLog("TEST MODE DISABLE");

            }

        }



        private void SetSubWindowKeyBinding(Window window, Key key, ModifierKeys modifierKey)

        {

            RoutedCommandForSubWindow command = new RoutedCommandForSubWindow(window);

            KeyBinding keyBinding = new KeyBinding(command, key, modifierKey);

            this.InputBindings.Add(keyBinding);

        }



        private Button AddBottomMenuButton(Grid grid, string caption, RoutedEventHandler eventHandler)

        {

            Button button = new Button();

            button.Content = caption;

            button.Margin = new Thickness(2, 2, 2, 2);

            button.HorizontalAlignment = System.Windows.HorizontalAlignment.Stretch;

            button.VerticalAlignment = System.Windows.VerticalAlignment.Stretch;

            button.Width = double.NaN;

            button.Height = double.NaN;

            ColumnDefinition col = AddBottomMenuColumn(grid);

            grid.Children.Add(button);

            Grid.SetColumn(button, grid.ColumnDefinitions.Count - 1);



            button.FontSize = 20;

            button.FontWeight = FontWeights.Bold;

            button.FontFamily = new System.Windows.Media.FontFamily("Tahoma");

            button.Click += eventHandler;

            return button;

        }



        private Button AddBottomMenuButton(Grid grid, string caption, Page page)

        {

            RoutedEventHandler action =

                delegate(object sender, RoutedEventArgs e)

                {

                    ShowPage(page);

                };



            Button button = AddBottomMenuButton(grid, caption, action);

            button.FontSize = 20;

            button.FontWeight = FontWeights.Bold;

            button.FontFamily = new System.Windows.Media.FontFamily("Tahoma");

            return button;

        }



        private ColumnDefinition AddBottomMenuColumn(Grid grid, int width = 0)

        {

            ColumnDefinition col = new ColumnDefinition();

            if (width > 0)

                col.Width = new GridLength(width);

            grid.ColumnDefinitions.Add(col);

            return col;

        }



        private void ShowPage(Page page)

        {

            frameBase.Visibility = System.Windows.Visibility.Hidden;

            gridMainGrid.Visibility = System.Windows.Visibility.Visible;

            frameMainView.Content = page;

        }



        private void ShowAlarm(Page page)

        {                        

            gridMainGrid.Visibility = System.Windows.Visibility.Hidden;

            frameBase.Visibility = System.Windows.Visibility.Visible;

            frameBase.Content = _alarmFrame;

        }



        private void ShowEmergency()

        {

            gridMainGrid.Visibility = System.Windows.Visibility.Hidden;

            frameBase.Visibility = System.Windows.Visibility.Visible;

            frameBase.Content = _emergencyFrame;

        }



        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)

        {

            _debugView.AllowClose = true;

            _windowUtility.AllowClose = true;

            _debugView.Close();

            _windowUtility.Close();

        }

        #endregion

    }



    class RoutedCommandForSubWindow : ICommand

    {

        public Window SubWindow { get; set; }

        public event EventHandler CanExecuteChanged = null;



        public RoutedCommandForSubWindow()

        {

        }



        public RoutedCommandForSubWindow(Window window)

        {

            SubWindow = window;

        }



        public bool CanExecute(Object parameter)

        {

            if (SubWindow == null)

                return false;

            else

            {

                if (CanExecuteChanged != null)

                    CanExecuteChanged(this, new EventArgs());

                return true;

            }

        }



        public void Execute(Object parameter)

        {

            if (SubWindow != null)

            {

                SubWindow.Show();

                if (SubWindow.IsActive == false)

                    SubWindow.Activate();

            }

        }

    }

}