WPG2Parser.h

/* libwpg
 * 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)
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02111-1301 USA
 *
 * 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 "WPGXParser.h"
#include "WPGBrush.h"
#include "WPGPen.h"

#include <map>
#include <stack>
#include <vector>

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
    {
        long rx = (long)(element[0][0]*x + element[1][0]*y + element[2][0]);
        long ry = (long)(element[0][1]*x + element[1][1]*y + element[2][1]);
        x = rx;
        y = ry;
    }

    libwpg::WPGPoint transform(const libwpg::WPGPoint& p) const
    {
        libwpg::WPGPoint point;
        point.x = element[0][0]*p.x + element[1][0]*p.y + element[2][0];
        point.y = element[0][1]*p.x + element[1][1]*p.y + element[2][1];
        return point;
    }

    libwpg::WPGRect transform(const libwpg::WPGRect& r) const
    {
        libwpg::WPGRect rect;
        rect.x1 = element[0][0]*r.x1 + element[1][0]*r.y1 + element[2][0];
        rect.y1 = element[0][1]*r.x1 + element[1][1]*r.y1 + element[2][1];
        rect.x2 = element[0][0]*r.x2 + element[1][0]*r.y2 + element[2][0];
        rect.y2 = element[0][1]*r.x2 + element[1][1]*r.y2 + element[2][1];
        return rect;
    }

    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;
    }
};

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;
    libwpg::WPGPath 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<libwpg::WPGString> mimeTypes;
    WPGBinaryDataContext(): x1(0), y1(0), x2(0), y2(0), numObjects(0), objectIndex(0), mimeTypes() {}
};

class WPG2Parser : public WPGXParser
{
public:
    WPG2Parser(WPXInputStream *input, libwpg::WPGPaintInterface* painter);
    bool parse();

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 handleObjectCapsule();
    void handleObjectImage();

    void resetPalette();
    void flushCompoundPolygon();

    // 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;
    libwpg::WPGPen m_pen;
    libwpg::WPGBrush m_brush;
    std::map<unsigned int,libwpg::WPGDashArray> m_penStyles;
    bool m_layerOpened;
    unsigned int m_layerId;
    WPG2TransformMatrix m_matrix;
    double m_gradientAngle;
    libwpg::WPGPoint 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;

    class ObjectCharacterization;
    void parseCharacterization(ObjectCharacterization*);
};

#endif // __WPG2PARSER_H__