WPSGraphicShape.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_SHAPE
#  define WPS_GRAPHIC_SHAPE
#  include <ostream>
#  include <string>
#  include <vector>
 
#  include "librevenge/librevenge.h"
 
#  include "libwps_internal.h"

class WPSGraphicShape
{
public:
        enum Type { Arc, Circle, Line, Rectangle, Path, Pie, Polygon, Polyline, ShapeUnknown };
        enum Command { C_Ellipse, C_Polyline, C_Rectangle, C_Path, C_Polygon, C_Bad };
        struct PathData
        {
                explicit PathData(char type, Vec2f const &x=Vec2f(), Vec2f const &x1=Vec2f(), Vec2f const &x2=Vec2f())
                        : m_type(type)
                        , m_x(x)
                        , m_x1(x1)
                        , m_x2(x2)
                        , m_r()
                        , m_rotate(0)
                        , m_largeAngle(false)
                        , m_sweep(false)
                {
                }

                void translate(Vec2f const &delta);
                void scale(Vec2f const &factor);
                void rotate(float angle, Vec2f const &delta);
                void transform(WPSTransformation const &matrix, float rotation);
                bool get(librevenge::RVNGPropertyList &pList, Vec2f const &orig) const;
                friend std::ostream &operator<<(std::ostream &o, PathData const &path);
                int cmp(PathData const &a) const;
                char m_type;
                Vec2f m_x;
                Vec2f m_x1;
                Vec2f m_x2;
                Vec2f m_r;
                float m_rotate;
                bool m_largeAngle;
                bool m_sweep;
        };

        WPSGraphicShape()
                : m_type(ShapeUnknown)
                , m_bdBox()
                , m_formBox()
                , m_cornerWidth(0,0)
                , m_arcAngles(0,0)
                , m_vertices()
                , m_path()
                , m_extra("")
        {
        }
        WPSGraphicShape(WPSGraphicShape const &)=default;
        WPSGraphicShape(WPSGraphicShape &&)=default;
        WPSGraphicShape &operator=(WPSGraphicShape const &)=default;
        WPSGraphicShape &operator=(WPSGraphicShape &&)=default;
        ~WPSGraphicShape() { }
        static WPSGraphicShape line(Vec2f const &orign, Vec2f const &dest);
        static WPSGraphicShape rectangle(WPSBox2f const &box, Vec2f const &corners=Vec2f(0,0))
        {
                WPSGraphicShape res;
                res.m_type=Rectangle;
                res.m_bdBox=res.m_formBox=box;
                res.m_cornerWidth=corners;
                return res;
        }

        static WPSGraphicShape circle(WPSBox2f const &box)
        {
                WPSGraphicShape res;
                res.m_type=Circle;
                res.m_bdBox=res.m_formBox=box;
                return res;
        }

        static WPSGraphicShape arc(WPSBox2f const &box, WPSBox2f const &circleWPSBox, Vec2f const &angles)
        {
                WPSGraphicShape res;
                res.m_type=Arc;
                res.m_bdBox=box;
                res.m_formBox=circleWPSBox;
                res.m_arcAngles=angles;
                return res;
        }

        static WPSGraphicShape pie(WPSBox2f const &box, WPSBox2f const &circleWPSBox, Vec2f const &angles)
        {
                WPSGraphicShape res;
                res.m_type=Pie;
                res.m_bdBox=box;
                res.m_formBox=circleWPSBox;
                res.m_arcAngles=angles;
                return res;
        }

        static WPSGraphicShape polygon(WPSBox2f const &box)
        {
                WPSGraphicShape res;
                res.m_type=Polygon;
                res.m_bdBox=box;
                return res;
        }

        static WPSGraphicShape polyline(WPSBox2f const &box)
        {
                WPSGraphicShape res;
                res.m_type=Polyline;
                res.m_bdBox=box;
                return res;
        }

        static WPSGraphicShape path(WPSBox2f const &box)
        {
                WPSGraphicShape res;
                res.m_type=Path;
                res.m_bdBox=box;
                return res;
        }

        void translate(Vec2f const &delta);
        void scale(Vec2f const &factor);
        WPSGraphicShape rotate(float angle, Vec2f const &center) const;
        WPSGraphicShape transform(WPSTransformation const &matrix) const;
        Type getType() const
        {
                return m_type;
        }

        WPSBox2f getBdBox() const
        {
                return m_bdBox;
        }

        Command addTo(Vec2f const &orig, bool asSurface, librevenge::RVNGPropertyList &propList) const;
        friend std::ostream &operator<<(std::ostream &o, WPSGraphicShape const &sh);
        int cmp(WPSGraphicShape const &a) const;
protected:
        std::vector<PathData> getPath(bool forTransformation) const;
public:
        Type m_type;
        WPSBox2f m_bdBox;
        WPSBox2f m_formBox;
        Vec2f m_cornerWidth;
        Vec2f m_arcAngles;
        std::vector<Vec2f> m_vertices;
        std::vector<PathData> m_path;
        std::string m_extra;
};
#endif
/* vim:set shiftwidth=4 softtabstop=4 noexpandtab: */