public SpectrumAnalyzerWin()
 {
     InitializeComponent();
     channels         = 0;
     spectrumAnalyzer = null;
     FormClosing     += SpectrumAnalyzerWin_FormClosing;
     CanClose         = false;
     timer            = new Timer();
 }
        public void initSpectrumAnalyzer(SpectrumAnalyzer _spectrumAnalyzer, int _channels, int _FIFOdepth)
        {
            inputs = new FIFO[_channels];
            for (int i = 0; i < _channels; i++)
            {
                inputs[i] = new FIFO(_FIFOdepth);
            }
            lines        = new SpectrumAnalyzerLine[_channels];
            inputsActive = new Boolean[_channels];
            inputData    = new double[_channels][];
            for (int i = 0; i < _channels; i++)
            {
                lines[i] = new SpectrumAnalyzerLine(spectrumAnalyzerScreen);
                switch (i % 4)
                {
                case 0: lines[i].color = Color.Red; break;

                case 1: lines[1].color = Color.Green; break;

                case 2: lines[2].color = Color.Cyan; break;

                case 3: lines[3].color = Color.Magenta; break;
                }
            }
            FIFOdepth        = _FIFOdepth;
            spectrumAnalyzer = _spectrumAnalyzer;
            timer.Interval   = 100; // ms
            timer.Tick      += Timer_Tick;

            _blockSize  = 4096;
            _windowType = FFTProcessor.WindowType.Hann;
            for (int i = 0; i < _channels; i++)
            {
                lines[i].acf = FFTProcessor.windowAmplitudeCorrectionFactorsdB[(int)_windowType];
            }

            fftProcessor = new FFTProcessor(_blockSize, spectrumAnalyzer.owner.sampleRate, _windowType);

            fftBlockSizes = new List <int>();
            for (int i = 64; i <= 8192; i *= 2)
            {
                SpectrumAnalyzerBlockSize.Items.Add(String.Format("{0} --> {1:f1}ms",
                                                                  i, 1000.0 * i / spectrumAnalyzer.owner.sampleRate));
                fftBlockSizes.Add(i);
            }
            SpectrumAnalyzerBlockSize.SelectedIndex         = fftBlockSizes.IndexOf(_blockSize);
            SpectrumAnalyzerBlockSize.SelectedIndexChanged += SpectrumAnalyzerBlockSize_SelectedIndexChanged;

            string[] windows = Enum.GetNames(typeof(FFTProcessor.WindowType));
            fftWindows = new List <FFTProcessor.WindowType>();
            for (int i = 0; i < windows.Length; i++)
            {
                fftWindows.Add((FFTProcessor.WindowType)i);
                SpectrumAnalyzerWindow.Items.Add(windows[i]);
            }
            SpectrumAnalyzerWindow.SelectedIndex         = fftWindows.IndexOf(_windowType);
            SpectrumAnalyzerWindow.SelectedIndexChanged += SpectrumAnalyzerWindow_SelectedIndexChanged;

            spectrumAnalyzerScreen.initSpectrumAnalyzerScreen(this, _channels, lines);

            if (spectrumAnalyzerScreen.gridF.logScale)
            {
                SpectrumAnalyzerFLog.Checked = true;
            }
            SpectrumAnalyzerFLog.Click += SpectrumAnalyzerFLog_Click;

            SpectrumAnalyzerFMin.Value = Convert.ToDecimal(spectrumAnalyzerScreen.gridF.min);
            SpectrumAnalyzerFMax.Value = Convert.ToDecimal(spectrumAnalyzerScreen.gridF.max);
            SpectrumAnalyzerYMin.Value = Convert.ToDecimal(spectrumAnalyzerScreen.gridY.min);
            SpectrumAnalyzerYMax.Value = Convert.ToDecimal(spectrumAnalyzerScreen.gridY.max);

            SpectrumAnalyzerFMin.ValueChanged += SpectrumAnalyzerFMin_ValueChanged;
            SpectrumAnalyzerFMax.ValueChanged += SpectrumAnalyzerFMax_ValueChanged;
            SpectrumAnalyzerYMin.ValueChanged += SpectrumAnalyzerYMin_ValueChanged;
            SpectrumAnalyzerYMax.ValueChanged += SpectrumAnalyzerYMax_ValueChanged;

            SpectrumAnalyzerAutoScale.Click += SpectrumAnalyzerAutoScale_Click;

            SpectrumAnalyzerChannelOnA.Checked = lines[0].show;
            SpectrumAnalyzerChannelOnB.Checked = lines[1].show;
            SpectrumAnalyzerChannelOnC.Checked = lines[2].show;
            SpectrumAnalyzerChannelOnD.Checked = lines[3].show;

            SpectrumAnalyzerChannelOnA.Click += SpectrumAnalyzerChannelOnA_Click;
            SpectrumAnalyzerChannelOnB.Click += SpectrumAnalyzerChannelOnB_Click;
            SpectrumAnalyzerChannelOnC.Click += SpectrumAnalyzerChannelOnC_Click;
            SpectrumAnalyzerChannelOnD.Click += SpectrumAnalyzerChannelOnD_Click;

            SpectrumAnalyzerPkHldA.Checked = lines[0].showMax;
            SpectrumAnalyzerPkHldB.Checked = lines[1].showMax;
            SpectrumAnalyzerPkHldC.Checked = lines[2].showMax;
            SpectrumAnalyzerPkHldD.Checked = lines[3].showMax;

            SpectrumAnalyzerPkHldA.Click += SpectrumAnalyzerPkHldA_Click;
            SpectrumAnalyzerPkHldB.Click += SpectrumAnalyzerPkHldB_Click;
            SpectrumAnalyzerPkHldC.Click += SpectrumAnalyzerPkHldC_Click;
            SpectrumAnalyzerPkHldD.Click += SpectrumAnalyzerPkHldD_Click;

            SpectrumAnalyzerAvgA.Checked = lines[0].showAvg;
            SpectrumAnalyzerAvgB.Checked = lines[1].showAvg;
            SpectrumAnalyzerAvgC.Checked = lines[2].showAvg;
            SpectrumAnalyzerAvgD.Checked = lines[3].showAvg;

            SpectrumAnalyzerAvgA.Click += SpectrumAnalyzerAvgA_Click;
            SpectrumAnalyzerAvgB.Click += SpectrumAnalyzerAvgB_Click;
            SpectrumAnalyzerAvgC.Click += SpectrumAnalyzerAvgC_Click;
            SpectrumAnalyzerAvgD.Click += SpectrumAnalyzerAvgD_Click;

            SpectrumAnalyzerSave.Click += SpectrumAnalyzerSave_Click;

            run = true;
            SpectrumAnalyzerRun.Checked = run;
            SpectrumAnalyzerRun.Click  += SpectrumAnalyzerRun_Click;

            showGrid = true;
            SpectrumAnalyzerGrid.Checked         = showGrid;
            spectrumAnalyzerScreen.drawGrid      = showGrid;
            SpectrumAnalyzerGrid.CheckedChanged += SpectrumAnalyzerGrid_CheckedChanged;

            channels      = _channels; // Triggers start
            timer.Enabled = true;
        }