chart.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_CHART_H
#define EGT_CHART_H
 
#include <deque>
#include <egt/widget.h>
 
namespace egt
{
inline namespace v1
{
 
namespace detail
{
class PlPlotImpl;
class PlPlotPieChart;
}
 
class ChartItemArray
{
public:
    ChartItemArray()
    {}
 
    using DataArray = std::deque<std::pair<double, double>>;
 
    using StringDataArray = std::deque<std::pair<double, std::string>>;
 
    bool add(const double& data, const double& data1)
    {
        if (m_sdata.empty())
        {
            m_data.emplace_back(std::make_pair(data, data1));
            return true;
        }
        return false;
    }
 
    bool add(const double& data, const std::string& data1)
    {
        if (m_data.empty())
        {
            m_sdata.emplace_back(std::make_pair(data, data1));
            return true;
        }
        return false;
    }
 
    void data(DataArray& data)
    {
        m_data = data;
    }
 
    void data(StringDataArray& data)
    {
        m_sdata = data;
    }
 
    DataArray get_data()
    {
        return m_data;
    }
 
    StringDataArray get_sdata()
    {
        return m_sdata;
    }
 
    DataArray get_data() const
    {
        return m_data;
    }
 
    StringDataArray get_sdata() const
    {
        return m_sdata;
    }
 
    EGT_NODISCARD bool IsStringArray() const
    {
        if (!m_sdata.empty())
            return true;
 
        return false;
    }
 
    void clear()
    {
        m_data.clear();
        m_sdata.clear();
    }
 
    ~ChartItemArray() = default;
 
private:
    DataArray m_data;
    StringDataArray m_sdata;
};
 
class EGT_API ChartBase: public Widget
{
public:
 
    using Widget::Widget;
 
    enum class GridFlag
    {
        none = -2,
        box = -1,
        box_ticks = 0,
        box_ticks_coord = 1,
        box_major_ticks_coord = 2,
        box_minor_ticks_coord = 3,
    };
 
    void draw(Painter& painter, const Rect& rect) override;
 
    virtual void create_impl() = 0;
 
    void data(const ChartItemArray& data);
 
    void add_data(const ChartItemArray& data);
 
    ChartItemArray data() const;
 
    size_t data_size() const;
 
    void remove_data(uint32_t count);
 
    void clear();
 
    void grid_style(GridFlag flag);
 
    GridFlag grid_style() const;
 
    void grid_width(const int val);
 
    int grid_width() const;
 
    void label(const std::string& xlabel, const std::string& ylabel, const std::string& title);
 
    std::string xlabel() const;
    std::string ylabel() const;
 
    std::string title() const;
 
    void xlabel(const std::string& xlabel);
    void ylabel(const std::string& ylabel);
 
    void title(const std::string& title);
 
    void resize(const Size& size) override;
 
    void bank(float bank);
 
    float bank() const;
 
    void serialize(Serializer& serializer) const;
 
    void deserialize(Serializer::Properties& props);
 
protected:
    std::unique_ptr<detail::PlPlotImpl> m_impl;
};
 
class EGT_API LineChart: public ChartBase
{
public:
 
    enum LinePattern
    {
        solid = 1,
        dotted,
        dashes,
    };
 
    explicit LineChart(const Rect& rect = {});
 
    LineChart(Serializer::Properties& props)
        : LineChart(props, false)
    {
    }
 
    LineChart(const LineChart&) = delete;
    LineChart& operator=(const LineChart&) = delete;
    LineChart(LineChart&&) noexcept = default;
    LineChart& operator=(LineChart&&) noexcept = default;
 
    void create_impl() override;
 
    void line_width(const int val);
 
    int line_width() const;
 
    void line_style(LinePattern pattern);
 
    LinePattern line_style() const;
 
    void serialize(Serializer& serializer) const override;
 
    ~LineChart() override;
 
protected:
 
    LineChart(Serializer::Properties& props, bool is_derived);
 
private:
 
    void deserialize(Serializer::Properties& props);
};
 
class EGT_API PointChart: public ChartBase
{
public:
 
    enum PointType
    {
        star = 3,
        circle,
        cross,
        dot = 17,
    };
 
    explicit PointChart(const Rect& rect = {});
 
    PointChart(Serializer::Properties& props)
        : PointChart(props, false)
    {
    }
 
    PointChart(const PointChart&) = delete;
    PointChart& operator=(const PointChart&) = delete;
    PointChart(PointChart&&) noexcept = default;
    PointChart& operator=(PointChart&&) noexcept = default;
 
    void create_impl() override;
 
    void point_type(PointType ptype);
 
    EGT_NODISCARD PointChart::PointType point_type() const;
 
    void serialize(Serializer& serializer) const override;
 
    ~PointChart() override;
 
protected:
 
    PointChart(Serializer::Properties& props, bool is_derived);
 
private:
 
    void deserialize(Serializer::Properties& props);
};
 
class EGT_API BarChart: public ChartBase
{
public:
 
    enum class BarPattern
    {
        solid = 0,
        horizontal_line = 1,
        vertical_line = 2,
        boxes = 7,
    };
 
    explicit BarChart(const Rect& rect = {});
 
    BarChart(Serializer::Properties& props)
        : BarChart(props, false)
    {
    }
 
public:
 
    BarChart(const BarChart&) = delete;
    BarChart& operator=(const BarChart&) = delete;
    BarChart(BarChart&&) noexcept = default;
    BarChart& operator=(BarChart&&) noexcept = default;
 
    void create_impl() override;
 
    void bar_style(BarPattern pattern);
 
    EGT_NODISCARD BarPattern bar_style() const;
 
    void serialize(Serializer& serializer) const override;
 
    ~BarChart() override;
 
protected:
 
    BarChart(Serializer::Properties& props, bool is_derived);
 
    BarChart(const Rect& rect, std::unique_ptr<detail::PlPlotImpl>&& impl);
 
    BarChart(Serializer::Properties& props, std::unique_ptr<detail::PlPlotImpl>&& impl);
 
private:
 
    void deserialize(Serializer::Properties& props);
};
 
 
class EGT_API HorizontalBarChart: public BarChart
{
public:
 
    explicit HorizontalBarChart(const Rect& rect = {});
 
    HorizontalBarChart(Serializer::Properties& props)
        : HorizontalBarChart(props, false)
    {
    }
 
protected:
 
    HorizontalBarChart(Serializer::Properties& props, bool is_derived);
 
public:
 
    HorizontalBarChart(const HorizontalBarChart&) = delete;
    HorizontalBarChart& operator=(const HorizontalBarChart&) = delete;
    HorizontalBarChart(HorizontalBarChart&&) noexcept = default;
    HorizontalBarChart& operator=(HorizontalBarChart&&) noexcept = default;
 
    ~HorizontalBarChart() override;
};
 
class EGT_API PieChart: public Widget
{
public:
    explicit PieChart(const Rect& rect = {});
 
    PieChart(Serializer::Properties& props)
        : PieChart(props, false)
    {
    }
 
    PieChart(const PieChart&) = delete;
    PieChart& operator=(const PieChart&) = delete;
    PieChart(PieChart&&) noexcept = default;
    PieChart& operator=(PieChart&&) noexcept = default;
 
    void draw(Painter& painter, const Rect& rect) override;
 
    void title(const std::string& title);
 
    EGT_NODISCARD std::string title() const;
 
    void data(const ChartItemArray& data);
 
    ChartItemArray data() const;
 
    EGT_NODISCARD size_t data_size() const;
 
    void add_data(const ChartItemArray& data);
 
    void remove_data(uint32_t count);
 
    void clear();
 
    void resize(const Size& size) override;
 
    void serialize(Serializer& serializer) const override;
 
    ~PieChart() override;
 
protected:
    PieChart(Serializer::Properties& props, bool is_derived);
 
    std::unique_ptr<detail::PlPlotPieChart> m_impl;
 
private:
 
    void deserialize(Serializer::Properties& props);
};
 
}
 
}
 
#endif