test_sdk/gui/gtl_gui_cross_spec_chart.cpp

#include "gtl_gui_cross_spec_chart.h"

namespace gtl {
    namespace gui {

        cross_spec_chart::cross_spec_chart(QWidget* parent)
            : chart(parent)
            , _frequency(200)
            , _resolution(10)
            , _window(5)
            , _lines(20)
            , _average(1)
            , _overlap(0)
        {
            set_axis_y_mode(true);
        }

        cross_spec_chart::~cross_spec_chart()
        {
            if(_cross_spec)
                delete _cross_spec;
        }

        void cross_spec_chart::set_x_log(bool value)
        {

        }

        chart_series *cross_spec_chart::create_series(analog_data *ai)
        {

            if(!_series.size())
                _ref = ai;

            if(_series.size() == 1 && static_cast<chart_series*>(_series[0])->ad() != _ref)
                _ref = _data;

            _data = ai;

            while(_series.size())
                remove_series(static_cast<chart_series*>(_series.back()));


            if(!_cross_spec)
            {
                _cross_spec = new gtl::math::cross_spec(_ref, _data);
                connect(_cross_spec, &gtl::math::cross_spec::frequency_changed, this,  &gtl::gui::cross_spec_chart::frequency_changed);
                connect(_cross_spec, &gtl::math::cross_spec::resolution_changed, this, &gtl::gui::cross_spec_chart::resolution_changed);
                connect(_cross_spec, &gtl::math::cross_spec::window_changed, this, &gtl::gui::cross_spec_chart::window_changed);
                connect(_cross_spec, &gtl::math::cross_spec::lines_changed, this, &gtl::gui::cross_spec_chart::lines_changed);
                connect(_cross_spec, &gtl::math::cross_spec::average_changed, this, &gtl::gui::cross_spec_chart::average_changed);
                connect(_cross_spec, &gtl::math::cross_spec::overlap_changed, this, &gtl::gui::cross_spec_chart::overlap_changed);

                _cross_spec->set_average(_average);
                _cross_spec->set_overlap(_overlap);
                _cross_spec->set_frequency(_frequency);
                _cross_spec->set_lines(_lines);
                _cross_spec->set_window(static_cast<gtl::math::cross_spec::windows>(_window));
            }
            _cross_spec->set_ref(_ref);
            _cross_spec->set_data(_data);

            cross_spec_series *series = new cross_spec_series(is_updating(), _cross_spec, _data, _axis_x, _axis_y);
            QString name = tr("cross_spec: ") + _ref->name() + tr(", ") + _data->name();
            series->set_name(name);
            series->update();

            return series;
        }

        qreal cross_spec_chart::frequency() const
        {
            if(_cross_spec)
                return _cross_spec->frequency();
            return _frequency;
        }

        void cross_spec_chart::set_frequency(qreal newFrequency)
        {
            if (qFuzzyCompare(_frequency, newFrequency))
                return;
            _frequency = newFrequency;
            if(_cross_spec && _ref && _data)
                _cross_spec->set_frequency(_frequency);
        }

        qreal cross_spec_chart::resolution() const
        {
            if(_cross_spec)
                return _cross_spec->resolution();
            return _resolution;
        }

        void cross_spec_chart::set_resolution(qreal newResolution)
        {
            if (qFuzzyCompare(_resolution, newResolution))
                return;
            _resolution = newResolution;
            if(_cross_spec && _ref && _data)
                _cross_spec->set_resolution(_resolution);
        }

        int cross_spec_chart::window() const
        {
            if(_cross_spec)
                return static_cast<int>(_cross_spec->window());
            return _window;
        }

        void cross_spec_chart::set_window(int newWindow)
        {
            if (_window == newWindow)
                return;
            _window = newWindow;
            if(_cross_spec && _ref && _data)
                _cross_spec->set_window(static_cast<gtl::math::cross_spec::windows>(_window));
        }

        int cross_spec_chart::lines() const
        {
            if(_cross_spec)
                return _cross_spec->lines();
            return _lines;
        }

        void cross_spec_chart::set_lines(int newLines)
        {
            if (_lines == newLines)
                return;
            _lines = newLines;
            if(_cross_spec && _ref && _data)
                _cross_spec->set_lines(_lines);
        }

        int cross_spec_chart::average() const
        {
            if(_cross_spec)
                return _cross_spec->average();
            return _average;
        }

        void cross_spec_chart::set_average(int newAverage)
        {
            if (_average == newAverage)
                return;
            _average = newAverage;
            if(_cross_spec && _ref && _data)
                _cross_spec->set_average(_average);
        }

        qreal cross_spec_chart::overlap() const
        {
            if(_cross_spec)
                return _cross_spec->overlap();
            return _overlap;
        }

        void cross_spec_chart::set_overlap(qreal newOverlap)
        {
            if (qFuzzyCompare(_overlap, newOverlap))
                return;
            _overlap = newOverlap;
            if(_cross_spec && _ref && _data)
                _cross_spec->set_overlap(_overlap);
        }

    } // namespace gui
} // namespace gtl