QGIS API Documentation 4.3.0-Master (0de80482b60)
Loading...
Searching...
No Matches
qgsmapinfosymbolconverter.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsmapinfosymbolconverter.cpp
3 --------------------------------------
4 Date : March 2021
5 Copyright : (C) 2021 by Nyall Dawson
6 Email : nyall dot dawson at gmail dot com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
16#include "qgsmapinfosymbolconverter.h"
17
18#include "qgsfillsymbol.h"
19#include "qgsfillsymbollayer.h"
20#include "qgslinesymbol.h"
21#include "qgslinesymbollayer.h"
22#include "qgslogger.h"
23#include "qgsmarkersymbol.h"
24#include "qgsmarkersymbollayer.h"
25#include "qgssymbol.h"
26
27#include <QString>
28
29using namespace Qt::StringLiterals;
30
31//
32// QgsMapInfoSymbolConversionContext
33//
34void QgsMapInfoSymbolConversionContext::pushWarning( const QString &warning )
35{
36 QgsDebugMsgLevel( warning, 2 );
37 mWarnings << warning;
38}
39
40
41std::unique_ptr<QgsLineSymbol> QgsMapInfoSymbolConverter::convertLineSymbol(
42 int identifier, QgsMapInfoSymbolConversionContext &context, const QColor &foreColor, double size, Qgis::RenderUnit sizeUnit, bool interleaved
43)
44{
45 auto simpleLine = std::make_unique< QgsSimpleLineSymbolLayer >( foreColor, size );
46 simpleLine->setWidthUnit( sizeUnit );
47 simpleLine->setPenCapStyle( Qt::RoundCap );
48 simpleLine->setPenJoinStyle( Qt::RoundJoin );
49
50 QVector< qreal > dashPattern;
51 double patternOffset = 0;
52 switch ( identifier )
53 {
54 case 1:
55 case 57:
56 case 58:
57 case 82:
58 case 90:
59 case 98:
60 case 106:
61 // no pen
62 simpleLine->setPenStyle( Qt::NoPen );
63 break;
64
65 case 2:
66 case 38:
67 // solid line
68 break;
69
70 case 3:
71 dashPattern << 1 << 2.2;
72 break;
73
74 case 4:
75 dashPattern << 2 << 2;
76 break;
77
78 case 5:
79 dashPattern << 4 << 2;
80 break;
81
82 case 6:
83 dashPattern << 8 << 2;
84 break;
85
86 case 7:
87 dashPattern << 16 << 4;
88 break;
89
90 case 8:
91 dashPattern << 32 << 8;
92 break;
93
94 case 9:
95 dashPattern << 10.5 << 4.5;
96 break;
97
98 case 10:
99 dashPattern << 1 << 13.5 / 2;
100 break;
101
102 case 11:
103 dashPattern << 4 << 8;
104 break;
105
106 case 12:
107 dashPattern << 8 << 8;
108 break;
109
110 case 13:
111 dashPattern << 16 << 16;
112 break;
113
114 case 14:
115 dashPattern << 10 << 5 << 1 << 5;
116 break;
117
118 case 15:
119 dashPattern << 18 << 3 << 1 << 3;
120 break;
121
122 case 16:
123 dashPattern << 20 << 3 << 4 << 3;
124 break;
125
126 case 17:
127 dashPattern << 32 << 12 << 6 << 12;
128 break;
129
130 case 18:
131 dashPattern << 32 << 6 << 4 << 6 << 4 << 6;
132 break;
133
134 case 19:
135 dashPattern << 32 << 6 << 4 << 6 << 4 << 6 << 4 << 6;
136 break;
137
138 case 20:
139 dashPattern << 11 << 5 << 1 << 5 << 1 << 5;
140 break;
141
142 case 21:
143 dashPattern << 20 << 4 << 1 << 4 << 1 << 4;
144 break;
145
146 case 22:
147 dashPattern << 20 << 4 << 1 << 4 << 1 << 4 << 1 << 4;
148 break;
149
150 case 23:
151 dashPattern << 6 << 2 << 1 << 2;
152 break;
153
154 case 24:
155 dashPattern << 6 << 2 << 1 << 2 << 1 << 2;
156 break;
157
158 case 25:
159 dashPattern << 10.5 << 2 << 1 << 2 << 4 << 2 << 1 << 2;
160 break;
161
162 case 32:
163 case 33:
164 case 34:
165 case 35:
166 dashPattern << 18 << 4;
167 break;
168
169 case 36:
170 dashPattern << 7 << 4;
171 break;
172
173 case 37:
174 dashPattern << 16 << 6;
175 break;
176
177 case 26:
178 case 27:
179 case 28:
180 case 29:
181 case 30:
182 case 31:
183 break;
184
185 case 39:
186 case 40:
187 dashPattern << 20 << 15;
188 break;
189
190 case 41:
191 case 42:
192 case 43:
193 case 44:
194 case 45:
195 case 46:
196 break;
197
198 case 47:
199 dashPattern << 4 << 8;
200 break;
201
202 case 48:
203 case 49:
204 case 50:
205 case 51:
206 break;
207
208 case 52:
209 case 53:
210 dashPattern << 15 << 4;
211 break;
212
213 case 54:
214 case 55:
215 case 56:
216 case 59:
217 case 60:
218 case 61:
219 case 62:
220 case 63:
221 case 64:
222 case 65:
223 case 66:
224 case 67:
225 break;
226
227 case 68:
228 dashPattern << 10 << 5;
229 break;
230
231 case 69:
232 case 70:
233 break;
234
235 case 71:
236 dashPattern << 12 << 20;
237 break;
238
239 case 72:
240 dashPattern << 20 << 8;
241 break;
242
243 case 73:
244 case 74:
245 case 75:
246 case 76:
247 case 77:
248 case 78:
249 case 79:
250 case 80:
251 case 81:
252 break;
253
254 case 83:
255 case 91:
256 case 99:
257 case 107:
258 dashPattern << 0 << 4 << 1 << 4;
259 patternOffset = 2;
260 break;
261
262 case 84:
263 case 85:
264 case 86:
265 case 87:
266 case 88:
267 case 89:
268 case 92:
269 case 93:
270 case 94:
271 case 95:
272 case 96:
273 case 97:
274 case 100:
275 case 101:
276 case 102:
277 case 103:
278 case 104:
279 case 105:
280 case 108:
281 case 109:
282 break;
283
284 case 110:
285 case 111:
286 case 112:
287 case 113:
288 // these four are zig-zaggy patterns which can't be reproduced in QGIS!
289 context.pushWarning( QObject::tr( "The line style is not supported in QGIS" ) );
290 return nullptr;
291
292 case 114:
293 case 115:
294 case 116:
295 simpleLine->setWidth( simpleLine->width() * 2 );
296 break;
297
298 case 117:
299 case 118:
300 break;
301
302 default:
303 QgsDebugError( u"Unknown line symbol identifier %1"_s.arg( identifier ) );
304 return nullptr;
305 }
306
307 if ( !dashPattern.isEmpty() )
308 {
309 // scale dash pattern -- sizes above expect a 1 pt width line
310 for ( int i = 0; i < dashPattern.size(); ++i )
311 dashPattern[i] *= size;
312
313 simpleLine->setCustomDashVector( dashPattern );
314 simpleLine->setUseCustomDashPattern( true );
315 simpleLine->setCustomDashPatternUnit( sizeUnit );
316
317 simpleLine->setDashPatternOffset( patternOffset * size );
318 simpleLine->setDashPatternOffsetUnit( sizeUnit );
319 }
320
321 auto symbol = std::make_unique< QgsLineSymbol >( QgsSymbolLayerList() << simpleLine.release() );
322
323 if ( ( identifier >= 26 && identifier < 29 ) || ( identifier >= 31 && identifier < 34 ) || ( identifier >= 36 && identifier < 38 ) || ( identifier >= 47 && identifier <= 53 ) || identifier == 118 )
324 {
325 auto hash = std::make_unique< QgsHashedLineSymbolLayer >();
326
327 double spacing = 1;
328 double offset = 1;
329 double lineOffset = 0;
330 double length = 3.5;
331 switch ( identifier )
332 {
333 case 26:
334 spacing = 10;
335 offset = 5;
336 length = 3.5;
337 break;
338
339 case 27:
340 spacing = 16;
341 offset = 5;
342 length = 3.5;
343 break;
344
345 case 28:
346 case 31:
347 spacing = 24;
348 offset = 5;
349 length = 3.5;
350 break;
351
352 case 32:
353 case 33:
354 spacing = 22;
355 offset = 9;
356 length = 3.5;
357 break;
358
359 case 36:
360 spacing = 11;
361 offset = 0;
362 length = 2;
363 break;
364
365 case 37:
366 spacing = 22;
367 offset = 0;
368 length = 2;
369 break;
370
371 case 47:
372 spacing = 12;
373 offset = 0;
374 length = 2;
375 break;
376
377 case 48:
378 spacing = 3;
379 offset = 0;
380 lineOffset = -1.5;
381 length = 3;
382 break;
383
384 case 49:
385 spacing = 3;
386 offset = 0;
387 lineOffset = 1.5;
388 length = 3;
389 break;
390
391 case 50:
392 spacing = 6;
393 offset = 0;
394 lineOffset = -1.5;
395 length = 3;
396 break;
397
398 case 51:
399 spacing = 6;
400 offset = 0;
401 lineOffset = 1.5;
402 length = 3;
403 break;
404
405 case 52:
406 spacing = 19;
407 offset = 5;
408 lineOffset = -1;
409 length = 2;
410 break;
411
412 case 53:
413 spacing = 19;
414 offset = 5;
415 lineOffset = 1;
416 length = 2;
417 break;
418
419 case 118:
420 spacing = 5;
421 offset = 0;
422 lineOffset = 0;
423 length = 8;
424 break;
425
426 default:
427 break;
428 }
429
430 hash->setInterval( spacing * size );
431 hash->setIntervalUnit( sizeUnit );
432
433 hash->setOffset( lineOffset * size );
434 hash->setOffsetUnit( sizeUnit );
435
436 hash->setOffsetAlongLine( offset * size );
437 hash->setOffsetAlongLineUnit( sizeUnit );
438
439 hash->setHashLength( length * size );
440 hash->setHashLengthUnit( sizeUnit );
441
442 auto subSimpleLine = std::make_unique< QgsSimpleLineSymbolLayer >( foreColor, size );
443 subSimpleLine->setWidthUnit( sizeUnit );
444 subSimpleLine->setPenCapStyle( Qt::RoundCap );
445 subSimpleLine->setPenJoinStyle( Qt::RoundJoin );
446
447 auto subSymbol = std::make_unique< QgsLineSymbol >( QgsSymbolLayerList() << subSimpleLine.release() );
448 hash->setSubSymbol( subSymbol.release() );
449
450 if ( identifier == 31 || identifier == 33 )
451 {
452 std::unique_ptr< QgsHashedLineSymbolLayer > hash2( hash->clone() );
453 hash->setOffsetAlongLine( hash->offsetAlongLine() - size );
454 hash2->setOffsetAlongLine( hash2->offsetAlongLine() + size );
455 symbol->appendSymbolLayer( hash2.release() );
456 }
457 else if ( identifier == 36 || identifier == 37 )
458 {
459 std::unique_ptr< QgsHashedLineSymbolLayer > hash2( hash->clone() );
460 hash2->setOffsetAlongLine( dashPattern.at( 0 ) );
461 symbol->appendSymbolLayer( hash2.release() );
462 }
463 else if ( identifier == 52 || identifier == 53 )
464 {
465 std::unique_ptr< QgsHashedLineSymbolLayer > hash2( hash->clone() );
466 hash2->setOffsetAlongLine( hash->offsetAlongLine() * 2 );
467 symbol->appendSymbolLayer( hash2.release() );
468 }
469 else if ( identifier == 118 )
470 {
471 qgis::down_cast< QgsSimpleLineSymbolLayer * >( symbol->symbolLayer( 0 ) )->setColor( QColor( 0, 0, 0 ) );
472 qgis::down_cast< QgsSimpleLineSymbolLayer * >( symbol->symbolLayer( 0 ) )->setWidth( 0 );
473 symbol->symbolLayer( 0 )->setLocked( true );
474
475 std::unique_ptr<QgsSimpleLineSymbolLayer > secondRail( qgis::down_cast< QgsSimpleLineSymbolLayer * >( symbol->symbolLayer( 0 ) )->clone() );
476 const double offset = 2 * size;
477 qgis::down_cast< QgsSimpleLineSymbolLayer * >( symbol->symbolLayer( 0 ) )->setOffset( offset );
478 qgis::down_cast< QgsSimpleLineSymbolLayer * >( symbol->symbolLayer( 0 ) )->setOffsetUnit( sizeUnit );
479 secondRail->setOffset( -offset );
480 secondRail->setOffsetUnit( sizeUnit );
481
482 secondRail->setLocked( true );
483 symbol->appendSymbolLayer( secondRail.release() );
484 }
485 symbol->appendSymbolLayer( hash.release() );
486 }
487 else if ( ( identifier >= 29 && identifier < 31 ) || ( identifier >= 34 && identifier < 36 ) )
488 {
489 double spacing = 1;
490 double offset = 1;
491 switch ( identifier )
492 {
493 case 29:
494 case 30:
495 spacing = 10;
496 offset = 5;
497 break;
498
499 case 34:
500 case 35:
501 spacing = 22;
502 offset = 9;
503 break;
504
505 default:
506 break;
507 }
508
509 auto hash = std::make_unique< QgsHashedLineSymbolLayer >();
510 hash->setInterval( spacing * size * 2 );
511 hash->setIntervalUnit( sizeUnit );
512
513 hash->setOffsetAlongLine( offset * size );
514 hash->setOffsetAlongLineUnit( sizeUnit );
515
516 hash->setHashLength( 3.5 * size * 0.5 );
517 hash->setHashLengthUnit( sizeUnit );
518
519 auto subSimpleLine = std::make_unique< QgsSimpleLineSymbolLayer >( foreColor, size );
520 subSimpleLine->setWidthUnit( sizeUnit );
521 subSimpleLine->setPenCapStyle( Qt::RoundCap );
522 subSimpleLine->setPenJoinStyle( Qt::RoundJoin );
523
524 auto subSymbol = std::make_unique< QgsLineSymbol >( QgsSymbolLayerList() << subSimpleLine.release() );
525 hash->setSubSymbol( subSymbol.release() );
526 std::unique_ptr< QgsHashedLineSymbolLayer > hash2( hash->clone() );
527
528 hash->setOffset( -hash->hashLength() );
529 hash->setOffsetUnit( hash->hashLengthUnit() );
530 hash2->setOffset( hash->hashLength() );
531 hash2->setOffsetUnit( hash->hashLengthUnit() );
532 hash2->setOffsetAlongLine( hash2->offsetAlongLine() + hash2->interval() * 0.5 );
533
534 switch ( identifier )
535 {
536 case 29:
537 case 34:
538 symbol->appendSymbolLayer( hash.release() );
539 symbol->appendSymbolLayer( hash2.release() );
540 break;
541
542 case 30:
543 case 35:
544 {
545 std::unique_ptr< QgsHashedLineSymbolLayer > hash3( hash->clone() );
546 std::unique_ptr< QgsHashedLineSymbolLayer > hash4( hash2->clone() );
547
548 hash->setOffsetAlongLine( hash->offsetAlongLine() - size );
549 hash3->setOffsetAlongLine( hash3->offsetAlongLine() + size );
550 hash2->setOffsetAlongLine( hash2->offsetAlongLine() - size );
551 hash4->setOffsetAlongLine( hash4->offsetAlongLine() + size );
552
553 symbol->appendSymbolLayer( hash.release() );
554 symbol->appendSymbolLayer( hash2.release() );
555 symbol->appendSymbolLayer( hash3.release() );
556 symbol->appendSymbolLayer( hash4.release() );
557 break;
558 }
559 }
560 }
561 else if ( ( identifier >= 38 && identifier < 41 ) || ( identifier >= 54 && identifier <= 61 ) || ( identifier >= 78 && identifier <= 109 ) || ( identifier >= 114 && identifier <= 117 ) )
562 {
563 auto marker = std::make_unique< QgsMarkerLineSymbolLayer >();
564
565 double spacing = 1;
566 double offset = 1;
567 double markerSize = 1;
568 double angle = 0;
569 double lineOffset = 0;
570 Qgis::MarkerLinePlacement placement = Qgis::MarkerLinePlacement::Interval;
571 Qgis::MarkerShape shape = Qgis::MarkerShape::Circle;
572 switch ( identifier )
573 {
574 case 38:
575 spacing = 35;
576 offset = 25;
577 markerSize = 3;
578 shape = Qgis::MarkerShape::Cross2;
579 break;
580
581 case 39:
582 spacing = 35;
583 offset = 27.5;
584 markerSize = 3;
585 shape = Qgis::MarkerShape::Cross2;
586 break;
587
588 case 40:
589 spacing = 35;
590 offset = 27.5;
591 markerSize = 3.2;
592 shape = Qgis::MarkerShape::Cross;
593 break;
594
595 case 54:
596 spacing = 12;
597 offset = 4;
598 markerSize = 6;
599 shape = Qgis::MarkerShape::ArrowHead;
600 break;
601
602 case 55:
603 spacing = 12;
604 offset = 0;
605 markerSize = 6;
606 shape = Qgis::MarkerShape::ArrowHead;
607 angle = 180;
608 break;
609
610 case 56:
611 spacing = 31;
612 offset = 4;
613 markerSize = 6;
614 shape = Qgis::MarkerShape::ArrowHead;
615 angle = 180;
616 break;
617
618 case 57:
619 spacing = 10;
620 offset = 4;
621 markerSize = 6;
622 shape = Qgis::MarkerShape::ArrowHead;
623 break;
624
625 case 58:
626 spacing = 10;
627 offset = 0;
628 markerSize = 6;
629 shape = Qgis::MarkerShape::ArrowHead;
630 angle = 180;
631 break;
632
633 case 59:
634 case 61:
635 offset = 0;
636 markerSize = 6;
637 shape = Qgis::MarkerShape::ArrowHead;
638 placement = Qgis::MarkerLinePlacement::LastVertex;
639 break;
640
641 case 60:
642 offset = 0;
643 markerSize = 6;
644 shape = Qgis::MarkerShape::ArrowHead;
645 placement = Qgis::MarkerLinePlacement::FirstVertex;
646 angle = 180;
647 break;
648
649 case 78:
650 case 80:
651 offset = 2;
652 markerSize = 4;
653 shape = Qgis::MarkerShape::Octagon;
654 placement = Qgis::MarkerLinePlacement::FirstVertex;
655 angle = 0;
656 break;
657
658 case 79:
659 offset = 2;
660 markerSize = 4;
661 shape = Qgis::MarkerShape::Octagon;
662 placement = Qgis::MarkerLinePlacement::LastVertex;
663 angle = 0;
664 break;
665
666 case 81:
667 case 82:
668 case 83:
669 case 84:
670 case 85:
671 spacing = 9;
672 offset = 2;
673 markerSize = 4;
674 shape = Qgis::MarkerShape::Octagon;
675 placement = Qgis::MarkerLinePlacement::Interval;
676 angle = 0;
677 break;
678
679 case 86:
680 case 88:
681 offset = 2;
682 markerSize = 4;
683 shape = Qgis::MarkerShape::Square;
684 placement = Qgis::MarkerLinePlacement::FirstVertex;
685 angle = 0;
686 break;
687
688 case 87:
689 offset = 2;
690 markerSize = 4;
691 shape = Qgis::MarkerShape::Square;
692 placement = Qgis::MarkerLinePlacement::LastVertex;
693 angle = 0;
694 break;
695
696 case 89:
697 case 90:
698 case 91:
699 case 92:
700 case 93:
701 spacing = 9;
702 offset = 2;
703 markerSize = 4;
704 shape = Qgis::MarkerShape::Square;
705 placement = Qgis::MarkerLinePlacement::Interval;
706 angle = 0;
707 break;
708
709 case 94:
710 case 96:
711 offset = 2;
712 markerSize = 4;
713 shape = Qgis::MarkerShape::EquilateralTriangle;
714 placement = Qgis::MarkerLinePlacement::FirstVertex;
715 angle = 0;
716 break;
717
718 case 95:
719 offset = 2;
720 markerSize = 4;
721 shape = Qgis::MarkerShape::EquilateralTriangle;
722 placement = Qgis::MarkerLinePlacement::LastVertex;
723 angle = 180;
724 break;
725
726 case 97:
727 case 98:
728 case 99:
729 case 100:
730 case 101:
731 spacing = 9;
732 offset = 2;
733 markerSize = 4;
734 shape = Qgis::MarkerShape::Diamond;
735 placement = Qgis::MarkerLinePlacement::Interval;
736 angle = 0;
737 break;
738
739 case 102:
740 case 104:
741 offset = 2;
742 markerSize = 4;
743 shape = Qgis::MarkerShape::Diamond;
744 placement = Qgis::MarkerLinePlacement::FirstVertex;
745 angle = 0;
746 break;
747
748 case 103:
749 offset = 2;
750 markerSize = 4;
751 shape = Qgis::MarkerShape::Diamond;
752 placement = Qgis::MarkerLinePlacement::LastVertex;
753 angle = 180;
754 break;
755
756 case 105:
757 case 106:
758 case 107:
759 case 108:
760 case 109:
761 spacing = 9;
762 offset = 2;
763 markerSize = 4;
764 shape = Qgis::MarkerShape::Diamond;
765 placement = Qgis::MarkerLinePlacement::Interval;
766 angle = 0;
767 break;
768
769 case 114:
770 spacing = 18;
771 offset = 9;
772 markerSize = 8;
773 shape = Qgis::MarkerShape::SemiCircle;
774 placement = Qgis::MarkerLinePlacement::Interval;
775 angle = 0;
776 lineOffset = -0.8;
777 break;
778
779 case 115:
780 spacing = 16;
781 offset = 8;
782 markerSize = 8;
783 shape = Qgis::MarkerShape::EquilateralTriangle;
784 placement = Qgis::MarkerLinePlacement::Interval;
785 angle = 0;
786 lineOffset = -2;
787 break;
788
789 case 116:
790 spacing = 23;
791 offset = 8;
792 markerSize = 8;
793 shape = Qgis::MarkerShape::SemiCircle;
794 placement = Qgis::MarkerLinePlacement::Interval;
795 angle = 0;
796 lineOffset = -0.8;
797 break;
798
799 case 117:
800 spacing = 9;
801 offset = 2;
802 markerSize = 4;
803 shape = Qgis::MarkerShape::Square;
804 placement = Qgis::MarkerLinePlacement::Interval;
805 angle = 0;
806 lineOffset = -2;
807 break;
808
809 default:
810 break;
811 }
812
813 if ( identifier >= 78 && identifier <= 109 )
814 {
815 qgis::down_cast< QgsSimpleLineSymbolLayer * >( symbol->symbolLayer( 0 ) )->setColor( QColor( 0, 0, 0 ) );
816 qgis::down_cast< QgsSimpleLineSymbolLayer * >( symbol->symbolLayer( 0 ) )->setWidth( 0 );
817 symbol->symbolLayer( 0 )->setLocked( true );
818
819 if ( ( identifier >= 84 && identifier <= 85 ) || ( identifier >= 92 && identifier <= 93 ) || ( identifier >= 100 && identifier <= 101 ) || ( identifier >= 108 && identifier <= 109 ) )
820 {
821 std::unique_ptr<QgsSimpleLineSymbolLayer > secondRail( qgis::down_cast< QgsSimpleLineSymbolLayer * >( symbol->symbolLayer( 0 ) )->clone() );
822
823 double offset = 2 * size;
824 if ( identifier == 85 || identifier == 93 || identifier == 101 || identifier == 109 )
825 offset = 3 * size;
826
827 qgis::down_cast< QgsSimpleLineSymbolLayer * >( symbol->symbolLayer( 0 ) )->setOffset( offset );
828 qgis::down_cast< QgsSimpleLineSymbolLayer * >( symbol->symbolLayer( 0 ) )->setOffsetUnit( sizeUnit );
829 secondRail->setOffset( -offset );
830 secondRail->setOffsetUnit( sizeUnit );
831
832 secondRail->setLocked( true );
833 symbol->appendSymbolLayer( secondRail.release() );
834 }
835 }
836
837 marker->setPlacements( placement );
838 marker->setInterval( spacing * size );
839 marker->setIntervalUnit( sizeUnit );
840
841 marker->setOffsetAlongLine( offset * size );
842 marker->setOffsetAlongLineUnit( sizeUnit );
843
844 marker->setOffset( lineOffset * size );
845 marker->setOffsetUnit( sizeUnit );
846
847 auto subSimpleMarker = std::make_unique< QgsSimpleMarkerSymbolLayer >( shape, markerSize * size );
848 subSimpleMarker->setColor( foreColor );
849 subSimpleMarker->setSizeUnit( sizeUnit );
850 subSimpleMarker->setStrokeWidth( size );
851 subSimpleMarker->setStrokeWidthUnit( sizeUnit );
852 subSimpleMarker->setAngle( angle );
853
854 subSimpleMarker->setPenJoinStyle( Qt::RoundJoin );
855 subSimpleMarker->setPenCapStyle( Qt::RoundCap );
856
857 if ( shape == Qgis::MarkerShape::Octagon
858 || shape == Qgis::MarkerShape::Square
859 || shape == Qgis::MarkerShape::EquilateralTriangle
860 || shape == Qgis::MarkerShape::Diamond
861 || shape == Qgis::MarkerShape::SemiCircle )
862 {
863 subSimpleMarker->setStrokeStyle( Qt::NoPen );
864 }
865
866 auto subSymbol = std::make_unique< QgsMarkerSymbol >( QgsSymbolLayerList() << subSimpleMarker.release() );
867 marker->setSubSymbol( subSymbol.release() );
868
869 if ( identifier == 56 )
870 {
871 std::unique_ptr< QgsMarkerLineSymbolLayer > marker2( marker->clone() );
872 marker2->setOffsetAlongLine( 19 * size );
873 qgis::down_cast< QgsMarkerSymbol * >( marker2->subSymbol() )->setAngle( 0 );
874 symbol->appendSymbolLayer( marker2.release() );
875 }
876 else if ( identifier == 61 )
877 {
878 std::unique_ptr< QgsMarkerLineSymbolLayer > marker2( marker->clone() );
879 marker2->setPlacements( Qgis::MarkerLinePlacement::FirstVertex );
880 qgis::down_cast< QgsMarkerSymbol * >( marker2->subSymbol() )->setAngle( 180 );
881 symbol->appendSymbolLayer( marker2.release() );
882 }
883 else if ( identifier == 80 || identifier == 88 || identifier == 96 || identifier == 104 )
884 {
885 std::unique_ptr< QgsMarkerLineSymbolLayer > marker2( marker->clone() );
886 marker2->setPlacements( Qgis::MarkerLinePlacement::LastVertex );
887 qgis::down_cast< QgsMarkerSymbol * >( marker2->subSymbol() )->setAngle( 180 );
888 symbol->appendSymbolLayer( marker2.release() );
889 }
890
891 if ( identifier == 116 )
892 {
893 std::unique_ptr< QgsMarkerLineSymbolLayer > marker2( marker->clone() );
894
895 qgis::down_cast< QgsSimpleMarkerSymbolLayer * >( marker2->subSymbol()->symbolLayer( 0 ) )->setShape( Qgis::MarkerShape::EquilateralTriangle );
896 marker2->setOffsetAlongLine( 16 * size );
897 marker2->setOffset( -1.5 * size );
898 symbol->appendSymbolLayer( marker2.release() );
899 }
900
901 symbol->appendSymbolLayer( marker.release() );
902 }
903 else if ( identifier >= 41 && identifier < 45 )
904 {
905 const int count = identifier - 40;
906 QgsSimpleLineSymbolLayer *simpleLine = qgis::down_cast< QgsSimpleLineSymbolLayer * >( symbol->symbolLayer( 0 ) );
907 simpleLine->setCustomDashVector( QVector< qreal >() << 0 << 5.25 * size << 4 * size << ( 3.25 * size + ( count - 1 ) * ( 7.25 * size ) ) );
908 simpleLine->setCustomDashPatternUnit( sizeUnit );
909 simpleLine->setUseCustomDashPattern( true );
910
911 for ( int i = 1; i < count; ++i )
912 {
913 std::unique_ptr< QgsSimpleLineSymbolLayer > dashLine( simpleLine->clone() );
914
915 dashLine->setCustomDashVector( QVector< qreal >() << 0 << 5.25 * size + ( i * 7.25 * size ) << 4 * size << ( 3.25 * size + ( count - 1 - i ) * ( 7.25 * size ) ) );
916 symbol->appendSymbolLayer( dashLine.release() );
917 }
918
919 auto simpleLine2 = std::make_unique< QgsSimpleLineSymbolLayer >( foreColor, 1.6 * size );
920 simpleLine2->setWidthUnit( sizeUnit );
921 simpleLine2->setPenCapStyle( Qt::RoundCap );
922 simpleLine2->setPenJoinStyle( Qt::RoundJoin );
923
924 simpleLine2->setCustomDashVector( QVector< qreal >() << 2 * size << 10.5 * size + ( count - 1 ) * ( 7.25 * size ) );
925 simpleLine2->setUseCustomDashPattern( true );
926 simpleLine2->setCustomDashPatternUnit( sizeUnit );
927
928 symbol->appendSymbolLayer( simpleLine2.release() );
929 }
930 else if ( identifier == 45 )
931 {
932 auto simpleLine2 = std::make_unique< QgsSimpleLineSymbolLayer >( foreColor, 1.6 * size );
933 simpleLine2->setWidthUnit( sizeUnit );
934 simpleLine2->setPenCapStyle( Qt::RoundCap );
935 simpleLine2->setPenJoinStyle( Qt::RoundJoin );
936
937 simpleLine2->setCustomDashVector( QVector< qreal >() << 0 << 2 * size << 1.25 * size << 6.5 * size );
938 simpleLine2->setUseCustomDashPattern( true );
939 simpleLine2->setCustomDashPatternUnit( sizeUnit );
940
941 symbol->appendSymbolLayer( simpleLine2.release() );
942 }
943 else if ( identifier == 46 )
944 {
945 auto hashLine = std::make_unique< QgsHashedLineSymbolLayer >();
946
947 hashLine->setInterval( 4 * size );
948 hashLine->setIntervalUnit( sizeUnit );
949 hashLine->setOffsetAlongLine( 2 * size );
950 hashLine->setOffsetAlongLineUnit( sizeUnit );
951 hashLine->setHashLength( 3.8 * size );
952 hashLine->setHashLengthUnit( sizeUnit );
953
954 hashLine->setSubSymbol( symbol.release() );
955
956 symbol = std::make_unique< QgsLineSymbol >( QgsSymbolLayerList() << hashLine.release() );
957 }
958 else if ( identifier == 62 )
959 {
960 auto markerLine = std::make_unique< QgsMarkerLineSymbolLayer >();
961 markerLine->setPlacements( Qgis::MarkerLinePlacement::FirstVertex );
962 markerLine->setOffsetAlongLine( 2 * size );
963 markerLine->setOffsetAlongLineUnit( sizeUnit );
964
965 auto subSimpleMarker = std::make_unique< QgsSimpleMarkerSymbolLayer >( Qgis::MarkerShape::Line, size * 4 );
966 subSimpleMarker->setColor( foreColor );
967 subSimpleMarker->setSizeUnit( sizeUnit );
968 subSimpleMarker->setStrokeWidth( 1.25 * size );
969 subSimpleMarker->setStrokeWidthUnit( sizeUnit );
970 subSimpleMarker->setAngle( 90 );
971
972 subSimpleMarker->setPenJoinStyle( Qt::RoundJoin );
973 subSimpleMarker->setPenCapStyle( Qt::RoundCap );
974
975 auto subSymbol = std::make_unique< QgsMarkerSymbol >( QgsSymbolLayerList() << subSimpleMarker.release() );
976 markerLine->setSubSymbol( subSymbol.release() );
977
978 symbol->appendSymbolLayer( markerLine.release() );
979 }
980 else if ( ( identifier >= 63 && identifier <= 69 ) || ( identifier >= 72 && identifier <= 77 ) )
981 {
982 std::unique_ptr< QgsSimpleLineSymbolLayer > upperLine( qgis::down_cast< QgsSimpleLineSymbolLayer * >( symbol->symbolLayer( 0 ) )->clone() );
983 upperLine->setUseCustomDashPattern( false );
984
985 if ( identifier < 65 || ( identifier >= 68 && identifier <= 69 ) || identifier == 73 )
986 {
987 upperLine->setColor( QColor( 255, 255, 255 ) );
988 upperLine->setLocked( true );
989 }
990 else if ( identifier < 67 || identifier == 72 || identifier == 75 || identifier == 76 )
991 {
992 qgis::down_cast< QgsSimpleLineSymbolLayer * >( symbol->symbolLayer( 0 ) )->setColor( QColor( 0, 0, 0 ) );
993 symbol->symbolLayer( 0 )->setLocked( true );
994 }
995 else if ( identifier <= 69 || identifier == 77 )
996 {
997 upperLine->setColor( QColor( 0, 0, 0 ) );
998 upperLine->setLocked( true );
999 }
1000 upperLine->setWidth( upperLine->width() * 0.9 );
1001 if ( interleaved )
1002 {
1003 upperLine->setRenderingPass( 1 );
1004 }
1005
1006 if ( identifier >= 73 && identifier <= 75 )
1007 {
1008 upperLine->setCustomDashVector( QVector< qreal >() << 0 << 10 * size << 12 * size << 2 * size );
1009 upperLine->setUseCustomDashPattern( true );
1010 upperLine->setCustomDashPatternUnit( sizeUnit );
1011 }
1012 else if ( identifier == 76 )
1013 {
1014 upperLine->setCustomDashVector( QVector< qreal >() << 0 << 10 * size << 24 * size << 14 * size );
1015 upperLine->setUseCustomDashPattern( true );
1016 upperLine->setCustomDashPatternUnit( sizeUnit );
1017 }
1018
1019 if ( identifier == 75 || identifier == 76 )
1020 {
1021 auto middleLine = std::make_unique< QgsSimpleLineSymbolLayer >( QColor( 255, 255, 255 ), upperLine->width() );
1022 middleLine->setWidthUnit( sizeUnit );
1023 middleLine->setLocked( true );
1024 middleLine->setPenCapStyle( Qt::RoundCap );
1025 middleLine->setPenJoinStyle( Qt::RoundJoin );
1026
1027 if ( interleaved )
1028 {
1029 middleLine->setRenderingPass( 1 );
1030 upperLine->setRenderingPass( 2 );
1031 }
1032 symbol->appendSymbolLayer( middleLine.release() );
1033 }
1034
1035 symbol->appendSymbolLayer( upperLine.release() );
1036
1037 if ( identifier == 64 || identifier == 66 )
1038 {
1039 auto middleLine = std::make_unique< QgsSimpleLineSymbolLayer >( identifier == 64 ? foreColor : QColor( 0, 0, 0 ), 0 );
1040 if ( identifier == 66 )
1041 middleLine->setLocked( true );
1042
1043 if ( interleaved )
1044 {
1045 middleLine->setRenderingPass( 2 );
1046 }
1047 symbol->appendSymbolLayer( middleLine.release() );
1048 }
1049
1050 else if ( identifier == 69 )
1051 {
1052 auto hashedLine = std::make_unique< QgsHashedLineSymbolLayer >();
1053
1054 auto middleLine = std::make_unique< QgsSimpleLineSymbolLayer >( foreColor, 0 );
1055 hashedLine->setSubSymbol( new QgsLineSymbol( { middleLine.release() } ) );
1056 hashedLine->setInterval( 18 * size );
1057 hashedLine->setIntervalUnit( sizeUnit );
1058 hashedLine->setOffsetAlongLine( 4 * size );
1059 hashedLine->setOffsetAlongLineUnit( sizeUnit );
1060 hashedLine->setHashLength( 8 * size );
1061 hashedLine->setHashLengthUnit( sizeUnit );
1062
1063 if ( interleaved )
1064 {
1065 hashedLine->setRenderingPass( 2 );
1066 }
1067 symbol->appendSymbolLayer( hashedLine.release() );
1068 }
1069 else if ( identifier == 77 )
1070 {
1071 auto middleLine = std::make_unique< QgsSimpleLineSymbolLayer >( QColor( 255, 255, 255 ), qgis::down_cast< QgsSimpleLineSymbolLayer * >( symbol->symbolLayer( 1 ) )->width() );
1072 middleLine->setWidthUnit( sizeUnit );
1073 middleLine->setLocked( true );
1074 middleLine->setPenCapStyle( Qt::RoundCap );
1075 middleLine->setPenJoinStyle( Qt::RoundJoin );
1076 middleLine->setCustomDashVector( QVector< qreal >() << 0 << 10 * size << 12 * size << 2 * size );
1077 middleLine->setUseCustomDashPattern( true );
1078 middleLine->setCustomDashPatternUnit( sizeUnit );
1079 if ( interleaved )
1080 {
1081 middleLine->setRenderingPass( 2 );
1082 }
1083 symbol->appendSymbolLayer( middleLine.release() );
1084 }
1085 }
1086 else if ( identifier >= 70 && identifier <= 71 )
1087 {
1088 qgis::down_cast< QgsSimpleLineSymbolLayer * >( symbol->symbolLayer( 0 ) )->setColor( QColor( 0, 0, 0 ) );
1089 qgis::down_cast< QgsSimpleLineSymbolLayer * >( symbol->symbolLayer( 0 ) )->setLocked( true );
1090
1091 auto simpleLine2 = std::make_unique< QgsSimpleLineSymbolLayer >( foreColor, size );
1092 simpleLine2->setWidthUnit( sizeUnit );
1093 simpleLine2->setPenCapStyle( Qt::RoundCap );
1094 simpleLine2->setPenJoinStyle( Qt::RoundJoin );
1095
1096 if ( identifier == 70 )
1097 simpleLine2->setCustomDashVector( QVector< qreal >() << 0 << 12 * size << 12 * size << 0 );
1098 else if ( identifier == 71 )
1099 simpleLine2->setCustomDashVector( QVector< qreal >() << 0 << 16 * size << 12 * size << 4 * size );
1100
1101 simpleLine2->setUseCustomDashPattern( true );
1102 simpleLine2->setCustomDashPatternUnit( sizeUnit );
1103
1104 symbol->appendSymbolLayer( simpleLine2.release() );
1105 }
1106
1107 return symbol;
1108}
1109
1110std::unique_ptr<QgsFillSymbol> QgsMapInfoSymbolConverter::convertFillSymbol( int identifier, QgsMapInfoSymbolConversionContext &context, const QColor &foreColor, const QColor &backColor )
1111{
1112 Qt::BrushStyle style = Qt::SolidPattern;
1113
1114 bool useLineFill = false;
1115 bool crossFill = false;
1116 double lineAngle = 0;
1117 double lineWidth = 0;
1118 double lineSpacing = 1;
1119 switch ( identifier )
1120 {
1121 case 0:
1122 case 1:
1123 style = Qt::NoBrush;
1124 break;
1125
1126 case 2:
1127 style = Qt::SolidPattern;
1128 break;
1129
1130 case 3:
1131 case 19:
1132 style = Qt::HorPattern;
1133 break;
1134
1135 case 4:
1136 case 24:
1137 style = Qt::VerPattern;
1138 break;
1139
1140 case 5:
1141 case 34:
1142 style = Qt::FDiagPattern;
1143 break;
1144
1145 case 6:
1146 case 29:
1147 style = Qt::BDiagPattern;
1148 break;
1149
1150 case 7:
1151 case 39:
1152 style = Qt::CrossPattern;
1153 break;
1154
1155 case 8:
1156 case 44:
1157 style = Qt::DiagCrossPattern;
1158 break;
1159
1160 case 12:
1161 style = Qt::Dense1Pattern;
1162 break;
1163
1164 case 13:
1165 style = Qt::Dense2Pattern;
1166 break;
1167
1168 case 14:
1169 style = Qt::Dense3Pattern;
1170 break;
1171
1172 case 15:
1173 style = Qt::Dense4Pattern;
1174 break;
1175
1176 case 16:
1177 style = Qt::Dense5Pattern;
1178 break;
1179
1180 case 17:
1181 style = Qt::Dense6Pattern;
1182 break;
1183
1184 case 18:
1185 style = Qt::Dense7Pattern;
1186 break;
1187
1188 case 20:
1189 useLineFill = true;
1190 lineAngle = 0;
1191 lineSpacing = 6;
1192 lineWidth = 1.2;
1193 break;
1194
1195 case 21:
1196 useLineFill = true;
1197 lineAngle = 0;
1198 lineSpacing = 4;
1199 lineWidth = 0.8;
1200 break;
1201
1202 case 22:
1203 useLineFill = true;
1204 lineAngle = 0;
1205 lineSpacing = 3.4;
1206 lineWidth = 1.2;
1207 break;
1208
1209 case 23:
1210 useLineFill = true;
1211 lineAngle = 0;
1212 lineSpacing = 3.0;
1213 lineWidth = 1.0;
1214 break;
1215
1216 case 25:
1217 useLineFill = true;
1218 lineAngle = 90;
1219 lineSpacing = 6;
1220 lineWidth = 1.2;
1221 break;
1222
1223 case 26:
1224 useLineFill = true;
1225 lineAngle = 90;
1226 lineSpacing = 4;
1227 lineWidth = 0.8;
1228 break;
1229
1230 case 27:
1231 useLineFill = true;
1232 lineAngle = 90;
1233 lineSpacing = 3.4;
1234 lineWidth = 1.2;
1235 break;
1236
1237 case 28:
1238 useLineFill = true;
1239 lineAngle = 90;
1240 lineSpacing = 3.0;
1241 lineWidth = 1.0;
1242 break;
1243
1244 case 30:
1245 useLineFill = true;
1246 lineAngle = 45;
1247 lineSpacing = 6;
1248 lineWidth = 1.2;
1249 break;
1250
1251 case 31:
1252 useLineFill = true;
1253 lineAngle = 45;
1254 lineSpacing = 4;
1255 lineWidth = 0.8;
1256 break;
1257
1258 case 32:
1259 useLineFill = true;
1260 lineAngle = 45;
1261 lineSpacing = 3.4;
1262 lineWidth = 1.2;
1263 break;
1264
1265 case 33:
1266 useLineFill = true;
1267 lineAngle = 45;
1268 lineSpacing = 3.0;
1269 lineWidth = 1.0;
1270 break;
1271
1272 case 35:
1273 useLineFill = true;
1274 lineAngle = 135;
1275 lineSpacing = 6;
1276 lineWidth = 1.2;
1277 break;
1278
1279 case 36:
1280 useLineFill = true;
1281 lineAngle = 135;
1282 lineSpacing = 4;
1283 lineWidth = 0.8;
1284 break;
1285
1286 case 37:
1287 useLineFill = true;
1288 lineAngle = 135;
1289 lineSpacing = 3.4;
1290 lineWidth = 1.2;
1291 break;
1292
1293 case 38:
1294 useLineFill = true;
1295 lineAngle = 135;
1296 lineSpacing = 3.0;
1297 lineWidth = 1.0;
1298 break;
1299
1300 case 40:
1301 useLineFill = true;
1302 crossFill = true;
1303 lineAngle = 0;
1304 lineSpacing = 6;
1305 lineWidth = 1.2;
1306 break;
1307
1308 case 41:
1309 useLineFill = true;
1310 crossFill = true;
1311 lineAngle = 0;
1312 lineSpacing = 4;
1313 lineWidth = 0.8;
1314 break;
1315
1316 case 42:
1317 useLineFill = true;
1318 crossFill = true;
1319 lineAngle = 0;
1320 lineSpacing = 3.4;
1321 lineWidth = 1.2;
1322 break;
1323
1324 case 43:
1325 useLineFill = true;
1326 crossFill = true;
1327 lineAngle = 0;
1328 lineSpacing = 3.0;
1329 lineWidth = 1.0;
1330 break;
1331
1332 case 45:
1333 useLineFill = true;
1334 crossFill = true;
1335 lineAngle = 45;
1336 lineSpacing = 6;
1337 lineWidth = 1.2;
1338 break;
1339
1340 case 46:
1341 useLineFill = true;
1342 crossFill = true;
1343 lineAngle = 45;
1344 lineSpacing = 4;
1345 lineWidth = 0.8;
1346 break;
1347
1348 case 47:
1349 useLineFill = true;
1350 crossFill = true;
1351 lineAngle = 45;
1352 lineSpacing = 3.4;
1353 lineWidth = 1.2;
1354 break;
1355
1356 default:
1357 context.pushWarning( QObject::tr( "The brush style is not supported in QGIS" ) );
1358 return nullptr;
1359 }
1360
1361 QgsSymbolLayerList layers;
1362 if ( backColor.isValid() && style != Qt::SolidPattern && ( useLineFill || style != Qt::NoBrush ) )
1363 {
1364 auto backgroundFill = std::make_unique< QgsSimpleFillSymbolLayer >( backColor );
1365 backgroundFill->setLocked( true );
1366 backgroundFill->setStrokeStyle( Qt::NoPen );
1367 layers << backgroundFill.release();
1368 }
1369
1370 if ( !useLineFill )
1371 {
1372 auto foregroundFill = std::make_unique< QgsSimpleFillSymbolLayer >( foreColor );
1373 foregroundFill->setBrushStyle( style );
1374 foregroundFill->setStrokeStyle( Qt::NoPen );
1375 layers << foregroundFill.release();
1376 }
1377 else
1378 {
1379 auto lineFill = std::make_unique< QgsLinePatternFillSymbolLayer >();
1380
1381 auto simpleLine = std::make_unique< QgsSimpleLineSymbolLayer >( foreColor, lineWidth );
1382 simpleLine->setWidthUnit( Qgis::RenderUnit::Points );
1383 lineFill->setSubSymbol( new QgsLineSymbol( QgsSymbolLayerList() << simpleLine.release() ) );
1384
1385 lineFill->setDistance( lineSpacing );
1386 lineFill->setDistanceUnit( Qgis::RenderUnit::Points );
1387 lineFill->setLineAngle( lineAngle );
1388
1389 if ( crossFill )
1390 {
1391 std::unique_ptr< QgsLinePatternFillSymbolLayer > lineFill2( lineFill->clone() );
1392 lineFill2->setLineAngle( lineFill->lineAngle() + 90 );
1393 layers << lineFill2.release();
1394 }
1395
1396 layers << lineFill.release();
1397 }
1398 return std::make_unique<QgsFillSymbol>( layers );
1399}
1400
1401std::unique_ptr<QgsMarkerSymbol> QgsMapInfoSymbolConverter::convertMarkerSymbol( int identifier, QgsMapInfoSymbolConversionContext &context, const QColor &color, double size, Qgis::RenderUnit sizeUnit )
1402{
1403 Qgis::MarkerShape shape;
1404 bool isFilled = true;
1405 bool isNull = false;
1406 bool hasShadow = false;
1407 double angle = 0;
1408 Qgis::VerticalAnchorPoint vertAlign = Qgis::VerticalAnchorPoint::Center;
1409 QPointF shadowOffset;
1410 switch ( identifier )
1411 {
1412 case 31:
1413 // null symbol
1414 shape = Qgis::MarkerShape::Square; // to initialize the variable
1415 isNull = true;
1416 break;
1417
1418 case 32:
1419 shape = Qgis::MarkerShape::Square;
1420 break;
1421
1422 case 33:
1423 shape = Qgis::MarkerShape::Diamond;
1424 break;
1425
1426 case 34:
1427 shape = Qgis::MarkerShape::Circle;
1428 break;
1429
1430 case 35:
1431 shape = Qgis::MarkerShape::Star;
1432 break;
1433
1434 case 36:
1435 shape = Qgis::MarkerShape::Triangle;
1436 break;
1437
1438 case 37:
1439 shape = Qgis::MarkerShape::Triangle;
1440 angle = 180;
1441 break;
1442
1443 case 38:
1444 shape = Qgis::MarkerShape::Square;
1445 isFilled = false;
1446 break;
1447
1448 case 39:
1449 shape = Qgis::MarkerShape::Diamond;
1450 isFilled = false;
1451 break;
1452
1453 case 40:
1454 shape = Qgis::MarkerShape::Circle;
1455 isFilled = false;
1456 break;
1457
1458 case 41:
1459 shape = Qgis::MarkerShape::Star;
1460 isFilled = false;
1461 break;
1462
1463 case 42:
1464 shape = Qgis::MarkerShape::Triangle;
1465 isFilled = false;
1466 break;
1467
1468 case 43:
1469 shape = Qgis::MarkerShape::Triangle;
1470 angle = 180;
1471 isFilled = false;
1472 break;
1473
1474 case 44:
1475 shape = Qgis::MarkerShape::Square;
1476 hasShadow = true;
1477 shadowOffset = QPointF( size * 0.1, size * 0.1 );
1478 break;
1479
1480 case 45:
1481 shape = Qgis::MarkerShape::Triangle;
1482 shadowOffset = QPointF( size * 0.2, size * 0.1 );
1483 hasShadow = true;
1484 break;
1485
1486 case 46:
1487 shape = Qgis::MarkerShape::Circle;
1488 shadowOffset = QPointF( size * 0.1, size * 0.1 );
1489 hasShadow = true;
1490 break;
1491
1492 case 47:
1493 shape = Qgis::MarkerShape::Arrow;
1494 size *= 0.66666;
1495 angle = 45;
1496 vertAlign = Qgis::VerticalAnchorPoint::Top;
1497 break;
1498
1499 case 48:
1500 shape = Qgis::MarkerShape::Arrow;
1501 size *= 0.66666;
1502 angle = 225;
1503 vertAlign = Qgis::VerticalAnchorPoint::Top;
1504 break;
1505
1506 case 49:
1507 shape = Qgis::MarkerShape::Cross;
1508 break;
1509
1510 case 50:
1511 shape = Qgis::MarkerShape::Cross2;
1512 break;
1513
1514 case 51:
1515 shape = Qgis::MarkerShape::Cross;
1516 break;
1517
1518 default:
1519 context.pushWarning( QObject::tr( "The symbol is not supported in QGIS" ) );
1520 return nullptr;
1521 }
1522
1523 auto simpleMarker = std::make_unique< QgsSimpleMarkerSymbolLayer >( shape, size );
1524 simpleMarker->setSizeUnit( sizeUnit );
1525 simpleMarker->setAngle( angle );
1526 simpleMarker->setVerticalAnchorPoint( vertAlign );
1527 simpleMarker->setStrokeWidth( 1.0 );
1528 simpleMarker->setStrokeWidthUnit( Qgis::RenderUnit::Points );
1529
1530 if ( isNull )
1531 {
1532 simpleMarker->setFillColor( QColor( 0, 0, 0, 0 ) );
1533 simpleMarker->setStrokeStyle( Qt::NoPen );
1534 }
1535 else if ( isFilled && QgsSimpleMarkerSymbolLayer::shapeIsFilled( shape ) )
1536 {
1537 simpleMarker->setColor( color );
1538 simpleMarker->setStrokeColor( QColor( 0, 0, 0 ) );
1539 }
1540 else
1541 {
1542 simpleMarker->setFillColor( QColor( 0, 0, 0, 0 ) );
1543 simpleMarker->setStrokeColor( color );
1544 }
1545
1546 QgsSymbolLayerList symbols;
1547 if ( hasShadow )
1548 {
1549 std::unique_ptr< QgsSimpleMarkerSymbolLayer > shadow( simpleMarker->clone() );
1550 shadow->setColor( QColor( 0, 0, 0 ) );
1551 shadow->setLocked( true );
1552 shadow->setOffset( shadowOffset );
1553 shadow->setOffsetUnit( sizeUnit );
1554
1555 symbols << shadow.release();
1556 symbols << simpleMarker.release();
1557 }
1558 else
1559 {
1560 if ( identifier == 51 )
1561 {
1562 std::unique_ptr< QgsSimpleMarkerSymbolLayer > second( simpleMarker->clone() );
1563 second->setShape( Qgis::MarkerShape::Cross2 );
1564 symbols << second.release();
1565 }
1566 symbols << simpleMarker.release();
1567 }
1568
1569 return std::make_unique<QgsMarkerSymbol>( symbols );
1570}
Qgis::MarkerLinePlacement
MarkerLinePlacement
Defines how/where the symbols should be placed on a line.
Definition qgis.h:3345
Qgis::MarkerLinePlacement::LastVertex
@ LastVertex
Place symbols on the last vertex in the line.
Definition qgis.h:3348
Qgis::MarkerLinePlacement::Interval
@ Interval
Place symbols at regular intervals.
Definition qgis.h:3346
Qgis::MarkerLinePlacement::FirstVertex
@ FirstVertex
Place symbols on the first vertex in the line.
Definition qgis.h:3349
Qgis::MarkerShape
MarkerShape
Marker shapes.
Definition qgis.h:3296
Qgis::MarkerShape::Arrow
@ Arrow
Arrow.
Definition qgis.h:3304
Qgis::MarkerShape::EquilateralTriangle
@ EquilateralTriangle
Equilateral triangle.
Definition qgis.h:3302
Qgis::MarkerShape::SemiCircle
@ SemiCircle
Semi circle (top half).
Definition qgis.h:3312
Qgis::MarkerShape::Circle
@ Circle
Circle.
Definition qgis.h:3305
Qgis::MarkerShape::ArrowHead
@ ArrowHead
Right facing arrow head (unfilled, lines only).
Definition qgis.h:3310
Qgis::MarkerShape::Octagon
@ Octagon
Octagon.
Definition qgis.h:3320
Qgis::MarkerShape::Line
@ Line
Vertical line.
Definition qgis.h:3309
Qgis::MarkerShape::Triangle
@ Triangle
Triangle.
Definition qgis.h:3301
Qgis::MarkerShape::Cross2
@ Cross2
Rotated cross (lines only), 'x' shape.
Definition qgis.h:3308
Qgis::MarkerShape::Diamond
@ Diamond
Diamond.
Definition qgis.h:3298
Qgis::MarkerShape::Square
@ Square
Square.
Definition qgis.h:3297
Qgis::MarkerShape::Cross
@ Cross
Cross (lines only).
Definition qgis.h:3306
Qgis::VerticalAnchorPoint
VerticalAnchorPoint
Marker symbol vertical anchor points.
Definition qgis.h:876
Qgis::VerticalAnchorPoint::Center
@ Center
Align to vertical center of symbol.
Definition qgis.h:878
Qgis::VerticalAnchorPoint::Top
@ Top
Align to top of symbol.
Definition qgis.h:877
Qgis::RenderUnit
RenderUnit
Rendering size units.
Definition qgis.h:5682
Qgis::RenderUnit::Points
@ Points
Points (e.g., for font sizes).
Definition qgis.h:5687
QgsLineSymbol
A line symbol type, for rendering LineString and MultiLineString geometries.
Definition qgslinesymbol.h:30
QgsMapInfoSymbolConversionContext
Context for a MapInfo symbol conversion operation.
Definition qgsmapinfosymbolconverter.h:37
QgsMapInfoSymbolConversionContext::pushWarning
void pushWarning(const QString &warning)
Pushes a warning message generated during the conversion.
Definition qgsmapinfosymbolconverter.cpp:34
QgsMapInfoSymbolConverter::convertFillSymbol
static std::unique_ptr< QgsFillSymbol > convertFillSymbol(int identifier, QgsMapInfoSymbolConversionContext &context, const QColor &foreColor, const QColor &backColor=QColor())
Converts the MapInfo fill symbol with the specified identifier to a QgsFillSymbol.
Definition qgsmapinfosymbolconverter.cpp:1110
QgsMapInfoSymbolConverter::convertLineSymbol
static std::unique_ptr< QgsLineSymbol > convertLineSymbol(int identifier, QgsMapInfoSymbolConversionContext &context, const QColor &foreColor, double size, Qgis::RenderUnit sizeUnit, bool interleaved=false)
Converts the MapInfo line symbol with the specified identifier to a QgsLineSymbol.
Definition qgsmapinfosymbolconverter.cpp:41
QgsMapInfoSymbolConverter::convertMarkerSymbol
static std::unique_ptr< QgsMarkerSymbol > convertMarkerSymbol(int identifier, QgsMapInfoSymbolConversionContext &context, const QColor &color, double size, Qgis::RenderUnit sizeUnit)
Converts the MapInfo marker symbol with the specified identifier to a QgsMarkerSymbol.
Definition qgsmapinfosymbolconverter.cpp:1401
QgsSimpleLineSymbolLayer
A simple line symbol layer, which renders lines using a line in a variety of styles (e....
Definition qgslinesymbollayer.h:46
QgsSimpleLineSymbolLayer::setUseCustomDashPattern
void setUseCustomDashPattern(bool b)
Sets whether the line uses a custom dash pattern.
Definition qgslinesymbollayer.h:154
QgsSimpleLineSymbolLayer::setCustomDashVector
void setCustomDashVector(const QVector< qreal > &vector)
Sets the custom dash vector, which is the pattern of alternating drawn/skipped lengths used while ren...
Definition qgslinesymbollayer.h:206
QgsSimpleLineSymbolLayer::clone
QgsSimpleLineSymbolLayer * clone() const override
Shall be reimplemented by subclasses to create a deep copy of the instance.
Definition qgslinesymbollayer.cpp:569
QgsSimpleLineSymbolLayer::setCustomDashPatternUnit
void setCustomDashPatternUnit(Qgis::RenderUnit unit)
Sets the unit for lengths used in the custom dash pattern.
Definition qgslinesymbollayer.h:160
QgsSimpleMarkerSymbolLayerBase::shapeIsFilled
static bool shapeIsFilled(Qgis::MarkerShape shape)
Returns true if a symbol shape has a fill.
Definition qgsmarkersymbollayer.cpp:118
QgsDebugMsgLevel
#define QgsDebugMsgLevel(str, level)
Definition qgslogger.h:80
QgsDebugError
#define QgsDebugError(str)
Definition qgslogger.h:71
QgsSymbolLayerList
QList< QgsSymbolLayer * > QgsSymbolLayerList
Definition qgssymbol.h:30
Generated on for QGIS API Documentation by doxygen 1.15.0