QGIS API Documentation 3.29.0-Master (006c3c0232)
qgslayoutitemscalebar.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgslayoutitemscalebar.cpp
3 -------------------------
4 begin : November 2017
5 copyright : (C) 2017 by Nyall Dawson
6 email : nyall dot dawson at gmail dot com
7 ***************************************************************************/
8/***************************************************************************
9 * *
10 * This program is free software; you can redistribute it and/or modify *
11 * it under the terms of the GNU General Public License as published by *
12 * the Free Software Foundation; either version 2 of the License, or *
13 * (at your option) any later version. *
14 * *
15 ***************************************************************************/
16
20#include "qgslayoutitemmap.h"
21#include "qgslayout.h"
22#include "qgslayoututils.h"
23#include "qgsdistancearea.h"
25#include "qgsscalebarrenderer.h"
26#include "qgsmapsettings.h"
27#include "qgsmessagelog.h"
28#include "qgsrectangle.h"
29#include "qgsproject.h"
30#include "qgssymbollayerutils.h"
31#include "qgsfontutils.h"
32#include "qgsunittypes.h"
33#include "qgssettings.h"
35#include "qgsnumericformat.h"
37#include "qgslinesymbollayer.h"
38#include "qgsfillsymbollayer.h"
39#include "qgslinesymbol.h"
40#include "qgsfillsymbol.h"
41
42#include <QDomDocument>
43#include <QDomElement>
44#include <QFontMetricsF>
45#include <QPainter>
46
47#include <cmath>
48
50 : QgsLayoutItem( layout )
51{
54}
55
57{
59}
60
62{
63 return QgsApplication::getThemeIcon( QStringLiteral( "/mLayoutItemScaleBar.svg" ) );
64}
65
67{
68 return new QgsLayoutItemScaleBar( layout );
69}
70
72{
74 return QgsLayoutSize( mStyle->calculateBoxSize( context, mSettings, createScaleContext() ), QgsUnitTypes::LayoutMillimeters );
75}
76
78{
79 if ( !mStyle )
80 return;
81
83 {
84 // compatibility code - ScalebarLineColor and ScalebarLineWidth are deprecated
86 std::unique_ptr< QgsLineSymbol > sym( mSettings.lineSymbol()->clone() );
89 sym->setWidth( mDataDefinedProperties.valueAsDouble( QgsLayoutObject::ScalebarLineWidth, expContext, mSettings.lineWidth() ) );
91 sym->setColor( mDataDefinedProperties.valueAsColor( QgsLayoutObject::ScalebarLineColor, expContext, mSettings.lineColor() ) );
93 mSettings.setLineSymbol( sym.release() );
94 }
96 {
97 // compatibility code - ScalebarLineColor and ScalebarLineWidth are deprecated
99 std::unique_ptr< QgsFillSymbol > sym( mSettings.fillSymbol()->clone() );
101 sym->setColor( mDataDefinedProperties.valueAsColor( QgsLayoutObject::ScalebarFillColor, expContext, mSettings.fillColor() ) );
103 mSettings.setFillSymbol( sym.release() );
104 }
106 {
107 // compatibility code - ScalebarLineColor and ScalebarLineWidth are deprecated
109 std::unique_ptr< QgsFillSymbol > sym( mSettings.alternateFillSymbol()->clone() );
111 sym->setColor( mDataDefinedProperties.valueAsColor( QgsLayoutObject::ScalebarFillColor2, expContext, mSettings.fillColor2() ) );
113 mSettings.setAlternateFillSymbol( sym.release() );
114 }
115
116 mStyle->draw( context.renderContext(), mSettings, createScaleContext() );
117}
118
120{
121 if ( !mStyle )
122 {
123 mSettings.setNumberOfSegments( nSegments );
124 return;
125 }
126 mSettings.setNumberOfSegments( nSegments );
128}
129
131{
132 if ( !mStyle )
133 {
134 mSettings.setUnitsPerSegment( units );
135 return;
136 }
137 mSettings.setUnitsPerSegment( units );
138 refreshSegmentMillimeters();
140}
141
142
144{
145 if ( !mStyle )
146 {
147 mSettings.setSegmentSizeMode( mode );
148 return;
149 }
150 mSettings.setSegmentSizeMode( mode );
151 refreshSegmentMillimeters();
153}
154
156{
157 if ( !mStyle )
158 {
159 mSettings.setMinimumBarWidth( minWidth );
160 return;
161 }
162 mSettings.setMinimumBarWidth( minWidth );
163 refreshSegmentMillimeters();
165}
166
168{
169 if ( !mStyle )
170 {
171 mSettings.setMaximumBarWidth( maxWidth );
172 return;
173 }
174 mSettings.setMaximumBarWidth( maxWidth );
175 refreshSegmentMillimeters();
177}
178
180{
181 return mSettings.textFormat();
182}
183
185{
186 mSettings.setTextFormat( format );
188 emit changed();
189}
190
192{
193 return mSettings.lineSymbol();
194}
195
197{
198 mSettings.setLineSymbol( symbol );
199}
200
202{
203 return mSettings.divisionLineSymbol();
204}
205
207{
208 mSettings.setDivisionLineSymbol( symbol );
209}
210
212{
213 return mSettings.subdivisionLineSymbol();
214}
215
217{
218 mSettings.setSubdivisionLineSymbol( symbol );
219}
220
222{
223 return mSettings.fillSymbol();
224}
225
227{
228 mSettings.setFillSymbol( symbol );
229}
230
232{
233 return mSettings.alternateFillSymbol();
234}
235
237{
238 mSettings.setAlternateFillSymbol( symbol );
239}
240
242{
243 if ( !mStyle )
244 {
245 mSettings.setNumberOfSegmentsLeft( nSegmentsLeft );
246 return;
247 }
248 mSettings.setNumberOfSegmentsLeft( nSegmentsLeft );
250}
251
253{
254 if ( !mStyle )
255 {
256 mSettings.setBoxContentSpace( space );
257 return;
258 }
259 mSettings.setBoxContentSpace( space );
261}
262
264{
265 disconnectCurrentMap();
266
267 mMap = map;
268
269 if ( !map )
270 {
271 return;
272 }
273
274 connect( mMap, &QgsLayoutItemMap::extentChanged, this, &QgsLayoutItemScaleBar::updateScale );
275 connect( mMap, &QObject::destroyed, this, &QgsLayoutItemScaleBar::disconnectCurrentMap );
276
277 refreshSegmentMillimeters();
278 emit changed();
279}
280
281void QgsLayoutItemScaleBar::disconnectCurrentMap()
282{
283 if ( !mMap )
284 {
285 return;
286 }
287
288 disconnect( mMap, &QgsLayoutItemMap::extentChanged, this, &QgsLayoutItemScaleBar::updateScale );
289 disconnect( mMap, &QObject::destroyed, this, &QgsLayoutItemScaleBar::disconnectCurrentMap );
290 mMap = nullptr;
291}
292
293void QgsLayoutItemScaleBar::refreshUnitsPerSegment( const QgsExpressionContext *context )
294{
296 {
297 double unitsPerSegment = mSettings.unitsPerSegment();
298 bool ok = false;
300
301 if ( !ok )
302 {
303 QgsMessageLog::logMessage( tr( "Scalebar units per segment expression eval error" ) );
304 }
305 else
306 {
308 }
309 }
310}
311
312void QgsLayoutItemScaleBar::refreshMinimumBarWidth( const QgsExpressionContext *context )
313{
315 {
316 double minimumBarWidth = mSettings.minimumBarWidth();
317
318 bool ok = false;
320
321 if ( !ok )
322 {
323 QgsMessageLog::logMessage( tr( "Scalebar minimum segment width expression eval error" ) );
324 }
325 else
326 {
328 }
329 }
330}
331
332void QgsLayoutItemScaleBar::refreshMaximumBarWidth( const QgsExpressionContext *context )
333{
335 {
336 double maximumBarWidth = mSettings.maximumBarWidth();
337
338 bool ok = false;
340
341 if ( !ok )
342 {
343 QgsMessageLog::logMessage( tr( "Scalebar maximum segment width expression eval error" ) );
344 }
345 else
346 {
348 }
349 }
350}
351
352void QgsLayoutItemScaleBar::refreshNumberOfSegmentsLeft( const QgsExpressionContext *context )
353{
355 {
356 int leftSegments = mSettings.numberOfSegmentsLeft();
357
358 bool ok = false;
359 leftSegments = mDataDefinedProperties.valueAsInt( QgsLayoutObject::ScalebarLeftSegments, *context, leftSegments, &ok );
360
361 if ( !ok )
362 {
363 QgsMessageLog::logMessage( tr( "Scalebar left segment count expression eval error" ) );
364 }
365 else
366 {
367 setNumberOfSegmentsLeft( leftSegments );
368 }
369 }
370}
371
372void QgsLayoutItemScaleBar::refreshNumberOfSegmentsRight( const QgsExpressionContext *context )
373{
375 {
376 int rightSegments = mSettings.numberOfSegments();
377
378 bool ok = false;
379 rightSegments = mDataDefinedProperties.valueAsInt( QgsLayoutObject::ScalebarRightSegments, *context, rightSegments, &ok );
380
381 if ( !ok )
382 {
383 QgsMessageLog::logMessage( tr( "Scalebar left segment count expression eval error" ) );
384 }
385 else
386 {
387 setNumberOfSegments( rightSegments );
388 }
389 }
390}
391
393{
395
396 bool forceUpdate = false;
397
398 if ( ( property == QgsLayoutObject::ScalebarHeight || property == QgsLayoutObject::AllProperties )
400 {
401 double height = mSettings.height();
402
403 bool ok = false;
405
406 if ( !ok )
407 {
408 QgsMessageLog::logMessage( tr( "Scalebar height expression eval error" ) );
409 }
410 else
411 {
412 setHeight( height );
413 }
414
415 forceUpdate = true;
416 }
417
420 {
421 double height = mSettings.subdivisionsHeight();
422
423 bool ok = false;
425
426 if ( !ok )
427 {
428 QgsMessageLog::logMessage( tr( "Scalebar subdivision height expression eval error" ) );
429 }
430 else
431 {
433 }
434
435 forceUpdate = true;
436 }
437
439 {
440 refreshNumberOfSegmentsLeft( &context );
441 forceUpdate = true;
442 }
443
445 {
446 refreshNumberOfSegmentsRight( &context );
447 forceUpdate = true;
448 }
449
452 {
453 int segments = mSettings.numberOfSubdivisions();
454
455 bool ok = false;
457
458 if ( !ok )
459 {
460 QgsMessageLog::logMessage( tr( "Scalebar number of subdivisions expression eval error" ) );
461 }
462 else
463 {
464 setNumberOfSubdivisions( segments );
465 }
466
467 forceUpdate = true;
468 }
469
470
472 {
473 refreshUnitsPerSegment( &context );
474 forceUpdate = true;
475 }
476
478 {
479 refreshMinimumBarWidth( &context );
480 forceUpdate = true;
481 }
482
484 {
485 refreshMaximumBarWidth( &context );
486 forceUpdate = true;
487 }
488
489 // updates data defined properties and redraws item to match
490 // -- Deprecated --
492 {
493 forceUpdate = true;
494 }
496 {
497 forceUpdate = true;
498 }
500 {
501 forceUpdate = true;
502 }
504 {
505 forceUpdate = true;
506 }
507
508 if ( forceUpdate )
509 {
511 update();
512 }
513
515}
516
517void QgsLayoutItemScaleBar::refreshSegmentMillimeters()
518{
519 if ( mMap )
520 {
521 //get mm dimension of composer map
522 const QRectF composerItemRect = mMap->rect();
523
524 switch ( mSettings.segmentSizeMode() )
525 {
527 {
528 //calculate size depending on mNumUnitsPerSegment
529 mSegmentMillimeters = composerItemRect.width() / mapWidth() * mSettings.unitsPerSegment();
530 break;
531 }
532
534 {
535 if ( mSettings.maximumBarWidth() < mSettings.minimumBarWidth() )
536 {
537 mSegmentMillimeters = 0;
538 }
539 else
540 {
541 const double nSegments = ( mSettings.numberOfSegmentsLeft() != 0 ) + mSettings.numberOfSegments();
542 // unitsPerSegments which fit minBarWidth resp. maxBarWidth
543 const double minUnitsPerSeg = ( mSettings.minimumBarWidth() * mapWidth() ) / ( nSegments * composerItemRect.width() );
544 const double maxUnitsPerSeg = ( mSettings.maximumBarWidth() * mapWidth() ) / ( nSegments * composerItemRect.width() );
545 mSettings.setUnitsPerSegment( QgsLayoutUtils::calculatePrettySize( minUnitsPerSeg, maxUnitsPerSeg ) );
546 mSegmentMillimeters = composerItemRect.width() / mapWidth() * mSettings.unitsPerSegment();
547 }
548 break;
549 }
550 }
551 }
552}
553
554double QgsLayoutItemScaleBar::mapWidth() const
555{
556 if ( !mMap )
557 {
558 return 0.0;
559 }
560
561 const QgsRectangle mapExtent = mMap->extent();
562 if ( mSettings.units() == QgsUnitTypes::DistanceUnknownUnit )
563 {
564 return mapExtent.width();
565 }
566 else
567 {
569 da.setSourceCrs( mMap->crs(), mLayout->project()->transformContext() );
570 da.setEllipsoid( mLayout->project()->ellipsoid() );
571
573 double measure = da.measureLine( QgsPointXY( mapExtent.xMinimum(), mapExtent.yMinimum() ),
574 QgsPointXY( mapExtent.xMaximum(), mapExtent.yMinimum() ) );
575 measure /= QgsUnitTypes::fromUnitToUnitFactor( mSettings.units(), units );
576 return measure;
577 }
578}
579
580QgsScaleBarRenderer::ScaleBarContext QgsLayoutItemScaleBar::createScaleContext() const
581{
583 scaleContext.size = rect().size();
584 scaleContext.segmentWidth = mSegmentMillimeters;
585 scaleContext.scale = mMap ? mMap->scale() : 1.0;
586 scaleContext.flags = mStyle->flags();
587 return scaleContext;
588}
589
591{
592 mSettings.setLabelVerticalPlacement( placement );
594 emit changed();
595}
596
598{
599 mSettings.setLabelHorizontalPlacement( placement );
601 emit changed();
602}
603
605{
606 mSettings.setAlignment( a );
608 emit changed();
609}
610
612{
613 mSettings.setUnits( u );
614 refreshSegmentMillimeters();
616 emit changed();
617}
618
620{
622 return mSettings.lineJoinStyle();
624}
625
626void QgsLayoutItemScaleBar::setLineJoinStyle( Qt::PenJoinStyle style )
627{
629 if ( mSettings.lineJoinStyle() == style )
630 {
631 //no change
632 return;
633 }
634 mSettings.setLineJoinStyle( style );
636 update();
637 emit changed();
638}
639
641{
643 return mSettings.lineCapStyle();
645}
646
647void QgsLayoutItemScaleBar::setLineCapStyle( Qt::PenCapStyle style )
648{
650 if ( mSettings.lineCapStyle() == style )
651 {
652 //no change
653 return;
654 }
655 mSettings.setLineCapStyle( style );
657 update();
658 emit changed();
659}
660
662{
663 //style
664 mStyle = std::make_unique< QgsSingleBoxScaleBarRenderer >();
665
666 //default to no background
667 setBackgroundEnabled( false );
668
669 //get default composer font from settings
670 const QgsSettings settings;
671 const QString defaultFontString = settings.value( QStringLiteral( "LayoutDesigner/defaultFont" ), QVariant(), QgsSettings::Gui ).toString();
672 QgsTextFormat format;
673 QFont f;
674 if ( !defaultFontString.isEmpty() )
675 {
676 f.setFamily( defaultFontString );
677 }
678 format.setFont( f );
679 format.setSize( 12.0 );
681
682 mSettings.setTextFormat( format );
683
686
687 emit changed();
688}
689
691{
692 return renderer->applyDefaultSettings( mSettings );
693}
694
696{
697 if ( !mMap )
699
700 const QgsCoordinateReferenceSystem crs = mMap->crs();
701 // start with crs units
704 {
705 // geographic CRS, use metric units
707 }
708
709 // try to pick reasonable choice between metric / imperial units
710 const double widthInSelectedUnits = mapWidth();
711 const double initialUnitsPerSegment = widthInSelectedUnits / 10.0; //default scalebar width equals half the map width
712 switch ( unit )
713 {
715 {
716 if ( initialUnitsPerSegment > 1000.0 )
717 {
719 }
720 break;
721 }
723 {
724 if ( initialUnitsPerSegment > 5419.95 )
725 {
727 }
728 break;
729 }
730 default:
731 break;
732 }
733
734 return unit;
735}
736
738{
739 mSettings.setUnits( units );
740 if ( mMap )
741 {
742 double upperMagnitudeMultiplier = 1.0;
743 const double widthInSelectedUnits = mapWidth();
744 const double initialUnitsPerSegment = widthInSelectedUnits / 10.0; //default scalebar width equals half the map width
745 mSettings.setUnitsPerSegment( initialUnitsPerSegment );
746
748 upperMagnitudeMultiplier = 1;
749
750 const double segmentWidth = initialUnitsPerSegment / upperMagnitudeMultiplier;
751 const int segmentMagnitude = std::floor( std::log10( segmentWidth ) );
752 double unitsPerSegment = upperMagnitudeMultiplier * ( std::pow( 10.0, segmentMagnitude ) );
753 const double multiplier = std::floor( ( widthInSelectedUnits / ( unitsPerSegment * 10.0 ) ) / 2.5 ) * 2.5;
754
755 if ( multiplier > 0 )
756 {
757 unitsPerSegment = unitsPerSegment * multiplier;
758 }
760 mSettings.setMapUnitsPerScaleBarUnit( upperMagnitudeMultiplier );
761
762 mSettings.setNumberOfSegments( 2 );
763 mSettings.setNumberOfSegmentsLeft( 0 );
764 }
765
766 refreshSegmentMillimeters();
768 emit changed();
769}
770
772{
773 if ( !mStyle )
774 return;
775
777 const double widthMM = mStyle->calculateBoxSize( context, mSettings, createScaleContext() ).width();
778 QgsLayoutSize currentSize = sizeWithUnits();
779 currentSize.setWidth( mLayout->renderContext().measurementConverter().convert( QgsLayoutMeasurement( widthMM, QgsUnitTypes::LayoutMillimeters ), currentSize.units() ).length() );
780 attemptResize( currentSize );
781 update();
782 emit changed();
783}
784
786{
787 //Don't adjust box size for numeric scale bars:
788 if ( mStyle && mStyle->id() != QLatin1String( "Numeric" ) )
789 {
791 }
792 QgsLayoutItem::update();
793}
794
795void QgsLayoutItemScaleBar::updateScale()
796{
797 refreshSegmentMillimeters();
798 //Don't adjust box size for numeric scale bars:
799 if ( mStyle && mStyle->id() != QLatin1String( "Numeric" ) )
800 {
802 }
803 update();
804}
805
806void QgsLayoutItemScaleBar::setStyle( const QString &styleName )
807{
808 //switch depending on style name
809 std::unique_ptr< QgsScaleBarRenderer> renderer( QgsApplication::scaleBarRendererRegistry()->renderer( styleName ) );
810 if ( renderer )
811 {
812 mStyle = std::move( renderer );
813 }
815 emit changed();
816}
817
819{
820 if ( mStyle )
821 {
822 return mStyle->id();
823 }
824 else
825 {
826 return QString();
827 }
828}
829
831{
832 return mSettings.numericFormat();
833}
834
836{
837 mSettings.setNumericFormat( format );
838}
839
841{
842 return mSettings.textFormat().font();
843}
844
845void QgsLayoutItemScaleBar::setFont( const QFont &font )
846{
848 mSettings.setFont( font );
851 emit changed();
852}
853
855{
856 QColor color = mSettings.textFormat().color();
857 color.setAlphaF( mSettings.textFormat().opacity() );
858 return color;
859}
860
861void QgsLayoutItemScaleBar::setFontColor( const QColor &color )
862{
863 mSettings.textFormat().setColor( color );
864 mSettings.textFormat().setOpacity( color.alphaF() );
865}
866
868{
870 return mSettings.fillColor();
872}
873
874void QgsLayoutItemScaleBar::setFillColor( const QColor &color )
875{
877 mSettings.setFillColor( color );
879}
880
882{
884 return mSettings.fillColor2();
886}
887
888void QgsLayoutItemScaleBar::setFillColor2( const QColor &color )
889{
891 mSettings.setFillColor2( color );
893}
894
896{
898 return mSettings.lineColor();
900}
901
902void QgsLayoutItemScaleBar::setLineColor( const QColor &color )
903{
905 mSettings.setLineColor( color );
907}
908
910{
912 return mSettings.lineWidth();
914}
915
917{
919 mSettings.setLineWidth( width );
921}
922
924{
926 return mSettings.pen();
928}
929
931{
933 return mSettings.brush();
935}
936
938{
940 return mSettings.brush2();
942}
943
944bool QgsLayoutItemScaleBar::writePropertiesToElement( QDomElement &composerScaleBarElem, QDomDocument &doc, const QgsReadWriteContext &rwContext ) const
945{
946 composerScaleBarElem.setAttribute( QStringLiteral( "height" ), QString::number( mSettings.height() ) );
947 composerScaleBarElem.setAttribute( QStringLiteral( "labelBarSpace" ), QString::number( mSettings.labelBarSpace() ) );
948 composerScaleBarElem.setAttribute( QStringLiteral( "boxContentSpace" ), QString::number( mSettings.boxContentSpace() ) );
949 composerScaleBarElem.setAttribute( QStringLiteral( "numSegments" ), mSettings.numberOfSegments() );
950 composerScaleBarElem.setAttribute( QStringLiteral( "numSegmentsLeft" ), mSettings.numberOfSegmentsLeft() );
951 composerScaleBarElem.setAttribute( QStringLiteral( "numSubdivisions" ), mSettings.numberOfSubdivisions() );
952 composerScaleBarElem.setAttribute( QStringLiteral( "subdivisionsHeight" ), mSettings.subdivisionsHeight() );
953 composerScaleBarElem.setAttribute( QStringLiteral( "numUnitsPerSegment" ), QString::number( mSettings.unitsPerSegment() ) );
954 composerScaleBarElem.setAttribute( QStringLiteral( "segmentSizeMode" ), mSettings.segmentSizeMode() );
955 composerScaleBarElem.setAttribute( QStringLiteral( "minBarWidth" ), mSettings.minimumBarWidth() );
956 composerScaleBarElem.setAttribute( QStringLiteral( "maxBarWidth" ), mSettings.maximumBarWidth() );
957 composerScaleBarElem.setAttribute( QStringLiteral( "segmentMillimeters" ), QString::number( mSegmentMillimeters ) );
958 composerScaleBarElem.setAttribute( QStringLiteral( "numMapUnitsPerScaleBarUnit" ), QString::number( mSettings.mapUnitsPerScaleBarUnit() ) );
959
960 const QDomElement textElem = mSettings.textFormat().writeXml( doc, rwContext );
961 composerScaleBarElem.appendChild( textElem );
962
964 // kept just for allowing projects to open in QGIS < 3.14, remove for 4.0
965 composerScaleBarElem.setAttribute( QStringLiteral( "outlineWidth" ), QString::number( mSettings.lineWidth() ) );
966 composerScaleBarElem.setAttribute( QStringLiteral( "lineJoinStyle" ), QgsSymbolLayerUtils::encodePenJoinStyle( mSettings.lineJoinStyle() ) );
967 composerScaleBarElem.setAttribute( QStringLiteral( "lineCapStyle" ), QgsSymbolLayerUtils::encodePenCapStyle( mSettings.lineCapStyle() ) );
968 //pen color
969 QDomElement strokeColorElem = doc.createElement( QStringLiteral( "strokeColor" ) );
970 strokeColorElem.setAttribute( QStringLiteral( "red" ), QString::number( mSettings.lineColor().red() ) );
971 strokeColorElem.setAttribute( QStringLiteral( "green" ), QString::number( mSettings.lineColor().green() ) );
972 strokeColorElem.setAttribute( QStringLiteral( "blue" ), QString::number( mSettings.lineColor().blue() ) );
973 strokeColorElem.setAttribute( QStringLiteral( "alpha" ), QString::number( mSettings.lineColor().alpha() ) );
974 composerScaleBarElem.appendChild( strokeColorElem );
976
977 composerScaleBarElem.setAttribute( QStringLiteral( "unitLabel" ), mSettings.unitLabel() );
978 composerScaleBarElem.setAttribute( QStringLiteral( "unitType" ), QgsUnitTypes::encodeUnit( mSettings.units() ) );
979
980 QDomElement numericFormatElem = doc.createElement( QStringLiteral( "numericFormat" ) );
981 mSettings.numericFormat()->writeXml( numericFormatElem, doc, rwContext );
982 composerScaleBarElem.appendChild( numericFormatElem );
983
984 //style
985 if ( mStyle )
986 {
987 composerScaleBarElem.setAttribute( QStringLiteral( "style" ), mStyle->id() );
988 }
989
990 //map id
991 if ( mMap )
992 {
993 composerScaleBarElem.setAttribute( QStringLiteral( "mapUuid" ), mMap->uuid() );
994 }
995
996 //colors
997
999 // kept just for allowing projects to open in QGIS < 3.14, remove for 4.0
1000
1001 //fill color
1002 QDomElement fillColorElem = doc.createElement( QStringLiteral( "fillColor" ) );
1003 fillColorElem.setAttribute( QStringLiteral( "red" ), QString::number( mSettings.fillColor().red() ) );
1004 fillColorElem.setAttribute( QStringLiteral( "green" ), QString::number( mSettings.fillColor().green() ) );
1005 fillColorElem.setAttribute( QStringLiteral( "blue" ), QString::number( mSettings.fillColor().blue() ) );
1006 fillColorElem.setAttribute( QStringLiteral( "alpha" ), QString::number( mSettings.fillColor().alpha() ) );
1007 composerScaleBarElem.appendChild( fillColorElem );
1008
1009 //fill color 2
1010 QDomElement fillColor2Elem = doc.createElement( QStringLiteral( "fillColor2" ) );
1011 fillColor2Elem.setAttribute( QStringLiteral( "red" ), QString::number( mSettings.fillColor2().red() ) );
1012 fillColor2Elem.setAttribute( QStringLiteral( "green" ), QString::number( mSettings.fillColor2().green() ) );
1013 fillColor2Elem.setAttribute( QStringLiteral( "blue" ), QString::number( mSettings.fillColor2().blue() ) );
1014 fillColor2Elem.setAttribute( QStringLiteral( "alpha" ), QString::number( mSettings.fillColor2().alpha() ) );
1015 composerScaleBarElem.appendChild( fillColor2Elem );
1016
1018
1019 //label vertical/horizontal placement
1020 composerScaleBarElem.setAttribute( QStringLiteral( "labelVerticalPlacement" ), QString::number( static_cast< int >( mSettings.labelVerticalPlacement() ) ) );
1021 composerScaleBarElem.setAttribute( QStringLiteral( "labelHorizontalPlacement" ), QString::number( static_cast< int >( mSettings.labelHorizontalPlacement() ) ) );
1022
1023 //alignment
1024 composerScaleBarElem.setAttribute( QStringLiteral( "alignment" ), QString::number( static_cast< int >( mSettings.alignment() ) ) );
1025
1026 QDomElement lineSymbol = doc.createElement( QStringLiteral( "lineSymbol" ) );
1027 const QDomElement symbolElem = QgsSymbolLayerUtils::saveSymbol( QString(),
1028 mSettings.lineSymbol(),
1029 doc,
1030 rwContext );
1031 lineSymbol.appendChild( symbolElem );
1032 composerScaleBarElem.appendChild( lineSymbol );
1033
1034 QDomElement divisionSymbol = doc.createElement( QStringLiteral( "divisionLineSymbol" ) );
1035 const QDomElement divisionSymbolElem = QgsSymbolLayerUtils::saveSymbol( QString(),
1036 mSettings.divisionLineSymbol(),
1037 doc,
1038 rwContext );
1039 divisionSymbol.appendChild( divisionSymbolElem );
1040 composerScaleBarElem.appendChild( divisionSymbol );
1041
1042 QDomElement subdivisionSymbol = doc.createElement( QStringLiteral( "subdivisionLineSymbol" ) );
1043 const QDomElement subdivisionSymbolElem = QgsSymbolLayerUtils::saveSymbol( QString(),
1044 mSettings.subdivisionLineSymbol(),
1045 doc,
1046 rwContext );
1047 subdivisionSymbol.appendChild( subdivisionSymbolElem );
1048 composerScaleBarElem.appendChild( subdivisionSymbol );
1049
1050 QDomElement fillSymbol1Elem = doc.createElement( QStringLiteral( "fillSymbol1" ) );
1051 const QDomElement symbol1Elem = QgsSymbolLayerUtils::saveSymbol( QString(),
1052 mSettings.fillSymbol(),
1053 doc,
1054 rwContext );
1055 fillSymbol1Elem.appendChild( symbol1Elem );
1056 composerScaleBarElem.appendChild( fillSymbol1Elem );
1057
1058 QDomElement fillSymbol2Elem = doc.createElement( QStringLiteral( "fillSymbol2" ) );
1059 const QDomElement symbol2Elem = QgsSymbolLayerUtils::saveSymbol( QString(),
1060 mSettings.alternateFillSymbol(),
1061 doc,
1062 rwContext );
1063 fillSymbol2Elem.appendChild( symbol2Elem );
1064 composerScaleBarElem.appendChild( fillSymbol2Elem );
1065
1066 return true;
1067}
1068
1069
1070bool QgsLayoutItemScaleBar::readPropertiesFromElement( const QDomElement &itemElem, const QDomDocument &, const QgsReadWriteContext &context )
1071{
1072 mSettings.setHeight( itemElem.attribute( QStringLiteral( "height" ), QStringLiteral( "5.0" ) ).toDouble() );
1073 mSettings.setLabelBarSpace( itemElem.attribute( QStringLiteral( "labelBarSpace" ), QStringLiteral( "3.0" ) ).toDouble() );
1074 mSettings.setBoxContentSpace( itemElem.attribute( QStringLiteral( "boxContentSpace" ), QStringLiteral( "1.0" ) ).toDouble() );
1075 mSettings.setNumberOfSegments( itemElem.attribute( QStringLiteral( "numSegments" ), QStringLiteral( "2" ) ).toInt() );
1076 mSettings.setNumberOfSegmentsLeft( itemElem.attribute( QStringLiteral( "numSegmentsLeft" ), QStringLiteral( "0" ) ).toInt() );
1077 mSettings.setNumberOfSubdivisions( itemElem.attribute( QStringLiteral( "numSubdivisions" ), QStringLiteral( "1" ) ).toInt() );
1078 mSettings.setSubdivisionsHeight( itemElem.attribute( QStringLiteral( "subdivisionsHeight" ), QStringLiteral( "1.5" ) ).toDouble() );
1079 mSettings.setUnitsPerSegment( itemElem.attribute( QStringLiteral( "numUnitsPerSegment" ), QStringLiteral( "1.0" ) ).toDouble() );
1080 mSettings.setSegmentSizeMode( static_cast<QgsScaleBarSettings::SegmentSizeMode>( itemElem.attribute( QStringLiteral( "segmentSizeMode" ), QStringLiteral( "0" ) ).toInt() ) );
1081 mSettings.setMinimumBarWidth( itemElem.attribute( QStringLiteral( "minBarWidth" ), QStringLiteral( "50" ) ).toDouble() );
1082 mSettings.setMaximumBarWidth( itemElem.attribute( QStringLiteral( "maxBarWidth" ), QStringLiteral( "150" ) ).toDouble() );
1083 mSegmentMillimeters = itemElem.attribute( QStringLiteral( "segmentMillimeters" ), QStringLiteral( "0.0" ) ).toDouble();
1084 mSettings.setMapUnitsPerScaleBarUnit( itemElem.attribute( QStringLiteral( "numMapUnitsPerScaleBarUnit" ), QStringLiteral( "1.0" ) ).toDouble() );
1085
1086 const QDomElement lineSymbolElem = itemElem.firstChildElement( QStringLiteral( "lineSymbol" ) );
1087 bool foundLineSymbol = false;
1088 if ( !lineSymbolElem.isNull() )
1089 {
1090 const QDomElement symbolElem = lineSymbolElem.firstChildElement( QStringLiteral( "symbol" ) );
1091 std::unique_ptr< QgsLineSymbol > lineSymbol( QgsSymbolLayerUtils::loadSymbol<QgsLineSymbol>( symbolElem, context ) );
1092 if ( lineSymbol )
1093 {
1094 mSettings.setLineSymbol( lineSymbol.release() );
1095 foundLineSymbol = true;
1096 }
1097 }
1098 const QDomElement divisionSymbolElem = itemElem.firstChildElement( QStringLiteral( "divisionLineSymbol" ) );
1099 if ( !divisionSymbolElem.isNull() )
1100 {
1101 const QDomElement symbolElem = divisionSymbolElem.firstChildElement( QStringLiteral( "symbol" ) );
1102 std::unique_ptr< QgsLineSymbol > lineSymbol( QgsSymbolLayerUtils::loadSymbol<QgsLineSymbol>( symbolElem, context ) );
1103 if ( lineSymbol )
1104 {
1105 mSettings.setDivisionLineSymbol( lineSymbol.release() );
1106 }
1107 }
1108 else if ( foundLineSymbol )
1109 {
1110 mSettings.setDivisionLineSymbol( mSettings.lineSymbol()->clone() );
1111 }
1112 const QDomElement subdivisionSymbolElem = itemElem.firstChildElement( QStringLiteral( "subdivisionLineSymbol" ) );
1113 if ( !subdivisionSymbolElem.isNull() )
1114 {
1115 const QDomElement symbolElem = subdivisionSymbolElem.firstChildElement( QStringLiteral( "symbol" ) );
1116 std::unique_ptr< QgsLineSymbol > lineSymbol( QgsSymbolLayerUtils::loadSymbol<QgsLineSymbol>( symbolElem, context ) );
1117 if ( lineSymbol )
1118 {
1119 mSettings.setSubdivisionLineSymbol( lineSymbol.release() );
1120 }
1121 }
1122 else if ( foundLineSymbol )
1123 {
1124 mSettings.setSubdivisionLineSymbol( mSettings.lineSymbol()->clone() );
1125 }
1126
1127 if ( !foundLineSymbol )
1128 {
1129 // old project compatibility
1130 std::unique_ptr< QgsLineSymbol > lineSymbol = std::make_unique< QgsLineSymbol >();
1131 std::unique_ptr< QgsSimpleLineSymbolLayer > lineSymbolLayer = std::make_unique< QgsSimpleLineSymbolLayer >();
1132 lineSymbolLayer->setWidth( itemElem.attribute( QStringLiteral( "outlineWidth" ), QStringLiteral( "0.3" ) ).toDouble() );
1133 lineSymbolLayer->setWidthUnit( QgsUnitTypes::RenderMillimeters );
1134 lineSymbolLayer->setPenJoinStyle( QgsSymbolLayerUtils::decodePenJoinStyle( itemElem.attribute( QStringLiteral( "lineJoinStyle" ), QStringLiteral( "miter" ) ) ) );
1135 lineSymbolLayer->setPenCapStyle( QgsSymbolLayerUtils::decodePenCapStyle( itemElem.attribute( QStringLiteral( "lineCapStyle" ), QStringLiteral( "square" ) ) ) );
1136
1137 //stroke color
1138 const QDomNodeList strokeColorList = itemElem.elementsByTagName( QStringLiteral( "strokeColor" ) );
1139 if ( !strokeColorList.isEmpty() )
1140 {
1141 const QDomElement strokeColorElem = strokeColorList.at( 0 ).toElement();
1142 bool redOk, greenOk, blueOk, alphaOk;
1143 int strokeRed, strokeGreen, strokeBlue, strokeAlpha;
1144
1145 strokeRed = strokeColorElem.attribute( QStringLiteral( "red" ) ).toDouble( &redOk );
1146 strokeGreen = strokeColorElem.attribute( QStringLiteral( "green" ) ).toDouble( &greenOk );
1147 strokeBlue = strokeColorElem.attribute( QStringLiteral( "blue" ) ).toDouble( &blueOk );
1148 strokeAlpha = strokeColorElem.attribute( QStringLiteral( "alpha" ) ).toDouble( &alphaOk );
1149
1150 if ( redOk && greenOk && blueOk && alphaOk )
1151 {
1152 lineSymbolLayer->setColor( QColor( strokeRed, strokeGreen, strokeBlue, strokeAlpha ) );
1153 }
1154 }
1155 else
1156 {
1157 lineSymbolLayer->setColor( QColor( itemElem.attribute( QStringLiteral( "penColor" ), QStringLiteral( "#000000" ) ) ) );
1158 }
1159
1160 // need to translate the deprecated ScalebarLineWidth and ScalebarLineColor properties to symbol properties,
1161 // and then remove them from the scalebar so they don't interfere and apply to other compatibility workarounds
1162 lineSymbolLayer->setDataDefinedProperty( QgsSymbolLayer::PropertyStrokeWidth, dataDefinedProperties().property( QgsLayoutObject::ScalebarLineWidth ) );
1164 lineSymbolLayer->setDataDefinedProperty( QgsSymbolLayer::PropertyStrokeColor, dataDefinedProperties().property( QgsLayoutObject::ScalebarLineColor ) );
1166
1167 lineSymbol->changeSymbolLayer( 0, lineSymbolLayer.release() );
1168 mSettings.setLineSymbol( lineSymbol->clone() );
1169 mSettings.setDivisionLineSymbol( lineSymbol->clone() );
1170 mSettings.setSubdivisionLineSymbol( lineSymbol.release() );
1171 }
1172
1173 mSettings.setUnitLabel( itemElem.attribute( QStringLiteral( "unitLabel" ) ) );
1174
1175 const QDomNodeList textFormatNodeList = itemElem.elementsByTagName( QStringLiteral( "text-style" ) );
1176 if ( !textFormatNodeList.isEmpty() )
1177 {
1178 const QDomElement textFormatElem = textFormatNodeList.at( 0 ).toElement();
1179 mSettings.textFormat().readXml( textFormatElem, context );
1180 }
1181 else
1182 {
1183 QFont f;
1184 if ( !QgsFontUtils::setFromXmlChildNode( f, itemElem, QStringLiteral( "scaleBarFont" ) ) )
1185 {
1186 f.fromString( itemElem.attribute( QStringLiteral( "font" ), QString() ) );
1187 }
1188 mSettings.textFormat().setFont( f );
1189 if ( f.pointSizeF() > 0 )
1190 {
1191 mSettings.textFormat().setSize( f.pointSizeF() );
1193 }
1194 else if ( f.pixelSize() > 0 )
1195 {
1196 mSettings.textFormat().setSize( f.pixelSize() );
1198 }
1199 }
1200
1201 const QDomNodeList numericFormatNodeList = itemElem.elementsByTagName( QStringLiteral( "numericFormat" ) );
1202 if ( !numericFormatNodeList.isEmpty() )
1203 {
1204 const QDomElement numericFormatElem = numericFormatNodeList.at( 0 ).toElement();
1205 mSettings.setNumericFormat( QgsApplication::numericFormatRegistry()->createFromXml( numericFormatElem, context ) );
1206 }
1207
1208 const QDomElement fillSymbol1Elem = itemElem.firstChildElement( QStringLiteral( "fillSymbol1" ) );
1209 bool foundFillSymbol1 = false;
1210 if ( !fillSymbol1Elem.isNull() )
1211 {
1212 const QDomElement symbolElem = fillSymbol1Elem.firstChildElement( QStringLiteral( "symbol" ) );
1213 std::unique_ptr< QgsFillSymbol > fillSymbol( QgsSymbolLayerUtils::loadSymbol<QgsFillSymbol>( symbolElem, context ) );
1214 if ( fillSymbol )
1215 {
1216 mSettings.setFillSymbol( fillSymbol.release() );
1217 foundFillSymbol1 = true;
1218 }
1219 }
1220 if ( !foundFillSymbol1 )
1221 {
1222 // old project compatibility
1223 std::unique_ptr< QgsFillSymbol > fillSymbol = std::make_unique< QgsFillSymbol >();
1224 std::unique_ptr< QgsSimpleFillSymbolLayer > fillSymbolLayer = std::make_unique< QgsSimpleFillSymbolLayer >();
1225 fillSymbolLayer->setStrokeStyle( Qt::NoPen );
1226
1227 //fill color
1228 const QDomNodeList fillColorList = itemElem.elementsByTagName( QStringLiteral( "fillColor" ) );
1229 if ( !fillColorList.isEmpty() )
1230 {
1231 const QDomElement fillColorElem = fillColorList.at( 0 ).toElement();
1232 bool redOk, greenOk, blueOk, alphaOk;
1233 int fillRed, fillGreen, fillBlue, fillAlpha;
1234
1235 fillRed = fillColorElem.attribute( QStringLiteral( "red" ) ).toDouble( &redOk );
1236 fillGreen = fillColorElem.attribute( QStringLiteral( "green" ) ).toDouble( &greenOk );
1237 fillBlue = fillColorElem.attribute( QStringLiteral( "blue" ) ).toDouble( &blueOk );
1238 fillAlpha = fillColorElem.attribute( QStringLiteral( "alpha" ) ).toDouble( &alphaOk );
1239
1240 if ( redOk && greenOk && blueOk && alphaOk )
1241 {
1242 fillSymbolLayer->setColor( QColor( fillRed, fillGreen, fillBlue, fillAlpha ) );
1243 }
1244 }
1245 else
1246 {
1247 fillSymbolLayer->setColor( QColor( itemElem.attribute( QStringLiteral( "brushColor" ), QStringLiteral( "#000000" ) ) ) );
1248 }
1249
1250 // need to translate the deprecated ScalebarFillColor property to symbol properties,
1251 // and then remove them from the scalebar so they don't interfere and apply to other compatibility workarounds
1252 fillSymbolLayer->setDataDefinedProperty( QgsSymbolLayer::PropertyFillColor, dataDefinedProperties().property( QgsLayoutObject::ScalebarFillColor ) );
1254
1255 fillSymbol->changeSymbolLayer( 0, fillSymbolLayer.release() );
1256 mSettings.setFillSymbol( fillSymbol.release() );
1257 }
1258
1259 const QDomElement fillSymbol2Elem = itemElem.firstChildElement( QStringLiteral( "fillSymbol2" ) );
1260 bool foundFillSymbol2 = false;
1261 if ( !fillSymbol2Elem.isNull() )
1262 {
1263 const QDomElement symbolElem = fillSymbol2Elem.firstChildElement( QStringLiteral( "symbol" ) );
1264 std::unique_ptr< QgsFillSymbol > fillSymbol( QgsSymbolLayerUtils::loadSymbol<QgsFillSymbol>( symbolElem, context ) );
1265 if ( fillSymbol )
1266 {
1267 mSettings.setAlternateFillSymbol( fillSymbol.release() );
1268 foundFillSymbol2 = true;
1269 }
1270 }
1271 if ( !foundFillSymbol2 )
1272 {
1273 // old project compatibility
1274 std::unique_ptr< QgsFillSymbol > fillSymbol = std::make_unique< QgsFillSymbol >();
1275 std::unique_ptr< QgsSimpleFillSymbolLayer > fillSymbolLayer = std::make_unique< QgsSimpleFillSymbolLayer >();
1276 fillSymbolLayer->setStrokeStyle( Qt::NoPen );
1277
1278 //fill color 2
1279
1280 const QDomNodeList fillColor2List = itemElem.elementsByTagName( QStringLiteral( "fillColor2" ) );
1281 if ( !fillColor2List.isEmpty() )
1282 {
1283 const QDomElement fillColor2Elem = fillColor2List.at( 0 ).toElement();
1284 bool redOk, greenOk, blueOk, alphaOk;
1285 int fillRed, fillGreen, fillBlue, fillAlpha;
1286
1287 fillRed = fillColor2Elem.attribute( QStringLiteral( "red" ) ).toDouble( &redOk );
1288 fillGreen = fillColor2Elem.attribute( QStringLiteral( "green" ) ).toDouble( &greenOk );
1289 fillBlue = fillColor2Elem.attribute( QStringLiteral( "blue" ) ).toDouble( &blueOk );
1290 fillAlpha = fillColor2Elem.attribute( QStringLiteral( "alpha" ) ).toDouble( &alphaOk );
1291
1292 if ( redOk && greenOk && blueOk && alphaOk )
1293 {
1294 fillSymbolLayer->setColor( QColor( fillRed, fillGreen, fillBlue, fillAlpha ) );
1295 }
1296 }
1297 else
1298 {
1299 fillSymbolLayer->setColor( QColor( itemElem.attribute( QStringLiteral( "brush2Color" ), QStringLiteral( "#ffffff" ) ) ) );
1300 }
1301
1302 // need to translate the deprecated ScalebarFillColor2 property to symbol properties,
1303 // and then remove them from the scalebar so they don't interfere and apply to other compatibility workarounds
1304 fillSymbolLayer->setDataDefinedProperty( QgsSymbolLayer::PropertyFillColor, dataDefinedProperties().property( QgsLayoutObject::ScalebarFillColor2 ) );
1306
1307 fillSymbol->changeSymbolLayer( 0, fillSymbolLayer.release() );
1308 mSettings.setAlternateFillSymbol( fillSymbol.release() );
1309
1310 }
1311
1312 //font color
1313 const QDomNodeList textColorList = itemElem.elementsByTagName( QStringLiteral( "textColor" ) );
1314 if ( !textColorList.isEmpty() )
1315 {
1316 const QDomElement textColorElem = textColorList.at( 0 ).toElement();
1317 bool redOk, greenOk, blueOk, alphaOk;
1318 int textRed, textGreen, textBlue, textAlpha;
1319
1320 textRed = textColorElem.attribute( QStringLiteral( "red" ) ).toDouble( &redOk );
1321 textGreen = textColorElem.attribute( QStringLiteral( "green" ) ).toDouble( &greenOk );
1322 textBlue = textColorElem.attribute( QStringLiteral( "blue" ) ).toDouble( &blueOk );
1323 textAlpha = textColorElem.attribute( QStringLiteral( "alpha" ) ).toDouble( &alphaOk );
1324
1325 if ( redOk && greenOk && blueOk && alphaOk )
1326 {
1327 mSettings.textFormat().setColor( QColor( textRed, textGreen, textBlue, textAlpha ) );
1328 }
1329 }
1330 else if ( itemElem.hasAttribute( QStringLiteral( "fontColor" ) ) )
1331 {
1332 QColor c;
1333 c.setNamedColor( itemElem.attribute( QStringLiteral( "fontColor" ), QStringLiteral( "#000000" ) ) );
1334 mSettings.textFormat().setColor( c );
1335 }
1336
1337 //style
1338 setStyle( itemElem.attribute( QStringLiteral( "style" ), QString() ) );
1339
1340 //call attemptResize after setStyle to ensure the appropriate size limitations are applied
1341 attemptResize( QgsLayoutSize::decodeSize( itemElem.attribute( QStringLiteral( "size" ) ) ) );
1342
1343 if ( itemElem.attribute( QStringLiteral( "unitType" ) ).isEmpty() )
1344 {
1346 switch ( itemElem.attribute( QStringLiteral( "units" ) ).toInt() )
1347 {
1348 case 0:
1350 break;
1351 case 1:
1353 break;
1354 case 2:
1356 break;
1357 case 3:
1359 break;
1360 }
1361 mSettings.setUnits( u );
1362 }
1363 else
1364 {
1365 mSettings.setUnits( QgsUnitTypes::decodeDistanceUnit( itemElem.attribute( QStringLiteral( "unitType" ) ) ) );
1366 }
1367
1368 mSettings.setLabelVerticalPlacement( static_cast< QgsScaleBarSettings::LabelVerticalPlacement >( itemElem.attribute( QStringLiteral( "labelVerticalPlacement" ), QStringLiteral( "0" ) ).toInt() ) );
1369 mSettings.setLabelHorizontalPlacement( static_cast< QgsScaleBarSettings::LabelHorizontalPlacement >( itemElem.attribute( QStringLiteral( "labelHorizontalPlacement" ), QStringLiteral( "0" ) ).toInt() ) );
1370
1371 mSettings.setAlignment( static_cast< QgsScaleBarSettings::Alignment >( itemElem.attribute( QStringLiteral( "alignment" ), QStringLiteral( "0" ) ).toInt() ) );
1372
1373 //map
1374 disconnectCurrentMap();
1375 mMap = nullptr;
1376 mMapUuid = itemElem.attribute( QStringLiteral( "mapUuid" ) );
1377 return true;
1378}
1379
1380
1382{
1383 if ( mLayout && !mMapUuid.isEmpty() )
1384 {
1385 disconnectCurrentMap();
1386 mMap = qobject_cast< QgsLayoutItemMap * >( mLayout->itemByUuid( mMapUuid, true ) );
1387 if ( mMap )
1388 {
1389 connect( mMap, &QgsLayoutItemMap::extentChanged, this, &QgsLayoutItemScaleBar::updateScale );
1390 connect( mMap, &QObject::destroyed, this, &QgsLayoutItemScaleBar::disconnectCurrentMap );
1391 }
1392 }
1393
1394 updateScale();
1395}
1396
1398{
1399 QgsStyleTextFormatEntity entity( mSettings.textFormat() );
1400 if ( !visitor->visit( QgsStyleEntityVisitorInterface::StyleLeaf( &entity, uuid(), displayName() ) ) )
1401 return false;
1402
1403 return true;
1404}
1405
1407{
1409}
QColor valueAsColor(int key, const QgsExpressionContext &context, const QColor &defaultColor=QColor(), bool *ok=nullptr) const
Calculates the current value of the property with the specified key and interprets it as a color.
int valueAsInt(int key, const QgsExpressionContext &context, int defaultValue=0, bool *ok=nullptr) const
Calculates the current value of the property with the specified key and interprets it as an integer.
double valueAsDouble(int key, const QgsExpressionContext &context, double defaultValue=0.0, bool *ok=nullptr) const
Calculates the current value of the property with the specified key and interprets it as a double.
static QgsScaleBarRendererRegistry * scaleBarRendererRegistry()
Gets the registry of available scalebar renderers.
static QgsNumericFormatRegistry * numericFormatRegistry()
Gets the registry of available numeric formats.
static QIcon getThemeIcon(const QString &name, const QColor &fillColor=QColor(), const QColor &strokeColor=QColor())
Helper to get a theme icon.
This class represents a coordinate reference system (CRS).
Q_GADGET QgsUnitTypes::DistanceUnit mapUnits
A general purpose distance and area calculator, capable of performing ellipsoid based calculations.
double measureLine(const QVector< QgsPointXY > &points) const
Measures the length of a line with multiple segments.
void setSourceCrs(const QgsCoordinateReferenceSystem &crs, const QgsCoordinateTransformContext &context)
Sets source spatial reference system crs.
bool setEllipsoid(const QString &ellipsoid)
Sets the ellipsoid by its acronym.
QgsUnitTypes::DistanceUnit lengthUnits() const
Returns the units of distance for length calculations made by this object.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
A fill symbol type, for rendering Polygon and MultiPolygon geometries.
Definition: qgsfillsymbol.h:30
QgsFillSymbol * clone() const override
Returns a deep copy of this symbol.
static bool setFromXmlChildNode(QFont &font, const QDomElement &element, const QString &childNode)
Sets the properties of a font to match the properties stored in an XML child node.
Layout graphical items for displaying a map.
void extentChanged()
Emitted when the map's extent changes.
double scale() const
Returns the map scale.
QgsRectangle extent() const
Returns the current map extent.
QgsCoordinateReferenceSystem crs() const
Returns coordinate reference system used for rendering the map.
@ LayoutScaleBar
Scale bar item.
Contains settings and helpers relating to a render of a QgsLayoutItem.
Definition: qgslayoutitem.h:45
QgsRenderContext & renderContext()
Returns a reference to the context's render context.
Definition: qgslayoutitem.h:72
A layout item subclass for scale bars.
void setNumberOfSegments(int segments)
Sets the number of segments included in the scalebar.
Q_DECL_DEPRECATED QBrush brush() const
Returns the primary brush for the scalebar.
Q_DECL_DEPRECATED QColor fillColor2() const
Returns the secondary color used for fills in the scalebar.
Q_DECL_DEPRECATED double lineWidth() const
Returns the line width in millimeters for lines in the scalebar.
QIcon icon() const override
Returns the item's icon.
Q_DECL_DEPRECATED void setFillColor(const QColor &color)
Sets the color used for fills in the scalebar.
void setLabelHorizontalPlacement(QgsScaleBarSettings::LabelHorizontalPlacement placement)
Sets the horizontal placement of text labels.
QgsLineSymbol * divisionLineSymbol() const
Returns the line symbol used to render the scalebar divisions (only used for some scalebar types).
QgsFillSymbol * alternateFillSymbol() const
Returns the secondary fill symbol used to render the scalebar (only used for some scalebar types).
Q_DECL_DEPRECATED QBrush brush2() const
Returns the secondary brush for the scalebar.
double height() const
Returns the scalebar height (in millimeters).
void setMinimumBarWidth(double minWidth)
Sets the minimum width (in millimeters) for scale bar segments.
QgsFillSymbol * fillSymbol() const
Returns the primary fill symbol used to render the scalebar (only used for some scalebar types).
void draw(QgsLayoutItemRenderContext &context) override
Draws the item's contents using the specified item render context.
Q_DECL_DEPRECATED QColor fontColor() const
Returns the color used for drawing text in the scalebar.
void setMaximumBarWidth(double maxWidth)
Sets the maximum width (in millimeters) for scale bar segments.
Q_DECL_DEPRECATED QColor fillColor() const
Returns the color used for fills in the scalebar.
void setSegmentSizeMode(QgsScaleBarSettings::SegmentSizeMode mode)
Sets the size mode for scale bar segments.
void setNumericFormat(QgsNumericFormat *format)
Sets the numeric format used for numbers in the scalebar.
Q_DECL_DEPRECATED void setLineColor(const QColor &color)
Sets the color used for lines in the scalebar.
void setDivisionLineSymbol(QgsLineSymbol *symbol)
Sets the line symbol used to render the scalebar divisions (only used for some scalebar types).
Q_DECL_DEPRECATED QColor lineColor() const
Returns the color used for lines in the scalebar.
bool accept(QgsStyleEntityVisitorInterface *visitor) const override
Accepts the specified style entity visitor, causing it to visit all style entities associated with th...
void update()
Adjusts the scale bar box size and updates the item.
void setFillSymbol(QgsFillSymbol *symbol)
Sets the primary fill symbol used to render the scalebar (only used for some scalebar types).
void setLabelVerticalPlacement(QgsScaleBarSettings::LabelVerticalPlacement placement)
Sets the vertical placement of text labels.
double unitsPerSegment() const
Returns the number of scalebar units per segment.
void finalizeRestoreFromXml() override
Called after all pending items have been restored from XML.
bool applyDefaultRendererSettings(QgsScaleBarRenderer *renderer)
Applies any default settings relating to the specified renderer to the item.
void setUnits(QgsUnitTypes::DistanceUnit units)
Sets the distance units used by the scalebar.
double minimumBarWidth() const
Returns the minimum width (in millimeters) for scale bar segments.
QgsLineSymbol * subdivisionLineSymbol() const
Returns the line symbol used to render the scalebar subdivisions (only used for some scalebar types).
QgsUnitTypes::DistanceUnit guessUnits() const
Attempts to guess the most reasonable unit choice for the scalebar, given the current linked map's sc...
Q_DECL_DEPRECATED QFont font() const
Returns the font used for drawing text in the scalebar.
bool readPropertiesFromElement(const QDomElement &element, const QDomDocument &document, const QgsReadWriteContext &context) override
Sets item state from a DOM element.
void setAlignment(QgsScaleBarSettings::Alignment alignment)
Sets the scalebar alignment.
void setAlternateFillSymbol(QgsFillSymbol *symbol)
Sets the secondary fill symbol used to render the scalebar (only used for some scalebar types).
void applyDefaultSize(QgsUnitTypes::DistanceUnit units=QgsUnitTypes::DistanceMeters)
Applies the default size to the scale bar (scale bar 1/5 of map item width)
int type() const override
void setLineSymbol(QgsLineSymbol *symbol)
Sets the line symbol used to render the scalebar (only used for some scalebar types).
void setStyle(const QString &name)
Sets the scale bar style by name.
Q_DECL_DEPRECATED void setFillColor2(const QColor &color)
Sets the secondary color used for fills in the scalebar.
void applyDefaultSettings()
Applies the default scalebar settings to the scale bar.
void setHeight(double height)
Sets the scalebar height (in millimeters).
Q_DECL_DEPRECATED Qt::PenCapStyle lineCapStyle() const
Returns the cap style used for drawing lines in the scalebar.
void setSubdivisionsHeight(double height)
Sets the scalebar subdivisions height (in millimeters) for segments included in the right part of the...
void setNumberOfSegmentsLeft(int segments)
Sets the number of segments included in the left part of the scalebar.
Q_DECL_DEPRECATED Qt::PenJoinStyle lineJoinStyle() const
Returns the join style used for drawing lines in the scalebar.
void setTextFormat(const QgsTextFormat &format)
Sets the text format used for drawing text in the scalebar.
void setLinkedMap(QgsLayoutItemMap *map)
Sets the map item linked to the scalebar.
QgsLayoutSize minimumSize() const override
Returns the minimum allowed size of the item, if applicable, or an empty size if item can be freely r...
Q_DECL_DEPRECATED void setLineJoinStyle(Qt::PenJoinStyle style)
Sets the join style used when drawing the lines in the scalebar.
QgsLineSymbol * lineSymbol() const
Returns the line symbol used to render the scalebar (only used for some scalebar types).
void refreshDataDefinedProperty(QgsLayoutObject::DataDefinedProperty property=QgsLayoutObject::AllProperties) override
Refreshes a data defined property for the item by reevaluating the property's value and redrawing the...
double maximumBarWidth() const
Returns the maximum width (in millimeters) for scale bar segments.
Q_DECL_DEPRECATED void setFontColor(const QColor &color)
Sets the color used for drawing text in the scalebar.
Q_DECL_DEPRECATED void setLineWidth(double width)
Sets the line width in millimeters for lines in the scalebar.
Q_DECL_DEPRECATED QPen pen() const
Returns the pen used for drawing outlines in the scalebar.
void setBoxContentSpace(double space)
Sets the space (margin) between the scalebar box and content in millimeters.
const QgsNumericFormat * numericFormat() const
Returns the numeric format used for numbers in the scalebar.
void setUnitLabel(const QString &label)
Sets the label for units.
QString style() const
Returns the scale bar style name.
ExportLayerBehavior exportLayerBehavior() const override
Returns the behavior of this item during exporting to layered exports (e.g.
QgsTextFormat textFormat() const
Returns the text format used for drawing text in the scalebar.
Q_DECL_DEPRECATED void setLineCapStyle(Qt::PenCapStyle style)
Sets the cap style used when drawing the lines in the scalebar.
bool writePropertiesToElement(QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context) const override
Stores item state within an XML DOM element.
void resizeToMinimumWidth()
Resizes the scale bar to its minimum width, without changing the height.
void setUnitsPerSegment(double units)
Sets the number of scalebar units per segment.
static QgsLayoutItemScaleBar * create(QgsLayout *layout)
Returns a new scale bar item for the specified layout.
Q_DECL_DEPRECATED void setFont(const QFont &font)
Sets the font used for drawing text in the scalebar.
void setSubdivisionLineSymbol(QgsLineSymbol *symbol)
Sets the line symbol used to render the scalebar subdivisions (only used for some scalebar types).
void setNumberOfSubdivisions(int subdivisions)
Sets the number of subdivisions for segments included in the right part of the scalebar (only used fo...
QgsUnitTypes::DistanceUnit units() const
Returns the distance units used by the scalebar.
QgsLayoutItemScaleBar(QgsLayout *layout)
Constructor for QgsLayoutItemScaleBar, with the specified parent layout.
Base class for graphical items within a QgsLayout.
QgsLayoutSize sizeWithUnits() const
Returns the item's current size, including units.
void refreshItemSize()
Refreshes an item's size by rechecking it against any possible item fixed or minimum sizes.
QgsExpressionContext createExpressionContext() const override
This method needs to be reimplemented in all classes which implement this interface and return an exp...
virtual QString displayName() const
Gets item display name.
virtual void attemptResize(const QgsLayoutSize &size, bool includesFrame=false)
Attempts to resize the item to a specified target size.
virtual void refreshDataDefinedProperty(QgsLayoutObject::DataDefinedProperty property=QgsLayoutObject::AllProperties)
Refreshes a data defined property for the item by reevaluating the property's value and redrawing the...
virtual QString uuid() const
Returns the item identification string.
ExportLayerBehavior
Behavior of item when exporting to layered outputs.
@ CanGroupWithItemsOfSameType
Item can only be placed on layers with other items of the same type, but multiple items of this type ...
void setBackgroundEnabled(bool drawBackground)
Sets whether this item has a background drawn under it or not.
This class provides a method of storing measurements for use in QGIS layouts using a variety of diffe...
QgsPropertyCollection mDataDefinedProperties
QgsPropertyCollection & dataDefinedProperties()
Returns a reference to the object's property collection, used for data defined overrides.
const QgsLayout * layout() const
Returns the layout the object is attached to.
void changed()
Emitted when the object's properties change.
QPointer< QgsLayout > mLayout
DataDefinedProperty
Data defined properties for different item types.
@ ScalebarMinimumWidth
Scalebar segment minimum width (since QGIS 3.26)
@ ScalebarFillColor2
Scalebar secondary fill color (deprecated, use data defined properties on scalebar fill symbol 2 inst...
@ ScalebarLineWidth
Scalebar line width (deprecated, use data defined properties on scalebar line symbol instead)
@ ScalebarSegmentWidth
Scalebar width in map units of a single segment (since QGIS 3.26)
@ AllProperties
All properties for item.
@ ScalebarFillColor
Scalebar fill color (deprecated, use data defined properties on scalebar fill symbol 1 instead)
@ ScalebarMaximumWidth
Scalebar segment maximum width (since QGIS 3.26)
@ ScalebarLineColor
Scalebar line color (deprecated, use data defined properties on scalebar line symbol instead)
@ ScalebarHeight
Scalebar height (since QGIS 3.26)
@ ScalebarRightSegments
Number of segments on the right of 0 (since QGIS 3.26)
@ ScalebarSubdivisionHeight
Scalebar subdivision height (since QGIS 3.26)
@ ScalebarRightSegmentSubdivisions
Number of subdivisions per segment on right of 0 (since QGIS 3.26)
@ ScalebarLeftSegments
Number of segments on the left of 0 (since QGIS 3.26)
This class provides a method of storing sizes, consisting of a width and height, for use in QGIS layo...
Definition: qgslayoutsize.h:41
static QgsLayoutSize decodeSize(const QString &string)
Decodes a size from a string.
QgsUnitTypes::LayoutUnit units() const
Returns the units for the size.
void setWidth(const double width)
Sets the width for the size.
Definition: qgslayoutsize.h:83
static QgsRenderContext createRenderContextForLayout(QgsLayout *layout, QPainter *painter, double dpi=-1)
Creates a render context suitable for the specified layout and painter destination.
static double calculatePrettySize(double minimumSize, double maximumSize)
Calculates a "pretty" size which falls between the range [minimumSize, maximumSize].
Base class for layouts, which can contain items such as maps, labels, scalebars, etc.
Definition: qgslayout.h:51
A line symbol type, for rendering LineString and MultiLineString geometries.
Definition: qgslinesymbol.h:30
QgsLineSymbol * clone() const override
Returns a deep copy of this symbol.
static void logMessage(const QString &message, const QString &tag=QString(), Qgis::MessageLevel level=Qgis::MessageLevel::Warning, bool notifyUser=true)
Adds a message to the log instance (and creates it if necessary).
A numeric formatter allows for formatting a numeric value for display, using a variety of different f...
void writeXml(QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context) const
Writes the format to an XML element.
A class to represent a 2D point.
Definition: qgspointxy.h:59
void setProperty(int key, const QgsProperty &property)
Adds a property to the collection and takes ownership of it.
bool isActive(int key) const override
Returns true if the collection contains an active property with the specified key.
A store for object properties.
Definition: qgsproperty.h:230
The class is used as a container of context for various read/write operations on other objects.
A rectangle specified with double values.
Definition: qgsrectangle.h:42
double xMaximum() const SIP_HOLDGIL
Returns the x maximum value (right side of rectangle).
Definition: qgsrectangle.h:183
double xMinimum() const SIP_HOLDGIL
Returns the x minimum value (left side of rectangle).
Definition: qgsrectangle.h:188
double yMinimum() const SIP_HOLDGIL
Returns the y minimum value (bottom side of rectangle).
Definition: qgsrectangle.h:198
double width() const SIP_HOLDGIL
Returns the width of the rectangle.
Definition: qgsrectangle.h:223
Contains information about the context of a rendering operation.
Abstract base class for scale bar renderers.
virtual bool applyDefaultSettings(QgsScaleBarSettings &settings) const
Applies any default settings relating to the scalebar to the passed settings object.
double subdivisionsHeight() const
Returns the scalebar subdivisions height (in millimeters) for segments included in the right part of ...
void setSubdivisionLineSymbol(QgsLineSymbol *symbol)
Sets the line symbol used to render the scalebar subdivisions (only used for some scalebar types).
Q_DECL_DEPRECATED QColor fillColor() const
Returns the color used for fills in the scalebar.
QgsLineSymbol * lineSymbol() const
Returns the line symbol used to render the scalebar (only used for some scalebar types).
void setAlignment(Alignment alignment)
Sets the scalebar alignment.
QgsLineSymbol * subdivisionLineSymbol() const
Returns the line symbol used to render the scalebar subdivisions (only used for some scalebar types).
Q_DECL_DEPRECATED QColor fillColor2() const
Returns the secondary color used for fills in the scalebar.
void setAlternateFillSymbol(QgsFillSymbol *symbol)
Sets the secondary fill symbol used to render the scalebar (only used for some scalebar types).
SegmentSizeMode segmentSizeMode() const
Returns the size mode for the scale bar segments.
const QgsNumericFormat * numericFormat() const
Returns the numeric format used for numbers in the scalebar.
Q_DECL_DEPRECATED void setFillColor(const QColor &color)
Sets the color used for fills in the scalebar.
int numberOfSegments() const
Returns the number of segments included in the scalebar.
Q_DECL_DEPRECATED void setFillColor2(const QColor &color)
Sets the secondary color used for fills in the scalebar.
double maximumBarWidth() const
Returns the maximum width (in millimeters) for scale bar segments.
Q_DECL_DEPRECATED void setLineCapStyle(Qt::PenCapStyle style)
Sets the cap style used when drawing the lines in the scalebar.
QgsUnitTypes::DistanceUnit units() const
Returns the distance units used by the scalebar.
void setFillSymbol(QgsFillSymbol *symbol)
Sets the primary fill symbol used to render the scalebar (only used for some scalebar types).
double unitsPerSegment() const
Returns the number of scalebar units per segment.
Q_DECL_DEPRECATED void setLineJoinStyle(Qt::PenJoinStyle style)
Sets the join style used when drawing the lines in the scalebar.
QgsTextFormat & textFormat()
Returns the text format used for drawing text in the scalebar.
Q_DECL_DEPRECATED QPen pen() const
Returns the pen used for drawing outlines in the scalebar.
void setLabelVerticalPlacement(LabelVerticalPlacement placement)
Sets the vertical placement of text labels.
Q_DECL_DEPRECATED void setLineColor(const QColor &color)
Sets the color used for lines in the scalebar.
void setUnitLabel(const QString &label)
Sets the label for units.
LabelHorizontalPlacement labelHorizontalPlacement() const
Returns the horizontal placement of text labels.
void setLineSymbol(QgsLineSymbol *symbol)
Sets the line symbol used to render the scalebar (only used for some scalebar types).
void setDivisionLineSymbol(QgsLineSymbol *symbol)
Sets the line symbol used to render the scalebar divisions (only used for some scalebar types).
void setBoxContentSpace(double space)
Sets the space (margin) between the scalebar box and content in millimeters.
Q_DECL_DEPRECATED void setLineWidth(double width)
Sets the line width in millimeters for lines in the scalebar.
Alignment alignment() const
Returns the scalebar alignment.
double boxContentSpace() const
Returns the spacing (margin) between the scalebar box and content in millimeters.
void setHeight(double height)
Sets the scalebar height (in millimeters).
QgsFillSymbol * alternateFillSymbol() const
Returns the secondary fill symbol used to render the scalebar (only used for some scalebar types).
void setUnits(QgsUnitTypes::DistanceUnit units)
Sets the distance units used by the scalebar.
QgsFillSymbol * fillSymbol() const
Returns the primary fill symbol used to render the scalebar (only used for some scalebar types).
Q_DECL_DEPRECATED double lineWidth() const
Returns the line width in millimeters for lines in the scalebar.
Q_DECL_DEPRECATED QBrush brush2() const
Returns the secondary brush for the scalebar.
Alignment
Scalebar alignment.
void setNumberOfSubdivisions(int subdivisions)
Sets the number of subdivisions for segments included in the right part of the scalebar (only used fo...
LabelVerticalPlacement labelVerticalPlacement() const
Returns the vertical placement of text labels.
void setNumericFormat(QgsNumericFormat *format)
Sets the numeric format used for numbers in the scalebar.
void setTextFormat(const QgsTextFormat &format)
Sets the text format used for drawing text in the scalebar.
double minimumBarWidth() const
Returns the minimum width (in millimeters) for scale bar segments.
QString unitLabel() const
Returns the label for units.
int numberOfSubdivisions() const
Returns the number of subdivisions for segments included in the right part of the scalebar (only used...
Q_DECL_DEPRECATED QColor lineColor() const
Returns the color used for lines in the scalebar.
LabelHorizontalPlacement
Label horizontal placement.
void setLabelBarSpace(double space)
Sets the spacing (in millimeters) between labels and the scalebar.
void setNumberOfSegments(int segments)
Sets the number of segments included in the scalebar.
void setUnitsPerSegment(double units)
Sets the number of scalebar units per segment.
LabelVerticalPlacement
Label vertical placement.
Q_DECL_DEPRECATED Qt::PenCapStyle lineCapStyle() const
Returns the cap style used for drawing lines in the scalebar.
void setLabelHorizontalPlacement(LabelHorizontalPlacement placement)
Sets the horizontal placement of text labels.
void setSubdivisionsHeight(double height)
Sets the scalebar subdivisions height (in millimeters) for segments included in the right part of the...
double labelBarSpace() const
Returns the spacing (in millimeters) between labels and the scalebar.
double height() const
Returns the scalebar height (in millimeters).
int numberOfSegmentsLeft() const
Returns the number of segments included in the left part of the scalebar.
Q_DECL_DEPRECATED void setFont(const QFont &font)
Sets the font used for drawing text in the scalebar.
SegmentSizeMode
Modes for setting size for scale bar segments.
@ SegmentSizeFitWidth
Scale bar segment size is calculated to fit a size range.
@ SegmentSizeFixed
Scale bar segment size is fixed to a map unit.
Q_DECL_DEPRECATED Qt::PenJoinStyle lineJoinStyle() const
Returns the join style used for drawing lines in the scalebar.
void setNumberOfSegmentsLeft(int segments)
Sets the number of segments included in the left part of the scalebar.
Q_DECL_DEPRECATED QBrush brush() const
Returns the primary brush used for filling the scalebar.
void setSegmentSizeMode(SegmentSizeMode mode)
Sets the size mode for scale bar segments.
QgsLineSymbol * divisionLineSymbol() const
Returns the line symbol used to render the scalebar divisions (only used for some scalebar types).
void setMapUnitsPerScaleBarUnit(double units)
Sets the number of map units per scale bar unit used by the scalebar.
double mapUnitsPerScaleBarUnit() const
Returns the number of map units per scale bar unit used by the scalebar.
void setMinimumBarWidth(double width)
Sets the minimum width (in millimeters) for scale bar segments.
void setMaximumBarWidth(double width)
Sets the maximum width (in millimeters) for scale bar segments.
This class is a composition of two QSettings instances:
Definition: qgssettings.h:62
QVariant value(const QString &key, const QVariant &defaultValue=QVariant(), Section section=NoSection) const
Returns the value for setting key.
An interface for classes which can visit style entity (e.g.
virtual bool visit(const QgsStyleEntityVisitorInterface::StyleLeaf &entity)
Called when the visitor will visit a style entity.
A text format entity for QgsStyle databases.
Definition: qgsstyle.h:1405
static Qt::PenJoinStyle decodePenJoinStyle(const QString &str)
static Qt::PenCapStyle decodePenCapStyle(const QString &str)
static QString encodePenCapStyle(Qt::PenCapStyle style)
static QDomElement saveSymbol(const QString &symbolName, const QgsSymbol *symbol, QDomDocument &doc, const QgsReadWriteContext &context)
Writes a symbol definition to XML.
static QString encodePenJoinStyle(Qt::PenJoinStyle style)
@ PropertyStrokeWidth
Stroke width.
@ PropertyFillColor
Fill color.
@ PropertyStrokeColor
Stroke color.
bool changeSymbolLayer(int index, QgsSymbolLayer *layer)
Deletes the current layer at the specified index and replaces it with layer.
Definition: qgssymbol.cpp:809
Container for all settings relating to text rendering.
Definition: qgstextformat.h:41
void setColor(const QColor &color)
Sets the color that text will be rendered in.
void setSize(double size)
Sets the size for rendered text.
void setFont(const QFont &font)
Sets the font used for rendering text.
void setOpacity(double opacity)
Sets the text's opacity.
void readXml(const QDomElement &elem, const QgsReadWriteContext &context)
Read settings from a DOM element.
void setSizeUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the size of rendered text.
double opacity() const
Returns the text's opacity.
QDomElement writeXml(QDomDocument &doc, const QgsReadWriteContext &context) const
Write settings into a DOM element.
QColor color() const
Returns the color that text will be rendered in.
QFont font() const
Returns the font used for rendering text.
DistanceUnit
Units of distance.
Definition: qgsunittypes.h:68
@ DistanceMeters
Meters.
Definition: qgsunittypes.h:69
@ DistanceDegrees
Degrees, for planar geographic CRS distance measurements.
Definition: qgsunittypes.h:75
@ DistanceKilometers
Kilometers.
Definition: qgsunittypes.h:70
@ DistanceMiles
Terrestrial miles.
Definition: qgsunittypes.h:74
@ DistanceUnknownUnit
Unknown distance unit.
Definition: qgsunittypes.h:78
@ DistanceFeet
Imperial feet.
Definition: qgsunittypes.h:71
@ DistanceNauticalMiles
Nautical miles.
Definition: qgsunittypes.h:72
@ LayoutMillimeters
Millimeters.
Definition: qgsunittypes.h:183
static Q_INVOKABLE QString encodeUnit(QgsUnitTypes::DistanceUnit unit)
Encodes a distance unit to a string.
static Q_INVOKABLE QgsUnitTypes::DistanceUnit decodeDistanceUnit(const QString &string, bool *ok=nullptr)
Decodes a distance unit from a string.
static Q_INVOKABLE double fromUnitToUnitFactor(QgsUnitTypes::DistanceUnit fromUnit, QgsUnitTypes::DistanceUnit toUnit)
Returns the conversion factor between the specified distance units.
static Q_INVOKABLE QString toAbbreviatedString(QgsUnitTypes::DistanceUnit unit)
Returns a translated abbreviation representing a distance unit.
@ RenderPoints
Points (e.g., for font sizes)
Definition: qgsunittypes.h:173
@ RenderPixels
Pixels.
Definition: qgsunittypes.h:171
@ RenderMillimeters
Millimeters.
Definition: qgsunittypes.h:169
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c
#define Q_NOWARN_DEPRECATED_POP
Definition: qgis.h:3499
#define Q_NOWARN_DEPRECATED_PUSH
Definition: qgis.h:3498
const QgsCoordinateReferenceSystem & crs
Contains parameters regarding scalebar calculations.
Flags flags
Scalebar renderer flags.
QSizeF size
Destination size for scalebar.
double segmentWidth
The width, in millimeters, of each individual segment drawn.
Contains information relating to the style entity currently being visited.