dl_entities.h

Go to the documentation of this file.

/****************************************************************************
** Copyright (C) 2001-2011 RibbonSoft. All rights reserved.
**
** This file is part of the dxflib project.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** 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_ENTITIES_H
#define DL_ENTITIES_H


#include <string>
using std::string;

struct DL_LayerData {
    DL_LayerData(const string& lName,
                 int lFlags) {
        name = lName;
        flags = lFlags;
    }

    string name;
    int flags;
};



struct DL_BlockData {
    DL_BlockData(const string& bName,
                 int bFlags,
                 double bbpx, double bbpy, double bbpz) {
        name = bName;
        flags = bFlags;
        bpx = bbpx;
        bpy = bbpy;
        bpz = bbpz;
    }

    string name;
    int flags;
    double bpx;
    double bpy;
    double bpz;
};



struct DL_LineTypeData {
    DL_LineTypeData(const string& lName,
                    int lFlags) {
        name = lName;
        flags = lFlags;
    }

    string name;
    int flags;
};



struct 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 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 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 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 DL_PolylineData {
    DL_PolylineData(int pNumber, int pMVerteces, int pNVerteces, int pFlags) {
        number = pNumber;
        m = pMVerteces;
        n = pNVerteces;
        flags = pFlags;
    }

    unsigned int number;

    unsigned int m;

    unsigned int n;

    int flags;
};



struct 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 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 DL_SplineData {
    DL_SplineData(int pDegree, int pNKnots, int pNControl, int pFlags) {
                degree = pDegree;
                nKnots = pNKnots;
                nControl = pNControl;
        flags = pFlags;
    }

    unsigned int degree;

    unsigned int nKnots;

    unsigned int nControl;

    int flags;
};



struct DL_KnotData {
    DL_KnotData() {}
    DL_KnotData(double pk) {
        k = pk;
    }

    double k;
};



struct 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 DL_EllipseData {
    DL_EllipseData(double ecx, double ecy, double ecz,
                   double emx, double emy, double emz,
                   double eRatio,
                   double eAngle1, double eAngle2) {

        cx = ecx;
        cy = ecy;
        cz = ecz;
        mx = emx;
        my = emy;
        mz = emz;
        ratio = eRatio;
        angle1 = eAngle1;
        angle2 = eAngle2;
    }

    double cx;
    double cy;
    double cz;

    double mx;
    double my;
    double mz;

    double ratio;
    double angle1;
    double angle2;
};



struct DL_InsertData {
    DL_InsertData(const string& iName,
                  double iipx, double iipy, double iipz,
                  double isx, double isy, double isz,
                  double iAngle,
                  int iCols, int iRows,
                  double iColSp, double iRowSp) {
        name = iName;
        ipx = iipx;
        ipy = iipy;
        ipz = iipz;
        sx = isx;
        sy = isy;
        sz = isz;
        angle = iAngle;
        cols = iCols;
        rows = iRows;
        colSp = iColSp;
        rowSp = iRowSp;
    }

    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 DL_MTextData {
    DL_MTextData(double tipx, double tipy, double tipz,
                 double tHeight, double tWidth,
                 int tAttachmentPoint,
                 int tDrawingDirection,
                 int tLineSpacingStyle,
                 double tLineSpacingFactor,
                 const string& tText,
                 const string& tStyle,
                 double tAngle) {
        ipx = tipx;
        ipy = tipy;
        ipz = tipz;

        height = tHeight;
        width = tWidth;
        attachmentPoint = tAttachmentPoint;
        drawingDirection = tDrawingDirection;
        lineSpacingStyle = tLineSpacingStyle;
        lineSpacingFactor = tLineSpacingFactor;
        text = tText;
        style = tStyle;
        angle = tAngle;
    }

    double ipx;
    double ipy;
    double ipz;
    double height;
    double width;
    int attachmentPoint;
    int drawingDirection;
    int lineSpacingStyle;
    double lineSpacingFactor;
    string text;
    string style;
    double angle;
};



struct DL_TextData {
    DL_TextData(double tipx, double tipy, double tipz,
                double tapx, double tapy, double tapz,
                double tHeight, double tXScaleFactor,
                int tTextGenerationFlags,
                int tHJustification,
                int tVJustification,
                const string& tText,
                const string& tStyle,
                double tAngle) {
        ipx = tipx;
        ipy = tipy;
        ipz = tipz;

        apx = tapx;
        apy = tapy;
        apz = tapz;

        height = tHeight;
        xScaleFactor = tXScaleFactor;
        textGenerationFlags = tTextGenerationFlags;
        hJustification = tHJustification;
        vJustification = tVJustification;
        text = tText;
        style = tStyle;
        angle = tAngle;
    }

    double ipx;
    double ipy;
    double ipz;

    double apx;
    double apy;
    double apz;

    double height;
    double xScaleFactor;
    int textGenerationFlags;
    int hJustification;
    int vJustification;
    string text;
    string style;
    double angle;
};



struct DL_DimensionData {
    DL_DimensionData(double ddpx, double ddpy, double ddpz,
                     double dmpx, double dmpy, double dmpz,
                     int dType,
                     int dAttachmentPoint,
                     int dLineSpacingStyle,
                     double dLineSpacingFactor,
                     const string& dText,
                     const string& dStyle,
                     double dAngle) {

        dpx = ddpx;
        dpy = ddpy;
        dpz = ddpz;

        mpx = dmpx;
        mpy = dmpy;
        mpz = dmpz;

        type = dType;

        attachmentPoint = dAttachmentPoint;
        lineSpacingStyle = dLineSpacingStyle;
        lineSpacingFactor = dLineSpacingFactor;
        text = dText;
        style = dStyle;
        angle = dAngle;
    }

    double dpx;
    double dpy;
    double dpz;
    double mpx;
    double mpy;
    double mpz;
    int type;
    int attachmentPoint;
    int lineSpacingStyle;
    double lineSpacingFactor;
    string text;
    string style;
    double angle;
};



struct 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 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 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 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 DL_DimAngularData {
    DL_DimAngularData(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 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 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 DL_LeaderData {
    DL_LeaderData(int lArrowHeadFlag,
                  int lLeaderPathType,
                  int lLeaderCreationFlag,
                  int lHooklineDirectionFlag,
                  int lHooklineFlag,
                  double lTextAnnotationHeight,
                  double lTextAnnotationWidth,
                  int lNumber) {

        arrowHeadFlag = lArrowHeadFlag;
        leaderPathType = lLeaderPathType;
        leaderCreationFlag = lLeaderCreationFlag;
        hooklineDirectionFlag = lHooklineDirectionFlag;
        hooklineFlag = lHooklineFlag;
        textAnnotationHeight = lTextAnnotationHeight;
        textAnnotationWidth = lTextAnnotationWidth;
        number = lNumber;
    }

    int arrowHeadFlag;
    int leaderPathType;
    int leaderCreationFlag;
    int hooklineDirectionFlag;
    int hooklineFlag;
    double textAnnotationHeight;
    double textAnnotationWidth;
    int number;
};



struct 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 DL_HatchData {
    DL_HatchData() {}

    DL_HatchData(int hNumLoops,
                 bool hSolid,
                 double hScale,
                 double hAngle,
                 const string& hPattern) {
        numLoops = hNumLoops;
        solid = hSolid;
        scale = hScale;
        angle = hAngle;
        pattern = hPattern;
    }

    int numLoops;
    bool solid;
    double scale;
    double angle;
    string pattern;
};



struct DL_HatchLoopData {
    DL_HatchLoopData() {}
    DL_HatchLoopData(int hNumEdges) {
        numEdges = hNumEdges;
    }

    int numEdges;
};



struct DL_HatchEdgeData {
    DL_HatchEdgeData() {
        defined = false;
    }

    DL_HatchEdgeData(double lx1, double ly1,
                     double lx2, double ly2) {
        x1 = lx1;
        y1 = ly1;
        x2 = lx2;
        y2 = ly2;
        type = 1;
        defined = true;
    }

    DL_HatchEdgeData(double acx, double acy,
                     double aRadius,
                     double aAngle1, double aAngle2,
                     bool aCcw) {
        cx = acx;
        cy = acy;
        radius = aRadius;
        angle1 = aAngle1;
        angle2 = aAngle2;
        ccw = aCcw;
        type = 2;
        defined = true;
    }

    int type;

    bool defined;

    double x1;
    double y1;
    double x2;
    double y2;
    double cx;
    double cy;
    double radius;
    double angle1;
    double angle2;
    bool ccw;
};



struct DL_ImageData {
    DL_ImageData(const 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;
    }

    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 DL_ImageDefData {
    DL_ImageDefData(const string& iref,
                                 const string& ifile) {
        ref = iref;
                file = ifile;
    }

    string ref;

        string file;
};

#endif

// EOF