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