OTS/OpenDll/OxfordApi61Dll/Extender Code Samples/ExampleCode.WPF/MainWindow.xaml.cs

#pragma warning disable CA1822
namespace OINA.Extender.WPF.Testharness
{
    using System;
    using System.Collections.Generic;
    using System.Collections.ObjectModel;
    using System.Collections.Specialized;
    using System.ComponentModel;
    using System.Drawing;
    using System.Drawing.Imaging;
    using System.Globalization;
    using System.IO;
    using System.Linq;
    using System.Reflection;
    using System.Runtime.Serialization;
    using System.Text;
    using System.Threading;
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Resources;
    using System.Windows.Threading;
    using Microsoft.Win32;
    using OINA.Extender.Acquisition;
    using OINA.Extender.Acquisition.Ed;
    using OINA.Extender.Controls;
    using OINA.Extender.Controls.Spectrum;
    using OINA.Extender.Data.Ed;
    using OINA.Extender.Data.Image;
    using OINA.Extender.MonitorControl;
    using OINA.Extender.Processing;
    using OINA.Extender.Processing.Quant;
    using WindowsMedia = System.Windows.Media;

    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window, INotifyPropertyChanged
    {
        /// <summary>
        /// List of ElectronImage objects
        /// </summary>
        private readonly List<IElectronImage> electronImageList = new List<IElectronImage>();

        /// <summary>
        /// StringBuilder object
        /// </summary>
        private StringBuilder sb = new StringBuilder();

        /// <summary>
        /// The element dictionary
        /// </summary>
        private Dictionary<int, string> elementDictionary;

        /// <summary>
        /// The current spectrum acquisitions
        /// </summary>
        private Dictionary<IEdSpectrum, AcquisitionItem> currentSpectrumAcquisitions;

        /// <summary>
        /// Acquisition status timer
        /// </summary>
        private DispatcherTimer acquisitionStatusTimer;

        /// <summary>
        /// Identify elements timer
        /// </summary>
        private DispatcherTimer identifyElementsTimer;

        /// <summary>
        /// The compare spectra ids
        /// </summary>
        private ObservableCollection<IEdSpectrum> compareSpectra;

        /// <summary>
        /// The comparison spectra
        /// </summary>
        private List<IEdSpectrum> comparisonSpectra;

        private int dataChangedCount;

        private List<DetectorEnableModel> enabledDetectors;

        private List<string> identifiedElements;
        private string selectedIdentifiedElement;
        private QuantAnalysisStatus status;
        private string statusMessage;

        /// <summary>
        /// MainWindow Constructor
        /// </summary>
        public MainWindow()
        {
            Application.Current.DispatcherUnhandledException += this.OnCurrentOnDispatcherUnhandledException;

            this.compareSpectra = new ObservableCollection<IEdSpectrum>();
            this.currentSpectrumAcquisitions = new Dictionary<IEdSpectrum, AcquisitionItem>();

            this.InitializeComponent();
            this.DataContext = this;

            this.LoadComparisonSpectra();

            // Binding spectrum acquisition controller events
            OIHelper.EdSpectrumAcquisitionController.ExperimentStarted += this.OnEdSpectrumExperimentStarted;
            OIHelper.EdSpectrumAcquisitionController.ExperimentFinished += this.OnEdSpectrumExperimentFinished;

            // Binding image acquisition controller events
            OIHelper.ImageAcquisitionController.ExperimentStarted += this.OnImageExperimentStarted;
            OIHelper.ImageAcquisitionController.ExperimentFinished += this.OnImageExperimentFinished;

            // Initial UI contents
            this.InitialSpectrumSettingsContent();
            this.InitialSpectrumViewer();
            this.InitialImageSettingsContent();
            this.InitialTimers();
            this.InitialProcessingSettingsContent();
            this.InitialiseElementDictionary();
            this.IncludedListBox.DataContext = this.PeriodicTable;
            this.UnsetListBox.DataContext = this.PeriodicTable;
            this.ExcludedListBox.DataContext = this.PeriodicTable;
            this.TableBackColorCombo.DataContext = this.PeriodicTable;

            var clearCompareSpectra = new MenuItem
            {
                Header = @"Clear Compare Spectra",
                Visibility = Visibility.Visible,
            };

            clearCompareSpectra.Click += this.OnClearCompareSpectra;

            this.spectrumViewer.ContextMenu.Items.Add(clearCompareSpectra);
            this.spectrumViewer.ContextMenu.UpdateLayout();

            this.compareSpectrumColor.SelectedColor = GetRandomColor();
            this.SortListBox();

            this.PeriodicTable.PropertyChanged += this.OnPropertyChanged;
        }

        /// <summary>
        /// Gets the comparison spectra.
        /// </summary>
        /// <value>
        /// The comparison spectra.
        /// </value>
        public IList<IEdSpectrum> ComparisonSpectra
        {
            get { return this.comparisonSpectra; }
        }

        /// <summary>
        /// Gets the compare spectra ids.
        /// </summary>
        /// <value>
        /// The compare spectra ids.
        /// </value>
        public ObservableCollection<IEdSpectrum> CompareSpectra
        {
            get { return this.compareSpectra; }
        }

        /// <summary>
        /// Gets the element dictionary.
        /// </summary>
        /// <value>
        /// The element dictionary.
        /// </value>
        public Dictionary<int, string> ElementDictionary
        {
            get { return this.elementDictionary; }
        }

        /// <summary>
        /// Gets a value indicating whether this instance is acquiring spectrum.
        /// </summary>
        /// <value>
        /// <c>true</c> if this instance is acquiring spectrum; otherwise, <c>false</c>.
        /// </value>
        public bool IsAcquiringSpectrum
        {
            get { return OIHelper.EdSpectrumAcquisitionController.IsAcquiring; }
        }

        /// <summary>
        /// The currently selected Exclusion element
        /// </summary>
        private int currentExclusionElement;

        /// <summary>
        /// Gets or sets currently selected Exclusion element
        /// </summary>
        public int CurrentExclusionElement
        {
            get
            {
                return this.currentExclusionElement;
            }

            set
            {
                if (value == this.currentExclusionElement)
                {
                    return;
                }

                this.currentExclusionElement = value;

                this.RaisePropertyChanged(nameof(this.CurrentExclusionElement));
            }
        }

        /// <summary>
        /// Enable or disable Markers on Spectrum
        /// </summary>
        private bool showMarkers;

        public bool ShowMarkers
        {
            get
            {
                return this.showMarkers;
            }

            set
            {
                if (value == this.showMarkers)
                {
                    return;
                }

                this.showMarkers = value;
                this.ShowHideMarker();
                this.RaisePropertyChanged(nameof(this.ShowMarkers));
            }
        }

        /// <summary>
        /// Gets or sets currently selected Deconvolution element
        /// </summary>
        private int currentDeconvolutionElement;

        /// <summary>
        /// Gets or sets currently selected Deconvolution element
        /// </summary>
        public int CurrentDeconvolutionElement
        {
            get
            {
                return this.currentDeconvolutionElement;
            }

            set
            {
                if (value == this.currentDeconvolutionElement)
                {
                    return;
                }

                this.currentDeconvolutionElement = value;
                this.RaisePropertyChanged(nameof(this.CurrentDeconvolutionElement));
            }
        }

        public IEnumerable<IEdDeviceStatus> DeviceStatus
        {
            get
            {
                return OIHelper.MonitoringController.EdStatus.Values;
            }
        }

        /// <summary>
        /// Handles the DispatcherUnhandledException.
        /// Specifically, here it handles the LicenseCheckExceptions which are wrapped in the DispatcherUnhandledException.
        /// Shutdowns application when a invalid or missing licence has been found in LicenseCheck.cs.
        /// </summary>
        /// <param name="obj">Object</param>
        /// <param name="args">Event</param>
        private void OnCurrentOnDispatcherUnhandledException(object obj, DispatcherUnhandledExceptionEventArgs args)
        {
            LicenseCheckException ex = args.Exception.InnerException as LicenseCheckException;
            if (ex != null)
            {
                MessageBox.Show(@"This application will shutdown, as a valid license is not available." + Environment.NewLine + ex.Message, @"Error Message", MessageBoxButton.OK, MessageBoxImage.Error);
                args.Handled = true;
                Application.Current.Shutdown();
            }
        }

        /// <summary>
        /// Gets the random color.
        /// </summary>
        /// <returns>A random color</returns>
        private static WindowsMedia.Color GetRandomColor()
        {
            Random randomGen = new Random();
            byte[] values = new byte[3];
            randomGen.NextBytes(values);

            PropertyInfo[] info = typeof(WindowsMedia.Colors).GetProperties();

            PropertyInfo colorInfo = info[randomGen.Next(info.Length)];

            WindowsMedia.Color randomColor = (WindowsMedia.Color)WindowsMedia.ColorConverter.ConvertFromString(colorInfo.Name);

            return randomColor;
        }

        #region Event handlers

        /// <summary>
        /// Called when [clear compare spectra menu item is selected].
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
        private void OnClearCompareSpectra(object sender, RoutedEventArgs e)
        {
            this.spectrumViewer.ClearComparisonSpectra();
            this.compareSpectra.Clear();
        }

        /// <summary>
        /// Acquisition status timer event handler
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">EventArgs</param>
        private void OnAcquisitionStatusTimer_Tick(object sender, EventArgs e)
        {
            if (OIHelper.EdSpectrumAcquisitionController.IsAcquiring || OIHelper.ImageAcquisitionController.IsAcquiring)
            {
                this.lbAcquisitionStatus.Visibility = System.Windows.Visibility.Visible;
            }
            else
            {
                this.lbAcquisitionStatus.Visibility = System.Windows.Visibility.Hidden;
            }
        }

        /// <summary>
        /// Indentify elements timer event handler
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">EventArgs</param>
        private void OnIdentifyElementsTimer_Tick(object sender, EventArgs e)
        {
            this.DoAutoID();
        }

        /// <summary>
        /// Called when [ed spectrum experiment started].
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="AcquisitionFinishedEventArgs{IEdSpectrum}"/> instance containing the event data.</param>
        private void OnEdSpectrumExperimentStarted(object sender, AcquisitionStartedEventArgs<IEdSpectrum> e)
        {
            var edSpectrum = e.Value;

            // execute on ui thread
            this.Dispatcher.BeginInvoke(() =>
            {
                this.spectrumViewer.Spectrum = edSpectrum;

                // Clear periodic table elements
                this.PeriodicTable.ClearAll();

                // Update Known Elements
                this.PeriodicTable.IncludeElements(OIHelper.AutoIdSettings.KnownElements.ToArray());
            });

            this.identifyElementsTimer.Tick += this.OnIdentifyElementsTimer_Tick;
            this.identifyElementsTimer.Start();

            edSpectrum.PropertyChanged += this.OnPropertyChanged;

            this.dataChangedCount = 0;
            edSpectrum.DataChanged += this.OnEdSpectrumDataChanged;
        }

        /// <summary>
        /// Called when [image experiment started].
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The instance containing the event data.</param>
        private void OnImageExperimentStarted(object sender, AcquisitionStartedEventArgs<IElectronImage[]> e)
        {
            // execute on UI thread
            this.Dispatcher.BeginInvoke(() =>
            {
                this.imageViewer.DisplayImage = e.Value[0];
            });
        }

        /// <summary>
        /// OnExperimentFinished
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">The <see cref="AcquisitionFinishedEventArgs{IEdSpectrum}"/> instance containing the event data.</param>
        private void OnEdSpectrumExperimentFinished(object sender, AcquisitionFinishedEventArgs<IEdSpectrum> e)
        {
            e.Value.PropertyChanged -= this.OnPropertyChanged;
            e.Value.DataChanged -= this.OnEdSpectrumDataChanged;

            this.identifyElementsTimer.Tick -= this.OnIdentifyElementsTimer_Tick;
            this.identifyElementsTimer.Stop();

            // execute on UI thread
            this.Dispatcher.BeginInvoke(() =>
            {
                this.DoAutoID();
                this.UpdatePeriodicTable();
                this.DoQuant();

                if (this.currentSpectrumAcquisitions.ContainsKey(e.Value))
                {
                    this.AcquisitionQueueListBox.Items.Remove(this.currentSpectrumAcquisitions[e.Value]);
                    this.currentSpectrumAcquisitions.Remove(e.Value);
                }

                // *** If this is the last experiment, call EndMultipleAcquisition on the Acquisition
                // *** controller, to re-enable external scan switching
                if (!this.currentSpectrumAcquisitions.Any())
                {
                    OIHelper.EdSpectrumAcquisitionController.EndMultipleAcquisition();
                }
            });
        }

        /// <summary>
        /// Called when [image experiment finished].
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The instance containing the event data.</param>
        private void OnImageExperimentFinished(object sender, AcquisitionFinishedEventArgs<IElectronImage[]> e)
        {
            // execute on UI thread
            this.Dispatcher.BeginInvoke(() =>
            {
                e.Value.ToList().ForEach(i =>
                    {
                        this.electronImageList.Remove(i);
                        this.ImageAcquisitionQueueListBox.Items.Remove(i.Label);
                    });
            });
        }

        /// <summary>
        /// Show or Hide Markers base on Selected Element in Periodic Table
        /// </summary>
        public void ShowHideMarker()
        {
            if (this.ShowMarkers)
            {
                this.spectrumViewer.MarkersElement = this.PeriodicTable.SelectedElement;
            }
            else
            {
                this.spectrumViewer.MarkersElement = 0;
            }
        }

        /// <summary>
        /// OnPropertyChanged
        /// </summary>
        /// <param name="sender">Event source</param>
        /// <param name="e">Event arguments</param>
        private void OnPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            var edSpectrum = sender as IEdSpectrum;
            if (e.PropertyName == nameof(edSpectrum.RealTimeSeconds))
            {
                this.Dispatcher.Invoke(() =>
                {
                    this.textRealTimeSeconds.Text = Math.Round(edSpectrum.RealTimeSeconds, 3).ToString(CultureInfo.InvariantCulture);
                });
            }
            else if (e.PropertyName == nameof(edSpectrum.LiveTimeSeconds))
            {
                this.Dispatcher.Invoke(() =>
                {
                    this.textLiveTimeSeconds.Text = Math.Round(edSpectrum.LiveTimeSeconds, 3).ToString(CultureInfo.InvariantCulture);
                });
            }
            else if (e.PropertyName == nameof(this.PeriodicTable.SelectedElement))
            {
                this.ShowHideMarker();
            }
        }

        /// <summary>
        /// Handles the CollectionChanged event of the IncludedElements.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="NotifyCollectionChangedEventArgs"/> instance containing the event data.</param>
        private void IncludedElements_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            var spectrum = this.spectrumViewer.Spectrum;

            // Update peak labels for included elements
            if (spectrum != null)
            {
                switch (e.Action)
                {
                    case NotifyCollectionChangedAction.Add:
                        foreach (int i in e.NewItems.Cast<int>())
                        {
                            spectrum.SetIdentifiedElement(i, true);
                        }

                        break;
                    case NotifyCollectionChangedAction.Remove:
                        foreach (int i in e.OldItems.Cast<int>())
                        {
                            spectrum.SetIdentifiedElement(i, false);
                        }

                        break;
                    default:
                        break;
                }

                this.UpdateSpectrumPeakLabels();
            }
        }

        /// <summary>
        /// Update current spectrum peak labels
        /// </summary>
        private void UpdateSpectrumPeakLabels()
        {
            try
            {
                OIHelper.EdSpectrumProcessing.UpdatePeakLabels(this.spectrumViewer.Spectrum, null, Processing.Ed.PeakLabelFormat.Symbol);
            }
            catch (ArgumentNullException)
            {
            }
            catch (InvalidOperationException)
            {
            }
        }

        /// <summary>
        /// Sort Listbox
        /// </summary>
        private void SortListBox()
        {
            this.IncludedListBox.Items.SortDescriptions.Add(new SortDescription(string.Empty, ListSortDirection.Ascending));
            this.ExcludedListBox.Items.SortDescriptions.Add(new SortDescription(string.Empty, ListSortDirection.Ascending));
        }

        #endregion

        #region Update UI Status

        /// <summary>
        /// Initialise spectrum acquisition settings
        /// </summary>
        private void InitialSpectrumSettingsContent()
        {
            if (OIHelper.EdSpectrumSettings.EdCapabilities.HasHardwareConnection)
            {
                this.tbSpectrumLabel.Text = @"Spectrum 1";
                this.cbAcquisitionMode.Items.Add(EdAcquireMode.LiveTime);
                this.cbAcquisitionMode.Items.Add(EdAcquireMode.RealTime);
                this.cbAcquisitionMode.SelectedIndex = 0;
                this.tbAcquisitionTime.Text = @"10000";
                this.cbProcessTime.ItemsSource = OIHelper.EdSpectrumSettings.EdCapabilities.AllowedProcessTimes;

                this.cbProcessTime.SelectedIndex = 3;
                this.cbEnergyRange.ItemsSource = OIHelper.EdSpectrumSettings.EdCapabilities.AllowedEnergyRanges;
                this.cbEnergyRange.SelectedIndex = 1;
                this.cbNumOfChannels.ItemsSource = OIHelper.EdSpectrumSettings.EdCapabilities.AllowedNumberOfChannels;
                this.cbNumOfChannels.SelectedIndex = 1;

                this.enabledDetectors = new List<DetectorEnableModel>();
                foreach (var kvp in OIHelper.EdSpectrumSettings.EdSettings.IsHardwareEnabled)
                {
                    this.enabledDetectors.Add(new DetectorEnableModel(kvp.Key, kvp.Value));
                }

                this.enabledDetectors = this.enabledDetectors.OrderBy(x => x.DisplayName).ToList();
                this.DetectorListBox.DataContext = this;

                this.cbPrimaryDetector.ItemsSource = this.enabledDetectors.Select(x => x.DisplayName).ToList();
                this.cbPrimaryDetector.SelectedIndex = 0;
            }
        }

        public IReadOnlyList<DetectorEnableModel> EnabledDetectors
        {
            get
            {
                return this.enabledDetectors;
            }
        }

        /// <summary>
        /// Initialise SpectrumViewer
        /// </summary>
        private void InitialSpectrumViewer()
        {
            this.spectrumViewer.IsXAxisAutoScaleEnabled = false;
            this.spectrumViewer.IsYAxisAutoScaleEnabled = true;
        }

        /// <summary>
        /// InitialImageSettingsContent
        /// </summary>
        private void InitialImageSettingsContent()
        {
            var settings = OIHelper.ImageSettings;

            if (settings.ImageCapabilities.HasHardwareConnection)
            {
                this.cbImageScanSize.ItemsSource = OIHelper.GetScanSizes(
                    settings.ScanCapabilities.MinimumPixelSize,
                    settings.ScanCapabilities.MaximumPixelSize);

                this.cbImageScanSize.SelectedIndex = this.cbImageScanSize.Items.Count > 4 ? 4 : this.cbImageScanSize.Items.Count - 1;

                this.cbInputSignal.ItemsSource = settings.ImageCapabilities.AllowedInputSources;
                this.cbInputSignal.SelectedIndex = 0;
                this.tbNumberOfFrames.Text = @"1";
                this.tbDwellTime.Text = @"40";
            }
        }

        /// <summary>
        /// Initialize Processing settings
        /// </summary>
        private void InitialProcessingSettingsContent()
        {
            this.ExcludedListBox.DataContext = this;
            ((INotifyCollectionChanged)this.PeriodicTable.IncludedElements).CollectionChanged += this.IncludedElements_CollectionChanged;
            this.AllElementsRadioButton.IsChecked = true;

            this.CombinedElementTextBox.IsEnabled = false;
            this.CombinedElementTextBox.Text = @"8";

            this.NumberOfIonsTextBox.IsEnabled = false;
            this.NumberOfIonsTextBox.Text = @"3.0";

            this.IsCoatedCheckBox.IsChecked = OIHelper.SEMQuantSettings.SampleCoating.IsCoated;
            this.CoatingElementTextBox.IsEnabled = OIHelper.SEMQuantSettings.SampleCoating.IsCoated;
            this.CoatingElementTextBox.Text = OIHelper.SEMQuantSettings.SampleCoating.CoatingElement.ToString(CultureInfo.InvariantCulture);
            this.DensityTextBox.IsEnabled = OIHelper.SEMQuantSettings.SampleCoating.IsCoated;
            this.DensityTextBox.Text = OIHelper.SEMQuantSettings.SampleCoating.Density.ToString(CultureInfo.InvariantCulture);
            this.ThicknessTextBox.IsEnabled = OIHelper.SEMQuantSettings.SampleCoating.IsCoated;
            this.ThicknessTextBox.Text = OIHelper.SEMQuantSettings.SampleCoating.Thickness.ToString(CultureInfo.InvariantCulture);

            foreach (int i in OIHelper.SEMQuantSettings.DeconvolutionElements)
            {
                this.DeconvolutionElementListTextBox.Text += i.ToString(CultureInfo.InvariantCulture) + System.Environment.NewLine;
            }

            this.ThresholdingCheckBox.IsChecked = false;
            this.SigmaLevelTextBox.IsEnabled = false;
            this.SigmaLevelTextBox.Text = @"3.0";
        }

        /// <summary>
        /// Initialises the element dictionary.
        /// </summary>
        private void InitialiseElementDictionary()
        {
            this.elementDictionary = new Dictionary<int, string>();

            for (int elementNo = 1; elementNo <= 103; elementNo++)
            {
                this.elementDictionary.Add(elementNo, this.PeriodicTable.LookupElementInfo(elementNo).ElementName);
            }

            this.EnableElementsList.DataContext = this;
        }

        /// <summary>
        /// Initialise acquisition timer
        /// </summary>
        private void InitialTimers()
        {
            this.acquisitionStatusTimer = new DispatcherTimer();
            this.acquisitionStatusTimer.Tick += new EventHandler(this.OnAcquisitionStatusTimer_Tick);
            this.acquisitionStatusTimer.Interval = TimeSpan.FromMilliseconds(100);
            this.acquisitionStatusTimer.Start();

            this.identifyElementsTimer = new DispatcherTimer();
            this.identifyElementsTimer.Interval = TimeSpan.FromMilliseconds(1000);
        }

        /// <summary>
        /// Update the Periodic Table content after acquisition finished
        /// </summary>
        private void UpdatePeriodicTable()
        {
            this.PeriodicTable.IncludeElements(this.spectrumViewer.Spectrum.IdentifiedElements.ToArray());
        }

        #endregion

        #region Menu items actions

        /// <summary>
        /// Exit application
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">RoutedEventArgs</param>
        private void AppExit(object sender, RoutedEventArgs e)
        {
            Application.Current.Shutdown();
        }

        /// <summary>
        /// Show detector control panel
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">RoutedEventArgs</param>
        private void DetectorControl_Click(object sender, RoutedEventArgs e)
        {
            new DetectorControlPanel(OIHelper.EDDetectorControl) { Owner = this }.Show();
        }

        /// <summary>
        /// Show microscope control panel
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">RoutedEventArgs</param>
        private void MicroscopeControl_Click(object sender, RoutedEventArgs e)
        {
            new MicroscopeControlPanel { Owner = this }.Show();
        }

        /// <summary>
        /// Calibrate Click event handler.
        /// </summary>
        /// <param name="sender">sender</param>
        /// <param name="e">RoutedEventArgs</param>
        private void Calibrate_Click(object sender, RoutedEventArgs e)
        {
            new Calibrate { Owner = this }.Show();
        }

        /// <summary>
        /// Auto ID settings Window
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">RoutedEventArgs</param>
        private void AutoIdSetting_Click(object sender, RoutedEventArgs e)
        {
            new AutoIdSettings { Owner = this }.Show();
        }

        /// <summary>
        /// Handles the Click event of the PeriodicTableSettings menu item.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
        private void PeriodicTableSettings_Click(object sender, RoutedEventArgs e)
        {
            new PeriodicTableVisualSettings { Owner = this, ShowInTaskbar = false }.Show();
        }

        /// <summary>
        /// Handles the Click event of the SpectrumViewerSettings menu item.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
        private void SpectrumViewerSettings_Click(object sender, RoutedEventArgs e)
        {
            new SpectrumViewerVisualSettings { Owner = this, ShowInTaskbar = false }.Show();
        }

        /// <summary>
        /// Handles the Click event of the ImageViewerSettings menu item.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
        private void ImageViewerSettings_Click(object sender, RoutedEventArgs e)
        {
            new ImageViewerVisualSettings { Owner = this, ShowInTaskbar = false }.Show();
        }

        /// <summary>
        /// Handles the Click event of the ElementComboSettings menu item.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
        private void ElementComboSettings_Click(object sender, RoutedEventArgs e)
        {
            new ElementComboVisualSettings { Owner = this, ShowInTaskbar = false }.Show();
        }

        /// <summary>
        /// Handles the Click event of the BC Dialog settings menu item.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
        private void BCDialogSettings_Click(object sender, RoutedEventArgs e)
        {
            new BCDialogVisualSettings { Owner = this, ShowInTaskbar = false }.Show();
        }

        /// <summary>
        /// Handles the Click event of the DetailDialogsVisualStyles control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
        private void DetailsDialogVisualStyles_Click(object sender, RoutedEventArgs e)
        {
            new DetailDialogVisualSettings { Owner = this, ShowInTaskbar = false }.Show();
        }

        /// <summary>
        /// Handles the Click event of the elementComboVisualSettingsToolStripMenuItem control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">instance containing the event data.</param>
        private void ExportSpectrumAs_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                short width = (short)this.spectrumViewer.ActualWidth;
                short height = (short)this.spectrumViewer.ActualHeight;
                Bitmap bitmap = OIHelper.EdSpectrumProcessing.CreateBitmap(this.spectrumViewer.Spectrum, width, height);
                SaveFileDialog exportSpectrumDialog = new SaveFileDialog();
                exportSpectrumDialog.Filter = @"Bitmap (*.bmp)|*.bmp|PNG (*.png)|*.png|TIFF (*.tif)|*.tif|JPEG (*.jpg)|*.jpg";
                exportSpectrumDialog.Title = @"Export Spectrum As...";
                if (exportSpectrumDialog.ShowDialog() == true)
                {
                    switch (exportSpectrumDialog.FilterIndex)
                    {
                        case 1:
                            bitmap.Save(exportSpectrumDialog.FileName, ImageFormat.Bmp);
                            break;
                        case 2:
                            bitmap.Save(exportSpectrumDialog.FileName, ImageFormat.Png);
                            break;
                        case 3:
                            bitmap.Save(exportSpectrumDialog.FileName, ImageFormat.Tiff);
                            break;
                        case 4:
                            bitmap.Save(exportSpectrumDialog.FileName, ImageFormat.Jpeg);
                            break;
                        default:
                            bitmap.Save(exportSpectrumDialog.FileName, ImageFormat.Bmp);
                            break;
                    }
                }
            }
            catch (ArgumentException)
            {
            }
        }

        /// <summary>
        /// LoadSpectrumData menuitem click event
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">RoutedEventArgs</param>
        private void LoadSpectrumData_Click(object sender, RoutedEventArgs e)
        {
            var of_dlg = new OpenFileDialog();
            of_dlg.Title = @"Select a file";
            of_dlg.Filter = @"Esd(*.esd)|*.esd|Iex(*.iex)|*.iex";
            of_dlg.FilterIndex = 1;
            if (of_dlg.ShowDialog() == true)
            {
                if (!File.Exists(of_dlg.FileName))
                {
                    throw new InvalidOperationException("File does not exists!");
                }

                this.spectrumViewer.ClearComparisonSpectra();
                switch (of_dlg.FilterIndex)
                {
                    case 1:
                        this.spectrumViewer.Spectrum = DataFactory.LoadEdSpectrum(OIHelper.FileToByteArray(of_dlg.FileName));
                        break;
                    case 2:
                        this.spectrumViewer.Spectrum = DataFactory.LoadEdSpectrumFromIex(of_dlg.FileName);
                        break;
                }

                // Initial Periodic table to show the element state
                this.PeriodicTable.ClearAll();
                this.PeriodicTable.IncludeElements(this.spectrumViewer.Spectrum.IdentifiedElements.ToArray());
            }
        }

        /// <summary>
        /// SaveSpectrumData menuitem click event
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">RoutedEventArgs</param>
        private void SaveSpectrumData_Click(object sender, RoutedEventArgs e)
        {
            var spectrum = this.spectrumViewer.Spectrum;
            if (spectrum != null)
            {
                try
                {
                    var sf_dlg = new SaveFileDialog();
                    sf_dlg.Title = @"Save spectrum as";
                    sf_dlg.Filter = @"Esd(*.esd)|*.esd|Iex(*.iex)|*.iex";
                    sf_dlg.FilterIndex = 1;
                    if (sf_dlg.ShowDialog() == true)
                    {
                        switch (sf_dlg.FilterIndex)
                        {
                            case 1:
                                byte[] spectrumData = spectrum.Save();
                                OIHelper.ByteArrayToFile(sf_dlg.FileName, spectrumData);
                                break;
                            case 2:
                                OIHelper.EdSpectrumProcessing.CreateIexSpectrum(sf_dlg.FileName, spectrum);
                                break;
                        }
                    }
                }
                catch (ArgumentException)
                {
                }
            }
        }

        /// <summary>
        /// LoadImageData_Click
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">RoutedEventArgs</param>
        private void LoadImageData_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                OpenFileDialog of_dlg = new OpenFileDialog();
                of_dlg.Title = @"Select a file";
                of_dlg.Filter = @"Img(*.img)|*.img";

                of_dlg.FilterIndex = 1;
                if (of_dlg.ShowDialog() == true)
                {
                    if (!File.Exists(of_dlg.FileName))
                    {
                        throw new System.InvalidOperationException("File does not exists!");
                    }

                    this.imageViewer.DisplayImage = DataFactory.LoadElectronImage(OIHelper.FileToByteArray(of_dlg.FileName));
                }
            }
            catch (SerializationException)
            {
            }
        }

        /// <summary>
        /// SaveImageData_Click
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">RoutedEventArgs</param>
        private void SaveImageData_Click(object sender, RoutedEventArgs e)
        {
            string filter = @"Img(*.img)|*.img";
            string title = @"Save image as";
            if (this.imageViewer.DisplayImage != null)
            {
                try
                {
                    var electronImage = this.imageViewer.DisplayImage;
                    SaveFileDialog sf_dlg = new SaveFileDialog();
                    sf_dlg.Filter = filter;
                    sf_dlg.Title = title;
                    sf_dlg.FilterIndex = 1;
                    if (sf_dlg.ShowDialog() == true)
                    {
                        byte[] imageData = electronImage.Save();
                        OIHelper.ByteArrayToFile(sf_dlg.FileName, imageData);
                    }
                }
                catch (ArgumentException)
                {
                }
            }
        }

        /// <summary>
        /// ChordListAcquire_Click
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">RoutedEventArgs</param>
        private void ChordListAcquire_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                Window edChordListAcquireWindow = new EdChordListAcquisition()
                {
                    Owner = this,
                    WindowStartupLocation = WindowStartupLocation.CenterOwner,
                };

                edChordListAcquireWindow.ShowDialog();
            }
            catch (LicenseCheckException)
            {
                MessageBox.Show(@"Not supported by the license");
            }
        }

        #endregion

        #region Control from UI

        /// <summary>
        /// Start spectrum acquisition
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">RoutedEventArgs</param>
        private void StartAcquisition(object sender, RoutedEventArgs e)
        {
            this.spectrumViewer.ClearComparisonSpectra();
            this.AcquireSpectrum(false);
        }

        /// <summary>
        /// Resume spectrum acquisition
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">RoutedEventArgs</param>
        private void ResumeAcquisitionButton_Click(object sender, RoutedEventArgs e)
        {
            if (this.spectrumViewer.Spectrum != null && !this.IsAcquiringSpectrum)
            {
                this.AcquireSpectrum(true);
            }
        }

        /// <summary>
        /// Adds a spectrum for comparison
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
        private void OnAddCompareSpectraButtonClick(object sender, RoutedEventArgs e)
        {
            var spectrum = this.cbCompareSpectra.SelectedItem as IEdSpectrum;

            if (spectrum != null)
            {
                ////add current spectrum to compare spectrum
                this.spectrumViewer.AddComparisonSpectrum(spectrum, this.compareSpectrumColor.SelectedColor);
                this.compareSpectra.Add(spectrum);
                this.compareSpectrumColor.SelectedColor = GetRandomColor();
            }
        }

        /// <summary>
        /// Acquires the spectrum.
        /// </summary>
        /// <param name="isResume">if set to <c>true</c> [is resume].</param>
        private void AcquireSpectrum(bool isResume)
        {
            IEdSpectrum edSpectrum = null;

            // Spectrum acquisition settings confirm
            var edSpectrumSettings = OIHelper.EdSpectrumSettings;
            var edSpectrumAcquisitionController = OIHelper.EdSpectrumAcquisitionController;

            edSpectrumSettings.EdSettings.AcquisitionMode = (EdAcquireMode)this.cbAcquisitionMode.SelectedItem;
            edSpectrumSettings.EdSettings.AcquisitionTime = TimeSpan.FromMilliseconds(int.Parse(this.tbAcquisitionTime.Text, CultureInfo.CurrentCulture));

            if (edSpectrumSettings.EdSettings.AcquisitionTime > edSpectrumSettings.EdCapabilities.MaximumAcquisitionTime)
            {
                edSpectrumSettings.EdSettings.AcquisitionTime = edSpectrumSettings.EdCapabilities.MaximumAcquisitionTime;
                this.tbAcquisitionTime.Text = edSpectrumSettings.EdSettings.AcquisitionTime.TotalMilliseconds.ToString(CultureInfo.CurrentCulture);
            }

            if (edSpectrumSettings.EdSettings.AcquisitionTime < edSpectrumSettings.EdCapabilities.MinimumAcquisitionTime)
            {
                edSpectrumSettings.EdSettings.AcquisitionTime = edSpectrumSettings.EdCapabilities.MinimumAcquisitionTime;
                this.tbAcquisitionTime.Text = edSpectrumSettings.EdSettings.AcquisitionTime.TotalSeconds.ToString(CultureInfo.CurrentCulture);
            }

            edSpectrumSettings.EdSettings.ProcessTime = (int)this.cbProcessTime.SelectedValue;
            edSpectrumSettings.EdSettings.EnergyRange = (int)this.cbEnergyRange.SelectedValue;
            edSpectrumSettings.EdSettings.NumberOfChannels = (int)this.cbNumOfChannels.SelectedValue;

            // Enable the appropriate detectors
            foreach (var item in this.EnabledDetectors)
            {
                edSpectrumSettings.EdSettings.EnableDevice(item.EdHardwareId, item.IsDetectorEnabled);
            }

            int selectedIndex = this.cbPrimaryDetector.SelectedIndex;
            if (selectedIndex >= 0 && selectedIndex < this.EnabledDetectors.Count)
            {
                DetectorEnableModel primaryDetectorModel = this.EnabledDetectors[selectedIndex];
                edSpectrumSettings.EdSettings.PrimaryHardwareId = primaryDetectorModel.EdHardwareId;
                edSpectrumSettings.EdSettings.EnableDevice(primaryDetectorModel.EdHardwareId, true);
                primaryDetectorModel.IsDetectorEnabled = true; // ensure the ui reflects settings
            }

            edSpectrumSettings.ScanSettings.AcquisitionRegion.CreateMicroscopeRegion();

            this.spectrumViewer.MaximumEnergy = edSpectrumSettings.EdSettings.EnergyRange;

            // If Ed hardware is not ready, the software will crash.
            if (edSpectrumAcquisitionController.IsEdHardwareReady(OIHelper.EdSpectrumSettings))
            {
                // *** If this is the first acquisition, call BeginMultipleAcquisition
                // *** on the AcquisitionController to suppress external scan switching
                if (!this.currentSpectrumAcquisitions.Any())
                {
                    edSpectrumAcquisitionController.BeginMultipleAcquisition();
                }

                if (!isResume)
                {
                    try
                    {
                        edSpectrum = edSpectrumAcquisitionController.StartAcquisition(edSpectrumSettings);
                        edSpectrum.Label = string.Format(CultureInfo.CurrentCulture, @"{0} ({1:HH:mm:ss})", this.tbSpectrumLabel.Text, DateTime.Now);
                    }
                    catch (InvalidSettingsException invalidSettingsException)
                    {
                        MessageBox.Show(invalidSettingsException.Message);
                    }
                    catch (AcquisitionStartException acquisitionStartException)
                    {
                        MessageBox.Show(acquisitionStartException.Message);
                    }
                }
                else
                {
                    edSpectrumAcquisitionController.ResumeAcquisition(edSpectrumSettings, this.spectrumViewer.Spectrum);
                    edSpectrum = this.spectrumViewer.Spectrum;
                }

                if (edSpectrum != null)
                {
                    this.currentSpectrumAcquisitions.Add(edSpectrum, new AcquisitionItem(edSpectrum, OIHelper.EdSpectrumSettings.EdSettings.AcquisitionMode, OIHelper.EdSpectrumSettings.EdSettings.AcquisitionTime.TotalMilliseconds));
                    this.AcquisitionQueueListBox.Items.Add(this.currentSpectrumAcquisitions[edSpectrum]);
                }
            }
        }

        private void OnEdSpectrumDataChanged(object sender, EventArgs e)
        {
            // execute on ui thread
            this.Dispatcher.BeginInvoke(() =>
            {
                this.dataChangedCount++;
                this.lbDataChanged.Content = string.Format(CultureInfo.InvariantCulture, @"Data Changed: ({0})", this.dataChangedCount);
            });
        }

        /// <summary>
        /// StopAcquisition
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">RoutedEventArgs</param>
        private void StopAcquisition(object sender, RoutedEventArgs e)
        {
            if (OIHelper.EdSpectrumAcquisitionController.IsAcquiring == true)
            {
                OIHelper.EdSpectrumAcquisitionController.StopAcquisition();
            }
        }

        /// <summary>
        /// Handles the Click event of btStartImageScan button.
        /// </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 StartImageScan_Click(object sender, EventArgs e)
        {
            // Image acquisition settings comfirm
            var imageSettings = OIHelper.ImageSettings.ImageSettings;
            var imageCapabilities = OIHelper.ImageSettings.ImageCapabilities;
            var scanSettings = OIHelper.ImageSettings.ScanSettings;
            var imageAcquisitionController = OIHelper.ImageAcquisitionController;

            this.tbImageData.Text = string.Empty;
            int value = int.Parse(this.tbDwellTime.Text, CultureInfo.InvariantCulture);
            if (value > imageCapabilities.MaximumImageDwellMicroseconds)
            {
                imageSettings.DwellTimeMicroSeconds = imageCapabilities.MaximumImageDwellMicroseconds;
            }

            if (value < imageCapabilities.MinimumImageDwellMicroseconds)
            {
                imageSettings.DwellTimeMicroSeconds = imageCapabilities.MinimumImageDwellMicroseconds;
            }
            else
            {
                imageSettings.DwellTimeMicroSeconds = value;
            }

            // *** Disable all input sources before enabling the one that the user has chosen
            imageSettings.InputSources.ToList().ForEach(i => imageSettings.EnableInputSource(i.Key, false));
            imageSettings.EnableInputSource((ImageInputSources)this.cbInputSignal.SelectedItem, true);

            scanSettings.FrameCount = int.Parse(this.tbNumberOfFrames.Text, CultureInfo.InvariantCulture);

            var pixelSize = 1d / double.Parse(this.cbImageScanSize.Text, CultureInfo.InvariantCulture);

            scanSettings.AcquisitionRegion.CreateFullFieldRegion(pixelSize);

            var images = imageAcquisitionController.StartAcquisition(OIHelper.ImageSettings).ToList();
            images.ForEach(i =>
                {
                    i.Label = string.Format(CultureInfo.CurrentCulture, @"{0} ({1:HH:mm:ss})", @"ElectronImage", DateTime.Now);

                    this.electronImageList.Add(i);
                    this.ImageAcquisitionQueueListBox.Items.Add(i.Label);
                });
        }

        /// <summary>
        /// Handles the Click event of btStopImageScan button.
        /// </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 StopImageScan_Click(object sender, EventArgs e)
        {
            if (OIHelper.ImageAcquisitionController.IsAcquiring)
            {
                OIHelper.ImageAcquisitionController.StopAcquisition();
            }
        }

        /// <summary>
        /// AutoID elements.
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">RoutedEventArgs</param>
        private void AutoIdButton_Click(object sender, RoutedEventArgs e)
        {
            this.DoAutoID();
        }

        /// <summary>
        /// Do AutoID
        /// </summary>
        private void DoAutoID()
        {
            var elements = new List<string>();
            var spectrum = this.spectrumViewer.Spectrum;
            if (spectrum != null)
            {
                elements = OIHelper.EdSpectrumProcessing.IdentifyElements(spectrum, OIHelper.AutoIdSettings)
                    .Select(i => ElementProperties.GetElementSymbol(i))
                    .ToList();

                // Update spectrum peak label
                this.UpdateSpectrumPeakLabels();
            }

            this.IdentifiedElements = elements;
            this.SelectedIdentifiedElement = elements.FirstOrDefault();
        }

        public IReadOnlyList<string> IdentifiedElements
        {
            get
            {
                return this.identifiedElements;
            }

            set
            {
                this.identifiedElements = value.ToList();
                this.RaisePropertyChanged(nameof(this.IdentifiedElements));
            }
        }

        public string SelectedIdentifiedElement
        {
            get
            {
                return this.selectedIdentifiedElement;
            }

            set
            {
                this.selectedIdentifiedElement = value;
                this.RaisePropertyChanged(nameof(this.SelectedIdentifiedElement));
            }
        }

        /// <summary>
        /// Confirm excluded element
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">EventArgs</param>
        private void AddElementButton_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                this.PeriodicTable.ExcludeElements(this.CurrentExclusionElement);
            }
            catch (FormatException fe)
            {
                MessageBox.Show(@"Please enter valid element!" + fe.Message);
            }
        }

        /// <summary>
        /// Detete Excluded Elements
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">EventArgs</param>
        private void RemoveElementButton_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                this.PeriodicTable.Clear(this.CurrentExclusionElement);
            }
            catch (FormatException fe)
            {
                MessageBox.Show(@"Please enter valid element!" + fe.Message);
            }
        }

        /// <summary>
        /// Clear Excluded element list
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">EventArgs</param>
        private void ClearButton_Click(object sender, RoutedEventArgs e)
        {
            this.PeriodicTable.ClearAll();
        }

        /// <summary>
        /// Do quant button click handler.
        /// </summary>
        /// <param name="sender">sender</param>
        /// <param name="e">RoutedEventArgs</param>
        private void QuantButton_Click(object sender, RoutedEventArgs e)
        {
            this.DoQuant();
        }

        /// <summary>
        /// Do quantitative processing and display
        /// </summary>
        private void DoQuant()
        {
            switch (OIHelper.SEMQuantSettings.ProcessingOption)
            {
                case ProcessingOption.ElementByDifference:
                    OIHelper.SEMQuantSettings.CombinedElement = int.Parse(this.CombinedElementTextBox.Text, CultureInfo.InvariantCulture);
                    break;
                case ProcessingOption.ElementByStoichiometry:
                    // While it is possible to choose other elements, Oxygen is the only supported element by stoichiometry.
                    OIHelper.SEMQuantSettings.CombinedElement = 8;
                    OIHelper.SEMQuantSettings.TypeOfIon = IonType.Anion;
                    OIHelper.SEMQuantSettings.NumberOfIons = double.Parse(this.NumberOfIonsTextBox.Text, CultureInfo.InvariantCulture);
                    break;
                case ProcessingOption.AllElements:
                default:
                    break;
            }

            if (this.IsCoatedCheckBox.IsChecked == true)
            {
                OIHelper.SEMQuantSettings.SampleCoating.IsCoated = true;
                OIHelper.SEMQuantSettings.SampleCoating.Thickness = double.Parse(this.ThicknessTextBox.Text, CultureInfo.InvariantCulture);
                OIHelper.SEMQuantSettings.SampleCoating.Density = double.Parse(this.DensityTextBox.Text, CultureInfo.InvariantCulture);
                OIHelper.SEMQuantSettings.SampleCoating.CoatingElement = int.Parse(this.CoatingElementTextBox.Text, CultureInfo.InvariantCulture);
            }
            else
            {
                OIHelper.SEMQuantSettings.SampleCoating.IsCoated = false;
                this.ThicknessTextBox.IsEnabled = false;
                this.DensityTextBox.IsEnabled = false;
            }

            if (this.ThresholdingCheckBox.IsChecked == true)
            {
                OIHelper.SEMQuantSettings.Thresholding = true;
                OIHelper.SEMQuantSettings.SigmaLevel = double.Parse(this.SigmaLevelTextBox.Text, CultureInfo.InvariantCulture);
            }
            else
            {
                OIHelper.SEMQuantSettings.Thresholding = false;
                this.SigmaLevelTextBox.IsEnabled = false;
            }

            OIHelper.SEMQuantSettings.Normalised = this.NormalisedCheckBox.IsChecked.Value;

            this.QuantResultDataGrid.Items.Clear();
            try
            {
                ISEMQuantStatus status = OIHelper.EdSpectrumProcessing.SEMQuantifySpectrum(this.spectrumViewer.Spectrum, OIHelper.SEMQuantSettings);
                this.Status = status.Status;
                this.StatusMessage = status.StatusMessage;

                double totalWeightPercent = 0;
                double totalAtomicPercent = 0;

                foreach (ISEMQuantResult result in status.Results)
                {
                    if (result.IsQuantLine)
                    {
                        var elementRow = new DataGridRow();
                        elementRow.Item = new
                        {
                            Element = ElementProperties.GetElementSymbol(result.AtomicNumber),
                            Line = result.LineType,
                            WtPcent = Math.Round(result.WeightPercent, 2),
                            WtSigma = Math.Round(result.WeightPercentSigma, 6),
                            AtPcent = Math.Round(result.AtomicPercent, 2),
                        };

                        this.QuantResultDataGrid.Items.Add(elementRow);
                    }

                    totalWeightPercent += result.WeightPercent;
                    totalAtomicPercent += result.AtomicPercent;
                }

                var totalRow = new DataGridRow();
                totalRow.Item = new
                {
                    Element = @"Total",
                    WtPcent = Math.Round(totalWeightPercent, 2),
                    AtPcent = Math.Round(totalAtomicPercent, 2),
                };

                this.QuantResultDataGrid.Items.Add(totalRow);

                this.spectrumViewer.SEMQuantify(OIHelper.SEMQuantSettings);
            }
            catch (QuantificationException ex)
            {
                MessageBox.Show(ex.Message, @"Quantification Error", MessageBoxButton.OK, MessageBoxImage.Warning);
            }
            catch (ArgumentNullException)
            {
            }
        }

        public QuantAnalysisStatus Status
        {
            get
            {
                return this.status;
            }

            set
            {
                this.status = value;
                this.RaisePropertyChanged(nameof(this.Status));
            }
        }

        public string StatusMessage
        {
            get
            {
                return this.statusMessage;
            }

            set
            {
                this.statusMessage = value;
                this.RaisePropertyChanged(nameof(this.StatusMessage));
            }
        }

        private void CurrentSpectrumRadioButton_Click(object sender, RoutedEventArgs e)
        {
            OIHelper.SEMQuantSettings.TypeOfElementList = ElementListType.CurrentSpectrum;
            this.FixedListRadioButton.IsChecked = false;
            this.CurrentAndFixed.IsChecked = false;
        }

        private void FixedList_Click(object sender, RoutedEventArgs e)
        {
            OIHelper.SEMQuantSettings.TypeOfElementList = ElementListType.Fixed;

            // Set the element as an example of fixed list
            OIHelper.SEMQuantSettings.SetElement(72, true);

            this.CurrentAndFixed.IsChecked = false;
            this.CurrentSpectrumRadioButton.IsChecked = false;
        }

        private void CurrentAndFixed_Click(object sender, RoutedEventArgs e)
        {
            OIHelper.SEMQuantSettings.TypeOfElementList = ElementListType.FixedAndCurrentSpectrum;
            this.FixedListRadioButton.IsChecked = false;
            this.CurrentSpectrumRadioButton.IsChecked = false;
        }

        /// <summary>
        /// Used when processing spectra from specimens in which all elements yield X-rays which can be readily detected.
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">EventArgs</param>
        private void AllElementsRadioButton_Click(object sender, RoutedEventArgs e)
        {
            OIHelper.SEMQuantSettings.ProcessingOption = ProcessingOption.AllElements;
            this.NormalisedCheckBox.IsEnabled = true;
            this.CombinedElementTextBox.IsEnabled = false;
            this.NumberOfIonsTextBox.IsEnabled = false;
        }

        /// <summary>
        /// Calculated assuming that the difference between the analyzed total and 100%
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">EventArgs</param>
        private void ElementByDifferenceRadioButton_Click(object sender, RoutedEventArgs e)
        {
            OIHelper.SEMQuantSettings.ProcessingOption = ProcessingOption.ElementByDifference;
            this.NormalisedCheckBox.IsChecked = false;
            this.NormalisedCheckBox.IsEnabled = false;
            this.CombinedElementTextBox.IsEnabled = true;
            this.NumberOfIonsTextBox.IsEnabled = false;
        }

        /// <summary>
        /// Concentration of oxygen to be calculated.
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">EventArgs</param>
        private void ElementByStoichiometryRadioButton_Click(object sender, RoutedEventArgs e)
        {
            OIHelper.SEMQuantSettings.ProcessingOption = ProcessingOption.ElementByStoichiometry;
            this.NormalisedCheckBox.IsEnabled = true;
            this.CombinedElementTextBox.IsEnabled = false;
            this.NumberOfIonsTextBox.IsEnabled = true;
        }

        /// <summary>
        /// Add deconvolution element to list
        /// </summary>
        /// <param name="sender">sender object</param>
        /// <param name="e">EventArgs</param>
        private void AddDeconvolutionButton_Click(object sender, RoutedEventArgs e)
        {
            this.DeconvolutionElementListTextBox.Clear();

            try
            {
                OIHelper.SEMQuantSettings.SetDeconvolutionElement(this.CurrentDeconvolutionElement, true);

                foreach (int i in OIHelper.SEMQuantSettings.DeconvolutionElements)
                {
                    this.DeconvolutionElementListTextBox.Text += i.ToString(CultureInfo.InvariantCulture) + Environment.NewLine;
                }
            }
            catch (FormatException fe)
            {
                this.DeconvolutionElementListTextBox.Text = fe.Message;
            }
            catch (ArgumentOutOfRangeException ae)
            {
                this.DeconvolutionElementListTextBox.Text = ae.Message;
            }
        }

        /// <summary>
        /// Remove 1 deconvolution element from elment list.
        /// </summary>
        /// <param name="sender">sender</param>
        /// <param name="e">RoutedEventArgs</param>
        private void DeconvolutionRemoveButton_Click(object sender, RoutedEventArgs e)
        {
            this.DeconvolutionElementListTextBox.Clear();

            try
            {
                OIHelper.SEMQuantSettings.SetDeconvolutionElement(this.CurrentDeconvolutionElement, false);

                foreach (int i in OIHelper.SEMQuantSettings.DeconvolutionElements)
                {
                    this.DeconvolutionElementListTextBox.Text += i.ToString(CultureInfo.InvariantCulture) + Environment.NewLine;
                }
            }
            catch (FormatException fe)
            {
                this.DeconvolutionElementListTextBox.Text = fe.Message;
            }
        }

        /// <summary>
        /// Clear DeconvolutionElementList
        /// </summary>
        /// <param name="sender">sender</param>
        /// <param name="e">RoutedEventArgs</param>
        private void DeconvolutionClearButton_Click(object sender, RoutedEventArgs e)
        {
            this.DeconvolutionElementListTextBox.Clear();
            OIHelper.SEMQuantSettings.ClearDeconvolutionElements();

            foreach (int i in OIHelper.SEMQuantSettings.DeconvolutionElements)
            {
                this.DeconvolutionElementListTextBox.Text += i.ToString(CultureInfo.InvariantCulture) + Environment.NewLine;
            }
        }

        /// <summary>
        /// ThicknessTextBox and DensityTextBox will be enabled when IsCoatedCheckBox_Checked
        /// </summary>
        /// <param name="sender">sender</param>
        /// <param name="e">RoutedEventArgs</param>
        private void IsCoatedCheckBox_Click(object sender, RoutedEventArgs e)
        {
            this.CoatingElementTextBox.IsEnabled = (bool)this.IsCoatedCheckBox.IsChecked;
            this.DensityTextBox.IsEnabled = (bool)this.IsCoatedCheckBox.IsChecked;
            this.ThicknessTextBox.IsEnabled = (bool)this.IsCoatedCheckBox.IsChecked;
        }

        /// <summary>
        /// SigmaLevelTextBox will be enabled when ThresholdingCheckBox_Checked
        /// </summary>
        /// <param name="sender">sender</param>
        /// <param name="e">RoutedEventArgs</param>
        private void ThresholdingCheckBox_Click(object sender, RoutedEventArgs e)
        {
            this.SigmaLevelTextBox.IsEnabled = (bool)this.ThresholdingCheckBox.IsChecked;
        }

        /// <summary>
        /// Handles the CheckedChanged event of the MultiselectCheckBox control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
        private void MultiselectCheckBox_CheckedChanged(object sender, RoutedEventArgs e)
        {
            this.PeriodicTable.SelectionMode = this.MultiselectCheckBox.IsChecked.Value ? SelectionMode.Multiple : SelectionMode.Single;
        }

        /// <summary>
        /// Handles the Checked event of the ElementEnable control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
        private void ElementEnable_Checked(object sender, RoutedEventArgs e)
        {
            CheckBox check = sender as CheckBox;
            this.PeriodicTable.EnableElements(true, (int)check.Tag);
        }

        /// <summary>
        /// Handles the Unchecked event of the ElementEnable control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
        private void ElementEnable_Unchecked(object sender, RoutedEventArgs e)
        {
            CheckBox check = sender as CheckBox;
            this.PeriodicTable.EnableElements(false, (int)check.Tag);
        }

        /// <summary>
        /// Handles the click Calculate button event.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
        private void CalculatePeakParameterButton_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                int atomicNum = ElementProperties.GetAtomicNumberByElementSymbol(this.SelectedIdentifiedElement);

                var peakParameters = OIHelper.EdSpectrumProcessing.CalculatePeakParameters(this.spectrumViewer.Spectrum, atomicNum);
                this.tbEnergy.Text = string.Format(CultureInfo.InvariantCulture, @"{0:F4} keV", peakParameters.Centre);
                this.tbFWHM.Text = string.Format(CultureInfo.InvariantCulture, @"{0:F2} eV", peakParameters.FWHM);
            }
            catch (NullReferenceException)
            {
            }
            catch (FormatException)
            {
            }
            catch (InvalidOperationException)
            {
            }
        }

        /// <summary>
        /// Handles the Click event of the GetPixelData button.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">instance containing the event data.</param>
        private void GetPixelData_Click(object sender, RoutedEventArgs e)
        {
            if (OIHelper.ImageAcquisitionController.IsAcquiring != true && this.imageViewer.DisplayImage != null)
            {
                try
                {
                    var electronImage = this.imageViewer.DisplayImage as IElectronImage;
                    int x = int.Parse(this.tbPointX.Text, CultureInfo.InvariantCulture);
                    int y = int.Parse(this.tbPointY.Text, CultureInfo.InvariantCulture);
                    this.sb.Append(string.Format(CultureInfo.CurrentCulture, @" Point({0},{1}), Value: {2}", x, y, electronImage.GetData(new System.Drawing.Point(x, y))));
                    this.sb.Append(System.Environment.NewLine);
                    this.tbImageData.Text = this.sb.ToString();
                }
                catch (ArgumentOutOfRangeException)
                {
                    //// stringBuilder - The length of the expanded string would exceed MaxCapacity.
                }
                catch (FormatException)
                {
                    //// int.Parse - The x or y coordinates are not in the correct format.
                }
            }
        }

        /// <summary>
        /// The Window is closing. Cancel if acquiring a spectrum.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="CancelEventArgs"/> instance containing the event data.</param>
        private void WindowClosing(object sender, CancelEventArgs e)
        {
            e.Cancel = this.IsAcquiringSpectrum;
        }

        #endregion

        /// <summary>
        /// Loads the comparison spectra.
        /// </summary>
        private void LoadComparisonSpectra()
        {
            byte[] data;
            Uri uri;
            StreamResourceInfo info;
            this.comparisonSpectra = new List<IEdSpectrum>();

            uri = new Uri(@"/ComparisonSpectra/Nickel.spec", UriKind.Relative);
            info = Application.GetResourceStream(uri);
            data = new byte[info.Stream.Length];
            info.Stream.Read(data, 0, (int)info.Stream.Length);
            this.comparisonSpectra.Add(DataFactory.LoadEdSpectrum(data));

            uri = new Uri(@"/ComparisonSpectra/Preview spectrum.spec", UriKind.Relative);
            info = Application.GetResourceStream(uri);
            data = new byte[info.Stream.Length];
            info.Stream.Read(data, 0, (int)info.Stream.Length);
            this.comparisonSpectra.Add(DataFactory.LoadEdSpectrum(data));

            uri = new Uri(@"/ComparisonSpectra/Tungsten particle.spec", UriKind.Relative);
            info = Application.GetResourceStream(uri);
            data = new byte[info.Stream.Length];
            info.Stream.Read(data, 0, (int)info.Stream.Length);
            this.comparisonSpectra.Add(DataFactory.LoadEdSpectrum(data));

            this.cbCompareSpectra.DataContext = this;
            this.cbCompareSpectra.SelectedIndex = 0;
        }

        #region INotifyPropertyChanged Members

        /// <summary>
        /// PropertyChanged event
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        private void RaisePropertyChanged(string propertyName)
        {
            this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        #endregion

        /// <summary>
        /// The last element set
        /// </summary>
        private int lastElementSet = -1;

        /// <summary>
        /// Handles the PropertyChanged event of the ExcludeElementCombo control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="PropertyChangedEventArgs"/> instance containing the event data.</param>
        private void ExcludeElementCombo_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == nameof(this.ExcludeElementCombo.CurrentElement))
            {
                this.UpdateHighlightedElementInTable();
            }
        }

        /// <summary>
        /// Updates the highlighted element in table.
        /// </summary>
        private void UpdateHighlightedElementInTable()
        {
            if (this.lastElementSet != -1)
            {
                this.PeriodicTable.SetElementColor(this.lastElementSet, System.Windows.Media.Colors.Transparent);
            }

            System.Windows.Media.Color currentElementColor = System.Windows.Media.Color.FromArgb(255, 200, 255, 0);

            this.PeriodicTable.SetElementColor(this.ExcludeElementCombo.CurrentElement, currentElementColor);
            this.PeriodicTable.ShowElementColors = true;
            this.lastElementSet = this.ExcludeElementCombo.CurrentElement;
            this.PeriodicTable.SelectedElement = this.lastElementSet;
        }

        /// <summary>
        /// Handles the Click event of the exportTiffButton control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
        private void ExportTiffButton_Click(object sender, RoutedEventArgs e)
        {
            // Export a tiff synchronously on the calling thread.
            var syncTiff = this.spectrumViewer.CreateImage(ExportImageType.Tiff);
            File.WriteAllBytes(Path.Combine(Path.GetTempPath(), @"zSpectrumSync.tiff"), syncTiff);

            // Export a tiff asynchronously on a background thread.
            // The thread must be created with an apartment state set to STA.
            // Calls to CreateImage() must be made on the same thread that created the viewer.
            var spectrum = this.spectrumViewer.Spectrum;
            var thread = new System.Threading.Thread(() =>
            {
                // For optimum performance, create a single spectrum viewer and change the spectrum
                // and viewer settings where required for all spectra that you need images for.
                var backgroundViewer = new SpectrumViewer();

                // A height and width must be set to provide the image dimensions in pixels.
                backgroundViewer.Width = 500;
                backgroundViewer.Height = 500;

                backgroundViewer.IsYAxisAutoScaleEnabled = true;
                backgroundViewer.YAxisType = ScaleType.Logarithmic;
                backgroundViewer.MaximumEnergy = 8;
                backgroundViewer.Spectrum = spectrum;

                var asyncTiff = backgroundViewer.CreateImage(ExportImageType.Tiff);
                File.WriteAllBytes(Path.Combine(Path.GetTempPath(), @"zSpectrumAsync.tiff"), asyncTiff);

                backgroundViewer.Dispatcher.InvokeShutdown();
            });

            thread.IsBackground = true;
            thread.SetApartmentState(ApartmentState.STA);
            thread.Start();
        }
    }
}