aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/PPC/Tango.PPC.UI/ThreadLoading/DefaultThreadLoadingService.cs
blob: 7cb0163af4288d66e1f153974b99b15950d7aa12 (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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.Core.DI;
using Tango.Integration.Operation;
using Tango.Logging;
using Tango.PPC.Common.Build;
using Tango.PPC.Common.Connection;
using Tango.PPC.Common.Notifications;
using Tango.PPC.Common.Threading;
using Tango.PPC.Common.ThreadLoading;
using Tango.PPC.UI.Dialogs;

namespace Tango.PPC.UI.ThreadLoading
{
    public class DefaultThreadLoadingService : IThreadLoadingService
    {
        private INotificationProvider _notificationsProvider;
        private IMachineProvider _machineProvider;
        private IDispatcherProvider _dispatcher;
        private bool _dialogShown;

        public DefaultThreadLoadingService(INotificationProvider notificationsProvider, IMachineProvider machineProvider, IDispatcherProvider dispatcher)
        {
            _notificationsProvider = notificationsProvider;
            _machineProvider = machineProvider;
            _dispatcher = dispatcher;
            if (false == TangoIOC.Default.GetInstance<IBuildProvider>().IsEureka)
                _machineProvider.MachineOperator.ThreadLoadingStatusChanged += MachineOperator_ThreadLoadingStatusChanged;
        }

        private void MachineOperator_ThreadLoadingStatusChanged(object sender, PMR.ThreadLoading.StartThreadLoadingResponse e)
        {
            if (!_dialogShown && e.State != PMR.ThreadLoading.ThreadLoadingState.None)
            {
                _dialogShown = true;
                _dispatcher.Invoke(async () =>
                {
                    var vm = await _notificationsProvider.ShowDialog<ThreadLoadingViewVM>(new ThreadLoadingViewVM());
                    _dialogShown = false;
                    if (!vm.DialogResult && vm.Stage != ThreadLoadingViewVM.ThreadLoadingStage.Completed)
                    {
                        if (_machineProvider.IsConnected)
                        {
                            try
                            {
                                await _machineProvider.MachineOperator.AbortThreadLoading();
                            }
                            catch (Exception ex)
                            {
                                LogManager.Default.Log(ex, "Error aborting thread loading.");
                            }

                            await _notificationsProvider.ShowInfo("Thread loading aborted.");
                        }
                    }
                });
            }
        }

        public async void StartThreadLoadingWizard()
        {
            _dialogShown = true;
            var vm = await _notificationsProvider.ShowDialog<ThreadLoadingViewVM>(new ThreadLoadingViewVM(true));
            _dialogShown = false;
            if (!vm.DialogResult && vm.Stage != ThreadLoadingViewVM.ThreadLoadingStage.Completed && vm.Stage != ThreadLoadingViewVM.ThreadLoadingStage.Welcome)
            {
                if (_machineProvider.IsConnected)
                {
                    try
                    {
                        _notificationsProvider.SetGlobalBusyMessage("Aborting thread loading...");
                        await Task.Delay(1000);
                        await _machineProvider.MachineOperator.AbortThreadLoading();
                        _notificationsProvider.ReleaseGlobalBusyMessage();
                        await _notificationsProvider.ShowInfo("Thread loading aborted.");
                    }
                    catch (Exception ex)
                    {
                        _notificationsProvider.ReleaseGlobalBusyMessage();
                        LogManager.Default.Log(ex, "Error aborting thread loading.");
                        await _notificationsProvider.ShowError("Could not properly abort the thread loading process.");
                    }
                }
            }
        }

        public async void StartThreadBreakWizard()
        {
            if (!_dialogShown)
            {
                _dialogShown = true;
                var vm = await _notificationsProvider.ShowDialog<ThreadBreakViewVM>();
                _dialogShown = false;

                if (vm.Result == ThreadBreakViewVM.ThreadBreakWizardResult.StartThreadLoading)
                {
                    StartThreadLoadingWizard();
                }
            }
        }
    }
}