← Back to branch summary

~librecad-dev/librecad/librecad

« back to all changes in this revision

Viewing changes to librecad/src/lib/filters/rs_filterjww.h

  • Committer: Scott Howard
  • Date: 2014-02-21 19:07:55 UTC
  • Revision ID: showard@debian.org-20140221190755-csjax9wb146hgdq4
first commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
librecad/src/lib/filters/rs_filterjww.h
 
1
/****************************************************************************
 
2
** $Id: rs_filterjww.h,v 1.1.1.2 2010/02/08 11:58:24 zeronemo2007 Exp $
 
3
**
 
4
** Copyright (C) 2001-2003 RibbonSoft. All rights reserved.
 
5
**
 
6
** This file is part of the qcadlib Library project.
 
7
**
 
8
** This file may be distributed and/or modified under the terms of the
 
9
** GNU General Public License version 2 as published by the Free Software
 
10
** Foundation and appearing in the file LICENSE.GPL included in the
 
11
** packaging of this file.
 
12
**
 
13
** Licensees holding valid qcadlib Professional Edition licenses may use 
 
14
** this file in accordance with the qcadlib Commercial License
 
15
** Agreement provided with the Software.
 
16
**
 
17
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 
18
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 
19
**
 
20
** See http://www.ribbonsoft.com for further details.
 
21
**
 
22
** Contact info@ribbonsoft.com if any conditions of this licensing are
 
23
** not clear to you.
 
24
**
 
25
**********************************************************************/
 
26
 
 
27
 
 
28
#ifndef RS_FILTERJWW_H
 
29
#define RS_FILTERJWW_H
 
30
 
 
31
#include "rs_filterinterface.h"
 
32
 
 
33
#include "rs_block.h"
 
34
#include "rs_color.h"
 
35
#include "rs_dimension.h"
 
36
#include "rs_hatch.h"
 
37
#include "rs_insert.h"
 
38
#include "rs_layer.h"
 
39
#include "rs_layer.h"
 
40
#include "rs_leader.h"
 
41
#include "rs_polyline.h"
 
42
#include "rs_spline.h"
 
43
#include "rs_solid.h"
 
44
#include "rs_mtext.h"
 
45
#include "rs_image.h"
 
46
 
 
47
#include "dl_creationinterface.h"
 
48
#include "dl_jww.h"
 
49
 
 
50
 
 
51
class DL_WriterA;
 
52
 
 
53
/**
 
54
 * This format filter class can import and export JWW files.
 
55
 * It depends on the jwwlib library.
 
56
 *
 
57
 * @author Andrew Mustun
 
58
 */
 
59
class RS_FilterJWW : public RS_FilterInterface, DL_CreationInterface {
 
60
public:
 
61
    RS_FilterJWW();
 
62
    ~RS_FilterJWW();
 
63
        
 
64
        /**
 
65
         * @return RS2::FormatJWW.
 
66
         */
 
67
        //RS2::FormatType rtti() {
 
68
        //      return RS2::FormatJWW;
 
69
        //}
 
70
 
 
71
        /*
 
72
    virtual bool canImport(RS2::FormatType t) {
 
73
                return (t==RS2::FormatJWW);
 
74
        }
 
75
        
 
76
    virtual bool canExport(RS2::FormatType t) {
 
77
                return (t==RS2::FormatJWW || t==RS2::FormatJWW12);
 
78
        }*/
 
79
 
 
80
    // Import:
 
81
    virtual bool fileImport(RS_Graphic& g, const QString& file, RS2::FormatType /*type*/);
 
82
 
 
83
    // Methods from DL_CreationInterface:
 
84
    virtual void addLayer(const DL_LayerData& data);
 
85
    virtual void addBlock(const DL_BlockData& data);
 
86
    virtual void endBlock();
 
87
    virtual void addPoint(const DL_PointData& data);
 
88
    virtual void addLine(const DL_LineData& data);
 
89
    virtual void addArc(const DL_ArcData& data);
 
90
    virtual void addEllipse(const DL_EllipseData& data);
 
91
    virtual void addCircle(const DL_CircleData& data);
 
92
    virtual void addPolyline(const DL_PolylineData& data);
 
93
    virtual void addVertex(const DL_VertexData& data);
 
94
    virtual void addSpline(const DL_SplineData& data);
 
95
    virtual void addKnot(const DL_KnotData&) {}
 
96
    virtual void addControlPoint(const DL_ControlPointData& data);
 
97
    virtual void addInsert(const DL_InsertData& data);
 
98
    virtual void addTrace(const DL_TraceData& ) {}
 
99
    virtual void addSolid(const DL_SolidData& ) {}
 
100
    virtual void addMTextChunk(const char* text);
 
101
    virtual void addMText(const DL_MTextData& data);
 
102
    virtual void addText(const DL_TextData& data);
 
103
    //virtual void addDimension(const DL_DimensionData& data);
 
104
    RS_DimensionData convDimensionData(const DL_DimensionData& data);
 
105
    virtual void addDimAlign(const DL_DimensionData& data,
 
106
                             const DL_DimAlignedData& edata);
 
107
    virtual void addDimLinear(const DL_DimensionData& data,
 
108
                              const DL_DimLinearData& edata);
 
109
    virtual void addDimRadial(const DL_DimensionData& data,
 
110
                              const DL_DimRadialData& edata);
 
111
    virtual void addDimDiametric(const DL_DimensionData& data,
 
112
                                 const DL_DimDiametricData& edata);
 
113
    virtual void addDimAngular(const DL_DimensionData& data,
 
114
                               const DL_DimAngularData& edata);
 
115
    virtual void addDimAngular3P(const DL_DimensionData& data,
 
116
                                 const DL_DimAngular3PData& edata);
 
117
    virtual void addLeader(const DL_LeaderData& data);
 
118
    virtual void addLeaderVertex(const DL_LeaderVertexData& data);
 
119
    virtual void addHatch(const DL_HatchData& data);
 
120
    virtual void addHatchLoop(const DL_HatchLoopData& data);
 
121
    virtual void addHatchEdge(const DL_HatchEdgeData& data);
 
122
    virtual void addImage(const DL_ImageData& data);
 
123
    virtual void linkImage(const DL_ImageDefData& data);
 
124
    virtual void endEntity();
 
125
    virtual void endSequence() {}
 
126
 
 
127
    virtual void add3dFace(const DL_3dFaceData& data);
 
128
    virtual void addDimOrdinate(const DL_DimensionData&, const DL_DimOrdinateData&);
 
129
    virtual void addComment(const char*);
 
130
 
 
131
    virtual void setVariableVector(const char* key,
 
132
                                   double v1, double v2, double v3, int code);
 
133
    virtual void setVariableString(const char* key, const char* value, int code);
 
134
    virtual void setVariableInt(const char* key, int value, int code);
 
135
    virtual void setVariableDouble(const char* key, double value, int code);
 
136
 
 
137
    // Export:
 
138
    virtual bool fileExport(RS_Graphic& g, const QString& file, RS2::FormatType type);
 
139
 
 
140
    void writeVariables(DL_WriterA& dw);
 
141
    void writeLayer(DL_WriterA& dw, RS_Layer* l);
 
142
    void writeLineType(DL_WriterA& dw, RS2::LineType t);
 
143
    void writeAppid(DL_WriterA& dw, const char* appid);
 
144
    void writeBlock(DL_WriterA& dw, RS_Block* blk);
 
145
    void writeEntity(DL_WriterA& dw, RS_Entity* e);
 
146
    void writeEntity(DL_WriterA& dw, RS_Entity* e, const DL_Attributes& attrib);
 
147
        void writePoint(DL_WriterA& dw, RS_Point* p, const DL_Attributes& attrib);
 
148
        void writeLine(DL_WriterA& dw, RS_Line* l, const DL_Attributes& attrib);
 
149
        void writePolyline(DL_WriterA& dw, 
 
150
                RS_Polyline* l, const DL_Attributes& attrib);
 
151
        void writeSpline(DL_WriterA& dw, 
 
152
                RS_Spline* s, const DL_Attributes& attrib);
 
153
        void writeCircle(DL_WriterA& dw, RS_Circle* c, const DL_Attributes& attrib);
 
154
        void writeArc(DL_WriterA& dw, RS_Arc* a, const DL_Attributes& attrib);
 
155
        void writeEllipse(DL_WriterA& dw, RS_Ellipse* s, const DL_Attributes& attrib);
 
156
        void writeInsert(DL_WriterA& dw, RS_Insert* i, const DL_Attributes& attrib);
 
157
    void writeText(DL_WriterA& dw, RS_MText* t, const DL_Attributes& attrib);
 
158
        void writeDimension(DL_WriterA& dw, RS_Dimension* d, 
 
159
                const DL_Attributes& attrib);
 
160
        void writeLeader(DL_WriterA& dw, RS_Leader* l, const DL_Attributes& attrib);
 
161
        void writeHatch(DL_WriterA& dw, RS_Hatch* h, const DL_Attributes& attrib);
 
162
        void writeSolid(DL_WriterA& dw, RS_Solid* s, const DL_Attributes& attrib);
 
163
        void writeImage(DL_WriterA& dw, RS_Image* i, const DL_Attributes& attrib);
 
164
        void writeEntityContainer(DL_WriterA& dw, RS_EntityContainer* con, 
 
165
                const DL_Attributes& attrib);
 
166
        void writeAtomicEntities(DL_WriterA& dw, RS_EntityContainer* c, 
 
167
                const DL_Attributes& attrib, RS2::ResolveLevel level);
 
168
        
 
169
    void writeImageDef(DL_WriterA& dw, RS_Image* i);
 
170
 
 
171
    void setEntityAttributes(RS_Entity* entity, const DL_Attributes& attrib);
 
172
    DL_Attributes getEntityAttributes(RS_Entity* entity);
 
173
 
 
174
    static QString toDxfString(const QString& string);
 
175
    QString toNativeString(const char* data, const QString& encoding);
 
176
    QString getDXFEncoding();
 
177
 
 
178
public:
 
179
    RS_Pen attributesToPen(const DL_Attributes& attrib) const;
 
180
 
 
181
    static RS_Color numberToColor(int num, bool comp=false);
 
182
    static int colorToNumber(const RS_Color& col);
 
183
 
 
184
    static RS2::LineType nameToLineType(const QString& name);
 
185
    static QString lineTypeToName(RS2::LineType lineType);
 
186
    //static QString lineTypeToDescription(RS2::LineType lineType);
 
187
 
 
188
    static RS2::LineWidth numberToWidth(int num);
 
189
    static int widthToNumber(RS2::LineWidth width);
 
190
 
 
191
        static RS2::AngleFormat numberToAngleFormat(int num);
 
192
        static int angleFormatToNumber(RS2::AngleFormat af);
 
193
 
 
194
        static RS2::Unit numberToUnit(int num);
 
195
        static int unitToNumber(RS2::Unit unit);
 
196
        
 
197
        static bool isVariableTwoDimensional(const QString& var);
 
198
 
 
199
    virtual bool canImport(const QString & /*fileName*/, RS2::FormatType t) const {
 
200
        return (t==RS2::FormatJWW);
 
201
    }
 
202
 
 
203
    virtual bool canExport(const QString& /*fileName*/, RS2::FormatType t) const {
 
204
        return (t==RS2::FormatJWW);
 
205
    }
 
206
 
 
207
    static RS_FilterInterface *createFilter() {return new RS_FilterJWW();}
 
208
private:
 
209
    /** Pointer to the graphic we currently operate on. */
 
210
    RS_Graphic* graphic;
 
211
        /** File name. Used to find out the full path of images. */
 
212
        QString file;
 
213
    /** string for concatinating text parts of MTEXT entities. */
 
214
    QString mtext;
 
215
    /** Pointer to current polyline entity we're adding vertices to. */
 
216
    RS_Polyline* polyline;
 
217
    /** Pointer to current spline entity we're adding control points to. */
 
218
    RS_Spline* spline;
 
219
    /** Pointer to current leader entity we're adding vertices to. */
 
220
    RS_Leader* leader;
 
221
    /** Pointer to current entity container (either block or graphic) */
 
222
    RS_EntityContainer* currentContainer;
 
223
 
 
224
    /** Pointer to current hatch or NULL. */
 
225
    RS_Hatch* hatch;
 
226
    /** Pointer to current hatch loop or NULL. */
 
227
    RS_EntityContainer* hatchLoop;
 
228
 
 
229
    DL_Jww jww;
 
230
    RS_VariableDict variables;
 
231
}
 
232
;
 
233
 
 
234
#endif