1 /******************************************************************************
2 **  libDXFrw - Library to read/write DXF files (ascii & binary)              **
3 **                                                                           **
4 **  Copyright (C) 2011-2015 José F. Soriano, rallazz@gmail.com               **
5 **                                                                           **
6 **  This library is free software, licensed under the terms of the GNU       **
7 **  General Public License as published by the Free Software Foundation,     **
8 **  either version 2 of the License, or (at your option) any later version.  **
9 **  You should have received a copy of the GNU General Public License        **
10 **  along with this program.  If not, see <http://www.gnu.org/licenses/>.    **
11 ******************************************************************************/
12 
13 #include <cstdlib>
14 #include "drw_entities.h"
15 #include "intern/dxfreader.h"
16 #include "intern/drw_dbg.h"
17 #include "../vmisc/diagnostic.h"
18 
19 
20 //! Calculate arbitary axis
21 /*!
22 *   Calculate arbitary axis for apply extrusions
23 *  @author Rallaz
24 */
calculateAxis(DRW_Coord extPoint)25 void DRW_Entity::calculateAxis(DRW_Coord extPoint){
26     //Follow the arbitrary DXF definitions for extrusion axes.
27     if (fabs(extPoint.x) < 0.015625 && fabs(extPoint.y) < 0.015625) {
28         //If we get here, implement Ax = Wy x N where Wy is [0,1,0] per the DXF spec.
29         //The cross product works out to Wy.y*N.z-Wy.z*N.y, Wy.z*N.x-Wy.x*N.z, Wy.x*N.y-Wy.y*N.x
30         //Factoring in the fixed values for Wy gives N.z,0,-N.x
31         extAxisX.x = extPoint.z;
32         extAxisX.y = 0;
33         extAxisX.z = -extPoint.x;
34     } else {
35         //Otherwise, implement Ax = Wz x N where Wz is [0,0,1] per the DXF spec.
36         //The cross product works out to Wz.y*N.z-Wz.z*N.y, Wz.z*N.x-Wz.x*N.z, Wz.x*N.y-Wz.y*N.x
37         //Factoring in the fixed values for Wz gives -N.y,N.x,0.
38         extAxisX.x = -extPoint.y;
39         extAxisX.y = extPoint.x;
40         extAxisX.z = 0;
41     }
42 
43     extAxisX.unitize();
44 
45     //Ay = N x Ax
46     extAxisY.x = (extPoint.y * extAxisX.z) - (extAxisX.y * extPoint.z);
47     extAxisY.y = (extPoint.z * extAxisX.x) - (extAxisX.z * extPoint.x);
48     extAxisY.z = (extPoint.x * extAxisX.y) - (extAxisX.x * extPoint.y);
49 
50     extAxisY.unitize();
51 }
52 
53 //! Extrude a point using arbitary axis
54 /*!
55 *   apply extrusion in a point using arbitary axis (previous calculated)
56 *  @author Rallaz
57 */
extrudePoint(DRW_Coord extPoint,DRW_Coord * point) const58 void DRW_Entity::extrudePoint(DRW_Coord extPoint, DRW_Coord *point) const{
59     double px, py, pz;
60     px = (extAxisX.x*point->x)+(extAxisY.x*point->y)+(extPoint.x*point->z);
61     py = (extAxisX.y*point->x)+(extAxisY.y*point->y)+(extPoint.y*point->z);
62     pz = (extAxisX.z*point->x)+(extAxisY.z*point->y)+(extPoint.z*point->z);
63 
64     point->x = px;
65     point->y = py;
66     point->z = pz;
67 }
68 
parseCode(int code,dxfReader * reader)69 bool DRW_Entity::parseCode(int code, dxfReader *reader){
70     switch (code) {
71     case 5:
72         handle = static_cast<quint32>(reader->getHandleString());
73         break;
74     case 330:
75         parentHandle = static_cast<quint32>(reader->getHandleString());
76         break;
77     case 8:
78         layer = reader->getUtf8String();
79         break;
80     case 6:
81         lineType = reader->getUtf8String();
82         break;
83     case 62:
84         color = reader->getInt32();
85         break;
86     case 370:
87         lWeight = DRW_LW_Conv::dxfInt2lineWidth(reader->getInt32());
88         break;
89     case 48:
90         ltypeScale = reader->getDouble();
91         break;
92     case 60:
93         visible = reader->getBool();
94         break;
95     case 420:
96         color24 = reader->getInt32();
97         break;
98     case 430:
99         colorName = reader->getString();
100         break;
101     case 67:
102         space = static_cast<DRW::Space>(reader->getInt32());
103         break;
104     case 102:
105         parseDxfGroups(code, reader);
106         break;
107     case 1000:
108     case 1001:
109     case 1002:
110     case 1003:
111     case 1004:
112     case 1005:
113         extData.push_back(new DRW_Variant(code, reader->getString()));
114         break;
115     case 1010:
116     case 1011:
117     case 1012:
118     case 1013:
119         curr = new DRW_Variant();
120         curr->addCoord();
121         curr->setCoordX(reader->getDouble());
122         curr->code = code;
123         extData.push_back(curr);
124         break;
125     case 1020:
126     case 1021:
127     case 1022:
128     case 1023:
129         if (curr)
130             curr->setCoordY(reader->getDouble());
131         break;
132     case 1030:
133     case 1031:
134     case 1032:
135     case 1033:
136         if (curr)
137             curr->setCoordZ(reader->getDouble());
138         curr=nullptr;
139         break;
140     case 1040:
141     case 1041:
142     case 1042:
143         extData.push_back(new DRW_Variant(code, reader->getDouble() ));
144         break;
145     case 1070:
146     case 1071:
147         extData.push_back(new DRW_Variant(code, reader->getInt32() ));
148         break;
149     default:
150         break;
151     }
152     return true;
153 }
154 
155 //parses dxf 102 groups to read entity
parseDxfGroups(int code,dxfReader * reader)156 bool DRW_Entity::parseDxfGroups(int code, dxfReader *reader){
157     std::list<DRW_Variant> ls;
158     DRW_Variant curr;
159     int nc;
160     std::string appName= reader->getString();
161     if (!appName.empty() && appName.at(0)== '{'){
162         curr.addString(appName.substr(1, static_cast<size_t>(appName.size()-1)));
163         curr.code = code;
164         ls.push_back(curr);
165         while (code !=102 && appName.at(0)== '}'){
166             reader->readRec(&nc);
167             curr.code = code;
168             if (code == 330 || code == 360)
169                 curr.addInt(reader->getHandleString());
170             else {
171                 switch (reader->type) {
172                 case dxfReader::STRING:
173                     curr.addString(reader->getString());
174                     break;
175                 case dxfReader::INT32:
176                 case dxfReader::INT64:
177                     curr.addInt(reader->getInt32());
178                     break;
179                 case dxfReader::DOUBLE:
180                     curr.addDouble(reader->getDouble());
181                     break;
182                 case dxfReader::BOOL:
183                     curr.addInt(reader->getInt32());
184                     break;
185                 default:
186                     break;
187                 }
188             }
189             ls.push_back(curr);
190         }
191     }
192 
193     appData.push_back(ls);
194     return true;
195 }
196 
parseCode(int code,dxfReader * reader)197 void DRW_Point::parseCode(int code, dxfReader *reader){
198     switch (code) {
199     case 10:
200         basePoint.x = reader->getDouble();
201         break;
202     case 20:
203         basePoint.y = reader->getDouble();
204         break;
205     case 30:
206         basePoint.z = reader->getDouble();
207         break;
208     case 39:
209         thickness = reader->getDouble();
210         break;
211     case 210:
212         haveExtrusion = true;
213         extPoint.x = reader->getDouble();
214         break;
215     case 220:
216         extPoint.y = reader->getDouble();
217         break;
218     case 230:
219         extPoint.z = reader->getDouble();
220         break;
221     default:
222         DRW_Entity::parseCode(code, reader);
223         break;
224     }
225 }
226 
parseCode(int code,dxfReader * reader)227 void DRW_ASTMNotch::parseCode(int code, dxfReader *reader)
228 {
229     switch (code) {
230     case 50:
231         angle = reader->getDouble();
232         break;
233     default:
234         DRW_Point::parseCode(code, reader);
235         break;
236     }
237 }
238 
parseCode(int code,dxfReader * reader)239 void DRW_Line::parseCode(int code, dxfReader *reader){
240     switch (code) {
241     case 11:
242         secPoint.x = reader->getDouble();
243         break;
244     case 21:
245         secPoint.y = reader->getDouble();
246         break;
247     case 31:
248         secPoint.z = reader->getDouble();
249         break;
250     default:
251         DRW_Point::parseCode(code, reader);
252         break;
253     }
254 }
255 
applyExtrusion()256 void DRW_Circle::applyExtrusion(){
257     if (haveExtrusion) {
258         //NOTE: Commenting these out causes the the arcs being tested to be located
259         //on the other side of the y axis (all x dimensions are negated).
260         calculateAxis(extPoint);
261         extrudePoint(extPoint, &basePoint);
262     }
263 }
264 
parseCode(int code,dxfReader * reader)265 void DRW_Circle::parseCode(int code, dxfReader *reader){
266     switch (code) {
267     case 40:
268         radious = reader->getDouble();
269         break;
270     default:
271         DRW_Point::parseCode(code, reader);
272         break;
273     }
274 }
275 
applyExtrusion()276 void DRW_Arc::applyExtrusion(){
277     DRW_Circle::applyExtrusion();
278 
279     if(haveExtrusion){
280         // If the extrusion vector has a z value less than 0, the angles for the arc
281         // have to be mirrored since DXF files use the right hand rule.
282         // Note that the following code only handles the special case where there is a 2D
283         // drawing with the z axis heading into the paper (or rather screen). An arbitrary
284         // extrusion axis (with x and y values greater than 1/64) may still have issues.
285         if (fabs(extPoint.x) < 0.015625 && fabs(extPoint.y) < 0.015625 && extPoint.z < 0.0) {
286             staangle=M_PI-staangle;
287             endangle=M_PI-endangle;
288 
289             double temp = staangle;
290             staangle=endangle;
291             endangle=temp;
292         }
293     }
294 }
295 
parseCode(int code,dxfReader * reader)296 void DRW_Arc::parseCode(int code, dxfReader *reader){
297     switch (code) {
298     case 50:
299         staangle = reader->getDouble()/ ARAD;
300         break;
301     case 51:
302         endangle = reader->getDouble()/ ARAD;
303         break;
304     default:
305         DRW_Circle::parseCode(code, reader);
306         break;
307     }
308 }
309 
parseCode(int code,dxfReader * reader)310 void DRW_Ellipse::parseCode(int code, dxfReader *reader){
311     switch (code) {
312     case 40:
313         ratio = reader->getDouble();
314         break;
315     case 41:
316         staparam = reader->getDouble();
317         break;
318     case 42:
319         endparam = reader->getDouble();
320         break;
321     default:
322         DRW_Line::parseCode(code, reader);
323         break;
324     }
325 }
326 
applyExtrusion()327 void DRW_Ellipse::applyExtrusion(){
328     if (haveExtrusion) {
329         calculateAxis(extPoint);
330         extrudePoint(extPoint, &secPoint);
331         double intialparam = staparam;
332         if (extPoint.z < 0.){
333             staparam = M_PIx2 - endparam;
334             endparam = M_PIx2 - intialparam;
335         }
336     }
337 }
338 
339 //if ratio > 1 minor axis are greather than major axis, correct it
correctAxis()340 void DRW_Ellipse::correctAxis(){
341     bool complete = false;
342     if (DRW_FuzzyComparePossibleNulls(staparam, endparam)) {
343         staparam = 0.0;
344         endparam = M_PIx2; //2*M_PI;
345         complete = true;
346     }
347     if (ratio > 1){
348         if ( fabs(endparam - staparam - M_PIx2) < 1.0e-10)
349             complete = true;
350         double incX = secPoint.x;
351         secPoint.x = -(secPoint.y * ratio);
352         secPoint.y = incX*ratio;
353         ratio = 1/ratio;
354         if (!complete){
355             if (staparam < M_PI_2)
356                 staparam += M_PI *2;
357             if (endparam < M_PI_2)
358                 endparam += M_PI *2;
359             endparam -= M_PI_2;
360             staparam -= M_PI_2;
361         }
362     }
363 }
364 
365 //parts are the number of vertex to split polyline, default 128
toPolyline(DRW_Polyline * pol,int parts)366 void DRW_Ellipse::toPolyline(DRW_Polyline *pol, int parts){
367     double radMajor, radMinor, cosRot, sinRot, incAngle, curAngle;
368     radMajor = sqrt(secPoint.x*secPoint.x + secPoint.y*secPoint.y);
369     radMinor = radMajor*ratio;
370     //calculate sin & cos of included angle
371     incAngle = atan2(secPoint.y, secPoint.x);
372     cosRot = cos(incAngle);
373     sinRot = sin(incAngle);
374     incAngle = M_PIx2 / parts;
375     curAngle = staparam;
376     int i = static_cast<int>(curAngle / incAngle);
377     do {
378         if (curAngle > endparam) {
379             curAngle = endparam;
380             i = parts+2;
381         }
382         double cosCurr = cos(curAngle);
383         double sinCurr = sin(curAngle);
384         double x = basePoint.x + (cosCurr*cosRot*radMajor) - (sinCurr*sinRot*radMinor);
385         double y = basePoint.y + (cosCurr*sinRot*radMajor) + (sinCurr*cosRot*radMinor);
386         pol->addVertex( DRW_Vertex(x, y, 0.0, 0.0));
387         curAngle = (++i)*incAngle;
388     } while (i<parts);
389     if ( fabs(endparam - staparam - M_PIx2) < 1.0e-10){
390         pol->flags = 1;
391     }
392     pol->layer = this->layer;
393     pol->lineType = this->lineType;
394     pol->color = this->color;
395     pol->lWeight = this->lWeight;
396     pol->extPoint = this->extPoint;
397 }
398 
applyExtrusion()399 void DRW_Trace::applyExtrusion(){
400     if (haveExtrusion) {
401         calculateAxis(extPoint);
402         extrudePoint(extPoint, &basePoint);
403         extrudePoint(extPoint, &secPoint);
404         extrudePoint(extPoint, &thirdPoint);
405         extrudePoint(extPoint, &fourPoint);
406     }
407 }
408 
parseCode(int code,dxfReader * reader)409 void DRW_Trace::parseCode(int code, dxfReader *reader){
410     switch (code) {
411     case 12:
412         thirdPoint.x = reader->getDouble();
413         break;
414     case 22:
415         thirdPoint.y = reader->getDouble();
416         break;
417     case 32:
418         thirdPoint.z = reader->getDouble();
419         break;
420     case 13:
421         fourPoint.x = reader->getDouble();
422         break;
423     case 23:
424         fourPoint.y = reader->getDouble();
425         break;
426     case 33:
427         fourPoint.z = reader->getDouble();
428         break;
429     default:
430         DRW_Line::parseCode(code, reader);
431         break;
432     }
433 }
434 
parseCode(int code,dxfReader * reader)435 void DRW_Solid::parseCode(int code, dxfReader *reader){
436     DRW_Trace::parseCode(code, reader);
437 }
438 
parseCode(int code,dxfReader * reader)439 void DRW_3Dface::parseCode(int code, dxfReader *reader){
440     switch (code) {
441     case 70:
442         invisibleflag = reader->getInt32();
443         break;
444     default:
445         DRW_Trace::parseCode(code, reader);
446         break;
447     }
448 }
449 
parseCode(int code,dxfReader * reader)450 void DRW_Block::parseCode(int code, dxfReader *reader){
451     switch (code) {
452     case 2:
453         name = reader->getUtf8String();
454         break;
455     case 70:
456         flags = reader->getInt32();
457         break;
458     default:
459         DRW_Point::parseCode(code, reader);
460         break;
461     }
462 }
463 
parseCode(int code,dxfReader * reader)464 void DRW_Insert::parseCode(int code, dxfReader *reader){
465     switch (code) {
466     case 2:
467         name = reader->getUtf8String();
468         break;
469     case 41:
470         xscale = reader->getDouble();
471         break;
472     case 42:
473         yscale = reader->getDouble();
474         break;
475     case 43:
476         zscale = reader->getDouble();
477         break;
478     case 50:
479         angle = reader->getDouble();
480         angle = angle/ARAD; //convert to radian
481         break;
482     case 70:
483         colcount = reader->getInt32();
484         break;
485     case 71:
486         rowcount = reader->getInt32();
487         break;
488     case 44:
489         colspace = reader->getDouble();
490         break;
491     case 45:
492         rowspace = reader->getDouble();
493         break;
494     default:
495         DRW_Point::parseCode(code, reader);
496         break;
497     }
498 }
499 
applyExtrusion()500 void DRW_LWPolyline::applyExtrusion(){
501     if (haveExtrusion) {
502         calculateAxis(extPoint);
503         for (unsigned int i=0; i<vertlist.size(); i++) {
504             DRW_Vertex2D *vert = vertlist.at(i);
505             DRW_Coord v(vert->x, vert->y, elevation);
506             extrudePoint(extPoint, &v);
507             vert->x = v.x;
508             vert->y = v.y;
509         }
510     }
511 }
512 
parseCode(int code,dxfReader * reader)513 void DRW_LWPolyline::parseCode(int code, dxfReader *reader){
514     switch (code) {
515     case 10: {
516         vertex = new DRW_Vertex2D();
517         vertlist.push_back(vertex);
518         vertex->x = reader->getDouble();
519         break; }
520     case 20:
521         if(vertex != NULL)
522             vertex->y = reader->getDouble();
523         break;
524     case 40:
525         if(vertex != NULL)
526             vertex->stawidth = reader->getDouble();
527         break;
528     case 41:
529         if(vertex != NULL)
530             vertex->endwidth = reader->getDouble();
531         break;
532     case 42:
533         if(vertex != NULL)
534             vertex->bulge = reader->getDouble();
535         break;
536     case 38:
537         elevation = reader->getDouble();
538         break;
539     case 39:
540         thickness = reader->getDouble();
541         break;
542     case 43:
543         width = reader->getDouble();
544         break;
545     case 70:
546         flags = reader->getInt32();
547         break;
548     case 90:
549         vertexnum = reader->getInt32();
550         vertlist.reserve(static_cast<size_t>(vertexnum));
551         break;
552     case 210:
553         haveExtrusion = true;
554         extPoint.x = reader->getDouble();
555         break;
556     case 220:
557         extPoint.y = reader->getDouble();
558         break;
559     case 230:
560         extPoint.z = reader->getDouble();
561         break;
562     default:
563         DRW_Entity::parseCode(code, reader);
564         break;
565     }
566 }
567 
parseCode(int code,dxfReader * reader)568 void DRW_Text::parseCode(int code, dxfReader *reader){
569     switch (code) {
570     case 40:
571         height = reader->getDouble();
572         break;
573     case 41:
574         widthscale = reader->getDouble();
575         break;
576     case 50:
577         angle = reader->getDouble();
578         break;
579     case 51:
580         oblique = reader->getDouble();
581         break;
582     case 71:
583         textgen = reader->getInt32();
584         break;
585     case 72:
586         alignH = static_cast<HAlign>(reader->getInt32());
587         break;
588     case 73:
589         alignV = static_cast<VAlign>(reader->getInt32());
590         break;
591     case 1:
592         text = reader->getUtf8String();
593         break;
594     case 7:
595         style = reader->getUtf8String();
596         break;
597     default:
598         DRW_Line::parseCode(code, reader);
599         break;
600     }
601 }
602 
parseCode(int code,dxfReader * reader)603 void DRW_MText::parseCode(int code, dxfReader *reader){
604     switch (code) {
605     case 1:
606         text += reader->getString();
607         text = reader->toUtf8String(text);
608         break;
609     case 11:
610         haveXAxis = true;
611         DRW_Text::parseCode(code, reader);
612         break;
613     case 3:
614         text += reader->getString();
615         break;
616     case 44:
617         interlin = reader->getDouble();
618         break;
619     case 71: {
620         // Attachment point
621         Attach a = static_cast<Attach>(reader->getInt32());
622 
623         QT_WARNING_PUSH
624         QT_WARNING_DISABLE_GCC("-Wswitch-default")
625 
626         switch(a) {
627             case TopLeft:
628                 alignV = VTop;
629                 alignH = HLeft;
630                 break;
631             case TopCenter:
632                 alignV = VTop;
633                 alignH = HCenter;
634                 break;
635             case TopRight:
636                 alignV = VTop;
637                 alignH = HRight;
638                 break;
639             case MiddleLeft:
640                 alignV = VMiddle;
641                 alignH = HLeft;
642                 break;
643             case MiddleCenter:
644                 alignV = VMiddle;
645                 alignH = HCenter;
646                 break;
647             case MiddleRight:
648                 alignV = VMiddle;
649                 alignH = HRight;
650                 break;
651             case BottomLeft:
652                 alignV = VBottom;
653                 alignH = HLeft;
654                 break;
655             case BottomCenter:
656                 alignV = VBottom;
657                 alignH = HCenter;
658                 break;
659             case BottomRight:
660                 alignV = VBottom;
661                 alignH = HRight;
662                 break;
663         }
664 
665         QT_WARNING_POP
666     } break;
667     case 72:
668         // To prevent redirection to DRW_Text::parseCode.
669         // This code meaning is different for MTEXT.
670         // Actually: Drawing direction
671         break;
672     case 73:
673         // To prevent redirection to DRW_Text::parseCode.
674         // This code meaning is different for MTEXT.
675         // Actually: Mtext line spacing style
676         break;
677     default:
678         DRW_Text::parseCode(code, reader);
679         break;
680     }
681 }
682 
updateAngle()683 void DRW_MText::updateAngle(){
684     if (haveXAxis) {
685             angle = atan2(secPoint.y, secPoint.x)*180/M_PI;
686     }
687 }
688 
parseCode(int code,dxfReader * reader)689 void DRW_Polyline::parseCode(int code, dxfReader *reader){
690     switch (code) {
691     case 70:
692         flags = reader->getInt32();
693         break;
694     case 40:
695         defstawidth = reader->getDouble();
696         break;
697     case 41:
698         defendwidth = reader->getDouble();
699         break;
700     case 71:
701         vertexcount = reader->getInt32();
702         break;
703     case 72:
704         facecount = reader->getInt32();
705         break;
706     case 73:
707         smoothM = reader->getInt32();
708         break;
709     case 74:
710         smoothN = reader->getInt32();
711         break;
712     case 75:
713         curvetype = reader->getInt32();
714         break;
715     default:
716         DRW_Point::parseCode(code, reader);
717         break;
718     }
719 }
720 
parseCode(int code,dxfReader * reader)721 void DRW_Vertex::parseCode(int code, dxfReader *reader){
722     switch (code) {
723     case 70:
724         flags = reader->getInt32();
725         break;
726     case 40:
727         stawidth = reader->getDouble();
728         break;
729     case 41:
730         endwidth = reader->getDouble();
731         break;
732     case 42:
733         bulge = reader->getDouble();
734         break;
735     case 50:
736         tgdir = reader->getDouble();
737         break;
738     case 71:
739         vindex1 = reader->getInt32();
740         break;
741     case 72:
742         vindex2 = reader->getInt32();
743         break;
744     case 73:
745         vindex3 = reader->getInt32();
746         break;
747     case 74:
748         vindex4 = reader->getInt32();
749         break;
750     case 91:
751         identifier = reader->getInt32();
752         break;
753     default:
754         DRW_Point::parseCode(code, reader);
755         break;
756     }
757 }
758 
parseCode(int code,dxfReader * reader)759 void DRW_Hatch::parseCode(int code, dxfReader *reader){
760     switch (code) {
761     case 2:
762         name = reader->getUtf8String();
763         break;
764     case 70:
765         solid = reader->getInt32();
766         break;
767     case 71:
768         associative = reader->getInt32();
769         break;
770     case 72:        /*edge type*/
771         if (ispol){ //if is polyline is a as_bulge flag
772             break;
773         } else if (reader->getInt32() == 1){ //line
774             addLine();
775         } else if (reader->getInt32() == 2){ //arc
776             addArc();
777         } else if (reader->getInt32() == 3){ //elliptic arc
778             addEllipse();
779         } else if (reader->getInt32() == 4){ //spline
780             addSpline();
781         }
782         break;
783     case 10:
784         if (pt) pt->basePoint.x = reader->getDouble();
785         else if (pline) {
786             plvert = pline->addVertex();
787             plvert->x = reader->getDouble();
788         }
789         break;
790     case 20:
791         if (pt) pt->basePoint.y = reader->getDouble();
792         else if (plvert) plvert ->y = reader->getDouble();
793         break;
794     case 11:
795         if (line) line->secPoint.x = reader->getDouble();
796         else if (ellipse) ellipse->secPoint.x = reader->getDouble();
797         break;
798     case 21:
799         if (line) line->secPoint.y = reader->getDouble();
800         else if (ellipse) ellipse->secPoint.y = reader->getDouble();
801         break;
802     case 40:
803         if (arc) arc->radious = reader->getDouble();
804         else if (ellipse) ellipse->ratio = reader->getDouble();
805         break;
806     case 41:
807         scale = reader->getDouble();
808         break;
809     case 42:
810         if (plvert) plvert ->bulge = reader->getDouble();
811         break;
812     case 50:
813         if (arc) arc->staangle = reader->getDouble()/ARAD;
814         else if (ellipse) ellipse->staparam = reader->getDouble()/ARAD;
815         break;
816     case 51:
817         if (arc) arc->endangle = reader->getDouble()/ARAD;
818         else if (ellipse) ellipse->endparam = reader->getDouble()/ARAD;
819         break;
820     case 52:
821         angle = reader->getDouble();
822         break;
823     case 73:
824         if (arc) arc->isccw = reader->getInt32();
825         else if (pline) pline->flags = reader->getInt32();
826         break;
827     case 75:
828         hstyle = reader->getInt32();
829         break;
830     case 76:
831         hpattern = reader->getInt32();
832         break;
833     case 77:
834         doubleflag = reader->getInt32();
835         break;
836     case 78:
837         deflines = reader->getInt32();
838         break;
839     case 91:
840         loopsnum = reader->getInt32();
841         looplist.reserve(static_cast<size_t>(loopsnum));
842         break;
843     case 92:
844         loop = new DRW_HatchLoop(reader->getInt32());
845         looplist.push_back(loop);
846         if (reader->getInt32() & 2) {
847             ispol = true;
848             clearEntities();
849             pline = new DRW_LWPolyline;
850             loop->objlist.push_back(pline);
851         } else ispol = false;
852         break;
853     case 93:
854         if (pline) pline->vertexnum = reader->getInt32();
855         else loop->numedges = reader->getInt32();//aqui reserve
856         break;
857     case 98: //seed points ??
858         clearEntities();
859         break;
860     default:
861         DRW_Point::parseCode(code, reader);
862         break;
863     }
864 }
865 
parseCode(int code,dxfReader * reader)866 void DRW_Spline::parseCode(int code, dxfReader *reader){
867     switch (code) {
868     case 210:
869         normalVec.x = reader->getDouble();
870         break;
871     case 220:
872         normalVec.y = reader->getDouble();
873         break;
874     case 230:
875         normalVec.z = reader->getDouble();
876         break;
877     case 12:
878         tgStart.x = reader->getDouble();
879         break;
880     case 22:
881         tgStart.y = reader->getDouble();
882         break;
883     case 32:
884         tgStart.z = reader->getDouble();
885         break;
886     case 13:
887         tgEnd.x = reader->getDouble();
888         break;
889     case 23:
890         tgEnd.y = reader->getDouble();
891         break;
892     case 33:
893         tgEnd.z = reader->getDouble();
894         break;
895     case 70:
896         flags = reader->getInt32();
897         break;
898     case 71:
899         degree = reader->getInt32();
900         break;
901     case 72:
902         nknots = reader->getInt32();
903         break;
904     case 73:
905         ncontrol = reader->getInt32();
906         break;
907     case 74:
908         nfit = reader->getInt32();
909         break;
910     case 42:
911         tolknot = reader->getDouble();
912         break;
913     case 43:
914         tolcontrol = reader->getDouble();
915         break;
916     case 44:
917         tolfit = reader->getDouble();
918         break;
919     case 10: {
920         controlpoint = new DRW_Coord();
921         controllist.push_back(controlpoint);
922         controlpoint->x = reader->getDouble();
923         break; }
924     case 20:
925         if(controlpoint != NULL)
926             controlpoint->y = reader->getDouble();
927         break;
928     case 30:
929         if(controlpoint != NULL)
930             controlpoint->z = reader->getDouble();
931         break;
932     case 11: {
933         fitpoint = new DRW_Coord();
934         fitlist.push_back(fitpoint);
935         fitpoint->x = reader->getDouble();
936         break; }
937     case 21:
938         if(fitpoint != NULL)
939             fitpoint->y = reader->getDouble();
940         break;
941     case 31:
942         if(fitpoint != NULL)
943             fitpoint->z = reader->getDouble();
944         break;
945     case 40:
946         knotslist.push_back(reader->getDouble());
947         break;
948     case 41:
949         weightlist.push_back(reader->getDouble());
950         break;
951     default:
952         DRW_Entity::parseCode(code, reader);
953         break;
954     }
955 }
956 
parseCode(int code,dxfReader * reader)957 void DRW_Image::parseCode(int code, dxfReader *reader){
958     switch (code) {
959     case 12:
960         vVector.x = reader->getDouble();
961         break;
962     case 22:
963         vVector.y = reader->getDouble();
964         break;
965     case 32:
966         vVector.z = reader->getDouble();
967         break;
968     case 13:
969         sizeu = reader->getDouble();
970         break;
971     case 23:
972         sizev = reader->getDouble();
973         break;
974     case 340:
975         ref = static_cast<duint32>(reader->getHandleString());
976         break;
977     case 280:
978         clip = reader->getInt32();
979         break;
980     case 281:
981         brightness = reader->getInt32();
982         break;
983     case 282:
984         contrast = reader->getInt32();
985         break;
986     case 283:
987         fade = reader->getInt32();
988         break;
989     default:
990         DRW_Line::parseCode(code, reader);
991         break;
992     }
993 }
994 
parseCode(int code,dxfReader * reader)995 void DRW_Dimension::parseCode(int code, dxfReader *reader){
996     switch (code) {
997     case 1:
998         text = reader->getUtf8String();
999         break;
1000     case 2:
1001         name = reader->getString();
1002         break;
1003     case 3:
1004         style = reader->getUtf8String();
1005         break;
1006     case 70:
1007         type = reader->getInt32();
1008         break;
1009     case 71:
1010         align = reader->getInt32();
1011         break;
1012     case 72:
1013         linesty = reader->getInt32();
1014         break;
1015     case 10:
1016         defPoint.x = reader->getDouble();
1017         break;
1018     case 20:
1019         defPoint.y = reader->getDouble();
1020         break;
1021     case 30:
1022         defPoint.z = reader->getDouble();
1023         break;
1024     case 11:
1025         textPoint.x = reader->getDouble();
1026         break;
1027     case 21:
1028         textPoint.y = reader->getDouble();
1029         break;
1030     case 31:
1031         textPoint.z = reader->getDouble();
1032         break;
1033     case 12:
1034         clonePoint.x = reader->getDouble();
1035         break;
1036     case 22:
1037         clonePoint.y = reader->getDouble();
1038         break;
1039     case 32:
1040         clonePoint.z = reader->getDouble();
1041         break;
1042     case 13:
1043         def1.x = reader->getDouble();
1044         break;
1045     case 23:
1046         def1.y = reader->getDouble();
1047         break;
1048     case 33:
1049         def1.z = reader->getDouble();
1050         break;
1051     case 14:
1052         def2.x = reader->getDouble();
1053         break;
1054     case 24:
1055         def2.y = reader->getDouble();
1056         break;
1057     case 34:
1058         def2.z = reader->getDouble();
1059         break;
1060     case 15:
1061         circlePoint.x = reader->getDouble();
1062         break;
1063     case 25:
1064         circlePoint.y = reader->getDouble();
1065         break;
1066     case 35:
1067         circlePoint.z = reader->getDouble();
1068         break;
1069     case 16:
1070         arcPoint.x = reader->getDouble();
1071         break;
1072     case 26:
1073         arcPoint.y = reader->getDouble();
1074         break;
1075     case 36:
1076         arcPoint.z = reader->getDouble();
1077         break;
1078     case 41:
1079         linefactor = reader->getDouble();
1080         break;
1081     case 42:
1082         actual = reader->getDouble();
1083         hasActual = not qFuzzyIsNull(actual);
1084         break;
1085     case 53:
1086         rot = reader->getDouble();
1087         break;
1088     case 50:
1089         angle = reader->getDouble();
1090         break;
1091     case 52:
1092         oblique = reader->getDouble();
1093         break;
1094     case 40:
1095         length = reader->getDouble();
1096         break;
1097     case 51:
1098         hdir = reader->getDouble();
1099         break;
1100     default:
1101         DRW_Entity::parseCode(code, reader);
1102         break;
1103     }
1104 }
1105 
parseCode(int code,dxfReader * reader)1106 void DRW_Leader::parseCode(int code, dxfReader *reader){
1107     switch (code) {
1108     case 3:
1109         style = reader->getUtf8String();
1110         break;
1111     case 71:
1112         arrow = reader->getInt32();
1113         break;
1114     case 72:
1115         leadertype = reader->getInt32();
1116         break;
1117     case 73:
1118         flag = reader->getInt32();
1119         break;
1120     case 74:
1121         hookline = reader->getInt32();
1122         break;
1123     case 75:
1124         hookflag = reader->getInt32();
1125         break;
1126     case 76:
1127         vertnum = reader->getInt32();
1128         break;
1129     case 77:
1130         coloruse = reader->getInt32();
1131         break;
1132     case 40:
1133         textheight = reader->getDouble();
1134         break;
1135     case 41:
1136         textwidth = reader->getDouble();
1137         break;
1138     case 10: {
1139         vertexpoint = new DRW_Coord();
1140         vertexlist.push_back(vertexpoint);
1141         vertexpoint->x = reader->getDouble();
1142         break; }
1143     case 20:
1144         if(vertexpoint != NULL)
1145             vertexpoint->y = reader->getDouble();
1146         break;
1147     case 30:
1148         if(vertexpoint != NULL)
1149             vertexpoint->z = reader->getDouble();
1150         break;
1151     case 340:
1152         annotHandle = static_cast<duint32>(reader->getHandleString());
1153         break;
1154     case 210:
1155         extrusionPoint.x = reader->getDouble();
1156         break;
1157     case 220:
1158         extrusionPoint.y = reader->getDouble();
1159         break;
1160     case 230:
1161         extrusionPoint.z = reader->getDouble();
1162         break;
1163     case 211:
1164         horizdir.x = reader->getDouble();
1165         break;
1166     case 221:
1167         horizdir.y = reader->getDouble();
1168         break;
1169     case 231:
1170         horizdir.z = reader->getDouble();
1171         break;
1172     case 212:
1173         offsetblock.x = reader->getDouble();
1174         break;
1175     case 222:
1176         offsetblock.y = reader->getDouble();
1177         break;
1178     case 232:
1179         offsetblock.z = reader->getDouble();
1180         break;
1181     case 213:
1182         offsettext.x = reader->getDouble();
1183         break;
1184     case 223:
1185         offsettext.y = reader->getDouble();
1186         break;
1187     case 233:
1188         offsettext.z = reader->getDouble();
1189         break;
1190     default:
1191         DRW_Entity::parseCode(code, reader);
1192         break;
1193     }
1194 }
1195 
parseCode(int code,dxfReader * reader)1196 void DRW_Viewport::parseCode(int code, dxfReader *reader){
1197     switch (code) {
1198     case 40:
1199         pswidth = reader->getDouble();
1200         break;
1201     case 41:
1202         psheight = reader->getDouble();
1203         break;
1204     case 68:
1205         vpstatus = reader->getInt32();
1206         break;
1207     case 69:
1208         vpID = reader->getInt32();
1209         break;
1210     case 12: {
1211         centerPX = reader->getDouble();
1212         break; }
1213     case 22:
1214         centerPY = reader->getDouble();
1215         break;
1216     default:
1217         DRW_Point::parseCode(code, reader);
1218         break;
1219     }
1220 }
1221