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