Программа висит при попытке открыть ComboBox

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using AKS16_AKS17_CalibrationGui_NewRev.ServiceClasses.UniversallyServiceClasses;
 
namespace AKS16_AKS17_CalibrationGui_NewRev.ViewModel
{
    class GUIComboBoxElements: PropertyChangeSupervisor
    {
        private ComboBox cbSensorType;
        public ComboBox CbSensorType
        {
            get { return cbSensorType; }
            set
            {
                cbSensorType = value;
                onPropertyChanged("CbSensorType");
            }
        }
        private ComboBox cbSize;
        public ComboBox CbSize
        {
            get { return cbSize; }
            set
            {
                cbSize = value;
                onPropertyChanged("CbSize");
            }
        }
        private ComboBox cbInterfaceAbsolut;
        public ComboBox CbInterfaceAbsolut
        {
            get { return cbInterfaceAbsolut; }
            set
            {
                cbInterfaceAbsolut = value;
                onPropertyChanged("CbInterfaceAbsolut");
            }
        }
        private ComboBox cbInterfaceIncremental;
        public ComboBox CbInterfaceIncremental
        {
            get { return cbInterfaceIncremental; }
            set
            {
                cbInterfaceIncremental = value;
                onPropertyChanged("CbInterfaceIncremental");
            }
        }
        private ComboBox cbABZResolution;
        public ComboBox CbABZResolution
        {
            get { return cbABZResolution; }
            set
            {
                cbABZResolution = value;
                onPropertyChanged("CbABZResolution");
            }
        }
        private ComboBox cbNumberOfPolePairs;
        public ComboBox CbNumberOfPolePairs
        {
            get { return cbNumberOfPolePairs; }
            set
            {
                cbNumberOfPolePairs = value;
                onPropertyChanged("CbNumberOfPolePairs");
            }
        }
        private List<string> lABZResolution;
        private List<string> lNumberOfPolePairs;
        /// <summary>
        /// Constructor, fills all MainWindow ComboBoxes with default values.
        /// </summary>
        public GUIComboBoxElements()
        {
            Services.FillComboBoxWithItems(out cbSensorType, "AKS16", "AKS17");
            Services.FillComboBoxWithItems(out cbSize, "Large 20-Bit(64/63 Nonius)", "Medium 19-Bit(32/31 Nonius)", "Small 18-Bit(16/15 Nonius)");
            Services.FillComboBoxWithItems(out cbInterfaceAbsolut, "BiSS", "SSI");
            Services.FillComboBoxWithItems(out cbInterfaceIncremental, "None", "ABZ", "UVW", "Step", "CW/CCW");
            lABZResolution = new List<string>();
            for (int i = 4; i<262148; i += 4)
            {
                string s = i.ToString();
                lABZResolution.Add(s);
            }
            Services.FillComboBoxWithItems(out cbABZResolution, lABZResolution);
            lNumberOfPolePairs = new List<string>();
            for (int i = 1; i<17; i++)
            {
                lNumberOfPolePairs.Add(i.ToString());
            }
            Services.FillComboBoxWithItems(out cbNumberOfPolePairs, lNumberOfPolePairs);
        }
        /// <summary>
        /// Adapts ComboBoxItems for actualy selection
        /// </summary>
        /// <param name="selectedItem"></param>
        public void ComboBoxSensorTypeSelectionChanged(ComboBoxItem selectedItem)
        {
            if(((string)(selectedItem.Content)) == "AKS16")
            {
                Services.FillComboBoxWithItems(out cbSize, "Large 20-Bit(64/63 Nonius)", "Medium 19-Bit(32/31 Nonius)", "Small 18-Bit(16/15 Nonius)");
                onPropertyChanged("CbSize");
            }
            else
            {
                Services.FillComboBoxWithItems(out cbSize, "XLarge 24-Bit(1023/1024/992)", "Large 23-Bit(511/512/496)", "Medium 22-Bit(255/256/240)", "Small 21-Bit(127/128/120)");
                onPropertyChanged("CbSize");
            }
        }
    }
}

/// <summary>
        /// Fills WPF ComboBox with items
        /// </summary>
        /// <param name="comboBoxToFill">ComboBox to fill</param>
        /// <param name="Items">List of string with items</param>
        public static void FillComboBoxWithItems(out ComboBox comboBoxToFill, List<string> Items)
        {
            comboBoxToFill = new ComboBox();
            for (int i = 0; i<Items.Count; i++)
            {
                comboBoxToFill.Items.Add(Items[i]);
            }
        }

using AKS16_AKS17_CalibrationGui_NewRev.ViewModel;
using System;
using System.Windows;
using System.Windows.Controls;
 
namespace AKS16_AKS17_CalibrationGui_NewRev
{
    /// <summary>
    /// Interaktionslogik für MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        MainWindowViewModel vmMainWindow = new MainWindowViewModel();
 
        public MainWindow()
        {
            DataContext = vmMainWindow;
 
            InitializeComponent();
            //Set MainWindowViewModel as datacontext
 
        }
 
        private void SensorType_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            
        }
 
        private void WindowView_Closed(object sender, EventArgs e)
        {
            App.Current.Shutdown();
        }
    }
}

using AKS16_AKS17_CalibrationGui_NewRev.View;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using System.Windows.Controls;
using AKS16_AKS17_CalibrationGui_NewRev.ServiceClasses.UniversallyServiceClasses;
using AKS16_AKS17_CalibrationGui_NewRev.UserControls;
using AKS16_AKS17_CalibrationGui_NewRev.Model;
 
namespace AKS16_AKS17_CalibrationGui_NewRev.ViewModel
{
    
    /// <summary>
    /// View model for main window
    /// </summary>
    public class MainWindowViewModel: PropertyChangeSupervisorWindowBased
    {
        private GUIComboBoxElements ComboBoxes;
        private DataModelAKS modelAKS;
 
        /// <summary>
        /// App title for MainWindow header
        /// </summary>
        private string sTitle = "AKS16 and AKS17 Calibration GUI Revision 2.0 ";
        public string STitle
        {
            get { return sTitle; }
            set
            {
                sTitle = value;
                onPropertyChanged("STitle");
            }
        }
        /// <summary>
        /// State holder for selected execution mode.
        /// True = development mode, false = production mode
        /// </summary>
        private bool bDevelopmentMode;
        /// <summary>
        /// bDevelopmentMode property superviser implement set and get methods for bIsInvertedRotation is neccessary for binding between view and data model.
        /// </summary>
        public bool BDevelopmentMode
        {
            get { return bDevelopmentMode; }
            set
            {
                bDevelopmentMode = value;
                onPropertyChanged("BDevelopmentMode");
            }
        }
        /// <summary>
        /// State holder for InvertedRotation property
        /// </summary>
        private bool bIsInvertedRotation = false;
        /// <summary>
        ///  bIsInvertedRotation property superviser implement set and get methods for bIsInvertedRotation is neccessary for binding between view and data model.
        /// </summary>
        public bool BIsInvertedRotation
        {
            get { return bIsInvertedRotation; }
            set
            {
                bIsInvertedRotation = value;
                onPropertyChanged("BIsInvertedRotation");
            }
        }
        /// <summary>
        /// An state holder for property SaveRawData
        /// </summary>
        private bool bIsSaveRawData = false;
        /// <summary>
        /// bIsSaveRawData property superviser implement set and get methods for bIsSaveRawData is neccessary for binding between view and data model.
        /// </summary>
        public bool BIsSaveRawData
        {
            get { return bIsSaveRawData; }
            set
            {
                bIsSaveRawData = value;
                onPropertyChanged("BIsSaveRawData");
            }
        }
        //Commands
        //Menu commands
        //File menu commands
        public ICommand CommandSaveEncoderConfig { get; private set; }
        public ICommand CommandLoadEncoderConfig { get; private set; }
        public ICommand CommandCalibrationSetup { get; private set; }
        public ICommand CommandPreference { get; private set; }
        public ICommand CommandExit { get; private set; }
        //Tools menu commands
        public ICommand CommandProductInformation { get; private set; }
        public ICommand CommandShowProtocolDataPacket { get; private set; }
        public ICommand CommandOffsetCompensation { get; private set; }
        public ICommand CommandMotorController { get; private set; }
        public ICommand CommandSerialPortTriggerSignal { get; private set; }
        public ICommand CommandSensorDemo { get; private set; }
        //Help menu commands
        public ICommand CommandSendReport { get; private set; }
        public ICommand CommandAbout { get; private set; }
        //GUIs itself commands
        public ICommand CommandOneStepCalibration { get; private set; }
        public ICommand CommandDetails { get; private set; }
        //Navigation commands, implimentation of user control OrientationOptionView commands
        public ICommand CommandNext { get; private set; }
        public ICommand CommandPrev { get; private set; }
        public ICommand CommandTest { get; private set; }
        /// <summary>
        /// Exemplar of OrientationOptionView user control
        /// </summary>
        private OrientationOptionUserControl orientationOptionControl;
        /// <summary>
        /// Property change supervizer of OrientationOptionView user control for binding into MainWindowView
        /// </summary>
        public OrientationOptionUserControl OrientationOptionControl
        {
            get { return orientationOptionControl; }
            set
            {
                orientationOptionControl = value;
                onPropertyChanged("OrientationOptionControl");
            }
        }
        private Visibility vDetailsButton;
        public Visibility VDetailsButton
        {
            get { return vDetailsButton; }
            set
            {
                vDetailsButton = value;
                onPropertyChanged("VDetailsButton");
            }
        }
        /// <summary>
        /// Constructor with mode argument
        /// </summary>
        /// <param name="mode">if true = development mode if false = production mode</param>
        public MainWindowViewModel()
        {
            ComboBoxes = new GUIComboBoxElements();
            ComboBoxSensor = ComboBoxes.CbSensorType;
            ComboBoxSize = ComboBoxes.CbSize;
            ComboBoxAbsoluteInterface = ComboBoxes.CbInterfaceAbsolut;
            ComboBoxIncrementalInterface = ComboBoxes.CbInterfaceIncremental;
            ComboBoxPolePairs = ComboBoxes.CbNumberOfPolePairs;
            ComboBoxResolution = ComboBoxes.CbABZResolution;
            ComboBoxVariables = ComboBoxResolution;
            modelAKS = new DataModelAKS();
            VDetailsButton = Visibility.Collapsed;
            // show versions info in Title
            System.Diagnostics.FileVersionInfo vi = System.Diagnostics.FileVersionInfo.GetVersionInfo(System.Reflection.Assembly.GetExecutingAssembly().Location);
            System.IO.FileInfo fileInfo = new System.IO.FileInfo(vi.FileName);
 
            Version version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
            DateTime buildDate = new DateTime(2000, 1, 1).AddDays(version.Build).AddSeconds(version.Revision * 2);
            string displayableVersion = $"{version} ({buildDate})";
 
            STitle = STitle + " - Version " + displayableVersion;
#if DEBUG
            STitle = STitle + " - Debug Version";
#endif
            BDevelopmentMode = true;
            //UserControl to show the orientations options
            OrientationOptionControl = new OrientationOptionUserControl();
            //Implements commands
            CommandSaveEncoderConfig = new DelegateCommand(SaveEncoderConfig, CanSaveEncoderConfig);
            CommandLoadEncoderConfig = new DelegateCommand(LoadEncoderConfig, CanLoadEncoderConfig);
            CommandCalibrationSetup = new DelegateCommand(CalibrationSetup, CanCalibrationSetup);
            CommandPreference = new DelegateCommand(Preference, CanPreference);
            CommandExit = new DelegateCommand(Exit, CanExit);
            CommandProductInformation = new DelegateCommand(ProductInformation, CanProductInformation);
            CommandShowProtocolDataPacket = new DelegateCommand(ShowProtocolDataPacket, CanShowProtocolDataPacket);
            CommandOffsetCompensation = new DelegateCommand(OffsetCompensation, CanOffsetCompensation);
            CommandMotorController = new DelegateCommand(MotorController, CanMotorController);
            CommandSerialPortTriggerSignal = new DelegateCommand(SerialPortTriggerSignal, CanSerialPortTriggerSignal);
            CommandSensorDemo = new DelegateCommand(SensorDemo, CanSensorDemo);
            CommandSendReport = new DelegateCommand(SendReport, CanSendReport);
            CommandAbout = new DelegateCommand(About, CanAbout);
            CommandOneStepCalibration = new DelegateCommand(OneStepCalibration, CanOneStepCalibration);
            CommandDetails = new DelegateCommand(Details, CanDetails);
        }
        #region ComboBoxes
        private ComboBox comboBoxVariables;
        public ComboBox ComboBoxVariables
        {
            get { return comboBoxVariables; }
            set
            {
                comboBoxVariables = value;
                onPropertyChanged("ComboBoxVariables");
            }
        }
        private ComboBox comboBoxSensor;
        public ComboBox ComboBoxSensor
        {
            get { return comboBoxSensor; }
            set
            {
                comboBoxSensor = value;
                onPropertyChanged("ComboBoxSensor");
            }
        }
        private ComboBox comboBoxIncrementalInterface;
        public ComboBox ComboBoxIncrementalInterface
        {
            get { return comboBoxIncrementalInterface; }
            set
            {
                comboBoxIncrementalInterface = value;
                onPropertyChanged("ComboBoxIncrementalInterface");
            }
        }
        private ComboBox comboBoxAbsoluteInterface;
        public ComboBox ComboBoxAbsoluteInterface
        {
            get { return comboBoxAbsoluteInterface; }
            set
            {
                comboBoxAbsoluteInterface = value;
                onPropertyChanged("ComboBoxAbsoluteInterface");
            }
        }
        private ComboBox comboBoxResolution;
        public ComboBox ComboBoxResolution
        {
            get { return comboBoxResolution; }
            set
            {
                comboBoxResolution = value;
                onPropertyChanged("ComboBoxResolution");
            }
        }
        private ComboBox comboBoxSize;
        public ComboBox ComboBoxSize
        {
            get { return comboBoxSize; }
            set
            {
                comboBoxSize = value;
                onPropertyChanged("ComboBoxSize");
            }
        }
        private ComboBox comboBoxPolePairs;
        public ComboBox ComboBoxPolePairs
        {
            get { return comboBoxPolePairs; }
            set
            {
                comboBoxPolePairs = value;
                onPropertyChanged("ComboBoxPolePairs");
            }
        }
        #endregion
        private CheckBox checkBoxInvertedRotation;
        public CheckBox CheckBoxInvertedRotation
        {
            get { return checkBoxInvertedRotation; }
            set
            {
                checkBoxInvertedRotation = value;
                onPropertyChanged("CheckBoxInvertedRotation");
            }
        }
        private uint uiSelectedOrientation;
        public uint UiSelectedOrientation
        {
            get { return uiSelectedOrientation; }
            set
            {
                uiSelectedOrientation = value;
                onPropertyChanged("UiSelectedOrientation");
            }
        }
        private bool bFullRangeCalibration;
        public bool BFullRangeCalibration
        {
            get { return bFullRangeCalibration; }
            set
            {
                bFullRangeCalibration = value;
                onPropertyChanged("BFullRangeCalibration");
            }
        }
        private CheckBox checkBoxSaveRawData;
        public CheckBox CheckBoxSaveRawData
        {
            get { return checkBoxSaveRawData; }
            set
            {
                checkBoxSaveRawData = value;
                onPropertyChanged("CheckBoxSaveRawData");
            }
        }
        private string sVariativeComboBoxText;
        public string SVariativeComboBoxtext
        {
            get { return sVariativeComboBoxText; }
            set
            {
                sVariativeComboBoxText = value;
                onPropertyChanged("SVariativeComboBoxtext");
            }
        }
        private Visibility v_VariativeComboBoxVisibility;
        public Visibility V_VariativeComboBoxVisibility
        {
            get { return v_VariativeComboBoxVisibility; }
            set
            {
                v_VariativeComboBoxVisibility = value;
                onPropertyChanged("V_VariativeComboBoxVisibility");
            }
        }
       
        #region Commands
        /// <summary>
        /// Can execute path of Details command.
        /// </summary>
        /// <param name="parameter">Not neccessary parameter, can be useful in deverse implementatins</param>
        /// <returns>true if command can execute or false if not.</returns>
        public bool CanDetails(object parameter = null)
        {
            return false;
        }
        /// <summary>
        /// Execute path of Details command, implements all aktions and command logic.
        /// </summary>
        private void Details()
        {
 
        }
        /// <summary>
        /// Can execute path of SaveEncodingConfig command.
        /// </summary>
        /// <param name="parameter">Not neccessary parameter, can be useful in deverse implementatins</param>
        /// <returns>true if command can execute or false if not.</returns>
        public bool CanSaveEncoderConfig(object parameter = null)
        {
            return false;
        }
        /// <summary>
        /// Execute path of SaveEncoderConfig command, implements all aktions and command logic.
        /// </summary>
        private void SaveEncoderConfig()
        {
 
        }
        /// <summary>
        /// Can execute path of LoadEncoderConfig command.
        /// </summary>
        /// <param name="parameter">Not neccessary parameter, can be useful in deverse implementatins</param>
        /// <returns>true if command can execute or false if not.</returns>
        public bool CanLoadEncoderConfig(object parameter = null)
        {
            return false;
        }
        /// <summary>
        /// Execute path of LoadEncoderConfig command, implements all aktions and command logic.
        /// </summary>
        private void LoadEncoderConfig()
        {
 
        }
        /// <summary>
        /// Can execute path of CalibrationSetup command.
        /// </summary>
        /// <param name="parameter">Not neccessary parameter, can be useful in deverse implementatins</param>
        /// <returns>true if command can execute or false if not.</returns>
        public bool CanCalibrationSetup(object parameter = null)
        {
            return false;
        }
        /// <summary>
        /// Execute path of CalibrationSetup command, implements all aktions and command logic.
        /// </summary>
        private void CalibrationSetup()
        {
 
        }
        /// <summary>
        /// Can execute path of Preference command.
        /// </summary>
        /// <param name="parameter">Not neccessary parameter, can be useful in deverse implementatins</param>
        /// <returns>true if command can execute or false if not.</returns>
        public bool CanPreference(object parameter = null)
        {
            return false;
        }
        /// <summary>
        /// Execute path of Preference command, implements all aktions and command logic.
        /// </summary>
        private void Preference()
        {
 
        }
        /// <summary>
        /// Can execute path of Exit command.
        /// </summary>
        /// <param name="parameter">Not neccessary parameter, can be useful in deverse implementatins</param>
        /// <returns>true if command can execute or false if not.</returns>
        public bool CanExit(object parameter = null)
        {
            return Application.Current != null && Application.Current.MainWindow != null && bDevelopmentMode;
        }
        /// <summary>
        /// Execute path of Exit command, implements all aktions and command logic.
        /// </summary>
        private void Exit()
        {
            Application.Current.Shutdown();
        }
        /// <summary>
        /// Can execute path of ProductInformation command.
        /// </summary>
        /// <param name="parameter">Not neccessary parameter, can be useful in deverse implementatins</param>
        /// <returns>true if command can execute or false if not.</returns>
        public bool CanProductInformation(object parameter = null)
        {
            return false;
        }
        /// <summary>
        /// Execute path of ProductInformation command, implements all aktions and command logic.
        /// </summary>
        private void ProductInformation()
        {
 
        }
        /// <summary>
        /// Can execute path of ShowProtocolDataPacket command.
        /// </summary>
        /// <param name="parameter">Not neccessary parameter, can be useful in deverse implementatins</param>
        /// <returns>true if command can execute or false if not.</returns>
        public bool CanShowProtocolDataPacket(object parameter = null)
        {
            return false;
        }
        /// <summary>
        /// Execute path of ShowProtocolDataPacket command, implements all aktions and command logic.
        /// </summary>
        private void ShowProtocolDataPacket()
        {
 
        }
        /// <summary>
        /// Can execute path of OffsetCompensation command.
        /// </summary>
        /// <param name="parameter">Not neccessary parameter, can be useful in deverse implementatins</param>
        /// <returns>true if command can execute or false if not.</returns>
        public bool CanOffsetCompensation(object parameter = null)
        {
            return false;
        }
        /// <summary>
        /// Execute path of OffsetCompensation command, implements all aktions and command logic.
        /// </summary>
        private void OffsetCompensation()
        {
 
        }
        /// <summary>
        /// Can execute path of MotorController command.
        /// </summary>
        /// <param name="parameter">Not neccessary parameter, can be useful in deverse implementatins</param>
        /// <returns>true if command can execute or false if not.</returns>
        public bool CanMotorController(object parameter = null)
        {
            return true;
        }
        /// <summary>
        /// Execute path of MotorController command, implements all aktions and command logic.
        /// </summary>
        private void MotorController()
        {
            MotorControllerView mc = new MotorControllerView();
            mc.ShowDialog();
        }
        /// <summary>
        /// Can execute path of SerialPortTriggerSignal command.
        /// </summary>
        /// <param name="parameter">Not neccessary parameter, can be useful in deverse implementatins</param>
        /// <returns>true if command can execute or false if not.</returns>
        public bool CanSerialPortTriggerSignal(object parameter = null)
        {
            return true;
        }
        /// <summary>
        /// Execute path of SerialPortTriggerSignal command, implements all aktions and command logic.
        /// </summary>
        private void SerialPortTriggerSignal()
        {
            SignalTriggerView st = new SignalTriggerView();
            st.ShowDialog();
        }
        /// <summary>
        /// Can execute path of SensorDemo command.
        /// </summary>
        /// <param name="parameter">Not neccessary parameter, can be useful in deverse implementatins</param>
        /// <returns>true if command can execute or false if not.</returns>
        public bool CanSensorDemo(object parameter = null)
        {
            return false;
        }
        /// <summary>
        /// Execute path of SensorDemo command, implements all aktions and command logic.
        /// </summary>
        private void SensorDemo()
        {
 
        }
        /// <summary>
        /// Can execute path of SendReport command.
        /// </summary>
        /// <param name="parameter">Not neccessary parameter, can be useful in deverse implementatins</param>
        /// <returns>true if command can execute or false if not.</returns>
        public bool CanSendReport(object parameter = null)
        {
            return false;
        }
        /// <summary>
        /// Execute path of SendReport command, implements all aktions and command logic.
        /// </summary>
        private void SendReport()
        {
 
        }
        /// <summary>
        /// Can execute path of About command.
        /// </summary>
        /// <param name="parameter">Not neccessary parameter, can be useful in deverse implementatins</param>
        /// <returns>true if command can execute or false if not.</returns>
        public bool CanAbout(object parameter = null)
        {
            return true;
        }
        /// <summary>
        /// Execute path of About command, implements all aktions and command logic.
        /// </summary>
        private void About()
        {
            About window = new About();
            window.Show();
        }
        /// <summary>
        /// Can execute path of OneStepCalibration command.
        /// </summary>
        /// <param name="parameter">Not neccessary parameter, can be useful in deverse implementatins</param>
        /// <returns>true if command can execute or false if not.</returns>
        public bool CanOneStepCalibration(object parameter = null)
        {
            return true;
        }
        /// <summary>
        /// Execute path of OneStepCalibration command, implements all aktions and command logic.
        /// </summary>
        private void OneStepCalibration()
        {
            BDevelopmentMode = !BDevelopmentMode;
            if(VDetailsButton == Visibility.Collapsed)
            {
                //ToDo: For Tests
                Window nw = new FormShowProtocolContainer(10, 10, 10, AKS16_AKS17_API.FormShowProtocol.EProtocol.BiSS);
                nw.ShowDialog();
                VDetailsButton = Visibility.Visible;
            }
            else
            {
                //ToDo: For Tests
                Window nw = new FormOffsetCompensationContainer();
                nw.ShowDialog();
                VDetailsButton = Visibility.Collapsed;
            }
           
        }
        #endregion
    }
}

            for (int i = 4; i<262148; i += 4)
            {
                string s = i.ToString();
                lABZResolution.Add(s);
            }

/// <summary>
        /// Fills WPF ComboBox with items
        /// </summary>
        /// <param name="comboBoxToFill">ComboBox to fill</param>
        /// <param name="Items">List of string with items</param>
        public static void FillComboBoxWithItems(out ComboBox comboBoxToFill, List<string> Items)
        {
            comboBoxToFill = new ComboBox();
            comboBoxToFill.ItemsSource = Items;
        }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using Microsoft.Win32;
 
namespace AKS16_AKS17_CalibrationGui_NewRev.ServiceClasses.UniversallyServiceClasses
{
    /// <summary>
    /// This class implements service functions for all projeckts levels
    /// </summary>
    public static class Services
    {
        /// <summary>
        /// Fills WPF ComboBox with items 
        /// </summary>
        /// <param name="comboBoxToFill">ComboBox to fill with items</param>
        /// <param name="Items">One or more string parameters for comboBox</param>
        public static void FillComboBoxWithItems(out ComboBox comboBoxToFill, params string[] Items)
        {
            comboBoxToFill = new ComboBox();
            for (int i = 0; i < Items.Length; i++)
            {
                comboBoxToFill.Items.Add(Items[i]);
            }
        }
        /// <summary>
        /// Fills WPF ComboBox with items
        /// </summary>
        /// <param name="comboBoxToFill">ComboBox to fill</param>
        /// <param name="Items">List of string with items</param>
        public static void FillComboBoxWithItems(out ComboBox comboBoxToFill, List<string> Items)
        {
            comboBoxToFill = new ComboBox();
            for (int i = 0; i<Items.Count; i++)
            {
                comboBoxToFill.Items.Add(Items[i]);
            }
        }
        /// <summary>
        /// Adds new items to WPF ComboBox
        /// </summary>
        /// <param name="comboBoxToAdd">ComboBox to expand with new items</param>
        /// <param name="Items">List of strings with items</param>
        public static void AddComboBoxItems(ref ComboBox comboBoxToAdd, List<string> Items)
        {
            for(int i = 0; i < Items.Count; i++)
            {
                comboBoxToAdd.Items.Add(Items[i]);
            }
        }
        /// <summary>
        /// Adds new items to WPF ComboBox
        /// </summary>
        /// <param name="comboBoxToAdd">ComboBox to expand with new items</param>
        /// <param name="Items">One or more strings with items</param>
        public static void AddComboBoxItems(ref ComboBox comboBoxToAdd, params string [] Items)
        {
            for(int i = 0; i < Items.Length; i++)
            {
                comboBoxToAdd.Items.Add(Items[i]);
            } 
        }
        /// <summary>
        /// Fills List<string> with values
        /// </summary>
        /// <param name="listToFill">List to fill</param>
        /// <param name="values">One or more string values</param>
        public static void FillListOfString(out List<string> listToFill, params string[] values)
        {
            listToFill = new List<string>();
            for(int i = 0; i<values.Length; i++)
            {
                listToFill.Add(values[i]);
            }
        }
        /// <summary>
        /// Closes the window with recived name
        /// </summary>
        /// <param name="Name"> Window name</param>
        /// <returns>true if was success or false if not</returns>
        public static bool CloseWindow(string sName)
        {
            try
            {
                WindowCollection collection = App.Current.Windows;
                foreach (Window current in collection)
                {
                    if (current.Name == sName)
                    {
                        current.Close();
                        return true;
                    }
                }
            }
            catch(Exception ex)
            {
                MessageBox.Show("Error in Servise classe Services, function CloseWindow" + "\r\n" + ex.Message);
                return false;
            }
            return false;
        }
        
    }
}