aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Developer/Converters/JobToColumnDefinitionsConverter.cs
blob: 2ce5886c66c5a9884f2a920f83b883bb1dfddad2 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using Tango.BL.Entities;

namespace Tango.MachineStudio.Developer.Converters
{
    public class JobToColumnDefinitionsConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            Job job = value as Job;

            List<ColumnDefinition> columns = new List<ColumnDefinition>();

            double totalLength = job.Segments.Sum(x => x.Length);

            foreach (var segment in job.OrderedSegments)
            {
                columns.Add(new ColumnDefinition() { Width = new GridLength(segment.Length / totalLength, GridUnitType.Star) });
            }

            return columns;
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }
}
ion */ .highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */ .highlight .nl { color: #336699; font-style: italic } /* Name.Label */ .highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */ .highlight .py { color: #336699; font-weight: bold } /* Name.Property */ .highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */ .highlight .nv { color: #336699 } /* Name.Variable */ .highlight .ow { color: #008800 } /* Operator.Word */ .highlight .w { color: #bbbbbb } /* Text.Whitespace */ .highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */ .highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */ .highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */ .highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */ .highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */ .highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */ .highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */ .highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */ .highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */ .highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */ .highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */ .highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */ .highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */ .highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */ .highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */ .highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */ .highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */ .highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */ .highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Threading;
using Tango.BL;
using Tango.BL.Builders;
using Tango.BL.Entities;
using Tango.Core.DI;
using Tango.Integration.ExternalBridge;
using Tango.Integration.Operation;
using Tango.PPC.Common;
using Tango.PPC.Common.Application;
using Tango.PPC.Common.Authentication;
using Tango.PPC.Common.ExternalBridge;
using Tango.PPC.Common.Modules;
using Tango.PPC.Common.Navigation;
using Tango.PPC.Common.Notifications;
using Tango.PPC.Common.WatchDog;
using Tango.PPC.UI.Dialogs;
using Tango.SharedUI;
using System.Data.Entity;
using Tango.PPC.UI.AppBarItems;
using Tango.PPC.Common.Notifications.NotificationItems;
using Tango.Core.Commands;
using System.Timers;

namespace Tango.PPC.UI.ViewModels
{
    /// <summary>
    /// Represents the PPC main view model.
    /// </summary>
    /// <seealso cref="Tango.PPC.Common.PPCViewModel" />
    public class MainViewVM : PPCViewModel
    {
        private DispatcherTimer _date_timer;
        private bool _isPowerUpDialogShown;
        private bool _isThreadLoadingShown;
        private PowerUpAppBarItem _powerUpAppBar;
        private bool _started;
        private MessageNotificationItem _headTypeNotification;
        private Timer _screenSaverTimer;

        private DateTime _currentDateTime;
        /// <summary>
        /// Gets or sets the current date time.
        /// </summary>
        public DateTime CurrentDateTime
        {
            get { return _currentDateTime; }
            set { _currentDateTime = value; RaisePropertyChangedAuto(); }
        }

        private bool _isScreenSaverOn;
        public bool IsScreenSaverOn
        {
            get { return _isScreenSaverOn; }
            set { _isScreenSaverOn = value; RaisePropertyChangedAuto(); }
        }

        public RelayCommand ScreenSaverExitCommand { get; set; }

        public MainViewVM()
        {
            _date_timer = new DispatcherTimer();
            _date_timer.Interval = TimeSpan.FromSeconds(1);
            _date_timer.Tick += _date_timer_Tick;
            _date_timer.Start();

            _headTypeNotification = new MessageNotificationItem();
            _headTypeNotification.CanClose = false;
            _headTypeNotification.MessageType = MessageNotificationItem.MessageNotificationItemTypes.Error;
            _headTypeNotification.Priority = NotificationItem.NotificationPriority.Critical;
            _headTypeNotification.Message = "Machine head type mismatch.";

            ScreenSaverExitCommand = new RelayCommand(ResetScreenSaverTimer);
            _screenSaverTimer = new Timer(TimeSpan.FromMinutes(Settings.ScreenSaverStartDuration).TotalMilliseconds);
        }

        /// <summary>
        /// Called when the application has been started.
        /// </summary>
        public override void OnApplicationStarted()
        {

        }

        public override void OnApplicationReady()
        {
            base.OnApplicationReady();
            MachineProvider.MachineOperator.CartridgeValidationRequestReceived += MachineOperator_CartridgeValidationRequestReceived;
            //MachineProvider.MachineOperator.FirmwareStarted += MachineOperator_FirmwareStarted;
            MachineProvider.MachineOperator.ThreadLoadingStatusChanged += MachineOperator_ThreadLoadingStatusChanged;
            MachineProvider.MachineOperator.ThreadLoadingConfirmationRequired += MachineOperator_ThreadLoadingConfirmationRequired;

            MachineProvider.MachineOperator.PowerUpStarted += MachineOperator_PowerUpStarted;
            MachineProvider.MachineOperator.PowerUpProgress += MachineOperator_PowerUpProgress;
            MachineProvider.MachineOperator.PowerUpEnded += MachineOperator_PowerUpEnded;

            MachineProvider.MachineConnected += MachineProvider_MachineConnected;

            MachineProvider.MachineOperator.WasteReplacementRequired += MachineOperator_WasteReplacementRequired;

            _screenSaverTimer.Elapsed += _screenSaverTimer_Elapsed;
            _screenSaverTimer.Start();
        }

        #region Waste Replacement

        private void MachineOperator_WasteReplacementRequired(object sender, EventArgs e)
        {
            InvokeUI(async () => 
            {
                var vm = await NotificationProvider.ShowDialog<WasteReplacementViewVM>();
                
                if (MachineProvider.IsConnected)
                {
                    try
                    {
                        await MachineProvider.MachineOperator.CompleteWasteReplacement(vm.DialogResult);
                    }
                    catch (Exception ex)
                    {
                        await NotificationProvider.ShowError($"Could not complete the process correctly.\n{ex.Message}");
                    }
                }
            });
        }

        #endregion

        #region Power Up

        private void MachineOperator_PowerUpEnded(object sender, EventArgs e)
        {
            _started = false;
            _powerUpAppBar?.Close();
            _powerUpAppBar = null;
        }

        private void MachineOperator_PowerUpProgress(object sender, PMR.Power.StartPowerUpResponse status)
        {
            if (_powerUpAppBar != null)
            {
                _powerUpAppBar.Status = status;
            }
        }

        private void MachineOperator_PowerUpStarted(object sender, PMR.Power.StartPowerUpResponse e)
        {
            _started = true;

            InvokeUI(() =>
            {
                if (_powerUpAppBar != null)
                {
                    _powerUpAppBar.Close();
                }

                if (_started)
                {
                    _powerUpAppBar = NotificationProvider.PushAppBarItem<PowerUpAppBarItem>();
                    _powerUpAppBar.Priority = AppBarPriority.Low;
                }
            });
        }

        #endregion

        #region Event Handlers

        /// <summary>
        /// Handles the Tick event of the _date_timer.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
        private void _date_timer_Tick(object sender, EventArgs e)
        {
            CurrentDateTime = DateTime.Now;
        }

        private void MachineOperator_CartridgeValidationRequestReceived(object sender, CartridgeValidationEventArgs e)
        {
            InvokeUI(async () =>
            {
                var vm = await NotificationProvider.ShowDialog<CartridgeValidationViewVM>(new CartridgeValidationViewVM()
                {
                    IDSPacks = MachineProvider.Machine.Configuration.NoneEmptyIdsPacks.ToList(),
                });

                if (vm.DialogResult)
                {
                    e.Approve(vm.SelectedIDSPack.PackIndex);
                }
                else
                {
                    e.Decline();
                }
            });
        }

        private async void MachineOperator_FirmwareStarted(object sender, EventArgs e)
        {
            if (_isPowerUpDialogShown)
            {
                LogManager.Log("Power up detected but power up dialog is already shown. Skipping...");
                return;
            }

            LogManager.Log("Power up detected, showing power up screen...");

            if (!Settings.DisplayPowerUpScreen)
            {
                LogManager.Log("Power up screen disabled. skipping...");
                return;
            }

            PowerUpViewVM vm;

            try
            {
                LogManager.Log("Loading site rmls...");

                List<Rml> rmls = new List<Rml>();

                using (ObservablesContext db = ObservablesContext.CreateDefault())
                {
                    rmls = (await new RmlsCollectionBuilder(db).SetAll().ForHeadType(MachineProvider.Machine.MachineHeadType).ForSite(MachineProvider.Machine.SiteGuid).BuildListAsync()).OrderBy(x => x.FinalName).ToList();
                }

                var selectedRml = rmls.SingleOrDefault(x => x.Guid == Settings.LoadedRmlGuid);

                vm = new PowerUpViewVM();
                vm.Rmls = rmls;
                vm.SelectedRml = selectedRml != null ? selectedRml : rmls.FirstOrDefault();
                vm.IsSelectedRml = selectedRml != null;
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error initializing power up screen.");
                return;
            }

            InvokeUI(async () =>
            {
                _isPowerUpDialogShown = true;
                await NotificationProvider.ShowDialog<PowerUpViewVM>(vm);
                _isPowerUpDialogShown = false;

                await Task.Factory.StartNew(() =>
                {
                    LogManager.Log("Power up screen closed.");

                    try
                    {
                        using (ObservablesContext db = ObservablesContext.CreateDefault())
                        {
                            List<ProcessParametersTable> processTables = new List<ProcessParametersTable>();

                            if (vm.IsSelectedRml)
                            {
                                LogManager.Log($"Selected rml '{vm.SelectedRml.Name}'...");
                                processTables = new RmlBuilder(db).Set(vm.SelectedRml.Guid).WithActiveParametersGroup().Build().GetActiveProcessGroup().ProcessParametersTables.ToList();
                            }
                            else
                            {
                                LogManager.Log("Selected minimal temperature...");
                                var rmlsToAvg = new RmlsCollectionBuilder(db).SetAll().ForHeadType(MachineProvider.Machine.MachineHeadType).ForSite(MachineProvider.Machine.SiteGuid).WithActiveParametersGroup().Build();
                                processTables = rmlsToAvg.Select(x => x.GetActiveProcessGroup()).SelectMany(x => x.ProcessParametersTables).ToList();
                            }

                            var processToLoad = processTables.OrderBy(x => x.GetAverageTemperature()).First();

                            LogManager.Log($"Selected process parameters:\nRML: {processToLoad.ProcessParametersTablesGroup.Rml.Name}\nGroup: {processToLoad.ProcessParametersTablesGroup.Name}\nProcess Table: {processToLoad.Name}");
                            LogManager.Log("Uploading process parameters...");
                            var r = MachineProvider.MachineOperator.UploadProcessParameters(processToLoad).Result;

                            Settings.LoadedRmlGuid = vm.IsSelectedRml ? vm.SelectedRml.Guid : null;
                            Settings.Save();
                        }
                    }
                    catch (Exception ex)
                    {
                        LogManager.Log(ex, "Error occurred while trying to get and upload the proper process parameters after power screen closed.");
                    }
                });
            });
        }

        private void MachineOperator_ThreadLoadingStatusChanged(object sender, PMR.ThreadLoading.StartThreadLoadingResponse e)
        {
            //if (e.State == PMR.ThreadLoading.ThreadLoadingState.Preparing)
            //{
            //    DisplayThreadLoading();
            //}
        }

        private void MachineOperator_ThreadLoadingConfirmationRequired(object sender, ThreadLoadingConfirmationRequiredEventArgs e)
        {
//            DisplayThreadLoading(e);
        }
        #endregion

        #region Head Type Check

        private void MachineProvider_MachineConnected(object sender, EventArgs e)
        {
            ResetScreenSaverTimer();

            NotificationProvider.PopNotification(_headTypeNotification);

            if (MachineProvider.MachineOperator.DeviceInformation != null && !MachineProvider.Machine.IsDemo)
            {
                if (MachineProvider.Machine.HeadType != (int)MachineProvider.MachineOperator.DeviceInformation.HeadType)
                {
                    _headTypeNotification.ExpandedMessage = $"Machine configuration reports head type '{MachineProvider.Machine.MachineHeadType}' while firmware device reports '{MachineProvider.MachineOperator.DeviceInformation.HeadType}'.";
                    NotificationProvider.PushNotification(_headTypeNotification);
                }
            }
        }

        #endregion

        #region Screen Saver

        public void ResetScreenSaverTimer()
        {
            _screenSaverTimer.Stop();
            _screenSaverTimer.Start();
            IsScreenSaverOn = false;
        }

        private void _screenSaverTimer_Elapsed(object sender, ElapsedEventArgs e)
        {
            _screenSaverTimer.Interval = TimeSpan.FromMinutes(Settings.ScreenSaverStartDuration).TotalMilliseconds;

            if (Settings.EnableScreenSaver && !MachineProvider.IsConnected && !BuildProvider.IsEureka)
            {
                IsScreenSaverOn = true;
            }
        }
        
        #endregion
    }
}