kicad/lib_dxf/libdxfrw.h

/******************************************************************************
**  libDXFrw - Library to read/write DXF files (ascii & binary)              **
**                                                                           **
**  Copyright (C) 2011 Rallaz, rallazz@gmail.com                             **
**                                                                           **
**  This library is free software, licensed under the terms of the GNU       **
**  General Public License as published by the Free Software Foundation,     **
**  either version 2 of the License, or (at your option) any later version.  **
**  You should have received a copy of the GNU General Public License        **
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.    **
******************************************************************************/

#ifndef LIBDXFRW_H
#define LIBDXFRW_H

#include <string>
#include "drw_entities.h"
#include "drw_objects.h"
#include "drw_interface.h"


class dxfReader;
class dxfWriter;

class dxfRW
{
public:
    dxfRW( const char* name );
    ~dxfRW();
    // / reads the file specified in constructor
    /*!
     * An interface must be provided. It is used by the class to signal various
     * components being added.
     * @param interface_ the interface to use
     * @param ext should the extrusion be applied to convert in 2D?
     * @return true for success
     */
    bool            read( DRW_Interface* interface_, bool ext );

    void setBinary( bool b ) { binary = b; }

    bool            write( DRW_Interface* interface_, DRW::Version ver, bool bin );
    bool            writeLineType( DRW_LType* ent );
    bool            writeLayer( DRW_Layer* ent );
    bool            writeDimstyle( DRW_Dimstyle* ent );
    bool            writeTextstyle( DRW_Textstyle* ent );
    bool            writeVport( DRW_Vport* ent );
    bool            writePoint( DRW_Point* ent );
    bool            writeLine( DRW_Line* ent );
    bool            writeRay( DRW_Ray* ent );
    bool            writeXline( DRW_Xline* ent );
    bool            writeCircle( DRW_Circle* ent );
    bool            writeArc( DRW_Arc* ent );
    bool            writeEllipse( DRW_Ellipse* ent );
    bool            writeTrace( DRW_Trace* ent );
    bool            writeSolid( DRW_Solid* ent );
    bool            write3dface( DRW_3Dface* ent );
    bool            writeLWPolyline( DRW_LWPolyline* ent );
    bool            writePolyline( DRW_Polyline* ent );
    bool            writeSpline( DRW_Spline* ent );
    bool            writeBlockRecord( std::string name );
    bool            writeBlock( DRW_Block* ent );
    bool            writeInsert( DRW_Insert* ent );
    bool            writeMText( DRW_MText* ent );
    bool            writeText( DRW_Text* ent );
    bool            writeHatch( DRW_Hatch* ent );
    bool            writeViewport( DRW_Viewport* ent );
    DRW_ImageDef*   writeImage( DRW_Image* ent, std::string name );
    bool            writeLeader( DRW_Leader* ent );
    bool            writeDimension( DRW_Dimension* ent );

    void setEllipseParts( int parts ) { elParts = parts; }    /*!< set parts munber when convert ellipse to polyline */
private:
    // / used by read() to parse the content of the file
    bool            processDxf();
    bool            processHeader();
    bool            processTables();
    bool            processBlocks();
    bool            processBlock();
    bool            processEntities( bool isblock );
    bool            processObjects();

    bool            processLType();
    bool            processLayer();
    bool            processDimStyle();
    bool            processTextStyle();
    bool            processVports();

    bool            processPoint();
    bool            processLine();
    bool            processRay();
    bool            processXline();
    bool            processCircle();
    bool            processArc();
    bool            processEllipse();
    bool            processTrace();
    bool            processSolid();
    bool            processInsert();
    bool            processLWPolyline();
    bool            processPolyline();
    bool            processVertex( DRW_Polyline* pl );
    bool            processText();
    bool            processMText();
    bool            processHatch();
    bool            processSpline();
    bool            process3dface();
    bool            processViewport();
    bool            processImage();
    bool            processImageDef();
    bool            processDimension();
    bool            processLeader();

// bool writeHeader();
    bool            writeEntity( DRW_Entity* ent );
    bool            writeTables();
    bool            writeBlocks();
    bool            writeObjects();
    std::string     toHexStr( int n );

private:
    DRW::Version                version;
    std::string                 fileName;
    std::string                 codePage;
    bool                        binary;
    dxfReader*                  reader;
    dxfWriter*                  writer;
    DRW_Interface*              iface;
    DRW_Header                  header;
// int section;
    std::string                 nextentity;
    int                         entCount;
    bool                        wlayer0;
    bool                        dimstyleStd;
    bool                        applyExt;
    bool                        writingBlock;
    int                         elParts;    /*!< parts munber when convert ellipse to polyline */
    std::map<std::string, int>  blockMap;
    std::vector<DRW_ImageDef*>  imageDef;   /*!< imageDef list */

    int                         currHandle;
};

#endif    // LIBDXFRW_H