Branch data Line data Source code
1 : : /***************************************************************************
2 : : qgsdxfexport.h
3 : : --------------
4 : : begin : September 2013
5 : : copyright : (C) 2013 by Marco Hugentobler
6 : : email : marco at sourcepole dot ch
7 : : ***************************************************************************/
8 : :
9 : : /***************************************************************************
10 : : * *
11 : : * This program is free software; you can redistribute it and/or modify *
12 : : * it under the terms of the GNU General Public License as published by *
13 : : * the Free Software Foundation; either version 2 of the License, or *
14 : : * (at your option) any later version. *
15 : : * *
16 : : ***************************************************************************/
17 : :
18 : : #ifndef QGSDXFEXPORT_H
19 : : #define QGSDXFEXPORT_H
20 : :
21 : : #include "qgis_core.h"
22 : : #include "qgis_sip.h"
23 : : #include "qgis.h"
24 : : #include "qgsgeometry.h"
25 : : #include "qgssymbol.h" // for OutputUnit enum
26 : : #include "qgsmapsettings.h"
27 : : #include "qgslabelsink.h"
28 : :
29 : : #include <QColor>
30 : : #include <QList>
31 : : #include <QTextStream>
32 : :
33 : : class QgsMapLayer;
34 : : class QgsPointXY;
35 : : class QgsSymbolLayer;
36 : : class QIODevice;
37 : : class QgsPalLayerSettings;
38 : : class QgsCurve;
39 : : class QgsCurvePolygon;
40 : : class QgsCircularString;
41 : : class QgsCompoundCurve;
42 : : struct DxfLayerJob;
43 : :
44 : : #define DXF_HANDSEED 100
45 : : #define DXF_HANDMAX 9999999
46 : : #define DXF_HANDPLOTSTYLE 0xf
47 : :
48 : : namespace pal // SIP_SKIP
49 : : {
50 : : class LabelPosition;
51 : : }
52 : :
53 : :
54 : : /**
55 : : * \ingroup core
56 : : * \class QgsDxfExport
57 : : * \brief Exports QGIS layers to the DXF format.
58 : : */
59 : : #ifdef SIP_RUN
60 : : class CORE_EXPORT QgsDxfExport
61 : : {
62 : : #else
63 : : class CORE_EXPORT QgsDxfExport : public QgsLabelSink
64 : : {
65 : : #endif
66 : : public:
67 : :
68 : : /**
69 : : * Layers and optional attribute index to split
70 : : * into multiple layers using attribute value as layer name.
71 : : */
72 : : struct CORE_EXPORT DxfLayer
73 : : {
74 : 0 : DxfLayer( QgsVectorLayer *vl, int layerOutputAttributeIndex = -1 )
75 : 0 : : mLayer( vl )
76 : 0 : , mLayerOutputAttributeIndex( layerOutputAttributeIndex )
77 : 0 : {}
78 : :
79 : : //! Returns the layer
80 : 0 : QgsVectorLayer *layer() const {return mLayer;}
81 : :
82 : : /**
83 : : * Returns the attribute index used to split into multiple layers.
84 : : * The attribute value is used for layer names.
85 : : * \see splitLayerAttribute
86 : : */
87 : 0 : int layerOutputAttributeIndex() const {return mLayerOutputAttributeIndex;}
88 : :
89 : : /**
90 : : * If the split layer attribute is set, the vector layer
91 : : * will be split into several dxf layers, one per each
92 : : * unique value.
93 : : * \since QGIS 3.12
94 : : */
95 : : QString splitLayerAttribute() const;
96 : :
97 : : private:
98 : : QgsVectorLayer *mLayer = nullptr;
99 : : int mLayerOutputAttributeIndex = -1;
100 : : };
101 : :
102 : : enum SymbologyExport
103 : : {
104 : : NoSymbology = 0, //!< Export only data
105 : : FeatureSymbology, //!< Keeps the number of features and export symbology per feature (using the first symbol level)
106 : : SymbolLayerSymbology //!< Exports one feature per symbol layer (considering symbol levels)
107 : : };
108 : :
109 : : //! Export flags
110 : : enum Flag
111 : : {
112 : : FlagNoMText = 1 << 1, //!< Export text as TEXT elements. If not set, text will be exported as MTEXT elements.
113 : : };
114 : : Q_DECLARE_FLAGS( Flags, Flag )
115 : :
116 : : /**
117 : : * The result of an export as dxf operation
118 : : *
119 : : * \since QGIS 3.10.1
120 : : */
121 : : enum class ExportResult
122 : : {
123 : : Success = 0, //!< Successful export
124 : : InvalidDeviceError, //!< Invalid device error
125 : : DeviceNotWritableError, //!< Device not writable error
126 : : EmptyExtentError //!< Empty extent, no extent given and no extent could be derived from layers
127 : : };
128 : :
129 : : /**
130 : : * Vertical alignments.
131 : : */
132 : : enum class VAlign : int
133 : : {
134 : : VBaseLine = 0, //!< Top (0)
135 : : VBottom = 1, //!< Bottom (1)
136 : : VMiddle = 2, //!< Middle (2)
137 : : VTop = 3, //!< Top (3)
138 : : Undefined = 9999 //!< Undefined
139 : : };
140 : :
141 : : //! Horizontal alignments.
142 : : enum class HAlign : int
143 : : {
144 : : HLeft = 0, //!< Left (0)
145 : : HCenter = 1, //!< Centered (1)
146 : : HRight = 2, //!< Right (2)
147 : : HAligned = 3, //!< Aligned = (3) (if VAlign==0)
148 : : HMiddle = 4, //!< Middle = (4) (if VAlign==0)
149 : : HFit = 5, //!< Fit into point = (5) (if VAlign==0)
150 : : Undefined = 9999 //!< Undefined
151 : : };
152 : :
153 : : /**
154 : : * Flags for polylines
155 : : *
156 : : * \since QGIS 3.12
157 : : */
158 : : enum DxfPolylineFlag
159 : : {
160 : : Closed = 1, //!< This is a closed polyline (or a polygon mesh closed in the M direction)
161 : : Curve = 2, //!< Curve-fit vertices have been added
162 : : Spline = 4, //! < Spline-fit vertices have been added
163 : : Is3DPolyline = 8, //!< This is a 3D polyline
164 : : Is3DPolygonMesh = 16, //!< This is a 3D polygon mesh
165 : : PolygonMesh = 32, //!< The polygon mesh is closed in the N direction
166 : : PolyfaceMesh = 64, //!< The polyline is a polyface mesh
167 : : ContinuousPattern = 128, //!< The linetype pattern is generated continuously around the vertices of this polyline
168 : : };
169 : :
170 : : Q_DECLARE_FLAGS( DxfPolylineFlags, DxfPolylineFlag )
171 : :
172 : : /**
173 : : * Constructor for QgsDxfExport.
174 : : */
175 : : QgsDxfExport();
176 : :
177 : : ~QgsDxfExport() override;
178 : :
179 : : /**
180 : : * Set map settings and assign layer name attributes
181 : : * \param settings map settings to apply
182 : : */
183 : : void setMapSettings( const QgsMapSettings &settings );
184 : :
185 : : /**
186 : : * Sets the export flags.
187 : : * \see flags()
188 : : * \since QGIS 3.0
189 : : */
190 : : void setFlags( QgsDxfExport::Flags flags );
191 : :
192 : : /**
193 : : * Returns the export flags.
194 : : * \see setFlags()
195 : : * \since QGIS 3.0
196 : : */
197 : : QgsDxfExport::Flags flags() const;
198 : :
199 : : /**
200 : : * Add layers to export
201 : : * \param layers list of layers and corresponding attribute indexes that determine the layer name (-1 for original layer name or title)
202 : : * \see setLayerTitleAsName
203 : : */
204 : : void addLayers( const QList< QgsDxfExport::DxfLayer > &layers );
205 : :
206 : : /**
207 : : * Export to a dxf file in the given encoding
208 : : * \param d device
209 : : * \param codec encoding
210 : : * \returns an ExportResult
211 : : */
212 : : ExportResult writeToFile( QIODevice *d, const QString &codec ); //maybe add progress dialog? other parameters (e.g. scale, dpi)?
213 : :
214 : : /**
215 : : * Set reference \a scale for output.
216 : : * The \a scale value indicates the scale denominator, e.g. 1000.0 for a 1:1000 map.
217 : : * \see symbologyScale()
218 : : * \since QGIS 3.0
219 : : */
220 : 0 : void setSymbologyScale( double scale ) { mSymbologyScale = scale; }
221 : :
222 : : /**
223 : : * Returns the reference scale for output.
224 : : * The scale value indicates the scale denominator, e.g. 1000.0 for a 1:1000 map.
225 : : * \see setSymbologyScale()
226 : : * \since QGIS 3.0
227 : : */
228 : 0 : double symbologyScale() const { return mSymbologyScale; }
229 : :
230 : : /**
231 : : * Retrieve map units
232 : : * \returns unit
233 : : */
234 : : QgsUnitTypes::DistanceUnit mapUnits() const;
235 : :
236 : : /**
237 : : * Set destination CRS
238 : : * \see destinationCrs()
239 : : * \since QGIS 3.0
240 : : */
241 : : void setDestinationCrs( const QgsCoordinateReferenceSystem &crs );
242 : :
243 : : /**
244 : : * Returns the destination CRS, or an invalid CRS if no reprojection will be done.
245 : : * \see setDestinationCrs()
246 : : * \since QGIS 3.0
247 : : */
248 : : QgsCoordinateReferenceSystem destinationCrs() const;
249 : :
250 : : /**
251 : : * Set symbology export mode
252 : : * \param e the mode
253 : : */
254 : 0 : void setSymbologyExport( QgsDxfExport::SymbologyExport e ) { mSymbologyExport = e; }
255 : :
256 : : /**
257 : : * Gets symbology export mode
258 : : * \returns mode
259 : : * \see setSymbologyExport
260 : : */
261 : : QgsDxfExport::SymbologyExport symbologyExport() const { return mSymbologyExport; }
262 : :
263 : : /**
264 : : * Set extent of area to export
265 : : * \param r area to export
266 : : */
267 : : void setExtent( const QgsRectangle &r ) { mExtent = r; }
268 : :
269 : : /**
270 : : * Gets extent of area to export
271 : : * \returns area to export
272 : : * \see setExtent
273 : : */
274 : : QgsRectangle extent() const { return mExtent; }
275 : :
276 : : /**
277 : : * Enable use of title (where set) instead of layer name,
278 : : * when attribute index of corresponding layer index is -1
279 : : * \param layerTitleAsName flag
280 : : * \see addLayers
281 : : */
282 : 0 : void setLayerTitleAsName( bool layerTitleAsName ) { mLayerTitleAsName = layerTitleAsName; }
283 : :
284 : : /**
285 : : * Retrieve whether layer title (where set) instead of name shall be use
286 : : * \returns flag
287 : : * \see setLayerTitleAsName
288 : : */
289 : : bool layerTitleAsName() { return mLayerTitleAsName; }
290 : :
291 : : /**
292 : : * Force 2d output (eg. to support linewidth in polylines)
293 : : * \param force2d flag
294 : : * \see force2d
295 : : */
296 : 0 : void setForce2d( bool force2d ) { mForce2d = force2d; }
297 : :
298 : : /**
299 : : * Retrieve whether the output should be forced to 2d
300 : : * \returns flag
301 : : * \see setForce2d
302 : : */
303 : : bool force2d() { return mForce2d; }
304 : :
305 : : /**
306 : : * Gets DXF palette index of nearest entry for given color
307 : : * \param color
308 : : */
309 : : static int closestColorMatch( QRgb color );
310 : :
311 : : /**
312 : : * Gets layer name for feature
313 : : * \param id layer id of layer
314 : : * \param f feature of layer
315 : : * \returns layer name for feature
316 : : */
317 : : QString layerName( const QString &id, const QgsFeature &f ) const;
318 : :
319 : : /**
320 : : * Gets name for layer respecting the use layer title as layer name mode
321 : : * \param vl the vector layer
322 : : * \returns name of layer
323 : : * \see setLayerTitleAsName
324 : : */
325 : : QString layerName( QgsVectorLayer *vl ) const;
326 : :
327 : : /**
328 : : * Write a tuple of group code and integer value
329 : : * \param code group code
330 : : * \param i integer value
331 : : * \note available in Python bindings as writeGroupInt
332 : : */
333 : : void writeGroup( int code, int i ) SIP_PYNAME( writeGroupInt );
334 : :
335 : : /**
336 : : * Write a tuple of group code and long value
337 : : * \param code group code
338 : : * \param i integer value
339 : : * \note available in Python bindings as writeGroupLong
340 : : */
341 : : void writeGroup( int code, long long i ) SIP_PYNAME( writeGroupLong );
342 : :
343 : : /**
344 : : * Write a group code with a floating point value
345 : : * \param code group code
346 : : * \param d floating point value
347 : : * \note available in Python bindings as writeGroupDouble
348 : : */
349 : : void writeGroup( int code, double d ) SIP_PYNAME( writeGroupDouble );
350 : :
351 : : /**
352 : : * Write a group code with a string value
353 : : * \param code group code
354 : : * \param s string value
355 : : */
356 : : void writeGroup( int code, const QString &s );
357 : :
358 : : /**
359 : : * Write a group code with a point
360 : : * \param code group code
361 : : * \param p point value
362 : : * \note available in Python bindings as writeGroupPointV2
363 : : * \since QGIS 2.15
364 : : */
365 : : void writeGroup( int code, const QgsPoint &p ) SIP_PYNAME( writeGroupPointV2 );
366 : :
367 : : /**
368 : : * Write a group code with color value
369 : : * \param color color
370 : : * \param exactMatch group code to use if the color has an exact match in the dxf palette
371 : : * \param rgbCode group code to use if the color doesn't have an exact match or has a transparency component
372 : : * \param transparencyCode group code to use for transparency component
373 : : * \note available in Python bindings as writeGroupPoint
374 : : */
375 : : void writeGroup( const QColor &color, int exactMatch = 62, int rgbCode = 420, int transparencyCode = 440 );
376 : :
377 : : /**
378 : : * Write a group code
379 : : * \param code group code value
380 : : */
381 : : void writeGroupCode( int code );
382 : :
383 : : /**
384 : : * Write an integer value
385 : : * \param i integer value
386 : : */
387 : : void writeInt( int i );
388 : :
389 : : /**
390 : : * Write a floating point value
391 : : * \param d floating point value
392 : : */
393 : : void writeDouble( double d );
394 : :
395 : : /**
396 : : * Write a string value
397 : : * \param s string value
398 : : */
399 : : void writeString( const QString &s );
400 : :
401 : : /**
402 : : * Write a tuple of group code and a handle
403 : : * \param code group code to use
404 : : * \param handle handle to use (0 generates a new handle)
405 : : * \returns the used handle
406 : : */
407 : : int writeHandle( int code = 5, int handle = 0 );
408 : :
409 : : /**
410 : : * Draw dxf primitives (LWPOLYLINE)
411 : : * \param line polyline
412 : : * \param layer layer name to use
413 : : * \param lineStyleName line type to use
414 : : * \param color color to use
415 : : * \param width line width to use
416 : : * \note not available in Python bindings
417 : : * \since QGIS 2.15
418 : : */
419 : : void writePolyline( const QgsPointSequence &line, const QString &layer, const QString &lineStyleName, const QColor &color, double width = -1 ) SIP_SKIP;
420 : :
421 : : /**
422 : : * Draw dxf primitives (LWPOLYLINE)
423 : : * \param curve polyline (including curved)
424 : : * \param layer layer name to use
425 : : * \param lineStyleName line type to use
426 : : * \param color color to use
427 : : * \param width line width to use
428 : : * \note not available in Python bindings
429 : : * \since QGIS 3.8
430 : : */
431 : : void writePolyline( const QgsCurve &curve, const QString &layer, const QString &lineStyleName, const QColor &color, double width = -1 ) SIP_SKIP;
432 : :
433 : : /**
434 : : * Draw dxf filled polygon (HATCH)
435 : : * \param polygon polygon
436 : : * \param layer layer name to use
437 : : * \param hatchPattern hatchPattern to use
438 : : * \param color color to use
439 : : * \note not available in Python bindings
440 : : * \since QGIS 2.15
441 : : */
442 : : void writePolygon( const QgsRingSequence &polygon, const QString &layer, const QString &hatchPattern, const QColor &color ) SIP_SKIP;
443 : :
444 : : /**
445 : : * Draw dxf curved filled polygon (HATCH)
446 : : * \param polygon polygon (including curves)
447 : : * \param layer layer name to use
448 : : * \param hatchPattern hatchPattern to use
449 : : * \param color color to use
450 : : * \note not available in Python bindings
451 : : * \since QGIS 3.8
452 : : */
453 : : void writePolygon( const QgsCurvePolygon &polygon, const QString &layer, const QString &hatchPattern, const QColor &color ) SIP_SKIP;
454 : :
455 : : /**
456 : : * Write line (as a polyline)
457 : : * \since QGIS 2.15
458 : : */
459 : : void writeLine( const QgsPoint &pt1, const QgsPoint &pt2, const QString &layer, const QString &lineStyleName, const QColor &color, double width = -1 );
460 : :
461 : : /**
462 : : * Write point
463 : : * \note available in Python bindings as writePointV2
464 : : * \since QGIS 2.15
465 : : */
466 : : void writePoint( const QString &layer, const QColor &color, const QgsPoint &pt ) SIP_PYNAME( writePointV2 );
467 : :
468 : : /**
469 : : * Write filled circle (as hatch)
470 : : * \note available in Python bindings as writePointV2
471 : : * \since QGIS 2.15
472 : : */
473 : : void writeFilledCircle( const QString &layer, const QColor &color, const QgsPoint &pt, double radius ) SIP_PYNAME( writeFillCircleV2 );
474 : :
475 : : /**
476 : : * Write circle (as polyline)
477 : : * \note available in Python bindings as writeCircleV2
478 : : * \since QGIS 2.15
479 : : */
480 : : void writeCircle( const QString &layer, const QColor &color, const QgsPoint &pt, double radius, const QString &lineStyleName, double width ) SIP_PYNAME( writeCircleV2 );
481 : :
482 : : /**
483 : : * Write text (TEXT)
484 : : * \note available in Python bindings as writeTextV2
485 : : * \since QGIS 2.15
486 : : */
487 : : void writeText( const QString &layer, const QString &text, const QgsPoint &pt, double size, double angle, const QColor &color, QgsDxfExport::HAlign hali = QgsDxfExport::HAlign::Undefined, QgsDxfExport::VAlign vali = QgsDxfExport::VAlign::Undefined ) SIP_PYNAME( writeTextV2 );
488 : :
489 : : /**
490 : : * Write mtext (MTEXT)
491 : : * \note available in Python bindings as writeMTextV2
492 : : * \since QGIS 2.15
493 : : */
494 : : void writeMText( const QString &layer, const QString &text, const QgsPoint &pt, double width, double angle, const QColor &color );
495 : :
496 : : /**
497 : : * Returns scale factor for conversion to map units
498 : : * \param scale the map scale denominator
499 : : * \param symbolUnits the symbol output units
500 : : * \param mapUnits the map units
501 : : * \param mapUnitsPerPixel Map units per pixel
502 : : */
503 : : static double mapUnitScaleFactor( double scale, QgsUnitTypes::RenderUnit symbolUnits, QgsUnitTypes::DistanceUnit mapUnits, double mapUnitsPerPixel = 1.0 );
504 : :
505 : : /**
506 : : * Clips value to scale minimum/maximum
507 : : * \param value the value to clip
508 : : * \param scale the scale dependent minimum/maximum values
509 : : * \param pixelToMMFactor pixels per mm
510 : : */
511 : : void clipValueToMapUnitScale( double &value, const QgsMapUnitScale &scale, double pixelToMMFactor ) const;
512 : :
513 : : //! Returns cleaned layer name for use in DXF
514 : : static QString dxfLayerName( const QString &name );
515 : :
516 : : //! Returns DXF encoding for Qt encoding
517 : : static QString dxfEncoding( const QString &name );
518 : :
519 : : //! Returns list of available DXF encodings
520 : : static QStringList encodings();
521 : :
522 : : /**
523 : : * Add a label to the dxf output.
524 : : *
525 : : * \note not available in Python bindings
526 : : */
527 : : void drawLabel( const QString &layerId, QgsRenderContext &context, pal::LabelPosition *label, const QgsPalLayerSettings &settings ) SIP_SKIP override;
528 : :
529 : : /**
530 : : * Register name of layer for feature
531 : : * \param layerId id of layer
532 : : * \param fid id of feature
533 : : * \param layer dxf layer of feature
534 : : *
535 : : * \deprecated Will be made private in QGIS 4
536 : : */
537 : : Q_DECL_DEPRECATED void registerDxfLayer( const QString &layerId, QgsFeatureId fid, const QString &layer );
538 : :
539 : : private:
540 : :
541 : : #ifdef SIP_RUN
542 : : QgsDxfExport( const QgsDxfExport &other );
543 : : QgsDxfExport &operator=( const QgsDxfExport & );
544 : : #endif
545 : : //! Extent for export, only intersecting features are exported. If the extent is an empty rectangle, all features are exported
546 : : QgsRectangle mExtent;
547 : : //! Scale for symbology export (used if symbols units are mm)
548 : : double mSymbologyScale = 1.0;
549 : : SymbologyExport mSymbologyExport = NoSymbology;
550 : : QgsUnitTypes::DistanceUnit mMapUnits = QgsUnitTypes::DistanceMeters;
551 : : bool mLayerTitleAsName = false;
552 : :
553 : : QTextStream mTextStream;
554 : :
555 : : int mSymbolLayerCounter = 0; //internal counter
556 : : int mNextHandleId = DXF_HANDSEED;
557 : : int mBlockCounter = 0;
558 : :
559 : : QHash< const QgsSymbolLayer *, QString > mLineStyles; //symbol layer name types
560 : : QHash< const QgsSymbolLayer *, QString > mPointSymbolBlocks; //reference to point symbol blocks
561 : :
562 : : //AC1009
563 : : void writeHeader( const QString &codepage );
564 : : void prepareRenderers();
565 : : void writeTables();
566 : : void writeBlocks();
567 : : void writeEntities();
568 : : void writeEntitiesSymbolLevels( DxfLayerJob *job );
569 : : void stopRenderers();
570 : : void writeEndFile();
571 : :
572 : : void startSection();
573 : : void endSection();
574 : :
575 : : void writePoint( const QgsPoint &pt, const QString &layer, const QColor &color, QgsSymbolRenderContext &ctx, const QgsSymbolLayer *symbolLayer, const QgsSymbol *symbol, double angle );
576 : : void writeDefaultLinetypes();
577 : : void writeSymbolLayerLinetype( const QgsSymbolLayer *symbolLayer );
578 : : void writeLinetype( const QString &styleName, const QVector<qreal> &pattern, QgsUnitTypes::RenderUnit u );
579 : :
580 : : /**
581 : : * Helper method to calculate text properties from (PAL) label
582 : : */
583 : : void writeText( const QString &layer, const QString &text, pal::LabelPosition *label, const QgsPalLayerSettings &layerSettings, const QgsExpressionContext &expressionContext );
584 : :
585 : : /**
586 : : * Writes geometry generator symbol layer
587 : : * \param ctx the symbol render context
588 : : * \param ct the coordinate transform
589 : : * \param layer the layer name
590 : : * \param symbolLayer the symbollayer to write to the dxf file
591 : : * \param allSymbolLayers if TRUE, all symbol layers of the subsymbol are written. If FALSE, only the first one is written
592 : : */
593 : : void addGeometryGeneratorSymbolLayer( QgsSymbolRenderContext &ctx, const QgsCoordinateTransform &ct, const QString &layer, QgsSymbolLayer *symbolLayer, bool allSymbolLayers );
594 : :
595 : : void addFeature( QgsSymbolRenderContext &ctx, const QgsCoordinateTransform &ct, const QString &layer, const QgsSymbolLayer *symbolLayer, const QgsSymbol *symbol );
596 : :
597 : : //returns dxf palette index from symbol layer color
598 : : static QColor colorFromSymbolLayer( const QgsSymbolLayer *symbolLayer, QgsSymbolRenderContext &ctx );
599 : : QString lineStyleFromSymbolLayer( const QgsSymbolLayer *symbolLayer );
600 : :
601 : : //functions for dxf palette
602 : : static int color_distance( QRgb p1, int index );
603 : : static QRgb createRgbEntry( qreal r, qreal g, qreal b );
604 : :
605 : : //helper functions for symbology export
606 : : QgsRenderContext renderContext() const;
607 : :
608 : : QList< QPair< QgsSymbolLayer *, QgsSymbol * > > symbolLayers( QgsRenderContext &context );
609 : : static int nLineTypes( const QList< QPair< QgsSymbolLayer *, QgsSymbol *> > &symbolLayers );
610 : : static bool hasDataDefinedProperties( const QgsSymbolLayer *sl, const QgsSymbol *symbol );
611 : : double dashSize() const;
612 : : double dotSize() const;
613 : : double dashSeparatorSize() const;
614 : : double sizeToMapUnits( double s ) const;
615 : : static QString lineNameFromPenStyle( Qt::PenStyle style );
616 : : bool layerIsScaleBasedVisible( const QgsMapLayer *layer ) const;
617 : :
618 : : QHash<QString, int> mBlockHandles;
619 : : QString mBlockHandle;
620 : :
621 : : //! DXF layer name for each label feature
622 : : QMap< QString, QMap<QgsFeatureId, QString> > mDxfLayerNames;
623 : : QgsCoordinateReferenceSystem mCrs;
624 : : QgsMapSettings mMapSettings;
625 : : QHash<QString, int> mLayerNameAttribute;
626 : : double mFactor = 1.0;
627 : : bool mForce2d = false;
628 : :
629 : : QgsDxfExport::Flags mFlags = QgsDxfExport::Flags();
630 : :
631 : : void appendCurve( const QgsCurve &c, QVector<QgsPoint> &points, QVector<double> &bulges );
632 : : void appendLineString( const QgsLineString &ls, QVector<QgsPoint> &points, QVector<double> &bulges );
633 : : void appendCircularString( const QgsCircularString &cs, QVector<QgsPoint> &points, QVector<double> &bulges );
634 : : void appendCompoundCurve( const QgsCompoundCurve &cc, QVector<QgsPoint> &points, QVector<double> &bulges );
635 : :
636 : : QgsRenderContext mRenderContext;
637 : : // Internal cache for layer related information required during rendering
638 : : QList<DxfLayerJob *> mJobs;
639 : : std::unique_ptr<QgsLabelingEngine> mLabelingEngine;
640 : : };
641 : :
642 : : Q_DECLARE_OPERATORS_FOR_FLAGS( QgsDxfExport::Flags )
643 : : Q_DECLARE_OPERATORS_FOR_FLAGS( QgsDxfExport::DxfPolylineFlags )
644 : :
645 : : #endif // QGSDXFEXPORT_H
|
