XLChart.hpp

Go to the documentation of this file.

#ifndef OPENXLSX_XLCHART_HPP
#define OPENXLSX_XLCHART_HPP
 
#include "OpenXLSX-Exports.hpp"
#include "XLConstants.hpp"
#include "XLXmlFile.hpp"
 
#include <optional>
#include <string>
#include <string_view>
 
namespace OpenXLSX
{
    enum class XLChartType {
        Bar,
        BarStacked,
        BarPercentStacked,
        Bar3D,
        Bar3DStacked,
        Bar3DPercentStacked,
        Column,
        ColumnStacked,
        ColumnPercentStacked,
        Column3D,
        Column3DStacked,
        Column3DPercentStacked,
        Line,
        LineStacked,
        LinePercentStacked,
        Line3D,
        Pie,
        Pie3D,
        Scatter,
        ScatterLine,            
        ScatterLineMarker,      
        ScatterSmooth,          
        ScatterSmoothMarker,    
        ScatterMarker,          
        Bubble,                 
        StockHLC,
        StockOHLC,
        Surface,
        Surface3D,
        SurfaceWireframe,
        Surface3DWireframe,
        Area,
        AreaStacked,
        AreaPercentStacked,
        Area3D,
        Area3DStacked,
        Area3DPercentStacked,
        Doughnut,
        Radar,
        RadarFilled,
        RadarMarkers,
        PieOfPie,
        BarOfPie
    };
 
    enum class XLLegendPosition { Bottom, Left, Right, Top, TopRight, Hidden };
 
    enum class XLMarkerStyle { None, Circle, Dash, Diamond, Dot, Picture, Plus, Square, Star, Triangle, X, Default };
 
    enum class XLLineDashType {
        Unset,
        Solid,
        Dot,
        Dash,
        LgDash,
        DashDot,
        LgDashDot,
        LgDashDotDot,
        SysDash,
        SysDot,
        SysDashDot
    };
 
    enum class XLAxisTickLabelPosition {
        NextToAxis,
        High,
        Low,
        None
    };
 
    class XLWorksheet;
    class XLCellRange;
 
    enum class XLErrorBarDirection { X, Y };
 
    enum class XLErrorBarType { Both, Minus, Plus };
 
    enum class XLErrorBarValueType { Custom, FixedValue, Percentage, StandardDeviation, StandardError };
 
    enum class XLTrendlineType { Linear, Exponential, Logarithmic, Polynomial, Power, MovingAverage };
 
    enum class XLAxisOrientation { MinMax, MaxMin };
 
    enum class XLAxisCrosses { AutoZero, Min, Max };
 
    class OPENXLSX_EXPORT XLChartSeries
    {
    public:
        XLChartSeries() = default;
        explicit XLChartSeries(const XMLNode& node);
 
        XLChartSeries& setTitle(std::string_view title);
        XLChartSeries& setSmooth(bool smooth);
        XLChartSeries& setMarkerStyle(XLMarkerStyle style);
 
        XLChartSeries& setColor(std::string_view hexRGB);
 
        XLChartSeries& setDataPointColor(uint32_t pointIdx, std::string_view hexRGB);
 
        XLChartSeries& setDataLabels(bool showValue, bool showCategoryName = false, bool showPercent = false);
 
        XLChartSeries& setDataLabelsFromRange(const XLWorksheet& wks, const XLCellRange& range);
 
        XLChartSeries& addTrendline(XLTrendlineType type, std::string_view name = "", uint8_t order = 2, uint8_t period = 2);
 
        XLChartSeries& addErrorBars(XLErrorBarDirection direction, XLErrorBarType type, XLErrorBarValueType valType, double value = 0.0);
 
        XLChartSeries& setLineWidth(double points);
        XLChartSeries& setLineDash(XLLineDashType dashType);
 
    private:
        XMLNode m_node;
    };
 
    struct XLChartAnchor
    {
        std::string name;
        uint32_t    row{1};
        uint32_t    col{1};
        XLDistance  width{XLDistance::Pixels(400)};
        XLDistance  height{XLDistance::Pixels(300)};
 
        XLChartAnchor() = default;
        XLChartAnchor(std::string_view n, uint32_t r, uint32_t c, XLDistance w, XLDistance h) : name(n), row(r), col(c), width(w), height(h)
        {}
    };
 
    class OPENXLSX_EXPORT XLAxis
    {
    public:
        XLAxis() = default;
        explicit XLAxis(const XMLNode& node);
 
        void setTitle(std::string_view title);
 
        void setMinBounds(double min);
        void clearMinBounds();
 
        void setMaxBounds(double max);
        void clearMaxBounds();
 
        void setMajorUnit(double unit);
 
        void setMinorUnit(double unit);
 
        void setLogScale(double base);
 
        void setDateAxis(bool isDateAxis);
 
        void setOrientation(XLAxisOrientation orientation);
 
        void setCrosses(XLAxisCrosses crosses);
 
        void setCrossesAt(double value);
 
        void setMajorGridlines(bool show);
        void setMinorGridlines(bool show);
 
        void setNumberFormat(std::string_view formatCode, bool sourceLinked = false);
 
        void setTickLabelPosition(XLAxisTickLabelPosition position);
 
    private:
        XMLNode m_node;
    };
 
    class OPENXLSX_EXPORT XLChart final : public XLXmlFile
    {
    public:
        XLChart() : XLXmlFile(nullptr) {}
 
        explicit XLChart(XLXmlData* xmlData);
 
        XLChart(const XLChart& other) = default;
 
        XLChart(XLChart&& other) noexcept = default;
 
        ~XLChart() = default;
 
        XLChart& operator=(const XLChart& other) = default;
 
        XLChart& operator=(XLChart&& other) noexcept = default;
 
        XLChartSeries addSeries(const XLWorksheet&         wks,
                                const XLCellRange&         values,
                                std::string_view           title            = "",
                                std::optional<XLChartType> targetChartType  = std::nullopt,
                                bool                       useSecondaryAxis = false);
        XLChartSeries addSeries(const XLWorksheet&         wks,
                                const XLCellRange&         values,
                                const XLCellRange&         categories,
                                std::string_view           title            = "",
                                std::optional<XLChartType> targetChartType  = std::nullopt,
                                bool                       useSecondaryAxis = false);
        XLChartSeries addSeries(std::string_view           valuesRef,
                                std::string_view           title            = "",
                                std::string_view           categoriesRef    = "",
                                std::optional<XLChartType> targetChartType  = std::nullopt,
                                bool                       useSecondaryAxis = false);
 
        XLChartSeries
            addBubbleSeries(std::string_view xValRef, std::string_view yValRef, std::string_view sizeRef, std::string_view title = "");
 
        XLChartSeries addBubbleSeries(const XLWorksheet& wks,
                                      const XLCellRange& xValues,
                                      const XLCellRange& yValues,
                                      const XLCellRange& sizes,
                                      std::string_view   title = "");
 
        void setTitle(std::string_view title);
 
        void setStyle(uint8_t styleId);
 
        void setLegendPosition(XLLegendPosition position);
 
        [[nodiscard]] XLAxis xAxis() const;
 
        [[nodiscard]] XLAxis yAxis() const;
 
        [[nodiscard]] XLAxis axis(std::string_view position) const;
 
        void setShowDataLabels(bool showValue, bool showCategory = false, bool showPercent = false);
 
        void setSeriesSmooth(uint32_t seriesIndex, bool smooth);
 
        void setSeriesMarker(uint32_t seriesIndex, XLMarkerStyle style);
 
        void setGapWidth(uint32_t percent);
 
        void setOverlap(int32_t percent);
 
        void setHoleSize(uint8_t percent);
 
        void setRotation(uint16_t x, uint16_t y, uint16_t perspective = 30);
 
        void setPlotAreaColor(std::string_view hexRGB);
 
        void setChartAreaColor(std::string_view hexRGB);
 
        void setShowDataTable(bool showTable, bool showKeys = false);
 
    private:
        friend class XLDocument;
        void                   initXml(XLChartType type = XLChartType::Bar);
        [[nodiscard]] uint32_t seriesCount() const;
    };
}    // namespace OpenXLSX
 
#endif    // OPENXLSX_XLCHART_HPP