SignalsMVVM/SignalsMVVM/MainVM.cs

using SignalsMVVM.Models;
using SignalsMVVM.HelperClasses;
using System.Collections.ObjectModel;
using System.Threading;
using System.Windows;
using System.Windows.Threading;
using System;
using System.Collections.Generic;
using SignalsMVVM.Interfaces;
using Autofac;
using System.Windows.Media;

namespace SignalsMVVM
{
    public class MainVM : PropertyChangedClass
    {
        public IList<BaseSignal> SignalPrototypes { get; set; }
        public IList<BaseSignal> ListOfSignals { get; set; }
        public IList<BaseSignal> ExecutionLog { get; set; }

        public BaseSignal SelectedSignalPrototype { get; set; }
        public BaseSignal SelectedSignalInList { get; set; }

        public RelayCommand AddNewSignalToList { get; set; }
        public RelayCommand RemoveSelectedSignalFromList { get; set; }
        public RelayCommand StartProcedure { get; set; }
        public RelayCommand AbortExecution { get; set; }
        public RelayCommand SaveSettings { get; set; }
        public RelayCommand LoadSettings { get; set; }

        public GeometryCollection CanvasGeometries { get; set; }
        
        public bool IsBusy { get; set; }

        private Thread CurrentThread;

        private Dispatcher dispatcher;

        private IContainer Container { get; set; }

        public MainVM()
        {
            SignalPrototypes = new ObservableCollection<BaseSignal>();
            SignalPrototypes.Add(new AmSignal("AM сигнал"));
            SignalPrototypes.Add(new FmSignal("FM сигнал"));
            ListOfSignals = new ObservableCollection<BaseSignal>();
            ExecutionLog = new ObservableCollection<BaseSignal>();
            CanvasGeometries = new GeometryCollection();

            AddNewSignalToList = new RelayCommand(AddNew, () => { if (IsBusy) return false; return SelectedSignalPrototype != null; });
            RemoveSelectedSignalFromList =
                new RelayCommand(RemoveSignalFromList, () => { if (IsBusy) return false; return SelectedSignalInList != null; });
            StartProcedure = new RelayCommand(Start, () => { if (IsBusy) return false; return ListOfSignals.Count > 0; });
            AbortExecution = new RelayCommand(AbortThreadExecution, () => IsBusy);
            SaveSettings = new RelayCommand(SaveSettingsToFile, () => { if (IsBusy) return false; return ListOfSignals.Count > 0; });
            LoadSettings = new RelayCommand(LoadSettingsFromFile, () => !IsBusy);

            var builder = new ContainerBuilder();
            builder.RegisterType<SignalController>().As<ISignalLoader>().As<ISignalSaver>();
            builder.RegisterInstance(new GraphicController(CanvasGeometries)).As<IGraphicControl>();
            Container = builder.Build();

            dispatcher = Application.Current.Dispatcher;

            Action a = () =>
            {
                Container.Resolve<IGraphicControl>().DrawLine(0, 0, 100, 100);
            };
            a.Invoke();
        }

        private void AddNew()
        {
            ListOfSignals.Add((BaseSignal)SelectedSignalPrototype.Clone());
        }

        private void RemoveSignalFromList()
        {
            ListOfSignals.Remove(SelectedSignalInList);
        }

        private void Start()
        {
            ExecutionLog.Clear();
            IProcedureLogger logger = new LogController(dispatcher, ListOfSignals, ExecutionLog, (value) => IsBusy = value);
            CurrentThread = new Thread(logger.ExecuteThread);
            CurrentThread.Start();
        }

        private void AbortThreadExecution()
        {
            CurrentThread.Abort();
            IsBusy = false;
        }

        private void SaveSettingsToFile()
        {
            Container.Resolve<ISignalSaver>().SaveSignals(ListOfSignals);
        }

        private void LoadSettingsFromFile()
        {
            ListOfSignals = Container.Resolve<ISignalLoader>().LoadSignals();
        }
    }
}