WPG2Parser.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/* libwpg
 * 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 Ariya Hidayat (ariya@kde.org)
 * Copyright (C) 2005 Fridrich Strba (fridrich.strba@bluewin.ch)
 * Copyright (C) 2004 Marc Oude Kotte (marc@solcon.nl)
 *
 * 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://libwpg.sourceforge.net
 */
 
/* "This product is not manufactured, approved, or supported by
 * Corel Corporation or Corel Corporation Limited."
 */
 
#ifndef __WPG2PARSER_H__
#define __WPG2PARSER_H__
 
#include <limits>
#include <map>
#include <stack>
#include <vector>
 
#include <librevenge/librevenge.h>
 
#include "WPGBitmap.h"
#include "WPGDashArray.h"
#include "WPGXParser.h"
 
class WPG2TransformMatrix
{
public:
        double element[3][3];
 
        WPG2TransformMatrix()
        {
                // identity transformation
                element[0][0] = element[1][1] = 1;
                element[2][2] = 1;
                element[0][1] = element[0][2] = 0;
                element[1][0] = element[1][2] = 0;
                element[2][0] = element[2][1] = 0;
        }
 
        void transform(long &x, long &y) const
        {
                const double rx = element[0][0]*x + element[1][0]*y + element[2][0];
                const double ry = element[0][1]*x + element[1][1]*y + element[2][1];
                x = toLong(rx);
                y = toLong(ry);
        }
 
        librevenge::RVNGPropertyList transformPoint(const ::librevenge::RVNGPropertyList &p) const
        {
                librevenge::RVNGPropertyList propList;
                propList.insert("svg:x", (element[0][0]*p["svg:x"]->getDouble() + element[1][0]*p["svg:y"]->getDouble() + element[2][0]));
                propList.insert("svg:y", (element[0][1]*p["svg:x"]->getDouble() + element[1][1]*p["svg:y"]->getDouble() + element[2][1]));
                return propList;
        }
 
        librevenge::RVNGPropertyList transformRect(const ::librevenge::RVNGPropertyList &r) const
        {
                librevenge::RVNGPropertyList propList;
                double oldx1 = r["svg:x"]->getDouble();
                double oldy1 = r["svg:y"]->getDouble();
                double oldx2 = r["svg:x"]->getDouble() + r["svg:width"]->getDouble();
                double oldy2 = r["svg:y"]->getDouble() + r["svg:height"]->getDouble();
 
                double newx1 = element[0][0]*oldx1 + element[1][0]*oldy1 + element[2][0];
                double newy1 = element[0][1]*oldx1 + element[1][1]*oldy1 + element[2][1];
                double newx2 = element[0][0]*oldx2 + element[1][0]*oldy2 + element[2][0];
                double newy2 = element[0][1]*oldx2 + element[1][1]*oldy2 + element[2][1];
 
                propList.insert("svg:x", (double)newx1);
                propList.insert("svg:y", (double)newy1);
                propList.insert("svg:width", (newx2-newx1));
                propList.insert("svg:height", (newy2-newy1));
                return propList;
        }
 
        WPG2TransformMatrix &transformBy(const WPG2TransformMatrix &m)
        {
                double result[3][3];
 
                for (int i = 0; i < 3; i++)
                        for (int j = 0; j < 3; j++)
                        {
                                result[i][j] = 0;
                                for (int k = 0; k < 3; k++)
                                        result[i][j] += m.element[i][k]*element[k][j];
                        }
 
                for (int x = 0; x < 3; x++)
                        for (int y = 0; y < 3; y++)
                                element[x][y] = result[x][y];
 
                return *this;
        }
 
private:
        static long toLong(double d)
        {
                if (d > double(std::numeric_limits<long>::max()))
                        return std::numeric_limits<long>::max();
                else if (d < double(std::numeric_limits<long>::min()))
                        return std::numeric_limits<long>::min();
                else
                        return long(d);
        }
};
 
class WPGCompoundPolygon
{
public:
        WPG2TransformMatrix matrix;
        bool isFilled;
        bool isFramed;
        bool isClosed;
 
        WPGCompoundPolygon(): matrix(), isFilled(true), isFramed(true), isClosed(true) {}
};
 
class WPGGroupContext
{
public:
        unsigned subIndex;
        int parentType;
        librevenge::RVNGPropertyListVector compoundPath;
        WPG2TransformMatrix compoundMatrix;
        bool compoundWindingRule;
        bool compoundFilled;
        bool compoundFramed;
        bool compoundClosed;
 
        WPGGroupContext(): subIndex(0), parentType(0),
                compoundPath(), compoundMatrix(), compoundWindingRule(false),
                compoundFilled(false), compoundFramed(true), compoundClosed(false)    {}
 
        bool isCompoundPolygon() const
        {
                return parentType == 0x1a;
        }
};
 
class WPGBitmapContext
{
public:
        double x1, y1, x2, y2;
        long hres, vres;
        WPGBitmapContext(): x1(0), y1(0), x2(0), y2(0), hres(100), vres(100) {}
};
 
class WPGBinaryDataContext
{
public:
        double x1, y1, x2, y2;
        int numObjects, objectIndex;
        std::vector<librevenge::RVNGString> mimeTypes;
        WPGBinaryDataContext(): x1(0), y1(0), x2(0), y2(0), numObjects(0), objectIndex(0), mimeTypes() {}
};
 
class WPGTextDataContext
{
public:
        double x1, y1, x2, y2;
        unsigned short flags;
        unsigned char vertAlign;
        unsigned char horAlign;
        double baseLineAngle;
        WPGTextDataContext(): x1(0), y1(0), x2(0), y2(0), flags(), vertAlign(), horAlign(), baseLineAngle(0.0) {}
};
 
class WPG2Parser : public WPGXParser
{
public:
        WPG2Parser(librevenge::RVNGInputStream *input, librevenge::RVNGDrawingInterface *painter, bool isEmbedded = false);
        bool parse() override;
 
private:
        void handleStartWPG();
        void handleEndWPG();
        void handleFormSettings();
        void handleLayer();
        void handleCompoundPolygon();
 
        void handlePenStyleDefinition();
        void handlePatternDefinition();
        void handleColorPalette();
        void handleDPColorPalette();
        void handlePenForeColor();
        void handleDPPenForeColor();
        void handlePenBackColor();
        void handleDPPenBackColor();
        void handlePenStyle();
        void handlePenSize();
        void handleDPPenSize();
        void handleLineCap();
        void handleLineJoin();
        void handleBrushGradient();
        void handleDPBrushGradient();
        void handleBrushForeColor();
        void handleDPBrushForeColor();
        void handleBrushBackColor();
        void handleDPBrushBackColor();
        void handleBrushPattern();
 
        void handlePolyline();
        void handlePolyspline();
        void handlePolycurve();
        void handleRectangle();
        void handleArc();
 
        void handleBitmap();
        void handleBitmapData();
 
        void handleTextData();
        void handleTextLine();
        void handleTextBlock();
        void handleTextPath();
 
        void handleObjectCapsule();
        void handleObjectImage();
 
        void resetPalette();
        void flushCompoundPolygon();
        void setPenStyle();
 
        unsigned int getRemainingRecordLength() const;
        bool checkRLESize(unsigned bytes) const;
 
        double toDouble(long x) const;
        void transformXY(long &x, long &y) const;
 
        // parsing context
        int m_recordLength;
        long m_recordEnd;
        bool m_success;
        bool m_exit;
        bool m_graphicsStarted;
        unsigned int m_xres;
        unsigned int m_yres;
        long m_xofs;
        long m_yofs;
        long m_width;
        long m_height;
        bool m_doublePrecision;
        librevenge::RVNGPropertyList m_style;
        libwpg::WPGColor m_penForeColor;
        libwpg::WPGColor m_penBackColor;
        libwpg::WPGColor m_brushForeColor;
        libwpg::WPGColor m_brushBackColor;
        libwpg::WPGDashArray m_dashArray;
        librevenge::RVNGPropertyListVector m_gradient;
        std::map<unsigned int,libwpg::WPGDashArray> m_dashArrayStyles;
        bool m_layerOpened;
#ifdef DEBUG
        unsigned int m_layerId;
#endif
        WPG2TransformMatrix m_matrix;
        double m_gradientAngle;
        librevenge::RVNGPropertyList m_gradientRef;
        std::stack<WPGGroupContext> m_groupStack;
        WPG2TransformMatrix m_compoundMatrix;
        bool m_compoundWindingRule;
        bool m_compoundFilled;
        bool m_compoundFramed;
        bool m_compoundClosed;
        WPGBitmapContext m_bitmap;
        WPGBinaryDataContext m_binaryData;
        bool m_hFlipped, m_vFlipped;
        WPGTextDataContext m_textData;
        bool m_drawTextData;
 
        class ObjectCharacterization;
        void parseCharacterization(ObjectCharacterization *);
#if DUMP_BINARY_DATA
        unsigned m_binaryId;
#endif
};
 
#endif // __WPG2PARSER_H__
/* vim:set shiftwidth=4 softtabstop=4 noexpandtab: */