dl_entities.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 [email protected] if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
 
#ifndef DL_ENTITIES_H
#define DL_ENTITIES_H
 
#include "dl_global.h"
 
#include <string>
#include <vector>
 
struct DXFLIB_EXPORT DL_LayerData {
    DL_LayerData(const std::string& name,
                 int flags, bool off = false) :
        name(name), flags(flags), off(off) {
    }
 
    std::string name;
    int flags;
    bool off;
};
 
 
 
struct DXFLIB_EXPORT DL_BlockData {
    DL_BlockData(const std::string& bName,
                 int bFlags,
                 double bbpx, double bbpy, double bbpz) {
        name = bName;
        flags = bFlags;
        bpx = bbpx;
        bpy = bbpy;
        bpz = bbpz;
    }
 
    std::string name;
    int flags;
    double bpx;
    double bpy;
    double bpz;
};
 
 
struct DXFLIB_EXPORT DL_LinetypeData {
    DL_LinetypeData(
        const std::string& name,
        const std::string& description,
        int flags,
        int numberOfDashes,
        double patternLength,
        double* pattern = NULL
        )
        : name(name),
        description(description),
        flags(flags),
        numberOfDashes(numberOfDashes),
        patternLength(patternLength),
        pattern(pattern)
    {}
 
    std::string name;
    std::string description;
    int flags;
    int numberOfDashes;
    double patternLength;
    double* pattern;
};
 
 
 
struct DXFLIB_EXPORT DL_StyleData {
    DL_StyleData(
        const std::string& name,
        int flags,
        double fixedTextHeight,
        double widthFactor,
        double obliqueAngle,
        int textGenerationFlags,
        double lastHeightUsed,
        const std::string& primaryFontFile,
        const std::string& bigFontFile
        )
        : name(name),
        flags(flags),
        fixedTextHeight(fixedTextHeight),
        widthFactor(widthFactor),
        obliqueAngle(obliqueAngle),
        textGenerationFlags(textGenerationFlags),
        lastHeightUsed(lastHeightUsed),
        primaryFontFile(primaryFontFile),
        bigFontFile(bigFontFile),
        bold(false),
        italic(false) {
    }
 
    bool operator==(const DL_StyleData& other) const {
        // ignore lastHeightUsed:
        return (name==other.name &&
            flags==other.flags &&
            fixedTextHeight==other.fixedTextHeight &&
            widthFactor==other.widthFactor &&
            obliqueAngle==other.obliqueAngle &&
            textGenerationFlags==other.textGenerationFlags &&
            primaryFontFile==other.primaryFontFile &&
            bigFontFile==other.bigFontFile);
    }
 
    std::string name;
    int flags;
    double fixedTextHeight;
    double widthFactor;
    double obliqueAngle;
    int textGenerationFlags;
    double lastHeightUsed;
    std::string primaryFontFile;
    std::string bigFontFile;
 
    bool bold;
    bool italic;
};
 
struct DXFLIB_EXPORT DL_PointData {
    DL_PointData(double px=0.0, double py=0.0, double pz=0.0) {
        x = px;
        y = py;
        z = pz;
    }
 
    double x;
    double y;
    double z;
};
 
 
 
struct DXFLIB_EXPORT DL_LineData {
    DL_LineData(double lx1, double ly1, double lz1,
                double lx2, double ly2, double lz2) {
        x1 = lx1;
        y1 = ly1;
        z1 = lz1;
 
        x2 = lx2;
        y2 = ly2;
        z2 = lz2;
    }
 
    double x1;
    double y1;
    double z1;
 
    double x2;
    double y2;
    double z2;
};
 
struct DXFLIB_EXPORT DL_XLineData {
    DL_XLineData(double bx, double by, double bz,
                double dx, double dy, double dz) :
        bx(bx), by(by), bz(bz),
        dx(dx), dy(dy), dz(dz) {
    }
 
    double bx;
    double by;
    double bz;
 
    double dx;
    double dy;
    double dz;
};
 
struct DXFLIB_EXPORT DL_RayData {
    DL_RayData(double bx, double by, double bz,
               double dx, double dy, double dz) :
        bx(bx), by(by), bz(bz),
        dx(dx), dy(dy), dz(dz) {
    }
 
    double bx;
    double by;
    double bz;
 
    double dx;
    double dy;
    double dz;
};
 
 
 
struct DXFLIB_EXPORT DL_ArcData {
    DL_ArcData(double acx, double acy, double acz,
               double aRadius,
               double aAngle1, double aAngle2) {
 
        cx = acx;
        cy = acy;
        cz = acz;
        radius = aRadius;
        angle1 = aAngle1;
        angle2 = aAngle2;
    }
 
    double cx;
    double cy;
    double cz;
 
    double radius;
    double angle1;
    double angle2;
};
 
 
 
struct DXFLIB_EXPORT DL_CircleData {
    DL_CircleData(double acx, double acy, double acz,
                  double aRadius) {
 
        cx = acx;
        cy = acy;
        cz = acz;
        radius = aRadius;
    }
 
    double cx;
    double cy;
    double cz;
 
    double radius;
};
 
 
 
struct DXFLIB_EXPORT DL_PolylineData {
    DL_PolylineData(int pNumber, int pMVerteces, int pNVerteces, int pFlags, double pElevation = 0.0) {
        number = pNumber;
        m = pMVerteces;
        n = pNVerteces;
        elevation = pElevation;
        flags = pFlags;
    }
 
    unsigned int number;
 
    unsigned int m;
 
    unsigned int n;
 
    double elevation;
 
    int flags;
};
 
 
 
struct DXFLIB_EXPORT DL_VertexData {
    DL_VertexData(double px=0.0, double py=0.0, double pz=0.0,
                  double pBulge=0.0) {
        x = px;
        y = py;
        z = pz;
        bulge = pBulge;
    }
 
    double x;
    double y;
    double z;
    double bulge;
};
 
 
struct DXFLIB_EXPORT DL_TraceData {
    DL_TraceData() {
        thickness = 0.0;
        for (int i=0; i<4; i++) {
            x[i] = 0.0;
            y[i] = 0.0;
            z[i] = 0.0;
        }
    }
    
    DL_TraceData(double sx1, double sy1, double sz1,
                double sx2, double sy2, double sz2,
                double sx3, double sy3, double sz3,
                double sx4, double sy4, double sz4,
                double sthickness=0.0) {
 
        thickness = sthickness;
 
        x[0] = sx1;
        y[0] = sy1;
        z[0] = sz1;
 
        x[1] = sx2;
        y[1] = sy2;
        z[1] = sz2;
        
        x[2] = sx3;
        y[2] = sy3;
        z[2] = sz3;
        
        x[3] = sx4;
        y[3] = sy4;
        z[3] = sz4;
    }
 
    double thickness;
    
    double x[4];
    double y[4];
    double z[4];
};
 
 
 
 
 
typedef DL_TraceData DL_SolidData;
 
 
typedef DL_TraceData DL_3dFaceData;
 
 
struct DXFLIB_EXPORT DL_SplineData {
    DL_SplineData(int degree,
                  int nKnots,
                  int nControl,
                  int nFit,
                  int flags) :
        degree(degree),
        nKnots(nKnots),
        nControl(nControl),
        nFit(nFit),
        flags(flags) {
    }
 
    unsigned int degree;
 
    unsigned int nKnots;
 
    unsigned int nControl;
 
    unsigned int nFit;
 
    int flags;
 
    double tangentStartX;
    double tangentStartY;
    double tangentStartZ;
    double tangentEndX;
    double tangentEndY;
    double tangentEndZ;
};
 
 
 
struct DXFLIB_EXPORT DL_KnotData {
    DL_KnotData() {}
    DL_KnotData(double pk) {
        k = pk;
    }
 
    double k;
};
 
 
 
struct DXFLIB_EXPORT DL_ControlPointData {
    DL_ControlPointData(double px, double py, double pz, double weight) {
        x = px;
        y = py;
        z = pz;
        w = weight;
    }
 
    double x;
    double y;
    double z;
    double w;
};
 
 
 
struct DXFLIB_EXPORT DL_FitPointData {
    DL_FitPointData(double x, double y, double z) : x(x), y(y), z(z) {}
 
    double x;
    double y;
    double z;
};
 
 
 
struct DXFLIB_EXPORT DL_EllipseData {
    DL_EllipseData(double cx, double cy, double cz,
                   double mx, double my, double mz,
                   double ratio,
                   double angle1, double angle2)
        : cx(cx),
          cy(cy),
          cz(cz),
          mx(mx),
          my(my),
          mz(mz),
          ratio(ratio),
          angle1(angle1),
          angle2(angle2) {
    }
 
    double cx;
    double cy;
    double cz;
 
    double mx;
    double my;
    double mz;
 
    double ratio;
    double angle1;
    double angle2;
};
 
 
 
struct DXFLIB_EXPORT DL_InsertData {
    DL_InsertData(const std::string& name,
                  double ipx, double ipy, double ipz,
                  double sx, double sy, double sz,
                  double angle,
                  int cols, int rows,
                  double colSp, double rowSp) :
          name(name),
          ipx(ipx), ipy(ipy), ipz(ipz),
          sx(sx), sy(sy), sz(sz),
          angle(angle),
          cols(cols), rows(rows),
          colSp(colSp), rowSp(rowSp) {
    }
 
    std::string name;
    double ipx;
    double ipy;
    double ipz;
    double sx;
    double sy;
    double sz;
    double angle;
    int cols;
    int rows;
    double colSp;
    double rowSp;
};
 
 
 
struct DXFLIB_EXPORT DL_MTextData {
    DL_MTextData(double ipx, double ipy, double ipz,
                 double dirx, double diry, double dirz,
                 double height, double width,
                 int attachmentPoint,
                 int drawingDirection,
                 int lineSpacingStyle,
                 double lineSpacingFactor,
                 const std::string& text,
                 const std::string& style,
                 double angle) :
         ipx(ipx), ipy(ipy), ipz(ipz),
         dirx(dirx), diry(diry), dirz(dirz),
         height(height), width(width),
         attachmentPoint(attachmentPoint),
         drawingDirection(drawingDirection),
         lineSpacingStyle(lineSpacingStyle),
         lineSpacingFactor(lineSpacingFactor),
         text(text),
         style(style),
         angle(angle) {
 
    }
 
    double ipx;
    double ipy;
    double ipz;
    double dirx;
    double diry;
    double dirz;
    double height;
    double width;
    int attachmentPoint;
    int drawingDirection;
    int lineSpacingStyle;
    double lineSpacingFactor;
    std::string text;
    std::string style;
    double angle;
};
 
 
 
struct DXFLIB_EXPORT DL_TextData {
    DL_TextData(double ipx, double ipy, double ipz,
                double apx, double apy, double apz,
                double height, double xScaleFactor,
                int textGenerationFlags,
                int hJustification,
                int vJustification,
                const std::string& text,
                const std::string& style,
                double angle)
        : ipx(ipx), ipy(ipy), ipz(ipz),
          apx(apx), apy(apy), apz(apz),
          height(height), xScaleFactor(xScaleFactor),
          textGenerationFlags(textGenerationFlags),
          hJustification(hJustification),
          vJustification(vJustification),
          text(text),
          style(style),
          angle(angle) {
    }
 
    double ipx;
    double ipy;
    double ipz;
 
    double apx;
    double apy;
    double apz;
 
    double height;
    double xScaleFactor;
    int textGenerationFlags;
    int hJustification;
    int vJustification;
    std::string text;
    std::string style;
    double angle;
};
 
struct DXFLIB_EXPORT DL_ArcAlignedTextData {
 
    std::string text;
    std::string font;
    std::string style;
 
    double cx;
    double cy;
    double cz;
    double radius;
 
    double xScaleFactor;
    double height;
    double spacing;
    double offset;
    double rightOffset;
    double leftOffset;
    double startAngle;
    double endAngle;
    bool reversedCharacterOrder;
    int direction;
    int alignment;
    int side;
    bool bold;
    bool italic;
    bool underline;
    int characerSet;
    int pitch;
    bool shxFont;
    bool wizard;
    int arcHandle;
};
 
struct DXFLIB_EXPORT DL_AttributeData : public DL_TextData {
    DL_AttributeData(const DL_TextData& tData, const std::string& tag)
        : DL_TextData(tData), tag(tag) {
 
    }
 
    DL_AttributeData(double ipx, double ipy, double ipz,
                double apx, double apy, double apz,
                double height, double xScaleFactor,
                int textGenerationFlags,
                int hJustification,
                int vJustification,
                const std::string& tag,
                const std::string& text,
                const std::string& style,
                double angle)
        : DL_TextData(ipx, ipy, ipz,
                apx, apy, apz,
                height, xScaleFactor,
                textGenerationFlags,
                hJustification,
                vJustification,
                text,
                style,
                angle),
          tag(tag) {
    }
 
    std::string tag;
};
 
 
struct DXFLIB_EXPORT DL_DimensionData {
    DL_DimensionData(double dpx, double dpy, double dpz,
                     double mpx, double mpy, double mpz,
                     int type,
                     int attachmentPoint,
                     int lineSpacingStyle,
                     double lineSpacingFactor,
                     const std::string& text,
                     const std::string& style,
                     double angle,
                     double linearFactor = 1.0,
                     double dimScale = 1.0) :
        dpx(dpx), dpy(dpy), dpz(dpz),
        mpx(mpx), mpy(mpy), mpz(mpz),
        type(type),
        attachmentPoint(attachmentPoint),
        lineSpacingStyle(lineSpacingStyle),
        lineSpacingFactor(lineSpacingFactor),
        text(text),
        style(style),
        angle(angle),
        linearFactor(linearFactor),
        dimScale(dimScale) {
 
    }
 
    double dpx;
    double dpy;
    double dpz;
    double mpx;
    double mpy;
    double mpz;
    int type;
    int attachmentPoint;
    int lineSpacingStyle;
    double lineSpacingFactor;
    std::string text;
    std::string style;
    double angle;
    double linearFactor;
    double dimScale;
    bool arrow1Flipped;
    bool arrow2Flipped;
};
 
 
 
struct DXFLIB_EXPORT DL_DimAlignedData {
    DL_DimAlignedData(double depx1, double depy1, double depz1,
                      double depx2, double depy2, double depz2) {
 
        epx1 = depx1;
        epy1 = depy1;
        epz1 = depz1;
 
        epx2 = depx2;
        epy2 = depy2;
        epz2 = depz2;
    }
 
    double epx1;
    double epy1;
    double epz1;
 
    double epx2;
    double epy2;
    double epz2;
};
 
 
 
struct DXFLIB_EXPORT DL_DimLinearData {
    DL_DimLinearData(double ddpx1, double ddpy1, double ddpz1,
                     double ddpx2, double ddpy2, double ddpz2,
                     double dAngle, double dOblique) {
 
        dpx1 = ddpx1;
        dpy1 = ddpy1;
        dpz1 = ddpz1;
 
        dpx2 = ddpx2;
        dpy2 = ddpy2;
        dpz2 = ddpz2;
 
        angle = dAngle;
        oblique = dOblique;
    }
 
    double dpx1;
    double dpy1;
    double dpz1;
 
    double dpx2;
    double dpy2;
    double dpz2;
 
    double angle;
    double oblique;
};
 
 
 
struct DXFLIB_EXPORT DL_DimRadialData {
    DL_DimRadialData(double ddpx, double ddpy, double ddpz, double dleader) {
        dpx = ddpx;
        dpy = ddpy;
        dpz = ddpz;
 
        leader = dleader;
    }
 
    double dpx;
    double dpy;
    double dpz;
 
    double leader;
};
 
 
 
struct DXFLIB_EXPORT DL_DimDiametricData {
    DL_DimDiametricData(double ddpx, double ddpy, double ddpz, double dleader) {
        dpx = ddpx;
        dpy = ddpy;
        dpz = ddpz;
 
        leader = dleader;
    }
 
    double dpx;
    double dpy;
    double dpz;
 
    double leader;
};
 
 
 
struct DXFLIB_EXPORT DL_DimAngular2LData {
    DL_DimAngular2LData(double ddpx1, double ddpy1, double ddpz1,
                      double ddpx2, double ddpy2, double ddpz2,
                      double ddpx3, double ddpy3, double ddpz3,
                      double ddpx4, double ddpy4, double ddpz4) {
 
        dpx1 = ddpx1;
        dpy1 = ddpy1;
        dpz1 = ddpz1;
 
        dpx2 = ddpx2;
        dpy2 = ddpy2;
        dpz2 = ddpz2;
 
        dpx3 = ddpx3;
        dpy3 = ddpy3;
        dpz3 = ddpz3;
 
        dpx4 = ddpx4;
        dpy4 = ddpy4;
        dpz4 = ddpz4;
    }
 
    double dpx1;
    double dpy1;
    double dpz1;
 
    double dpx2;
    double dpy2;
    double dpz2;
 
    double dpx3;
    double dpy3;
    double dpz3;
 
    double dpx4;
    double dpy4;
    double dpz4;
};
 
 
struct DXFLIB_EXPORT DL_DimAngular3PData {
    DL_DimAngular3PData(double ddpx1, double ddpy1, double ddpz1,
                        double ddpx2, double ddpy2, double ddpz2,
                        double ddpx3, double ddpy3, double ddpz3) {
 
        dpx1 = ddpx1;
        dpy1 = ddpy1;
        dpz1 = ddpz1;
 
        dpx2 = ddpx2;
        dpy2 = ddpy2;
        dpz2 = ddpz2;
 
        dpx3 = ddpx3;
        dpy3 = ddpy3;
        dpz3 = ddpz3;
    }
 
    double dpx1;
    double dpy1;
    double dpz1;
 
    double dpx2;
    double dpy2;
    double dpz2;
 
    double dpx3;
    double dpy3;
    double dpz3;
};
 
 
 
struct DXFLIB_EXPORT DL_DimOrdinateData {
    DL_DimOrdinateData(double ddpx1, double ddpy1, double ddpz1,
                      double ddpx2, double ddpy2, double ddpz2,
                      bool dxtype) {
 
        dpx1 = ddpx1;
        dpy1 = ddpy1;
        dpz1 = ddpz1;
 
        dpx2 = ddpx2;
        dpy2 = ddpy2;
        dpz2 = ddpz2;
 
        xtype = dxtype;
    }
 
    double dpx1;
    double dpy1;
    double dpz1;
 
    double dpx2;
    double dpy2;
    double dpz2;
 
    bool xtype;
};
 
 
 
struct DXFLIB_EXPORT DL_LeaderData {
    DL_LeaderData(int arrowHeadFlag,
                  int leaderPathType,
                  int leaderCreationFlag,
                  int hooklineDirectionFlag,
                  int hooklineFlag,
                  double textAnnotationHeight,
                  double textAnnotationWidth,
                  int number,
                  double dimScale = 1.0) :
        arrowHeadFlag(arrowHeadFlag),
        leaderPathType(leaderPathType),
        leaderCreationFlag(leaderCreationFlag),
        hooklineDirectionFlag(hooklineDirectionFlag),
        hooklineFlag(hooklineFlag),
        textAnnotationHeight(textAnnotationHeight),
        textAnnotationWidth(textAnnotationWidth),
        number(number),
        dimScale(dimScale) {
 
    }
 
    int arrowHeadFlag;
    int leaderPathType;
    int leaderCreationFlag;
    int hooklineDirectionFlag;
    int hooklineFlag;
    double textAnnotationHeight;
    double textAnnotationWidth;
    int number;
    double dimScale;
};
 
 
 
struct DXFLIB_EXPORT DL_LeaderVertexData {
    DL_LeaderVertexData(double px=0.0, double py=0.0, double pz=0.0) {
        x = px;
        y = py;
        z = pz;
    }
 
    double x;
    double y;
    double z;
};
 
 
 
struct DXFLIB_EXPORT DL_HatchData {
    DL_HatchData() {}
 
    DL_HatchData(int numLoops,
                 bool solid,
                 double scale,
                 double angle,
                 const std::string& pattern,
                 double originX = 0.0,
                 double originY = 0.0) :
        numLoops(numLoops),
        solid(solid),
        scale(scale),
        angle(angle),
        pattern(pattern),
        originX(originX),
        originY(originY) {
 
    }
 
    int numLoops;
    bool solid;
    double scale;
    double angle;
    std::string pattern;
    double originX;
    double originY;
};
 
 
 
struct DXFLIB_EXPORT DL_HatchLoopData {
    DL_HatchLoopData() {}
    DL_HatchLoopData(int hNumEdges) {
        numEdges = hNumEdges;
    }
 
    int numEdges;
};
 
 
 
struct DXFLIB_EXPORT DL_HatchEdgeData {
    DL_HatchEdgeData() : defined(false), x1(0.0), y1(0.0), x2(0.0), y2(0.0) {
    }
 
    DL_HatchEdgeData(double x1, double y1,
                     double x2, double y2) :
        defined(true),
        type(1),
        x1(x1),
        y1(y1),
        x2(x2),
        y2(y2) {
    }
 
    DL_HatchEdgeData(double cx, double cy,
                     double radius,
                     double angle1, double angle2,
                     bool ccw) :
        defined(true),
        type(2),
        cx(cx),
        cy(cy),
        radius(radius),
        angle1(angle1),
        angle2(angle2),
        ccw(ccw) {
    }
 
    DL_HatchEdgeData(double cx, double cy,
                     double mx, double my,
                     double ratio,
                     double angle1, double angle2,
                     bool ccw) :
        defined(true),
        type(3),
        cx(cx),
        cy(cy),
        angle1(angle1),
        angle2(angle2),
        ccw(ccw),
        mx(mx),
        my(my),
        ratio(ratio) {
    }
 
    DL_HatchEdgeData(unsigned int degree,
                     bool rational,
                     bool periodic,
                     unsigned int nKnots,
                     unsigned int nControl,
                     unsigned int nFit,
                     const std::vector<double>& knots,
                     const std::vector<std::vector<double> >& controlPoints,
                     const std::vector<std::vector<double> >& fitPoints,
                     const std::vector<double>& weights,
                     double startTangentX,
                     double startTangentY,
                     double endTangentX,
                     double endTangentY) :
        defined(true),
        type(4),
        degree(degree),
        rational(rational),
        periodic(periodic),
        nKnots(nKnots),
        nControl(nControl),
        nFit(nFit),
        controlPoints(controlPoints),
        knots(knots),
        weights(weights),
        fitPoints(fitPoints),
        startTangentX(startTangentX),
        startTangentY(startTangentY),
        endTangentX(endTangentX),
        endTangentY(endTangentY) {
    }
 
    bool defined;
 
    int type;
 
    // line edges:
 
    double x1;
    double y1;
    double x2;
    double y2;
 
    double cx;
    double cy;
    double radius;
    double angle1;
    double angle2;
    bool ccw;
 
    double mx;
    double my;
    double ratio;
 
 
    unsigned int degree;
    bool rational;
    bool periodic;
    unsigned int nKnots;
    unsigned int nControl;
    unsigned int nFit;
 
    std::vector<std::vector<double> > controlPoints;
    std::vector<double> knots;
    std::vector<double> weights;
    std::vector<std::vector<double> > fitPoints;
 
    double startTangentX;
    double startTangentY;
 
    double endTangentX;
    double endTangentY;
 
    std::vector<std::vector<double> > vertices;
    //bool closed;
};
 
 
 
struct DXFLIB_EXPORT DL_ImageData {
    DL_ImageData(const std::string& iref,
                  double iipx, double iipy, double iipz,
                  double iux, double iuy, double iuz,
                  double ivx, double ivy, double ivz,
                  int iwidth, int iheight,
                  int ibrightness, int icontrast, int ifade) {
        ref = iref;
        ipx = iipx;
        ipy = iipy;
        ipz = iipz;
        ux = iux;
        uy = iuy;
        uz = iuz;
        vx = ivx;
        vy = ivy;
        vz = ivz;
        width = iwidth;
        height = iheight;
        brightness = ibrightness;
        contrast = icontrast;
        fade = ifade;
    }
 
    std::string ref;
    double ipx;
    double ipy;
    double ipz;
    double ux;
    double uy;
    double uz;
    double vx;
    double vy;
    double vz;
    int width;
    int height;
    int brightness;
    int contrast;
    int fade;
};
 
 
 
struct DXFLIB_EXPORT DL_ImageDefData {
    DL_ImageDefData(const std::string& iref,
                 const std::string& ifile) {
        ref = iref;
        file = ifile;
    }
 
    std::string ref;
 
    std::string file;
};
 
 
 
struct DXFLIB_EXPORT DL_DictionaryData {
    DL_DictionaryData(const std::string& handle) : handle(handle) {}
    std::string handle;
};
 
 
 
struct DXFLIB_EXPORT DL_DictionaryEntryData {
    DL_DictionaryEntryData(const std::string& name, const std::string& handle) :
        name(name), handle(handle) {}
 
    std::string name;
    std::string handle;
};
 
#endif
 
// EOF