dl_dxf.h

Go to the documentation of this file.

/****************************************************************************
** Copyright (C) 2001-2013 RibbonSoft, GmbH. All rights reserved.
**
** This file is part of the dxflib project.
**
** This file is free software; you can redistribute it and/or modify
** it 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.
**
** Licensees holding valid dxflib Professional Edition licenses may use
** this file in accordance with the dxflib Commercial License
** Agreement provided with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.ribbonsoft.com for further details.
**
** Contact info@ribbonsoft.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
 
#ifndef DL_DXF_H
#define DL_DXF_H
 
#include <stdio.h>
#include <stdlib.h>
 
#include <limits>
#include <map>
#include <sstream>
#include <string>
 
#include "dl_attributes.h"
#include "dl_codes.h"
#include "dl_entities.h"
#include "dl_global.h"
#include "dl_writer_ascii.h"
 
#ifdef _WIN32
#undef M_PI
#define M_PI 3.14159265358979323846
#pragma warning(disable : 4800)
#endif
 
#ifndef M_PI
#define M_PI 3.1415926535897932384626433832795
#endif
 
#ifndef DL_NANDOUBLE
#define DL_NANDOUBLE std::numeric_limits<double>::quiet_NaN()
#endif
 
class DL_CreationInterface;
class DL_WriterA;
 
#define DL_VERSION "3.17.0.0"
 
#define DL_VERSION_MAJOR 3
#define DL_VERSION_MINOR 17
#define DL_VERSION_REV 0
#define DL_VERSION_BUILD 0
 
#define DL_UNKNOWN 0
#define DL_LAYER 10
#define DL_BLOCK 11
#define DL_ENDBLK 12
#define DL_LINETYPE 13
#define DL_STYLE 20
#define DL_SETTING 50
#define DL_ENTITY_POINT 100
#define DL_ENTITY_LINE 101
#define DL_ENTITY_POLYLINE 102
#define DL_ENTITY_LWPOLYLINE 103
#define DL_ENTITY_VERTEX 104
#define DL_ENTITY_SPLINE 105
#define DL_ENTITY_KNOT 106
#define DL_ENTITY_CONTROLPOINT 107
#define DL_ENTITY_ARC 108
#define DL_ENTITY_CIRCLE 109
#define DL_ENTITY_ELLIPSE 110
#define DL_ENTITY_INSERT 111
#define DL_ENTITY_TEXT 112
#define DL_ENTITY_MTEXT 113
#define DL_ENTITY_DIMENSION 114
#define DL_ENTITY_LEADER 115
#define DL_ENTITY_HATCH 116
#define DL_ENTITY_ATTRIB 117
#define DL_ENTITY_IMAGE 118
#define DL_ENTITY_IMAGEDEF 119
#define DL_ENTITY_TRACE 120
#define DL_ENTITY_SOLID 121
#define DL_ENTITY_3DFACE 122
#define DL_ENTITY_XLINE 123
#define DL_ENTITY_RAY 124
#define DL_ENTITY_ARCALIGNEDTEXT 125
#define DL_ENTITY_SEQEND 126
#define DL_XRECORD 200
#define DL_DICTIONARY 210
 
class DXFLIB_EXPORT DL_Dxf {
public:
    DL_Dxf();
    ~DL_Dxf();
 
    bool in(const std::string& file, DL_CreationInterface* creationInterface);
    bool readDxfGroups(FILE* fp, DL_CreationInterface* creationInterface);
    static bool getStrippedLine(std::string& s,
                                unsigned int size,
                                FILE* stream,
                                bool stripSpace = true);
 
    bool readDxfGroups(std::stringstream& stream,
                       DL_CreationInterface* creationInterface);
    bool in(std::stringstream& stream, DL_CreationInterface* creationInterface);
    static bool getStrippedLine(std::string& s,
                                unsigned int size,
                                std::stringstream& stream,
                                bool stripSpace = true);
 
    static bool stripWhiteSpace(char** s, bool stripSpaces = true);
 
    bool processDXFGroup(DL_CreationInterface* creationInterface,
                         int groupCode,
                         const std::string& groupValue);
    void addSetting(DL_CreationInterface* creationInterface);
    void addLayer(DL_CreationInterface* creationInterface);
    void addLinetype(DL_CreationInterface* creationInterface);
    void addBlock(DL_CreationInterface* creationInterface);
    void endBlock(DL_CreationInterface* creationInterface);
    void addTextStyle(DL_CreationInterface* creationInterface);
 
    void addPoint(DL_CreationInterface* creationInterface);
    void addLine(DL_CreationInterface* creationInterface);
    void addXLine(DL_CreationInterface* creationInterface);
    void addRay(DL_CreationInterface* creationInterface);
 
    void addPolyline(DL_CreationInterface* creationInterface);
    void addVertex(DL_CreationInterface* creationInterface);
 
    void addSpline(DL_CreationInterface* creationInterface);
 
    void addArc(DL_CreationInterface* creationInterface);
    void addCircle(DL_CreationInterface* creationInterface);
    void addEllipse(DL_CreationInterface* creationInterface);
    void addInsert(DL_CreationInterface* creationInterface);
 
    void addTrace(DL_CreationInterface* creationInterface);
    void add3dFace(DL_CreationInterface* creationInterface);
    void addSolid(DL_CreationInterface* creationInterface);
 
    void addMText(DL_CreationInterface* creationInterface);
    void addText(DL_CreationInterface* creationInterface);
    void addArcAlignedText(DL_CreationInterface* creationInterface);
 
    void addAttribute(DL_CreationInterface* creationInterface);
 
    DL_DimensionData getDimData();
    void addDimLinear(DL_CreationInterface* creationInterface);
    void addDimAligned(DL_CreationInterface* creationInterface);
    void addDimRadial(DL_CreationInterface* creationInterface);
    void addDimDiametric(DL_CreationInterface* creationInterface);
    void addDimAngular(DL_CreationInterface* creationInterface);
    void addDimAngular3P(DL_CreationInterface* creationInterface);
    void addDimOrdinate(DL_CreationInterface* creationInterface);
 
    void addLeader(DL_CreationInterface* creationInterface);
 
    void addHatch(DL_CreationInterface* creationInterface);
    void addHatchLoop();
    void addHatchEdge();
    bool handleHatchData(DL_CreationInterface* creationInterface);
 
    void addImage(DL_CreationInterface* creationInterface);
    void addImageDef(DL_CreationInterface* creationInterface);
 
    void addComment(DL_CreationInterface* creationInterface,
                    const std::string& comment);
 
    void addDictionary(DL_CreationInterface* creationInterface);
    void addDictionaryEntry(DL_CreationInterface* creationInterface);
 
    bool handleXRecordData(DL_CreationInterface* creationInterface);
    bool handleDictionaryData(DL_CreationInterface* creationInterface);
 
    bool handleXData(DL_CreationInterface* creationInterface);
    bool handleMTextData(DL_CreationInterface* creationInterface);
    bool handleLWPolylineData(DL_CreationInterface* creationInterface);
    bool handleSplineData(DL_CreationInterface* creationInterface);
    bool handleLeaderData(DL_CreationInterface* creationInterface);
    bool handleLinetypeData(DL_CreationInterface* creationInterface);
 
    void endEntity(DL_CreationInterface* creationInterface);
 
    void endSequence(DL_CreationInterface* creationInterface);
 
    // int  stringToInt(const char* s, bool* ok=NULL);
 
    DL_WriterA* out(const char* file,
                    DL_Codes::version version = DL_VERSION_2000);
 
    void writeHeader(DL_WriterA& dw);
 
    void writePoint(DL_WriterA& dw,
                    const DL_PointData& data,
                    const DL_Attributes& attrib);
    void writeLine(DL_WriterA& dw,
                   const DL_LineData& data,
                   const DL_Attributes& attrib);
    void writeXLine(DL_WriterA& dw,
                    const DL_XLineData& data,
                    const DL_Attributes& attrib);
    void writeRay(DL_WriterA& dw,
                  const DL_RayData& data,
                  const DL_Attributes& attrib);
    void writePolyline(DL_WriterA& dw,
                       const DL_PolylineData& data,
                       const DL_Attributes& attrib);
    void writeVertex(DL_WriterA& dw, const DL_VertexData& data);
    void writePolylineEnd(DL_WriterA& dw);
    void writeSpline(DL_WriterA& dw,
                     const DL_SplineData& data,
                     const DL_Attributes& attrib);
    void writeControlPoint(DL_WriterA& dw, const DL_ControlPointData& data);
    void writeFitPoint(DL_WriterA& dw, const DL_FitPointData& data);
    void writeKnot(DL_WriterA& dw, const DL_KnotData& data);
    void writeCircle(DL_WriterA& dw,
                     const DL_CircleData& data,
                     const DL_Attributes& attrib);
    void writeArc(DL_WriterA& dw,
                  const DL_ArcData& data,
                  const DL_Attributes& attrib);
    void writeEllipse(DL_WriterA& dw,
                      const DL_EllipseData& data,
                      const DL_Attributes& attrib);
    void writeSolid(DL_WriterA& dw,
                    const DL_SolidData& data,
                    const DL_Attributes& attrib);
    void writeTrace(DL_WriterA& dw,
                    const DL_TraceData& data,
                    const DL_Attributes& attrib);
    void write3dFace(DL_WriterA& dw,
                     const DL_3dFaceData& data,
                     const DL_Attributes& attrib);
    void writeInsert(DL_WriterA& dw,
                     const DL_InsertData& data,
                     const DL_Attributes& attrib);
    void writeMText(DL_WriterA& dw,
                    const DL_MTextData& data,
                    const DL_Attributes& attrib);
    void writeText(DL_WriterA& dw,
                   const DL_TextData& data,
                   const DL_Attributes& attrib);
    void writeAttribute(DL_WriterA& dw,
                        const DL_AttributeData& data,
                        const DL_Attributes& attrib);
    void writeDimStyleOverrides(DL_WriterA& dw, const DL_DimensionData& data);
    void writeDimAligned(DL_WriterA& dw,
                         const DL_DimensionData& data,
                         const DL_DimAlignedData& edata,
                         const DL_Attributes& attrib);
    void writeDimLinear(DL_WriterA& dw,
                        const DL_DimensionData& data,
                        const DL_DimLinearData& edata,
                        const DL_Attributes& attrib);
    void writeDimRadial(DL_WriterA& dw,
                        const DL_DimensionData& data,
                        const DL_DimRadialData& edata,
                        const DL_Attributes& attrib);
    void writeDimDiametric(DL_WriterA& dw,
                           const DL_DimensionData& data,
                           const DL_DimDiametricData& edata,
                           const DL_Attributes& attrib);
    void writeDimAngular(DL_WriterA& dw,
                         const DL_DimensionData& data,
                         const DL_DimAngularData& edata,
                         const DL_Attributes& attrib);
    void writeDimAngular3P(DL_WriterA& dw,
                           const DL_DimensionData& data,
                           const DL_DimAngular3PData& edata,
                           const DL_Attributes& attrib);
    void writeDimOrdinate(DL_WriterA& dw,
                          const DL_DimensionData& data,
                          const DL_DimOrdinateData& edata,
                          const DL_Attributes& attrib);
    void writeLeader(DL_WriterA& dw,
                     const DL_LeaderData& data,
                     const DL_Attributes& attrib);
    void writeLeaderVertex(DL_WriterA& dw, const DL_LeaderVertexData& data);
    void writeHatch1(DL_WriterA& dw,
                     const DL_HatchData& data,
                     const DL_Attributes& attrib);
    void writeHatch2(DL_WriterA& dw,
                     const DL_HatchData& data,
                     const DL_Attributes& attrib);
    void writeHatchLoop1(DL_WriterA& dw, const DL_HatchLoopData& data);
    void writeHatchLoop2(DL_WriterA& dw, const DL_HatchLoopData& data);
    void writeHatchEdge(DL_WriterA& dw, const DL_HatchEdgeData& data);
 
    int writeImage(DL_WriterA& dw,
                   const DL_ImageData& data,
                   const DL_Attributes& attrib);
 
    void writeImageDef(DL_WriterA& dw, int handle, const DL_ImageData& data);
 
    void writeLayer(DL_WriterA& dw,
                    const DL_LayerData& data,
                    const DL_Attributes& attrib);
 
    void writeLinetype(DL_WriterA& dw, const DL_LinetypeData& data);
 
    void writeAppid(DL_WriterA& dw, const std::string& name);
 
    void writeBlock(DL_WriterA& dw, const DL_BlockData& data);
    void writeEndBlock(DL_WriterA& dw, const std::string& name);
 
    void writeVPort(DL_WriterA& dw);
    void writeStyle(DL_WriterA& dw, const DL_StyleData& style);
    void writeView(DL_WriterA& dw);
    void writeUcs(DL_WriterA& dw);
    void writeDimStyle(DL_WriterA& dw,
                       double dimasz,
                       double dimexe,
                       double dimexo,
                       double dimgap,
                       double dimtxt);
    void writeBlockRecord(DL_WriterA& dw);
    void writeBlockRecord(DL_WriterA& dw, const std::string& name);
    void writeObjects(DL_WriterA& dw,
                      const std::string& appDictionaryName = "");
    void writeAppDictionary(DL_WriterA& dw);
    int writeDictionaryEntry(DL_WriterA& dw, const std::string& name);
    void writeXRecord(DL_WriterA& dw, int handle, int value);
    void writeXRecord(DL_WriterA& dw, int handle, double value);
    void writeXRecord(DL_WriterA& dw, int handle, bool value);
    void writeXRecord(DL_WriterA& dw, int handle, const std::string& value);
    void writeObjectsEnd(DL_WriterA& dw);
 
    void writeComment(DL_WriterA& dw, const std::string& comment);
 
    // static double toReal(const char* value, double def=0.0);
 
    //    static int toInt(const char* value, int def=0) {
    //        if (value!=NULL && value[0] != '\0') {
    //            return atoi(value);
    //        }
 
    //        return def;
    //    }
 
    //    static const char* toString(const char* value, const char* def="") {
    //        if (value!=NULL && value[0] != '\0') {
    //            return value;
    //        } else {
    //            return def;
    //        }
    //    }
 
    static bool checkVariable(const char* var, DL_Codes::version version);
 
    DL_Codes::version getVersion() { return version; }
 
    int getLibVersion(const std::string& str);
 
    static void test();
 
    bool hasValue(int code) { return values.count(code) == 1; }
 
    int getIntValue(int code, int def) {
        if (!hasValue(code)) {
            return def;
        }
        return toInt(values[code]);
    }
 
    int toInt(const std::string& str) {
        char* p;
        return strtol(str.c_str(), &p, 10);
    }
 
    int getInt16Value(int code, int def) {
        if (!hasValue(code)) {
            return def;
        }
        return toInt16(values[code]);
    }
 
    int toInt16(const std::string& str) {
        char* p;
        return strtol(str.c_str(), &p, 16);
    }
 
    bool toBool(const std::string& str) {
        char* p;
        return (bool)strtol(str.c_str(), &p, 10);
    }
 
    std::string getStringValue(int code, const std::string& def) {
        if (!hasValue(code)) {
            return def;
        }
        return values[code];
    }
 
    double getRealValue(int code, double def) {
        if (!hasValue(code)) {
            return def;
        }
        return toReal(values[code]);
    }
 
    double toReal(const std::string& str) {
        double ret;
        // make sure the real value uses '.' not ',':
        std::string str2 = str;
        std::replace(str2.begin(), str2.end(), ',', '.');
        // make sure c++ expects '.' not ',':
        std::istringstream istr(str2);
        // istr.imbue(std::locale("C"));
        istr >> ret;
        return ret;
    }
 
private:
    DL_Codes::version version;
 
    std::string polylineLayer;
    double* vertices;
    int maxVertices;
    int vertexIndex;
 
    double* knots;
    int maxKnots;
    int knotIndex;
 
    double* weights;
    int weightIndex;
 
    double* controlPoints;
    int maxControlPoints;
    int controlPointIndex;
 
    double* fitPoints;
    int maxFitPoints;
    int fitPointIndex;
 
    double* leaderVertices;
    int maxLeaderVertices;
    int leaderVertexIndex;
 
    bool firstHatchLoop;
    DL_HatchEdgeData hatchEdge;
    std::vector<std::vector<DL_HatchEdgeData>> hatchEdges;
 
    std::string xRecordHandle;
    bool xRecordValues;
 
    // Only the useful part of the group code
    std::string groupCodeTmp;
    // ...same as integer
    unsigned int groupCode;
    // Only the useful part of the group value
    std::string groupValue;
    // Current entity type
    int currentObjectType;
    // Value of the current setting
    char settingValue[DL_DXF_MAXLINE + 1];
    // Key of the current setting (e.g. "$ACADVER")
    std::string settingKey;
    // Stores the group codes
    std::map<int, std::string> values;
    // First call of this method. We initialize all group values in
    //  the first call.
    bool firstCall;
    // Attributes of the current entity (layer, color, width, line type)
    DL_Attributes attrib;
    // library version. hex: 0x20003001 = 2.0.3.1
    int libVersion;
    // app specific dictionary handle:
    unsigned long appDictionaryHandle;
    // handle of standard text style, referenced by dimstyle:
    unsigned long styleHandleStd;
};
 
#endif
 
// EOF