WPSGraphicStyle.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) 2002, 2005 William Lachance (william.lachance@sympatico.ca)
 * Copyright (C) 2002, 2004 Marc Maurer (uwog@uwog.net)
 *
 * 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.
 *
 * For further information visit http://libwps.sourceforge.net
*/
#ifndef WPS_GRAPHIC_STYLE
#  define WPS_GRAPHIC_STYLE
#  include <ostream>
#  include <string>
#  include <vector>
 
#  include "librevenge/librevenge.h"
#  include "libwps_internal.h"

class WPSGraphicStyle
{
public:
        enum LineCap { C_Butt, C_Square, C_Round };
        enum LineJoin { J_Miter, J_Round, J_Bevel };
        enum GradientType { G_None, G_Axial, G_Linear, G_Radial, G_Rectangular, G_Square, G_Ellipsoid };

        struct GradientStop
        {
                explicit GradientStop(float offset=0.0, WPSColor const &col=WPSColor::black(), float opacity=1.0)
                        : m_offset(offset)
                        , m_color(col)
                        , m_opacity(opacity)
                {
                }

                int cmp(GradientStop const &a) const
                {
                        if (m_offset < a.m_offset) return -1;
                        if (m_offset > a.m_offset) return 1;
                        if (m_color < a.m_color) return -1;
                        if (m_color > a.m_color) return 1;
                        if (m_opacity < a.m_opacity) return -1;
                        if (m_opacity > a.m_opacity) return 1;
                        return 0;
                }

                friend std::ostream &operator<<(std::ostream &o, GradientStop const &st)
                {
                        o << "offset=" << st.m_offset << ",";
                        o << "color=" << st.m_color << ",";
                        if (st.m_opacity<1.0f)
                                o << "opacity=" << st.m_opacity*100.f << "%,";
                        return o;
                }

                float m_offset;
                WPSColor m_color;
                float m_opacity;
        };

        struct Pattern
        {
                Pattern()
                        : m_dim(0,0)
                        , m_data()
                        , m_picture()
                        , m_pictureMime("")
                        , m_pictureAverageColor(WPSColor::white())
                {
                        m_colors[0]=WPSColor::black();
                        m_colors[1]=WPSColor::white();
                }

                Pattern(Vec2i dim, librevenge::RVNGBinaryData const &picture, std::string const &mime, WPSColor const &avColor)
                        : m_dim(dim)
                        , m_data()
                        , m_picture(picture)
                        , m_pictureMime(mime)
                        , m_pictureAverageColor(avColor)
                {
                        m_colors[0]=WPSColor::black();
                        m_colors[1]=WPSColor::white();
                }
                Pattern(Pattern const &)=default;
                Pattern(Pattern &&)=default;
                virtual ~Pattern();
                bool empty() const
                {
                        if (m_dim[0]==0 || m_dim[1]==0) return true;
                        if (m_picture.size()) return false;
                        if (m_dim[0]!=8 && m_dim[0]!=16 && m_dim[0]!=32) return true;
                        return m_data.size()!=size_t((m_dim[0]/8)*m_dim[1]);
                }

                bool getAverageColor(WPSColor &col) const;
                bool getUniqueColor(WPSColor &col) const;
                bool getBinary(librevenge::RVNGBinaryData &data, std::string &type) const;

                int cmp(Pattern const &a) const
                {
                        int diff = m_dim.cmp(a.m_dim);
                        if (diff) return diff;
                        if (m_data.size() < a.m_data.size()) return -1;
                        if (m_data.size() > a.m_data.size()) return 1;
                        for (size_t h=0; h < m_data.size(); ++h)
                        {
                                if (m_data[h]<a.m_data[h]) return 1;
                                if (m_data[h]>a.m_data[h]) return -1;
                        }
                        for (int i=0; i<2; ++i)
                        {
                                if (m_colors[i] < a.m_colors[i]) return 1;
                                if (m_colors[i] > a.m_colors[i]) return -1;
                        }
                        if (m_pictureAverageColor < a.m_pictureAverageColor) return 1;
                        if (m_pictureAverageColor > a.m_pictureAverageColor) return -1;
                        if (m_pictureMime < a.m_pictureMime) return 1;
                        if (m_pictureMime > a.m_pictureMime) return -1;
                        if (m_picture.size() < a.m_picture.size()) return 1;
                        if (m_picture.size() > a.m_picture.size()) return -1;
                        const unsigned char *ptr=m_picture.getDataBuffer();
                        const unsigned char *aPtr=a.m_picture.getDataBuffer();
                        if (!ptr || !aPtr) return 0; // must only appear if the two buffers are empty
                        for (unsigned long h=0; h < m_picture.size(); ++h, ++ptr, ++aPtr)
                        {
                                if (*ptr < *aPtr) return 1;
                                if (*ptr > *aPtr) return -1;
                        }
                        return 0;
                }

                friend std::ostream &operator<<(std::ostream &o, Pattern const &pat)
                {
                        o << "dim=" << pat.m_dim << ",";
                        if (pat.m_picture.size())
                        {
                                o << "type=" << pat.m_pictureMime << ",";
                                o << "col[average]=" << pat.m_pictureAverageColor << ",";
                        }
                        else
                        {
                                if (!pat.m_colors[0].isBlack()) o << "col0=" << pat.m_colors[0] << ",";
                                if (!pat.m_colors[1].isWhite()) o << "col1=" << pat.m_colors[1] << ",";
                                o << "[";
                                for (auto const &data : pat.m_data)
                                        o << std::hex << int(data) << std::dec << ",";
                                o << "],";
                        }
                        return o;
                }

                Pattern &operator=(Pattern const &)=default;
                Vec2i m_dim;

                WPSColor m_colors[2];
                std::vector<unsigned char> m_data;
        protected:
                librevenge::RVNGBinaryData m_picture;
                std::string m_pictureMime;
                WPSColor m_pictureAverageColor;
        };

        WPSGraphicStyle()
                : m_lineWidth(1)
                , m_lineDashWidth()
                , m_lineCap(C_Butt)
                , m_lineJoin(J_Miter)
                , m_lineOpacity(1)
                , m_lineColor(WPSColor::black())
                , m_fillRuleEvenOdd(false)
                , m_surfaceColor(WPSColor::white())
                , m_surfaceOpacity(0)
                , m_shadowColor(WPSColor::black())
                , m_shadowOpacity(0)
                , m_shadowOffset(1,1)
                , m_pattern()
                , m_gradientType(G_None)
                , m_gradientStopList()
                , m_gradientAngle(0)
                , m_gradientBorder(0)
                , m_gradientPercentCenter(0.5f,0.5f)
                , m_gradientRadius(1)
                , m_backgroundColor(WPSColor::white())
                , m_backgroundOpacity(-1)
                , m_bordersList()
                , m_frameName("")
                , m_frameNextName("")
                , m_rotate(0)
                , m_extra("")
        {
                m_arrows[0]=m_arrows[1]=false;
                m_flip[0]=m_flip[1]=false;
                m_gradientStopList.push_back(GradientStop(0.0, WPSColor::white()));
                m_gradientStopList.push_back(GradientStop(1.0, WPSColor::black()));
        }
        WPSGraphicStyle(WPSGraphicStyle const &)=default;
        WPSGraphicStyle(WPSGraphicStyle &&)=default;
        WPSGraphicStyle &operator=(WPSGraphicStyle &&)=default;
        WPSGraphicStyle &operator=(WPSGraphicStyle const &)=default;
        static WPSGraphicStyle emptyStyle()
        {
                WPSGraphicStyle res;
                res.m_lineWidth=0;
                return res;
        }

        virtual ~WPSGraphicStyle();
        bool hasLine() const
        {
                return m_lineWidth>0 && m_lineOpacity>0;
        }

        void setSurfaceColor(WPSColor const &col, float opacity = 1)
        {
                m_surfaceColor = col;
                m_surfaceOpacity = opacity;
        }

        bool hasSurfaceColor() const
        {
                return m_surfaceOpacity > 0;
        }

        void setPattern(Pattern const &pat)
        {
                m_pattern=pat;
        }

        bool hasPattern() const
        {
                return !m_pattern.empty();
        }

        bool hasGradient(bool complex=false) const
        {
                return m_gradientType != G_None && int(m_gradientStopList.size()) >= (complex ? 3 : 2);
        }

        bool hasSurface() const
        {
                return hasSurfaceColor() || hasPattern() || hasGradient();
        }

        void setBackgroundColor(WPSColor const &col, float opacity = 1)
        {
                m_backgroundColor = col;
                m_backgroundOpacity = opacity;
        }

        bool hasBackgroundColor() const
        {
                return m_backgroundOpacity > 0;
        }

        void setShadowColor(WPSColor const &col, float opacity = 1)
        {
                m_shadowColor = col;
                m_shadowOpacity = opacity;
        }

        bool hasShadow() const
        {
                return m_shadowOpacity > 0;
        }

        bool hasBorders() const
        {
                return !m_bordersList.empty();
        }

        bool hasSameBorders() const
        {
                if (m_bordersList.empty()) return true;
                if (m_bordersList.size()!=4) return false;
                for (size_t i=1; i<m_bordersList.size(); ++i)
                {
                        if (m_bordersList[i]!=m_bordersList[0])
                                return false;
                }
                return true;
        }

        std::vector<WPSBorder> const &borders() const
        {
                return m_bordersList;
        }

        void resetBorders()
        {
                m_bordersList.resize(0);
        }

        void setBorders(int wh, WPSBorder const &border);
        friend std::ostream &operator<<(std::ostream &o, WPSGraphicStyle const &st);
        void addTo(librevenge::RVNGPropertyList &pList, bool only1d=false) const;
        void addFrameTo(librevenge::RVNGPropertyList &pList) const;
        int cmp(WPSGraphicStyle const &a) const;

        float m_lineWidth;
        std::vector<float> m_lineDashWidth;
        LineCap m_lineCap;
        LineJoin m_lineJoin;
        float m_lineOpacity;
        WPSColor m_lineColor;
        bool m_fillRuleEvenOdd;
        WPSColor m_surfaceColor;
        float m_surfaceOpacity;

        WPSColor m_shadowColor;
        float m_shadowOpacity;
        Vec2f m_shadowOffset;

        Pattern m_pattern;

        GradientType m_gradientType;
        std::vector<GradientStop> m_gradientStopList;
        float m_gradientAngle;
        float m_gradientBorder;
        Vec2f m_gradientPercentCenter;
        float m_gradientRadius;

        bool m_arrows[2];
 
        //
        // related to the frame
        //

        WPSColor m_backgroundColor;
        float m_backgroundOpacity;
        std::vector<WPSBorder> m_bordersList;
        librevenge::RVNGString m_frameName;
        librevenge::RVNGString m_frameNextName;
 
        //
        // some transformation: must probably be somewhere else
        //

        float m_rotate;
        bool m_flip[2];

        std::string m_extra;
};
#endif
/* vim:set shiftwidth=4 softtabstop=4 noexpandtab: */