test_sdk/gui/orbit/gtl_gui_orbit_chart.cpp

#include "gtl_gui_orbit_chart.h"
#include "gtl_gui_orbit_series.h"

namespace gtl {
    namespace gui {
        namespace orbit{

            chart::chart(QWidget* parent, ::chart::axis_horz *axis_x, ::chart::axis_vert *axis_y)
            : gtl::gui::chart(parent, static_cast<chart_axis_x*>(axis_x), static_cast<chart_axis_y*>(axis_y))
            {
                setBackgroundBrush(QBrush(Qt::white));

                _marker_action_add->disconnect();
                connect(_marker_action_add, &QAction::triggered, this, &chart::add_marker);

                _orbit_menu = new QMenu(this);
                _orbit_menu->addAction(_set_theme_action);

            }

            chart::~chart()
            {
                remove();
            }

            void chart::add(::chart::series::series *s)
            {
                remove();
                ::chart::widget::add(s);
            }

            void chart::add_marker()
            {
                if(_series.empty())
                    return;

                chart_marker* marker = new chart_marker(_series[0], _set_theme_action->isChecked());
                gtl::gui::chart::add(marker);

                connect(marker, &chart_marker::get_nearest_x, this, &chart::get_neares_series_x);
                connect(marker, &chart_marker::get_series_data, this, &chart::get_neares_series_y);
//                connect(marker, &chart_marker::get_series_values, this, &chart::get_series_values);
                connect(marker, &chart_marker::deleting, this, &chart::remove_marker);

                marker->set_pos(_mouse_pos_release);

                _markers->add_marker(marker);
                _single_markers->add(marker);
            }

            void chart::mouseDoubleClickEvent(QMouseEvent *event)
            {
                if(event->button() == Qt::LeftButton)
                {
                    if(_series.empty())
                        return;

                    series* s = static_cast<series*>(_series[0]);
                    s->autoscale();
                }
            }

            void chart::contextMenuEvent(QContextMenuEvent *event)
            {
                _orbit_menu->popup(event->globalPos());
            }

            void chart::get_neares_series_x(qreal &x, chart_line::pos_behaviors behavior)
            {
                if(_series.empty())
                    return;
            }

            void chart::get_neares_series_y(qreal x, bool is_widget_pos, QVariantList &data)
            {
                if(_series.empty())
                    return;

                series* s = static_cast<series*>(_series[0]);
                auto p_begin = s->points_begin();
                auto p_end = s->points_end();


                if(std::distance(p_begin, p_end) < 4)
                {
                    data.push_back(QVariant(qQNaN()));
                    data.push_back(QVariant(QColor(Qt::black)));
                    return;
                }

                auto it = std::lower_bound(p_begin, p_end, QPointF(x, 0), [](const QPointF &p0, const QPointF &p1)
                                           {
                                               return p0.x() < p1.x();
                                           }
                                           );

                if(it > p_begin + 1 && it < p_end - 1)
                {
                    qreal x1 = (it-1)->x();
                    qreal y1 = (it-1)->y();

                    qreal x2 = it->x();
                    qreal y2 = it->y();

                    qreal k = (y2 - y1) / (x2 - x1);

                    qreal y = k*(x - x1) + y1;

                    data.push_back(QVariant(s->map_to_widget(x, y).y()));
                    data.push_back(QVariant(s->color()));
                }
                else
                {
                    data.push_back(QVariant(qQNaN()));
                    data.push_back(QVariant(QColor(Qt::black)));
                }
            }

//            void chart::get_series_values(qreal x_min, qreal x_max, int series_idx, QVariantList &data)
//            {
//                if(_series.empty())
//                    return;

//                series* s = static_cast<series*>(_series[0]);
//                auto p_begin = s->points_begin();
//                auto p_end = s->points_end();


//                if(std::distance(p_begin, p_end) < 4)
//                    return;

//                auto it_min = std::lower_bound(p_begin, p_end, QPointF(x_min, 0), [](
//                                                const QPointF &p0, const QPointF &p1)
//                                                {
//                                                    return p0.x() < p1.x();
//                                                }
//                                                );

//                auto it_max = std::upper_bound(p_begin, p_end, QPointF(x_max, 0), [](
//                                                const QPointF &p0, const QPointF &p1)
//                                                {
//                                                    return p0.x() < p1.x();
//                                                }
//                                                );

//                for(auto it = it_min; it != it_max; it++)
//                    data.push_back(it->y());

//            }
        }
    } // namespace gui
} // namespace gtl