test_sdk/gui/gtl_gui_octv_chart.cpp

#include "gtl_gui_octv_chart.h"

namespace gtl
{
    namespace gui
    {
        octv_chart::octv_chart(QWidget* parent)
            : chart(parent)
            , _minimum(1)
            , _maximum(1000)
            , _ratio(0)
            , _look(0)
            , _fraction(0)
            , _unit(0)
        {

        }

        qreal octv_chart::minimum()
        {
            for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
            {
                _minimum = static_cast<octv_series*>(*iter_series)->minimum();
            }
            return _minimum;
        }

        qreal octv_chart::maximum()
        {
            for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
            {
                _maximum = static_cast<octv_series*>(*iter_series)->maximum();
            }
            return _maximum;
        }

        int octv_chart::ratio()
        {
            for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
            {
                _ratio = static_cast<octv_series*>(*iter_series)->ratio();
            }
            return _ratio;
        }

        int octv_chart::look()
        {
            for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
            {
                _look = static_cast<octv_series*>(*iter_series)->look();
            }
            return _look;
        }

        int octv_chart::fraction()
        {
            for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
            {
                _fraction = static_cast<octv_series*>(*iter_series)->fraction();
            }
            return _fraction;
        }

        int octv_chart::unit()
        {
            for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
            {
                _unit = static_cast<octv_series*>(*iter_series)->unit();
            }
            return _unit;
        }

        void octv_chart::save(QDomElement &root_element)
        {
//            chart::save(root_element);

//            root_element.setAttribute("minimum", _minimum);
//            root_element.setAttribute("maximum", _maximum);
//            root_element.setAttribute("ratio", _ratio);
//            root_element.setAttribute("look", _look);
//            root_element.setAttribute("fraction", _fraction);
//            root_element.setAttribute("unit", _unit);
        }

        void octv_chart::load(const QDomElement &root_element)
        {
//            chart::load(root_element);

//            _minimum = root_element.attribute("minimum", "1").toDouble();
//            _maximum = root_element.attribute("maximum", "1000").toDouble();
//            _ratio = root_element.attribute("ratio", "0").toInt();
//            _look = root_element.attribute("look", "0").toUInt();
//            _fraction = root_element.attribute("fraction", "0").toUInt();
//            _unit = root_element.attribute("unit", "0").toInt();
        }

        void octv_chart::set_minimum(qreal value)
        {
            if(value != _minimum)
            {
                if(_series.empty())
                {
                    _minimum = value;
                }
                else
                {
                    for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
                    {
                        static_cast<octv_series*>(*iter_series)->set_minimum(value);
                        _minimum = static_cast<octv_series*>(*iter_series)->minimum();
                    }
                }

                emit minimum_changed();
            }
        }

        void octv_chart::set_maximum(qreal value)
        {
            if(value != _maximum)
            {
                if(_series.empty())
                {
                    _maximum = value;
                }
                else
                {
                    for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
                    {
                        static_cast<octv_series*>(*iter_series)->set_maximum(value);
                        _maximum = static_cast<octv_series*>(*iter_series)->maximum();
                    }
                }

                emit minimum_changed();
            }
        }

        void octv_chart::set_ratio(int value)
        {
            if(value != _ratio)
            {
                if(_series.empty())
                {
                    _ratio = value;
                }
                else
                {
                    for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
                    {
                        static_cast<octv_series*>(*iter_series)->set_ratio(value);
                        _ratio = static_cast<octv_series*>(*iter_series)->ratio();
                    }
                }

                emit ratio_changed();
            }
        }

        void octv_chart::set_look(int value)
        {
            if(value != _look)
            {
                if(_series.empty())
                {
                    _look = value;
                }
                else
                {
                    for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
                    {
                        static_cast<octv_series*>(*iter_series)->set_look(value);
                        _look = static_cast<octv_series*>(*iter_series)->look();
                    }
                }

                emit look_changed();
            }
        }

        void octv_chart::set_fraction(int value)
        {
            if(value != _fraction)
            {
                if(_series.empty())
                {
                    _fraction = value;
                }
                else
                {
                    for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
                    {
                        static_cast<octv_series*>(*iter_series)->set_fraction(value);
                        _fraction = static_cast<octv_series*>(*iter_series)->fraction();
                    }
                }

                emit fraction_changed();
            }
        }

        void octv_chart::set_unit(int value)
        {
            if(value != _unit)
            {
                if(_series.empty())
                {
                    _unit = value;
                }
                else
                {
                    for(std::vector<::chart::series::series*>::iterator iter_series = _series.begin(); iter_series != _series.end(); iter_series++)
                    {
                        static_cast<octv_series*>(*iter_series)->set_unit(value);
                        _unit = static_cast<octv_series*>(*iter_series)->unit();
                    }
                }

                emit unit_changed();
            }
        }

        chart_series *octv_chart::create_series(analog_data *ai)
        {
            octv_series *series = new octv_series(is_updating(), ai, _axis_x, _axis_y);

            series->set_minimum(_minimum);
            series->set_maximum(_maximum);
            series->set_ratio(_ratio);
            series->set_look(_look);
            series->set_fraction(_fraction);
            series->set_unit(_unit);

            series->update();

            return series;
        }
    }
}