WKSChart.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/* libwps
 * Version: MPL 2.0 / LGPLv2.1+
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * Major Contributor(s):
 * Copyright (C) 2006, 2007 Andrew Ziem
 * Copyright (C) 2004 Marc Maurer (uwog@uwog.net)
 * Copyright (C) 2004-2006 Fridrich Strba (fridrich.strba@bluewin.ch)
 *
 * For minor contributions see the git repository.
 *
 * Alternatively, the contents of this file may be used under the terms
 * of the GNU Lesser General Public License Version 2.1 or later
 * (LGPLv2.1+), in which case the provisions of the LGPLv2.1+ are
 * applicable instead of those above.
 */
 
/*
 * Structure to store and construct a chart
 *
 */
 
#ifndef WKS_CHART
#  define WKS_CHART
 
#include <iostream>
#include <vector>
#include <map>
 
#include "libwps_internal.h"
 
#include "WPSEntry.h"
#include "WPSFont.h"
#include "WPSGraphicStyle.h"
 
namespace WKSChartInternal
{
class SubDocument;
}
class WKSChart
{
        friend class WKSChartInternal::SubDocument;
public:
        struct Position
        {
                explicit Position(Vec2i pos=Vec2i(-1,-1), librevenge::RVNGString const &sheetName="")
                        : m_pos(pos)
                        , m_sheetName(sheetName)
                        , m_sheetId(-1)
                {
                }

                bool valid() const
                {
                        return m_pos[0]>=0 && m_pos[1]>=0 && (!m_sheetName.empty() || m_sheetId>=0);
                }

                bool valid(Position const &maxPos) const
                {
                        return valid() && maxPos.valid() && maxPos.m_pos[0]>=m_pos[0] && maxPos.m_pos[1]>=m_pos[1];
                }

                librevenge::RVNGString getCellName() const;
                friend std::ostream &operator<<(std::ostream &o, Position const &pos);
                bool operator==(Position const &pos) const
                {
                        return m_pos==pos.m_pos && m_sheetName==pos.m_sheetName && m_sheetId==pos.m_sheetId;
                }

                bool operator!=(Position const &pos) const
                {
                        return !(operator==(pos));
                }

                Vec2i m_pos;
                librevenge::RVNGString m_sheetName;
                int m_sheetId;
        };

        struct Axis
        {
                enum Type { A_None, A_Numeric, A_Logarithmic, A_Sequence, A_Sequence_Skip_Empty };
                Axis();
                ~Axis();
                void addContentTo(int coord, librevenge::RVNGPropertyList &propList) const;
                void addStyleTo(librevenge::RVNGPropertyList &propList) const;
                friend std::ostream &operator<<(std::ostream &o, Axis const &axis);
                Type m_type;
                bool m_automaticScaling;
                Vec2f m_scaling;
                bool m_showGrid;
                bool m_showLabel;
                Position m_labelRanges[2];

                bool m_showTitle;
                Position m_titleRange;
                librevenge::RVNGString m_title;
                librevenge::RVNGString m_subTitle;
                WPSGraphicStyle m_style;
        };

        struct Legend
        {
                Legend()
                        : m_show(false)
                        , m_autoPosition(true)
                        , m_relativePosition(WPSBorder::RightBit)
                        , m_position(0,0)
                        , m_font()
                        , m_style()
                {
                }

                void addContentTo(librevenge::RVNGPropertyList &propList) const;
                void addStyleTo(librevenge::RVNGPropertyList &propList) const;
                friend std::ostream &operator<<(std::ostream &o, Legend const &legend);
                bool m_show;
                bool m_autoPosition;
                int m_relativePosition;
                Vec2f m_position;
                WPSFont m_font;
                WPSGraphicStyle m_style;
        };

        struct Serie
        {
                enum Type { S_Area, S_Bar, S_Bubble, S_Circle, S_Column, S_Gantt, S_Line, S_Radar, S_Ring, S_Scatter, S_Stock, S_Surface };
                enum PointType
                {
                        P_None=0, P_Automatic, P_Square, P_Diamond, P_Arrow_Down,
                        P_Arrow_Up, P_Arrow_Right, P_Arrow_Left, P_Bow_Tie, P_Hourglass,
                        P_Circle, P_Star, P_X, P_Plus, P_Asterisk,
                        P_Horizontal_Bar, P_Vertical_Bar
                };

                Serie();
                Serie(Serie const &)=default;
                Serie(Serie &&)=default;
                Serie &operator=(Serie const &)=default;
                Serie &operator=(Serie &&)=default;
                virtual ~Serie();
                bool is1DStyle() const
                {
                        return m_type==S_Line || m_type==S_Radar || (m_type==S_Scatter && m_pointType==P_None);
                }

                void setPrimaryColor(WPSColor const &color, float opacity = 1, bool force1D=false)
                {
                        if (force1D || is1DStyle())
                                m_style.m_lineColor=color;
                        else
                                m_style.setSurfaceColor(color, opacity);
                }

                void setPrimaryPattern(WPSGraphicStyle::Pattern const &pattern, bool force1D=false);
                void setSecondaryColor(WPSColor const &color)
                {
                        if (!is1DStyle())
                                m_style.m_lineColor=color;
                }

                bool valid() const
                {
                        return m_ranges[0].valid(m_ranges[0]);
                }

                void addContentTo(librevenge::RVNGPropertyList &propList) const;
                void addStyleTo(librevenge::RVNGPropertyList &propList) const;
                static std::string getSerieTypeName(Type type);
                friend std::ostream &operator<<(std::ostream &o, Serie const &series);
                Type m_type;
                Position m_ranges[2];
                bool m_useSecondaryY;
                WPSFont m_font;
                Position m_labelRanges[2];
                Position m_legendRange;
                librevenge::RVNGString m_legendText;
                WPSGraphicStyle m_style;
                PointType m_pointType;
        };

        struct TextZone
        {
                enum Type { T_Title, T_SubTitle, T_Footer };
                enum ContentType { C_Cell, C_Text };

                explicit TextZone(Type type);
                TextZone(TextZone const &)=default;
                ~TextZone();
                bool valid() const
                {
                        if (!m_show) return false;
                        if (m_contentType==C_Cell)
                                return m_cell.valid();
                        if (m_contentType!=C_Text)
                                return false;
                        for (auto const &e : m_textEntryList)
                        {
                                if (e.valid()) return true;
                        }
                        return false;
                }

                void addContentTo(librevenge::RVNGPropertyList &propList) const;
                void addStyleTo(librevenge::RVNGPropertyList &propList) const;
                friend std::ostream &operator<<(std::ostream &o, TextZone const &zone);
                Type m_type;
                ContentType m_contentType;
                bool m_show;
                Vec2f m_position;
                Position m_cell;
                std::vector<WPSEntry> m_textEntryList;
                WPSFont m_font;
                WPSGraphicStyle m_style;
        };

        explicit WKSChart(Vec2f const &dim=Vec2f());
        virtual ~WKSChart();
        void sendChart(WKSContentListenerPtr &listener, librevenge::RVNGSpreadsheetInterface *interface) const;
        virtual void sendContent(TextZone const &zone, WPSListenerPtr &listener) const=0;

        void setGridColor(WPSColor const &color)
        {
                m_gridColor=color;
        }

        Axis &getAxis(int coord);
        Axis const &getAxis(int coord) const;

        Legend const &getLegend() const
        {
                return m_legend;
        }

        Legend &getLegend()
        {
                return m_legend;
        }

        Serie *getSerie(int id, bool create);
        std::map<int, Serie> const &getIdSerieMap() const
        {
                return m_serieMap;
        }

        TextZone *getTextZone(TextZone::Type type, bool create=false);
 
protected:
        void sendTextZoneContent(TextZone::Type type, WPSListenerPtr listener) const;
 
public:
        Vec2f m_dimension;
        Serie::Type m_type;
        bool m_dataStacked;
        bool m_dataPercentStacked;
        bool m_dataVertical;
        bool m_is3D;
        bool m_is3DDeep;
 
        // main

        WPSGraphicStyle m_style;
        librevenge::RVNGString m_name;
 
        // plot area

        WPSBox2f m_plotAreaPosition;
        WPSGraphicStyle m_plotAreaStyle;
 
        // legend

        WPSBox2f m_legendPosition;

        WPSGraphicStyle m_floorStyle;
        WPSGraphicStyle m_wallStyle;
 
protected:
        WPSColor m_gridColor;
        Axis m_axis[5];
        Legend m_legend;
        std::map<int, Serie> m_serieMap;
        std::map<TextZone::Type, TextZone> m_textZoneMap;
private:
        explicit WKSChart(WKSChart const &orig) = delete;
        WKSChart &operator=(WKSChart const &orig) = delete;
};
 
#endif
/* vim:set shiftwidth=4 softtabstop=4 noexpandtab: */